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

pylsp/config/source.py

@@ -0,0 +1,88 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import configparser
+import logging
+import os
+import sys
+
+log = logging.getLogger(__name__)
+
+
+class ConfigSource:
+    """Base class for implementing a config source."""
+
+    def __init__(self, root_path) -> None:
+        self.root_path = root_path
+        self.is_windows = sys.platform == "win32"
+        self.xdg_home = os.environ.get(
+            "XDG_CONFIG_HOME", os.path.expanduser("~/.config")
+        )
+
+    def user_config(self) -> None:
+        """Return user-level (i.e. home directory) configuration."""
+        raise NotImplementedError()
+
+    def project_config(self, document_path) -> None:
+        """Return project-level (i.e. workspace directory) configuration."""
+        raise NotImplementedError()
+
+    @classmethod
+    def read_config_from_files(cls, files):
+        config = configparser.RawConfigParser()
+        for filename in files:
+            if os.path.exists(filename) and not os.path.isdir(filename):
+                config.read(filename)
+
+        return config
+
+    @classmethod
+    def parse_config(cls, config, key, options):
+        """Parse the config with the given options."""
+        conf = {}
+        for source, destination, opt_type in options:
+            opt_value = cls._get_opt(config, key, source, opt_type)
+            if opt_value is not None:
+                cls._set_opt(conf, destination, opt_value)
+        return conf
+
+    @classmethod
+    def _get_opt(cls, config, key, option, opt_type):
+        """Get an option from a configparser with the given type."""
+        for opt_key in [option, option.replace("-", "_")]:
+            if not config.has_option(key, opt_key):
+                continue
+
+            if opt_type is bool:
+                return config.getboolean(key, opt_key)
+
+            if opt_type is int:
+                return config.getint(key, opt_key)
+
+            if opt_type is str:
+                return config.get(key, opt_key)
+
+            if opt_type is list:
+                return cls._parse_list_opt(config.get(key, opt_key))
+
+            raise ValueError("Unknown option type: %s" % opt_type)
+
+    @classmethod
+    def _parse_list_opt(cls, string):
+        return [s.strip() for s in string.split(",") if s.strip()]
+
+    @classmethod
+    def _set_opt(cls, config_dict, path, value):
+        """Set the value in the dictionary at the given path if the value is not None."""
+        if value is None:
+            return
+
+        if "." not in path:
+            config_dict[path] = value
+            return
+
+        key, rest = path.split(".", 1)
+        if key not in config_dict:
+            config_dict[key] = {}
+
+        cls._set_opt(config_dict[key], rest, value)

pylsp/hookspecs.py

@@ -0,0 +1,140 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+from pylsp import hookspec
+
+
+@hookspec
+def pylsp_code_actions(config, workspace, document, range, context):
+    pass
+
+
+@hookspec
+def pylsp_code_lens(config, workspace, document) -> None:
+    pass
+
+
+@hookspec
+def pylsp_commands(config, workspace) -> None:
+    """The list of command strings supported by the server.
+
+    Returns:
+        List[str]: The supported commands.
+    """
+
+
+@hookspec
+def pylsp_completions(config, workspace, document, position, ignored_names) -> None:
+    pass
+
+
+@hookspec
+def pylsp_completion_detail(config, item) -> None:
+    pass
+
+
+@hookspec(firstresult=True)
+def pylsp_completion_item_resolve(config, workspace, document, completion_item) -> None:
+    pass
+
+
+@hookspec
+def pylsp_definitions(config, workspace, document, position) -> None:
+    pass
+
+
+@hookspec
+def pylsp_dispatchers(config, workspace) -> None:
+    pass
+
+
+@hookspec
+def pylsp_document_did_open(config, workspace, document) -> None:
+    pass
+
+
+@hookspec
+def pylsp_document_did_save(config, workspace, document) -> None:
+    pass
+
+
+@hookspec
+def pylsp_document_highlight(config, workspace, document, position) -> None:
+    pass
+
+
+@hookspec
+def pylsp_document_symbols(config, workspace, document) -> None:
+    pass
+
+
+@hookspec(firstresult=True)
+def pylsp_execute_command(config, workspace, command, arguments) -> None:
+    pass
+
+
+@hookspec
+def pylsp_experimental_capabilities(config, workspace) -> None:
+    pass
+
+
+@hookspec
+def pylsp_folding_range(config, workspace, document) -> None:
+    pass
+
+
+@hookspec(firstresult=True)
+def pylsp_format_document(config, workspace, document, options) -> None:
+    pass
+
+
+@hookspec(firstresult=True)
+def pylsp_format_range(config, workspace, document, range, options) -> None:
+    pass
+
+
+@hookspec(firstresult=True)
+def pylsp_hover(config, workspace, document, position) -> None:
+    pass
+
+
+@hookspec
+def pylsp_initialize(config, workspace) -> None:
+    pass
+
+
+@hookspec
+def pylsp_initialized() -> None:
+    pass
+
+
+@hookspec
+def pylsp_lint(config, workspace, document, is_saved) -> None:
+    pass
+
+
+@hookspec
+def pylsp_references(
+    config, workspace, document, position, exclude_declaration
+) -> None:
+    pass
+
+
+@hookspec(firstresult=True)
+def pylsp_rename(config, workspace, document, position, new_name) -> None:
+    pass
+
+
+@hookspec
+def pylsp_settings(config) -> None:
+    pass
+
+
+@hookspec(firstresult=True)
+def pylsp_signature_help(config, workspace, document, position) -> None:
+    pass
+
+
+@hookspec
+def pylsp_workspace_configuration_changed(config, workspace) -> None:
+    pass

