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

wexample_wex_addon_dev_python/config_value/python_package_readme_config_value.py

@@ -2,248 +2,49 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from wexample_filestate.config_value.readme_content_config_value import (
-    ReadmeContentConfigValue,
-)
-from wexample_helpers.classes.field import public_field
 from wexample_helpers.decorator.base_class import base_class
+from wexample_wex_addon_app.config_value.app_readme_config_value import (
+    AppReadmeConfigValue,
+)
 
 if TYPE_CHECKING:
-    from wexample_wex_addon_dev_python.workdir.python_package_workdir import (
-        PythonPackageWorkdir,
-    )
+    pass
 
 
 @base_class
-class PythonPackageReadmeContentConfigValue(ReadmeContentConfigValue):
-    workdir: PythonPackageWorkdir = public_field(
-        description="The python package workdir"
-    )
-
-    def get_templates(self) -> list[str] | None:
-        # Prepare context for Jinja2 rendering
-        context = self._get_template_context()
-
-        # Define fixed order of README sections
-        section_names = [
-            "title",
-            "table-of-contents",
-            "status-compatibility",
-            "prerequisites",
-            "installation",
-            "quickstart",
-            "basic-usage",
-            "configuration",
-            "logging",
-            "api-reference",
-            "examples",
-            "tests",
-            "code-quality",
-            "versioning",
-            "changelog",
-            "migration-notes",
-            "roadmap",
-            "troubleshooting",
-            "security",
-            "privacy",
-            "support",
-            "contribution-guidelines",
-            "maintainers",
-            "license",
-            "useful-links",
-            "suite-integration",
-            "compatibility-matrix",
-            "requirements",
-            "dependencies",
-            "links",
-            "suite-signature",
-        ]
-
-        # First pass: collect available sections (excluding title and table-of-contents)
-        available_sections = []
-        for section_name in section_names:
-            if section_name not in ["title", "table-of-contents"]:
-                # Check if section exists
-                if self._section_exists(section_name):
-                    available_sections.append(
-                        {
-                            "name": section_name,
-                            "title": self._section_name_to_title(section_name),
-                            "anchor": section_name.replace("_", "-"),
-                        }
-                    )
-
-        # Add available sections to context for table-of-contents
-        context["available_sections"] = available_sections
+class PythonPackageReadmeContentConfigValue(AppReadmeConfigValue):
+    """README generation for Python packages."""
 
-        # Render ordered sections (supports both .md and .md.j2)
-        rendered_content = ""
-        for section_name in section_names:
-            section_content = self._render_readme_section(section_name, context)
-            if section_content:
-                rendered_content += f"{section_content}\n\n"
+    def _get_app_description(self) -> str:
+        """Extract description from pyproject.toml."""
+        return self.workdir.get_app_config().get("project", {}).get("description")
 
-        return [rendered_content]
-
-    def _get_template_context(self) -> dict:
-        # Use TOMLDocument from the workdir
-        doc = self.workdir.get_project_config()
-        project = doc.get("project", {}) if isinstance(doc, dict) else {}
-
-        # Extract information
-        description = project.get("description", "")
-        python_version = project.get("requires-python", "")
-        dependencies = project.get("dependencies", [])
+    def _get_app_homepage(self) -> str:
+        """Extract homepage URL from pyproject.toml."""
+        project = self.workdir.get_app_config()
         urls = (
             project.get("urls", {}) if isinstance(project.get("urls", {}), dict) else {}
         )
-        # Accept both lowercase and capitalized homepage key variants
-        homepage = urls.get("homepage") or urls.get("Homepage") or ""
+        return urls.get("homepage") or urls.get("Homepage") or ""
+
+    def _get_project_license(self) -> str | None:
+        """Extract license information from pyproject.toml."""
+        project = self.workdir.get_app_config()
         license_field = project.get("license", {})
         if isinstance(license_field, dict):
-            license_info = license_field.get("text", "") or license_field.get(
-                "file", ""
-            )
-        else:
-            license_info = str(license_field) if license_field else ""
-
-        # Format dependencies list
-        deps_list = "\n".join([f"- {dep}" for dep in dependencies])
-
-        return {
-            "package_name": self.workdir.get_package_name(),
-            "version": self.workdir.get_project_version(),
-            "description": description,
-            "python_version": python_version,
-            "dependencies": dependencies,
-            "deps_list": deps_list,
-            "homepage": homepage,
-            "license_info": license_info,
-            "workdir": self.workdir,
-        }
-
-    def _render_readme_section(self, section_name: str, context: dict) -> str | None:
-        """
-        Render a README section from .md or .md.j2 file with Jinja2 support.
-
-        Searches in three levels (in order):
-        1. Package-level templates
-        2. Suite-level templates
-        3. Default templates (bundled with the module)
-
-        Tries .md.j2 first, then .md. Both formats support Jinja2 variables.
-
-        Args:
-            section_name: Name of the section (without extension)
-            context: Jinja2 context variables for rendering
-
-        Returns:
-            Rendered content or None if section file not found
-        """
-        from pathlib import Path
-
-        from jinja2 import Environment, FileSystemLoader, TemplateNotFound
-        from wexample_app.const.globals import WORKDIR_SETUP_DIR
-
-        workdir_path = self.workdir.get_path()
-
-        search_paths = [
-            workdir_path / WORKDIR_SETUP_DIR / "knowledge" / "readme",  # Package-level
-        ]
+            return license_field.get("text", "") or license_field.get("file", "")
+        return str(license_field) if license_field else ""
 
