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

wexample_wex_addon_dev_python/commands/code/check/mypy.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+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
+
+    # Import mypy modules
+    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,101 @@
+from __future__ import annotations
+
+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,105 @@
+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_helpers.helpers.cli import cli_make_clickable_path
+    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: {cli_make_clickable_path(context.kernel.host_workdir.get_resolved_target(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")
+
+            from wexample_app.response.failure_response import FailureResponse
+
+            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,43 @@
+from __future__ import annotations
+
+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,44 @@
+from __future__ import annotations
+
+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,77 @@
+from __future__ import annotations
+
+from wexample_wex_core.common.kernel import Kernel
+from wexample_wex_core.decorator.command import command
+from wexample_wex_core.decorator.middleware import middleware
+from wexample_wex_core.decorator.option import option
+
+
+@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/classes/example_pydantic_class_with_public_var_internaly_defined.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from pydantic import BaseModel, PrivateAttr
+
+# Stay lazy as most as possible
+if TYPE_CHECKING:
+    from wexample_wex_addon_dev_python.commands.examples.utils.some_example_type import (
+        SomeExampleType,
+    )
+
+
+class ExamplePydanticClassWithPublicVarInternallyDefined(BaseModel):
+    _internal_var: SomeExampleType = PrivateAttr()
+
+    # model_post_init runs AFTER Pydantic has validated/coerced model fields.
+    # Use it to initialize PrivateAttr that may rely on validated state.
+    # If you depend on other mixins' __init__ ordering, prefer a custom __init__ or finalize().
+    def model_post_init(self, __context: Any) -> None:
+        # Lazy import to avoid circular imports; runs after validation
+        from wexample_wex_addon_dev_python.commands.examples.utils.some_example_type import (
+            SomeExampleType,
+        )
+
+        self._internal_var = SomeExampleType(property="Yes")
+
+    @property
+    def public_var(self) -> SomeExampleType:
+        return self._internal_var
+
+    @public_var.setter
+    def public_var(self, value: SomeExampleType) -> None:
+        from wexample_wex_addon_dev_python.commands.examples.utils.some_example_type import (
+            SomeExampleType,
+        )
+
+        # Stay lazy as most as possible
+        # Check value at setting, avoid checking it
+        if not isinstance(value, SomeExampleType):
+            raise TypeError(f"public_var must be SomeExampleType, got {type(value)!r}")
+        self._internal_var = value

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)