pylsp/lsp.py

@@ -0,0 +1,115 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+"""Some Language Server Protocol constants
+
+https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md
+"""
+
+
+class CompletionItemKind:
+    Text = 1
+    Method = 2
+    Function = 3
+    Constructor = 4
+    Field = 5
+    Variable = 6
+    Class = 7
+    Interface = 8
+    Module = 9
+    Property = 10
+    Unit = 11
+    Value = 12
+    Enum = 13
+    Keyword = 14
+    Snippet = 15
+    Color = 16
+    File = 17
+    Reference = 18
+    Folder = 19
+    EnumMember = 20
+    Constant = 21
+    Struct = 22
+    Event = 23
+    Operator = 24
+    TypeParameter = 25
+
+
+class DocumentHighlightKind:
+    Text = 1
+    Read = 2
+    Write = 3
+
+
+class DiagnosticSeverity:
+    Error = 1
+    Warning = 2
+    Information = 3
+    Hint = 4
+
+
+class DiagnosticTag:
+    Unnecessary = 1
+    Deprecated = 2
+
+
+class InsertTextFormat:
+    PlainText = 1
+    Snippet = 2
+
+
+class MessageType:
+    Error = 1
+    Warning = 2
+    Info = 3
+    Log = 4
+
+
+class SymbolKind:
+    File = 1
+    Module = 2
+    Namespace = 3
+    Package = 4
+    Class = 5
+    Method = 6
+    Property = 7
+    Field = 8
+    Constructor = 9
+    Enum = 10
+    Interface = 11
+    Function = 12
+    Variable = 13
+    Constant = 14
+    String = 15
+    Number = 16
+    Boolean = 17
+    Array = 18
+
+
+class TextDocumentSyncKind:
+    NONE = 0
+    FULL = 1
+    INCREMENTAL = 2
+
+
+class NotebookCellKind:
+    Markup = 1
+    Code = 2
+
+
+# https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#errorCodes
+class ErrorCodes:
+    ParseError = -32700
+    InvalidRequest = -32600
+    MethodNotFound = -32601
+    InvalidParams = -32602
+    InternalError = -32603
+    jsonrpcReservedErrorRangeStart = -32099
+    ServerNotInitialized = -32002
+    UnknownErrorCode = -32001
+    jsonrpcReservedErrorRangeEnd = -32000
+    lspReservedErrorRangeStart = -32899
+    ServerCancelled = -32802
+    ContentModified = -32801
+    RequestCancelled = -32800
+    lspReservedErrorRangeEnd = -32800

pylsp/plugins/__init__.py

@@ -0,0 +1,2 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.

pylsp/plugins/_resolvers.py

