vscode-common-python-lsp 0.1.0__py3-none-any.whl

vscode_common_python_lsp/paths.py

@@ -0,0 +1,254 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+"""Path utilities for VS Code Python tool extensions."""
+
+from __future__ import annotations
+
+import fnmatch
+import functools
+import os
+import pathlib
+import site
+import sys
+import sysconfig
+import threading
+from enum import Enum
+from typing import Any
+
+# Save the working directory used when loading this module
+SERVER_CWD = os.getcwd()
+CWD_LOCK = threading.Lock()
+
+
+class PythonFileKind(Enum):
+    """Classification of a Python file by its location in the environment."""
+
+    STDLIB = "stdlib"
+    USER_SITE = "user_site"
+    SYSTEM_SITE = "system_site"
+
+
+def as_list(content: Any) -> list[Any]:
+    """Ensures we always get a list."""
+    if isinstance(content, (list, tuple)):
+        return list(content)
+    return [content]
+
+
+def get_sys_config_paths() -> list[str]:
+    """Returns Python installation paths from sysconfig.get_paths().
+
+    Uses the broader filter (not in data/platdata/scripts) to match
+    black, isort, mypy, and pylint. Includes stdlib, platstdlib,
+    purelib, platlib, include, and platinclude.
+    """
+    return [
+        path
+        for group, path in sysconfig.get_paths().items()
+        if group not in ["data", "platdata", "scripts"]
+    ]
+
+
+def get_extensions_dir() -> list[str]:
+    """Returns the VS Code extensions folder (under ~/.vscode or ~/.vscode-server).
+
+    The path is calculated relative to this file, because users can launch
+    VS Code with a custom extensions folder using the --extensions-dir argument.
+    """
+    path = pathlib.Path(__file__).parent.parent.parent.parent
+    #                              ^     bundled  ^  extensions
+    #                            tool        <extension>
+    if path.name == "extensions":
+        return [os.fspath(path)]
+    return []
+
+
+# ---------------------------------------------------------------------------
+# Path classification (lazy, cached)
+# ---------------------------------------------------------------------------
+
+
+@functools.lru_cache(maxsize=1)
+def _get_stdlib_roots() -> frozenset[pathlib.Path]:
+    """Resolved stdlib and platstdlib paths plus VS Code extensions dir.
+
+    Uses only the strict stdlib/platstdlib sysconfig groups so that
+    purelib/platlib (which point to site-packages) are excluded.
+
+    The result is computed lazily on the first call, then cached for
+    the lifetime of the process (paths do not change at runtime).
+    """
+    roots: set[pathlib.Path] = set()
+    for group in ("stdlib", "platstdlib"):
+        p = sysconfig.get_path(group)
+        if p:
+            try:
+                roots.add(pathlib.Path(p).resolve())
+            except OSError:
+                pass
+    for p in get_extensions_dir():
+        try:
+            roots.add(pathlib.Path(p).resolve())
+        except OSError:
+            pass
+    return frozenset(roots)
+
+
+@functools.lru_cache(maxsize=1)
+def _get_user_site_root() -> pathlib.Path | None:
+    """Resolved user site-packages path, or None.
+
+    The result is computed lazily on the first call, then cached for
+    the lifetime of the process.
+    """
+    try:
+        raw = site.getusersitepackages()
+    except Exception:
+        return None
+    if raw:
+        try:
+            return pathlib.Path(raw).resolve()
+        except OSError:
+            pass
+    return None
+
+
+@functools.lru_cache(maxsize=1)
+def _get_system_site_roots() -> frozenset[pathlib.Path]:
+    """All system site-packages roots.
+
+    Includes purelib/platlib from sysconfig plus every entry from
+    ``site.getsitepackages()``.  On Windows Store Python the latter
+    includes the base installation directory, which is a *parent* of
+    the stdlib root — the classifier handles this by checking stdlib
+    first.
+
+    The result is computed lazily on the first call, then cached for
+    the lifetime of the process.
+    """
+    roots: set[pathlib.Path] = set()
+    for group in ("purelib", "platlib"):
+        p = sysconfig.get_path(group)
+        if p:
+            try:
+                roots.add(pathlib.Path(p).resolve())
+            except OSError:
+                pass
+    try:
+        for p in as_list(site.getsitepackages()):
+            try:
+                roots.add(pathlib.Path(p).resolve())
+            except OSError:
+                pass
+    except Exception:
+        pass
+    return frozenset(roots)
+
+
+def classify_python_file(file_path: str) -> PythonFileKind | None:
+    """Classify a file as stdlib, user site-packages, or system site-packages.
+
+    Returns None if the file does not belong to any known Python
+    installation path.  Resolution order:
+
+    1. User site-packages (most specific user path).
+    2. Stdlib roots *excluding* ``site-packages``/``dist-packages``
+       subdirectories — checked before system site-packages because on
+       some platforms (Windows Store Python) ``site.getsitepackages()``
+       includes the base installation directory, which is a parent of
+       the stdlib root.
+    3. System site-packages (purelib, platlib, broad base roots).
+    """
+    try:
+        resolved = pathlib.Path(file_path).resolve()
+    except OSError:
+        return None
+
+    # 1. User site-packages (most specific)
+    user_site = _get_user_site_root()
+    if user_site and resolved.is_relative_to(user_site):
+        return PythonFileKind.USER_SITE
+
+    parts = resolved.parts
+    has_site_packages = "site-packages" in parts or "dist-packages" in parts
+
+    # 2. Stdlib (only if the path does NOT traverse a site-packages dir)
+    if not has_site_packages:
+        for root in _get_stdlib_roots():
+            if resolved.is_relative_to(root):
+                return PythonFileKind.STDLIB
+
+    # 3. System site-packages (includes broad roots like the base dir)
+    for root in _get_system_site_roots():
+        if resolved.is_relative_to(root):
+            return PythonFileKind.SYSTEM_SITE
+
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Path comparison and normalization
+# ---------------------------------------------------------------------------
+
+
+def is_same_path(
+    file_path1: str, file_path2: str, resolve_symlinks: bool = False
+) -> bool:
+    """Returns true if two paths are the same.
+
+    When *resolve_symlinks* is True, both paths are resolved through the
+    filesystem first so that symlinked paths compare equal (mirrors the
+    behaviour required by mypy).  Falls back to lexical comparison on
+    OSError (e.g. the file does not exist yet).
+    """
+    p1, p2 = pathlib.Path(file_path1), pathlib.Path(file_path2)
+    if resolve_symlinks:
+        try:
+            return p1.resolve() == p2.resolve()
+        except OSError:
+            pass
+    return p1 == p2
+
+
+def normalize_path(file_path: str, resolve_symlinks: bool = True) -> str:
+    """Returns normalized path."""
+    path = pathlib.Path(file_path)
+    if resolve_symlinks:
+        path = path.resolve()
+    return str(path)
+
+
+def is_current_interpreter(executable: str) -> bool:
+    """Returns true if the executable path is same as the current interpreter."""
+    return is_same_path(executable, sys.executable)
+
+
+def get_relative_path(file_path: str, workspace_root: str) -> str:
+    """Returns the file path relative to the workspace root.
+
+    Falls back to the original path if the workspace root is empty or
+    the paths are on different drives (Windows).
+    """
+    if not workspace_root:
+        return pathlib.Path(file_path).as_posix()
+    try:
+        return pathlib.Path(file_path).relative_to(workspace_root).as_posix()
+    except ValueError:
+        return pathlib.Path(file_path).as_posix()
+
+
+def is_match(
+    patterns: list[str], file_path: str, workspace_root: str | None = None
+) -> bool:
+    """Returns true if the file matches one of the fnmatch patterns."""
+    if not patterns:
+        return False
+    relative_path = (
+        get_relative_path(file_path, workspace_root) if workspace_root else file_path
+    )
+    file_name = pathlib.Path(file_path).name
+    return any(
+        fnmatch.fnmatch(relative_path, pattern)
+        or (not pattern.startswith("/") and fnmatch.fnmatch(file_name, pattern))
+        for pattern in patterns
+    )

