wexample-wex-addon-dev-python 0.0.53__py3-none-any.whl → 0.0.61__py3-none-any.whl

wexample_wex_addon_dev_python/const/python.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+PYTHON_PYTEST_COV_REPORT_DIR: Path = Path("htmlcov")
+PYTHON_PYTEST_COV_FORMAT_HTML: str = "html"
+PYTHON_PYTEST_COV_FORMAT_JSON: str = "json"

wexample_wex_addon_dev_python/file/python_package_toml_file.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING
 
 from wexample_filestate.item.file.toml_file import TomlFile
 from wexample_helpers.decorator.base_class import base_class
+from wexample_wex_addon_app.const.path import APP_PATH_README
 
 if TYPE_CHECKING:
     from tomlkit import TOMLDocument
@@ -22,19 +23,21 @@ class PythonPackageTomlFile(TomlFile):
         from wexample_filestate_python.helpers.toml import toml_sort_string_array
 
         deps = self._get_deps_array(optional=optional, group=group)
-        # Remove existing entries for the same package name before adding the new spec.
-        new_name = canonicalize_name(Requirement(spec).name)
-        removed = self.remove_dependency_by_name(
-            new_name, optional=optional, group=group
-        )
+        new_req = Requirement(spec)
+        new_name = canonicalize_name(new_req.name)
 
-        # Append (or re-append) the new spec if it is not already present verbatim
-        if spec not in deps:
-            deps.append(spec)
-            toml_sort_string_array(deps)
-            return True
+        old_spec = None
+        for dep in deps:
+            if canonicalize_name(Requirement(dep).name) == new_name:
+                old_spec = dep
+                break
+
+        self.remove_dependency_by_name(new_name, optional=optional, group=group)
 
-        return removed
+        deps.append(spec)
+        toml_sort_string_array(deps)
+
+        return old_spec != spec
 
     def dumps(self, content: TOMLDocument | dict | None = None) -> str:
         """Serialize a TOMLDocument (preferred) or a plain dict to TOML.
@@ -54,6 +57,7 @@ class PythonPackageTomlFile(TomlFile):
         self._enforce_project_metadata(content, project_name, project_version)
         self._normalize_dependencies(content)
         self._ensure_dev_dependencies(content)
+        self._enforce_pytest_coverage_config(content, import_name)
         self._reorder_toml_sections(content)
 
         result = dumps(content)
@@ -96,6 +100,19 @@ class PythonPackageTomlFile(TomlFile):
                 continue
         return names
 
+    def optional_group_array(self, group: str):
+        """Ensure and return project.optional-dependencies[group] as multi-line array."""
+        from wexample_filestate_python.helpers.toml import (
+            toml_ensure_array,
+            toml_ensure_table,
+        )
+
+        project = self._project_table()
+        opt, _ = toml_ensure_table(project, ["optional-dependencies"])
+        arr, _ = toml_ensure_array(opt, group)
+        arr.multiline(True)
+        return arr
+
     def remove_dependency_by_name(
         self, package_name: str, optional: bool = False, group: str = "dev"
     ) -> bool:
@@ -218,20 +235,55 @@ class PythonPackageTomlFile(TomlFile):
 
         # Add README if it exists
         if package:
-            from wexample_wex_addon_app.workdir.mixin.with_readme_workdir_mixin import (
-                WithReadmeWorkdirMixin,
-            )
+            pass
 
-            readme_file = package.find_by_name(WithReadmeWorkdirMixin.README_FILENAME)
+            readme_file = package.find_by_name(APP_PATH_README)
             if readme_file:
                 readme_tbl, _ = toml_ensure_table(project_tbl, ["readme"])
-                readme_tbl["file"] = WithReadmeWorkdirMixin.README_FILENAME
+                readme_tbl["file"] = str(APP_PATH_README)
                 readme_tbl["content-type"] = "text/markdown"
 
         # Add MIT license
         license_tbl, _ = toml_ensure_table(project_tbl, ["license"])
         license_tbl["text"] = "MIT"
 
+    def _enforce_pytest_coverage_config(
+        self, content: dict, import_name: str | None
+    ) -> None:
+        """Add pytest and coverage configuration to limit coverage to the package only."""
+        if not import_name:
+            return
+
+        from wexample_filestate_python.helpers.toml import toml_ensure_table
+
+        tool_tbl, _ = toml_ensure_table(content, ["tool"])
+
+        # Add pytest configuration
+        pytest_tbl, _ = toml_ensure_table(tool_tbl, ["pytest", "ini_options"])
+        pytest_tbl["testpaths"] = ["tests"]
+        pytest_tbl["pythonpath"] = ["src"]
+
+        # Add coverage.run configuration to limit source to the package
+        coverage_run_tbl, _ = toml_ensure_table(tool_tbl, ["coverage", "run"])
+        coverage_run_tbl["source"] = [import_name]
+        coverage_run_tbl["omit"] = [
+            "*/tests/*",
+            "*/.venv/*",
+            "*/venv/*",
+        ]
+
+        # Add coverage.report configuration
+        coverage_report_tbl, _ = toml_ensure_table(tool_tbl, ["coverage", "report"])
+        coverage_report_tbl["exclude_lines"] = [
+            "pragma: no cover",
+            "def __repr__",
+            "raise AssertionError",
+            "raise NotImplementedError",
+            "if __name__ == .__main__.:",
+            "if TYPE_CHECKING:",
+            "@abstractmethod",
+        ]
+
     def _ensure_dev_dependencies(self, content: dict) -> None:
         from wexample_filestate_python.helpers.package import package_normalize_name
         from wexample_filestate_python.helpers.toml import (
@@ -239,7 +291,7 @@ class PythonPackageTomlFile(TomlFile):
             toml_sort_string_array,
         )
 
-        dev_arr = self._optional_group_array("dev")
+        dev_arr = self.optional_group_array("dev")
         deps_arr = self._dependencies_array()
 
         runtime_pkgs = {
@@ -257,9 +309,7 @@ class PythonPackageTomlFile(TomlFile):
     def _get_deps_array(self, optional: bool = False, group: str = "dev"):
         """Return TOML array for runtime deps or optional group (multiline)."""
         return (
-            self._optional_group_array(group)
-            if optional
-            else self._dependencies_array()
+            self.optional_group_array(group) if optional else self._dependencies_array()
         )
 
     def _normalize_dependencies(self, content: dict) -> None:
@@ -276,9 +326,24 @@ class PythonPackageTomlFile(TomlFile):
         deps_arr = self._dependencies_array()
         toml_sort_string_array(deps_arr)
 
+        # Read the keep list from [tool.filestate].keep
+        keep_packages: set[str] = set()
+        if "tool" in content and isinstance(content["tool"], dict):
+            tool_tbl = content["tool"]
+            if "filestate" in tool_tbl and isinstance(tool_tbl["filestate"], dict):
+                filestate_tbl = tool_tbl["filestate"]
+                if "keep" in filestate_tbl and isinstance(filestate_tbl["keep"], list):
+                    keep_packages = {
+                        package_normalize_name(str(pkg))
+                        for pkg in filestate_tbl["keep"]
+                    }
+
         # filter unwanted deps
         def _should_remove(item: object) -> bool:
             name = package_normalize_name(toml_get_string_value(item))
+            # Don't remove if in keep list
+            if name in keep_packages:
+                return False
             return name in RUNTIME_DEPENDENCY_REMOVE_NAMES or (
                 name == "typing-extensions"
             )
@@ -288,29 +353,6 @@ class PythonPackageTomlFile(TomlFile):
         deps_arr.extend(filtered)
         toml_sort_string_array(deps_arr)
 
-        # normalize attrs/cattrs
-        normalized = []
-        for it in list(deps_arr):
-            base = package_normalize_name(toml_get_string_value(it).strip())
-            if base == "attrs":
-                normalized.append("attrs>=23.1.0")
-            elif base == "cattrs":
-                normalized.append("cattrs>=23.1.0")
-            else:
-                normalized.append(it)
-        if normalized:
-            deps_arr.clear()
-            deps_arr.extend(normalized)
-            toml_sort_string_array(deps_arr)
-
-        # ensure they are present
-        names = {package_normalize_name(toml_get_string_value(it)) for it in deps_arr}
-        if "attrs" not in names:
-            deps_arr.append("attrs>=23.1.0")
-        if "cattrs" not in names:
-            deps_arr.append("cattrs>=23.1.0")
-        toml_sort_string_array(deps_arr)
-
     def _normalize_toml_formatting(self, content: str) -> str:
         """Normalize TOML formatting:
         - No empty lines at the beginning
