wexample-wex-addon-dev-python 0.0.40__py3-none-any.whl → 0.0.43__py3-none-any.whl

wexample_wex_addon_dev_python-0.0.43.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.1
+Name: wexample-wex-addon-dev-python
+Version: 0.0.43
+Summary: Python dev addon for wex
+Author-Email: weeger <contact@wexample.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Project-URL: homepage, https://github.com/wexample/python-wex-dev-python
+Requires-Python: >=3.10
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: pylint
+Requires-Dist: pyright
+Requires-Dist: wexample-filestate-python==0.0.39
+Requires-Dist: wexample-wex-addon-app==0.0.41
+Requires-Dist: wexample-wex-core==6.0.43
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Description-Content-Type: text/markdown
+
+# wexample-wex-addon-dev-python
+
+Python dev addon for wex
+
+Version: 0.0.41
+
+## Requirements
+
+- Python >=3.10
+
+## Dependencies
+
+- pydantic>=2,<3
+- pylint
+- pyright
+- wexample-filestate-python==0.0.37
+- wexample-wex-addon-app==0.0.39
+- wexample-wex-core==6.0.41
+
+## Installation
+
+```bash
+pip install wexample-wex-addon-dev-python
+```
+
+## Links
+
+- Homepage: https://github.com/wexample/python-wex-dev-python
+
+## License
+
+MIT
+## Credits
+
+This package has been developed by [Wexample](https://wexample.com), a collection of tools and utilities to streamline development workflows.
+
+Visit [wexample.com](https://wexample.com) to discover more tools and resources for efficient development.

wexample_wex_addon_dev_python-0.0.43.dist-info/RECORD

@@ -0,0 +1,5 @@
+wexample_wex_addon_dev_python-0.0.43.dist-info/METADATA,sha256=-CZaOJi_qz3KPVeRPk1X-tv1ilIGZRlJeL6innF2ITY,1401
+wexample_wex_addon_dev_python-0.0.43.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+wexample_wex_addon_dev_python-0.0.43.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+wexample_wex_addon_dev_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wexample_wex_addon_dev_python-0.0.43.dist-info/RECORD,,

{wexample_wex_addon_dev_python-0.0.40.dist-info → wexample_wex_addon_dev_python-0.0.43.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: pdm-backend (2.4.5)
 Root-Is-Purelib: true
 Tag: py3-none-any
-

wexample_wex_addon_dev_python-0.0.43.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+
+[gui_scripts]
+

wexample_wex_addon_dev_python/commands/code/check/mypy.py

@@ -1,44 +0,0 @@
-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

@@ -1,106 +0,0 @@
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from wexample_wex_core.common.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

@@ -1,99 +0,0 @@
-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

@@ -1,103 +0,0 @@
-from typing import Optional, TYPE_CHECKING
-
-from wexample_wex_core.const.middleware import MIDDLEWARE_OPTION_VALUE_OPTIONAL, MIDDLEWARE_OPTION_VALUE_ALLWAYS
-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.common.execution_context import ExecutionContext
-
-
-# TODO working command:  bash cli/wex python::code/check --file ../../pip/wex-core/wexample_wex_core/ -sof
-@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
-)
-# TODO
-#   - Créer des commandes de test
-#   - Les outils 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(
-        context: "ExecutionContext",
-        file: str,
-        tool: Optional[str] = None,
-        stop_on_failure: bool = True,
-        parallel: 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_helpers.helpers.cli import cli_make_clickable_path
-    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

@@ -1 +0,0 @@
-

wexample_wex_addon_dev_python/commands/code/format/black.py

@@ -1,41 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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/middleware/each_python_file_middleware.py

@@ -1,74 +0,0 @@
-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/python_addon_manager.py

@@ -1,13 +0,0 @@
-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.40.dist-info/METADATA

@@ -1,15 +0,0 @@
-Metadata-Version: 2.4
-Name: wexample-wex-addon-dev-python
-Version: 0.0.40
-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
-Requires-Dist: wexample-wex-core
-
-# Wex Addon Dev Python

wexample_wex_addon_dev_python-0.0.40.dist-info/RECORD

@@ -1,17 +0,0 @@
-wexample_wex_addon_dev_python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wexample_wex_addon_dev_python/python_addon_manager.py,sha256=iEgJ-jqrReMMkI2tHIOSKlumKXBW1ZAbGTzXY17Ilh0,497
-wexample_wex_addon_dev_python/commands/code/check.py,sha256=f_cTeGVAiLJCjTe-lOa74ynOrhtkDOJFwtW4sdj_J6Q,3682
-wexample_wex_addon_dev_python/commands/code/format.py,sha256=r2DNT6_Mf9ltKRY7beqBCHIXmXn6LWe8h0Jm7TAX0xs,2395
-wexample_wex_addon_dev_python/commands/code/check/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wexample_wex_addon_dev_python/commands/code/check/mypy.py,sha256=2Dy72ctj6RFaL4uMQTyWKAJePhULqu9AMfOli8DYF4w,1337
-wexample_wex_addon_dev_python/commands/code/check/pylint.py,sha256=HmGUfJQWlVcmFrPHwwTimfegUAdmIJvga5_lfl8i258,3309
-wexample_wex_addon_dev_python/commands/code/check/pyright.py,sha256=22a8bOBrVSZzSTJRggGx1smgT9ZsnxbIy4EpJdvBLZg,3529
-wexample_wex_addon_dev_python/commands/code/format/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-wexample_wex_addon_dev_python/commands/code/format/black.py,sha256=qDr_siZYzSDoCv1BIqa95S0C97cW7mp7kWLxidJvP4s,1372
-wexample_wex_addon_dev_python/commands/code/format/isort.py,sha256=IwBeUntdtUwbmvW2OMDwVSjmxrPCPu2BOuZ_8RAnFC8,1450
-wexample_wex_addon_dev_python/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wexample_wex_addon_dev_python/middleware/each_python_file_middleware.py,sha256=K9thNgehAKN3WDvOCfa_k9pfPGZi_ooay7m9ttWOhK8,2317
-wexample_wex_addon_dev_python-0.0.40.dist-info/METADATA,sha256=HVLI1ODWv2zXky-VB7qco92dAi-dHTLUKRLBrS-Oj_s,504
-wexample_wex_addon_dev_python-0.0.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wexample_wex_addon_dev_python-0.0.40.dist-info/top_level.txt,sha256=UH2tJu4bqlyH4nrhg8KctBXufm1rw1ZprTwvdz0robs,30
-wexample_wex_addon_dev_python-0.0.40.dist-info/RECORD,,

wexample_wex_addon_dev_python-0.0.40.dist-info/top_level.txt

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