vscode-common-python-lsp 0.1.0__tar.gz

vscode_common_python_lsp-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: vscode-common-python-lsp
+Version: 0.1.0
+Summary: Shared Python utilities for VS Code Python tool extensions
+Author: Microsoft Corporation
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pygls>=1.1.0
+Requires-Dist: lsprotocol>=2023.0.0
+Requires-Dist: packaging>=22.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+
+# vscode-common-python-lsp (Python)
+
+Shared Python utilities for VS Code Python tool extensions.
+
+See the [main README](../README.md) for full documentation.

vscode_common_python_lsp-0.1.0/README.md

@@ -0,0 +1,5 @@
+# vscode-common-python-lsp (Python)
+
+Shared Python utilities for VS Code Python tool extensions.
+
+See the [main README](../README.md) for full documentation.

vscode_common_python_lsp-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vscode-common-python-lsp"
+version = "0.1.0"
+description = "Shared Python utilities for VS Code Python tool extensions"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Microsoft Corporation" },
+]
+
+dependencies = [
+    "pygls>=1.1.0",
+    "lsprotocol>=2023.0.0",
+    "packaging>=22.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "black",
+    "isort",
+    "flake8",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["vscode_common_python_lsp*"]
+
+[tool.isort]
+profile = "black"
+
+[tool.black]
+line-length = 88
+target-version = ["py310"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

vscode_common_python_lsp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vscode_common_python_lsp-0.1.0/tests/test_code_actions.py

@@ -0,0 +1,155 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+"""Tests for vscode_common_python_lsp.code_actions."""
+
+import lsprotocol.types as lsp
+import pytest
+
+from vscode_common_python_lsp.code_actions import (
+    QuickFixRegistrationError,
+    QuickFixRegistry,
+    command_quick_fix,
+    create_workspace_edit,
+)
+
+# ---------------------------------------------------------------------------
+# QuickFixRegistry
+# ---------------------------------------------------------------------------
+
+
+class TestQuickFixRegistry:
+    def test_register_single_code(self):
+        registry = QuickFixRegistry()
+
+        @registry.quick_fix(codes="E001")
+        def handler(doc, diags):
+            return []
+
+        assert registry.solutions("E001") is handler
+
+    def test_register_multiple_codes(self):
+        registry = QuickFixRegistry()
+
+        @registry.quick_fix(codes=["E001", "E002"])
+        def handler(doc, diags):
+            return []
+
+        assert registry.solutions("E001") is handler
+        assert registry.solutions("E002") is handler
+
+    def test_unknown_code_returns_none(self):
+        registry = QuickFixRegistry()
+        assert registry.solutions("X999") is None
+
+    def test_none_code_returns_none(self):
+        registry = QuickFixRegistry()
+        assert registry.solutions(None) is None
+
+    def test_duplicate_code_raises(self):
+        registry = QuickFixRegistry()
+
+        @registry.quick_fix(codes="E001")
+        def handler1(doc, diags):
+            return []
+
+        with pytest.raises(QuickFixRegistrationError):
+
+            @registry.quick_fix(codes="E001")
+            def handler2(doc, diags):
+                return []
+
+    def test_duplicate_in_list_raises(self):
+        registry = QuickFixRegistry()
+
+        @registry.quick_fix(codes="E001")
+        def handler1(doc, diags):
+            return []
+
+        with pytest.raises(QuickFixRegistrationError):
+
+            @registry.quick_fix(codes=["E001", "E002"])
+            def handler2(doc, diags):
+                return []
+
+    def test_decorator_returns_function(self):
+        """Decorator should return the original function for chaining."""
+        registry = QuickFixRegistry()
+
+        @registry.quick_fix(codes="E001")
+        def handler(doc, diags):
+            return ["result"]
+
+        # The decorated function is still callable
+        assert handler(None, []) == ["result"]
+
+
+# ---------------------------------------------------------------------------
+# command_quick_fix
+# ---------------------------------------------------------------------------
+
+
+class TestCommandQuickFix:
+    def test_basic(self):
+        diag = lsp.Diagnostic(
+            range=lsp.Range(
+                start=lsp.Position(line=0, character=0),
+                end=lsp.Position(line=0, character=0),
+            ),
+            message="test",
+        )
+        action = command_quick_fix(
+            diagnostics=[diag],
+            title="Fix it",
+            command="editor.action.fix",
+        )
+        assert action.title == "Fix it"
+        assert action.kind == lsp.CodeActionKind.QuickFix
+        assert action.diagnostics == [diag]
+        assert action.command.command == "editor.action.fix"
+
+    def test_with_args(self):
+        action = command_quick_fix(
+            diagnostics=[],
+            title="Fix",
+            command="cmd",
+            args=["arg1", 42],
+        )
+        assert action.command.arguments == ["arg1", 42]
+
+
+# ---------------------------------------------------------------------------
+# create_workspace_edit
+# ---------------------------------------------------------------------------
+
+
+class TestCreateWorkspaceEdit:
+    def test_basic(self):
+        edit = lsp.TextEdit(
+            range=lsp.Range(
+                start=lsp.Position(line=0, character=0),
+                end=lsp.Position(line=1, character=0),
+            ),
+            new_text="replaced\n",
+        )
+        ws_edit = create_workspace_edit("file:///a.py", 5, [edit])
+        assert len(ws_edit.document_changes) == 1
+        doc_edit = ws_edit.document_changes[0]
+        assert doc_edit.text_document.uri == "file:///a.py"
+        assert doc_edit.text_document.version == 5
+        assert doc_edit.edits == [edit]
+
+    def test_none_version_defaults_to_0(self):
+        ws_edit = create_workspace_edit("file:///a.py", None, [])
+        assert ws_edit.document_changes[0].text_document.version == 0
+
+    def test_version_zero_preserved(self):
+        """Version 0 is a valid LSP document version (the initial version)."""
+        edit = lsp.TextEdit(
+            range=lsp.Range(
+                start=lsp.Position(line=0, character=0),
+                end=lsp.Position(line=0, character=0),
+            ),
+            new_text="x",
+        )
+        ws_edit = create_workspace_edit("file:///a.py", 0, [edit])
+        assert ws_edit.document_changes[0].text_document.version == 0

vscode_common_python_lsp-0.1.0/tests/test_context.py

@@ -0,0 +1,102 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+"""Tests for context module."""
+
+import io
+import logging
+import os
+import sys
+from unittest.mock import patch
+
+import pytest
+
+from vscode_common_python_lsp.context import change_cwd, redirect_io, substitute_attr
+
+
+class TestSubstituteAttr:
+    def test_restores_attribute(self):
+        class Obj:
+            value = "original"
+
+        obj = Obj()
+        with substitute_attr(obj, "value", "modified"):
+            assert obj.value == "modified"
+        assert obj.value == "original"
+
+    def test_with_sys_argv(self):
+        original_argv = sys.argv
+        with substitute_attr(sys, "argv", ["test", "--flag"]):
+            assert sys.argv == ["test", "--flag"]
+        assert sys.argv is original_argv
+
+    def test_restores_on_exception(self):
+        """Attribute is restored even when the body raises."""
+        original_argv = sys.argv
+        with pytest.raises(RuntimeError):
+            with substitute_attr(sys, "argv", ["test"]):
+                raise RuntimeError("boom")
+        assert sys.argv is original_argv
+
+
+class TestRedirectIo:
+    def test_redirect_stdout(self):
+        buf = io.StringIO()
+        with redirect_io("stdout", buf):
+            print("hello", end="")
+        assert buf.getvalue() == "hello"
+
+    def test_restores_original(self):
+        original = sys.stdout
+        buf = io.StringIO()
+        with redirect_io("stdout", buf):
+            pass
+        assert sys.stdout is original
+
+    def test_restores_on_exception(self):
+        """Stream is restored even when the body raises."""
+        original = sys.stdout
+        buf = io.StringIO()
+        with pytest.raises(RuntimeError):
+            with redirect_io("stdout", buf):
+                raise RuntimeError("boom")
+        assert sys.stdout is original
+
+
+class TestChangeCwd:
+    def test_changes_and_restores(self, tmp_path):
+        original = os.getcwd()
+        with change_cwd(str(tmp_path)):
+            assert os.path.samefile(os.getcwd(), str(tmp_path))
+        assert os.getcwd() == original
+
+    def test_invalid_directory_does_not_raise(self):
+        original = os.getcwd()
+        with change_cwd("/nonexistent/path/that/does/not/exist"):
+            pass  # should not raise, falls back gracefully
+        assert os.getcwd() == original
+
+    @pytest.mark.parametrize(
+        "error, path, message",
+        [
+            (PermissionError("Access denied"), "/restricted/path", "Access denied"),
+            (OSError("Some OS error"), "/inaccessible", "Some OS error"),
+        ],
+    )
+    def test_chdir_error_logs_warning(self, caplog, error, path, message):
+        """When os.chdir raises, body still runs and warning is logged."""
+        original = os.getcwd()
+        body_executed = False
+
+        with patch(
+            "vscode_common_python_lsp.context.os.chdir",
+            side_effect=error,
+        ):
+            with caplog.at_level(logging.WARNING):
+                with change_cwd(path):
+                    body_executed = True
+                    assert os.path.normcase(os.getcwd()) == os.path.normcase(original)
+
+        assert body_executed
+        assert os.path.normcase(os.getcwd()) == os.path.normcase(original)
+        assert any(path in r.message for r in caplog.records)
+        assert any(message in r.message for r in caplog.records)

vscode_common_python_lsp-0.1.0/tests/test_debug.py

@@ -0,0 +1,119 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+"""Tests for vscode_common_python_lsp.debug."""
+
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from vscode_common_python_lsp.debug import setup_debugpy
+
+PATCH_UPDATE = "vscode_common_python_lsp.debug.update_sys_path"
+
+
+def test_no_env_var_does_nothing():
+    """When USE_DEBUGPY is not set, debugpy is not loaded."""
+    with patch.dict(os.environ, {}, clear=True):
+        os.environ.pop("USE_DEBUGPY", None)
+        os.environ.pop("DEBUGPY_PATH", None)
+        setup_debugpy()
+
+
+@pytest.mark.parametrize("value", ["False", "false", "0", "no", ""])
+def test_disabled_values_do_nothing(value):
+    """Non-truthy USE_DEBUGPY values skip debugpy setup."""
+    with patch.dict(os.environ, {"USE_DEBUGPY": value}, clear=False):
+        setup_debugpy()
+
+
+@pytest.mark.parametrize("value", ["True", "TRUE", "1", "T"])
+def test_enabled_without_path_does_nothing(value):
+    """USE_DEBUGPY enabled but no DEBUGPY_PATH skips setup."""
+    env = {"USE_DEBUGPY": value}
+    with patch.dict(os.environ, env, clear=False):
+        os.environ.pop("DEBUGPY_PATH", None)
+        setup_debugpy()
+
+
+def test_enabled_with_path_connects():
+    """USE_DEBUGPY + DEBUGPY_PATH triggers debugpy.connect."""
+    mock_debugpy = MagicMock()
+    debugger_dir = os.path.dirname(__file__)
+    env = {"USE_DEBUGPY": "True", "DEBUGPY_PATH": debugger_dir}
+    with patch.dict(os.environ, env, clear=False):
+        with patch.dict("sys.modules", {"debugpy": mock_debugpy}):
+            with patch(PATCH_UPDATE) as mock_update:
+                setup_debugpy(port=9999)
+
+                mock_update.assert_called_once_with(debugger_dir, "fromEnvironment")
+                mock_debugpy.connect.assert_called_once_with(9999)
+                mock_debugpy.breakpoint.assert_called_once()
+
+
+def test_debugpy_path_ending_with_debugpy_strips_suffix():
+    """DEBUGPY_PATH ending with 'debugpy' uses parent directory."""
+    test_parent = os.path.dirname(__file__)
+    debugpy_path = os.path.join(test_parent, "debugpy")
+    env = {"USE_DEBUGPY": "True", "DEBUGPY_PATH": debugpy_path}
+
+    mock_debugpy = MagicMock()
+    with patch.dict(os.environ, env, clear=False):
+        with patch.dict("sys.modules", {"debugpy": mock_debugpy}):
+            with patch(PATCH_UPDATE) as mock_update:
+                setup_debugpy()
+                mock_update.assert_called_once_with(test_parent, "fromEnvironment")
+
+
+def test_debugpy_path_with_similar_name_not_stripped():
+    """DEBUGPY_PATH like 'mydebugpy' should NOT be stripped."""
+    test_parent = os.path.dirname(__file__)
+    debugpy_path = os.path.join(test_parent, "mydebugpy")
+    env = {"USE_DEBUGPY": "True", "DEBUGPY_PATH": debugpy_path}
+
+    mock_debugpy = MagicMock()
+    with patch.dict(os.environ, env, clear=False):
+        with patch.dict("sys.modules", {"debugpy": mock_debugpy}):
+            with patch(PATCH_UPDATE) as mock_update:
+                setup_debugpy()
+                # Should NOT strip — "mydebugpy" basename != "debugpy"
+                mock_update.assert_called_once_with(debugpy_path, "fromEnvironment")
+
+
+# ---------------------------------------------------------------------------
+# require_opt_in=False tests (for repos without USE_DEBUGPY guard)
+# ---------------------------------------------------------------------------
+
+
+def test_no_opt_in_skips_use_debugpy_check():
+    """With require_opt_in=False, USE_DEBUGPY is not checked."""
+    mock_debugpy = MagicMock()
+    debugger_dir = os.path.dirname(__file__)
+    env = {"DEBUGPY_PATH": debugger_dir}
+    with patch.dict(os.environ, env, clear=True):
+        with patch.dict("sys.modules", {"debugpy": mock_debugpy}):
+            with patch(PATCH_UPDATE):
+                setup_debugpy(require_opt_in=False)
+
+                mock_debugpy.connect.assert_called_once_with(5678)
+                mock_debugpy.breakpoint.assert_called_once()
+
+
+def test_no_opt_in_still_requires_debugpy_path():
+    """With require_opt_in=False but no DEBUGPY_PATH, nothing happens."""
+    with patch.dict(os.environ, {}, clear=True):
+        setup_debugpy(require_opt_in=False)
+
+
+@pytest.mark.parametrize("value", ["False", "0", "no"])
+def test_no_opt_in_ignores_use_debugpy_value(value):
+    """With require_opt_in=False, USE_DEBUGPY value is irrelevant."""
+    mock_debugpy = MagicMock()
+    debugger_dir = os.path.dirname(__file__)
+    env = {"USE_DEBUGPY": value, "DEBUGPY_PATH": debugger_dir}
+    with patch.dict(os.environ, env, clear=False):
+        with patch.dict("sys.modules", {"debugpy": mock_debugpy}):
+            with patch(PATCH_UPDATE):
+                setup_debugpy(require_opt_in=False)
+
+                mock_debugpy.connect.assert_called_once()

vscode_common_python_lsp-0.1.0/tests/test_diagnostics.py

@@ -0,0 +1,207 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+"""Tests for vscode_common_python_lsp.diagnostics."""
+
+import re
+
+import lsprotocol.types as lsp
+
+from vscode_common_python_lsp.diagnostics import (
+    ParsedRecord,
+    get_severity,
+    make_diagnostic,
+    parse_diagnostics_regex,
+)
+
+# ---------------------------------------------------------------------------
+# get_severity
+# ---------------------------------------------------------------------------
+
+FLAKE8_SEVERITY = {"E": "Error", "F": "Error", "I": "Information", "W": "Warning"}
+PYLINT_SEVERITY = {
+    "convention": "Information",
+    "error": "Error",
+    "fatal": "Error",
+    "refactor": "Hint",
+    "warning": "Warning",
+}
+MYPY_SEVERITY = {"error": "Error", "note": "Information"}
+
+
+class TestGetSeverity:
+    def test_lookup_by_code(self):
+        assert (
+            get_severity("E501", "Error", FLAKE8_SEVERITY)
+            == lsp.DiagnosticSeverity.Error
+        )
+
+    def test_lookup_by_code_type(self):
+        assert (
+            get_severity("X999", "W", FLAKE8_SEVERITY) == lsp.DiagnosticSeverity.Warning
+        )
+
+    def test_fallback_to_default(self):
+        assert get_severity("X999", "unknown", {}) == lsp.DiagnosticSeverity.Error
+
+    def test_custom_default(self):
+        assert (
+            get_severity("X999", "unknown", {}, default="Warning")
+            == lsp.DiagnosticSeverity.Warning
+        )
+
+    def test_pylint_symbol_lookup(self):
+        severity_map = {**PYLINT_SEVERITY, "line-too-long": "Warning"}
+        result = get_severity(
+            "C0301", "convention", severity_map, symbol="line-too-long"
+        )
+        assert result == lsp.DiagnosticSeverity.Warning
+
+    def test_pylint_symbol_takes_priority(self):
+        severity_map = {
+            "line-too-long": "Hint",
+            "C0301": "Error",
+            "convention": "Information",
+        }
+        result = get_severity(
+            "C0301", "convention", severity_map, symbol="line-too-long"
+        )
+        assert result == lsp.DiagnosticSeverity.Hint
+
+    def test_mypy_code_lookup(self):
+        assert (
+            get_severity("error", "error", MYPY_SEVERITY)
+            == lsp.DiagnosticSeverity.Error
+        )
+        assert (
+            get_severity("note", "note", MYPY_SEVERITY)
+            == lsp.DiagnosticSeverity.Information
+        )
+
+    def test_invalid_severity_name(self):
+        result = get_severity("X", "X", {"X": "NotAReal"})
+        assert result == lsp.DiagnosticSeverity.Error
+
+    def test_code_type_fallback(self):
+        """Falls back to default when neither code nor code_type matches."""
+        assert get_severity("E501", "", {"E": "Error"}) == lsp.DiagnosticSeverity.Error
+
+
+# ---------------------------------------------------------------------------
+# make_diagnostic
+# ---------------------------------------------------------------------------
+
+
+class TestMakeDiagnostic:
+    def test_basic(self):
+        diag = make_diagnostic(
+            line=10,
+            column=5,
+            message="test error",
+            severity=lsp.DiagnosticSeverity.Error,
+            code="E001",
+            source="TestTool",
+        )
+        assert diag.range.start.line == 10
+        assert diag.range.start.character == 5
+        assert diag.range.end.line == 10
+        assert diag.range.end.character == 5
+        assert diag.message == "test error"
+        assert diag.severity == lsp.DiagnosticSeverity.Error
+        assert diag.code == "E001"
+        assert diag.source == "TestTool"
+
+    def test_with_end_range(self):
+        diag = make_diagnostic(
+            line=10,
+            column=0,
+            message="msg",
+            severity=lsp.DiagnosticSeverity.Warning,
+            end_line=12,
+            end_column=5,
+        )
+        assert diag.range.end.line == 12
+        assert diag.range.end.character == 5
+
+    def test_empty_code_is_none(self):
+        diag = make_diagnostic(
+            line=0, column=0, message="m", severity=lsp.DiagnosticSeverity.Error
+        )
+        assert diag.code is None
+        assert diag.source is None
+
+
+# ---------------------------------------------------------------------------
+# parse_diagnostics_regex
+# ---------------------------------------------------------------------------
+
+# Flake8-style regex
+FLAKE8_RE = re.compile(
+    r"(?P<line>\d+),(?P<column>-?\d+),"
+    r"(?P<type>\w+),(?P<code>\w+\d+):(?P<message>[^\r\n]*)"
+)
+
+
+class TestParseDiagnosticsRegex:
+    def test_flake8_output(self):
+        content = (
+            "5,1,Error,E302:expected 2 blank lines, got 1\n"
+            "10,80,Warning,W501:line too long"
+        )
+        result = parse_diagnostics_regex(content, FLAKE8_RE, FLAKE8_SEVERITY, "Flake8")
+        assert len(result) == 2
+        assert result[0].range.start.line == 4  # 5 - 1 (line_at_1)
+        assert result[0].range.start.character == 0  # 1 - 1 (col_at_1)
+        assert result[0].code == "E302"
+        assert result[0].message == "expected 2 blank lines, got 1"
+        assert result[0].source == "Flake8"
+
+    def test_no_matches(self):
+        result = parse_diagnostics_regex(
+            "no matching lines\n", FLAKE8_RE, FLAKE8_SEVERITY, "Flake8"
+        )
+        assert result == []
+
+    def test_empty_content(self):
+        result = parse_diagnostics_regex("", FLAKE8_RE, FLAKE8_SEVERITY, "Flake8")
+        assert result == []
+
+    def test_line_at_0(self):
+        content = "0,0,Error,E001:msg\n"
+        result = parse_diagnostics_regex(
+            content,
+            FLAKE8_RE,
+            FLAKE8_SEVERITY,
+            "Flake8",
+            line_at_1=False,
+            col_at_1=False,
+        )
+        assert result[0].range.start.line == 0
+        assert result[0].range.start.character == 0
+
+    def test_record_callback(self):
+        """record_callback lets tools like mypy do custom diagnostic construction."""
+        records: list[ParsedRecord] = []
+
+        def capture(record: ParsedRecord) -> lsp.Diagnostic | None:
+            records.append(record)
+            return make_diagnostic(
+                line=record.line,
+                column=record.column,
+                message=f"CUSTOM: {record.message}",
+                severity=lsp.DiagnosticSeverity.Hint,
+                code=record.code,
+                source="Custom",
+            )
+
+        content = "5,1,Error,E302:expected 2 blank lines, got 1\n"
+        result = parse_diagnostics_regex(
+            content, FLAKE8_RE, {}, "Flake8", record_callback=capture
+        )
+        assert len(records) == 1
+        assert records[0].code == "E302"
+        assert result[0].message == "CUSTOM: expected 2 blank lines, got 1"
+
+    def test_negative_column_clamped(self):
+        content = "1,-1,Error,E001:msg\n"
+        result = parse_diagnostics_regex(content, FLAKE8_RE, FLAKE8_SEVERITY, "Flake8")
+        assert result[0].range.start.character == 0  # clamped to 0