wexample-wex-addon-dev-python 0.0.44__py3-none-any.whl → 0.0.47__py3-none-any.whl

wexample_wex_addon_dev_python/commands/code/check/mypy.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from wexample_wex_core.common.kernel import Kernel
+
+
+def _code_check_mypy(kernel: Kernel, file_path: str) -> bool:
+    """Check a Python file using mypy for static type checking.
+
+    Args:
+        kernel: The application kernel
+        file_path: Path to the Python file to check
+
+    Returns:
+        bool: True if check passes, False otherwise
+    """
+    import sys
+
+    from mypy import build
+    from mypy.modulefinder import BuildSource
+    from mypy.options import Options
+
+    # Configure mypy options
+    options = Options()
+    options.python_version = sys.version_info[:2]
+    options.show_traceback = True
+    options.disallow_untyped_defs = True
+    options.disallow_incomplete_defs = True
+
+    # Ignore import as file might be placed anywhere, we have no more context.
+    options.ignore_missing_imports = True
+
+    # Build and check the file
+    source = BuildSource(path=file_path, module=None, text=None)
+    result = build.build(sources=[source], options=options, alt_lib_path=None)
+    if result.errors:
+        kernel.io.log_indent_up()
+        kernel.io.error(f"Mypy errors:")
+        kernel.io.log_indent_up()
+
+        for error in result.errors:
+            kernel.io.error(message=error, symbol=False)
+
+        kernel.io.log_indent_down(number=2)
+        return False
+    return True

wexample_wex_addon_dev_python/commands/code/check/pylint.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from wexample_wex_core.context.execution_context import ExecutionContext
+
+
+def _code_check_pylint(context: ExecutionContext, file_path: str) -> bool:
+    """Check a Python file using pylint for code quality.
+
+    Args:
+        kernel: The application kernel
+        file_path: Path to the Python file to check
+
+    Returns:
+        bool: True if check passes, False otherwise
+    """
+    import json
+    import subprocess
+    import sys
+
+    # Use subprocess to capture pylint output
+    # This avoids issues with pylint's direct printing to stdout
+    # List of warnings to disable
+    disabled_warnings = [
+        "missing-module-docstring",
+        "import-outside-toplevel",
+        "no-name-in-module",
+        "broad-exception-caught",
+        "c-extension-no-member",
+        "line-too-long",
+    ]
+
+    cmd = [
+        sys.executable,
+        "-m",
+        "pylint",
+        file_path,
+        "--output-format=json",
+        f"--disable={','.join(disabled_warnings)}",
+    ]
+    process = subprocess.run(cmd, capture_output=True, text=True, check=False)
+
+    # Get the output from stdout
+    json_output = process.stdout.strip()
+
+    # If no output or invalid JSON, return empty list
+    if not json_output:
+        context.io.success(f"No pylint issues found in {file_path}")
+        return True
+
+    # Parse the JSON output
+    results = json.loads(json_output)
+
+    # Filter messages by type
+    errors = [msg for msg in results if msg.get("type") in ("error", "fatal")]
+    warnings = [msg for msg in results if msg.get("type") == "warning"]
+    conventions = [
+        msg for msg in results if msg.get("type") in ("convention", "refactor", "info")
+    ]
+
+    # Display results if any issues found
+    if errors or warnings or conventions:
+        # Display errors
+        if errors:
+            context.io.log_indent_up()
+            context.io.error(f"Pylint errors:")
+            context.io.log_indent_up()
+
+            for error in errors:
+                context.io.error(
+                    message=f"Line {error.get('line')}: "
+                    f"{error.get('message')} ({error.get('symbol')})",
+                    symbol=False,
+                )
+
+            context.io.log_indent_down(number=2)
+
+        # Display warnings with detailed logging
+        if warnings:
+            context.io.log_indent_up()
+            context.io.warning(f"Pylint warnings:")
+            context.io.log_indent_up()
+
+            for warning in warnings:
+                context.io.warning(
+                    f"Line {warning.get('line')}: "
+                    f"{warning.get('message')} ({warning.get('symbol')})",
+                    symbol=False,
+                )
+                context.io.properties(warning)
+
+            context.io.log_indent_down(number=2)
+        # Display conventions
+        if conventions:
+            context.io.info("Conventions:")
+            for convention in conventions:
+                context.io.base(
+                    message=f"  Line {convention.get('line')}: "
+                    f"{convention.get('message')} ({convention.get('symbol')})"
+                )
+
+        # Only consider errors as failures
+        if errors:
+            return False
+        return True
+    return True

