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

pylsp/_utils.py

@@ -0,0 +1,418 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import functools
+import inspect
+import logging
+import os
+import pathlib
+import re
+import subprocess
+import sys
+import threading
+import time
+from typing import Optional
+
+import docstring_to_markdown
+import jedi
+
+JEDI_VERSION = jedi.__version__
+
+# Eol chars accepted by the LSP protocol
+# the ordering affects performance
+EOL_CHARS = ["\r\n", "\r", "\n"]
+EOL_REGEX = re.compile(f"({'|'.join(EOL_CHARS)})")
+
+log = logging.getLogger(__name__)
+
+
+def debounce(interval_s, keyed_by=None):
+    """Debounce calls to this function until interval_s seconds have passed."""
+
+    def wrapper(func):
+        timers = {}
+        lock = threading.Lock()
+
+        @functools.wraps(func)
+        def debounced(*args, **kwargs):
+            sig = inspect.signature(func)
+            call_args = sig.bind(*args, **kwargs)
+            key = call_args.arguments[keyed_by] if keyed_by else None
+
+            def run():
+                with lock:
+                    del timers[key]
+                return func(*args, **kwargs)
+
+            with lock:
+                old_timer = timers.get(key)
+                if old_timer:
+                    old_timer.cancel()
+
+                timer = threading.Timer(interval_s, run)
+                timers[key] = timer
+                timer.start()
+
+        return debounced
+
+    return wrapper
+
+
+def throttle(seconds=1):
+    """Throttles calls to a function every `seconds` seconds."""
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            if not hasattr(wrapper, "last_call"):
+                wrapper.last_call = 0
+            if time.time() - wrapper.last_call >= seconds:
+                wrapper.last_call = time.time()
+                return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def find_parents(root, path, names):
+    """Find files matching the given names relative to the given path.
+
+    Args:
+        path (str): The file path to start searching up from.
+        names (list[str]): The file/directory names to look for.
+        root (str): The directory at which to stop recursing upwards.
+
+    Note:
+        The path MUST be within the root.
+    """
+    if not root:
+        return []
+
+    if not os.path.commonprefix((root, path)):
+        log.warning("Path %r not in %r", path, root)
+        return []
+
+    # Split the relative by directory, generate all the parent directories, then check each of them.
+    # This avoids running a loop that has different base-cases for unix/windows
+    # e.g. /a/b and /a/b/c/d/e.py -> ['/a/b', 'c', 'd']
+    dirs = [root] + os.path.relpath(os.path.dirname(path), root).split(os.path.sep)
+
+    # Search each of /a/b/c, /a/b, /a
+    while dirs:
+        search_dir = os.path.join(*dirs)
+        existing = list(
+            filter(os.path.exists, [os.path.join(search_dir, n) for n in names])
+        )
+        if existing:
+            return existing
+        dirs.pop()
+
+    # Otherwise nothing
+    return []
+
+
+def path_to_dot_name(path):
+    """Given a path to a module, derive its dot-separated full name."""
+    directory = os.path.dirname(path)
+    module_name, _ = os.path.splitext(os.path.basename(path))
+    full_name = [module_name]
+    while os.path.exists(os.path.join(directory, "__init__.py")):
+        this_directory = os.path.basename(directory)
+        directory = os.path.dirname(directory)
+        full_name = [this_directory] + full_name
+    return ".".join(full_name)
+
+
+def match_uri_to_workspace(uri, workspaces):
+    if uri is None:
+        return None
+    max_len, chosen_workspace = -1, None
+    path = pathlib.Path(uri).parts
+    for workspace in workspaces:
+        workspace_parts = pathlib.Path(workspace).parts
+        if len(workspace_parts) > len(path):
+            continue
+        match_len = 0
+        for workspace_part, path_part in zip(workspace_parts, path):
+            if workspace_part == path_part:
+                match_len += 1
+        if match_len > 0:
+            if match_len > max_len:
+                max_len = match_len
+                chosen_workspace = workspace
+    return chosen_workspace
+
+
+def list_to_string(value):
+    return ",".join(value) if isinstance(value, list) else value
+
+
+def merge_dicts(dict_a, dict_b):
+    """Recursively merge dictionary b into dictionary a.
+
+    If override_nones is True, then
+    """
+
+    def _merge_dicts_(a, b):
+        for key in set(a.keys()).union(b.keys()):
+            if key in a and key in b:
+                if isinstance(a[key], dict) and isinstance(b[key], dict):
+                    yield (key, dict(_merge_dicts_(a[key], b[key])))
+                elif isinstance(a[key], list) and isinstance(b[key], list):
+                    yield (key, list(set(a[key] + b[key])))
+                elif b[key] is not None:
+                    yield (key, b[key])
+                else:
+                    yield (key, a[key])
+            elif key in a:
+                yield (key, a[key])
+            elif b[key] is not None:
+                yield (key, b[key])
+
+    return dict(_merge_dicts_(dict_a, dict_b))
+
+
+def escape_plain_text(contents: str) -> str:
+    """
+    Format plain text to display nicely in environments which do not respect whitespaces.
+    """
+    contents = contents.replace("\t", "\u00a0" * 4)
+    contents = contents.replace("  ", "\u00a0" * 2)
+    return contents
+
+
+def escape_markdown(contents: str) -> str:
+    """
+    Format plain text to display nicely in Markdown environment.
+    """
+    # escape markdown syntax
+    contents = re.sub(r"([\\*_#[\]])", r"\\\1", contents)
+    # preserve white space characters
+    contents = escape_plain_text(contents)
+    return contents
+
+
+def wrap_signature(signature):
+    return "```python\n" + signature + "\n```\n"
+
+
+SERVER_SUPPORTED_MARKUP_KINDS = {"markdown", "plaintext"}
+
+
+def choose_markup_kind(client_supported_markup_kinds: list[str]):
+    """Choose a markup kind supported by both client and the server.
+
+    This gives priority to the markup kinds provided earlier on the client preference list.
+    """
+    for kind in client_supported_markup_kinds:
+        if kind in SERVER_SUPPORTED_MARKUP_KINDS:
+            return kind
+    return "markdown"
+
+
+class Formatter:
+    command: list[str]
+
+    @property
+    def is_installed(self) -> bool:
+        """Returns whether formatter is available"""
+        if not hasattr(self, "_is_installed"):
+            self._is_installed = self._is_available_via_cli()
+        return self._is_installed
+
+    def format(self, code: str, line_length: int) -> str:
+        """Formats code"""
+        return subprocess.check_output(
+            [
+                sys.executable,
+                "-m",
+                *self.command,
+                "--line-length",
+                str(line_length),
+                "-",
+            ],
+            input=code,
+            text=True,
+        ).strip()
+
+    def _is_available_via_cli(self) -> bool:
+        try:
+            subprocess.check_output(
+                [
+                    sys.executable,
+                    "-m",
+                    *self.command,
+                    "--help",
+                ],
+            )
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+
+class RuffFormatter(Formatter):
+    command = ["ruff", "format"]
+
+
+class BlackFormatter(Formatter):
+    command = ["black"]
+
+
+formatters = {"ruff": RuffFormatter(), "black": BlackFormatter()}
+
+
+def format_signature(signature: str, config: dict, signature_formatter: str) -> str:
+    """Formats signature using ruff or black if either is available."""
+    as_func = f"def {signature.strip()}:\n    pass"
+    line_length = config.get("line_length", 88)
+    formatter = formatters[signature_formatter]
+    if formatter.is_installed:
+        try:
+            return (
+                formatter.format(as_func, line_length=line_length)
+                .removeprefix("def ")
+                .removesuffix(":\n    pass")
+            )
+        except subprocess.CalledProcessError as e:
+            log.warning("Signature formatter failed %s", e)
+    else:
+        log.warning(
+            "Formatter %s was requested but it does not appear to be installed",
+            signature_formatter,
+        )
+    return signature
+
+
+def convert_signatures_to_markdown(signatures: list[str], config: dict) -> str:
+    signature_formatter = config.get("formatter", "black")
+    if signature_formatter:
+        signatures = [
+            format_signature(
+                signature, signature_formatter=signature_formatter, config=config
+            )
+            for signature in signatures
+        ]
+    return wrap_signature("\n".join(signatures))
+
+
+def format_docstring(
+    contents: str,
+    markup_kind: str,
+    signatures: Optional[list[str]] = None,
+    signature_config: Optional[dict] = None,
+):
+    """Transform the provided docstring into a MarkupContent object.
+
+    If `markup_kind` is 'markdown' the docstring will get converted to
+    markdown representation using `docstring-to-markdown`; if it is
+    `plaintext`, it will be returned as plain text.
+    Call signatures of functions (or equivalent code summaries)
+    provided in optional `signatures` argument will be prepended
+    to the provided contents of the docstring if given.
+    """
+    if not isinstance(contents, str):
+        contents = ""
+
+    if markup_kind == "markdown":
+        try:
+            value = docstring_to_markdown.convert(contents)
+        except docstring_to_markdown.UnknownFormatError:
+            # try to escape the Markdown syntax instead:
+            value = escape_markdown(contents)
+
+        if signatures:
+            wrapped_signatures = convert_signatures_to_markdown(
+                signatures, config=signature_config or {}
+            )
+            value = wrapped_signatures + "\n\n" + value
+
+        return {"kind": "markdown", "value": value}
+    value = contents
+    if signatures:
+        value = "\n".join(signatures) + "\n\n" + value
+    return {"kind": "plaintext", "value": escape_plain_text(value)}
+
+
+def clip_column(column, lines, line_number):
+    """
+    Normalise the position as per the LSP that accepts character positions > line length
+
+    https://microsoft.github.io/language-server-protocol/specification#position
+    """
+    max_column = (
+        len(lines[line_number].rstrip("\r\n")) if len(lines) > line_number else 0
+    )
+    return min(column, max_column)
+
+
+def position_to_jedi_linecolumn(document, position):
+    """
+    Convert the LSP format 'line', 'character' to Jedi's 'line', 'column'
+
+    https://microsoft.github.io/language-server-protocol/specification#position
+    """
+    code_position = {}
+    if position:
+        code_position = {
+            "line": position["line"] + 1,
+            "column": clip_column(
+                position["character"], document.lines, position["line"]
+            ),
+        }
+    return code_position
+
+
+if os.name == "nt":
+    import ctypes
+
+    kernel32 = ctypes.windll.kernel32
+    PROCESS_QUERY_INFROMATION = 0x1000
+
+    def is_process_alive(pid):
+        """Check whether the process with the given pid is still alive.
+
+        Running `os.kill()` on Windows always exits the process, so it can't be used to check for an alive process.
+        see: https://docs.python.org/3/library/os.html?highlight=os%20kill#os.kill
+
+        Hence ctypes is used to check for the process directly via windows API avoiding any other 3rd-party dependency.
+
+        Args:
+            pid (int): process ID
+
+        Returns:
+            bool: False if the process is not alive or don't have permission to check, True otherwise.
+        """
+        process = kernel32.OpenProcess(PROCESS_QUERY_INFROMATION, 0, pid)
+        if process != 0:
+            kernel32.CloseHandle(process)
+            return True
+        return False
+
+else:
+    import errno
+
+    def is_process_alive(pid):
+        """Check whether the process with the given pid is still alive.
+
+        Args:
+            pid (int): process ID
+
+        Returns:
+            bool: False if the process is not alive or don't have permission to check, True otherwise.
+        """
+        if pid < 0:
+            return False
+        try:
+            os.kill(pid, 0)
+        except OSError as e:
+            return e.errno == errno.EPERM
+        return True
+
+
+def get_eol_chars(text):
+    """Get EOL chars used in text."""
+    match = EOL_REGEX.search(text)
+    if match:
+        return match.group(0)
+    return None

