deepnote-python-lsp-server 1.13.1rc2__py3-none-any.whl

pylsp/config/pycodestyle_conf.py

@@ -0,0 +1,34 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import pycodestyle
+
+from pylsp._utils import find_parents
+
+from .source import ConfigSource
+
+CONFIG_KEY = "pycodestyle"
+USER_CONFIGS = [pycodestyle.USER_CONFIG] if pycodestyle.USER_CONFIG else []
+PROJECT_CONFIGS = ["pycodestyle.cfg", "setup.cfg", "tox.ini"]
+
+OPTIONS = [
+    ("exclude", "plugins.pycodestyle.exclude", list),
+    ("filename", "plugins.pycodestyle.filename", list),
+    ("hang-closing", "plugins.pycodestyle.hangClosing", bool),
+    ("ignore", "plugins.pycodestyle.ignore", list),
+    ("max-line-length", "plugins.pycodestyle.maxLineLength", int),
+    ("indent-size", "plugins.pycodestyle.indentSize", int),
+    ("select", "plugins.pycodestyle.select", list),
+    ("aggressive", "plugins.pycodestyle.aggressive", int),
+]
+
+
+class PyCodeStyleConfig(ConfigSource):
+    def user_config(self):
+        config = self.read_config_from_files(USER_CONFIGS)
+        return self.parse_config(config, CONFIG_KEY, OPTIONS)
+
+    def project_config(self, document_path):
+        files = find_parents(self.root_path, document_path, PROJECT_CONFIGS)
+        config = self.read_config_from_files(files)
+        return self.parse_config(config, CONFIG_KEY, OPTIONS)

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,150 @@
+# 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(firstresult=True)
+def pylsp_type_definition(config, document, position):
+    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
+
+
+@hookspec
+def pylsp_shutdown(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 = f"{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 += "${{{}:{}}}".format(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,107 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Sequence
+from typing import Callable, ContextManager
+
+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: int | None, 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: str | None) -> 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) -> float | None:
+        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: int | None = 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) -> BaseJobSet | None:
+        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()