deepnote-python-lsp-server 0.0.0__py2.py3-none-any.whl

pylsp/plugins/pydocstyle_lint.py

@@ -0,0 +1,127 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import contextlib
+import logging
+import os
+import re
+import sys
+
+import pydocstyle
+
+from pylsp import hookimpl, lsp
+
+log = logging.getLogger(__name__)
+
+# PyDocstyle is a little verbose in debug message
+pydocstyle_logger = logging.getLogger(pydocstyle.utils.__name__)
+pydocstyle_logger.setLevel(logging.INFO)
+
+DEFAULT_MATCH_RE = pydocstyle.config.ConfigurationParser.DEFAULT_MATCH_RE
+DEFAULT_MATCH_DIR_RE = pydocstyle.config.ConfigurationParser.DEFAULT_MATCH_DIR_RE
+
+
+@hookimpl
+def pylsp_settings():
+    # Default pydocstyle to disabled
+    return {"plugins": {"pydocstyle": {"enabled": False}}}
+
+
+@hookimpl
+def pylsp_lint(config, workspace, document):
+    with workspace.report_progress("lint: pydocstyle"):
+        settings = config.plugin_settings("pydocstyle", document_path=document.path)
+        log.debug("Got pydocstyle settings: %s", settings)
+
+        # Explicitly passing a path to pydocstyle means it doesn't respect the --match flag, so do it ourselves
+        filename_match_re = re.compile(settings.get("match", DEFAULT_MATCH_RE) + "$")
+        if not filename_match_re.match(os.path.basename(document.path)):
+            return []
+
+        # Likewise with --match-dir
+        dir_match_re = re.compile(settings.get("matchDir", DEFAULT_MATCH_DIR_RE) + "$")
+        if not dir_match_re.match(os.path.basename(os.path.dirname(document.path))):
+            return []
+
+        args = [document.path]
+
+        if settings.get("convention"):
+            args.append("--convention=" + settings["convention"])
+
+            if settings.get("addSelect"):
+                args.append("--add-select=" + ",".join(settings["addSelect"]))
+            if settings.get("addIgnore"):
+                args.append("--add-ignore=" + ",".join(settings["addIgnore"]))
+
+        elif settings.get("select"):
+            args.append("--select=" + ",".join(settings["select"]))
+        elif settings.get("ignore"):
+            args.append("--ignore=" + ",".join(settings["ignore"]))
+
+        log.info("Using pydocstyle args: %s", args)
+
+        conf = pydocstyle.config.ConfigurationParser()
+        with _patch_sys_argv(args):
+            # TODO(gatesn): We can add more pydocstyle args here from our pylsp config
+            conf.parse()
+
+        # Will only yield a single filename, the document path
+        diags = []
+        for (
+            filename,
+            checked_codes,
+            ignore_decorators,
+            property_decorators,
+            ignore_self_only_init,
+        ) in conf.get_files_to_check():
+            errors = pydocstyle.checker.ConventionChecker().check_source(
+                document.source,
+                filename,
+                ignore_decorators=ignore_decorators,
+                property_decorators=property_decorators,
+                ignore_self_only_init=ignore_self_only_init,
+            )
+
+            try:
+                for error in errors:
+                    if error.code not in checked_codes:
+                        continue
+                    diags.append(_parse_diagnostic(document, error))
+            except pydocstyle.parser.ParseError:
+                # In the case we cannot parse the Python file, just continue
+                pass
+
+        log.debug("Got pydocstyle errors: %s", diags)
+        return diags
+
+
+def _parse_diagnostic(document, error):
+    lineno = error.definition.start - 1
+    line = document.lines[0] if document.lines else ""
+
+    start_character = len(line) - len(line.lstrip())
+    end_character = len(line)
+
+    return {
+        "source": "pydocstyle",
+        "code": error.code,
+        "message": error.message,
+        "severity": lsp.DiagnosticSeverity.Warning,
+        "range": {
+            "start": {"line": lineno, "character": start_character},
+            "end": {"line": lineno, "character": end_character},
+        },
+    }
+
+
+@contextlib.contextmanager
+def _patch_sys_argv(arguments) -> None:
+    old_args = sys.argv
+
+    # Preserve argv[0] since it's the executable
+    sys.argv = old_args[0:1] + arguments
+
+    try:
+        yield
+    finally:
+        sys.argv = old_args