pylsp/_version.py

@@ -0,0 +1 @@
+__version__ = "1.13.1rc2"

pylsp/config/__init__.py

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

pylsp/config/config.py

@@ -0,0 +1,203 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import logging
+import sys
+from collections.abc import Mapping, Sequence
+from functools import lru_cache
+from typing import Union
+
+import pluggy
+from pluggy._hooks import HookImpl
+
+from pylsp import PYLSP, _utils, hookspecs, uris
+
+# See compatibility note on `group` keyword:
+#   https://docs.python.org/3/library/importlib.metadata.html#entry-points
+if sys.version_info < (3, 10):  # pragma: no cover
+    from importlib_metadata import entry_points
+else:  # pragma: no cover
+    from importlib.metadata import entry_points
+
+
+log = logging.getLogger(__name__)
+
+# Sources of config, first source overrides next source
+DEFAULT_CONFIG_SOURCES = ["pycodestyle"]
+
+
+class PluginManager(pluggy.PluginManager):
+    def _hookexec(
+        self,
+        hook_name: str,
+        methods: Sequence[HookImpl],
+        kwargs: Mapping[str, object],
+        firstresult: bool,
+    ) -> Union[object, list[object]]:
+        # called from all hookcaller instances.
+        # enable_tracing will set its own wrapping function at self._inner_hookexec
+        try:
+            return self._inner_hookexec(hook_name, methods, kwargs, firstresult)
+        except Exception as e:
+            log.warning(f"Failed to load hook {hook_name}: {e}", exc_info=True)
+            return []
+
+
+class Config:
+    def __init__(self, root_uri, init_opts, process_id, capabilities) -> None:
+        self._root_path = uris.to_fs_path(root_uri)
+        self._root_uri = root_uri
+        self._init_opts = init_opts
+        self._process_id = process_id
+        self._capabilities = capabilities
+
+        self._settings = {}
+        self._plugin_settings = {}
+
+        self._config_sources = {}
+        try:
+            from .flake8_conf import Flake8Config
+
+            self._config_sources["flake8"] = Flake8Config(self._root_path)
+        except ImportError:
+            pass
+        try:
+            from .pycodestyle_conf import PyCodeStyleConfig
+
+            self._config_sources["pycodestyle"] = PyCodeStyleConfig(self._root_path)
+        except ImportError:
+            pass
+
+        self._pm = PluginManager(PYLSP)
+        self._pm.trace.root.setwriter(log.debug)
+        self._pm.enable_tracing()
+        self._pm.add_hookspecs(hookspecs)
+
+        # Pluggy will skip loading a plugin if it throws a DistributionNotFound exception.
+        # However I don't want all plugins to have to catch ImportError and re-throw. So here we'll filter
+        # out any entry points that throw ImportError assuming one or more of their dependencies isn't present.
+        for entry_point in entry_points(group=PYLSP):
+            try:
+                entry_point.load()
+            except Exception as e:
+                log.info(
+                    "Failed to load %s entry point '%s': %s", PYLSP, entry_point.name, e
+                )
+                self._pm.set_blocked(entry_point.name)
+
+        # Load the entry points into pluggy, having blocked any failing ones.
+        # Despite the API name, recent Pluggy versions will use ``importlib_metadata``.
+        self._pm.load_setuptools_entrypoints(PYLSP)
+
+        for name, plugin in self._pm.list_name_plugin():
+            if plugin is not None:
+                log.info("Loaded pylsp plugin %s from %s", name, plugin)
+
+        for plugin_conf in self._pm.hook.pylsp_settings(config=self):
+            self._plugin_settings = _utils.merge_dicts(
+                self._plugin_settings, plugin_conf
+            )
+
+        self._plugin_settings = _utils.merge_dicts(
+            self._plugin_settings, self._init_opts.get("pylsp", {})
+        )
+
+        self._update_disabled_plugins()
+
+    @property
+    def disabled_plugins(self):
+        return self._disabled_plugins
+
+    @property
+    def plugin_manager(self):
+        return self._pm
+
+    @property
+    def init_opts(self):
+        return self._init_opts
+
+    @property
+    def root_uri(self):
+        return self._root_uri
+
+    @property
+    def process_id(self):
+        return self._process_id
+
+    @property
+    def capabilities(self):
+        return self._capabilities
+
+    @lru_cache(maxsize=32)
+    def settings(self, document_path=None):
+        """Settings are constructed from a few sources:
+
+            1. User settings, found in user's home directory
+            2. Plugin settings, reported by PyLS plugins
+            3. LSP settings, given to us from didChangeConfiguration
+            4. Project settings, found in config files in the current project.
+
+        Since this function is nondeterministic, it is important to call
+        settings.cache_clear() when the config is updated
+        """
+        settings = {}
+        sources = self._settings.get("configurationSources", DEFAULT_CONFIG_SOURCES)
+
+        # Plugin configuration
+        settings = _utils.merge_dicts(settings, self._plugin_settings)
+
+        # LSP configuration
+        settings = _utils.merge_dicts(settings, self._settings)
+
+        # User configuration
+        for source_name in reversed(sources):
+            source = self._config_sources.get(source_name)
+            if not source:
+                continue
+            source_conf = source.user_config()
+            log.debug(
+                "Got user config from %s: %s", source.__class__.__name__, source_conf
+            )
+            settings = _utils.merge_dicts(settings, source_conf)
+
+        # Project configuration
+        for source_name in reversed(sources):
+            source = self._config_sources.get(source_name)
+            if not source:
+                continue
+            source_conf = source.project_config(document_path or self._root_path)
+            log.debug(
+                "Got project config from %s: %s", source.__class__.__name__, source_conf
+            )
+            settings = _utils.merge_dicts(settings, source_conf)
+
+        log.debug("With configuration: %s", settings)
+
+        return settings
+
+    def find_parents(self, path, names):
+        root_path = uris.to_fs_path(self._root_uri)
+        return _utils.find_parents(root_path, path, names)
+
+    def plugin_settings(self, plugin, document_path=None):
+        return (
+            self.settings(document_path=document_path)
+            .get("plugins", {})
+            .get(plugin, {})
+        )
+
+    def update(self, settings) -> None:
+        """Recursively merge the given settings into the current settings."""
+        self.settings.cache_clear()
+        self._settings = settings
+        log.info("Updated settings to %s", self._settings)
+        self._update_disabled_plugins()
+
+    def _update_disabled_plugins(self) -> None:
+        # All plugins default to enabled
+        self._disabled_plugins = [
+            plugin
+            for name, plugin in self.plugin_manager.list_name_plugin()
+            if not self.settings().get("plugins", {}).get(name, {}).get("enabled", True)
+        ]
+        log.info("Disabled plugins: %s", self._disabled_plugins)