@@ -0,0 +1,132 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import logging
+from collections import defaultdict
+from time import time
+
+from jedi.api.classes import Completion
+
+from pylsp import lsp
+
+log = logging.getLogger(__name__)
+
+
+# ---- Base class
+# -----------------------------------------------------------------------------
+class Resolver:
+    def __init__(self, callback, resolve_on_error, time_to_live=60 * 30) -> None:
+        self.callback = callback
+        self.resolve_on_error = resolve_on_error
+        self._cache = {}
+        self._time_to_live = time_to_live
+        self._cache_ttl = defaultdict(set)
+        self._clear_every = 2
+        # see https://github.com/davidhalter/jedi/blob/master/jedi/inference/helpers.py#L194-L202
+        self._cached_modules = {"pandas", "numpy", "tensorflow", "matplotlib"}
+
+    @property
+    def cached_modules(self):
+        return self._cached_modules
+
+    @cached_modules.setter
+    def cached_modules(self, new_value):
+        self._cached_modules = set(new_value)
+
+    def clear_outdated(self) -> None:
+        now = self.time_key()
+        to_clear = [timestamp for timestamp in self._cache_ttl if timestamp < now]
+        for time_key in to_clear:
+            for key in self._cache_ttl[time_key]:
+                del self._cache[key]
+            del self._cache_ttl[time_key]
+
+    def time_key(self):
+        return int(time() / self._time_to_live)
+
+    def get_or_create(self, completion: Completion):
+        if not completion.full_name:
+            use_cache = False
+        else:
+            module_parts = completion.full_name.split(".")
+            use_cache = module_parts and module_parts[0] in self._cached_modules
+
+        if use_cache:
+            key = self._create_completion_id(completion)
+            if key not in self._cache:
+                if self.time_key() % self._clear_every == 0:
+                    self.clear_outdated()
+
+                self._cache[key] = self.resolve(completion)
+                self._cache_ttl[self.time_key()].add(key)
+            return self._cache[key]
+
+        return self.resolve(completion)
+
+    def _create_completion_id(self, completion: Completion):
+        return (
+            completion.full_name,
+            completion.module_path,
+            completion.line,
+            completion.column,
+            self.time_key(),
+        )
+
+    def resolve(self, completion):
+        try:
+            sig = completion.get_signatures()
+            return self.callback(completion, sig)
+        except Exception as e:
+            log.warning(
+                f"Something went wrong when resolving label for {completion}: {e}"
+            )
+            return self.resolve_on_error
+
+
+# ---- Label resolver
+# -----------------------------------------------------------------------------
+def format_label(completion, sig):
+    if sig and completion.type in ("function", "method"):
+        params = ", ".join(param.name for param in sig[0].params)
+        label = "{}({})".format(completion.name, params)
+        return label
+    return completion.name
+
+
+LABEL_RESOLVER = Resolver(callback=format_label, resolve_on_error="")
+
+
+# ---- Snippets resolver
+# -----------------------------------------------------------------------------
+def format_snippet(completion, sig):
+    if not sig:
+        return {}
+
+    snippet_completion = {}
+
+    positional_args = [
+        param
+        for param in sig[0].params
+        if "=" not in param.description and param.name not in {"/", "*"}
+    ]
+
+    if len(positional_args) > 1:
+        # For completions with params, we can generate a snippet instead
+        snippet_completion["insertTextFormat"] = lsp.InsertTextFormat.Snippet
+        snippet = completion.name + "("
+        for i, param in enumerate(positional_args):
+            snippet += "${%s:%s}" % (i + 1, param.name)
+            if i < len(positional_args) - 1:
+                snippet += ", "
+        snippet += ")$0"
+        snippet_completion["insertText"] = snippet
+    elif len(positional_args) == 1:
+        snippet_completion["insertTextFormat"] = lsp.InsertTextFormat.Snippet
+        snippet_completion["insertText"] = completion.name + "($0)"
+    else:
+        snippet_completion["insertText"] = completion.name + "()"
+
+    return snippet_completion
+
+
+SNIPPET_RESOLVER = Resolver(callback=format_snippet, resolve_on_error={})

