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

pylsp/plugins/definition.py

@@ -0,0 +1,84 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, List
+
+import jedi
+
+from pylsp import _utils, hookimpl, uris
+
+if TYPE_CHECKING:
+    from jedi.api import Script
+    from jedi.api.classes import Name
+
+    from pylsp.config.config import Config
+    from pylsp.workspace import Document
+
+log = logging.getLogger(__name__)
+
+
+MAX_JEDI_GOTO_HOPS = 100
+
+
+def _resolve_definition(
+    maybe_defn: Name, script: Script, settings: Dict[str, Any]
+) -> Name:
+    for _ in range(MAX_JEDI_GOTO_HOPS):
+        if maybe_defn.is_definition() or maybe_defn.module_path != script.path:
+            break
+        defns = script.goto(
+            follow_imports=settings.get("follow_imports", True),
+            follow_builtin_imports=settings.get("follow_builtin_imports", True),
+            line=maybe_defn.line,
+            column=maybe_defn.column,
+        )
+        if len(defns) == 1:
+            maybe_defn = defns[0]
+        else:
+            break
+    return maybe_defn
+
+
+@hookimpl
+def pylsp_definitions(
+    config: Config, document: Document, position: Dict[str, int]
+) -> List[Dict[str, Any]]:
+    settings = config.plugin_settings("jedi_definition")
+    code_position = _utils.position_to_jedi_linecolumn(document, position)
+    script = document.jedi_script(use_document_path=True)
+    auto_import_modules = jedi.settings.auto_import_modules
+
+    try:
+        jedi.settings.auto_import_modules = []
+        definitions = script.goto(
+            follow_imports=settings.get("follow_imports", True),
+            follow_builtin_imports=settings.get("follow_builtin_imports", True),
+            **code_position,
+        )
+        definitions = [_resolve_definition(d, script, settings) for d in definitions]
+    finally:
+        jedi.settings.auto_import_modules = auto_import_modules
+
+    follow_builtin_defns = settings.get("follow_builtin_definitions", True)
+    return [
+        {
+            "uri": uris.uri_with(document.uri, path=str(d.module_path)),
+            "range": {
+                "start": {"line": d.line - 1, "character": d.column},
+                "end": {"line": d.line - 1, "character": d.column + len(d.name)},
+            },
+        }
+        for d in definitions
+        if d.is_definition() and (follow_builtin_defns or _not_internal_definition(d))
+    ]
+
+
+def _not_internal_definition(definition: Name) -> bool:
+    return (
+        definition.line is not None
+        and definition.column is not None
+        and definition.module_path is not None
+        and not definition.in_builtin_module()
+    )

pylsp/plugins/flake8_lint.py