vscode_common_python_lsp/process_runner.py

@@ -0,0 +1,94 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+"""Runner to use when running under a different interpreter."""
+
+from __future__ import annotations
+
+import os
+import sys
+import traceback
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from .context import substitute_attr
+
+if TYPE_CHECKING:
+    from .jsonrpc import JsonRpc
+
+
+def update_sys_path(path_to_add: str, strategy: str) -> None:
+    """Add given path to ``sys.path``.
+
+    Parameters
+    ----------
+    path_to_add:
+        The directory to add.
+    strategy:
+        ``"useBundled"`` inserts at position 0 (highest priority);
+        any other value appends.
+    """
+    if path_to_add not in sys.path and os.path.isdir(path_to_add):
+        if strategy == "useBundled":
+            sys.path.insert(0, path_to_add)
+        else:
+            sys.path.append(path_to_add)
+
+
+def run_message_loop(
+    rpc: JsonRpc,
+    run_fn: Callable[..., object],
+    result_cls: Callable[[str, str], object],
+) -> None:
+    """Process JSON-RPC messages in a loop until ``exit`` is received.
+
+    Parameters
+    ----------
+    rpc:
+        A ``JsonRpc`` instance connected to the parent process.
+    run_fn:
+        Callable with signature ``(module, argv, use_stdin, cwd, source=None)``
+        that returns a result object with ``.stdout`` and ``.stderr`` attrs.
+    result_cls:
+        Callable ``(stdout, stderr) -> result`` used to wrap exceptions.
+    """
+    exit_now = False
+    while not exit_now:
+        msg = rpc.receive_data()
+
+        method = msg["method"]
+        if method == "exit":
+            exit_now = True
+            continue
+
+        if method == "run":
+            is_exception = False
+            with substitute_attr(sys, "path", [""] + sys.path[:]):
+                try:
+                    result = run_fn(
+                        module=msg["module"],
+                        argv=msg["argv"],
+                        use_stdin=msg["useStdin"],
+                        cwd=msg["cwd"],
+                        source=msg.get("source"),
+                    )
+                except Exception:
+                    result = result_cls("", traceback.format_exc(chain=True))
+                    is_exception = True
+
+            response: dict[str, object] = {
+                "id": msg["id"],
+                "error": result.stderr,
+            }
+            if is_exception:
+                response["exception"] = is_exception
+            elif result.stdout is not None:
+                response["result"] = result.stdout
+
+            rpc.send_data(response)
+        else:
+            rpc.send_data(
+                {
+                    "id": msg.get("id", ""),
+                    "error": f"Unknown method: {method}",
+                }
+            )