@@ -330,19 +372,6 @@ class PythonPackageTomlFile(TomlFile):
 
         return content
 
-    def _optional_group_array(self, group: str):
-        """Ensure and return project.optional-dependencies[group] as multi-line array."""
-        from wexample_filestate_python.helpers.toml import (
-            toml_ensure_array,
-            toml_ensure_table,
-        )
-
-        project = self._project_table()
-        opt, _ = toml_ensure_table(project, ["optional-dependencies"])
-        arr, _ = toml_ensure_array(opt, group)
-        arr.multiline(True)
-        return arr
-
     def _project_table(self):
         """Ensure and return the [project] table."""
         from wexample_filestate_python.helpers.toml import toml_ensure_table
@@ -392,9 +421,21 @@ class PythonPackageTomlFile(TomlFile):
             "optional-dependencies",
         ]
 
+        # Define the desired order for keys within [tool]
+        tool_key_order = [
+            "setuptools",
+            "pdm",
+            "pytest",
+            "coverage",
+        ]
+
         # Reorder top-level sections
         self._reorder_dict_keys(content, section_order)
 
         # Reorder keys within [project] if it exists
         if "project" in content:
             self._reorder_dict_keys(content["project"], project_key_order)
+
+        # Reorder keys within [tool] if it exists
+        if "tool" in content:
+            self._reorder_dict_keys(content["tool"], tool_key_order)

wexample_wex_addon_dev_python/resources/readme_templates/tests.md.j2

@@ -13,7 +13,7 @@ First, install the required testing dependencies:
 
 Run all tests with coverage:
 ```bash
-.venv/bin/python -m pytest --cov
+.venv/bin/python -m pytest --cov --cov-report=html
 ```
 
 ### Common Commands

wexample_wex_addon_dev_python/workdir/python_package_workdir.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from wexample_filestate.const.disk import DiskItemType
+
 from wexample_wex_addon_dev_python.workdir.python_workdir import PythonWorkdir
 
 if TYPE_CHECKING:
@@ -18,88 +20,17 @@ if TYPE_CHECKING:
 class PythonPackageWorkdir(PythonWorkdir):
     _project_info_cache = None
 
-    def _get_children_package_workdir_class(self) -> type[FrameworkPackageSuiteWorkdir]:
-        from wexample_wex_addon_dev_python.workdir.python_packages_suite_workdir import (
-            PythonPackagesSuiteWorkdir,
-        )
-
-        return PythonPackagesSuiteWorkdir
-
-    def depends_from(self, package: PythonPackageWorkdir) -> bool:
-        for dependence_name in self.get_dependencies():
-            if package.get_package_name() == dependence_name:
-                return True
-        return False
-
-    def prepare_value(self, raw_value: DictConfig | None = None) -> DictConfig:
-        from wexample_helpers.helpers.array import array_dict_get_by
-
-        raw_value = super().prepare_value(raw_value=raw_value)
-
-        # Retrieve the '.gitignore' configuration or create it if it doesn't exist
-        config_gitignore = array_dict_get_by(
-            "name", ".gitignore", raw_value["children"]
-        )
-        if config_gitignore is not None:
-            generic_gitignore_rules = {
-                "Python artifacts": [
-                    "*.egg-info",
-                    "__pycache__/",
-                    "*.py[cod]",
-                    "*.pyo",
-                ],
-                "Build directories": [
-                    "/build/",
-                    "/dist/",
-                    "/pip-wheel-metadata/",
-                ],
-                "Virtual environments": [
-                    ".env",
-                    ".venv",
-                    "venv/",
-                ],
-                "Test and coverage artifacts": [
-                    ".tox/",
-                    ".mypy_cache/",
-                    "pytest_cache/",
-                    ".coverage",
-                    "htmlcov/",
-                ],
-                "Editor and IDE settings": [
-                    ".vscode/",
-                    ".idea/",
-                    "*.swp",
-                    "*~",
-                ],
-            }
-
-            should_contain_lines = config_gitignore.setdefault(
-                "should_contain_lines", []
-            )
-            if not isinstance(should_contain_lines, list):
-                raise ValueError("'should_contain_lines' must be a list")
-
-            for category, rules in generic_gitignore_rules.items():
-                category_header = f"# {category}"
-                if category_header not in should_contain_lines:
-                    should_contain_lines.append(category_header)
-
-                for rule in rules:
-                    if rule not in should_contain_lines:
-                        should_contain_lines.append(rule)
-
-        return raw_value
-
     def app_install(self, env: str | None = None, force: bool = False) -> bool:
         from wexample_app.const.env import ENV_NAME_LOCAL
         from wexample_helpers.helpers.shell import shell_run
 