@@ -0,0 +1,243 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+"""Linter pluging for flake8"""
+
+import logging
+import os.path
+import re
+import sys
+from pathlib import PurePath
+from subprocess import PIPE, Popen
+
+from flake8.plugins.pyflakes import FLAKE8_PYFLAKES_CODES
+
+from pylsp import hookimpl, lsp
+from pylsp.plugins.pyflakes_lint import PYFLAKES_ERROR_MESSAGES
+
+log = logging.getLogger(__name__)
+
+FIX_IGNORES_RE = re.compile(r"([^a-zA-Z0-9_,]*;.*(\W+||$))")
+UNNECESSITY_CODES = {
+    "F401",  # `module` imported but unused
+    "F504",  # % format unused named arguments
+    "F522",  # .format(...) unused named arguments
+    "F523",  # .format(...) unused positional arguments
+    "F841",  # local variable `name` is assigned to but never used
+}
+# NOTE: If the user sets the flake8 executable with workspace configuration, the
+# error codes in this set may be inaccurate.
+ERROR_CODES = (
+    # Errors from the pyflakes plugin of flake8
+    {FLAKE8_PYFLAKES_CODES.get(m.__name__, "E999") for m in PYFLAKES_ERROR_MESSAGES}
+    # Syntax error from flake8 itself
+    | {"E999"}
+)
+
+
+@hookimpl
+def pylsp_settings():
+    # Default flake8 to disabled
+    return {"plugins": {"flake8": {"enabled": False}}}
+
+
+@hookimpl
+def pylsp_lint(workspace, document):
+    with workspace.report_progress("lint: flake8"):
+        config = workspace._config
+        settings = config.plugin_settings("flake8", document_path=document.path)
+        log.debug("Got flake8 settings: %s", settings)
+
+        ignores = settings.get("ignore", [])
+        per_file_ignores = settings.get("perFileIgnores")
+
+        if per_file_ignores:
+            prev_file_pat = None
+            for path in per_file_ignores:
+                try:
+                    file_pat, errors = path.split(":")
+                    prev_file_pat = file_pat
+                except ValueError:
+                    # It's legal to just specify another error type for the same
+                    # file pattern:
+                    if prev_file_pat is None:
+                        log.warning("skipping a Per-file-ignore with no file pattern")
+                        continue
+                    file_pat = prev_file_pat
+                    errors = path
+                if PurePath(document.path).match(file_pat):
+                    ignores.extend(errors.split(","))
+
+        opts = {
+            "config": settings.get("config"),
+            "exclude": settings.get("exclude"),
+            "extend-ignore": settings.get("extendIgnore"),
+            "extend-select": settings.get("extendSelect"),
+            "filename": settings.get("filename"),
+            "hang-closing": settings.get("hangClosing"),
+            "ignore": ignores or None,
+            "max-complexity": settings.get("maxComplexity"),
+            "max-line-length": settings.get("maxLineLength"),
+            "indent-size": settings.get("indentSize"),
+            "select": settings.get("select"),
+        }
+
+        # flake takes only absolute path to the config. So we should check and
+        # convert if necessary
+        if opts.get("config") and not os.path.isabs(opts.get("config")):
+            opts["config"] = os.path.abspath(
+                os.path.expanduser(os.path.expandvars(opts.get("config")))
+            )
+            log.debug("using flake8 with config: %s", opts["config"])
+
+        # Call the flake8 utility then parse diagnostics from stdout
+        flake8_executable = settings.get("executable", "flake8")
+
+        args = build_args(opts)
+
+        # ensure the same source is used for flake8 execution and result parsing;
+        # single source access improves performance as it is only one disk access
+        source = document.source
+        output = run_flake8(flake8_executable, args, document, source)
+        return parse_stdout(source, output)
+
+
+def run_flake8(flake8_executable, args, document, source):
+    """Run flake8 with the provided arguments, logs errors
+    from stderr if any.
+    """
+    # a quick temporary fix to deal with Atom
+    args = [
+        (i if not i.startswith("--ignore=") else FIX_IGNORES_RE.sub("", i))
+        for i in args
+        if i is not None
+    ]
+
+    if document.path and document.path.startswith(document._workspace.root_path):
+        args.extend(
+            [
+                "--stdin-display-name",
+                os.path.relpath(document.path, document._workspace.root_path),
+            ]
+        )
+
+    # if executable looks like a path resolve it
+    if not os.path.isfile(flake8_executable) and os.sep in flake8_executable:
+        flake8_executable = os.path.abspath(
+            os.path.expanduser(os.path.expandvars(flake8_executable))
+        )
+
+    log.debug("Calling %s with args: '%s'", flake8_executable, args)
+    popen_kwargs = {}
+    if cwd := document._workspace.root_path:
+        popen_kwargs["cwd"] = cwd
+    try:
+        cmd = [flake8_executable]
+        cmd.extend(args)
+        p = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE, **popen_kwargs)
+    except IOError:
+        log.debug(
+            "Can't execute %s. Trying with '%s -m flake8'",
+            flake8_executable,
+            sys.executable,
+        )
+        cmd = [sys.executable, "-m", "flake8"]
+        cmd.extend(args)
+        p = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE, **popen_kwargs)
+    (stdout, stderr) = p.communicate(source.encode())
+    if stderr:
+        log.error("Error while running flake8 '%s'", stderr.decode())
+    return stdout.decode()
+
+
+def build_args(options):
+    """Build arguments for calling flake8.
+
+    Args:
+        options: dictionary of argument names and their values.
+    """
+    args = ["-"]  # use stdin
+    for arg_name, arg_val in options.items():
+        if arg_val is None:
+            continue
+        arg = None
+        if isinstance(arg_val, list):
+            arg = "--{}={}".format(arg_name, ",".join(arg_val))
+        elif isinstance(arg_val, bool):
+            if arg_val:
+                arg = "--{}".format(arg_name)
+        else:
+            arg = "--{}={}".format(arg_name, arg_val)
+        args.append(arg)
+    return args
+
+
+def parse_stdout(source, stdout):
+    """
+    Build a diagnostics from flake8's output, it should extract every result and format
+    it into a dict that looks like this:
+        {
+            'source': 'flake8',
+            'code': code, # 'E501'
+            'range': {
+                'start': {
+                    'line': start_line,
+                    'character': start_column,
+                },
+                'end': {
+                    'line': end_line,
+                    'character': end_column,
+                },
+            },
+            'message': msg,
+            'severity': lsp.DiagnosticSeverity.*,
+        }
+
+    Args:
+        document: The document to be linted.
+        stdout: output from flake8
+    Returns:
+        A list of dictionaries.
+    """
+
+    document_lines = source.splitlines(True)
+    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("Flake8 output parser can't parse line '%s'", raw_line)
+            continue
+
+        parsed_line = parsed_line.groups()
+        if len(parsed_line) != 5:
+            log.debug("Flake8 output parser can't parse line '%s'", raw_line)
+            continue
+
+        _, line, character, code, msg = parsed_line
+        line = int(line) - 1
+        character = int(character) - 1
+        # show also the code in message
+        msg = code + " " + msg
+        severity = lsp.DiagnosticSeverity.Warning
+        if code in ERROR_CODES:
+            severity = lsp.DiagnosticSeverity.Error
+        diagnostic = {
+            "source": "flake8",
+            "code": code,
+            "range": {
+                "start": {"line": line, "character": character},
+                "end": {
+                    "line": line,
+                    # no way to determine the column
+                    "character": len(document_lines[line]),
+                },
+            },
+            "message": msg,
+            "severity": severity,
+        }
+        if code in UNNECESSITY_CODES:
+            diagnostic["tags"] = [lsp.DiagnosticTag.Unnecessary]
+        diagnostics.append(diagnostic)
+
+    return diagnostics