wexample_wex_addon_dev_python/commands/code/check/pyright.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from wexample_wex_core.common.kernel import Kernel
+
+
+def _code_check_pyright(kernel: Kernel, file_path: str) -> bool:
+    """Check a Python file using pyright for static type checking.
+
+    Args:
+        kernel: The application kernel
+        file_path: Path to the Python file to check
+
+    Returns:
+        bool: True if check passes, False otherwise
+    """
+    import json
+    import subprocess
+    import sys
+
+    # Use subprocess to run pyright
+    cmd = [sys.executable, "-m", "pyright", file_path, "--outputjson"]
+    process = subprocess.run(cmd, capture_output=True, text=True, check=False)
+
+    # Get the output from stdout
+    json_output = process.stdout.strip()
+
+    # If command failed or no output, handle the error
+    if process.returncode != 0 and not json_output:
+        kernel.io.error(f"Pyright failed to run on {file_path}")
+        if process.stderr:
+            kernel.io.error(f"Error: {process.stderr}")
+        return False
+
+    # If no output, assume success
+    if not json_output:
+        kernel.io.success(f"No pyright issues found in {file_path}")
+        return True
+
+    # Parse the JSON output
+    results = json.loads(json_output)
+
+    # Extract diagnostics
+    diagnostics = results.get("diagnostics", [])
+
+    # Filter by severity
+    errors = [diag for diag in diagnostics if diag.get("severity") == "error"]
+    warnings = [diag for diag in diagnostics if diag.get("severity") == "warning"]
+    info = [diag for diag in diagnostics if diag.get("severity") == "information"]
+
+    # Display results if any issues found
+    if errors or warnings or info:
+        # Display errors
+        if errors:
+            kernel.io.log_indent_up()
+            kernel.io.error(f"Pyright errors:")
+
+            for error in errors:
+                line = error.get("range", {}).get("start", {}).get("line", 0) + 1
+                message = error.get("message", "Unknown error")
+                rule = error.get("rule", "")
+                rule_text = f" ({rule})" if rule else ""
+                kernel.io.error(f"Line {line}: {message}{rule_text}", symbol=False)
+                kernel.io.properties(error)
+
+            kernel.io.log_indent_down(number=2)
+
+        # Display warnings
+        if warnings:
+            kernel.io.log_indent_up()
+            kernel.io.warning(f"Pyright warnings:")
+
+            for warning in warnings:
+                line = warning.get("range", {}).get("start", {}).get("line", 0) + 1
+                message = warning.get("message", "Unknown warning")
+                rule = warning.get("rule", "")
+                rule_text = f" ({rule})" if rule else ""
+                kernel.io.warning(f"Line {line}: {message}{rule_text}", symbol=False)
+                kernel.io.properties(warning)
+
+            kernel.io.log_indent_down(number=2)
+
+        # Display information
+        if info:
+            kernel.io.log_indent_up()
+            kernel.io.info(f"Pyright information:")
+            kernel.io.log_indent_up()
+
+            for item in info:
+                line = item.get("range", {}).get("start", {}).get("line", 0) + 1
+                message = item.get("message", "Unknown info")
+                rule = item.get("rule", "")
+                rule_text = f" ({rule})" if rule else ""
+                kernel.io.info(f"Line {line}: {message}{rule_text}", symbol=False)
+                kernel.io.properties(item)
+
+            kernel.io.log_indent_down(number=2)
+
+        # Only consider errors as failures
+        if errors:
+            return False
+    return True

