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

pylsp/plugins/jedi_completion.py

@@ -0,0 +1,318 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import logging
+import os
+
+import parso
+
+from pylsp import _utils, hookimpl, lsp
+from pylsp.plugins._resolvers import LABEL_RESOLVER, SNIPPET_RESOLVER
+
+log = logging.getLogger(__name__)
+
+# Map to the LSP type
+# > Valid values for type are ``module``, `` class ``, ``instance``, ``function``,
+# > ``param``, ``path``, ``keyword``, ``property`` and ``statement``.
+# see: https://jedi.readthedocs.io/en/latest/docs/api-classes.html#jedi.api.classes.BaseName.type
+_TYPE_MAP = {
+    "module": lsp.CompletionItemKind.Module,
+    "namespace": lsp.CompletionItemKind.Module,  # to be added in Jedi 0.18+
+    "class": lsp.CompletionItemKind.Class,
+    "instance": lsp.CompletionItemKind.Reference,
+    "function": lsp.CompletionItemKind.Function,
+    "param": lsp.CompletionItemKind.Variable,
+    "path": lsp.CompletionItemKind.File,
+    "keyword": lsp.CompletionItemKind.Keyword,
+    "property": lsp.CompletionItemKind.Property,  # added in Jedi 0.18
+    "statement": lsp.CompletionItemKind.Variable,
+}
+
+COMPLETION_CACHE = {}
+
+# Types of parso nodes for which snippet is not included in the completion
+_IMPORTS = ("import_name", "import_from")
+
+# Types of parso node for errors
+_ERRORS = ("error_node",)
+
+
+@hookimpl
+def pylsp_completions(config, document, position):
+    """Get formatted completions for current code position"""
+    settings = config.plugin_settings("jedi_completion", document_path=document.path)
+    resolve_eagerly = settings.get("eager", False)
+    code_position = _utils.position_to_jedi_linecolumn(document, position)
+
+    code_position["fuzzy"] = settings.get("fuzzy", False)
+    completions = document.jedi_script(use_document_path=True).complete(**code_position)
+
+    if not completions:
+        return None
+
+    completion_capabilities = config.capabilities.get("textDocument", {}).get(
+        "completion", {}
+    )
+    item_capabilities = completion_capabilities.get("completionItem", {})
+    snippet_support = item_capabilities.get("snippetSupport")
+    supported_markup_kinds = item_capabilities.get("documentationFormat", ["markdown"])
+    preferred_markup_kind = _utils.choose_markup_kind(supported_markup_kinds)
+
+    should_include_params = settings.get("include_params")
+    should_include_class_objects = settings.get("include_class_objects", False)
+    should_include_function_objects = settings.get("include_function_objects", False)
+
+    max_to_resolve = settings.get("resolve_at_most", 25)
+    modules_to_cache_for = settings.get("cache_for", None)
+    if modules_to_cache_for is not None:
+        LABEL_RESOLVER.cached_modules = modules_to_cache_for
+        SNIPPET_RESOLVER.cached_modules = modules_to_cache_for
+
+    include_params = (
+        snippet_support and should_include_params and use_snippets(document, position)
+    )
+    include_class_objects = (
+        snippet_support
+        and should_include_class_objects
+        and use_snippets(document, position)
+    )
+    include_function_objects = (
+        snippet_support
+        and should_include_function_objects
+        and use_snippets(document, position)
+    )
+
+    ready_completions = [
+        _format_completion(
+            c,
+            markup_kind=preferred_markup_kind,
+            include_params=include_params if c.type in ["class", "function"] else False,
+            resolve=resolve_eagerly,
+            resolve_label_or_snippet=(i < max_to_resolve),
+            snippet_support=snippet_support,
+        )
+        for i, c in enumerate(completions)
+    ]
+
+    # TODO split up once other improvements are merged
+    if include_class_objects:
+        for i, c in enumerate(completions):
+            if c.type == "class":
+                completion_dict = _format_completion(
+                    c,
+                    markup_kind=preferred_markup_kind,
+                    include_params=False,
+                    resolve=resolve_eagerly,
+                    resolve_label_or_snippet=(i < max_to_resolve),
+                    snippet_support=snippet_support,
+                )
+                completion_dict["kind"] = lsp.CompletionItemKind.TypeParameter
+                completion_dict["label"] += " object"
+                ready_completions.append(completion_dict)
+
+    if include_function_objects:
+        for i, c in enumerate(completions):
+            if c.type == "function":
+                completion_dict = _format_completion(
+                    c,
+                    markup_kind=preferred_markup_kind,
+                    include_params=False,
+                    resolve=resolve_eagerly,
+                    resolve_label_or_snippet=(i < max_to_resolve),
+                    snippet_support=snippet_support,
+                )
+                completion_dict["kind"] = lsp.CompletionItemKind.TypeParameter
+                completion_dict["label"] += " object"
+                ready_completions.append(completion_dict)
+
+    for completion_dict in ready_completions:
+        completion_dict["data"] = {"doc_uri": document.uri}
+
+    # most recently retrieved completion items, used for resolution
+    document.shared_data["LAST_JEDI_COMPLETIONS"] = {
+        # label is the only required property; here it is assumed to be unique
+        completion["label"]: (completion, data)
+        for completion, data in zip(ready_completions, completions)
+    }
+
+    return ready_completions or None
+
+@hookimpl
+def pylsp_completion_detail(config, item):
+    d = COMPLETION_CACHE.get(item)
+    if d:
+      completion = {
+        'label': '', #_label(d),
+        'kind': _TYPE_MAP.get(d.type),
+        'detail': '', #_detail(d),
+        'documentation': _utils.format_docstring(d.docstring()),
+        'sortText': '', #_sort_text(d),
+        'insertText': d.name
+      }
+      return completion
+    else:
+      log.info('Completion missing')
+      return None
+
+@hookimpl
+def pylsp_completion_item_resolve(config, completion_item, document):
+    """Resolve formatted completion for given non-resolved completion"""
+    shared_data = document.shared_data["LAST_JEDI_COMPLETIONS"].get(
+        completion_item["label"]
+    )
+
+    completion_capabilities = config.capabilities.get("textDocument", {}).get(
+        "completion", {}
+    )
+    item_capabilities = completion_capabilities.get("completionItem", {})
+    supported_markup_kinds = item_capabilities.get("documentationFormat", ["markdown"])
+    preferred_markup_kind = _utils.choose_markup_kind(supported_markup_kinds)
+
+    if shared_data:
+        completion, data = shared_data
+        return _resolve_completion(completion, data, markup_kind=preferred_markup_kind)
+    return completion_item
+
+
+def is_exception_class(name):
+    """
+    Determine if a class name is an instance of an Exception.
+
+    This returns `False` if the name given corresponds with a instance of
+    the 'Exception' class, `True` otherwise
+    """
+    try:
+        return name in [cls.__name__ for cls in Exception.__subclasses__()]
+    except AttributeError:
+        # Needed in case a class don't uses new-style
+        # class definition in Python 2
+        return False
+
+
+def use_snippets(document, position):
+    """
+    Determine if it's necessary to return snippets in code completions.
+
+    This returns `False` if a completion is being requested on an import
+    statement, `True` otherwise.
+    """
+    line = position["line"]
+    lines = document.source.split("\n", line)
+    act_lines = [lines[line][: position["character"]]]
+    line -= 1
+    last_character = ""
+    while line > -1:
+        act_line = lines[line]
+        if (
+            act_line.rstrip().endswith("\\")
+            or act_line.rstrip().endswith("(")
+            or act_line.rstrip().endswith(",")
+        ):
+            act_lines.insert(0, act_line)
+            line -= 1
+            if act_line.rstrip().endswith("("):
+                # Needs to be added to the end of the code before parsing
+                # to make it valid, otherwise the node type could end
+                # being an 'error_node' for multi-line imports that use '('
+                last_character = ")"
+        else:
+            break
+    if "(" in act_lines[-1].strip():
+        last_character = ")"
+    code = "\n".join(act_lines).rsplit(";", maxsplit=1)[-1].strip() + last_character
+    tokens = parso.parse(code)
+    expr_type = tokens.children[0].type
+    return expr_type not in _IMPORTS and not (expr_type in _ERRORS and "import" in code)
+
+
+def _resolve_completion(completion, d, markup_kind: str):
+    completion["detail"] = _detail(d)
+    try:
+        docs = _utils.format_docstring(
+            d.docstring(raw=True),
+            signatures=[signature.to_string() for signature in d.get_signatures()],
+            markup_kind=markup_kind,
+        )
+    except Exception:
+        docs = ""
+    completion["documentation"] = docs
+    return completion
+
+
+def _format_completion(
+    d,
+    markup_kind: str,
+    include_params=True,
+    resolve=False,
+    resolve_label_or_snippet=False,
+    snippet_support=False,
+):
+    COMPLETION_CACHE[d.name] = d
+    completion = {
+        "label": _label(d, resolve_label_or_snippet),
+        "kind": _TYPE_MAP.get(d.type),
+        "sortText": _sort_text(d),
+        "insertText": d.name,
+    }
+
+    if resolve:
+        completion = _resolve_completion(completion, d, markup_kind)
+
+    # Adjustments for file completions
+    if d.type == "path":
+        path = os.path.normpath(d.name)
+
+        # If the completion ends with os.sep, it means it's a directory. So we add os.sep at the end
+        # to ease additional file completions.
+        if d.name.endswith(os.sep):
+            if os.name == "nt":
+                path = path + "\\"
+            else:
+                path = path + "/"
+
+        # Escape to prevent conflicts with the code snippets grammer
+        # See also https://github.com/python-lsp/python-lsp-server/issues/373
+        if snippet_support:
+            path = path.replace("\\", "\\\\")
+            path = path.replace("/", "\\/")
+
+        completion["insertText"] = path
+
+    if include_params and not is_exception_class(d.name):
+        snippet = _snippet(d, resolve_label_or_snippet)
+        completion.update(snippet)
+
+    return completion
+
+
+def _label(definition, resolve=False):
+    if not resolve:
+        return definition.name
+    sig = LABEL_RESOLVER.get_or_create(definition)
+    if sig:
+        return sig
+    return definition.name
+
+
+def _snippet(definition, resolve=False):
+    if not resolve:
+        return {}
+    snippet = SNIPPET_RESOLVER.get_or_create(definition)
+    return snippet
+
+
+def _detail(definition):
+    try:
+        return definition.parent().full_name or ""
+    except AttributeError:
+        return definition.full_name or ""
+
+
+def _sort_text(definition):
+    """Ensure builtins appear at the bottom.
+    Description is of format <type>: <module>.<item>
+    """
+
+    # If its 'hidden', put it next last
+    prefix = "z{}" if definition.name.startswith("_") else "a{}"
+    return prefix.format(definition.name)