+        # In local env, installs packages using pip.
         if env == ENV_NAME_LOCAL:
+            toml_file = self.get_project_config_file()
             # Get all dependencies from pyproject.toml
-            pyproject_toml_dependencies = (
-                self.get_project_config_file().list_dependency_names()
-            )
-            suite_workdir = self.get_suite_workdir()
+            pyproject_toml_dependencies = toml_file.list_dependency_names()
+
+            suite_workdir = self.get_shallow_suite_workdir()
 
             # Ensure venv is created and configured
             app_path = self.get_path()
@@ -112,7 +43,7 @@ class PythonPackageWorkdir(PythonWorkdir):
             if not venv_is_valid:
                 # Remove corrupted/empty venv if it exists
                 if venv_path.exists():
-                    self.io.log(f"Removing invalid venv at {venv_path}", indentation=1)
+                    self.log(f"Removing invalid venv at {venv_path}", indentation=1)
                     import shutil
 
                     shutil.rmtree(venv_path)
@@ -143,6 +74,7 @@ class PythonPackageWorkdir(PythonWorkdir):
                 inherit_stdio=True,
             )
 
+            # The package is a part of a workdir, so we install manually individual package.
             if suite_workdir:
                 # Get all packages from the suite ordered by dependencies (leaf -> trunk)
                 suite_packages = suite_workdir.get_ordered_packages()
@@ -162,12 +94,12 @@ class PythonPackageWorkdir(PythonWorkdir):
 
                 # Install external packages first (normal install)
                 if external_dependencies:
