wexample-wex-addon-dev-python 12.2.0__py3-none-any.whl → 13.0.0__py3-none-any.whl

wexample_wex_addon_dev_python/refactor/python_package_rename_handler.py

@@ -1,132 +1,41 @@
 from __future__ import annotations
 
-from dataclasses import dataclass, field
 from pathlib import Path
 
-import libcst as cst
+from wexample_helpers.decorator.base_class import base_class
 
-from wexample_wex_addon_dev_python.refactor.applier import (
-    NaiveRenameApplier,
-    RenameApplier,
+from wexample_wex_addon_dev_python.refactor.abstract_python_path_rename_handler import (
+    AbstractPythonPathRenameHandler,
 )
+from wexample_wex_addon_dev_python.refactor.python_common import SKIP_DIR_NAMES
 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__",
-    ".venv",
-    "venv",
-    "env",
-    ".git",
-    "node_modules",
-    ".pytest_cache",
-    ".mypy_cache",
-    ".ruff_cache",
-    ".pdm-build",
-    "dist",
-    "build",
-})
 
+@base_class
+class PythonPackageRenameHandler(AbstractPythonPathRenameHandler):
+    """Rename a Python package (a directory containing `__init__.py`) and
+    propagate the import-rewrite across every scope root.
 
-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 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.
-
-    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_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.
+    When the target directory already exists (typically because the user has
+    been migrating modules one at a time before flipping the rest in bulk),
+    the handler switches to a merge mode: each child of the source dir is
+    moved into the target, identical/empty `__init__.py` duplicates are
+    dropped, and the now-empty source dir is removed. Any non-identical,
+    non-empty file collision is surfaced as a clean error instead of being
+    silently overwritten.
     """
 
-    def __init__(
-        self,
-        scope_roots: list[Path],
-        source: str,
-        target: str,
-        *,
-        dry_run: bool = True,
-    ) -> None:
-        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
-        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 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 _derive_target_path(self, source_path: Path) -> Path:
+        # A package rename is a sibling-directory move: same parent, last part
+        # swapped for the target's last part.
+        return source_path.parent / self._target_parts[-1]
 
-    def find_package_dir(self) -> Path:
-        """Return the unique directory matching `source` across all scope roots."""
+    def _find_source_path(self) -> Path:
         n = len(self._source_parts)
         matches: list[Path] = []
         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):
+                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:
@@ -149,113 +58,68 @@ class PythonPackageRenameHandler:
             )
         return unique[0]
 
-    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,
-        )
-
-        if self.dry_run:
-            return report
-
-        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):
-        """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."""
-        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)
-        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)
+    def _plan_merge_into_existing(
+        self, plan: RenamePlan, source_dir: Path, target_dir: Path
+    ) -> None:
+        """Merge every child of `source_dir` into `target_dir`, then remove
+        the now-empty `source_dir`.
+
+        Conflict resolution per child:
+          - target missing       → move source child in
+          - both directories     → unsupported in this palier; refuse
+          - both files, equal    → drop source's copy (it's a duplicate)
+          - source file empty    → drop source's copy (target wins)
+          - non-empty mismatch   → refuse with a clear error
+        """
+        for entry in sorted(source_dir.iterdir()):
+            # Build/VCS artefacts (`__pycache__`, `.pytest_cache`, …) block
+            # the non-recursive rmdir but they're regenerable, so we purge
+            # them instead of refusing the whole merge.
+            if entry.is_dir() and entry.name in SKIP_DIR_NAMES:
+                plan.directories_to_purge.append(entry)
                 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:
-        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))
+            target_entry = target_dir / entry.name
+            if not target_entry.exists():
+                plan.path_renames.append((entry, target_entry))
+                continue
 
