vscode-common-python-lsp 0.5.1__tar.gz → 0.5.2__tar.gz

{vscode_common_python_lsp-0.5.1 → vscode_common_python_lsp-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vscode-common-python-lsp
-Version: 0.5.1
+Version: 0.5.2
 Summary: Shared Python utilities for VS Code Python tool extensions
 Author: Microsoft Corporation
 License-Expression: MIT

{vscode_common_python_lsp-0.5.1 → vscode_common_python_lsp-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vscode-common-python-lsp"
-version = "0.5.1"
+version = "0.5.2"
 description = "Shared Python utilities for VS Code Python tool extensions"
 readme = "README.md"
 license = "MIT"

{vscode_common_python_lsp-0.5.1 → vscode_common_python_lsp-0.5.2}/tests/test_paths.py

@@ -3,6 +3,7 @@
 """Tests for paths module."""
 
 import os
+import pathlib
 import site
 import sys
 import sysconfig
@@ -20,6 +21,7 @@ from vscode_common_python_lsp.paths import (
     is_match,
     is_same_path,
     normalize_path,
+    sanitize_path_for_name_max,
 )
 
 
@@ -266,3 +268,152 @@ class TestIsMatch:
     def test_with_workspace_root(self, tmp_path):
         fp = str(tmp_path / "src" / "test.py")
         assert is_match(["src/*.py"], fp, str(tmp_path))
+
+
+# ---------------------------------------------------------------------------
+# sanitize_path_for_name_max tests
+# ---------------------------------------------------------------------------
+
+# A realistic dev-container/tunnel netloc component (>255 chars).
+_LONG_NETLOC = (
+    "dev-container+7b22686f737450617468223a222f686f6d652f646f6e6e79"
+    "2f50726f6a656374732f776f72647365617263682d637370222c226c6f63"
+    "616c446f636b6572223a66616c73652c22636f6e66696746696c65223a7b"
+    "22246d6964223a312c2270617468223a222f686f6d652f646f6e6e792f50"
+    "726f6a656374732f776f72647365617263682d6373702f2e646576636f6e"
+    "7461696e65722f646576636f6e7461696e65722e6a736f6e222c22736368"
+    "656d65223a227673636f64652d66696c65486f7374227d7d"
+)
+
+
+class TestSanitizePathForNameMax:
+    """Tests for sanitize_path_for_name_max() — path sanitisation."""
+
+    def test_short_path_unchanged(self):
+        """Normal paths should pass through untouched."""
+        p = os.path.join(os.sep, "home", "user", "project", "src", "main.py")
+        assert sanitize_path_for_name_max(p) == p
+
+    def test_overlong_component_detected(self):
+        """The fixture netloc must actually exceed NAME_MAX."""
+        assert len(_LONG_NETLOC.encode()) > 255
+
+    def test_overlong_without_workspace(self):
+        """Overlong component is replaced with '_', basename preserved."""
+        p = os.path.join(os.sep, _LONG_NETLOC, "workspace", "src", "main.py")
+        result = sanitize_path_for_name_max(p)
+        for part in pathlib.PurePath(result).parts:
+            assert len(part.encode()) <= 255
+        assert result.endswith("main.py")
+
+    def test_overlong_with_workspace(self):
+        """With a workspace, result preserves sub-path below overlong component."""
+        p = os.path.join(os.sep, _LONG_NETLOC, "workspace", "src", "main.py")
+        workspace = os.path.join(os.sep, "workspace")
+        result = sanitize_path_for_name_max(p, workspace=workspace)
+        assert result == os.path.join(workspace, "workspace", "src", "main.py")
+
+    def test_overlong_with_workspace_preserves_subpath(self):
+        """Sub-path below overlong component is preserved when re-rooting."""
+        p = os.path.join(os.sep, _LONG_NETLOC, "deep", "nested", "path", "app.py")
+        workspace = os.path.join(os.sep, "home", "user", "project")
+        result = sanitize_path_for_name_max(p, workspace=workspace)
+        assert result == os.path.join(workspace, "deep", "nested", "path", "app.py")
+
+    def test_multiple_overlong_components(self):
+        """Multiple overlong components are all sanitised."""
+        long1 = "a" * 300
+        long2 = "b" * 400
+        p = os.path.join(os.sep, long1, long2, "file.py")
+        result = sanitize_path_for_name_max(p)
+        for part in pathlib.PurePath(result).parts:
+            assert len(part.encode()) <= 255
+
+    def test_empty_workspace_falls_back(self):
+        """Empty workspace string triggers component-replacement fallback."""
+        p = os.path.join(os.sep, _LONG_NETLOC, "src", "file.py")
+        result = sanitize_path_for_name_max(p, workspace="")
+        assert result.endswith("file.py")
+        for part in pathlib.PurePath(result).parts:
+            assert len(part.encode()) <= 255
+
+    def test_unicode_path_component(self):
+        """Multi-byte UTF-8 components exceeding 255 bytes are sanitised."""
+        # Each emoji is 4 bytes in UTF-8; 64 emojis = 256 bytes > 255
+        long_unicode = "\U0001f600" * 64
+        p = os.path.join(os.sep, long_unicode, "file.py")
+        result = sanitize_path_for_name_max(p)
+        for part in pathlib.PurePath(result).parts:
+            assert len(part.encode("utf-8")) <= 255
+
+    def test_overlong_basename_without_workspace(self):
+        """Overlong basename without workspace is sanitized, preserving suffix."""
+        long_name = "x" * 300 + ".py"
+        p = os.path.join(os.sep, "dev", long_name)
+        result = sanitize_path_for_name_max(p)
+        assert pathlib.PurePath(result).name == "_.py"
+        for part in pathlib.PurePath(result).parts:
+            assert len(part.encode()) <= 255
+
+    def test_overlong_basename_with_workspace(self):
+        """Overlong basename with workspace is sanitized, preserving suffix."""
+        long_name = "a" * 300 + ".py"
+        p = os.path.join(os.sep, _LONG_NETLOC, "src", long_name)
+        workspace = os.path.join(os.sep, "workspace")
+        result = sanitize_path_for_name_max(p, workspace=workspace)
+        assert pathlib.PurePath(result).name == "_.py"
+        for part in pathlib.PurePath(result).parts:
+            assert len(part.encode()) <= 255
+
+    def test_overlong_basename_replaced_preserving_suffix(self):
+        """If basename itself is too long, it gets replaced preserving suffix."""
+        long_name = "x" * 300 + ".py"
+        p = os.path.join(os.sep, "workspace", "src", long_name)
+        workspace = os.path.join(os.sep, "workspace")
+        result = sanitize_path_for_name_max(p, workspace=workspace)
+        # Should replace with "_.py" not reroute under workspace
+        assert pathlib.PurePath(result).name == "_.py"
+
+    def test_workspace_preserves_subpath(self):
+        """Intermediate directories below overlong component are preserved."""
+        p = os.path.join(os.sep, _LONG_NETLOC, "src", "pkg", "main.py")
+        workspace = os.path.join(os.sep, "ws")
+        result = sanitize_path_for_name_max(p, workspace=workspace)
+        assert result == os.path.join(os.sep, "ws", "src", "pkg", "main.py")
+
+    def test_workspace_with_overlong_basename_in_tail(self):
+        """Workspace branch sanitizes an overlong basename in the tail."""
+        long_name = "a" * 300 + ".py"
+        p = os.path.join(os.sep, _LONG_NETLOC, "workspace", long_name)
+        workspace = os.path.join(os.sep, "ws")
+        result = sanitize_path_for_name_max(p, workspace=workspace)
+        assert pathlib.PurePath(result).name == "_.py"
+        assert result.startswith(workspace)
+
+    def test_windows_limit_kind(self):
+        """Windows mode uses character count, not byte count."""
+        # 200 emoji chars = 200 characters but 800 UTF-8 bytes
+        # Should NOT exceed on windows (200 < 255) but WOULD exceed on posix (800 > 255)
+        component = "\U0001f600" * 200
+        p = os.path.join(os.sep, component, "file.py")
+        result_win = sanitize_path_for_name_max(p, limit_kind="windows")
+        result_posix = sanitize_path_for_name_max(p, limit_kind="posix")
+        # Windows: unchanged (200 chars < 255)
+        assert result_win == p
+        # POSIX: sanitized (800 bytes > 255)
+        assert result_posix != p
+        assert result_posix.endswith("file.py")
+
+    def test_root_components_ignored(self):
+        """Root/anchor parts like '/' are not flagged as overlong."""
+        p = os.path.join(os.sep, "normal", "path.py")
+        assert sanitize_path_for_name_max(p) == p
+
+    def test_unicode_posix_ascii_fast_path(self):
+        """ASCII-only strings that are short skip the byte-counting loop."""
+        p = os.path.join(os.sep, "a" * 255, "file.py")
+        # Exactly 255 is fine
+        assert sanitize_path_for_name_max(p) == p
+        # 256 exceeds
+        p2 = os.path.join(os.sep, "a" * 256, "file.py")
+        assert sanitize_path_for_name_max(p2) != p2

{vscode_common_python_lsp-0.5.1 → vscode_common_python_lsp-0.5.2}/vscode_common_python_lsp/__init__.py

@@ -58,6 +58,7 @@ from .paths import (
     is_same_path,
     normalize_path,
     reset_caches,
+    sanitize_path_for_name_max,
 )
 from .process_runner import (
     resolve_bundle_path,
@@ -84,6 +85,7 @@ __all__ = [
     "PythonFileKind",
     "is_match",
     "reset_caches",
+    "sanitize_path_for_name_max",
     # context
     "substitute_attr",
     "redirect_io",

{vscode_common_python_lsp-0.5.1 → vscode_common_python_lsp-0.5.2}/vscode_common_python_lsp/paths.py

@@ -13,7 +13,7 @@ import sys
 import sysconfig
 import threading
 from enum import Enum
-from typing import Any
+from typing import Any, Literal
 
 # Save the working directory used when loading this module
 SERVER_CWD = os.getcwd()
@@ -239,6 +239,138 @@ def normalize_path(file_path: str, resolve_symlinks: bool = True) -> str:
     return str(path)
 
 
+# Conservative maximum length of a single path component.  POSIX NAME_MAX is
+# 255 *bytes* (ext4, APFS, …).  NTFS actually limits to 255 UTF-16 code units,
+# so this byte-oriented heuristic is stricter than necessary on Windows — but
+# that is safe and keeps the logic simple across platforms.
+_NAME_MAX = 255
+
+PathComponentLimitKind = Literal["windows", "posix"]
+
+
+def _utf8_len_exceeds(s: str, limit: int) -> bool:
+    """Check if UTF-8 byte length of s exceeds limit, without allocating."""
+    total = 0
+
+    for ch in s:
+        code = ord(ch)
+
+        if code < 0x80:
+            total += 1
+        elif code < 0x800:
+            total += 2
+        elif code < 0x10000:
+            total += 3
+        else:
+            total += 4
+
+        if total > limit:
+            return True
+
+    return False
+
+
+def _component_exceeds_name_max(
+    component: str,
+    *,
+    limit_kind: PathComponentLimitKind,
+) -> bool:
+    # Ignore root/anchor-ish path parts.
+    if component in ("", "/", "\\") or component.endswith(":"):
+        return False
+
+    if limit_kind == "windows":
+        # Windows component limits are character-oriented for normal paths.
+        return len(component) > _NAME_MAX
+
+    # POSIX NAME_MAX is byte-oriented.
+    if len(component) > _NAME_MAX:
+        return True
+
+    if component.isascii():
+        return False
+
+    return _utf8_len_exceeds(component, _NAME_MAX)
+
+
+def sanitize_path_for_name_max(
+    fs_path: str,
+    workspace: str | None = None,
+    *,
+    limit_kind: PathComponentLimitKind = "posix",
+) -> str:
+    """Return *fs_path* with any overlong path components shortened.
+
+    Dev-container / tunnel URIs can embed a ``netloc`` component that far
+    exceeds the conservative 255-byte ``NAME_MAX`` heuristic used here
+    (ext4 and APFS use 255 bytes; NTFS uses 255 UTF-16 code units, so
+    this byte-oriented check is stricter than necessary on Windows).  When that
+    value is used as ``--stdin-filename`` or similar, the downstream tool
+    raises ``OSError: [Errno 36] File name too long``.
+
+    This helper replaces every overlong path component with ``_`` plus the
+    original file extension (e.g. ``_.py``), preserving the suffix that
+    downstream tools use for file-type dispatch.
+
+    If *workspace* is supplied and the overlong component is *not* the
+    basename, the path is re-rooted under the workspace while preserving
+    the full sub-path below the overlong component.  For example::
+
+        sanitize_path_for_name_max(
+            "/dev-container+<long>/workspace/src/pkg/main.py",
+            workspace="/workspace",
+        )
+        # → "/workspace/workspace/src/pkg/main.py"
+
+    If *fs_path* contains no overlong component, it is returned unchanged.
+
+    Parameters
+    ----------
+    fs_path:
+        Filesystem path derived from a document URI (e.g. via
+        ``pygls.uris.to_fs_path`` or VS Code's ``Uri.fsPath``).
+    workspace:
+        Optional workspace root path.  When provided and the overlong
+        component is not the basename, the result is
+        ``<workspace>/<sub-path>`` — the portion of the path below
+        the overlong component is preserved so that downstream tools
+        can still resolve config files and derive module names.
+    limit_kind:
+        Whether to apply Windows (character-count) or POSIX (byte-count)
+        limits.  Defaults to ``"posix"``.  Note: the POSIX byte-count
+        heuristic is conservative on NTFS, which actually limits to 255
+        UTF-16 code units.
+    """
+    path = pathlib.PurePath(fs_path)
+    parts = path.parts
+
+    safe_parts: list[str] | None = None
+
+    for i, part in enumerate(parts):
+        if not _component_exceeds_name_max(part, limit_kind=limit_kind):
+            continue
+
+        if workspace and i != len(parts) - 1:
+            # Preserve the sub-path below the overlong component so that
+            # intermediate directories (used by tools to locate config files
+            # and derive module names) are retained.
+            tail_parts = list(parts[i + 1 :])
+            for j, tp in enumerate(tail_parts):
+                if _component_exceeds_name_max(tp, limit_kind=limit_kind):
+                    tail_parts[j] = "_" + pathlib.PurePath(tp).suffix
+            return str(pathlib.PurePath(workspace, *tail_parts))
+
+        if safe_parts is None:
+            safe_parts = list(parts)
+
+        safe_parts[i] = "_" + pathlib.PurePath(part).suffix
+
+    if safe_parts is None:
+        return fs_path
+
+    return str(pathlib.PurePath(*safe_parts))
+
+
 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)

{vscode_common_python_lsp-0.5.1 → vscode_common_python_lsp-0.5.2}/vscode_common_python_lsp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vscode-common-python-lsp
-Version: 0.5.1
+Version: 0.5.2
 Summary: Shared Python utilities for VS Code Python tool extensions
 Author: Microsoft Corporation
 License-Expression: MIT