pylsp/plugins/pyflakes_lint.py

@@ -0,0 +1,97 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+from pyflakes import api as pyflakes_api
+from pyflakes import messages
+
+from pylsp import hookimpl, lsp
+
+# Pyflakes messages that should be reported as Errors instead of Warns
+PYFLAKES_ERROR_MESSAGES = (
+    messages.UndefinedName,
+    messages.UndefinedExport,
+    messages.UndefinedLocal,
+    messages.DuplicateArgument,
+    messages.FutureFeatureNotDefined,
+    messages.ReturnOutsideFunction,
+    messages.YieldOutsideFunction,
+    messages.ContinueOutsideLoop,
+    messages.BreakOutsideLoop,
+    messages.TwoStarredExpressions,
+)
+
+
+@hookimpl
+def pylsp_lint(workspace, document):
+    with workspace.report_progress("lint: pyflakes"):
+        reporter = PyflakesDiagnosticReport(document.lines)
+        pyflakes_api.check(
+            document.source.encode("utf-8"), document.path, reporter=reporter
+        )
+        return reporter.diagnostics
+
+
+class PyflakesDiagnosticReport:
+    def __init__(self, lines) -> None:
+        self.lines = lines
+        self.diagnostics = []
+
+    def unexpectedError(self, _filename, msg) -> None:  # pragma: no cover
+        err_range = {
+            "start": {"line": 0, "character": 0},
+            "end": {"line": 0, "character": 0},
+        }
+        self.diagnostics.append(
+            {
+                "source": "pyflakes",
+                "range": err_range,
+                "message": msg,
+                "severity": lsp.DiagnosticSeverity.Error,
+            }
+        )
+
+    def syntaxError(self, _filename, msg, lineno, offset, text) -> None:
+        # We've seen that lineno and offset can sometimes be None
+        lineno = lineno or 1
+        offset = offset or 0
+        # could be None if the error is due to an invalid encoding
+        # see e.g. https://github.com/python-lsp/python-lsp-server/issues/429
+        text = text or ""
+
+        err_range = {
+            "start": {"line": lineno - 1, "character": offset},
+            "end": {"line": lineno - 1, "character": offset + len(text)},
+        }
+        self.diagnostics.append(
+            {
+                "source": "pyflakes",
+                "range": err_range,
+                "message": msg,
+                "severity": lsp.DiagnosticSeverity.Error,
+            }
+        )
+
+    def flake(self, message) -> None:
+        """Get message like <filename>:<lineno>: <msg>"""
+        err_range = {
+            "start": {"line": message.lineno - 1, "character": message.col},
+            "end": {
+                "line": message.lineno - 1,
+                "character": len(self.lines[message.lineno - 1]),
+            },
+        }
+
+        severity = lsp.DiagnosticSeverity.Warning
+        for message_type in PYFLAKES_ERROR_MESSAGES:
+            if isinstance(message, message_type):
+                severity = lsp.DiagnosticSeverity.Error
+                break
+
+        self.diagnostics.append(
+            {
+                "source": "pyflakes",
+                "range": err_range,
+                "message": message.message % message.message_args,
+                "severity": severity,
+            }
+        )

pylsp/plugins/pylint_lint.py