-        # Package may have a suite.
-        suite_path = self.workdir.find_suite_workdir_path()
-        if suite_path is not None:
-            search_paths.append(
-                suite_path
-                / WORKDIR_SETUP_DIR
-                / "knowledge"
-                / "package-readme",  # Suite-level
-            )
-
-        # Add default templates path (bundled with the module)
-        default_templates_path = (
-            Path(__file__).parent.parent / "resources" / "readme_templates"
-        )
-        search_paths.append(default_templates_path)
-
-        # Try .md.j2 first (Jinja2 template)
-        for search_path in search_paths:
-            if not search_path.exists():
-                continue
-
-            env = Environment(loader=FileSystemLoader(str(search_path)))
-            try:
-                template = env.get_template(f"{section_name}.md.j2")
-                return template.render(context)
-            except TemplateNotFound:
-                pass
-
-        # Try .md (static markdown, still rendered with Jinja2)
-        for search_path in search_paths:
-            md_path = search_path / f"{section_name}.md"
-            if md_path.exists():
-                content = md_path.read_text(encoding="utf-8")
-                env = Environment(loader=FileSystemLoader(str(search_path)))
-                template = env.from_string(content)
-                return template.render(context)
-
-        return None
-
-    def _section_exists(self, section_name: str) -> bool:
-        """
-        Check if a section file exists (.md or .md.j2).
-
-        Searches in three levels:
-        1. Package-level templates
-        2. Suite-level templates
-        3. Default templates (bundled with the module)
-
-        Args:
-            section_name: Name of the section (without extension)
+    def _get_template_context(self) -> dict:
+        """Build template context with Python-specific variables.
 