pylsp/config/flake8_conf.py

@@ -0,0 +1,64 @@
+# Copyright 2017-2020 Palantir Technologies, Inc.
+# Copyright 2021- Python Language Server Contributors.
+
+import logging
+import os
+
+from pylsp._utils import find_parents
+
+from .source import ConfigSource
+
+log = logging.getLogger(__name__)
+
+CONFIG_KEY = "flake8"
+PROJECT_CONFIGS = [".flake8", "setup.cfg", "tox.ini"]
+
+OPTIONS = [
+    # mccabe
+    ("max-complexity", "plugins.mccabe.threshold", int),
+    # pycodestyle
+    ("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),
+    # flake8
+    ("exclude", "plugins.flake8.exclude", list),
+    ("extend-ignore", "plugins.flake8.extendIgnore", list),
+    ("extend-select", "plugins.flake8.extendSelect", list),
+    ("filename", "plugins.flake8.filename", list),
+    ("hang-closing", "plugins.flake8.hangClosing", bool),
+    ("ignore", "plugins.flake8.ignore", list),
+    ("max-complexity", "plugins.flake8.maxComplexity", int),
+    ("max-line-length", "plugins.flake8.maxLineLength", int),
+    ("indent-size", "plugins.flake8.indentSize", int),
+    ("select", "plugins.flake8.select", list),
+    ("per-file-ignores", "plugins.flake8.perFileIgnores", list),
+]
+
+
+class Flake8Config(ConfigSource):
+    """Parse flake8 configurations."""
+
+    def user_config(self):
+        config_file = self._user_config_file()
+        config = self.read_config_from_files([config_file])
+        return self.parse_config(config, CONFIG_KEY, OPTIONS)
+
+    def _user_config_file(self):
+        if self.is_windows:
+            return os.path.expanduser("~\\.flake8")
+        return os.path.join(self.xdg_home, "flake8")
+
+    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)
+
+    @classmethod
+    def _parse_list_opt(cls, string):
+        if string.startswith("\n"):
+            return [s.strip().rstrip(",") for s in string.split("\n") if s.strip()]
+        return [s.strip() for s in string.split(",") if s.strip()]