-                    self.io.subtitle(
+                    self.subtitle(
                         f"Installing {len(external_dependencies)} external packages",
                         indentation=1,
                     )
                     for dep in external_dependencies:
-                        self.io.log(f"Installing {dep}", indentation=2)
+                        self.log(f"Installing {dep}", indentation=2)
                         shell_run(
                             cmd=[
                                 ".venv/bin/python",
@@ -182,7 +114,7 @@ class PythonPackageWorkdir(PythonWorkdir):
 
                 # Install suite packages in editable mode (leaf -> trunk order)
                 if suite_dependencies_ordered:
-                    self.io.subtitle(
+                    self.subtitle(
                         f"Installing {len(suite_dependencies_ordered)} suite packages in editable mode (leaf -> trunk)",
                         indentation=1,
                     )
@@ -194,13 +126,13 @@ class PythonPackageWorkdir(PythonWorkdir):
                         if not force and self._is_package_installed_editable(
                             app_path, package_name, package_path
                         ):
-                            self.io.log(
+                            self.log(
                                 f"Skipping {package_name} (already installed in editable mode)",
                                 indentation=2,
                             )
                             continue
 
-                        self.io.log(f"Installing {package_name}", indentation=2)
+                        self.log(f"Installing {package_name}", indentation=2)
                         shell_run(
                             cmd=[
                                 ".venv/bin/python",
@@ -213,6 +145,26 @@ class PythonPackageWorkdir(PythonWorkdir):
                             cwd=app_path,
                             inherit_stdio=True,
                         )
+
+                # Avoid error using -G
+                dev_group_name = "dev"
+                if (
+                    len(
+                        self.get_project_config_file().optional_group_array(
+                            group=dev_group_name
+                        )
+                    )
+                    > 0
+                ):
+                    self._pdm_update_lock_if_needed()
+
+                    self.log(f"Installing dev group dependencies")
+                    self._pdm_run_command(command=["install", "-G", dev_group_name])
+                else:
+                    self.log(
+                        "Skipping dev group install: group 'dev' not defined in pyproject.toml"
+                    )
+
                 return True
 
         # For non-local environments, use standard PDM install
@@ -221,49 +173,125 @@ class PythonPackageWorkdir(PythonWorkdir):
             force=force,
         )
 
-    def _is_package_installed_editable(
-        self,
-        app_path,
-        package_name: str,
-        package_path,
-    ) -> bool:
-        """Check if a package is already installed in editable mode at the correct path."""
-        import subprocess
+    def depends_from(self, package: PythonPackageWorkdir) -> bool:
+        for dependence_name in self.get_dependencies():
+            if package.get_package_name() == dependence_name:
+                return True
+        return False
 
-        try:
-            result = subprocess.run(
-                [".venv/bin/python", "-m", "pip", "show", package_name],
-                cwd=app_path,
-                capture_output=True,
-                text=True,
-                timeout=5,
+    def prepare_value(self, raw_value: DictConfig | None = None) -> DictConfig:
+        from wexample_helpers.helpers.array import array_dict_get_by
+
+        raw_value = super().prepare_value(raw_value=raw_value)
+        children = raw_value.get("children")
+
+        children.append(
+            {
+                "name": "examples",
+                "type": DiskItemType.DIRECTORY,
+                "should_exist": True,
+                "children": [
+                    {
+                        "name": "__main__.py",
+                        "type": DiskItemType.FILE,
+                        "should_exist": True,
+                    },
+                ],
+            },
+        )
+
+        # Retrieve the '.gitignore' configuration or create it if it doesn't exist
+        config_gitignore = array_dict_get_by("name", ".gitignore", children)
+        if config_gitignore is not None:
+            generic_gitignore_rules = {
+                "Python artifacts": [
+                    "*.egg-info",
+                    "__pycache__/",
+                    "*.py[cod]",
+                    "*.pyo",
+                ],
+                "Build directories": [
+                    "/build/",
+                    "/dist/",
+                    "/pip-wheel-metadata/",
+                ],
+                "Virtual environments": [
+                    ".env",
+                    ".venv",
+                    "venv/",
+                ],
+                "Test and coverage artifacts": [
+                    ".tox/",
+                    ".mypy_cache/",
+                    "pytest_cache/",
+                    ".coverage",
+                    "htmlcov/",
+                ],
+                "Editor and IDE settings": [
+                    ".vscode/",
+                    ".idea/",
+                    "*.swp",
+                    "*~",
+                ],
+            }
+
+            should_contain_lines = config_gitignore.setdefault(
+                "should_contain_lines", []
             )
+            if not isinstance(should_contain_lines, list):
+                raise ValueError("'should_contain_lines' must be a list")
 
-            if result.returncode != 0:
-                return False
+            for category, rules in generic_gitignore_rules.items():
+                category_header = f"# {category}"
+                if category_header not in should_contain_lines:
+                    should_contain_lines.append(category_header)
 
-            # Parse pip show output
-            output_lines = result.stdout.strip().split("\n")
-            location = None
-            editable_location = None
+                for rule in rules:
+                    if rule not in should_contain_lines:
+                        should_contain_lines.append(rule)
 
-            for line in output_lines:
-                if line.startswith("Location:"):
-                    location = line.split(":", 1)[1].strip()
-                elif line.startswith("Editable project location:"):
-                    editable_location = line.split(":", 1)[1].strip()
+        return raw_value
 
-            # Check if installed in editable mode at the correct path
-            if editable_location:
-                from pathlib import Path
+    def search_imports_in_codebase(
+        self, searched_package: PythonPackageWorkdir
+    ) -> list[SearchResult]:
+        """Find import statements that reference the given package.
 
-                return Path(editable_location).resolve() == Path(package_path).resolve()
+        Supports common Python forms:
+        - from <pkg>(.<sub>)* import ...
+        - import <pkg>(.<sub>)* [as alias]
 
-            return False
+        Returns a list of SearchResult with file, line and column for each match.
+        """
+        import re
 
-        except Exception:
-            # If any error occurs, assume not installed
-            return False
+        pkg = searched_package.get_package_import_name()
+        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")"
+        )
+        return self.search_in_codebase(pattern, regex=True, flags=re.MULTILINE)
+
+    def search_in_codebase(
+        self, string: str, *, regex: bool = False, flags: int = 0
+    ) -> list[SearchResult]:
+        from wexample_filestate.utils.search_result import SearchResult
+        from wexample_filestate_python.file.python_file import PythonFile
+
+        found = []
+
+        def _search(item: PythonFile) -> None:
+            found.extend(
+                SearchResult.create_for_all_matches(
+                    string, item, regex=regex, flags=flags
+                )
+            )
+
+        self.for_each_child_of_type_recursive(callback=_search, class_type=PythonFile)
+
+        return found
 
     def _collect_suite_dependencies(
         self,
@@ -306,6 +334,88 @@ class PythonPackageWorkdir(PythonWorkdir):
 
         return suite_deps_ordered
 
+    def _get_children_package_workdir_class(self) -> type[FrameworkPackageSuiteWorkdir]:
+        from wexample_wex_addon_dev_python.workdir.python_packages_suite_workdir import (
+            PythonPackagesSuiteWorkdir,
+        )
+
+        return PythonPackagesSuiteWorkdir
+
+    def _get_readme_content(self) -> ReadmeContentConfigValue | None:
+        from wexample_wex_addon_dev_python.config_value.python_package_readme_config_value import (
+            PythonPackageReadmeContentConfigValue,
+        )
+
+        return PythonPackageReadmeContentConfigValue(workdir=self)
+
+    def _is_package_installed_editable(
+        self,
+        app_path,
+        package_name: str,
+        package_path,
+    ) -> bool:
+        """Check if a package is already installed in editable mode at the correct path."""
+        import subprocess
+
+        try:
+            result = subprocess.run(
+                [".venv/bin/python", "-m", "pip", "show", package_name],
+                cwd=app_path,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+
+            if result.returncode != 0:
+                return False
+
+            # Parse pip show output
+            output_lines = result.stdout.strip().split("\n")
+            location = None
+            editable_location = None
+
+            for line in output_lines:
+                if line.startswith("Location:"):
+                    location = line.split(":", 1)[1].strip()
+                elif line.startswith("Editable project location:"):
+                    editable_location = line.split(":", 1)[1].strip()
+
+            # Check if installed in editable mode at the correct path
+            if editable_location:
+                from pathlib import Path
+
+                return Path(editable_location).resolve() == Path(package_path).resolve()
+
+            return False
+
+        except Exception:
+            # If any error occurs, assume not installed
+            return False
+
+    def _pdm_run_command(self, command: list[str]) -> None:
+        from wexample_helpers.helpers.shell import shell_run
+
+        # Install dev group
+        shell_run(
+            cmd=["pdm"] + command,
+            cwd=self.get_path(),
+            inherit_stdio=True,
+        )
+
+    def _pdm_update_lock_if_needed(self) -> None:
+        try:
+            self._pdm_run_command(command=["lock", "--check"])
+            self.log("pdm.lock is up to date")
+
+        except Exception:
+            self.log("pdm.lock is out of date")
+
+            try:
+                self._pdm_run_command(command=["lock"])
+                self.success("pdm.lock updated")
+            except Exception:
+                self.failure("pdm.lock updated")
+
     def _publish(self, force: bool = False) -> None:
         from wexample_filestate_python.common.pipy_gateway import PipyGateway
         from wexample_helpers.helpers.shell import shell_run
@@ -331,51 +441,3 @@ class PythonPackageWorkdir(PythonWorkdir):
                 publish_cmd += ["--password", password]
 
             shell_run(publish_cmd, inherit_stdio=True, cwd=self.get_path())
-
-    def search_imports_in_codebase(
-        self, searched_package: PythonPackageWorkdir
-    ) -> list[SearchResult]:
-        """Find import statements that reference the given package.
-
-        Supports common Python forms:
-        - from <pkg>(.<sub>)* import ...
-        - import <pkg>(.<sub>)* [as alias]
-
-        Returns a list of SearchResult with file, line and column for each match.
-        """
-        import re
-
-        pkg = searched_package.get_package_import_name()
-        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")"
-        )
-        return self.search_in_codebase(pattern, regex=True, flags=re.MULTILINE)
-
-    def search_in_codebase(
-        self, string: str, *, regex: bool = False, flags: int = 0
-    ) -> list[SearchResult]:
-        from wexample_filestate.utils.search_result import SearchResult
-        from wexample_filestate_python.file.python_file import PythonFile
-
-        found = []
-
-        def _search(item: PythonFile) -> None:
-            found.extend(
-                SearchResult.create_for_all_matches(
-                    string, item, regex=regex, flags=flags
-                )
-            )
-
-        self.for_each_child_of_type_recursive(callback=_search, class_type=PythonFile)
-
-        return found
-
-    def _get_readme_content(self) -> ReadmeContentConfigValue | None:
-        from wexample_wex_addon_dev_python.config_value.python_package_readme_config_value import (
-            PythonPackageReadmeContentConfigValue,
-        )
-
-        return PythonPackageReadmeContentConfigValue(workdir=self)

wexample_wex_addon_dev_python/workdir/python_packages_suite_workdir.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
+
 from wexample_wex_addon_app.workdir.framework_packages_suite_workdir import (
     FrameworkPackageSuiteWorkdir,
 )
@@ -11,6 +12,7 @@ if TYPE_CHECKING:
     from wexample_wex_addon_app.workdir.code_base_workdir import (
         CodeBaseWorkdir,
     )
+
     from wexample_wex_addon_dev_python.workdir.python_package_workdir import (
         PythonPackageWorkdir,
     )
@@ -89,7 +91,10 @@ class PythonPackagesSuiteWorkdir(FrameworkPackageSuiteWorkdir):
         return [by_name[n] for n in order]
 
     def packages_validate_internal_dependencies_declarations(self) -> None:
-        from wexample_wex_addon_app.exception.dependency_violation_exception import DependencyViolationException
+        from wexample_wex_addon_app.exception.dependency_violation_exception import (
+            DependencyViolationException,
+        )
+
         dependencies_map = self.build_dependencies_map()
 
         self.io.log("Checking packages dependencies consistency...")

wexample_wex_addon_dev_python/workdir/python_workdir.py

@@ -4,14 +4,30 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from tomlkit import TOMLDocument
-
+from wexample_app.item.file.iml_file import ImlFile
+from wexample_event.dataclass.event import Event
+from wexample_event.dataclass.listener_record import EventCallback
+from wexample_filestate.const.types_state_items import TargetFileOrDirectoryType
 from wexample_filestate.item.file.json_file import JsonFile
-from wexample_filestate_python.const.python_file import PYTHON_FILE_PYTEST_COVERAGE_JSON
+from wexample_filestate.operation.abstract_operation import AbstractOperation
+from wexample_filestate.operation.file_rename_operation import FileRenameOperation
+from wexample_filestate_python.const.path import PATH_DIR_SRC, PATH_DIR_TESTS
+from wexample_filestate_python.const.python_file import (
+    PYTHON_FILE_EXTENSION,
+    PYTHON_FILE_PYTEST_COVERAGE_JSON,
+)
 from wexample_wex_addon_app.helpers.python import python_install_environment
+from wexample_wex_addon_app.item.file.python_app_iml_file import PythonAppImlFile
 from wexample_wex_addon_app.workdir.code_base_workdir import (
     CodeBaseWorkdir,
 )
 
+from wexample_wex_addon_dev_python.const.python import (
+    PYTHON_PYTEST_COV_FORMAT_HTML,
+    PYTHON_PYTEST_COV_FORMAT_JSON,
+    PYTHON_PYTEST_COV_REPORT_DIR,
+)
+
 if TYPE_CHECKING:
     from wexample_config.const.types import DictConfig
     from wexample_config.options_provider.abstract_options_provider import (
@@ -24,57 +40,13 @@ if TYPE_CHECKING:
         ChildrenFileFactoryOption,
     )
     from wexample_helpers.const.types import StructuredData
+
     from wexample_wex_addon_dev_python.file.python_package_toml_file import (
         PythonPackageTomlFile,
     )
 
 
 class PythonWorkdir(CodeBaseWorkdir):
-    def get_venv_path(self) -> Path:
-        return self.get_path() / ".venv"
-
-    def get_venv_bin_path(self) -> Path:
-        return self.get_venv_path() / "bin"
-
-    def get_python_path(self) -> Path:
-        return self.get_venv_bin_path() / "python"
-
-    def get_python_exec_module_command(self, module_name: str) -> list[str]:
-        return [self.get_python_path(), "-m", module_name]
-
-    def test_run(self) -> None:
-        self.shell_run_for_app(cmd=self.test_get_command())
-
-        json_file = JsonFile.create_from_path(
-            path=self.get_path() / PYTHON_FILE_PYTEST_COVERAGE_JSON
-        )
-        totals = json_file.read_config().search("totals", default={}).get_dict()
-
-        config_file = self.get_config_file()
-        config = config_file.read_config()
-        config.set_by_path(
-            "test.coverage.last_report",
-            {
-                "covered": totals.get("covered_lines", 0),
-                "excluded": totals.get("excluded_lines", 0),
-                "missing": totals.get("missing_lines", 0),
-                "percent": totals.get("percent_covered", 0),
-                "total": totals.get("num_statements", 0),
-            },
-        )
-        config_file.write_config()
-
-    def test_get_command(self) -> list[str]:
-        cmd = self.get_python_exec_module_command("pytest")
-        cmd.extend(
-            [
-                "--cov",
-                "--cov-report=json",
-            ]
-        )
-
-        return cmd
-
     def app_install(self, env: str | None = None, force: bool = False) -> bool:
         # Use standard PDM install
         return python_install_environment(path=self.get_path())
@@ -87,6 +59,9 @@ class PythonWorkdir(CodeBaseWorkdir):
             dependencies.append(Requirement(dependency).name)
         return dependencies
 
+    def get_main_code_file_extension(self) -> str:
+        return PYTHON_FILE_EXTENSION
+
     def get_options_providers(self) -> list[type[AbstractOptionsProvider]]:
         from wexample_filestate_python.options_provider.python_options_provider import (
             PythonOptionsProvider,
@@ -111,6 +86,61 @@ class PythonWorkdir(CodeBaseWorkdir):
 
         return string_to_kebab_case(self.get_package_import_name())
 
+    def get_project_config(self, reload: bool = True) -> TOMLDocument:
+        """
+        Fetch the data from the pyproject.toml file.
+        """
+        return self.get_project_config_file(reload=reload).read_parsed()
+
+    def get_project_config_file(self, reload: bool = True) -> PythonPackageTomlFile:
+        from wexample_wex_addon_dev_python.file.python_package_toml_file import (
+            PythonPackageTomlFile,
+        )
+
+        config_file = self.find_by_name("pyproject.toml")
+        assert isinstance(config_file, PythonPackageTomlFile)
+        # Read once to populate content with file source.
+        config_file.read_text(reload=reload)
+        return config_file
+
+    def get_python_exec_module_command(self, module_name: str) -> list[str]:
+        return [self.get_python_path(), "-m", module_name]
+
+    def get_python_path(self) -> Path:
+        return self.get_venv_bin_path() / "python"
+
+    def get_venv_bin_path(self) -> Path:
+        return self.get_venv_path() / "bin"
+
+    def get_venv_path(self) -> Path:
+        return self.get_path() / ".venv"
+
+    def has_coverage_changes_since_last_report(self) -> bool:
+        """Return True if coverage has changed since last saved report."""
+        last_report = (
+            self.app_workdir.get_config()
+            .search("test.coverage.last_report")
+            .get_dict_or_default()
+        )
+
+        if not last_report:
+            return True
+
+        current_coverage = self._run_coverage()
+
+        return current_coverage != last_report.get("percent")
+
+    def operation_add_event_listener(
+        self,
+        operation: AbstractOperation | type[AbstractOperation],
+        callback: EventCallback,
+        suffix: str | None = None,
+        **kwargs,
+    ) -> None:
+        self.add_event_listener(
+            name=operation.get_event_name(suffix=suffix), callback=callback, **kwargs
+        )
+
     def prepare_value(self, raw_value: DictConfig | None = None) -> DictConfig:
         from wexample_config.config_value.callback_render_config_value import (
             CallbackRenderConfigValue,
@@ -120,6 +150,7 @@ class PythonWorkdir(CodeBaseWorkdir):
             ChildrenFilterOption,
         )
         from wexample_helpers.helpers.array import array_dict_get_by
+
         from wexample_wex_addon_dev_python.file.python_package_toml_file import (
             PythonPackageTomlFile,
         )
@@ -231,6 +262,100 @@ class PythonWorkdir(CodeBaseWorkdir):
 
         return raw_value
 
+    def save_dependency(self, package_name: str, version: str) -> bool:
+        """Add or update a dependency with strict version."""
+        config = self.get_project_config_file()
+        updated = config.add_dependency(f"{package_name}=={version}")
+
+        if updated:
+            config.write_parsed()
+
+        return updated
+
+    def save_project_config_file(self, config: StructuredData) -> None:
+        """Save the project configuration to pyproject.toml."""
+        config_file = self.get_project_config_file()
+        config_file.write(config)
+
+    def test_get_command(
+        self, format: str = PYTHON_PYTEST_COV_FORMAT_JSON
+    ) -> list[str]:
+        cmd = self.get_python_exec_module_command("pytest")
+        cmd.extend(
+            [
+                "--cov",
+                f"--cov-report={format}",
+            ]
+        )
+
+        return cmd
+
+    def test_run(self, format: str = PYTHON_PYTEST_COV_FORMAT_JSON) -> None:
+        self.shell_run_for_app(cmd=self.test_get_command(format=format))
+
+        json_file = JsonFile.create_from_path(
+            path=self.get_path() / PYTHON_FILE_PYTEST_COVERAGE_JSON
+        )
+        totals = json_file.read_config().search("totals", default={}).get_dict()
+
+        config_file = self.get_config_file()
+        config = config_file.read_config()
+        config.set_by_path(
+            "test.coverage.last_report",
+            {
+                "covered": totals.get("covered_lines", 0),
+                "excluded": totals.get("excluded_lines", 0),
+                "missing": totals.get("missing_lines", 0),
+                "percent": totals.get("percent_covered", 0),
+                "total": totals.get("num_statements", 0),
+            },
+        )
+        config_file.write_config()
+
+        if format == PYTHON_PYTEST_COV_FORMAT_HTML:
+            report_path = self.get_path() / PYTHON_PYTEST_COV_REPORT_DIR / "index.html"
+            if report_path.exists():
+                self.info(f"Report: @path{{{report_path}}}")
+
+    def update_dependencies(self, dependencies_map: dict[str, str]) -> None:
+        """Update dependencies versions based on the provided map.
+
+        Args:
+            dependencies_map: Dictionary mapping package names to their new versions.
+                             Example: {"wexample-helpers": "0.2.3", "attrs": "23.1.0"}
+        """
+        from packaging.requirements import Requirement
+        from packaging.utils import canonicalize_name
+
+        config_file = self.get_project_config_file()
+
+        # Canonicalize the keys in dependencies_map for consistent matching
+        canonical_map = {
+            canonicalize_name(name): version
+            for name, version in dependencies_map.items()
+        }
+
+        # Get current dependencies
+        current_deps = config_file.list_dependencies()
+
+        # Update each dependency if it's in the map
+        for dep_spec in current_deps:
+            try:
+                req = Requirement(dep_spec)
+                canonical_name = canonicalize_name(req.name)
+
+                # If this dependency is in our update map, update it
+                if canonical_name in canonical_map:
+                    new_version = canonical_map[canonical_name]
+                    # Use add_dependency which handles removal of old version
+                    config_file.add_dependency(f"{req.name}=={new_version}")
+            except Exception:
+                # Skip unparsable dependencies
+                continue
+
+        # Save the updated config
+        config_file.write_parsed()
+
     def _create_init_children_factory(self) -> ChildrenFileFactoryOption:
         from wexample_filestate.const.disk import DiskItemType
         from wexample_filestate.const.globals import NAME_PATTERN_NO_LEADING_DOT
@@ -279,7 +404,67 @@ class PythonWorkdir(CodeBaseWorkdir):
             ChildrenFilterOption,
         )
         from wexample_filestate_python.file.python_file import PythonFile
-        from wexample_filestate_python.option.python_option import PythonOption
+        from wexample_filestate_python.option.python.add_future_annotations_option import (
+            AddFutureAnnotationsOption,
+        )
+        from wexample_filestate_python.option.python.add_return_types_option import (
+            AddReturnTypesOption,
+        )
+        from wexample_filestate_python.option.python.fix_attrs_option import (
+            FixAttrsOption,
+        )
+        from wexample_filestate_python.option.python.fix_blank_lines_option import (
+            FixBlankLinesOption,
+        )
+        from wexample_filestate_python.option.python.format_option import FormatOption
+        from wexample_filestate_python.option.python.fstringify_option import (
+            FstringifyOption,
+        )
+        from wexample_filestate_python.option.python.modernize_typing_option import (
+            ModernizeTypingOption,
+        )
+        from wexample_filestate_python.option.python.order_class_attributes_option import (
+            OrderClassAttributesOption,
+        )
+        from wexample_filestate_python.option.python.order_class_docstring_option import (
+            OrderClassDocstringOption,
+        )
+        from wexample_filestate_python.option.python.order_class_methods_option import (
+            OrderClassMethodsOption,
+        )
+        from wexample_filestate_python.option.python.order_constants_option import (
+            OrderConstantsOption,
+        )
+        from wexample_filestate_python.option.python.order_iterable_items_option import (
+            OrderIterableItemsOption,
+        )
+        from wexample_filestate_python.option.python.order_main_guard_option import (
+            OrderMainGuardOption,
+        )
+        from wexample_filestate_python.option.python.order_module_docstring_option import (
+            OrderModuleDocstringOption,
+        )
+        from wexample_filestate_python.option.python.order_module_functions_option import (
+            OrderModuleFunctionsOption,
+        )
+        from wexample_filestate_python.option.python.order_module_metadata_option import (
+            OrderModuleMetadataOption,
+        )
+        from wexample_filestate_python.option.python.order_type_checking_block_option import (
+            OrderTypeCheckingBlockOption,
+        )
+        from wexample_filestate_python.option.python.relocate_imports_option import (
+            RelocateImportsOption,
+        )
+        from wexample_filestate_python.option.python.remove_unused_option import (
+            RemoveUnusedOption,
+        )
+        from wexample_filestate_python.option.python.sort_imports_option import (
+            SortImportsOption,
+        )
+        from wexample_filestate_python.option.python.unquote_annotations_option import (
+            UnquoteAnnotationsOption,
+        )
 
         return ChildrenFilterOption(
             pattern={
@@ -287,96 +472,57 @@ class PythonWorkdir(CodeBaseWorkdir):
                 "type": DiskItemType.FILE,
                 "python": {
                     # Configured for python >= 3.12
-                    PythonOption.OPTION_NAME_ADD_FUTURE_ANNOTATIONS: True,
-                    PythonOption.OPTION_NAME_RELOCATE_IMPORTS: True,
-                    PythonOption.OPTION_NAME_REMOVE_UNUSED: True,
-                    PythonOption.OPTION_NAME_SORT_IMPORTS: True,
-                    PythonOption.OPTION_NAME_MODERNIZE_TYPING: True,
-                    PythonOption.OPTION_NAME_FSTRINGIFY: True,
-                    PythonOption.OPTION_NAME_ADD_RETURN_TYPES: True,
-                    PythonOption.OPTION_NAME_UNQUOTE_ANNOTATIONS: True,
-                    PythonOption.OPTION_NAME_FIX_ATTRS: True,
-                    PythonOption.OPTION_NAME_ORDER_TYPE_CHECKING_BLOCK: True,
-                    PythonOption.OPTION_NAME_ORDER_MODULE_DOCSTRING: True,
-                    PythonOption.OPTION_NAME_ORDER_MODULE_METADATA: True,
-                    PythonOption.OPTION_NAME_ORDER_CONSTANTS: True,
-                    PythonOption.OPTION_NAME_ORDER_ITERABLE_ITEMS: True,
-                    PythonOption.OPTION_NAME_ORDER_MODULE_FUNCTIONS: True,
-                    PythonOption.OPTION_NAME_ORDER_MAIN_GUARD: True,
-                    PythonOption.OPTION_NAME_ORDER_CLASS_DOCSTRING: True,
-                    PythonOption.OPTION_NAME_ORDER_CLASS_ATTRIBUTES: True,
-                    PythonOption.OPTION_NAME_ORDER_CLASS_METHODS: True,
-                    PythonOption.OPTION_NAME_FIX_BLANK_LINES: True,
-                    PythonOption.OPTION_NAME_FORMAT: True,
+                    AddFutureAnnotationsOption.get_name(): True,
+                    RelocateImportsOption.get_name(): True,
+                    RemoveUnusedOption.get_name(): True,
+                    SortImportsOption.get_name(): True,
+                    ModernizeTypingOption.get_name(): True,
+                    FstringifyOption.get_name(): True,
+                    AddReturnTypesOption.get_name(): True,
+                    UnquoteAnnotationsOption.get_name(): True,
+                    FixAttrsOption.get_name(): True,
+                    OrderTypeCheckingBlockOption.get_name(): True,
+                    OrderModuleDocstringOption.get_name(): True,
+                    OrderModuleMetadataOption.get_name(): True,
+                    OrderConstantsOption.get_name(): True,
+                    OrderIterableItemsOption.get_name(): True,
+                    OrderModuleFunctionsOption.get_name(): True,
+                    OrderMainGuardOption.get_name(): True,
+                    OrderClassDocstringOption.get_name(): True,
+                    OrderClassAttributesOption.get_name(): True,
+                    OrderClassMethodsOption.get_name(): True,
+                    FixBlankLinesOption.get_name(): True,
+                    FormatOption.get_name(): True,
                 },
             },
             name_pattern=r"^.*\.py$",
             recursive=True,
         )
 
-    def get_project_config_file(self, reload: bool = True) -> PythonPackageTomlFile:
-        from wexample_wex_addon_dev_python.file.python_package_toml_file import (
-            PythonPackageTomlFile,
-        )
+    def _get_iml_file_class(self) -> type[ImlFile]:
+        return PythonAppImlFile
 
-        config_file = self.find_by_name("pyproject.toml")
-        assert isinstance(config_file, PythonPackageTomlFile)
-        # Read once to populate content with file source.
-        config_file.read_text(reload=reload)
-        return config_file
+    def _get_source_code_directories(self) -> [TargetFileOrDirectoryType]:
+        src = self.find_by_name(PATH_DIR_SRC)
 
-    def get_project_config(self, reload: bool = True) -> TOMLDocument:
-        """
-        Fetch the data from the pyproject.toml file.
-        """
-        return self.get_project_config_file(reload=reload).read_parsed()
+        if src:
+            return [src]
 
-    def save_dependency(self, package_name: str, version: str) -> None:
-        """Add or update a dependency with strict version."""
-        config = self.get_project_config_file()
-        config.add_dependency(f"{package_name}=={version}")
-        config.write_parsed()
+        return []
 
-    def save_project_config_file(self, config: StructuredData) -> None:
-        """Save the project configuration to pyproject.toml."""
-        config_file = self.get_project_config_file()
-        config_file.write(config)
+    def _get_test_code_directories(self) -> [TargetFileOrDirectoryType]:
+        tests = self.find_by_name(PATH_DIR_TESTS)
 
-    def update_dependencies(self, dependencies_map: dict[str, str]) -> None:
-        """Update dependencies versions based on the provided map.
+        if tests:
+            return [tests]
 
-        Args:
-            dependencies_map: Dictionary mapping package names to their new versions.
-                             Example: {"wexample-helpers": "0.2.3", "attrs": "23.1.0"}
-        """
-        from packaging.requirements import Requirement
-        from packaging.utils import canonicalize_name
-
-        config_file = self.get_project_config_file()
+        return []
 
-        # Canonicalize the keys in dependencies_map for consistent matching
-        canonical_map = {
-            canonicalize_name(name): version
-            for name, version in dependencies_map.items()
-        }
-
-        # Get current dependencies
-        current_deps = config_file.list_dependencies()
-
-        # Update each dependency if it's in the map
-        for dep_spec in current_deps:
-            try:
-                req = Requirement(dep_spec)
-                canonical_name = canonicalize_name(req.name)
-
-                # If this dependency is in our update map, update it
-                if canonical_name in canonical_map:
-                    new_version = canonical_map[canonical_name]
-                    # Use add_dependency which handles removal of old version
-                    config_file.add_dependency(f"{req.name}=={new_version}")
-            except Exception:
-                # Skip unparsable dependencies
-                continue
+    def _init_listeners(self) -> None:
+        """Add event listeners"""
+        self.operation_add_event_listener(
+            operation=FileRenameOperation, suffix="post", callback=self._on_test_event
+        )
 
-        # Save the updated config
-        config_file.write_parsed()
+    def _on_test_event(self, event: Event) -> None:
+        self.success("A python file has been renamed")

{wexample_wex_addon_dev_python-0.0.53.dist-info → wexample_wex_addon_dev_python-0.0.61.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wexample-wex-addon-dev-python
-Version: 0.0.53
+Version: 0.0.61
 Summary: Python dev addon for wex
 Author-Email: weeger <contact@wexample.com>
 License: MIT
@@ -15,9 +15,9 @@ Requires-Dist: jinja2
 Requires-Dist: networkx
 Requires-Dist: pylint
 Requires-Dist: pyright
-Requires-Dist: wexample-filestate-python==0.0.48
-Requires-Dist: wexample-wex-addon-app==0.0.49
-Requires-Dist: wexample-wex-core==6.0.55
+Requires-Dist: wexample-filestate-python==0.0.56
+Requires-Dist: wexample-wex-addon-app==0.0.53
+Requires-Dist: wexample-wex-core==6.0.65
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -25,7 +25,7 @@ Description-Content-Type: text/markdown
 
 # wexample-wex-addon-dev-python
 
-Version: 0.0.53
+Version: 0.0.61
 
 Python dev addon for wex
 
@@ -44,7 +44,7 @@ First, install the required testing dependencies:
 
 Run all tests with coverage:
 ```bash
-.venv/bin/python -m pytest --cov
+.venv/bin/python -m pytest --cov --cov-report=html
 ```
 
 ### Common Commands

{wexample_wex_addon_dev_python-0.0.53.dist-info → wexample_wex_addon_dev_python-0.0.61.dist-info}/RECORD

@@ -1,6 +1,6 @@
-wexample_wex_addon_dev_python-0.0.53.dist-info/METADATA,sha256=9CcuVf5ioaUJoFnBrKESDfwlL_5XRgATtWrFYZ3gTck,6541
-wexample_wex_addon_dev_python-0.0.53.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-wexample_wex_addon_dev_python-0.0.53.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+wexample_wex_addon_dev_python-0.0.61.dist-info/METADATA,sha256=yqx7BuSnRvvBEUgCXySFgzwZRJz9W_9jjXPa_E3EOF8,6559
+wexample_wex_addon_dev_python-0.0.61.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+wexample_wex_addon_dev_python-0.0.61.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
 wexample_wex_addon_dev_python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_python/__pycache__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_python/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -25,9 +25,10 @@ wexample_wex_addon_dev_python/config_value/python_package_readme_config_value.py
 wexample_wex_addon_dev_python/const/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_python/const/__pycache__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_python/const/package.py,sha256=oRCPhaazJp5TujxF-35rrIYA4FJsqMqCns8lOFKOLeA,451
+wexample_wex_addon_dev_python/const/python.py,sha256=jxdPt5CnD0dcp4SmobEc_c7XcCkPFfX_lk3SVHsiVpM,203
 wexample_wex_addon_dev_python/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_python/file/__pycache__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wexample_wex_addon_dev_python/file/python_package_toml_file.py,sha256=OjN0CJP6eKyEs54dp_KZW086G0r5RmM-lQPyLhLP8oc,14936
+wexample_wex_addon_dev_python/file/python_package_toml_file.py,sha256=ShJrZiiJj8-HrsD92W_1WozE02fi6Avll8VuYPQ25r0,16357
 wexample_wex_addon_dev_python/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_python/middleware/__pycache__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_python/middleware/each_python_file_middleware.py,sha256=UzNEpedCYf31aNONFl0SuSJnoXRzhJhgEiTCaPark6E,2311
@@ -35,11 +36,11 @@ wexample_wex_addon_dev_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 wexample_wex_addon_dev_python/python_addon_manager.py,sha256=Mmr9F5lOS2gbb8JTB4-vTri4Qn5Cd2Jukjk7uiTr1Hs,582
 wexample_wex_addon_dev_python/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_python/resources/readme_templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wexample_wex_addon_dev_python/resources/readme_templates/tests.md.j2,sha256=6ellaBCay9Ggk61MgcyPok6euJMi-2cUboE2z8REzBs,1271
+wexample_wex_addon_dev_python/resources/readme_templates/tests.md.j2,sha256=tKLcDwx7jhQkryXIxWr12AK-hKEaP6Rusu2MrluiABs,1289
 wexample_wex_addon_dev_python/resources/readme_templates/title.md.j2,sha256=U-q_U_WhTTwz3enrht3UTfQ9fwioaKUuJqwYyhBtCiA,64
 wexample_wex_addon_dev_python/workdir/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_python/workdir/__pycache__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wexample_wex_addon_dev_python/workdir/python_package_workdir.py,sha256=l7-Qaei_MGvVSvXqNk4nE-3cpq49MB10wT71FOYmjT8,14317
-wexample_wex_addon_dev_python/workdir/python_packages_suite_workdir.py,sha256=5_wmwhJ3Ox0ougYyQJtybu6WijTTvtzjutcVvuXFY6E,6636
-wexample_wex_addon_dev_python/workdir/python_workdir.py,sha256=bNg7PA3danMdOdMZpv0VV4DGS1jCzxqvcB5VRf5BBmU,14547
-wexample_wex_addon_dev_python-0.0.53.dist-info/RECORD,,
+wexample_wex_addon_dev_python/workdir/python_package_workdir.py,sha256=v-6B-rz1WBO94qC-4KzIVhkIBnabmAyV76du_Od2JGU,16398
+wexample_wex_addon_dev_python/workdir/python_packages_suite_workdir.py,sha256=41bzNISqVKHirOSVkwBD9wuZokrMDrtWKUjlMRT_GyU,6664
+wexample_wex_addon_dev_python/workdir/python_workdir.py,sha256=RE3neOVS8Nju9hTuTjalqe25Q4mZ4Uhx6x2y3XRv18s,19893
+wexample_wex_addon_dev_python-0.0.61.dist-info/RECORD,,

{wexample_wex_addon_dev_python-0.0.53.dist-info → wexample_wex_addon_dev_python-0.0.61.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.4.5)
+Generator: pdm-backend (2.4.6)
 Root-Is-Purelib: true
 Tag: py3-none-any