pylsp/plugins/jedi_rename.py

@@ -0,0 +1,56 @@
+# 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_rename(config, workspace, document, position, new_name):
+    log.debug(
+        "Executing rename of %s to %s", document.word_at_position(position), new_name
+    )
+    kwargs = _utils.position_to_jedi_linecolumn(document, position)
+    kwargs["new_name"] = new_name
+    try:
+        refactoring = document.jedi_script().rename(**kwargs)
+    except NotImplementedError as exc:
+        raise Exception(
+            "No support for renaming in Python 2/3.5 with Jedi. "
+            "Consider using the pylsp-rope plugin instead"
+        ) from exc
+    log.debug("Finished rename: %s", refactoring.get_diff())
+    changes = []
+
+    changed_files = refactoring.get_changed_files()
+    for file_path, changed_file in changed_files.items():
+        uri = uris.from_fs_path(str(file_path))
+        doc = workspace.get_maybe_document(uri)
+        changes.append(
+            {
+                "textDocument": {"uri": uri, "version": doc.version if doc else None},
+                "edits": [
+                    {
+                        "range": {
+                            "start": {"line": 0, "character": 0},
+                            "end": {
+                                "line": _num_lines(changed_file.get_new_code()),
+                                "character": 0,
+                            },
+                        },
+                        "newText": changed_file.get_new_code(),
+                    }
+                ],
+            }
+        )
+    return {"documentChanges": changes}
+
+
+def _num_lines(file_contents):
+    "Count the number of lines in the given string."
+    if _utils.get_eol_chars(file_contents):
+        return len(file_contents.splitlines())
+    return 0