pylsp/plugins/folding.py

@@ -0,0 +1,210 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import re
+
+import parso
+import parso.python.tree as tree_nodes
+
+from pylsp import hookimpl
+
+SKIP_NODES = (tree_nodes.Module, tree_nodes.IfStmt, tree_nodes.TryStmt)
+IDENTATION_REGEX = re.compile(r"(\s+).+")
+
+
+@hookimpl
+def pylsp_folding_range(document):
+    program = document.source + "\n"
+    lines = program.splitlines()
+    tree = parso.parse(program)
+    ranges = __compute_folding_ranges(tree, lines)
+
+    results = []
+    for start_line, end_line in ranges:
+        start_line -= 1
+        end_line -= 1
+        # If start/end character is not defined, then it defaults to the
+        # corresponding line last character
+        results.append(
+            {
+                "startLine": start_line,
+                "endLine": end_line,
+            }
+        )
+    return results
+
+
+def __merge_folding_ranges(left, right):
+    for start in list(left.keys()):
+        right_start = right.pop(start, None)
+        if right_start is not None:
+            left[start] = max(right_start, start)
+    left.update(right)
+    return left
+
+
+def __empty_identation_stack(
+    identation_stack, level_limits, current_line, folding_ranges
+):
+    while identation_stack != []:
+        upper_level = identation_stack.pop(0)
+        level_start = level_limits.pop(upper_level)
+        folding_ranges.append((level_start, current_line))
+    return folding_ranges
+
+
+def __match_identation_stack(
+    identation_stack, level, level_limits, folding_ranges, current_line
+):
+    upper_level = identation_stack.pop(0)
+    while upper_level >= level:
+        level_start = level_limits.pop(upper_level)
+        folding_ranges.append((level_start, current_line))
+        upper_level = identation_stack.pop(0)
+    identation_stack.insert(0, upper_level)
+    return identation_stack, folding_ranges
+
+
+def __compute_folding_ranges_identation(text):
+    lines = text.splitlines()
+    folding_ranges = []
+    identation_stack = []
+    level_limits = {}
+    current_level = 0
+    current_line = 0
+    while lines[current_line] == "":
+        current_line += 1
+    for i, line in enumerate(lines):
+        if i < current_line:
+            continue
+        i += 1
+        identation_match = IDENTATION_REGEX.match(line)
+        if identation_match is not None:
+            whitespace = identation_match.group(1)
+            level = len(whitespace)
+            if level > current_level:
+                level_limits[current_level] = current_line
+                identation_stack.insert(0, current_level)
+                current_level = level
+            elif level < current_level:
+                identation_stack, folding_ranges = __match_identation_stack(
+                    identation_stack, level, level_limits, folding_ranges, current_line
+                )
+                current_level = level
+        else:
+            folding_ranges = __empty_identation_stack(
+                identation_stack, level_limits, current_line, folding_ranges
+            )
+            current_level = 0
+        if line.strip() != "":
+            current_line = i
+    folding_ranges = __empty_identation_stack(
+        identation_stack, level_limits, current_line, folding_ranges
+    )
+    return dict(folding_ranges)
+
+
+def __check_if_node_is_valid(node):
+    valid = True
+    if isinstance(node, tree_nodes.PythonNode):
+        kind = node.type
+        valid = kind not in {
+            "decorated",
+            "parameters",
+            "dictorsetmaker",
+            "testlist_comp",
+        }
+        if kind == "suite":
+            if isinstance(node.parent, tree_nodes.Function):
+                valid = False
+    return valid
+
+
+def __handle_skip(stack, skip):
+    body = stack[skip]
+    children = [body]
+    if hasattr(body, "children"):
+        children = body.children
+    stack = stack[:skip] + children + stack[skip + 1 :]
+    node = body
+    end_line, _ = body.end_pos
+    return node, end_line
+
+
+def __handle_flow_nodes(node, end_line, stack):
+    from_keyword = False
+    if isinstance(node, tree_nodes.Keyword):
+        from_keyword = True
+        if node.value in {"if", "elif", "with", "while"}:
+            node, end_line = __handle_skip(stack, 2)
+        elif node.value in {"except"}:
+            first_node = stack[0]
+            if isinstance(first_node, tree_nodes.Operator):
+                node, end_line = __handle_skip(stack, 1)
+            else:
+                node, end_line = __handle_skip(stack, 2)
+        elif node.value in {"for"}:
+            node, end_line = __handle_skip(stack, 4)
+        elif node.value in {"else"}:
+            node, end_line = __handle_skip(stack, 1)
+    return end_line, from_keyword, node, stack
+
+
+def __compute_start_end_lines(node, stack):
+    start_line, _ = node.start_pos
+    end_line, _ = node.end_pos
+    modified = False
+    end_line, from_keyword, node, stack = __handle_flow_nodes(node, end_line, stack)
+
+    last_leaf = node.get_last_leaf()
+    last_newline = isinstance(last_leaf, tree_nodes.Newline)
+    last_operator = isinstance(last_leaf, tree_nodes.Operator)
+    node_is_operator = isinstance(node, tree_nodes.Operator)
+    last_operator = last_operator or not node_is_operator
+
+    end_line -= 1
+
+    if isinstance(node.parent, tree_nodes.PythonNode) and not from_keyword:
+        kind = node.type
+        if kind in {"suite", "atom", "atom_expr", "arglist"}:
+            if len(stack) > 0:
+                next_node = stack[0]
+                next_line, _ = next_node.start_pos
+                if next_line > end_line:
+                    end_line += 1
+                    modified = True
+    if not last_newline and not modified and not last_operator:
+        end_line += 1
+    return start_line, end_line, stack
+
+
+def __compute_folding_ranges(tree, lines):
+    folding_ranges = {}
+    stack = [tree]
+
+    while len(stack) > 0:
+        node = stack.pop(0)
+        if isinstance(node, tree_nodes.Newline):
+            # Skip newline nodes
+            continue
+        if isinstance(node, tree_nodes.PythonErrorNode):
+            # Fallback to indentation-based (best-effort) folding
+            start_line, _ = node.start_pos
+            start_line -= 1
+            padding = [""] * start_line
+            text = "\n".join(padding + lines[start_line:]) + "\n"
+            identation_ranges = __compute_folding_ranges_identation(text)
+            folding_ranges = __merge_folding_ranges(folding_ranges, identation_ranges)
+            break
+        if not isinstance(node, SKIP_NODES):
+            valid = __check_if_node_is_valid(node)
+            if valid:
+                start_line, end_line, stack = __compute_start_end_lines(node, stack)
+                if end_line > start_line:
+                    current_end = folding_ranges.get(start_line, -1)
+                    folding_ranges[start_line] = max(current_end, end_line)
+        if hasattr(node, "children"):
+            stack = node.children + stack
+
+    folding_ranges = sorted(folding_ranges.items())
+    return folding_ranges

