wexample-wex-addon-dev-python 10.2.0__py3-none-any.whl → 11.1.0__py3-none-any.whl

wexample_wex_addon_dev_python/middleware/each_python_file_middleware.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 from typing import TYPE_CHECKING
 
 from wexample_wex_core.middleware.each_file_middleware import EachFileMiddleware
@@ -32,12 +33,13 @@ class EachPythonFileMiddleware(EachFileMiddleware):
     python_extension_only: bool = True
 
     def __init__(self, **kwargs) -> None:
-        # Allow overriding the default settings
-        if "python_extension_only" in kwargs:
-            self.python_extension_only = kwargs.pop("python_extension_only")
-
-        if "ignored_directories" in kwargs:
-            self.ignored_directories = set(kwargs.pop("ignored_directories"))
+        # Allow overriding the default settings (pop avoids a double-lookup)
+        self.python_extension_only = kwargs.pop(
+            "python_extension_only", self.python_extension_only
+        )
+        ignored = kwargs.pop("ignored_directories", None)
+        if ignored is not None:
+            self.ignored_directories = set(ignored)
 
         super().__init__(**kwargs)
 
@@ -65,13 +67,9 @@ class EachPythonFileMiddleware(EachFileMiddleware):
         Returns:
             True if the item should be processed, False otherwise
         """
-        # First check if it's a file (parent class behavior)
-        if not os.path.isfile(item_path):
+        # Cheap string check before the expensive isfile() syscall: skip
+        # non-.py paths immediately when extension filtering is active.
+        if self.python_extension_only and not item_path.endswith(".py"):
             return False
 
-        # If python_extension_only is enabled, check file extension
-        if self.python_extension_only:
-            return item_path.endswith(".py")
-
-        # Otherwise, accept all files
-        return True
+        return os.path.isfile(item_path)

wexample_wex_addon_dev_python/refactor/__init__.py

@@ -0,0 +1,7 @@
+"""Code-refactor primitives.
+
+Step 1: support `kind=package` only. Designed to grow to module / class /
+function / constant / method through the same `SymbolKind` enum.
+"""
+
+from __future__ import annotations

wexample_wex_addon_dev_python/refactor/python_package_rename_handler.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import libcst as cst
+
+# Directories never scanned for source files (build/venv artefacts, VCS).
+_SKIP_DIR_NAMES: frozenset[str] = frozenset({
+    "__pycache__",
+    ".venv",
+    "venv",
+    "env",
+    ".git",
+    "node_modules",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".pdm-build",
+    "dist",
+    "build",
+})
+
+
+def _dotted_to_parts(node) -> tuple[str, ...] | None:
+    """Flatten a chained `cst.Attribute` / `cst.Name` into ('a', 'b', 'c')."""
+    parts: list[str] = []
+    cur = node
+    while isinstance(cur, cst.Attribute):
+        if not isinstance(cur.attr, cst.Name):
+            return None
+        parts.append(cur.attr.value)
+        cur = cur.value
+    if not isinstance(cur, cst.Name):
+        return None
+    parts.append(cur.value)
+    parts.reverse()
+    return tuple(parts)
+
+
+def _parts_to_dotted(parts: tuple[str, ...]):
+    node: cst.BaseExpression = cst.Name(parts[0])
+    for part in parts[1:]:
+        node = cst.Attribute(value=node, attr=cst.Name(part))
+    return node
+
+
+@dataclass
+class RenameReport:
+    """Outcome of a package rename run.
+
+    `package_dir_old`/`new` describe the move (or proposed move in dry-run).
+    `files_changed` lists every .py whose imports were rewritten.
+    """
+    files_changed: list[Path] = field(default_factory=list)
+    files_scanned: int = 0
+    package_dir_new: Path | None = None
+    package_dir_old: Path | None = None
+
+
+class PythonPackageRenameHandler:
+    """Rename a Python package (directory + its dotted name) within a workdir.
+
+    Locates the directory whose path tail matches `source` (split on `.`),
+    rewrites every `import …` / `from … import …` that starts with `source`
+    to use `target` instead, and finally renames the directory on disk.
+
+    Scope = a single workdir. Cross-package propagation (suite-wide) is
+    delegated to a later step via the event bus.
+    """
+
+    def __init__(
+        self,
+        workdir_path: Path,
+        source: str,
+        target: str,
+        *,
+        dry_run: bool = True,
+    ) -> None:
+        self.workdir_path = workdir_path
+        self.source = source
+        self.target = target
+        self.dry_run = dry_run
+        self._source_parts: tuple[str, ...] = tuple(source.split("."))
+        self._target_parts: tuple[str, ...] = tuple(target.split("."))
+        if not all(self._source_parts) or not all(self._target_parts):
+            raise ValueError("source and target must be dotted names without empty parts")
+
+    def find_package_dir(self) -> Path:
+        """Return the unique directory matching `source` as a Python package."""
+        n = len(self._source_parts)  # hoisted: avoid recomputing per candidate
+        matches: list[Path] = []
+        for init_file in self.workdir_path.rglob("__init__.py"):
+            if any(part in _SKIP_DIR_NAMES for part in init_file.parts):
+                continue
+            pkg_dir = init_file.parent
+            if len(pkg_dir.parts) < n:
+                continue
+            if pkg_dir.parts[-n:] == self._source_parts:  # tuple cmp, no Path alloc
+                matches.append(pkg_dir)
+
+        if not matches:
+            raise FileNotFoundError(
+                f"No package directory matching '{self.source}' under {self.workdir_path}"
+            )
+        if len(matches) > 1:
+            joined = "\n  ".join(str(m) for m in matches)
+            raise ValueError(
+                f"Multiple packages match '{self.source}', refine the dotted name:\n  {joined}"
+            )
+        return matches[0]
+
+    def run(self) -> RenameReport:
+        report = RenameReport()
+        package_dir = self.find_package_dir()
+        report.package_dir_old = package_dir
+        report.package_dir_new = package_dir.parent / self._target_parts[-1]
+
+        for py_file in self._iter_python_files():
+            report.files_scanned += 1
+            new_source = self._rewrite_imports(py_file)
+            if new_source is None:
+                continue
+            report.files_changed.append(py_file)
+            if not self.dry_run:
+                py_file.write_text(new_source, encoding="utf-8")
+
+        if not self.dry_run:
+            # Move happens AFTER rewrites: a file under the package itself
+            # would otherwise be looked up at the new path that doesn't exist
+            # yet during the rewrite pass.
+            package_dir.rename(report.package_dir_new)
+
+        return report
+
+    def _iter_python_files(self):
+        stack: list[Path] = [self.workdir_path]
+        while stack:
+            current = stack.pop()
+            try:
+                entries = list(current.iterdir())
+            except (PermissionError, FileNotFoundError):
+                continue
+            for entry in entries:
+                if entry.is_dir():
+                    if entry.name not in _SKIP_DIR_NAMES:
+                        stack.append(entry)
+                elif entry.suffix == ".py":
+                    yield entry
+
+    def _rewrite_imports(self, py_file: Path) -> str | None:
+        """Return rewritten source, or None when no import touched this file."""
+        source = py_file.read_text(encoding="utf-8")
+        try:
+            module = cst.parse_module(source)
+        except cst.ParserSyntaxError:
+            return None
+
+        transformer = _ImportRenameTransformer(
+            old_parts=self._source_parts,
+            new_parts=self._target_parts,
+        )
+        new_module = module.visit(transformer)
+        if not transformer.changed:
+            return None
+        return new_module.code
+
+
+class _ImportRenameTransformer(cst.CSTTransformer):
+    """Rewrites import statements whose dotted name starts with `old_parts`."""
+
+    def __init__(self, old_parts: tuple[str, ...], new_parts: tuple[str, ...]) -> None:
+        super().__init__()
+        self.old_parts = old_parts
+        self.new_parts = new_parts
+        self._n = len(old_parts)  # cached: avoid repeated len() + attr-lookup
+        self.changed = False
+
+    def leave_Import(
+        self,
+        original_node: cst.Import,
+        updated_node: cst.Import,
+    ) -> cst.Import:
+        new_names = []
+        touched = False
+        for alias in updated_node.names:
+            parts = _dotted_to_parts(alias.name)
+            if parts is None or not self._starts_with(parts):
+                new_names.append(alias)
+                continue
+            new_parts = self.new_parts + parts[self._n:]
+            new_names.append(alias.with_changes(name=_parts_to_dotted(new_parts)))
+            touched = True
+        if not touched:
+            return updated_node
+        self.changed = True
+        return updated_node.with_changes(names=new_names)
+
+    def leave_ImportFrom(
+        self,
+        original_node: cst.ImportFrom,
+        updated_node: cst.ImportFrom,
+    ) -> cst.ImportFrom:
+        # `from . import X` has module=None; relative imports are out of scope.
+        if updated_node.module is None:
+            return updated_node
+        parts = _dotted_to_parts(updated_node.module)
+        if parts is None or not self._starts_with(parts):
+            return updated_node
+        new_parts = self.new_parts + parts[self._n:]
+        self.changed = True
+        return updated_node.with_changes(module=_parts_to_dotted(new_parts))
+
+    def _starts_with(self, parts: tuple[str, ...]) -> bool:
+        return len(parts) >= self._n and parts[: self._n] == self.old_parts

wexample_wex_addon_dev_python/refactor/symbol_kind.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class SymbolKind(str, Enum):
+    """The kind of symbol targeted by a rename.
+
+    Step 1 only implements PACKAGE; the other members are listed so callers can
+    already pass `--kind class` and get a clear `NotImplementedError` instead
+    of a parsing error.
+    """
+
+    PACKAGE = "package"
+    MODULE = "module"
+    CLASS = "class"
+    FUNCTION = "function"
+    METHOD = "method"
+    CONSTANT = "constant"

wexample_wex_addon_dev_python/selection/abstract_python_code_selection.py

@@ -32,14 +32,27 @@ class AbstractPythonCodeSelection(AbstractCodeFromDirectorySelection):
     MIN_SIZE_BYTES: ClassVar[int] = 50
 
     def get_excluded_file_names(self) -> tuple[str, ...]:
-        return super().get_excluded_file_names() + ("__init__.py",)
+        try:
+            return self._excl_file_names  # type: ignore[attr-defined]
+        except AttributeError:
+            self._excl_file_names: tuple[str, ...] = (
+                super().get_excluded_file_names() + ("__init__.py",)
+            )
+            return self._excl_file_names
 
     def get_excluded_path_fragments(self) -> tuple[str, ...]:
-        return super().get_excluded_path_fragments() + (
-            "__pycache__",
-            "/tests/",
-            "/build/",
-            "/dist/",
-            "/.venv/",
-            "/.pdm-build/",
-        )
+        try:
+            return self._excl_path_frags  # type: ignore[attr-defined]
+        except AttributeError:
+            self._excl_path_frags: tuple[str, ...] = (
+                super().get_excluded_path_fragments()
+                + (
+                    "__pycache__",
+                    "/tests/",
+                    "/build/",
+                    "/dist/",
+                    "/.venv/",
+                    "/.pdm-build/",
+                )
+            )
+            return self._excl_path_frags

wexample_wex_addon_dev_python/selection/python_code_performance_selection.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import ast
 from typing import TYPE_CHECKING, ClassVar
 
 from wexample_helpers.decorator.base_class import base_class
@@ -67,8 +68,6 @@ class PythonCodePerformanceSelection(AbstractPythonCodeSelection):
         files isn't what this sweep is for, the operator fixes those first.
         Other I/O errors (FileNotFoundError, PermissionError) propagate.
         """