pylsp/plugins/mccabe_lint.py

@@ -0,0 +1,56 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import ast
+import logging
+
+import mccabe
+
+from pylsp import hookimpl, lsp
+
+log = logging.getLogger(__name__)
+
+THRESHOLD = "threshold"
+DEFAULT_THRESHOLD = 15
+
+
+@hookimpl
+def pylsp_lint(config, workspace, document):
+    with workspace.report_progress("lint: mccabe"):
+        threshold = config.plugin_settings("mccabe", document_path=document.path).get(
+            THRESHOLD, DEFAULT_THRESHOLD
+        )
+        log.debug("Running mccabe lint with threshold: %s", threshold)
+
+        try:
+            tree = compile(document.source, document.path, "exec", ast.PyCF_ONLY_AST)
+        except SyntaxError:
+            # We'll let the other linters point this one out
+            return None
+
+        visitor = mccabe.PathGraphingAstVisitor()
+        visitor.preorder(tree, visitor)
+
+        diags = []
+        for graph in visitor.graphs.values():
+            if graph.complexity() >= threshold:
+                diags.append(
+                    {
+                        "source": "mccabe",
+                        "range": {
+                            "start": {
+                                "line": graph.lineno - 1,
+                                "character": graph.column,
+                            },
+                            "end": {
+                                "line": graph.lineno - 1,
+                                "character": len(document.lines[graph.lineno]),
+                            },
+                        },
+                        "message": "Cyclomatic complexity too high: %s (threshold %s)"
+                        % (graph.complexity(), threshold),
+                        "severity": lsp.DiagnosticSeverity.Warning,
+                    }
+                )
+
+        return diags