wexample_wex_addon_dev_python/commands/code/check.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from wexample_wex_core.const.middleware import (
+    MIDDLEWARE_OPTION_VALUE_ALLWAYS,
+    MIDDLEWARE_OPTION_VALUE_OPTIONAL,
+)
+from wexample_wex_core.decorator.command import command
+from wexample_wex_core.decorator.middleware import middleware
+from wexample_wex_core.decorator.option import option
+from wexample_wex_core.decorator.option_stop_on_failure import option_stop_on_failure
+
+if TYPE_CHECKING:
+    from wexample_wex_core.context.execution_context import ExecutionContext
+
+
+@option(
+    name="tool",
+    type=str,
+    required=False,
+    description="Specific tool to run (mypy, pylint, pyright). If not specified, all tools will be run.",
+)
+@option_stop_on_failure()
+@middleware(
+    name="each_python_file",
+    should_exist=True,
+    expand_glob=True,
+    stop_on_failure=MIDDLEWARE_OPTION_VALUE_OPTIONAL,
+    recursive=True,
+    parallel=MIDDLEWARE_OPTION_VALUE_OPTIONAL,
+    show_progress=MIDDLEWARE_OPTION_VALUE_ALLWAYS,
+)
+@command(
+    description="Check python code on every file: "
+    "bash cli/wex python::code/check --file ../../pip/wex-core/wexample_wex_core/ -sof"
+)
+def python__code__check(
+    context: ExecutionContext,
+    file: str,
+    tool: str | None = None,
+    stop_on_failure: bool = True,
+    parallel: bool = True,
+) -> bool:
+    """Check a Python file using various code quality tools."""
+    from wexample_app.response.failure_response import FailureResponse
+    from wexample_wex_addon_dev_python.commands.code.check.mypy import _code_check_mypy
+    from wexample_wex_addon_dev_python.commands.code.check.pylint import (
+        _code_check_pylint,
+    )
+    from wexample_wex_addon_dev_python.commands.code.check.pyright import (
+        _code_check_pyright,
+    )
+
+    # Map tool names to their check functions
+    tool_map = {
+        "mypy": _code_check_mypy,
+        "pylint": _code_check_pylint,
+        "pyright": _code_check_pyright,
+    }
+
+    # Determine which tools to run
+    if tool and tool.lower() in tool_map:
+        # Run only the specified tool
+        check_functions = [tool_map[tool.lower()]]
+    else:
+        # Run all tools if no specific tool is specified or if the specified tool is invalid
+        check_functions = [
+            _code_check_mypy,
+            _code_check_pylint,
+            _code_check_pyright,
+        ]
+
+    # Track overall success
+    all_checks_passed = True
+
+    # Run each check function
+    for check_function in check_functions:
+        context.io.title(check_function.__name__)
+        context.io.log_indent_up()
+
+        context.io.log(
+            f"🐍 Python: {context.kernel.host_workdir.render_display_path(file)}"
+        )
+
+        check_result = check_function(context, file)
+
+        if check_result:
+            context.io.success(f"No critical issue found for {check_function.__name__}")
+
+        # Update overall success status
+        all_checks_passed = all_checks_passed and check_result
+
+        # Stop if a check fails and stop_on_failure is True
+        if not check_result and stop_on_failure:
+            context.io.error("One check failed")
+
+            context.io.log_indent_down()
+
+            return FailureResponse(message="One check failed", kernel=context.kernel)
+
+        context.io.log_indent_down()
+    return all_checks_passed

wexample_wex_addon_dev_python/commands/code/format/__init__.py

@@ -0,0 +1 @@
+