-        Returns:
-            True if section file exists, False otherwise
+        Adds python_version to the base context.
         """
-        from pathlib import Path
+        context = super()._get_template_context()
 
-        from wexample_app.const.globals import WORKDIR_SETUP_DIR
-
-        workdir_path = self.workdir.get_path()
-
-        search_paths = [
-            workdir_path / WORKDIR_SETUP_DIR / "knowledge" / "readme",
-        ]
-
-        # Package may have a suite.
-        suite_path = self.workdir.find_suite_workdir_path()
-        if suite_path is not None:
-            search_paths.append(
-                suite_path / WORKDIR_SETUP_DIR / "knowledge" / "package-readme",
-            )
-
-        # Add default templates path (bundled with the module)
-        default_templates_path = (
-            Path(__file__).parent.parent / "resources" / "readme_templates"
+        # Add Python-specific variable
+        context["python_version"] = (
+            self.workdir.get_app_config().get("project", {}).get("requires-python", "")
         )
-        search_paths.append(default_templates_path)
-
-        for search_path in search_paths:
-            if (search_path / f"{section_name}.md.j2").exists():
-                return True
-            if (search_path / f"{section_name}.md").exists():
-                return True
 
-        return False
-
-    def _section_name_to_title(self, section_name: str) -> str:
-        """
-        Convert section name to human-readable title.
-
-        Args:
-            section_name: Section name (e.g., "basic-usage")
-
-        Returns:
-            Human-readable title (e.g., "Basic Usage")
-        """
-        return section_name.replace("-", " ").replace("_", " ").title()
+        return context

wexample_wex_addon_dev_python/file/python_app_iml_file.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any, ClassVar
+
+from wexample_app.item.file.iml_file import ImlFile
+
+
+class PythonAppImlFile(ImlFile):
+    """
+    IntelliJ IDEA .iml helper tailored for Python apps (src/tests layout, python module type).
+    """
+
+    MODULE_TYPE: ClassVar[str] = "PYTHON_MODULE"
+
+    def _default_exclude_folders(self) -> Iterable[dict[str, Any]]:
+        return (
+            {
+                "@url": f"{self.MODULE_DIR_URL}/dist",
+            },
+        )
+
+    def _default_module_attributes(self) -> dict[str, str]:
+        attrs = super()._default_module_attributes()
+        attrs.setdefault("@type", self.MODULE_TYPE)
+        return attrs
+
+    def _default_order_entries(self) -> Iterable[dict[str, Any]]:
+        return ({"@type": "sourceFolder", "@forTests": "false"},)
+
+    def _default_source_folders(self) -> Iterable[dict[str, Any]]:
+        return (
+            {
+                "@url": f"{self.MODULE_DIR_URL}/src",
+                "@isTestSource": "false",
+            },
+            {
+                "@url": f"{self.MODULE_DIR_URL}/tests",
+                "@isTestSource": "true",
+            },
+        )

wexample_wex_addon_dev_python/file/{python_package_toml_file.py → python_pyproject_toml_file.py}

@@ -14,29 +14,44 @@ if TYPE_CHECKING:
 
 
 @base_class
-class PythonPackageTomlFile(TomlFile):
+class PythonPyprojectTomlFile(TomlFile):
     def add_dependency(
-        self, spec: str, optional: bool = False, group: str = "dev"
+        self,
+        package_name: str,
+        version: str,
+        operator: str = "==",
+        optional: bool = False,
+        group: None | str = None,
     ) -> bool:
         from packaging.requirements import Requirement
         from packaging.utils import canonicalize_name
         from wexample_filestate_python.helpers.toml import toml_sort_string_array
 
-        deps = self._get_deps_array(optional=optional, group=group)
+        spec = f"{package_name}{operator}{version}"
         new_req = Requirement(spec)
         new_name = canonicalize_name(new_req.name)
 
-        old_spec = None
-        for dep in deps:
-            if canonicalize_name(Requirement(dep).name) == new_name:
-                old_spec = dep
-                break
+        deps = self._get_deps_array(optional=optional, group=group)
+
+        # Look for existing dependency
+        old_spec = next(
+            (d for d in deps if canonicalize_name(Requirement(d).name) == new_name),
+            None,
+        )
 
-        self.remove_dependency_by_name(new_name, optional=optional, group=group)
+        # Remove old dep if exists
+        if old_spec:
+            deps.remove(old_spec)
 
+        # Add new version
         deps.append(spec)
+
+        # Sort array
         toml_sort_string_array(deps)
 
+        # Save file
+        self.write_parsed()
+
         return old_spec != spec
 
     def dumps(self, content: TOMLDocument | dict | None = None) -> str:
@@ -70,35 +85,21 @@ class PythonPackageTomlFile(TomlFile):
 
         return self.find_closest(CodeBaseWorkdir)
 
-    def list_dependencies(
+    def get_dependencies_versions(
         self, optional: bool = False, group: str = "dev"
-    ) -> list[str]:
-        deps = self._get_deps_array(optional=optional, group=group)
-        return [str(x) for x in list(deps)]
-
-    def list_dependency_names(
-        self,
-        canonicalize_names: bool = True,
-        optional: bool = False,
-        group: str = "dev",
-    ) -> list[str]:
-        """Return dependency package names derived from list_dependencies().
-
-        If canonicalize_names is True, names are normalized using packaging's
-        canonicalize_name for robust comparisons (dash/underscore, case, etc.).
-        """
+    ) -> dict[str, str]:
         from packaging.requirements import Requirement
         from packaging.utils import canonicalize_name
 
-        names: list[str] = []
-        for spec in self.list_dependencies(optional=optional, group=group):
-            try:
-                name = Requirement(spec).name
-                names.append(canonicalize_name(name) if canonicalize_names else name)
-            except Exception:
-                # Skip unparsable entries when deriving names
-                continue
-        return names
+        deps = self._get_deps_array(optional=optional, group=group)
+
+        map = {}
+        for spec in list(deps):
+            req = Requirement(spec)
+            # name: version
+            map[canonicalize_name(req.name)] = str(req.specifier)
+
+        return map
 
     def optional_group_array(self, group: str):
         """Ensure and return project.optional-dependencies[group] as multi-line array."""
@@ -305,7 +306,6 @@ class PythonPackageTomlFile(TomlFile):
 
         toml_sort_string_array(dev_arr)
 
-    # --- Unified dependency accessors (runtime vs optional) ---
     def _get_deps_array(self, optional: bool = False, group: str = "dev"):
         """Return TOML array for runtime deps or optional group (multiline)."""
         return (

wexample_wex_addon_dev_python/workdir/python_package_workdir.py

@@ -1,8 +1,13 @@
 from __future__ import annotations
 
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from wexample_filestate.const.disk import DiskItemType
+from wexample_wex_addon_app.helpers.python import (
+    python_install_dependency_in_venv,
+    python_is_package_installed_editable_in_venv,
+)
 
 from wexample_wex_addon_dev_python.workdir.python_workdir import PythonWorkdir
 
@@ -20,165 +25,6 @@ if TYPE_CHECKING:
 class PythonPackageWorkdir(PythonWorkdir):
     _project_info_cache = None
 
-    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 = toml_file.list_dependency_names()
-
-            suite_workdir = self.get_shallow_suite_workdir()
-
-            # Ensure venv is created and configured
-            app_path = self.get_path()
-            venv_path = app_path / ".venv"
-
-            # Check if venv exists and is valid (has bin/python)
-            venv_python = venv_path / "bin" / "python"
-            venv_is_valid = venv_path.exists() and venv_python.exists()
-
-            if not venv_is_valid:
-                # Remove corrupted/empty venv if it exists
-                if venv_path.exists():
-                    self.log(f"Removing invalid venv at {venv_path}", indentation=1)
-                    import shutil
-
-                    shutil.rmtree(venv_path)
-
-                # Create new venv
-                shell_run(
-                    cmd=["pdm", "venv", "create"],
-                    cwd=app_path,
-                    inherit_stdio=True,
-                )
-
-            # Force PDM to use the local .venv
-            shell_run(
-                cmd=["pdm", "use", ".venv"],
-                cwd=app_path,
-                inherit_stdio=True,
-            )
-
-            # Ensure pip is installed in the venv
-            shell_run(
-                cmd=[
-                    ".venv/bin/python",
-                    "-m",
-                    "ensurepip",
-                    "--upgrade",
-                ],
-                cwd=app_path,
-                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()
-                suite_package_names = {pkg.get_package_name() for pkg in suite_packages}
-
-                # Collect all suite packages that need to be installed (including transitive dependencies)
-                suite_dependencies_ordered = self._collect_suite_dependencies(
-                    pyproject_toml_dependencies, suite_workdir, suite_package_names
-                )
-
-                # External dependencies are those not in the suite
-                external_dependencies = [
-                    dep
-                    for dep in pyproject_toml_dependencies
-                    if dep not in suite_package_names
-                ]
-
-                # Install external packages first (normal install)
-                if external_dependencies:
-                    self.subtitle(
-                        f"Installing {len(external_dependencies)} external packages",
-                        indentation=1,
-                    )
-                    for dep in external_dependencies:
-                        self.log(f"Installing {dep}", indentation=2)
-                        shell_run(
-                            cmd=[
-                                ".venv/bin/python",
-                                "-m",
-                                "pip",
-                                "install",
-                                dep,
-                            ],
-                            cwd=app_path,
-                            inherit_stdio=True,
-                        )
-
-                # Install suite packages in editable mode (leaf -> trunk order)
-                if suite_dependencies_ordered:
-                    self.subtitle(
-                        f"Installing {len(suite_dependencies_ordered)} suite packages in editable mode (leaf -> trunk)",
-                        indentation=1,
-                    )
-                    for pkg in suite_dependencies_ordered:
-                        package_path = pkg.get_path()
-                        package_name = pkg.get_package_name()
-
-                        # Check if package is already installed in editable mode at the correct path
-                        if not force and self._is_package_installed_editable(
-                            app_path, package_name, package_path
-                        ):
-                            self.log(
-                                f"Skipping {package_name} (already installed in editable mode)",
-                                indentation=2,
-                            )
-                            continue
-
-                        self.log(f"Installing {package_name}", indentation=2)
-                        shell_run(
-                            cmd=[
-                                ".venv/bin/python",
-                                "-m",
-                                "pip",
-                                "install",
-                                "-e",
-                                str(package_path),
-                            ],
-                            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
-        return super().app_install(
-            env=env,
-            force=force,
-        )
-
-    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
 
@@ -318,7 +164,7 @@ class PythonPackageWorkdir(PythonWorkdir):
                     pkg = suite_workdir.get_package(dep_name)
                     if pkg:
                         # Get dependencies of this suite package and recurse
-                        pkg_dependencies = pkg.get_dependencies()
+                        pkg_dependencies = pkg.list_dependencies_names()
                         collect_recursive(pkg_dependencies)
 
         # Start with direct dependencies from pyproject.toml
@@ -334,87 +180,111 @@ class PythonPackageWorkdir(PythonWorkdir):
 
         return suite_deps_ordered
 
-    def _get_children_package_workdir_class(self) -> type[FrameworkPackageSuiteWorkdir]:
+    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 _get_suite_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,
+    def _install_dependencies_in_venv(
+        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 (
+            python_install_dependencies_in_venv,
         )
 
-        return PythonPackageReadmeContentConfigValue(workdir=self)
+        suite_workdir = self.get_shallow_suite_workdir()
+        toml_file = self.get_app_config_file()
 
-    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,
-            )
+        # Check for suite only in local env.
+        if env == ENV_NAME_LOCAL:
+            # Package is part of a suite that may have a venv configured.
+            if suite_workdir:
+                # Get all dependencies from pyproject.toml
+                pyproject_toml_dependencies = toml_file.list_dependencies_names()
 
-            if result.returncode != 0:
-                return False
+                # Get all packages from the suite ordered by dependencies (leaf -> trunk)
+                suite_packages = suite_workdir.get_ordered_packages()
+                suite_package_names = {pkg.get_package_name() for pkg in suite_packages}
 
-            # Parse pip show output
-            output_lines = result.stdout.strip().split("\n")
-            location = None
-            editable_location = None
+                # Collect all suite packages that need to be installed (including transitive dependencies)
+                suite_dependencies_ordered = self._collect_suite_dependencies(
+                    pyproject_toml_dependencies, suite_workdir, suite_package_names
+                )
 
-            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()
+                # External dependencies are those not in the suite
+                external_dependencies = [
+                    dep
+                    for dep in pyproject_toml_dependencies
+                    if dep not in suite_package_names
+                ]
 
-            # Check if installed in editable mode at the correct path
-            if editable_location:
-                from pathlib import Path
+                self.subtitle(
+                    f"Installing {len(external_dependencies)} external packages",
+                    indentation=1,
+                )
+                python_install_dependencies_in_venv(
+                    venv_path=venv_path, names=external_dependencies
+                )
 
-                return Path(editable_location).resolve() == Path(package_path).resolve()
+                # Install suite packages in editable mode (leaf -> trunk order)
+                if suite_dependencies_ordered:
+                    self.subtitle(
+                        f"Installing {len(suite_dependencies_ordered)} suite packages in editable mode (leaf -> trunk)",
+                        indentation=1,
+                    )
 
-            return False
+                    editable_paths = []
 
-        except Exception:
-            # If any error occurs, assume not installed
-            return False
+                    for pkg in suite_dependencies_ordered:
+                        pkg_path = pkg.get_path()
+                        pkg_name = pkg.get_package_name()
 
-    def _pdm_run_command(self, command: list[str]) -> None:
-        from wexample_helpers.helpers.shell import shell_run
+                        if force or not python_is_package_installed_editable_in_venv(
+                            venv_path=venv_path,
+                            package_name=pkg_name,
+                            package_path=pkg_path,
+                        ):
+                            editable_paths.append(str(pkg_path))
 
-        # Install dev group
-        shell_run(
-            cmd=["pdm"] + command,
-            cwd=self.get_path(),
-            inherit_stdio=True,
-        )
+                    python_install_dependencies_in_venv(
+                        venv_path=venv_path,
+                        names=editable_paths,
+                        editable=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")
+                self.subtitle(
+                    "Installing dev group dependencies",
+                    indentation=1,
+                )
+                python_install_dependencies_in_venv(
+                    venv_path=venv_path,
+                    names=self.get_app_config_file().optional_group_array(group="dev"),
+                )
+
+            self.subtitle(
+                "Installing itself in editable mode",
+                indentation=1,
+            )
+
+            # Install itself as editable.
+            python_install_dependency_in_venv(
+                venv_path=venv_path, name=self.get_path(), editable=True
+            )
 
-        except Exception:
-            self.log("pdm.lock is out of date")
+            return
 
-            try:
-                self._pdm_run_command(command=["lock"])
-                self.success("pdm.lock updated")
-            except Exception:
-                self.failure("pdm.lock updated")
+        # Fallback to parent behaviour
+        super()._install_dependencies_in_venv(venv_path=venv_path, env=env, force=force)
 
     def _publish(self, force: bool = False) -> None:
         from wexample_filestate_python.common.pipy_gateway import PipyGateway

wexample_wex_addon_dev_python/workdir/python_packages_suite_workdir.py

@@ -71,94 +71,6 @@ class PythonPackagesSuiteWorkdir(FrameworkPackageSuiteWorkdir):
 
         return stack if stack and stack[-1].get_package_name() == target else []
 
-    def build_ordered_dependencies(self) -> list[str]:
-        # Build and validate the dependency map, then compute a stable topological order
-        return self.topological_order(self.build_dependencies_map())
-
-    def get_dependents(
-        self, package: PythonPackageWorkdir
-    ) -> list[PythonPackageWorkdir]:
-        dependents = []
-        for neighbor_package in self.get_packages():
-            if neighbor_package.depends_from(package):
-                dependents.append(neighbor_package)
-        return dependents
-
-    def get_ordered_packages(self) -> list[PythonPackageWorkdir]:
-        """Return package objects ordered leaves -> trunk."""
-        order = self.build_ordered_dependencies()
-        by_name = {p.get_package_name(): p for p in self.get_packages()}
-        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,
-        )
-
-        dependencies_map = self.build_dependencies_map()
-
-        self.io.log("Checking packages dependencies consistency...")
-        self.io.indentation_up()
-        progress = self.io.progress(
-            total=len(dependencies_map), print_response=False
-        ).get_handle()
-
-        for package_name in dependencies_map:
-            package = self.get_package(package_name)
-
-            for package_name_search in dependencies_map:
-                searched_package = self.get_package(package_name_search)
-                imports = package.search_imports_in_codebase(searched_package)
-                if len(imports) > 0:
-                    dependencies_stack = self.build_dependencies_stack(
-                        package, searched_package, dependencies_map
-                    )
-
-                    if len(dependencies_stack) == 0:
-                        # Build a readable list of import locations to help debugging
-                        import_locations = [
-                            f"{res.item.get_path()}:{res.line}:{res.column}"
-                            for res in imports
-                        ]
-                        raise DependencyViolationException(
-                            package_name=package_name,
-                            imported_package=package_name_search,
-                            import_locations=import_locations,
-                        )
-
-            progress.advance(label=f"Package {package.get_project_name()}", step=1)
-
-        self.io.success("Internal dependencies match.")
-        self.io.indentation_down()
-
-    def topological_order(self, dep_map: dict[str, list[str]]) -> list[str]:
-        """Deterministic topological order using graphlib.TopologicalSorter.
-        Returns a leaves -> trunk order (dependencies before dependents).
-        Raises ValueError on cycles.
-        """
-        from graphlib import CycleError, TopologicalSorter
-
-        # Normalize: include every mentioned node and sort for stable results
-        nodes = set(dep_map.keys()) | {d for deps in dep_map.values() for d in deps}
-        normalized: dict[str, list[str]] = {
-            k: sorted([d for d in dep_map.get(k, []) if d in nodes])
-            for k in sorted(nodes)
-        }
-
-        ts = TopologicalSorter()
-        for k, deps in normalized.items():
-            ts.add(k, *deps)
-
-        try:
-            order = list(ts.static_order())
-        except CycleError as e:
-            # Extract involved nodes if present, otherwise a generic message
-            msg = getattr(e, "args", [None])[0] or "Cyclic dependencies detected"
-            raise ValueError(str(msg)) from e
-
-        # Return only local packages (original keys of dep_map)
-        return [n for n in order if n in dep_map]
-
     def _child_is_package_directory(self, entry: Path) -> bool:
         return entry.is_dir() and (entry / "pyproject.toml").is_file()
 

wexample_wex_addon_dev_python/workdir/python_workdir.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 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
@@ -16,8 +15,6 @@ 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,
 )
@@ -27,6 +24,7 @@ from wexample_wex_addon_dev_python.const.python import (
     PYTHON_PYTEST_COV_FORMAT_JSON,
     PYTHON_PYTEST_COV_REPORT_DIR,
 )
+from wexample_wex_addon_dev_python.file.python_app_iml_file import PythonAppImlFile
 
 if TYPE_CHECKING:
     from wexample_config.const.types import DictConfig
@@ -41,23 +39,51 @@ if TYPE_CHECKING:
     )
     from wexample_helpers.const.types import StructuredData
 
-    from wexample_wex_addon_dev_python.file.python_package_toml_file import (
-        PythonPackageTomlFile,
+    from wexample_wex_addon_dev_python.file.python_pyproject_toml_file import (
+        PythonPyprojectTomlFile,
     )
 
 
 class PythonWorkdir(CodeBaseWorkdir):
-    def app_install(self, env: str | None = None, force: bool = False) -> bool:
+    def app_install(self, env: str | None = None, force: bool = False) -> Path:
+        from wexample_wex_addon_app.helpers.python import (
+            python_ensure_pip_or_fail,
+            python_install_environment,
+        )
+
+        # Check if a venv path is somewhere in the config hierarchy.
+        venv_path_config = self.search_app_or_suite_runtime_config("python.venv_path")
+
+        # There is no venv, so create a venv for this project.
+        if venv_path_config.is_none():
+            venv_path = python_install_environment(path=self.get_path())
+        else:
+            venv_path = Path(venv_path_config.get_str())
+
+        self.log(f"Using venv: @path{{{venv_path}}}")
+        python_ensure_pip_or_fail(venv_path)
+
+        self._install_dependencies_in_venv(
+            venv_path=venv_path,
+            env=env,
+            force=force,
+        )
+
         # Use standard PDM install
-        return python_install_environment(path=self.get_path())
+        return venv_path
 
-    def get_dependencies(self) -> list[str]:
-        from packaging.requirements import Requirement
+    def get_app_config_file(self, reload: bool = True) -> PythonPyprojectTomlFile:
+        from wexample_wex_addon_dev_python.file.python_pyproject_toml_file import (
+            PythonPyprojectTomlFile,
+        )
+
+        config_file = self.find_by_type(PythonPyprojectTomlFile)
+        # Read once to populate content with file source.
+        config_file.read_text(reload=reload)
+        return config_file
 
-        dependencies = []
-        for dependency in self.get_project_config_file().list_dependency_names():
-            dependencies.append(Requirement(dependency).name)
-        return dependencies
+    def get_dependencies_versions(self) -> dict[str, str]:
+        return self.get_app_config_file().get_dependencies_versions()
 
     def get_main_code_file_extension(self) -> str:
         return PYTHON_FILE_EXTENSION
@@ -86,23 +112,6 @@ 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]
 
@@ -151,8 +160,8 @@ class PythonWorkdir(CodeBaseWorkdir):
         )
         from wexample_helpers.helpers.array import array_dict_get_by
 
-        from wexample_wex_addon_dev_python.file.python_package_toml_file import (
-            PythonPackageTomlFile,
+        from wexample_wex_addon_dev_python.file.python_pyproject_toml_file import (
+            PythonPyprojectTomlFile,
         )
 
         raw_value = super().prepare_value(raw_value=raw_value)
@@ -166,7 +175,6 @@ class PythonWorkdir(CodeBaseWorkdir):
             [
                 ".pdm-python",
                 ".python-version",
-                ".venv",
                 f"/{PYTHON_FILE_PYTEST_COVERAGE_JSON}",
             ]
         )
@@ -183,34 +191,7 @@ class PythonWorkdir(CodeBaseWorkdir):
                     ],
                 },
                 {
-                    "name": ".venv",
-                    "type": DiskItemType.DIRECTORY,
-                    "should_exist": True,
-                },
-                # Replaced by pdm
-                {
-                    "name": "requirements.in",
-                    "type": DiskItemType.FILE,
-                    "should_exist": False,
-                },
-                {
-                    "name": "requirements.txt",
-                    "type": DiskItemType.FILE,
-                    "should_exist": False,
-                },
-                {
-                    "name": "requirements-dev.in",
-                    "type": DiskItemType.FILE,
-                    "should_exist": False,
-                },
-                {
-                    "name": "requirements-dev.txt",
-                    "type": DiskItemType.FILE,
-                    "should_exist": False,
-                },
-                # Pdm versions
-                {
-                    "class": PythonPackageTomlFile,
+                    "class": PythonPyprojectTomlFile,
                     "name": "pyproject.toml",
                     "type": DiskItemType.FILE,
                     "should_exist": True,
@@ -264,8 +245,8 @@ class PythonWorkdir(CodeBaseWorkdir):
 
     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}")
+        config = self.get_app_config_file()
+        updated = config.add_dependency(package_name=package_name, version=version)
 
         if updated:
             config.write_parsed()
@@ -274,7 +255,7 @@ class PythonWorkdir(CodeBaseWorkdir):
 
     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 = self.get_app_config_file()
         config_file.write(config)
 
     def test_get_command(
@@ -327,7 +308,7 @@ class PythonWorkdir(CodeBaseWorkdir):
         from packaging.requirements import Requirement
         from packaging.utils import canonicalize_name
 
-        config_file = self.get_project_config_file()
+        config_file = self.get_app_config_file()
 
         # Canonicalize the keys in dependencies_map for consistent matching
         canonical_map = {
@@ -336,7 +317,7 @@ class PythonWorkdir(CodeBaseWorkdir):
         }
 
         # Get current dependencies
-        current_deps = config_file.list_dependencies()
+        current_deps = config_file.list_dependencies_names()
 
         # Update each dependency if it's in the map
         for dep_spec in current_deps:
@@ -348,7 +329,9 @@ class PythonWorkdir(CodeBaseWorkdir):
                 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}")
+                    config_file.add_dependency(
+                        package_name=req.name, version=new_version
+                    )
             except Exception:
                 # Skip unparsable dependencies
                 continue
@@ -524,5 +507,18 @@ class PythonWorkdir(CodeBaseWorkdir):
             operation=FileRenameOperation, suffix="post", callback=self._on_test_event
         )
 
+    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 (
+            python_install_dependencies_in_venv,
+        )
+
+        toml_file = self.get_app_config_file()
+        # Get all dependencies from pyproject.toml
+        python_install_dependencies_in_venv(
+            venv_path=venv_path, names=toml_file.list_dependencies_names()
+        )
+
     def _on_test_event(self, event: Event) -> None:
         self.success("A python file has been renamed")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wexample-wex-addon-dev-python
-Version: 0.0.61
+Version: 0.0.62
 Summary: Python dev addon for wex
 Author-Email: weeger <contact@wexample.com>
 License: MIT
@@ -11,13 +11,12 @@ Project-URL: homepage, https://github.com/wexample/python-wex-dev-python
 Requires-Python: >=3.10
 Requires-Dist: attrs>=23.1.0
 Requires-Dist: cattrs>=23.1.0
-Requires-Dist: jinja2
 Requires-Dist: networkx
 Requires-Dist: pylint
 Requires-Dist: pyright
-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
+Requires-Dist: wexample-filestate-python==0.0.57
+Requires-Dist: wexample-wex-addon-app==0.0.54
+Requires-Dist: wexample-wex-core==6.0.66
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -25,10 +24,49 @@ Description-Content-Type: text/markdown
 
 # wexample-wex-addon-dev-python
 
-Version: 0.0.61
+Version: 0.0.62
 
 Python dev addon for wex
 
+## Table of Contents
+
+- [Status Compatibility](#status-compatibility)
+- [Api Reference](#api-reference)
+- [Tests](#tests)
+- [Code Quality](#code-quality)
+- [Versioning](#versioning)
+- [Changelog](#changelog)
+- [Migration Notes](#migration-notes)
+- [Roadmap](#roadmap)
+- [Security](#security)
+- [Privacy](#privacy)
+- [Support](#support)
+- [Contribution Guidelines](#contribution-guidelines)
+- [Maintainers](#maintainers)
+- [License](#license)
+- [Useful Links](#useful-links)
+- [Suite Integration](#suite-integration)
+- [Compatibility Matrix](#compatibility-matrix)
+- [Dependencies](#dependencies)
+- [Suite Signature](#suite-signature)
+
+
+## Status & Compatibility
+
+**Maturity**: Production-ready
+
+**Python Support**: >=3.10
+
+**OS Support**: Linux, macOS, Windows
+
+**Status**: Actively maintained
+
+## API Reference
+
+Full API documentation is available in the source code docstrings.
+
+Key modules and classes are documented with type hints for better IDE support.
+
 ## Tests
 
 This project uses `pytest` for testing and `pytest-cov` for code coverage analysis.
@@ -115,13 +153,13 @@ Breaking changes are clearly documented with upgrade paths and examples.
 
 Current limitations and planned features are tracked in the GitHub issues.
 
-See the [project roadmap](https://github.com/wexample/python-wex-dev-python/issues) for upcoming features and improvements.
+See the [project roadmap](https://github.com/wexample/python-wex_addon_dev_python/issues) for upcoming features and improvements.
 
 ## Security Policy
 
 ### Reporting Vulnerabilities
 
-If you discover a security vulnerability, please email security@wexample.com.
+If you discover a security vulnerability, please email contact@wexample.com.
 
 **Do not** open public issues for security vulnerabilities.
 
@@ -144,7 +182,7 @@ Community support is available through GitHub Discussions.
 
 ## Contribution Guidelines
 
-We welcome contributions to the Wexample suite! 
+We welcome contributions to the Wexample suite!
 
 ### How to Contribute
 
@@ -162,14 +200,16 @@ See [CONTRIBUTORS.md](CONTRIBUTORS.md) for the full list of contributors.
 
 ## License
 
-MIT
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+Free to use in both personal and commercial projects.
 
 ## Useful Links
 
-- **Homepage**: https://github.com/wexample/python-wex-dev-python
+- **Homepage**: https://github.com/wexample/python-wex-addon-dev-python
 - **Documentation**: [docs.wexample.com](https://docs.wexample.com)
-- **Issue Tracker**: https://github.com/wexample/python-wex-dev-python/issues
-- **Discussions**: https://github.com/wexample/python-wex-dev-python/discussions
+- **Issue Tracker**: https://github.com/wexample/python-wex-addon-dev-python/issues
+- **Discussions**: https://github.com/wexample/python-wex-addon-dev-python/discussions
 - **PyPI**: [pypi.org/project/wexample-wex-addon-dev-python](https://pypi.org/project/wexample-wex-addon-dev-python/)
 
 ## Integration in the Suite
@@ -182,9 +222,27 @@ The suite includes packages for configuration management, file handling, prompts
 
 Visit the [Wexample Suite documentation](https://docs.wexample.com) for the complete package ecosystem.
 
+## Compatibility Matrix
+
+This package is part of the Wexample suite and is compatible with other suite packages.
+
+Refer to each package's documentation for specific version compatibility requirements.
+
+## Dependencies
+
+- attrs: >=23.1.0
+- cattrs: >=23.1.0
+- networkx: 
+- pylint: 
+- pyright: 
+- wexample-filestate-python: ==0.0.57
+- wexample-wex-addon-app: ==0.0.54
+- wexample-wex-core: ==6.0.66
+
+
 # About us
 
-Wexample stands as a cornerstone of the digital ecosystem — a collective of seasoned engineers, researchers, and creators driven by a relentless pursuit of technological excellence. More than a media platform, it has grown into a vibrant community where innovation meets craftsmanship, and where every line of code reflects a commitment to clarity, durability, and shared intelligence.
+[Wexample](https://wexample.com) stands as a cornerstone of the digital ecosystem — a collective of seasoned engineers, researchers, and creators driven by a relentless pursuit of technological excellence. More than a media platform, it has grown into a vibrant community where innovation meets craftsmanship, and where every line of code reflects a commitment to clarity, durability, and shared intelligence.
 
 This packages suite embodies this spirit. Trusted by professionals and enthusiasts alike, it delivers a consistent, high-quality foundation for modern development — open, elegant, and battle-tested. Its reputation is built on years of collaboration, refinement, and rigorous attention to detail, making it a natural choice for those who demand both robustness and beauty in their tools.
 

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

@@ -1,6 +1,6 @@
-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-0.0.62.dist-info/METADATA,sha256=wfg0YuX89h46KwubjV5ys0GaCD4PuplKcQeBaALDRLM,8086
+wexample_wex_addon_dev_python-0.0.62.dist-info/WHEEL,sha256=tsUv_t7BDeJeRHaSrczbGeuK-TtDpGsWi_JfpzD255I,90
+wexample_wex_addon_dev_python-0.0.62.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
@@ -21,14 +21,15 @@ wexample_wex_addon_dev_python/commands/examples/validate.py,sha256=jHiWkEtETkVSY
 wexample_wex_addon_dev_python/commands/release/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_python/config_value/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_python/config_value/__pycache__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wexample_wex_addon_dev_python/config_value/python_package_readme_config_value.py,sha256=Dwy_NBUd6bQoP37XpzVs9FC1WjeXTLH9xaOFHf6GazU,8573
+wexample_wex_addon_dev_python/config_value/python_package_readme_config_value.py,sha256=9L67C6oGwebd8tMSqECmSSpah7nsDTkjEQMNMCWAyp0,1722
 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=ShJrZiiJj8-HrsD92W_1WozE02fi6Avll8VuYPQ25r0,16357
+wexample_wex_addon_dev_python/file/python_app_iml_file.py,sha256=l6YHEILxSGFjOvYWY20zIyAODjOIfuyHsuCfSMw0jVE,1201
+wexample_wex_addon_dev_python/file/python_pyproject_toml_file.py,sha256=EGWwBy5W7zNf8-q7XqXHKV8Qb6FVFoW3qm6Rtwcn4NY,15911
 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
@@ -37,10 +38,9 @@ wexample_wex_addon_dev_python/python_addon_manager.py,sha256=Mmr9F5lOS2gbb8JTB4-
 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=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=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/workdir/python_package_workdir.py,sha256=djUfgI1MCn9KOgYCYiwFIpZaGQ28spaiOz6t8gL6FoA,11780
+wexample_wex_addon_dev_python/workdir/python_packages_suite_workdir.py,sha256=ICHHewLpsXiheYzGDEahphBryH98ZVezWzSAy6A5w5I,2874
+wexample_wex_addon_dev_python/workdir/python_workdir.py,sha256=ERpSw5qti1NmHiufOix6bS5lW2vIvclr82SKwlWOhKk,19681
+wexample_wex_addon_dev_python-0.0.62.dist-info/RECORD,,

wexample_wex_addon_dev_python/resources/readme_templates/title.md.j2

@@ -1,5 +0,0 @@
-# {{ package_name }}
-
-Version: {{ version }}
-
-{{ description }}