pylsp/plugins/highlight.py

@@ -0,0 +1,36 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import logging
+
+from pylsp import _utils, hookimpl, lsp
+
+log = logging.getLogger(__name__)
+
+
+@hookimpl
+def pylsp_document_highlight(document, position):
+    code_position = _utils.position_to_jedi_linecolumn(document, position)
+    usages = document.jedi_script().get_references(**code_position)
+
+    def is_valid(definition):
+        return definition.line is not None and definition.column is not None
+
+    def local_to_document(definition):
+        return (
+            not definition.module_path or str(definition.module_path) == document.path
+        )
+
+    return [
+        {
+            "range": {
+                "start": {"line": d.line - 1, "character": d.column},
+                "end": {"line": d.line - 1, "character": d.column + len(d.name)},
+            },
+            "kind": lsp.DocumentHighlightKind.Write
+            if d.is_definition()
+            else lsp.DocumentHighlightKind.Read,
+        }
+        for d in usages
+        if is_valid(d) and local_to_document(d)
+    ]

pylsp/plugins/hover.py

@@ -0,0 +1,57 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import logging
+
+from pylsp import _utils, hookimpl
+
+log = logging.getLogger(__name__)
+
+
+@hookimpl
+def pylsp_hover(config, document, position):
+    code_position = _utils.position_to_jedi_linecolumn(document, position)
+    definitions = document.jedi_script(use_document_path=True).infer(**code_position)
+    word = document.word_at_position(position)
+
+    # Find first exact matching definition
+    definition = next((x for x in definitions if x.name == word), None)
+
+    # Ensure a definition is used if only one is available
+    # even if the word doesn't match. An example of this case is 'np'
+    # where 'numpy' doesn't match with 'np'. Same for NumPy ufuncs
+    if len(definitions) == 1:
+        definition = definitions[0]
+
+    if not definition:
+        return {"contents": ""}
+
+    hover_capabilities = config.capabilities.get("textDocument", {}).get("hover", {})
+    supported_markup_kinds = hover_capabilities.get("contentFormat", ["markdown"])
+    preferred_markup_kind = _utils.choose_markup_kind(supported_markup_kinds)
+
+    doc = _utils.format_docstring(definition.docstring(raw=True), preferred_markup_kind)["value"]
+
+    # Find first exact matching signature
+    signature = next(
+        (
+            x.to_string()
+            for x in definition.get_signatures()
+            if (x.name == word and x.type not in ["module"])
+        ),
+        "",
+    )
+
+    contents = []
+    if signature:
+        contents.append({
+            'language': 'python',
+            'value': signature,
+        })
+    
+    if doc:
+        contents.append(doc)
+
+    return {
+        "contents": contents or ''
+    }