wexample-wex-addon-dev-python 0.0.61__py3-none-any.whl → 0.0.63__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}

@@ -8,35 +8,47 @@ from wexample_wex_addon_app.const.path import APP_PATH_README
 
 if TYPE_CHECKING:
     from tomlkit import TOMLDocument
-    from wexample_wex_addon_app.workdir.code_base_workdir import (
-        CodeBaseWorkdir,
-    )
 
 
 @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)
 
-        self.remove_dependency_by_name(new_name, 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,
+        )
+
+        # 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:
@@ -47,10 +59,10 @@ class PythonPackageTomlFile(TomlFile):
 
         content = content or self.read_parsed()
 
-        package = self.find_package_workdir()
-        import_name = package.get_package_import_name() if package else None
-        project_name = package.get_package_name() if package else None
-        project_version = package.get_project_version() if package else None
+        workdir = self.get_parent_item()
+        import_name = workdir.get_package_import_name()
+        project_name = workdir.get_package_name()
+        project_version = workdir.get_project_version()
 
         self._enforce_build_system(content)
         self._enforce_pdm_build(content, import_name)
@@ -65,40 +77,21 @@ class PythonPackageTomlFile(TomlFile):
 
         return result
 
-    def find_package_workdir(self) -> CodeBaseWorkdir | None:
-        from wexample_wex_addon_app.workdir.code_base_workdir import CodeBaseWorkdir
-
-        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."""
@@ -197,34 +190,28 @@ class PythonPackageTomlFile(TomlFile):
             project_tbl["requires-python"] = ">=3.10"
 
         # Add description if available
-        package = self.find_package_workdir()
-        if package:
-            description = package.get_config().search("global.description")
-            if not description.is_none():
-                project_tbl["description"] = description.get_str()
+        workdir = self.get_parent_item()
+        description = workdir.get_config().search("global.description")
+        if not description.is_none():
+            project_tbl["description"] = description.get_str()
 
         # Add authors if available
-        if package:
-            from tomlkit import array, inline_table
+        from tomlkit import array, inline_table
 
-            author_name = package.search_in_package_or_suite_config(
-                "global.authors.name"
-            )
-            author_email = package.search_in_package_or_suite_config(
-                "global.authors.email"
-            )
+        author_name = workdir.search_in_package_or_suite_config("global.authors.name")
+        author_email = workdir.search_in_package_or_suite_config("global.authors.email")
 
-            if not author_name.is_none() or not author_email.is_none():
-                authors_arr = array()
-                author_tbl = inline_table()
+        if not author_name.is_none() or not author_email.is_none():
+            authors_arr = array()
+            author_tbl = inline_table()
 
-                if not author_name.is_none():
-                    author_tbl["name"] = author_name.get_str()
-                if not author_email.is_none():
-                    author_tbl["email"] = author_email.get_str()
+            if not author_name.is_none():
+                author_tbl["name"] = author_name.get_str()
+            if not author_email.is_none():
+                author_tbl["email"] = author_email.get_str()
 
-                authors_arr.append(author_tbl)
-                project_tbl["authors"] = authors_arr
+            authors_arr.append(author_tbl)
+            project_tbl["authors"] = authors_arr
 
         # Add classifiers (standard Python package metadata)
         project_tbl["classifiers"] = [
@@ -234,14 +221,11 @@ class PythonPackageTomlFile(TomlFile):
         ]
 
         # Add README if it exists
-        if package:
-            pass
-
-            readme_file = package.find_by_name(APP_PATH_README)
-            if readme_file:
-                readme_tbl, _ = toml_ensure_table(project_tbl, ["readme"])
-                readme_tbl["file"] = str(APP_PATH_README)
-                readme_tbl["content-type"] = "text/markdown"
+        readme_file = workdir.find_by_name(APP_PATH_README)
+        if readme_file:
+            readme_tbl, _ = toml_ensure_table(project_tbl, ["readme"])
+            readme_tbl["file"] = str(APP_PATH_README)
+            readme_tbl["content-type"] = "text/markdown"
 
         # Add MIT license
         license_tbl, _ = toml_ensure_table(project_tbl, ["license"])
@@ -305,7 +289,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 (