wexample-wex-addon-dev-python 0.0.33__tar.gz

wexample_wex_addon_dev_python-0.0.33/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: wexample-wex-addon-dev-python
+Version: 0.0.33
+Summary: Python dev addon for wex
+Author-email: weeger <contact@wexample.com>
+License: MIT
+Project-URL: homepage, https://github.com/wexample/python-wex-dev-python
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# Wex Addon Dev Python

wexample_wex_addon_dev_python-0.0.33/README.md

@@ -0,0 +1 @@
+# Wex Addon Dev Python

wexample_wex_addon_dev_python-0.0.33/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = [
+    "setuptools",
+    "wheel",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wexample-wex-addon-dev-python"
+version = "0.0.33"
+description = "Python dev addon for wex"
+authors = [
+    { name = "weeger", email = "contact@wexample.com" },
+]
+requires-python = ">=3.6"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = []
+
+[project.readme]
+file = "README.md"
+content-type = "text/markdown"
+
+[project.license]
+text = "MIT"
+
+[project.urls]
+homepage = "https://github.com/wexample/python-wex-dev-python"

wexample_wex_addon_dev_python-0.0.33/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wexample_wex_addon_dev_python-0.0.33/wexample_wex_addon_dev_python/commands/code/check/mypy.py

@@ -0,0 +1,42 @@
+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.error(f"Mypy found errors in {file_path}:")
+        kernel.io.log_indent_up()
+
+        for error in result.errors:
+            kernel.io.error(message=error, symbol=False)
+        kernel.io.log_indent_down()
+        return False
+    return True

wexample_wex_addon_dev_python-0.0.33/wexample_wex_addon_dev_python/commands/code/check/pylint.py

@@ -0,0 +1,100 @@
+from wexample_wex_core.common.kernel import Kernel
+
+
+def _code_check_pylint(kernel: "Kernel", 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 pylint modules
+    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:
+        kernel.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:
+            kernel.io.error(f"Pylint found errors in {file_path}:")
+            kernel.io.log_indent_up()
+            for error in errors:
+                kernel.io.error(
+                    message=f"Line {error.get('line')}: "
+                    f"{error.get('message')} ({error.get('symbol')})",
+                    symbol=False,
+                )
+            kernel.io.log_indent_down()
+
+        # Display warnings with detailed logging
+        if warnings:
+            kernel.io.warning(f"Pylint found warnings in {file_path}:")
+            kernel.io.log_indent_up()
+
+            for warning in warnings:
+                kernel.io.warning(
+                    f"Line {warning.get('line')}: "
+                    f"{warning.get('message')} ({warning.get('symbol')})",
+                    symbol=False,
+                )
+                kernel.io.properties(warning)
+
+            kernel.io.log_indent_down()
+        # Display conventions
+        if conventions:
+            kernel.io.info("Conventions:")
+            for convention in conventions:
+                kernel.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-0.0.33/wexample_wex_addon_dev_python/commands/code/check/pyright.py

@@ -0,0 +1,98 @@
+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.error(f"Pyright found errors in {file_path}:")
+            kernel.io.log_indent_up()
+
+            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()
+
+        # Display warnings
+        if warnings:
+            kernel.io.warning(f"Pyright found warnings in {file_path}:")
+            kernel.io.log_indent_up()
+
+            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()
+
+        # Display information
+        if info:
+            kernel.io.info(f"Pyright found information in {file_path}:")
+            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()
+
+        # Only consider errors as failures
+        if errors:
+            return False
+    return True

wexample_wex_addon_dev_python-0.0.33/wexample_wex_addon_dev_python/commands/code/check.py

@@ -0,0 +1,101 @@
+from typing import Optional
+
+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 (mypy, pylint, pyright). 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(
+    # TODO working command:  bash cli/wex python::code/check --file ../../pip/wex-core/wexample_wex_core/ -sof
+    #      -> sof / stop_on_failure does not works
+    #         en tout cas ça ne marche pas lors de l'itération, il faudrait etre capable d'ajouter un signal d'arret.
+    #      -> Gérer les valeurs de retour, pour l'instant c'est une liste, ce sera un MultipleResponse
+    #      -> continue_on_error=False,
+    #      -> aggregation_mode='list',
+    #      -> parallel=True,
+    #      -> limit=False,
+    #      -> show_progres=True
+    #      -> Peut être que
+    name="each_python_file",
+    should_exist=True,
+    expand_glob=True,
+    recursive=True)
+# TODO après et durant la mise en place de ça on pourrait:
+#   - Créer des commandes de test
+#   - Les outilis utilisent des méthodes pour exécuter des commandes shell, on peut les wrap dans des premier helpers
+#   - Dans les commandes de test:
+#     > teste l'appel de commandes en interne
+#     > teste du prompting et des context de prompt et du nesting
+@command()
+def python__code__check(
+    kernel: "Kernel",
+    file: str,
+    tool: Optional[str] = None,
+    stop_on_failure: bool = True,
+) -> bool:
+    """Check a Python file using various code quality tools."""
+    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:
+        kernel.io.title(check_function.__name__)
+        kernel.io.log_indent_up()
+        kernel.io.log(file)
+
+        check_result = check_function(kernel, file)
+
+        if check_result:
+            kernel.io.success(f"No critical issue found for {check_function.__name__}")
+
+        # Update overall success status
+        all_checks_passed = all_checks_passed and check_result
+        kernel.io.log_indent_down()
+
+        # Stop if a check fails and stop_on_failure is True
+        if not check_result and stop_on_failure:
+            kernel.io.error("One check failed")
+            return False
+
+    return all_checks_passed

wexample_wex_addon_dev_python-0.0.33/wexample_wex_addon_dev_python/commands/code/format/__init__.py

@@ -0,0 +1 @@
+

wexample_wex_addon_dev_python-0.0.33/wexample_wex_addon_dev_python/commands/code/format/black.py

@@ -0,0 +1,41 @@
+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-0.0.33/wexample_wex_addon_dev_python/commands/code/format/isort.py

@@ -0,0 +1,42 @@
+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-0.0.33/wexample_wex_addon_dev_python/commands/code/format.py

@@ -0,0 +1,75 @@
+from typing import Optional
+
+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: Optional[str] = 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-0.0.33/wexample_wex_addon_dev_python/middleware/each_python_file_middleware.py

@@ -0,0 +1,74 @@
+import os.path
+from typing import Set, TYPE_CHECKING
+
+from wexample_wex_core.middleware.each_file_middleware import EachFileMiddleware
+
+if TYPE_CHECKING:
+    from wexample_wex_core.common.command_request import CommandRequest
+
+
+class EachPythonFileMiddleware(EachFileMiddleware):
+    """
+    Middleware for processing Python files only.
+    - Filters files by .py extension by default
+    - Ignores special directories like __pycache__ during recursion
+    """
+    # Default extension to filter
+    python_extension_only: bool = True
+
+    # Default list of directories to ignore during recursion
+    ignored_directories: Set[str] = {
+        "__pycache__",
+        ".git",
+        ".idea",
+        ".vscode",
+        "venv",
+        "env",
+        "node_modules",
+        ".pytest_cache",
+        ".mypy_cache",
+        ".ruff_cache",
+    }
+
+    def __init__(self, **kwargs):
+        # Allow overriding the default settings
+        if "python_extension_only" in kwargs:
+            self.python_extension_only = kwargs.pop("python_extension_only")
+
+        if "ignored_directories" in kwargs:
+            self.ignored_directories = set(kwargs.pop("ignored_directories"))
+
+        super().__init__(**kwargs)
+
+    def _should_process_item(self, request: "CommandRequest", item_path: str) -> bool:
+        """
+        Only process Python files based on extension.
+        
+        Args:
+            item_path: Path to the item to check
+            
+        Returns:
+            True if the item should be processed, False otherwise
+        """
+        # First check if it's a file (parent class behavior)
+        if not os.path.isfile(item_path):
+            return False
+
+        # If python_extension_only is enabled, check file extension
+        if self.python_extension_only:
+            return item_path.endswith(".py")
+
+        # Otherwise, accept all files
+        return True
+
+    def _should_explore_directory(self, request: "CommandRequest", directory_name: str) -> bool:
+        """
+        Skip directories that are in the ignored_directories list.
+        
+        Args:
+            directory_name: Name of the directory to check
+            
+        Returns:
+            False if the directory is in the ignored list, True otherwise
+        """
+        return directory_name not in self.ignored_directories

wexample_wex_addon_dev_python-0.0.33/wexample_wex_addon_dev_python/python_addon_manager.py

@@ -0,0 +1,13 @@
+from typing import List, Type
+
+from wexample_wex_core.common.abstract_addon_manager import AbstractAddonManager
+from wexample_wex_core.middleware.abstract_middleware import AbstractMiddleware
+
+
+class PythonAddonManager(AbstractAddonManager):
+    def get_middlewares_classes(self) -> List[Type["AbstractMiddleware"]]:
+        from wexample_wex_addon_dev_python.middleware.each_python_file_middleware import EachPythonFileMiddleware
+
+        return [
+            EachPythonFileMiddleware,
+        ]

wexample_wex_addon_dev_python-0.0.33/wexample_wex_addon_dev_python.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: wexample-wex-addon-dev-python
+Version: 0.0.33
+Summary: Python dev addon for wex
+Author-email: weeger <contact@wexample.com>
+License: MIT
+Project-URL: homepage, https://github.com/wexample/python-wex-dev-python
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# Wex Addon Dev Python

wexample_wex_addon_dev_python-0.0.33/wexample_wex_addon_dev_python.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+wexample_wex_addon_dev_python/__init__.py
+wexample_wex_addon_dev_python/python_addon_manager.py
+wexample_wex_addon_dev_python.egg-info/PKG-INFO
+wexample_wex_addon_dev_python.egg-info/SOURCES.txt
+wexample_wex_addon_dev_python.egg-info/dependency_links.txt
+wexample_wex_addon_dev_python.egg-info/top_level.txt
+wexample_wex_addon_dev_python/commands/code/check.py
+wexample_wex_addon_dev_python/commands/code/format.py
+wexample_wex_addon_dev_python/commands/code/check/__init__.py
+wexample_wex_addon_dev_python/commands/code/check/mypy.py
+wexample_wex_addon_dev_python/commands/code/check/pylint.py
+wexample_wex_addon_dev_python/commands/code/check/pyright.py
+wexample_wex_addon_dev_python/commands/code/format/__init__.py
+wexample_wex_addon_dev_python/commands/code/format/black.py
+wexample_wex_addon_dev_python/commands/code/format/isort.py
+wexample_wex_addon_dev_python/middleware/__init__.py
+wexample_wex_addon_dev_python/middleware/each_python_file_middleware.py

wexample_wex_addon_dev_python-0.0.33/wexample_wex_addon_dev_python.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

wexample_wex_addon_dev_python-0.0.33/wexample_wex_addon_dev_python.egg-info/top_level.txt

@@ -0,0 +1 @@
+wexample_wex_addon_dev_python