wexample-wex-addon-dev-python 11.2.0__tar.gz → 12.0.0__tar.gz

{wexample_wex_addon_dev_python-11.2.0 → wexample_wex_addon_dev_python-12.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wexample-wex-addon-dev-python
-Version: 11.2.0
+Version: 12.0.0
 Summary: Python dev addon for wex
 Author-Email: weeger <contact@wexample.com>
 License: MIT
@@ -17,8 +17,8 @@ Requires-Dist: pylint
 Requires-Dist: pyright
 Requires-Dist: wexample-api>=6.6.0
 Requires-Dist: wexample-filestate-python>=8.2.0
-Requires-Dist: wexample-wex-addon-ai>=11.2.0
-Requires-Dist: wexample-wex-addon-app>=26.0.0
+Requires-Dist: wexample-wex-addon-ai>=11.3.0
+Requires-Dist: wexample-wex-addon-app>=26.1.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -26,7 +26,7 @@ Description-Content-Type: text/markdown
 
 # wex_addon_dev_python
 
-Version: 11.2.0
+Version: 12.0.0
 
 Python dev addon for wex
 
@@ -114,8 +114,8 @@ Visit the [Wexample Suite documentation](https://docs.wexample.com) for the comp
 - pyright: 
 - wexample-api: >=6.6.0
 - wexample-filestate-python: >=8.2.0
-- wexample-wex-addon-ai: >=11.2.0
-- wexample-wex-addon-app: >=26.0.0
+- wexample-wex-addon-ai: >=11.3.0
+- wexample-wex-addon-app: >=26.1.0
 
 ## Versioning & Compatibility Policy
 

{wexample_wex_addon_dev_python-11.2.0 → wexample_wex_addon_dev_python-12.0.0}/README.md

@@ -1,6 +1,6 @@
 # wex_addon_dev_python
 
-Version: 11.2.0
+Version: 12.0.0
 
 Python dev addon for wex
 
@@ -88,8 +88,8 @@ Visit the [Wexample Suite documentation](https://docs.wexample.com) for the comp
 - pyright: 
 - wexample-api: >=6.6.0
 - wexample-filestate-python: >=8.2.0
-- wexample-wex-addon-ai: >=11.2.0
-- wexample-wex-addon-app: >=26.0.0
+- wexample-wex-addon-ai: >=11.3.0
+- wexample-wex-addon-app: >=26.1.0
 
 ## Versioning & Compatibility Policy
 

{wexample_wex_addon_dev_python-11.2.0 → wexample_wex_addon_dev_python-12.0.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "wexample-wex-addon-dev-python"
-version = "11.2.0"
+version = "12.0.0"
 description = "Python dev addon for wex"
 authors = [
     { name = "weeger", email = "contact@wexample.com" },
@@ -26,8 +26,8 @@ dependencies = [
     "pyright",
     "wexample-api>=6.6.0",
     "wexample-filestate-python>=8.2.0",
-    "wexample-wex-addon-ai>=11.2.0",
-    "wexample-wex-addon-app>=26.0.0",
+    "wexample-wex-addon-ai>=11.3.0",
+    "wexample-wex-addon-app>=26.1.0",
 ]
 
 [project.readme]

{wexample_wex_addon_dev_python-11.2.0 → wexample_wex_addon_dev_python-12.0.0}/src/wexample_wex_addon_dev_python/commands/code/rename.py

@@ -94,26 +94,24 @@ def python__code__rename(
             ),
         )
 
-    workdir_path = app_workdir.get_path()
+    scope_roots, suite_info = _resolve_scope_roots(context.kernel, app_workdir)
+
     handler = PythonPackageRenameHandler(
-        workdir_path=workdir_path,
+        scope_roots=scope_roots,
         source=source,
         target=target,
         dry_run=dry_run,
     )
     try:
         report = handler.run()
-    except FileNotFoundError:
-        return FailureResponse(
-            kernel=context.kernel,
-            message=(
-                f"No Python package matching '{source}' under {workdir_path}. "
-                "Check the dotted name (e.g. 'mylib.helpers') and that you're "
-                "in the right workdir."
-            ),
-        )
+    except FileNotFoundError as e:
+        return FailureResponse(kernel=context.kernel, message=str(e))
     except ValueError as e:
-        # Raised on ambiguous match (multiple packages) or invalid dotted name.
+        # Ambiguous match (multiple packages) or invalid dotted name.
+        return FailureResponse(kernel=context.kernel, message=str(e))
+    except RuntimeError as e:
+        # Preflight failure (permissions, target exists). Plan was thrown away,
+        # no file has been written — safe to surface as a clean failure.
         return FailureResponse(kernel=context.kernel, message=str(e))
 
     mode = "APPLIED" if not dry_run else "DRY-RUN"
@@ -121,14 +119,52 @@ def python__code__rename(
         f"[{mode}] {report.package_dir_old} → {report.package_dir_new}"
     )
     context.io.log(
-        f"[{mode}] scanned={report.files_scanned} changed={len(report.files_changed)}"
+        f"[{mode}] scope={suite_info} scanned={report.files_scanned} "
+        f"changed={len(report.files_changed)}"
     )
 
-    rows = [
-        [str(p.relative_to(workdir_path))] for p in report.files_changed
-    ]
+    # Display paths relative to the matched scope root they live under, so the
+    # output stays compact regardless of how many roots are involved.
+    rows = [[str(_shortest_rel(p, scope_roots))] for p in report.files_changed]
     return TableResponse(
         kernel=context.kernel,
         content=rows,
         headers=["File"],
     )
+
+
+def _resolve_scope_roots(kernel, app_workdir):
+    """Return (scope_roots, info_string).
+
+    Looks up a containing suite via `find_suite_workdir_path()`; if found,
+    materialises the suite workdir and returns the path of every ordered
+    sibling package. Otherwise falls back to the current workdir alone.
+    """
+    from wexample_wex_addon_app.app_addon_manager import AppAddonManager
+
+    suite_path = app_workdir.find_suite_workdir_path()
+    if not suite_path:
+        return [app_workdir.get_path()], f"workdir={app_workdir.get_path()}"
+
+    suite_workdir = AppAddonManager.from_kernel(kernel).create_app_workdir(
+        path=suite_path
+    )
+    packages = suite_workdir.get_ordered_packages()
+    if not packages:
+        return [app_workdir.get_path()], f"workdir={app_workdir.get_path()}"
+
+    roots = [p.get_path() for p in packages]
+    return roots, f"suite={suite_path} (packages={len(roots)})"
+
+
+def _shortest_rel(path, roots):
+    """Return `path` relative to the longest matching root, else absolute."""
+    best = None
+    for root in roots:
+        try:
+            rel = path.relative_to(root)
+        except ValueError:
+            continue
+        if best is None or len(rel.parts) < len(best.parts):
+            best = rel
+    return best if best is not None else path

wexample_wex_addon_dev_python-12.0.0/src/wexample_wex_addon_dev_python/refactor/applier.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from wexample_wex_addon_dev_python.refactor.rename_plan import RenamePlan
+
+
+class RenameApplier(ABC):
+    """Strategy that actually mutates the filesystem from a `RenamePlan`.
+
+    Kept abstract so we can swap a naive write/rename today for a
+    filestate-backed applier later (observability, rollback, dry-run unified
+    with the rest of the framework) without touching the handler/commands.
+    """
+
+    def apply(self, plan: RenamePlan) -> None:
+        """Default sequencing: all file writes first, then directory renames.
+
+        Subclasses may override for a different ordering or to wrap the whole
+        batch in a transaction.
+        """
+        for path, content in plan.rewrites.items():
+            self.write_file(path, content)
+        for old_dir, new_dir in plan.dir_renames:
+            self.rename_dir(old_dir, new_dir)
+
+    @abstractmethod
+    def rename_dir(self, old: Path, new: Path) -> None: ...
+
+    @abstractmethod
+    def write_file(self, path: Path, content: str) -> None: ...
+
+
+class NaiveRenameApplier(RenameApplier):
+    """Direct os-level applier. No rollback, no observability beyond the OS.
+
+    Sufficient for V2; deeper integration with filestate is deferred until we
+    measure that it pays off (volume, types of errors actually encountered).
+    """
+
+    def rename_dir(self, old: Path, new: Path) -> None:
+        old.rename(new)
+
+    def write_file(self, path: Path, content: str) -> None:
+        path.write_text(content, encoding="utf-8")

{wexample_wex_addon_dev_python-11.2.0 → wexample_wex_addon_dev_python-12.0.0}/src/wexample_wex_addon_dev_python/refactor/python_package_rename_handler.py

@@ -5,6 +5,12 @@ from pathlib import Path
 
 import libcst as cst
 
+from wexample_wex_addon_dev_python.refactor.applier import (
+    NaiveRenameApplier,
+    RenameApplier,
+)
+from wexample_wex_addon_dev_python.refactor.rename_plan import RenamePlan
+
 # Directories never scanned for source files (build/venv artefacts, VCS).
 _SKIP_DIR_NAMES: frozenset[str] = frozenset({
     "__pycache__",
@@ -52,6 +58,7 @@ class RenameReport:
     `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
@@ -59,25 +66,36 @@ class RenameReport:
 
 
 class PythonPackageRenameHandler:
-    """Rename a Python package (directory + its dotted name) within a workdir.
+    """Rename a Python package and propagate the change to importers.
+
+    Three phases, fully separated:
+      1. compute_plan() — read-only scan, builds a `RenamePlan` in memory.
+      2. plan.preflight() — validation (permissions, target existence).
+      3. applier.apply(plan) — single batch of writes + the directory rename.
 
-    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.
+    Splitting plan/apply is the durability strategy: a permission error mid-run
+    can't leave the repo half-rewritten. Splitting from the applier lets us
+    swap the write backend (naive → filestate-backed) without touching this
+    handler.
 
-    Scope = a single workdir. Cross-package propagation (suite-wide) is
-    delegated to a later step via the event bus.
+    `scope_roots` = the set of roots to sweep for both the source package
+    directory AND import rewrites. Caller passes the sibling-package roots
+    when running suite-wide (typically obtained via the framework's
+    `FrameworkPackageSuiteWorkdir.get_ordered_packages()`), or a single
+    workdir when running standalone.
     """
 
     def __init__(
         self,
-        workdir_path: Path,
+        scope_roots: list[Path],
         source: str,
         target: str,
         *,
         dry_run: bool = True,
     ) -> None:
-        self.workdir_path = workdir_path
+        if not scope_roots:
+            raise ValueError("scope_roots must contain at least one path")
+        self.scope_roots = scope_roots
         self.source = source
         self.target = target
         self.dry_run = dry_run
@@ -86,67 +104,96 @@ class PythonPackageRenameHandler:
         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 compute_plan(self) -> RenamePlan:
+        """Phase 1: scan and build the plan. No write yet."""
+        plan = RenamePlan()
+        package_dir = self.find_package_dir()
+        plan.dir_renames.append(
+            (package_dir, package_dir.parent / self._target_parts[-1])
+        )
+
+        for py_file in self._iter_python_files():
+            plan.files_scanned += 1
+            new_source = self._rewrite_imports(py_file)
+            if new_source is not None:
+                plan.rewrites[py_file] = new_source
+
+        return plan
+
     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
+        """Return the unique directory matching `source` across all scope roots."""
+        n = len(self._source_parts)
         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.parent.parts):  # skip filename "__init__.py"
-                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)
+        for root in self.scope_roots:
+            for init_file in root.rglob("__init__.py"):
+                if any(part in _SKIP_DIR_NAMES for part in init_file.parent.parts):
+                    continue
+                pkg_dir = init_file.parent
+                if len(pkg_dir.parts) < n:
+                    continue
+                if pkg_dir.parts[-n:] == self._source_parts:
+                    matches.append(pkg_dir)
+
+        # Same path discovered through two overlapping roots → dedupe.
+        unique = list({str(m): m for m in matches}.values())
 
-        if not matches:
+        if not unique:
+            roots_str = ", ".join(str(r) for r in self.scope_roots)
             raise FileNotFoundError(
-                f"No package directory matching '{self.source}' under {self.workdir_path}"
+                f"No package directory matching '{self.source}' under: {roots_str}"
             )
-        if len(matches) > 1:
-            joined = "\n  ".join(str(m) for m in matches)
+        if len(unique) > 1:
+            joined = "\n  ".join(str(m) for m in unique)
             raise ValueError(
                 f"Multiple packages match '{self.source}', refine the dotted name:\n  {joined}"
             )
-        return matches[0]
+        return unique[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]
+    def run(
+        self,
+        applier: RenameApplier | None = None,
+    ) -> RenameReport:
+        """Compute plan → preflight → apply (or stop after compute in dry-run)."""
+        plan = self.compute_plan()
+        old_dir, new_dir = plan.dir_renames[0]
+        report = RenameReport(
+            files_changed=list(plan.rewrites.keys()),
+            files_scanned=plan.files_scanned,
+            package_dir_new=new_dir,
+            package_dir_old=old_dir,
+        )
 
-        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 self.dry_run:
+            return report
 
-        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)
+        problems = plan.preflight()
+        if problems:
+            joined = "\n  - ".join(problems)
+            raise RuntimeError(f"Plan preflight failed:\n  - {joined}")
 
+        (applier or NaiveRenameApplier()).apply(plan)
         return report
 
     def _iter_python_files(self):
-        stack: list[Path] = [self.workdir_path]
-        while stack:
-            current = stack.pop()
-            try:
-                # Iterate the OS generator directly — avoids a list allocation per dir.
-                for entry in current.iterdir():
-                    if entry.is_dir():
-                        if entry.name not in _SKIP_DIR_NAMES:
-                            stack.append(entry)
-                    elif entry.suffix == ".py":
-                        yield entry
-            except (PermissionError, FileNotFoundError):
-                continue
+        """Iterate every .py file under any scope root, skipping build/VCS dirs."""
+        seen: set[str] = set()
+        for root in self.scope_roots:
+            stack: list[Path] = [root]
+            while stack:
+                current = stack.pop()
+                try:
+                    for entry in current.iterdir():
+                        if entry.is_dir():
+                            if entry.name not in _SKIP_DIR_NAMES:
+                                stack.append(entry)
+                        elif entry.suffix == ".py":
+                            key = str(entry.resolve())
+                            if key in seen:
+                                continue
+                            seen.add(key)
+                            yield entry
+                except (PermissionError, FileNotFoundError):
+                    continue
 
     def _rewrite_imports(self, py_file: Path) -> str | None:
         """Return rewritten source, or None when no import touched this file."""
@@ -173,8 +220,7 @@ class _ImportRenameTransformer(cst.CSTTransformer):
         super().__init__()
         self.old_parts = old_parts
         self.new_parts = new_parts
-        self._n = len(old_parts)  # cached: avoid repeated len() + attr-lookup
-        self._old_parts_0 = old_parts[0]  # fast first-element guard in _starts_with
+        self._n = len(old_parts)
         self.changed = False
 
     def leave_Import(
@@ -202,7 +248,6 @@ class _ImportRenameTransformer(cst.CSTTransformer):
         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)
@@ -213,8 +258,4 @@ class _ImportRenameTransformer(cst.CSTTransformer):
         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[0] == self._old_parts_0  # fast guard: avoid slice alloc on mismatch
-            and parts[: self._n] == self.old_parts
-        )
+        return len(parts) >= self._n and parts[: self._n] == self.old_parts

wexample_wex_addon_dev_python-12.0.0/src/wexample_wex_addon_dev_python/refactor/rename_plan.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class RenamePlan:
+    """Everything a rename will touch, fully computed before any disk write.
+
+    The plan is collected, validated (`preflight`), then applied as one batch.
+    Splitting the phases means a permission error or a target-already-exists
+    error stops the run before any partial change reaches the filesystem.
+    """
+
+    rewrites: dict[Path, str] = field(default_factory=dict)
+    """Per-file new source code. Keys = absolute file paths."""
+
+    dir_renames: list[tuple[Path, Path]] = field(default_factory=list)
+    """(old_dir, new_dir) pairs. Ordered: applied last, after rewrites."""
+
+    files_scanned: int = 0
+    """Total .py files inspected (for reporting)."""
+
+    def preflight(self) -> list[str]:
+        """Return a list of human-readable problems, empty if plan can run.
+
+        Checks (cheap, no writes):
+          - each file in `rewrites` is writable
+          - each `dir_rename` target doesn't already exist
+          - each `dir_rename` source exists
+        """
+        problems: list[str] = []
+        for path in self.rewrites:
+            if not os.access(path, os.W_OK):
+                problems.append(f"Not writable: {path}")
+        for old_dir, new_dir in self.dir_renames:
+            if not old_dir.exists():
+                problems.append(f"Source directory missing: {old_dir}")
+            if new_dir.exists():
+                problems.append(f"Target directory already exists: {new_dir}")
+        return problems

{wexample_wex_addon_dev_python-11.2.0 → wexample_wex_addon_dev_python-12.0.0}/src/wexample_wex_addon_dev_python/selection/python_code_performance_selection.py

@@ -12,6 +12,10 @@ from wexample_wex_addon_dev_python.selection.abstract_python_code_selection impo
 if TYPE_CHECKING:
     from pathlib import Path
 
+# Hoisted to module scope so the generator inside `is_candidate` captures it via
+# a single LOAD_DEREF (closure) instead of rebuilding the tuple on each call.
+_FUNC_TYPES: tuple[type, ...] = (ast.FunctionDef, ast.AsyncFunctionDef)
+
 
 @base_class
 class PythonCodePerformanceSelection(AbstractPythonCodeSelection):
@@ -78,9 +82,14 @@ class PythonCodePerformanceSelection(AbstractPythonCodeSelection):
             tree = ast.parse(source)
         except SyntaxError:
             return False
+        # Local bindings keep hot-path overhead minimal:
+        # - `func_types`: one LOAD_DEREF instead of LOAD_GLOBAL per generator tick.
+        # - `is_trivial`: one LOAD_DEREF instead of LOAD_DEREF(self)+LOAD_ATTR
+        #   for every function-def node that passes the isinstance guard.
+        func_types = _FUNC_TYPES
+        is_trivial = self._is_trivial_function
         return any(
-            isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
-            and not self._is_trivial_function(node)
+            isinstance(node, func_types) and not is_trivial(node)
             for node in ast.walk(tree)
         )
 
@@ -92,7 +101,11 @@ class PythonCodePerformanceSelection(AbstractPythonCodeSelection):
         - `pass`.
         - `...` (Ellipsis statement — modern stub idiom).
         - `raise NotImplementedError` or `raise NotImplementedError(...)`.
-        - `super().__init__(...)` only, when the function IS `__init__`.
+        - `super().<same_name>(...)` (with or without `return`) — pure
+          pass-through to the parent. Matches when the called super-method
+          name equals the wrapping function's name; a mismatched name is
+          almost certainly a bug or unusual API and we let the perf agent
+          look at it.
 
         Plus: any decorator named `abstractmethod` (bare or qualified like
         `abc.abstractmethod`) → trivial regardless of body. Abstract definitions
@@ -104,13 +117,9 @@ class PythonCodePerformanceSelection(AbstractPythonCodeSelection):
         check decoupled from its container.
         """
         for deco in node.decorator_list:
-            deco_name = (
-                deco.id
-                if isinstance(deco, ast.Name)
-                else deco.attr
-                if isinstance(deco, ast.Attribute)
-                else None
-            )
+            # `ast.Name` has `id`; `ast.Attribute` has `attr`; other node types
+            # have neither — two C-level getattr probes beat two isinstance calls.
+            deco_name = getattr(deco, "id", None) or getattr(deco, "attr", None)
             if deco_name == "abstractmethod":
                 return True
 
@@ -153,19 +162,28 @@ class PythonCodePerformanceSelection(AbstractPythonCodeSelection):
             ):
                 return True
 
-        if node.name == "__init__" and isinstance(stmt, ast.Expr):
+        # Same-name super pass-through: `super().<node.name>(...)` as either a
+        # bare expression or a return value. Matches `def foo(...): super().foo(...)`,
+        # `def foo(...): return super().foo(...)`, and the historical `__init__`
+        # case (which is subsumed). Different-name super calls (`def cleanup():
+        # super().close()`) intentionally fall through — that's not a textbook
+        # pass-through and might be hiding intent.
+        call = None
+        if isinstance(stmt, ast.Expr):
+            call = stmt.value
+        elif isinstance(stmt, ast.Return) and stmt.value is not None:
             call = stmt.value
+        if (
+            isinstance(call, ast.Call)
+            and isinstance(call.func, ast.Attribute)
+            and call.func.attr == node.name
+        ):
+            base = call.func.value
             if (
-                isinstance(call, ast.Call)
-                and isinstance(call.func, ast.Attribute)
-                and call.func.attr == "__init__"
+                isinstance(base, ast.Call)
+                and isinstance(base.func, ast.Name)
+                and base.func.id == "super"
             ):
-                base = call.func.value
-                if (
-                    isinstance(base, ast.Call)
-                    and isinstance(base.func, ast.Name)
-                    and base.func.id == "super"
-                ):
-                    return True
+                return True
 
         return False