Muchos de nuestros módulos comienzan con:

try:
    import json
except ImportError:
    from django.utils import simplejson as json  # Python 2.4 fallback.

... y es la única advertencia de Pyflakes en todo el archivo:

foo/bar.py:14: redefinition of unused 'json' from line 12

¿Cómo puedo hacer que Pyflakes ignore esto?

(Normalmente iría a leer los documentos, pero el enlace está roto. Si nadie tiene una respuesta, simplemente leeré la fuente).

Si puede usar flake8 en su lugar, que envuelve los copos de nieve y el verificador pep8, una línea que termina con

# NOQA

(en el que el espacio es significativo: 2 espacios entre el final del código y el #, uno entre este y el NOQAtexto) le indicarán al verificador que ignore cualquier error en esa línea.

Sé que esto fue cuestionado hace algún tiempo y ya está respondido.

Pero quería agregar lo que suelo usar:

try:
    import json
    assert json  # silence pyflakes
except ImportError:
    from django.utils import simplejson as json  # Python 2.4 fallback.

Sí, desafortunadamente dimod.org está abajo junto con todas las golosinas.

Al mirar el código de pyflakes, me parece que pyflakes está diseñado para que sea fácil de usar como un "verificador rápido incrustado".

Para implementar la funcionalidad de ignorar, deberá escribir una propia que llame al verificador de pyflakes.

Aquí puede encontrar una idea: http://djangosnippets.org/snippets/1762/

Tenga en cuenta que el fragmento anterior solo para los lugares de comentarios en la misma línea. Para ignorar un bloque completo, es posible que desee agregar 'pyflakes: ignore' en la cadena de documentos del bloque y en el filtro basado en node.doc.

¡Buena suerte!

Estoy usando Pocket-Lint para todo tipo de análisis de código estático. Estos son los cambios realizados en la pelusa de bolsillo para ignorar los copos de nieve: https://code.launchpad.net/~adiroiban/pocket-lint/907742/+merge/102882

Para citar el ticket de emisión de github :

Si bien la solución aún está por llegar, así es como se puede solucionar, si se está preguntando:

try:
    from unittest.runner import _WritelnDecorator
    _WritelnDecorator; # workaround for pyflakes issue #13
except ImportError:
    from unittest import _WritelnDecorator

Sustituya _unittest y _WritelnDecorator con las entidades (módulos, funciones, clases) que necesita

- deemoowoor

Aquí hay un parche de mono para pyflakes que agrega una # bypass_pyflakesopción de comentario.

bypass_pyflakes.py

#!/usr/bin/env python

from pyflakes.scripts import pyflakes
from pyflakes.checker import Checker


def report_with_bypass(self, messageClass, *args, **kwargs):
    text_lineno = args[0] - 1
    with open(self.filename, 'r') as code:
        if code.readlines()[text_lineno].find('bypass_pyflakes') >= 0:
            return
    self.messages.append(messageClass(self.filename, *args, **kwargs))

# monkey patch checker to support bypass
Checker.report = report_with_bypass

pyflakes.main()

Si guarda esto como bypass_pyflakes.py, puede invocarlo como python bypass_pyflakes.py myfile.py.

http://chase-seibert.github.com/blog/2013/01/11/bypass_pyflakes.html

También puedes importar con __import__. No es pitónico, pero pyflakes ya no te advierte. Ver documentación para__import__ .

try:
    import json
except ImportError:
    __import__('django.utils', globals(), locals(), ['json'], -1)

Creé un pequeño script de shell con algo de awkmagia para ayudarme. Con esto import typing, se excluyen todas las líneas con , from typing importo #$(este último es un comentario especial que estoy usando aquí) ( $1es el nombre del archivo del script Python):

result=$(pyflakes -- "$1" 2>&1)

# check whether there is any output
if [ "$result" ]; then

    # lines to exclude
    excl=$(awk 'BEGIN { ORS="" } /(#\$)|(import +typing)|(from +typing +import )/ { print sep NR; sep="|" }' "$1")

    # exclude lines if there are any (otherwise we get invalid regex)
    [ "$excl" ] &&
        result=$(awk "! /^[^:]+:(${excl}):/" <<< "$result")

fi

# now echo "$result" or such ...

Básicamente, anota los números de línea y crea dinámicamente una expresión regular.