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

pylsp/plugins/symbols.py

@@ -0,0 +1,214 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import logging
+from pathlib import Path
+
+from pylsp import hookimpl
+from pylsp.lsp import SymbolKind
+
+log = logging.getLogger(__name__)
+
+
+@hookimpl
+def pylsp_document_symbols(config, document):
+    symbols_settings = config.plugin_settings("jedi_symbols")
+    all_scopes = symbols_settings.get("all_scopes", True)
+    add_import_symbols = symbols_settings.get("include_import_symbols", True)
+    definitions = document.jedi_names(all_scopes=all_scopes)
+    symbols = []
+    exclude = set({})
+    redefinitions = {}
+
+    while definitions != []:
+        d = definitions.pop(0)
+
+        # Skip symbols imported from other modules.
+        if not add_import_symbols:
+            # Skip if there's an import in the code the symbol is defined.
+            code = d.get_line_code()
+            if " import " in code or "import " in code:
+                continue
+
+            # Skip imported symbols comparing module names.
+            sym_full_name = d.full_name
+            if sym_full_name is not None:
+                document_dot_path = document.dot_path
+
+                # We assume a symbol is imported from another module to start
+                # with.
+                imported_symbol = True
+
+                # The last element of sym_full_name is the symbol itself, so
+                # we need to discard it to do module comparisons below.
+                if "." in sym_full_name:
+                    sym_module_name = sym_full_name.rpartition(".")[0]
+                else:
+                    sym_module_name = sym_full_name
+
+                # This is necessary to display symbols in init files (the checks
+                # below fail without it).
+                if document_dot_path.endswith("__init__"):
+                    document_dot_path = document_dot_path.rpartition(".")[0]
+
+                # document_dot_path is the module where the symbol is imported,
+                # whereas sym_module_name is the one where it was declared.
+                if document_dot_path in sym_module_name:
+                    # If document_dot_path is in sym_module_name, we can safely assume
+                    # that the symbol was declared in the document.
+                    imported_symbol = False
+                elif sym_module_name.split(".")[0] in document_dot_path.split("."):
+                    # If the first module in sym_module_name is one of the modules in
+                    # document_dot_path, we need to check if sym_module_name starts
+                    # with the modules in document_dot_path.
+                    document_mods = document_dot_path.split(".")
+                    for i in range(1, len(document_mods) + 1):
+                        submod = ".".join(document_mods[-i:])
+                        if sym_module_name.startswith(submod):
+                            imported_symbol = False
+                            break
+
+                # When there's no __init__.py next to a file or in one of its
+                # parents, the checks above fail. However, Jedi has a nice way
+                # to tell if the symbol was declared in the same file: if
+                # sym_module_name starts by __main__.
+                if imported_symbol:
+                    if not sym_module_name.startswith("__main__"):
+                        continue
+            else:
+                # We need to skip symbols if their definition doesn't have `full_name` info, they
+                # are detected as a definition, but their description (e.g. `class Foo`) doesn't
+                # match the code where they're detected by Jedi. This happens for relative imports.
+                if _include_def(d):
+                    if d.description not in d.get_line_code():
+                        continue
+                else:
+                    continue
+
+        if _include_def(d) and Path(document.path) == Path(d.module_path):
+            tuple_range = _tuple_range(d)
+            if tuple_range in exclude:
+                continue
+
+            kind = redefinitions.get(tuple_range, None)
+            if kind is not None:
+                exclude |= {tuple_range}
+
+            if d.type == "statement":
+                if d.description.startswith("self"):
+                    kind = "field"
+
+            symbol = {
+                "name": d.name,
+                "containerName": _container(d),
+                "location": {
+                    "uri": document.uri,
+                    "range": _range(d),
+                },
+                "kind": _kind(d) if kind is None else _SYMBOL_KIND_MAP[kind],
+            }
+            symbols.append(symbol)
+
+            if d.type == "class":
+                try:
+                    defined_names = list(d.defined_names())
+                    for method in defined_names:
+                        if method.type == "function":
+                            redefinitions[_tuple_range(method)] = "method"
+                        elif method.type == "statement":
+                            redefinitions[_tuple_range(method)] = "field"
+                        else:
+                            redefinitions[_tuple_range(method)] = method.type
+                    definitions = list(defined_names) + definitions
+                except Exception:
+                    pass
+    return symbols
+
+
+def _include_def(definition):
+    return (
+        # Don't tend to include parameters as symbols
+        definition.type != "param"
+        and
+        # Unused vars should also be skipped
+        definition.name != "_"
+        and _kind(definition) is not None
+    )
+
+
+def _container(definition):
+    try:
+        # Jedi sometimes fails here.
+        parent = definition.parent()
+        # Here we check that a grand-parent exists to avoid declaring symbols
+        # as children of the module.
+        if parent.parent():
+            return parent.name
+    except:
+        return None
+
+    return None
+
+
+def _range(definition):
+    # This gets us more accurate end position
+    definition = definition._name.tree_name.get_definition()
+    (start_line, start_column) = definition.start_pos
+    (end_line, end_column) = definition.end_pos
+    return {
+        "start": {"line": start_line - 1, "character": start_column},
+        "end": {"line": end_line - 1, "character": end_column},
+    }
+
+
+def _tuple_range(definition):
+    definition = definition._name.tree_name.get_definition()
+    return (definition.start_pos, definition.end_pos)
+
+
+_SYMBOL_KIND_MAP = {
+    "none": SymbolKind.Variable,
+    "type": SymbolKind.Class,
+    "tuple": SymbolKind.Class,
+    "dict": SymbolKind.Class,
+    "dictionary": SymbolKind.Class,
+    "function": SymbolKind.Function,
+    "lambda": SymbolKind.Function,
+    "generator": SymbolKind.Function,
+    "class": SymbolKind.Class,
+    "instance": SymbolKind.Class,
+    "method": SymbolKind.Method,
+    "builtin": SymbolKind.Class,
+    "builtinfunction": SymbolKind.Function,
+    "module": SymbolKind.Module,
+    "file": SymbolKind.File,
+    "xrange": SymbolKind.Array,
+    "slice": SymbolKind.Class,
+    "traceback": SymbolKind.Class,
+    "frame": SymbolKind.Class,
+    "buffer": SymbolKind.Array,
+    "dictproxy": SymbolKind.Class,
+    "funcdef": SymbolKind.Function,
+    "property": SymbolKind.Property,
+    "import": SymbolKind.Module,
+    "keyword": SymbolKind.Variable,
+    "constant": SymbolKind.Constant,
+    "variable": SymbolKind.Variable,
+    "value": SymbolKind.Variable,
+    "param": SymbolKind.Variable,
+    "statement": SymbolKind.Variable,
+    "boolean": SymbolKind.Boolean,
+    "int": SymbolKind.Number,
+    "longlean": SymbolKind.Number,
+    "float": SymbolKind.Number,
+    "complex": SymbolKind.Number,
+    "string": SymbolKind.String,
+    "unicode": SymbolKind.String,
+    "list": SymbolKind.Array,
+    "field": SymbolKind.Field,
+}
+
+
+def _kind(d):
+    """Return the VSCode Symbol Type"""
+    return _SYMBOL_KIND_MAP.get(d.type)