pylsp/plugins/_rope_task_handle.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import logging
+from typing import Callable, ContextManager, List, Optional, Sequence
+
+from rope.base.taskhandle import BaseJobSet, BaseTaskHandle
+
+from pylsp._utils import throttle
+from pylsp.workspace import Workspace
+
+log = logging.getLogger(__name__)
+Report = Callable[[str, int], None]
+
+
+class PylspJobSet(BaseJobSet):
+    count: int = 0
+    done: int = 0
+    _reporter: Report
+    _report_iter: ContextManager
+    job_name: str = ""
+
+    def __init__(self, count: Optional[int], report_iter: ContextManager) -> None:
+        if count is not None:
+            self.count = count
+        self._reporter = report_iter.__enter__()
+        self._report_iter = report_iter
+
+    def started_job(self, name: Optional[str]) -> None:
+        if name:
+            self.job_name = name
+
+    def finished_job(self) -> None:
+        self.done += 1
+        if self.get_percent_done() is not None and int(self.get_percent_done()) >= 100:
+            if self._report_iter is None:
+                return
+            self._report_iter.__exit__(None, None, None)
+            self._report_iter = None
+        else:
+            self._report()
+
+    def check_status(self) -> None:
+        pass
+
+    def get_percent_done(self) -> Optional[float]:
+        if self.count == 0:
+            return 0
+        return (self.done / self.count) * 100
+
+    def increment(self) -> None:
+        """
+        Increment the number of tasks to complete.
+
+        This is used if the number is not known ahead of time.
+        """
+        self.count += 1
+        self._report()
+
+    @throttle(0.5)
+    def _report(self) -> None:
+        percent = int(self.get_percent_done())
+        message = f"{self.job_name} {self.done}/{self.count}"
+        log.debug(f"Reporting {message} {percent}%")
+        self._reporter(message, percent)
+
+
+class PylspTaskHandle(BaseTaskHandle):
+    name: str
+    observers: List
+    job_sets: List[PylspJobSet]
+    stopped: bool
+    workspace: Workspace
+    _report: Callable[[str, str], None]
+
+    def __init__(self, workspace: Workspace) -> None:
+        self.workspace = workspace
+        self.job_sets = []
+        self.observers = []
+
+    def create_jobset(self, name="JobSet", count: Optional[int] = None):
+        report_iter = self.workspace.report_progress(
+            name, None, None, skip_token_initialization=True
+        )
+        result = PylspJobSet(count, report_iter)
+        self.job_sets.append(result)
+        self._inform_observers()
+        return result
+
+    def stop(self) -> None:
+        pass
+
+    def current_jobset(self) -> Optional[BaseJobSet]:
+        pass
+
+    def add_observer(self) -> None:
+        pass
+
+    def is_stopped(self) -> bool:
+        pass
+
+    def get_jobsets(self) -> Sequence[BaseJobSet]:
+        pass
+
+    def _inform_observers(self) -> None:
+        for observer in self.observers:
+            observer()

pylsp/plugins/autopep8_format.py

@@ -0,0 +1,95 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import logging
+
+import pycodestyle
+from autopep8 import continued_indentation as autopep8_c_i
+from autopep8 import fix_code
+
+from pylsp import hookimpl
+from pylsp._utils import get_eol_chars
+
+log = logging.getLogger(__name__)
+
+
+@hookimpl(tryfirst=True)  # Prefer autopep8 over YAPF
+def pylsp_format_document(config, workspace, document, options):
+    with workspace.report_progress("format: autopep8"):
+        log.info("Formatting document %s with autopep8", document)
+        return _format(config, document)
+
+
+@hookimpl(tryfirst=True)  # Prefer autopep8 over YAPF
+def pylsp_format_range(config, workspace, document, range, options):
+    log.info("Formatting document %s in range %s with autopep8", 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
+
+    # Add 1 for 1-indexing vs LSP's 0-indexing
+    line_range = (range["start"]["line"] + 1, range["end"]["line"])
+    return _format(config, document, line_range=line_range)
+
+
+def _format(config, document, line_range=None):
+    options = _autopep8_config(config, document)
+    if line_range:
+        options["line_range"] = list(line_range)
+
+    # Temporarily re-monkey-patch the continued_indentation checker - #771
+    del pycodestyle._checks["logical_line"][pycodestyle.continued_indentation]
+    pycodestyle.register_check(autopep8_c_i)
+
+    # Autopep8 doesn't work with CR line endings, so we replace them by '\n'
+    # and restore them below.
+    replace_cr = False
+    source = document.source
+    eol_chars = get_eol_chars(source)
+    if eol_chars == "\r":
+        replace_cr = True
+        source = source.replace("\r", "\n")
+
+    new_source = fix_code(source, options=options)
+
+    # Switch it back
+    del pycodestyle._checks["logical_line"][autopep8_c_i]
+    pycodestyle.register_check(pycodestyle.continued_indentation)
+
+    if new_source == source:
+        return []
+
+    if replace_cr:
+        new_source = new_source.replace("\n", "\r")
+
+    # I'm too lazy at the moment to parse diffs into TextEdit items
+    # So let's just return the entire file...
+    return [
+        {
+            "range": {
+                "start": {"line": 0, "character": 0},
+                # End char 0 of the line after our document
+                "end": {"line": len(document.lines), "character": 0},
+            },
+            "newText": new_source,
+        }
+    ]
+
+
+def _autopep8_config(config, document=None):
+    # We user pycodestyle settings to avoid redefining things
+    path = document.path if document is not None else None
+    settings = config.plugin_settings("pycodestyle", document_path=path)
+    options = {
+        "exclude": settings.get("exclude"),
+        "hang_closing": settings.get("hangClosing"),
+        "ignore": settings.get("ignore"),
+        "max_line_length": settings.get("maxLineLength"),
+        "select": settings.get("select"),
+        "aggressive": settings.get("aggressive"),
+    }
+
+    # Filter out null options
+    return {k: v for k, v in options.items() if v}