python - style - install pylint visual studio code

invocando pylint programáticamente

Question

Me gustaría invocar el comprobador de pylint, limitado a la parte de señalización de error, como parte de la prueba de mi unidad. así que verifiqué el script ejecutable pylint, llegué a la clase pylint.lint.Run helper y allí me perdí en una función __init__ bastante larga, que terminó con una llamada a sys.exit() .

¿Alguna vez alguien lo intentó y logró hacerlo?

El plan del sueño sería este:

if __name__ == ''__main__'':
import pylint.lint
pylint.lint.something(__file__, justerrors=True)
# now continue with unit testing

¿Alguna pista? aparte de "copiar el método __init__ y omitir sys.exit() ", quiero decir?

No necesito que las pruebas se pylint con pylint , podría ser también pyflakes u otro software: siéntase libre de sugerir alternativas. ¡Gracias!

Answer 1

Eche un vistazo a pylint/epylint.py que contiene dos formas diferentes de iniciar pylint mediante programación.

También puedes simplemente llamar:

from pylint.lint import Run
Run([''--errors-only'', ''myfile.py''])

por ejemplo.

Answer 2

En lugar de crear una clase WritableObject, podemos usar StringIO. StringIO contiene método de escritura.

import sys
try:
from io import StringIO
except:
from StringIO import StringIO
stdout = sys.stdout
sys.stdout = StringIO()
ARGS = ["-r","n", "--rcfile=rcpylint"]
r = lint.Run([''../test.py'']+ARGS, exit=False)
test = sys.stdout.getvalue()
sys.stdout.close()
sys.stdout = stdout
print (test.split(''/n''))

Fuente:

• la answer @cdarke

• La answer @ mad7777

Answer 3

Me alegro de haber encontrado esto. Utilicé algunas de las respuestas aquí y alguna iniciativa para llegar a:

# a simple class with a write method
class WritableObject:
def __init__(self):
self.content = []
def write(self, string):
self.content.append(string)
pylint_output = WritableObject()
pylint = lint.Run(args, reporter=ParseableTextReporter(pylint_output), exit=False)

Args en lo anterior es una lista de cadenas por ejemplo. ["-r", "n", "myfile.py"]

Answer 4

Otro punto de entrada para pylint es la función epylint.py_run , que implementa la intercepción stdout y stderr. Sin embargo, como se muestra en el siguiente código, pylint parece no escribir sus informes en la salida estándar:

from pylint import epylint
pylint_stdout, pylint_stderr = epylint.py_run(__file__, return_std=True)
print(pylint_stdout.getvalue()) # -> there is just the final rank, no report nor message
print(pylint_stderr.getvalue())

Ahora, encontré que pylint de API y pylint de CLI no usan los mismos parámetros predeterminados. Por lo tanto, solo tiene que proporcionar los parámetros que necesita para imprimir.

from pylint import epylint
options = ''--enable=all'' # all messages will be shown
options += ''--reports=y'' # also print the reports (ascii tables at the end)
pylint_stdout, pylint_stderr = epylint.py_run(__file__ + '' '' + options, return_std=True)
print(pylint_stdout.getvalue())
print(pylint_stderr.getvalue())

Como se describe here , pylint realizará el análisis en sí mismo y emitirá correctamente los resultados esperados en la salida estándar.

Answer 5

Tengo el mismo problema recientemente. syt tiene razón, pylint.epylint tiene varios métodos ahí. Sin embargo, todos llaman a un subproceso en el que Python se inicia de nuevo. En mi caso, esto se estaba haciendo bastante lento.

A partir de la respuesta de mcarans, y encontrando que hay una salida de bandera, hice lo siguiente

class WritableObject(object):
"dummy output stream for pylint"
def __init__(self):
self.content = []
def write(self, st):
"dummy write"
self.content.append(st)
def read(self):
"dummy read"
return self.content
def run_pylint(filename):
"run pylint on the given file"
from pylint import lint
from pylint.reporters.text import TextReporter
ARGS = ["-r","n", "--rcfile=rcpylint"] # put your own here
pylint_output = WritableObject()
lint.Run([filename]+ARGS, reporter=TextReporter(pylint_output), exit=False)
for l in pylint_output.read():
do what ever you want with l...

que es aproximadamente 3 veces más rápido en mi caso. Con esto he estado pasando por todo un proyecto, utilizando resultados completos para verificar cada archivo de origen, errores puntuales y clasificar todos los archivos de su nota.