Pylint: comment éviter les impressions

Le seul moyen que j'ai trouvé est de commenter la ligne:

self.reporter.display_messages(report_nodes.Section())

depuis \ pylint \ lint.py

Vous pouvez facilement utiliser la sortie stdout capture pour une commande donnée, pour supprimer la sortie imprimée

import pylint.lint
filename = "server.py"
options = [
    filename,
    "--output-format=json"
]

import contextlib
@contextlib.contextmanager
def capture():
    import sys
    from io import StringIO
    oldout,olderr = sys.stdout, sys.stderr
    try:
        out=[StringIO(), StringIO()]
        sys.stdout,sys.stderr = out
        yield out
    finally:
        sys.stdout,sys.stderr = oldout, olderr
        out[0] = out[0].getvalue()
        out[1] = out[1].getvalue()

with capture() as out:
    results = pylint.lint.Run(options, do_exit=False)
messages = results.linter.reporter.messages

Vous pouvez voir de nombreuses autres approches abordées dans

Capturer stdout à partir d'un script en Python

La seule façon de bien le faire ... est d'utiliser votre ReporterClass .

import html
from pylint.interfaces import IReporter
from pylint.reporters import *

class MyReporterClass(BaseReporter):
    """Report messages and layouts."""

    __implements__ = IReporter
    name = "myreporter"
    extension = "myreporter"

    def __init__(self, output=sys.stdout):
        BaseReporter.__init__(self, output)
        self.messages = []

    def handle_message(self, msg):
        """Manage message of different type and in the context of path."""
        self.messages.append(
            {
                "type": msg.category,
                "module": msg.module,
                "obj": msg.obj,
                "line": msg.line,
                "column": msg.column,
                "path": msg.path,
                "symbol": msg.symbol,
                "message": html.escape(msg.msg or "", quote=False),
                "message-id": msg.msg_id,
            }
        )

    def display_messages(self, layout):
        """Do nothing."""

    def display_reports(self, layout):
        """Do nothing."""

    def _display(self, layout):
        """Do nothing."""


def register(linter):
    """Register the reporter classes with the linter."""
    linter.register_reporter(MyReporterClass)

Le code ci-dessous a le même comportement que json mais sa méthode display_messages ne fait rien

import pylint.lint
options = [
    filename, 
    "--output-format=mypackage.mymodule.MyReporterClass" 
]
results = pylint.lint.Run(options, do_exit=False)
messages = results.linter.reporter.messages

PyLint ne fera plus print() après avoir évalué le code.

Vous pouvez également utiliser le CollectingReporter, puis vous convertir vous-même en JSON.

CONSEIL : notez que vous devez désactiver le scoring, sinon CollectingReporter crée une erreur, car il n'a pas de fonction d'affichage.

from pylint.reporters import CollectingReporter
from pylint.lint import Run
rep = CollectingReporter()
Run([filename, "-sn"], reporter=rep, do_exit=False)
# Now continue processing rep.messages

Je me rends compte que c'est une réponse tardive, mais j'ai pensé mentionner qu'il existe une alternative entre le roulement de votre propre journaliste et la redirection de stdout. Malheureusement, ce n'est pas très bien documenté, mais un rapide coup d'œil au code montre que la classe BaseReporter a une méthode set_output qui semble être conçue exactement pour cela. Donc, une autre approche qui permet la suppression de stdout mais rassemble toujours la sortie JSON (je l'utilise pour les rapports sélectifs) est quelque chose comme ceci:

from io import StringIO
import pylint.lint
from pylint.reporters import JSONReporter

out_stream = StringIO()
quiet_reporter = JSONReporter()
quiet_reporter.set_output(out_stream)

results = pylint.lint.Run([filename], reporter=quiet_reporter, do_exit=False)

Ensuite , vous pouvez utiliser results.linter.stats pour prendre des décisions sur ce qu'il faut signaler (par exemple, les statistiques [ « refactor »] détient le nombre de messages générés réusiner), et vous pouvez imprimer ou ouvrir une session out_stream comme bon vous semble.