pylsp/plugins/preload_imports.py

@@ -0,0 +1,38 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import logging
+
+from pylsp import hookimpl
+
+log = logging.getLogger(__name__)
+
+MODULES = [
+    "numpy", "tensorflow", "sklearn", "array", "binascii", "cmath", "collections",
+    "datetime", "errno", "exceptions", "gc", "imageop", "imp", "itertools",
+    "marshal", "math", "matplotlib", "mmap", "mpmath", "msvcrt", "networkx", "nose", "nt",
+    "operator", "os", "os.path", "pandas", "parser", "scipy", "signal",
+    "skimage", "statsmodels", "strop", "sympy", "sys", "thread", "time", "wx", "zlib"
+]
+
+
+@hookimpl
+def pylsp_settings():
+    # Setup default modules to preload, and rope extension modules
+    return {
+        "plugins": {"preload": {"modules": MODULES}},
+        "rope": {"extensionModules": MODULES},
+    }
+
+
+@hookimpl
+def pylsp_initialize(config) -> None:
+    for mod_name in config.plugin_settings("preload").get("modules", []):
+        try:
+            __import__(mod_name)
+            log.debug("Preloaded module %s", mod_name)
+        except Exception:
+            # Catch any exception since not only ImportError can be raised here
+            # For example, old versions of NumPy can cause a ValueError.
+            # See spyder-ide/spyder#13985
+            pass