vscode_common_python_lsp/runner.py

@@ -0,0 +1,174 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+"""Tool execution runners for VS Code Python tool extensions."""
+
+from __future__ import annotations
+
+import contextlib
+import io
+import os
+import runpy
+import subprocess
+import sys
+from collections.abc import Callable, Iterator, Sequence
+from dataclasses import dataclass
+
+from .context import change_cwd, redirect_io, substitute_attr
+from .paths import CWD_LOCK, is_same_path
+
+
+@dataclass
+class RunResult:
+    """Object to hold result from running tool."""
+
+    stdout: str
+    stderr: str
+    exit_code: int | str | None = None
+
+
+class CustomIO(io.TextIOWrapper):
+    """Custom stream object to replace stdio."""
+
+    name = None
+
+    def __init__(self, name, encoding="utf-8", newline=None):
+        self._buffer = io.BytesIO()
+        super().__init__(self._buffer, encoding=encoding, newline=newline)
+        self.name = name
+
+    def close(self):
+        """Provide this close method which is used by some tools."""
+        # This is intentionally empty.
+        pass
+
+    def get_value(self) -> str:
+        """Returns value from the buffer as string."""
+        self.seek(0)
+        return self.read()
+
+
+@contextlib.contextmanager
+def _cwd_lock(cwd: str) -> Iterator[None]:
+    """Acquire CWD_LOCK and optionally change directory."""
+    with CWD_LOCK:
+        if is_same_path(os.getcwd(), cwd):
+            yield
+        else:
+            with change_cwd(cwd):
+                yield
+
+
+def run_module(
+    module: str,
+    argv: Sequence[str],
+    use_stdin: bool,
+    cwd: str,
+    source: str | None = None,
+) -> RunResult:
+    """Runs a Python module via runpy (e.g. black, flake8).
+
+    Captures stdout, stderr, and SystemExit exit codes.
+    """
+    with _cwd_lock(cwd):
+        str_output = CustomIO("<stdout>", encoding="utf-8")
+        str_error = CustomIO("<stderr>", encoding="utf-8")
+
+        exit_code = None
+        try:
+            with substitute_attr(sys, "argv", list(argv)):
+                with redirect_io("stdout", str_output):
+                    with redirect_io("stderr", str_error):
+                        if use_stdin:
+                            str_input = CustomIO(
+                                "<stdin>", encoding="utf-8", newline="\n"
+                            )
+                            with redirect_io("stdin", str_input):
+                                if source is not None:
+                                    str_input.write(source)
+                                    str_input.seek(0)
+                                runpy.run_module(module, run_name="__main__")
+                        else:
+                            runpy.run_module(module, run_name="__main__")
+        except SystemExit as e:
+            exit_code = e.code
+
+        return RunResult(str_output.get_value(), str_error.get_value(), exit_code)
+
+
+def run_path(
+    argv: Sequence[str],
+    use_stdin: bool,
+    cwd: str,
+    source: str | None = None,
+    env: dict[str, str] | None = None,
+    timeout: float | None = None,
+) -> RunResult:
+    """Runs tool as a subprocess via executable path."""
+    if use_stdin:
+        with subprocess.Popen(
+            argv,
+            encoding="utf-8",
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            stdin=subprocess.PIPE,
+            cwd=cwd,
+            env=env,
+        ) as process:
+            try:
+                stdout, stderr = process.communicate(input=source, timeout=timeout)
+            except subprocess.TimeoutExpired:
+                process.kill()
+                stdout, stderr = process.communicate()
+            return RunResult(stdout, stderr, process.returncode)
+    else:
+        try:
+            result = subprocess.run(
+                argv,
+                encoding="utf-8",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                check=False,
+                cwd=cwd,
+                env=env,
+                timeout=timeout,
+            )
+        except subprocess.TimeoutExpired as e:
+            return RunResult(e.stdout or "", e.stderr or "", None)
+        return RunResult(result.stdout, result.stderr, result.returncode)
+
+
+def run_api(
+    callback: Callable[[Sequence[str], CustomIO, CustomIO, CustomIO | None], None],
+    argv: Sequence[str],
+    use_stdin: bool,
+    cwd: str,
+    source: str | None = None,
+) -> RunResult:
+    """Runs tool via API callback (importable tools).
+
+    Captures stdout, stderr, and SystemExit exit codes.
+    """
+    with _cwd_lock(cwd):
+        str_output = CustomIO("<stdout>", encoding="utf-8")
+        str_error = CustomIO("<stderr>", encoding="utf-8")
+
+        exit_code = None
+        try:
+            with substitute_attr(sys, "argv", list(argv)):
+                with redirect_io("stdout", str_output):
+                    with redirect_io("stderr", str_error):
+                        if use_stdin:
+                            str_input = CustomIO(
+                                "<stdin>", encoding="utf-8", newline="\n"
+                            )
+                            with redirect_io("stdin", str_input):
+                                if source is not None:
+                                    str_input.write(source)
+                                    str_input.seek(0)
+                                callback(argv, str_output, str_error, str_input)
+                        else:
+                            callback(argv, str_output, str_error, None)
+        except SystemExit as e:
+            exit_code = e.code
+
+        return RunResult(str_output.get_value(), str_error.get_value(), exit_code)