| # mode: python; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 |
| # -*- vim:fenc=utf-8:ft=python:et:sw=4:ts=4:sts=4 |
| |
| # Copyright (c) 2008-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr> |
| # Copyright (c) 2014 Jakob Normark <jakobnormark@gmail.com> |
| # Copyright (c) 2014 Brett Cannon <brett@python.org> |
| # Copyright (c) 2014 Manuel Vázquez Acosta <mva.led@gmail.com> |
| # Copyright (c) 2014 Derek Harland <derek.harland@finq.co.nz> |
| # Copyright (c) 2014 Arun Persaud <arun@nubati.net> |
| # Copyright (c) 2015-2020 Claudiu Popa <pcmanticore@gmail.com> |
| # Copyright (c) 2015 Mihai Balint <balint.mihai@gmail.com> |
| # Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro> |
| # Copyright (c) 2017, 2020 hippo91 <guillaume.peillex@gmail.com> |
| # Copyright (c) 2017 Daniela Plascencia <daplascen@gmail.com> |
| # Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com> |
| # Copyright (c) 2018 Ryan McGuire <ryan@enigmacurry.com> |
| # Copyright (c) 2018 thernstig <30827238+thernstig@users.noreply.github.com> |
| # Copyright (c) 2018 Radostin Stoyanov <rst0git@users.noreply.github.com> |
| # Copyright (c) 2019, 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com> |
| # Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com> |
| # Copyright (c) 2020 Damien Baty <damien.baty@polyconseil.fr> |
| # Copyright (c) 2020 Anthony Sottile <asottile@umich.edu> |
| # Copyright (c) 2021 Andreas Finkler <andi.finkler@gmail.com> |
| |
| # Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html |
| # For details: https://github.com/PyCQA/pylint/blob/master/LICENSE |
| |
| """Emacs and Flymake compatible Pylint. |
| |
| This script is for integration with emacs and is compatible with flymake mode. |
| |
| epylint walks out of python packages before invoking pylint. This avoids |
| reporting import errors that occur when a module within a package uses the |
| absolute import path to get another module within this package. |
| |
| For example: |
| - Suppose a package is structured as |
| |
| a/__init__.py |
| a/b/x.py |
| a/c/y.py |
| |
| - Then if y.py imports x as "from a.b import x" the following produces pylint |
| errors |
| |
| cd a/c; pylint y.py |
| |
| - The following obviously doesn't |
| |
| pylint a/c/y.py |
| |
| - As this script will be invoked by emacs within the directory of the file |
| we are checking we need to go out of it to avoid these false positives. |
| |
| |
| You may also use py_run to run pylint with desired options and get back (or not) |
| its output. |
| """ |
| import os |
| import shlex |
| import sys |
| from io import StringIO |
| from subprocess import PIPE, Popen |
| |
| |
| def _get_env(): |
| """Extracts the environment PYTHONPATH and appends the current sys.path to |
| those.""" |
| env = dict(os.environ) |
| env["PYTHONPATH"] = os.pathsep.join(sys.path) |
| return env |
| |
| |
| def lint(filename, options=()): |
| """Pylint the given file. |
| |
| When run from emacs we will be in the directory of a file, and passed its |
| filename. If this file is part of a package and is trying to import other |
| modules from within its own package or another package rooted in a directory |
| below it, pylint will classify it as a failed import. |
| |
| To get around this, we traverse down the directory tree to find the root of |
| the package this module is in. We then invoke pylint from this directory. |
| |
| Finally, we must correct the filenames in the output generated by pylint so |
| Emacs doesn't become confused (it will expect just the original filename, |
| while pylint may extend it with extra directories if we've traversed down |
| the tree) |
| """ |
| # traverse downwards until we are out of a python package |
| full_path = os.path.abspath(filename) |
| parent_path = os.path.dirname(full_path) |
| child_path = os.path.basename(full_path) |
| |
| while parent_path != "/" and os.path.exists( |
| os.path.join(parent_path, "__init__.py") |
| ): |
| child_path = os.path.join(os.path.basename(parent_path), child_path) |
| parent_path = os.path.dirname(parent_path) |
| |
| # Start pylint |
| # Ensure we use the python and pylint associated with the running epylint |
| run_cmd = "import sys; from pylint.lint import Run; Run(sys.argv[1:])" |
| cmd = ( |
| [sys.executable, "-c", run_cmd] |
| + [ |
| "--msg-template", |
| "{path}:{line}: {category} ({msg_id}, {symbol}, {obj}) {msg}", |
| "-r", |
| "n", |
| child_path, |
| ] |
| + list(options) |
| ) |
| |
| with Popen( |
| cmd, stdout=PIPE, cwd=parent_path, env=_get_env(), universal_newlines=True |
| ) as process: |
| |
| for line in process.stdout: |
| # remove pylintrc warning |
| if line.startswith("No config file found"): |
| continue |
| |
| # modify the file name thats output to reverse the path traversal we made |
| parts = line.split(":") |
| if parts and parts[0] == child_path: |
| line = ":".join([filename] + parts[1:]) |
| print(line, end=" ") |
| |
| process.wait() |
| return process.returncode |
| |
| |
| def py_run(command_options="", return_std=False, stdout=None, stderr=None): |
| """Run pylint from python |
| |
| ``command_options`` is a string containing ``pylint`` command line options; |
| ``return_std`` (boolean) indicates return of created standard output |
| and error (see below); |
| ``stdout`` and ``stderr`` are 'file-like' objects in which standard output |
| could be written. |
| |
| Calling agent is responsible for stdout/err management (creation, close). |
| Default standard output and error are those from sys, |
| or standalone ones (``subprocess.PIPE``) are used |
| if they are not set and ``return_std``. |
| |
| If ``return_std`` is set to ``True``, this function returns a 2-uple |
| containing standard output and error related to created process, |
| as follows: ``(stdout, stderr)``. |
| |
| To silently run Pylint on a module, and get its standard output and error: |
| >>> (pylint_stdout, pylint_stderr) = py_run( 'module_name.py', True) |
| """ |
| # Detect if we use Python as executable or not, else default to `python` |
| executable = sys.executable if "python" in sys.executable else "python" |
| |
| # Create command line to call pylint |
| epylint_part = [executable, "-c", "from pylint import epylint;epylint.Run()"] |
| options = shlex.split(command_options, posix=not sys.platform.startswith("win")) |
| cli = epylint_part + options |
| |
| # Providing standard output and/or error if not set |
| if stdout is None: |
| if return_std: |
| stdout = PIPE |
| else: |
| stdout = sys.stdout |
| if stderr is None: |
| if return_std: |
| stderr = PIPE |
| else: |
| stderr = sys.stderr |
| # Call pylint in a subprocess |
| with Popen( |
| cli, |
| shell=False, |
| stdout=stdout, |
| stderr=stderr, |
| env=_get_env(), |
| universal_newlines=True, |
| ) as process: |
| proc_stdout, proc_stderr = process.communicate() |
| # Return standard output and error |
| if return_std: |
| return StringIO(proc_stdout), StringIO(proc_stderr) |
| return None |
| |
| |
| def Run(): |
| if len(sys.argv) == 1: |
| print("Usage: %s <filename> [options]" % sys.argv[0]) |
| sys.exit(1) |
| elif not os.path.exists(sys.argv[1]): |
| print("%s does not exist" % sys.argv[1]) |
| sys.exit(1) |
| else: |
| sys.exit(lint(sys.argv[1], sys.argv[2:])) |
| |
| |
| if __name__ == "__main__": |
| Run() |