pylsp/plugins/pycodestyle_lint.py

@@ -0,0 +1,113 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import logging
+
+import pycodestyle
+
+from pylsp import hookimpl, lsp
+from pylsp._utils import get_eol_chars
+
+try:
+    from autopep8 import continued_indentation as autopep8_c_i
+except ImportError:
+    pass
+else:
+    # Check if autopep8's continued_indentation implementation
+    # is overriding pycodestyle's and if so, re-register
+    # the check using pycodestyle's implementation as expected
+    if autopep8_c_i in pycodestyle._checks["logical_line"]:
+        del pycodestyle._checks["logical_line"][autopep8_c_i]
+        pycodestyle.register_check(pycodestyle.continued_indentation)
+
+log = logging.getLogger(__name__)
+
+
+@hookimpl
+def pylsp_lint(workspace, document):
+    with workspace.report_progress("lint: pycodestyle"):
+        config = workspace._config
+        settings = config.plugin_settings("pycodestyle", document_path=document.path)
+        log.debug("Got pycodestyle settings: %s", settings)
+
+        opts = {
+            "exclude": settings.get("exclude"),
+            "filename": settings.get("filename"),
+            "hang_closing": settings.get("hangClosing"),
+            "ignore": settings.get("ignore"),
+            "max_line_length": settings.get("maxLineLength"),
+            "indent_size": settings.get("indentSize"),
+            "select": settings.get("select"),
+        }
+        kwargs = {k: v for k, v in opts.items() if v}
+        styleguide = pycodestyle.StyleGuide(kwargs)
+
+        # Use LF to lint file because other line endings can give false positives.
+        # See spyder-ide/spyder#19565 for context.
+        source = document.source
+        eol_chars = get_eol_chars(source)
+        if eol_chars in ["\r", "\r\n"]:
+            source = source.replace(eol_chars, "\n")
+            lines = source.splitlines(keepends=True)
+        else:
+            lines = document.lines
+
+        c = pycodestyle.Checker(
+            filename=document.path,
+            lines=lines,
+            options=styleguide.options,
+            report=PyCodeStyleDiagnosticReport(styleguide.options),
+        )
+        c.check_all()
+        diagnostics = c.report.diagnostics
+
+        return diagnostics
+
+
+class PyCodeStyleDiagnosticReport(pycodestyle.BaseReport):
+    def __init__(self, options) -> None:
+        self.diagnostics = []
+        super().__init__(options=options)
+
+    def error(self, line_number, offset, text, check):
+        code = text[:4]
+        if self._ignore_code(code):
+            return
+
+        # Don't care about expected errors or warnings
+        if code in self.expected:
+            return
+
+        # PyCodeStyle will sometimes give you an error the line after the end of the file
+        #   e.g. no newline at end of file
+        # In that case, the end offset should just be some number ~100
+        # (because why not? There's nothing to underline anyways)
+        err_range = {
+            "start": {"line": line_number - 1, "character": offset},
+            "end": {
+                # FIXME: It's a little naiive to mark until the end of the line, can we not easily do better?
+                "line": line_number - 1,
+                "character": 100
+                if line_number > len(self.lines)
+                else len(self.lines[line_number - 1]),
+            },
+        }
+        diagnostic = {
+            "source": "pycodestyle",
+            "range": err_range,
+            "message": text,
+            "code": code,
+            # Are style errors really ever errors?
+            "severity": _get_severity(code),
+        }
+        if code.startswith("W6"):
+            diagnostic["tags"] = [lsp.DiagnosticTag.Deprecated]
+        self.diagnostics.append(diagnostic)
+
+
+def _get_severity(code):
+    # Are style errors ever really errors?
+    if code[0] == "E" or code[0] == "W":
+        return lsp.DiagnosticSeverity.Warning
+    # If no severity is specified, why wouldn't this be informational only?
+    return lsp.DiagnosticSeverity.Information