wexample_wex_addon_dev_python/commands/code/format/black.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from wexample_wex_core.common.kernel import Kernel
+
+
+def _code_format_black(kernel: Kernel, file_path: str) -> bool:
+    """Format a Python file using Black.
+
+    Args:
+        kernel: The application kernel
+        file_path: Path to the Python file to format
+
+    Returns:
+        bool: True if formatting succeeds, False otherwise
+    """
+    import subprocess
+    import sys
+
+    # Use subprocess to run black
+    cmd = [sys.executable, "-m", "black", file_path]
+    process = subprocess.run(cmd, capture_output=True, text=True, check=False)
+
+    # Check if the command was successful
+    if process.returncode == 0:
+        if "reformatted" in process.stderr or "reformatted" in process.stdout:
+            kernel.io.success(f"Black successfully reformatted {file_path}")
+        else:
+            kernel.io.success(f"Black: {file_path} already well formatted")
+        return True
+    else:
+        kernel.io.error(f"Black failed to format {file_path}")
+        kernel.io.log_indent_up()
+
+        if process.stderr:
+            kernel.io.error(f"Error: {process.stderr}", symbol=False)
+        if process.stdout:
+            kernel.io.error(f"Output: {process.stdout}", symbol=False)
+
+        # Add detailed error properties
+        kernel.io.properties({"returncode": process.returncode, "command": cmd})
+
+        kernel.io.log_indent_down()
+        return False

wexample_wex_addon_dev_python/commands/code/format/isort.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from wexample_wex_core.common.kernel import Kernel
+
+
+def _code_format_isort(kernel: Kernel, file_path: str) -> bool:
+    """Format imports in a Python file using isort.
+
+    Args:
+        kernel: The application kernel
+        file_path: Path to the Python file to format
+
+    Returns:
+        bool: True if formatting succeeds, False otherwise
+    """
+    import subprocess
+    import sys
+
+    # Use subprocess to run isort
+    # --profile=black ensures compatibility with Black formatter
+    cmd = [sys.executable, "-m", "isort", "--profile=black", file_path]
+    process = subprocess.run(cmd, capture_output=True, text=True, check=False)
+
+    # Check if the command was successful
+    if process.returncode == 0:
+        if "Skipped" in process.stdout:
+            kernel.io.success(f"isort: {file_path} already well formatted")
+        else:
+            kernel.io.success(f"isort successfully reformatted imports in {file_path}")
+        return True
+    else:
+        kernel.io.error(f"isort failed to format imports in {file_path}")
+        kernel.io.log_indent_up()
+
+        if process.stderr:
+            kernel.io.error(f"Error: {process.stderr}", symbol=False)
+        if process.stdout:
+            kernel.io.error(f"Output: {process.stdout}", symbol=False)
+
+        # Add detailed error properties
+        kernel.io.properties({"returncode": process.returncode, "command": cmd})
+
+        kernel.io.log_indent_down()
+        return False

wexample_wex_addon_dev_python/commands/code/format.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from wexample_wex_core.decorator.command import command
+from wexample_wex_core.decorator.middleware import middleware
+from wexample_wex_core.decorator.option import option
+
+if TYPE_CHECKING:
+    from wexample_wex_core.common.kernel import Kernel
+
+
+@option(
+    name="tool",
+    type=str,
+    required=False,
+    description="Specific tool to run (black, isort). If not specified, all tools will be run.",
+)
+@option(
+    name="stop_on_failure",
+    type=bool,
+    required=False,
+    default=True,
+    description="Stop execution when a tool reports a failure",
+)
+@middleware(
+    name="each_python_file", should_exist=True, expand_glob=True, recursive=True
+)
+@command()
+def python__code__format(
+    kernel: Kernel,
+    file: str,
+    tool: str | None = None,
+    stop_on_failure: bool = True,
+) -> bool:
+    """Format a Python file using various code formatting tools."""
+    from wexample_wex_addon_dev_python.commands.code.format.black import (
+        _code_format_black,
+    )
+    from wexample_wex_addon_dev_python.commands.code.format.isort import (
+        _code_format_isort,
+    )
+
+    # Map tool names to their format functions
+    tool_map = {
+        "black": _code_format_black,
+        "isort": _code_format_isort,
+    }
+
+    # Determine which tools to run
+    if tool and tool.lower() in tool_map:
+        # Run only the specified tool
+        format_functions = [tool_map[tool.lower()]]
+    else:
+        # Run all tools if no specific tool is specified or if the specified tool is invalid
+        if tool and tool.lower() not in tool_map:
+            kernel.io.warning(f"Unknown tool '{tool}', running all available tools")
+
+        # Run isort first, then black (recommended order)
+        format_functions = [
+            _code_format_isort,
+            _code_format_black,
+        ]
+
+    # Track overall success
+    all_formats_passed = True
+
+    # Run each format function
+    for format_function in format_functions:
+        kernel.io.title(format_function.__name__)
+        format_result = format_function(kernel, file)
+
+        # Update overall success status
+        all_formats_passed = all_formats_passed and format_result
+
+        # Stop if a format fails and stop_on_failure is True
+        if not format_result and stop_on_failure:
+            kernel.io.warning("One formatting failed")
+            return False
+
+    return all_formats_passed