-    def _starts_with(self, parts: tuple[str, ...]) -> bool:
-        return len(parts) >= self._n and parts[: self._n] == self.old_parts
+            if entry.is_dir() or target_entry.is_dir():
+                raise RuntimeError(
+                    "Nested directory merge is not supported in this palier "
+                    f"(conflict on {entry.name}). Move that subtree manually "
+                    "before retrying the package rename."
+                )
+
+            try:
+                src_content = entry.read_text(encoding="utf-8")
+                tgt_content = target_entry.read_text(encoding="utf-8")
+            except OSError as e:
+                raise RuntimeError(
+                    f"Cannot read content while planning merge: {e}"
+                )
+
+            if src_content == tgt_content or src_content == "":
+                plan.files_to_delete.append(entry)
+            else:
+                raise RuntimeError(
+                    "Merge conflict — different non-empty file contents:\n"
+                    f"  source: {entry}\n"
+                    f"  target: {target_entry}\n"
+                    "Reconcile manually before retrying."
+                )
+
+        plan.directories_to_remove.append(source_dir)
+
+    def _plan_path_move(
+        self, plan: RenamePlan, source_path: Path, target_path: Path
+    ) -> None:
+        if not target_path.exists():
+            super()._plan_path_move(plan, source_path, target_path)
+            return
+        if not (source_path.is_dir() and target_path.is_dir()):
+            raise RuntimeError(
+                f"Cannot merge: source or target is not a directory "
+                f"({source_path} → {target_path})"
+            )
+        self._plan_merge_into_existing(plan, source_path, target_path)

wexample_wex_addon_dev_python/refactor/rename_plan.py

@@ -15,29 +15,70 @@ class RenamePlan:
     """
 
     rewrites: dict[Path, str] = field(default_factory=dict)
-    """Per-file new source code. Keys = absolute file paths."""
+    """Per-file new source code. Keys = absolute file paths. May include
+    `__init__.py` files for directories listed in `directories_to_create`."""
 
-    dir_renames: list[tuple[Path, Path]] = field(default_factory=list)
-    """(old_dir, new_dir) pairs. Ordered: applied last, after rewrites."""
+    path_renames: list[tuple[Path, Path]] = field(default_factory=list)
+    """(old, new) pairs — files or directories. Applied after rewrites and
+    directory creation, before file/dir deletions."""
+
+    directories_to_create: list[Path] = field(default_factory=list)
+    """Directories that don't exist yet and must be created before any
+    rewrite or path rename runs. Ordered outermost-first so `parent` is in
+    place by the time a deeper child is created."""
+
+    files_to_delete: list[Path] = field(default_factory=list)
+    """Files to unlink after the path-renames step. Typically used by the
+    package-merge logic to drop duplicate/empty `__init__.py` once the rest
+    of the source dir has been merged into the target."""
+
+    directories_to_remove: list[Path] = field(default_factory=list)
+    """Directories to `rmdir` once their contents have been moved or
+    deleted. `rmdir` is non-recursive: anything left over is a bug in the
+    plan and surfaces as a clean OSError at apply time."""
+
+    directories_to_purge: list[Path] = field(default_factory=list)
+    """Directories to remove recursively. Reserved for build/VCS artefacts
+    (`__pycache__`, `.pytest_cache`, …) encountered during a merge: they
+    block the non-recursive `rmdir` but they're regenerated automatically,
+    so nuking them is safe and keeps the merge clean."""
 
     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
-        """
+        """Return a list of human-readable problems, empty if plan can run."""
         problems: list[str] = []
+        pending_dirs = {d.resolve() for d in self.directories_to_create}
+
         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}")
+            if path.exists():
+                if not os.access(path, os.W_OK):
+                    problems.append(f"Not writable: {path}")
+            elif not self._parent_will_exist(path, pending_dirs):
+                problems.append(f"Target parent missing for rewrite: {path}")
+
+        for old_path, new_path in self.path_renames:
+            if not old_path.exists():
+                problems.append(f"Source path missing: {old_path}")
+            if new_path.exists():
+                problems.append(f"Target path already exists: {new_path}")
+            if not self._parent_will_exist(new_path, pending_dirs):
+                problems.append(f"Target parent directory missing: {new_path.parent}")
+
+        for directory in self.directories_to_create:
+            if directory.exists():
+                problems.append(
+                    f"Directory already exists (cannot create): {directory}"
+                )
+
         return problems
+
+    def _parent_will_exist(self, path: Path, pending: set[Path]) -> bool:
+        parent = path.parent
+        if parent.exists():
+            return True
+        try:
+            return parent.resolve() in pending
+        except OSError:
+            return False

wexample_wex_addon_dev_python/refactor/symbol_kind.py