-        import ast
-
         if not super().is_candidate(item):
             return False
         try:
@@ -104,8 +103,6 @@ class PythonCodePerformanceSelection(AbstractPythonCodeSelection):
         already visits every descendant function independently. Keeps each
         check decoupled from its container.
         """
-        import ast
-
         for deco in node.decorator_list:
             deco_name = (
                 deco.id
@@ -117,21 +114,23 @@ class PythonCodePerformanceSelection(AbstractPythonCodeSelection):
             if deco_name == "abstractmethod":
                 return True
 
-        body = list(node.body)
+        body = node.body
+        start = 0
         if (
             body
             and isinstance(body[0], ast.Expr)
             and isinstance(body[0].value, ast.Constant)
             and isinstance(body[0].value.value, str)
         ):
-            body = body[1:]
+            start = 1
 
-        if not body:
+        effective_len = len(body) - start
+        if effective_len == 0:
             return True
-        if len(body) != 1:
+        if effective_len != 1:
             return False
 
-        stmt = body[0]
+        stmt = body[start]
 
         if isinstance(stmt, ast.Pass):
             return True

wexample_wex_addon_dev_python/services/python/commands/service/install.py

@@ -29,27 +29,24 @@ def python__service__install(
     context: ExecutionContext,
     service: AppService,
 ) -> None:
-    project_name = service.app_workdir.get_project_name()
-
     config_file = service.app_workdir.get_config_file()
     config = config_file.read_config()
 
-    from wexample_app.const.globals import WORKDIR_SETUP_DIR
-
     if config.search("docker.images").is_none():
+        from wexample_app.const.globals import WORKDIR_SETUP_DIR
+
+        project_name = service.app_workdir.get_project_name()
+        docker_images_dir = WORKDIR_SETUP_DIR / "docker" / "images"
+
         config.set_by_path(
             "docker.images",
             {
                 "base": {
-                    "dockerfile": str(
-                        WORKDIR_SETUP_DIR / "docker" / "images" / "Dockerfile.base"
-                    ),
+                    "dockerfile": str(docker_images_dir / "Dockerfile.base"),
                     "tag": f"{project_name}:local",
                 },
                 "develop": {
-                    "dockerfile": str(
-                        WORKDIR_SETUP_DIR / "docker" / "images" / "Dockerfile.develop"
-                    ),
+                    "dockerfile": str(docker_images_dir / "Dockerfile.develop"),
                     "tag": f"{project_name}-dev:local",
                     "depends_on": "base",
                 },

wexample_wex_addon_dev_python/services/python/commands/service/setup.py

@@ -53,16 +53,18 @@ def python__service__setup(
         return
 
     ordered = resolve_build_order(builds)
+    app_path_str = str(app_path)
 
     for build_name in ordered:
         build = builds[build_name]
         dockerfile = str(app_path / build["dockerfile"])
         tag = build["tag"]
         cmd = ["docker", "build", "-f", dockerfile, "-t", tag]
-        if "depends_on" in build:
-            parent_tag = builds[build["depends_on"]]["tag"]
+        depends_on = build.get("depends_on")
+        if depends_on is not None:
+            parent_tag = builds[depends_on]["tag"]
             cmd += ["--build-arg", f"BASE_IMAGE={parent_tag}"]
-        cmd.append(str(app_path))
+        cmd.append(app_path_str)
         context.io.log(f"Building image '{build_name}' → {tag}")
         subprocess.run(cmd, check=True)
 

wexample_wex_addon_dev_python/workdir/mixin/with_profiling_python_workdir_mixin.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from pathlib import Path
+
 from wexample_helpers.decorator.base_class import base_class
 from wexample_wex_addon_app.workdir.mixin.abstract_profiling_workdir_mixin import (
     AbstractProfilingWorkdirMixin,
@@ -24,7 +26,8 @@ class WithProfilingPythonWorkdirMixin(AbstractProfilingWorkdirMixin):
         import json
         import subprocess
 
-        bench_output_path = self.get_path() / self._BENCH_OUTPUT_FILENAME
+        workdir_path = self.get_path()
+        bench_output_path = workdir_path / self._BENCH_OUTPUT_FILENAME
         python = self._get_profiling_python()
 
         bench_result = subprocess.run(
@@ -39,7 +42,7 @@ class WithProfilingPythonWorkdirMixin(AbstractProfilingWorkdirMixin):
             ],
             capture_output=True,
             text=True,
-            cwd=str(self.get_path()),
+            cwd=str(workdir_path),
         )
 
         if not bench_output_path.exists():
@@ -69,27 +72,23 @@ class WithProfilingPythonWorkdirMixin(AbstractProfilingWorkdirMixin):
 
     def _get_profiling_python(self) -> Path:
         import sys
-        from pathlib import Path
 
         return Path(sys.executable)
 
     def _parse_profiling_output(self, raw: dict) -> dict:
-        entries = []
-        for bench in raw.get("benchmarks", []):
+        def _bench_entry(bench: dict) -> dict:
             stats = bench.get("stats", {})
-            entries.append(
-                {
-                    "name": bench.get("name"),
-                    "min_ms": round(stats.get("min", 0) * 1000, 3),
-                    "mean_ms": round(stats.get("mean", 0) * 1000, 3),
-                    "median_ms": round(stats.get("median", 0) * 1000, 3),
-                    "max_ms": round(stats.get("max", 0) * 1000, 3),
-                    "rounds": stats.get("rounds", 0),
-                }
-            )
+            return {
+                "name": bench.get("name"),
+                "min_ms": round(stats.get("min", 0) * 1000, 3),
+                "mean_ms": round(stats.get("mean", 0) * 1000, 3),
+                "median_ms": round(stats.get("median", 0) * 1000, 3),
+                "max_ms": round(stats.get("max", 0) * 1000, 3),
+                "rounds": stats.get("rounds", 0),
+            }
 
         return {
             "language": "python",
             "tool": "pytest-benchmark",
-            "entries": entries,
+            "entries": [_bench_entry(b) for b in raw.get("benchmarks", [])],
         }

wexample_wex_addon_dev_python/workdir/python_package_workdir.py

@@ -156,10 +156,11 @@ class PythonPackageWorkdir(PythonWorkdir):
         import re
 
         pkg = searched_package.get_package_import_name()
+        escaped = re.escape(pkg)
         pattern = (
             rf"(?m)^\s*(?:"
-            rf"from\s+{re.escape(pkg)}(?:\.[\w\.]+)?\s+import\s+"
-            rf"|import\s+{re.escape(pkg)}(?:\.[\w\.]+)?(?:\s+as\s+\w+)?\b"
+            rf"from\s+{escaped}(?:\.[\w\.]+)?\s+import\s+"
+            rf"|import\s+{escaped}(?:\.[\w\.]+)?(?:\s+as\s+\w+)?\b"
             rf")"
         )
         return self.search_in_codebase(pattern, regex=True, flags=re.MULTILINE)
@@ -198,7 +199,8 @@ class PythonPackageWorkdir(PythonWorkdir):
             import griffe
 
             module_name = self.get_package_name().replace("-", "_")
-            repo_path = str(self.get_path())
+            path = self.get_path()
+            repo_path = str(path)
 
             previous = griffe.load_git(
                 module_name,
@@ -208,10 +210,10 @@ class PythonPackageWorkdir(PythonWorkdir):
             )
             current = griffe.load(
                 module_name,
-                search_paths=[str(self.get_path() / "src")],
+                search_paths=[str(path / "src")],
             )
 
-            if list(griffe.find_breaking_changes(previous, current)):
+            if any(griffe.find_breaking_changes(previous, current)):
                 return UPGRADE_TYPE_MAJOR
 
             return UPGRADE_TYPE_INTERMEDIATE
@@ -353,7 +355,7 @@ class PythonPackageWorkdir(PythonWorkdir):
                 )
                 python_install_dependencies_in_venv(
                     venv_path=venv_path,
-                    names=self.get_app_config_file().optional_group_array(group="dev"),
+                    names=toml_file.optional_group_array(group="dev"),
                 )
 
             self.subtitle(
@@ -489,7 +491,7 @@ class PythonPackageWorkdir(PythonWorkdir):
             )
 
         PollingCallbackManager(
-            callback=lambda: True if gateway.has_version(package, version) else None,
+            callback=lambda: gateway.has_version(package, version) or None,
             max_attempts=max_attempts,
             delay_seconds_callback=lambda _attempt: delay_seconds,
             on_retry_callback=on_retry,

wexample_wex_addon_dev_python/workdir/python_packages_suite_workdir.py

@@ -52,9 +52,8 @@ class PythonPackagesSuiteWorkdir(FrameworkPackageSuiteWorkdir):
         for n in sorted(nodes):
             G.add_node(n)
         for src in sorted(dependencies_map.keys()):
-            for dst in sorted(dependencies_map.get(src, [])):
-                if dst in nodes:
-                    G.add_edge(src, dst)
+            for dst in sorted(dependencies_map[src]):
+                G.add_edge(src, dst)
 
         if not (G.has_node(start) and G.has_node(target)):
             return []