wexample_wex_addon_dev_python/commands/examples/utils/some_example_type.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class SomeExampleType(BaseModel):
+    property: str

wexample_wex_addon_dev_python/commands/examples/validate.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from wexample_wex_core.decorator.command import command
+
+if TYPE_CHECKING:
+    from wexample_wex_core.context.execution_context import ExecutionContext
+
+
+@command(description="Check python code on every file.")
+def python__examples__validate(
+    context: ExecutionContext,
+) -> None:
+    from wexample_wex_addon_dev_python.commands.examples.classes.example_pydantic_class_with_public_var_internaly_defined import (
+        ExamplePydanticClassWithPublicVarInternallyDefined,
+    )
+
+    example_class = ExamplePydanticClassWithPublicVarInternallyDefined()
+    context.kernel.log(example_class)

wexample_wex_addon_dev_python/config_value/python_package_readme_config_value.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import os
+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_dev_python.workdir.python_package_workdir import (
+    PythonPackageWorkdir,
+)
+
+if TYPE_CHECKING:
+    from wexample_wex_addon_dev_python.workdir.python_package_workdir import (
+        PythonPackageWorkdir,
+    )
+
+
+@base_class
+class PythonPackageReadmeContentConfigValue(ReadmeContentConfigValue):
+    workdir: PythonPackageWorkdir = public_field(
+        description="The python package workdir"
+    )
+
+    def get_templates(self) -> list[str] | None:
+        # 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", [])
+        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 ""
+        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])
+
+        package_name = self.workdir.get_package_name()
+        return [
+            f"# {package_name}\n\n"
+            f"{description}\n\n"
+            f"Version: {self.workdir.get_project_version()}\n\n"
+            f'{self._add_section_if_exists("features")}'
+            "## Requirements\n\n"
+            f"- Python {python_version}\n\n"
+            "## Dependencies\n\n"
+            f"{deps_list}\n\n"
+            "## Installation\n\n"
+            "```bash\n"
+            f"pip install {package_name}\n"
+            "```\n\n"
+            f'{self._add_section_if_exists("usage")}'
+            "## Links\n\n"
+            f"- Homepage: {homepage}\n\n"
+            "## License\n\n"
+            f"{license_info}"
+        ]
+
+    def _add_section_if_exists(self, section: str) -> str:
+        """
+        Returns section content if the documentation file exists
+        """
+        doc_path = self._get_doc_path(section)
+
+        if os.path.exists(doc_path):
+            with open(doc_path, encoding="utf-8") as file:
+                content = file.read()
+                return f"## {section.title()}\n\n{content}\n\n"
+
+        return ""
+
+    def _get_doc_path(self, section: str) -> str:
+        """
+        Returns the path to a documentation section file
+        """
+        return os.path.join(
+            self.workdir.get_path(), ".wex", "doc", "readme", f"{section}.md"
+        )