pylsp/plugins/yapf_format.py

@@ -0,0 +1,199 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import logging
+import os
+
+import whatthepatch
+from yapf.yapflib import file_resources, style
+from yapf.yapflib.yapf_api import FormatCode
+
+from pylsp import hookimpl
+from pylsp._utils import get_eol_chars
+
+log = logging.getLogger(__name__)
+
+
+@hookimpl
+def pylsp_format_document(workspace, document, options):
+    log.info("Formatting document %s with yapf", document)
+    with workspace.report_progress("format: yapf"):
+        return _format(document, options=options)
+
+
+@hookimpl
+def pylsp_format_range(document, range, options):
+    log.info("Formatting document %s in range %s with yapf", document, range)
+    # First we 'round' the range up/down to full lines only
+    range["start"]["character"] = 0
+    range["end"]["line"] += 1
+    range["end"]["character"] = 0
+
+    # From Yapf docs:
+    # lines: (list of tuples of integers) A list of tuples of lines, [start, end],
+    #   that we want to format. The lines are 1-based indexed. It can be used by
+    #   third-party code (e.g., IDEs) when reformatting a snippet of code rather
+    #   than a whole file.
+
+    # Add 1 for 1-indexing vs LSP's 0-indexing
+    lines = [(range["start"]["line"] + 1, range["end"]["line"] + 1)]
+    return _format(document, lines=lines, options=options)
+
+
+def get_style_config(document_path, options=None):
+    # Exclude file if it follows the patterns for that
+    exclude_patterns_from_ignore_file = file_resources.GetExcludePatternsForDir(
+        os.getcwd()
+    )
+    if file_resources.IsIgnored(document_path, exclude_patterns_from_ignore_file):
+        return []
+
+    # Get the default styles as a string
+    # for a preset configuration, i.e. "pep8"
+    style_config = file_resources.GetDefaultStyleForDir(os.path.dirname(document_path))
+    if options is None:
+        return style_config
+
+    # We have options passed from LSP format request
+    # let's pass them to the formatter.
+    # First we want to get a dictionary of the preset style
+    # to pass instead of a string so that we can modify it
+    style_config = style.CreateStyleFromConfig(style_config)
+
+    use_tabs = style_config["USE_TABS"]
+    indent_width = style_config["INDENT_WIDTH"]
+
+    if options.get("tabSize") is not None:
+        indent_width = max(int(options.get("tabSize")), 1)
+
+    if options.get("insertSpaces") is not None:
+        # TODO is it guaranteed to be a boolean, or can it be a string?
+        use_tabs = not options.get("insertSpaces")
+
+        if use_tabs:
+            # Indent width doesn't make sense when using tabs
+            # the specifications state: "Size of a tab in spaces"
+            indent_width = 1
+
+    style_config["USE_TABS"] = use_tabs
+    style_config["INDENT_WIDTH"] = indent_width
+    style_config["CONTINUATION_INDENT_WIDTH"] = indent_width
+
+    for style_option, value in options.items():
+        # Apply arbitrary options passed as formatter options
+        if style_option not in style_config:
+            # ignore if it's not a known yapf config
+            continue
+
+        style_config[style_option] = value
+
+    return style_config
+
+
+def diff_to_text_edits(diff, eol_chars):
+    # To keep things simple our text edits will be line based.
+    # We will also return the edits uncompacted, meaning a
+    # line replacement will come in as a line remove followed
+    # by a line add instead of a line replace.
+    text_edits = []
+    # keep track of line number since additions
+    # don't include the line number it's being added
+    # to in diffs. lsp is 0-indexed so we'll start with -1
+    prev_line_no = -1
+
+    for change in diff.changes:
+        if change.old and change.new:
+            # old and new are the same line, no change
+            # diffs are 1-indexed
+            prev_line_no = change.old - 1
+        elif change.new:
+            # addition
+            text_edits.append(
+                {
+                    "range": {
+                        "start": {"line": prev_line_no + 1, "character": 0},
+                        "end": {"line": prev_line_no + 1, "character": 0},
+                    },
+                    "newText": change.line + eol_chars,
+                }
+            )
+        elif change.old:
+            # remove
+            lsp_line_no = change.old - 1
+            text_edits.append(
+                {
+                    "range": {
+                        "start": {"line": lsp_line_no, "character": 0},
+                        "end": {
+                            # From LSP spec:
+                            # If you want to specify a range that contains a line
+                            # including the line ending character(s) then use an
+                            # end position denoting the start of the next line.
+                            "line": lsp_line_no + 1,
+                            "character": 0,
+                        },
+                    },
+                    "newText": "",
+                }
+            )
+            prev_line_no = lsp_line_no
+
+    return text_edits
+
+
+def ensure_eof_new_line(document, eol_chars, text_edits):
+    # diffs don't include EOF newline https://github.com/google/yapf/issues/1008
+    # we'll add it ourselves if our document doesn't already have it and the diff
+    # does not change the last line.
+    if document.source.endswith(eol_chars):
+        return
+
+    lines = document.lines
+    last_line_number = len(lines) - 1
+
+    if text_edits and text_edits[-1]["range"]["start"]["line"] >= last_line_number:
+        return
+
+    text_edits.append(
+        {
+            "range": {
+                "start": {"line": last_line_number, "character": 0},
+                "end": {"line": last_line_number + 1, "character": 0},
+            },
+            "newText": lines[-1] + eol_chars,
+        }
+    )
+
+
+def _format(document, lines=None, options=None):
+    source = document.source
+    # Yapf doesn't work with CRLF/CR line endings, so we replace them by '\n'
+    # and restore them below when adding new lines
+    eol_chars = get_eol_chars(source)
+    if eol_chars in ["\r", "\r\n"]:
+        source = source.replace(eol_chars, "\n")
+    else:
+        eol_chars = "\n"
+
+    style_config = get_style_config(document_path=document.path, options=options)
+
+    diff_txt, changed = FormatCode(
+        source,
+        lines=lines,
+        filename=document.filename,
+        print_diff=True,
+        style_config=style_config,
+    )
+
+    if not changed:
+        return []
+
+    patch_generator = whatthepatch.parse_patch(diff_txt)
+    diff = next(patch_generator)
+    patch_generator.close()
+
+    text_edits = diff_to_text_edits(diff=diff, eol_chars=eol_chars)
+
+    ensure_eof_new_line(document=document, eol_chars=eol_chars, text_edits=text_edits)
+
+    return text_edits