@@ -4,16 +4,31 @@ 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.
-    """
+    """The kind of symbol targeted by a rename."""
 
     PACKAGE = "package"
     MODULE = "module"
     CLASS = "class"
     FUNCTION = "function"
+    # METHOD is intentionally NOT implemented yet.
+    #
+    # Renaming a method `Color.brighten` safely means knowing, at every call
+    # site `something.brighten()`, whether `something` is actually a `Color`
+    # instance. Python is dynamic: that type can only be inferred reliably by
+    # a full static-analysis pipeline (mypy / pyright), and even those tools
+    # are routinely wrong on untyped or partially-typed codebases. A naive
+    # rewrite would silently rename every `.brighten()` in sight, breaking
+    # every unrelated class that happens to share the method name.
+    #
+    # We defer this until:
+    #   - The other kinds (PACKAGE / MODULE / CLASS / FUNCTION / CONSTANT)
+    #     have been used at scale on real refactors and proven robust.
+    #   - Strict typing and stable syntax conventions are the norm across
+    #     the codebases we refactor, giving a static type-checker enough
+    #     signal to disambiguate receivers reliably.
+    #   - A dedicated validation budget is available: large synthetic
+    #     fixtures plus dry-runs across the monorepo, broad test coverage,
+    #     and code-quality agents reviewing every proposed rewrite before
+    #     it touches a real tree.
     METHOD = "method"
     CONSTANT = "constant"

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

@@ -33,8 +33,8 @@ def python__service__setup(
     import subprocess
 
     from wexample_app.const.globals import WORKDIR_LOCAL_DIR_NAME, WORKDIR_SETUP_DIR
-    from wexample_helpers.helpers.file import file_mkdir_as_real_user
-    from wexample_wex_addon_app.helpers.image_builds import (
+    from wexample_helpers.helper.file import file_mkdir_as_real_user
+    from wexample_wex_addon_app.helper.image_builds import (
         load_builds,
         resolve_build_order,
     )

wexample_wex_addon_dev_python/workdir/python_package_workdir.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 
 from wexample_filestate.const.disk import DiskItemType
 from wexample_helpers.decorator.base_class import base_class
-from wexample_wex_addon_app.helpers.python import (
+from wexample_wex_addon_app.helper.python import (
     python_install_dependency_in_venv,
     python_is_package_installed_editable_in_venv,
 )
@@ -49,8 +49,8 @@ class PythonPackageWorkdir(PythonWorkdir):
             )
 
     def prepare_value(self, raw_value: DictConfig | None = None) -> DictConfig:
-        from wexample_helpers.helpers.file import file_read
-        from wexample_helpers.helpers.module import module_get_path
+        from wexample_helpers.helper.file import file_read
+        from wexample_helpers.helper.module import module_get_path
 
         import wexample_wex_addon_dev_python
 
@@ -190,7 +190,7 @@ class PythonPackageWorkdir(PythonWorkdir):
             UPGRADE_TYPE_MAJOR,
             UPGRADE_TYPE_MINOR,
         )
-        from wexample_helpers_git.helpers.git import git_has_changes_since_tag
+        from wexample_helpers_git.helper.git import git_has_changes_since_tag
 
         if not git_has_changes_since_tag(last_tag, "src", cwd=self.get_path()):
             return UPGRADE_TYPE_MINOR
@@ -283,7 +283,7 @@ class PythonPackageWorkdir(PythonWorkdir):
         self, venv_path: Path, env: str | None = None, force: bool = False
     ) -> None:
         from wexample_app.const.env import ENV_NAME_LOCAL
-        from wexample_wex_addon_app.helpers.python import (
+        from wexample_wex_addon_app.helper.python import (
             python_install_dependencies_in_venv,
         )
 
@@ -381,8 +381,8 @@ class PythonPackageWorkdir(PythonWorkdir):
 
     def _publish(self, force: bool = False) -> None:
         from wexample_filestate_python.common.pipy_gateway import PipyGateway
-        from wexample_helpers.helpers.shell import shell_run
-        from wexample_helpers_git.helpers.git import (
+        from wexample_helpers.helper.shell import shell_run
+        from wexample_helpers_git.helper.git import (
             git_push_tag,
             git_tag_annotated,
             git_tag_exists,
@@ -445,7 +445,7 @@ class PythonPackageWorkdir(PythonWorkdir):
         shell_run(publish_cmd, inherit_stdio=True, cwd=self.get_path())
 
     def _wait_for_registry(self) -> None:
-        from wexample_helpers.helpers.polling_callback_manager import (
+        from wexample_helpers.helper.polling_callback_manager import (
             PollingCallbackManager,
         )
 

wexample_wex_addon_dev_python/workdir/python_workdir.py

@@ -59,7 +59,7 @@ class PythonWorkdir(
     WithAiWorkdirMixin, WithProfilingPythonWorkdirMixin, CodeBaseWorkdir
 ):
     def app_install(self, env: str | None = None, force: bool = False) -> Path:
-        from wexample_wex_addon_app.helpers.python import (
+        from wexample_wex_addon_app.helper.python import (
             python_ensure_pip_or_fail,
             python_install_environment,
         )
@@ -127,7 +127,7 @@ class PythonWorkdir(
         return f"{self.get_vendor_name()}_{self.get_project_name()}"
 
     def get_package_name(self) -> str:
-        from wexample_helpers.helpers.string import string_to_kebab_case
+        from wexample_helpers.helper.string import string_to_kebab_case
 
         return string_to_kebab_case(self.get_package_import_name())
 
@@ -387,7 +387,7 @@ class PythonWorkdir(
         json_file = JsonFile.create_from_path(path=json_path)
         totals = json_file.read_config().search("totals", default={}).get_dict()
 
-        from wexample_helpers_git.helpers.git import git_get_current_commit_hash
+        from wexample_helpers_git.helper.git import git_get_current_commit_hash
 
         # Derived state, not configuration: lives in .wex/local/ (untracked)
         # so test runs never dirty the repository.
@@ -412,7 +412,7 @@ class PythonWorkdir(
     def update_dependencies(self, dependencies_map: dict[str, str]) -> None:
         import subprocess
 
-        from wexample_helpers.helpers.retryable_callback_manager import (
+        from wexample_helpers.helper.retryable_callback_manager import (
             RetryableCallbackManager,
         )
 
@@ -493,7 +493,7 @@ class PythonWorkdir(
         )
 
     def _create_package_name_snake(self, option: ItemTreeConfigOptionMixin) -> str:
-        from wexample_helpers.helpers.string import string_to_snake_case
+        from wexample_helpers.helper.string import string_to_snake_case
 
         vendor_prefix = self.get_vendor_name()
         return (
@@ -646,7 +646,7 @@ class PythonWorkdir(
     def _install_dependencies_in_venv(
         self, venv_path: Path, env: str | None = None, force: bool = False
     ) -> None:
-        from wexample_wex_addon_app.helpers.python import (
+        from wexample_wex_addon_app.helper.python import (
             python_install_dependency_in_venv,
         )
 

{wexample_wex_addon_dev_python-12.2.0.dist-info → wexample_wex_addon_dev_python-13.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wexample-wex-addon-dev-python
-Version: 12.2.0
+Version: 13.0.0
 Summary: Python dev addon for wex
 Author-Email: weeger <contact@wexample.com>
 License: MIT
@@ -15,10 +15,10 @@ Requires-Dist: griffe>=2.0.2
 Requires-Dist: networkx
 Requires-Dist: pylint
 Requires-Dist: pyright
-Requires-Dist: wexample-api>=6.7.0
-Requires-Dist: wexample-filestate-python>=8.2.0
-Requires-Dist: wexample-wex-addon-ai>=11.3.0
-Requires-Dist: wexample-wex-addon-app>=27.0.0
+Requires-Dist: wexample-api>=6.8.0
+Requires-Dist: wexample-filestate-python>=9.0.0
+Requires-Dist: wexample-wex-addon-ai>=12.0.0
+Requires-Dist: wexample-wex-addon-app>=28.0.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: 12.2.0
+Version: 13.0.0
 
 Python dev addon for wex
 
@@ -112,10 +112,10 @@ Visit the [Wexample Suite documentation](https://docs.wexample.com) for the comp
 - networkx: 
 - pylint: 
 - pyright: 
-- wexample-api: >=6.7.0
-- wexample-filestate-python: >=8.2.0
-- wexample-wex-addon-ai: >=11.3.0
-- wexample-wex-addon-app: >=27.0.0
+- wexample-api: >=6.8.0
+- wexample-filestate-python: >=9.0.0
+- wexample-wex-addon-ai: >=12.0.0
+- wexample-wex-addon-app: >=28.0.0
 
 ## Versioning & Compatibility Policy