@@ -0,0 +1,367 @@
+# Copyright 2018 Google LLC.
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+"""Linter plugin for pylint."""
+
+import collections
+import logging
+import os
+import re
+import shlex
+import sys
+from subprocess import PIPE, Popen
+
+from pylsp import hookimpl, lsp
+
+try:
+    import ujson as json
+except Exception:
+    import json
+
+log = logging.getLogger(__name__)
+
+# Pylint fails to suppress STDOUT when importing whitelisted C
+# extensions, mangling their output into the expected JSON which breaks the
+# parser. The most prominent example (and maybe the only one out there) is
+# pygame - we work around that by asking pygame to NOT display the message upon
+# import via an (otherwise harmless) environment variable. This is an ad-hoc
+# fix for a very specific upstream issue.
+# Related: https://github.com/PyCQA/pylint/issues/3518
+os.environ["PYGAME_HIDE_SUPPORT_PROMPT"] = "hide"
+DEPRECATION_CODES = {
+    "W0402",  # Uses of a deprecated module %r
+    "W1505",  # Using deprecated method %s()
+    "W1511",  # Using deprecated argument %s of method %s()
+    "W1512",  # Using deprecated class %s of module %s
+    "W1513",  # Using deprecated decorator %s()
+}
+UNNECESSITY_CODES = {
+    "W0611",  # Unused import %s
+    "W0612",  # Unused variable %r
+    "W0613",  # Unused argument %r
+    "W0614",  # Unused import %s from wildcard import
+    "W1304",  # Unused-format-string-argument
+}
+
+
+class PylintLinter:
+    last_diags = collections.defaultdict(list)
+
+    @classmethod
+    def lint(cls, document, is_saved, flags=""):
+        """Plugin interface to pylsp linter.
+
+        Args:
+            document: The document to be linted.
+            is_saved: Whether or not the file has been saved to disk.
+            flags: Additional flags to pass to pylint. Not exposed to
+                pylsp_lint, but used for testing.
+
+        Returns:
+            A list of dicts with the following format:
+
+                {
+                    'source': 'pylint',
+                    'range': {
+                        'start': {
+                            'line': start_line,
+                            'character': start_column,
+                        },
+                        'end': {
+                            'line': end_line,
+                            'character': end_column,
+                        },
+                    }
+                    'message': msg,
+                    'severity': lsp.DiagnosticSeverity.*,
+                }
+        """
+        if not is_saved:
+            # Pylint can only be run on files that have been saved to disk.
+            # Rather than return nothing, return the previous list of
+            # diagnostics. If we return an empty list, any diagnostics we'd
+            # previously shown will be cleared until the next save. Instead,
+            # continue showing (possibly stale) diagnostics until the next
+            # save.
+            return cls.last_diags[document.path]
+
+        cmd = [
+            sys.executable,
+            "-c",
+            "import sys; from pylint.lint import Run; Run(sys.argv[1:])",
+            "-f",
+            "json",
+            document.path,
+        ] + (shlex.split(str(flags)) if flags else [])
+        log.debug("Calling pylint with '%s'", " ".join(cmd))
+
+        cwd = document._workspace.root_path
+        if not cwd:
+            cwd = os.path.dirname(__file__)
+
+        with Popen(
+            cmd, stdout=PIPE, stderr=PIPE, cwd=cwd, universal_newlines=True
+        ) as process:
+            json_out, err = process.communicate()
+
+        if err != "":
+            log.error("Error calling pylint: '%s'", err)
+
+        # pylint prints nothing rather than [] when there are no diagnostics.
+        # json.loads will not parse an empty string, so just return.
+        if not json_out.strip():
+            cls.last_diags[document.path] = []
+            return []
+
+        # Pylint's JSON output is a list of objects with the following format.
+        #
+        #     {
+        #         "obj": "main",
+        #         "path": "foo.py",
+        #         "message": "Missing function docstring",
+        #         "message-id": "C0111",
+        #         "symbol": "missing-docstring",
+        #         "column": 0,
+        #         "type": "convention",
+        #         "line": 5,
+        #         "module": "foo"
+        #     }
+        #
+        # The type can be any of:
+        #
+        #  * convention
+        #  * information
+        #  * error
+        #  * fatal
+        #  * refactor
+        #  * warning
+        diagnostics = []
+        for diag in json.loads(json_out):
+            # pylint lines index from 1, pylsp lines index from 0
+            line = diag["line"] - 1
+
+            err_range = {
+                "start": {
+                    "line": line,
+                    # Index columns start from 0
+                    "character": diag["column"],
+                },
+                "end": {
+                    "line": line,
+                    # It's possible that we're linting an empty file. Even an empty
+                    # file might fail linting if it isn't named properly.
+                    "character": (
+                        _find_end_of_identifier(document.lines[line], diag["column"])
+                        if document.lines
+                        else 0
+                    ),
+                },
+            }
+
+            if diag["type"] == "convention":
+                severity = lsp.DiagnosticSeverity.Information
+            elif diag["type"] == "information":
+                severity = lsp.DiagnosticSeverity.Information
+            elif diag["type"] == "error":
+                severity = lsp.DiagnosticSeverity.Error
+            elif diag["type"] == "fatal":
+                severity = lsp.DiagnosticSeverity.Error
+            elif diag["type"] == "refactor":
+                severity = lsp.DiagnosticSeverity.Hint
+            elif diag["type"] == "warning":
+                severity = lsp.DiagnosticSeverity.Warning
+
+            code = diag["message-id"]
+
+            diagnostic = {
+                "source": "pylint",
+                "range": err_range,
+                "message": "[{}] {}".format(diag["symbol"], diag["message"]),
+                "severity": severity,
+                "code": code,
+            }
+
+            if code in UNNECESSITY_CODES:
+                diagnostic["tags"] = [lsp.DiagnosticTag.Unnecessary]
+            if code in DEPRECATION_CODES:
+                diagnostic["tags"] = [lsp.DiagnosticTag.Deprecated]
+
+            diagnostics.append(diagnostic)
+        cls.last_diags[document.path] = diagnostics
+        return diagnostics
+
+
+def _build_pylint_flags(settings):
+    """Build arguments for calling pylint."""
+    pylint_args = settings.get("args")
+    if pylint_args is None:
+        return ""
+    return " ".join(pylint_args)
+
+
+@hookimpl
+def pylsp_settings():
+    # Default pylint to disabled because it requires a config
+    # file to be useful.
+    return {
+        "plugins": {
+            "pylint": {
+                "enabled": False,
+                "args": [],
+                # disabled by default as it can slow down the workflow
+                "executable": None,
+            }
+        }
+    }
+
+
+@hookimpl
+def pylsp_lint(config, workspace, document, is_saved):
+    """Run pylint linter."""
+    with workspace.report_progress("lint: pylint"):
+        settings = config.plugin_settings("pylint")
+        log.debug("Got pylint settings: %s", settings)
+        # pylint >= 2.5.0 is required for working through stdin and only
+        # available with python3
+        if settings.get("executable") and sys.version_info[0] >= 3:
+            flags = build_args_stdio(settings)
+            pylint_executable = settings.get("executable", "pylint")
+            return pylint_lint_stdin(pylint_executable, document, flags)
+        flags = _build_pylint_flags(settings)
+        return PylintLinter.lint(document, is_saved, flags=flags)
+
+
+def build_args_stdio(settings):
+    """Build arguments for calling pylint.
+
+    :param settings: client settings
+    :type settings: dict
+
+    :return: arguments to path to pylint
+    :rtype: list
+    """
+    pylint_args = settings.get("args")
+    if pylint_args is None:
+        return []
+    return pylint_args
+
+
+def pylint_lint_stdin(pylint_executable, document, flags):
+    """Run pylint linter from stdin.
+
+    This runs pylint in a subprocess with popen.
+    This allows passing the file from stdin and as a result
+    run pylint on unsaved files. Can slowdown the workflow.
+
+    :param pylint_executable: path to pylint executable
+    :type pylint_executable: string
+    :param document: document to run pylint on
+    :type document: pylsp.workspace.Document
+    :param flags: arguments to path to pylint
+    :type flags: list
+
+    :return: linting diagnostics
+    :rtype: list
+    """
+    pylint_result = _run_pylint_stdio(pylint_executable, document, flags)
+    return _parse_pylint_stdio_result(document, pylint_result)
+
+
+def _run_pylint_stdio(pylint_executable, document, flags):
+    """Run pylint in popen.
+
+    :param pylint_executable: path to pylint executable
+    :type pylint_executable: string
+    :param document: document to run pylint on
+    :type document: pylsp.workspace.Document
+    :param flags: arguments to path to pylint
+    :type flags: list
+
+    :return: result of calling pylint
+    :rtype: string
+    """
+    log.debug("Calling %s with args: '%s'", pylint_executable, flags)
+    try:
+        cmd = [pylint_executable]
+        cmd.extend(flags)
+        cmd.extend(["--from-stdin", document.path])
+        p = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
+    except IOError:
+        log.debug("Can't execute %s. Trying with 'python -m pylint'", pylint_executable)
+        cmd = [sys.executable, "-m", "pylint"]
+        cmd.extend(flags)
+        cmd.extend(["--from-stdin", document.path])
+        p = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
+    (stdout, stderr) = p.communicate(document.source.encode())
+    if stderr:
+        log.error("Error while running pylint '%s'", stderr.decode())
+    return stdout.decode()
+
+
+def _parse_pylint_stdio_result(document, stdout):
+    """Parse pylint results.
+
+    :param document: document to run pylint on
+    :type document: pylsp.workspace.Document
+    :param stdout: pylint results to parse
+    :type stdout: string
+
+    :return: linting diagnostics
+    :rtype: list
+    """
+    diagnostics = []
+    lines = stdout.splitlines()
+    for raw_line in lines:
+        parsed_line = re.match(r"(.*):(\d*):(\d*): (\w*): (.*)", raw_line)
+        if not parsed_line:
+            log.debug("Pylint output parser can't parse line '%s'", raw_line)
+            continue
+
+        parsed_line = parsed_line.groups()
+        if len(parsed_line) != 5:
+            log.debug("Pylint output parser can't parse line '%s'", raw_line)
+            continue
+
+        _, line, character, code, msg = parsed_line
+        line = int(line) - 1
+        character = int(character)
+        severity_map = {
+            "C": lsp.DiagnosticSeverity.Information,
+            "E": lsp.DiagnosticSeverity.Error,
+            "F": lsp.DiagnosticSeverity.Error,
+            "I": lsp.DiagnosticSeverity.Information,
+            "R": lsp.DiagnosticSeverity.Hint,
+            "W": lsp.DiagnosticSeverity.Warning,
+        }
+        severity = severity_map[code[0]]
+        diagnostic = {
+            "source": "pylint",
+            "code": code,
+            "range": {
+                "start": {"line": line, "character": character},
+                "end": {
+                    "line": line,
+                    "character": _find_end_of_identifier(
+                        document.lines[line], character
+                    ),
+                },
+            },
+            "message": msg,
+            "severity": severity,
+        }
+        if code in UNNECESSITY_CODES:
+            diagnostic["tags"] = [lsp.DiagnosticTag.Unnecessary]
+        if code in DEPRECATION_CODES:
+            diagnostic["tags"] = [lsp.DiagnosticTag.Deprecated]
+        diagnostics.append(diagnostic)
+
+    return diagnostics
+
+
+def _find_end_of_identifier(string, start):
+    """Find the end of the identifier starting at the given position."""
+    for i in range(len(string), start, -1):
+        if string[start:i].isidentifier():
+            return i
+    return len(string) - 1

pylsp/plugins/references.py

@@ -0,0 +1,33 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import logging
+
+from pylsp import _utils, hookimpl, uris
+
+log = logging.getLogger(__name__)
+
+
+@hookimpl
+def pylsp_references(document, position, exclude_declaration):
+    code_position = _utils.position_to_jedi_linecolumn(document, position)
+    usages = document.jedi_script().get_references(**code_position)
+
+    if exclude_declaration:
+        # Filter out if the usage is the actual declaration of the thing
+        usages = [d for d in usages if not d.is_definition()]
+
+    # Filter out builtin modules
+    return [
+        {
+            "uri": uris.uri_with(document.uri, path=str(d.module_path))
+            if d.module_path
+            else document.uri,
+            "range": {
+                "start": {"line": d.line - 1, "character": d.column},
+                "end": {"line": d.line - 1, "character": d.column + len(d.name)},
+            },
+        }
+        for d in usages
+        if not d.in_builtin_module()
+    ]