wexample-wex-core 0.0.40__py3-none-any.whl

wexample_wex_core/addons/__init__.py

@@ -0,0 +1,3 @@
+"""
+Wex Core built-in addons
+"""

wexample_wex_core/addons/default/commands/info/show.py

@@ -0,0 +1,32 @@
+from typing import TYPE_CHECKING
+
+from wexample_wex_core.decorator.command import command
+
+if TYPE_CHECKING:
+    from wexample_wex_core.common.execution_context import ExecutionContext
+
+
+@command()
+def default__info__show(
+        context: "ExecutionContext"
+) -> None:
+    registry = context.kernel.get_configuration_registry()
+    
+    context.io.properties(
+        title="General",
+        properties={
+            "Location": context.kernel.workdir.get_resolved(),
+            "Environment": registry.env,
+            "Arguments": context.kernel._sys_argv,
+        }
+    )
+
+    context.kernel.io.properties(
+        title="Resolvers",
+        properties=context.kernel.get_resolvers()
+    )
+
+    context.kernel.io.properties(
+        title="Runners",
+        properties=context.kernel.get_runners()
+    )

wexample_wex_core/addons/default/commands/version/increment.py

@@ -0,0 +1,29 @@
+from typing import TYPE_CHECKING
+
+from wexample_helpers.const.types import UPGRADE_TYPE_MINOR
+from wexample_helpers.helpers.version import version_increment
+from wexample_wex_core.decorator.command import command
+from wexample_wex_core.decorator.option import option
+
+if TYPE_CHECKING:
+    from wexample_wex_core.common.execution_context import ExecutionContext
+
+
+@option(name="version", type=str, required=True)
+@option(name="type", type=str)
+@option(name="increment", type=int)
+@option(name="build", type=bool)
+@command()
+def default__version__increment(
+        context: "ExecutionContext",
+        version: str,
+        type: str = UPGRADE_TYPE_MINOR,
+        increment: int = 1,
+        build: bool = False,
+) -> str:
+    return version_increment(
+        version=version,
+        type=type,
+        increment=increment,
+        build=build,
+    )

wexample_wex_core/addons/default/default_addon_manager.py

@@ -0,0 +1,17 @@
+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 DefaultAddonManager(AbstractAddonManager):
+    def get_middlewares_classes(self) -> List[Type["AbstractMiddleware"]]:
+        from wexample_wex_core.middleware.each_directory_middleware import EachDirectoryMiddleware
+        from wexample_wex_core.middleware.each_file_middleware import EachFileMiddleware
+        from wexample_wex_core.middleware.each_path_middleware import EachPathMiddleware
+
+        return [
+            EachDirectoryMiddleware,
+            EachFileMiddleware,
+            EachPathMiddleware,
+        ]

wexample_wex_core/addons/test/commands/run/all.py

@@ -0,0 +1,54 @@
+import os
+from typing import TYPE_CHECKING
+
+from wexample_wex_core.decorator.command import command
+
+if TYPE_CHECKING:
+    from wexample_wex_core.common.execution_context import ExecutionContext
+
+
+@command()
+def test__run__all(
+        context: "ExecutionContext"
+) -> None:
+    import pytest
+    from wexample_wex_core.common.abstract_addon_manager import AbstractAddonManager
+
+    # Change to project root directory
+    workdir = context.kernel.workdir.get_resolved()
+    os.chdir(workdir)
+
+    context.io.log(f"Starting pytest test suite from {workdir}")
+
+    # TODO
+    #  Voir /home/weeger/Desktop/WIP/WEB/WEXAMPLE/WEX/local/wex/src/core/file/KernelRegistryFileStructure.py
+    #  Voir /home/weeger/Desktop/WIP/WEB/WEXAMPLE/WEX/local/wex/src/core/file/AbstractFileSystemStructure.py
+    #  - Recopier un maximum de propriétés utiles dur genre on_missing ou atre
+    #  - Créer YamlLocalFile basé sur LocalFile
+    #  - Créer KernelRegistryFileStructure basé sur YamlLocalFile + KernelChild
+    #  - Créer le registre comme avant et le sauver dans tmp.
+    #  - Le registre identifier les fichier test pour chaque commande, qu'on réutilisera ici.
+
+
+    # Build pytest arguments explicitly to avoid using sys.argv
+    pytest_args = [
+        "tests",  # Run tests from the tests directory
+        "--color=yes",  # Enable colored output
+        "-v"  # Verbose output
+    ]
+
+    # Add addons tests directories
+    for addon in context.kernel.get_addons().values():
+        assert isinstance(addon, AbstractAddonManager)
+        context.io.log(f'Adding tests from addon: {addon.get_snake_short_class_name()}')
+        pytest_args.append(addon.workdir.get_resolved_target('tests'))
+
+    context.io.log(f"Running pytest with args: {' '.join(pytest_args)}")
+
+    # Run pytest with explicit arguments
+    exit_code = pytest.main(pytest_args)
+
+    if exit_code == 0:
+        context.io.success("All tests passed!")
+    else:
+        context.io.error(f"Tests failed with exit code: {exit_code}")

wexample_wex_core/addons/test/test_addon_manager.py

@@ -0,0 +1,5 @@
+from wexample_wex_core.common.abstract_addon_manager import AbstractAddonManager
+
+
+class TestAddonManager(AbstractAddonManager):
+    pass

wexample_wex_core/command/extended_command.py

@@ -0,0 +1,291 @@
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import TYPE_CHECKING, Dict, Any, List
+
+from wexample_app.common.command import Command
+from wexample_app.response.failure_response import FailureResponse
+from wexample_helpers.const.types import Kwargs
+from wexample_wex_core.common.command_method_wrapper import CommandMethodWrapper
+from wexample_wex_core.common.execution_context import ExecutionContext
+from wexample_wex_core.const.middleware import MIDDLEWARE_OPTION_VALUE_ALLWAYS, MIDDLEWARE_OPTION_VALUE_OPTIONAL
+from wexample_wex_core.const.types import ParsedArgs
+from wexample_wex_core.exception.command_argument_conversion_exception import CommandArgumentConversionException
+from wexample_wex_core.exception.command_option_missing_exception import CommandOptionMissingException
+from wexample_wex_core.exception.command_unexpected_argument_exception import CommandUnexpectedArgumentException
+
+if TYPE_CHECKING:
+    from wexample_app.common.command_request import CommandRequest
+
+
+class ExtendedCommand(Command):
+    command_wrapper: CommandMethodWrapper
+
+    def __init__(self, command_wrapper: CommandMethodWrapper, *args: Any, **kwargs: Kwargs):
+        kwargs['command_wrapper'] = command_wrapper
+
+        super().__init__(
+            function=command_wrapper.function,
+            *args,
+            **kwargs
+        )
+
+    def execute_request(self, request: "CommandRequest") -> Any:
+        from wexample_app.helpers.response import response_normalize
+        from wexample_app.response.multiple_response import MultipleResponse
+
+        middlewares_attributes = self.command_wrapper.middlewares_attributes
+        middlewares_registry = self.kernel.get_registry('middlewares')
+
+        for name in middlewares_attributes:
+            middleware_class = middlewares_registry.get_class(name)
+            middleware = middleware_class(name=name, **middlewares_attributes[name])
+            self.command_wrapper.set_middleware(middleware)
+
+        function_kwargs = self._build_function_kwargs(
+            request=request
+        )
+
+        if len(self.command_wrapper.middlewares) > 0:
+            output = MultipleResponse(kernel=self.kernel)
+
+            for middleware in self.command_wrapper.middlewares:
+                show_progress = middleware.show_progress == MIDDLEWARE_OPTION_VALUE_ALLWAYS or (
+                        middleware.show_progress == MIDDLEWARE_OPTION_VALUE_OPTIONAL and function_kwargs[
+                    "show_progress"])
+
+                # Each middleware can multiply the executions,
+                # e.g. executing the command on every file of a list.
+                execution_contexts = middleware.build_execution_contexts(
+                    command_wrapper=self.command_wrapper,
+                    request=request,
+                    function_kwargs=function_kwargs
+                )
+
+                # Apply limit if specified
+                if isinstance(middleware.max_iterations, int) and middleware.max_iterations > 0:
+                    execution_contexts = execution_contexts[:middleware.max_iterations]
+                    self.kernel.io.info(
+                        f'Middleware \"{middleware.get_short_class_name()}\" truncated list to {middleware.max_iterations} items')
+
+                # Check if middleware should run in parallel
+                if (middleware.parallel == MIDDLEWARE_OPTION_VALUE_ALLWAYS
+                        or (middleware.parallel == MIDDLEWARE_OPTION_VALUE_OPTIONAL
+                            and "parallel" in function_kwargs and function_kwargs["parallel"])):
+                    # Execute passes in parallel using asyncio
+                    responses = asyncio.run(self._execute_passes_parallel(
+                        execution_contexts=execution_contexts,
+                    ))
+
+                    # Add all responses to output
+                    for response in responses:
+                        output.append(response)
+
+                        # Check if we should stop on failure
+                        if isinstance(response, FailureResponse) and middleware.stop_on_failure:
+                            # "Stop" does not mean "fail", so we just stop the process.
+                            return output
+                else:
+                    i = 0
+                    length = len(execution_contexts)
+
+                    if show_progress:
+                        # First bar.
+                        request.kernel.io.progress(length, i)
+
+                    # Execute passes sequentially
+                    for context in execution_contexts:
+
+                        response = response_normalize(
+                            kernel=self.kernel,
+                            response=self.function(
+                                **context.function_kwargs
+                            )
+                        )
+
+                        output.append(response)
+                        i += 1
+
+                        if show_progress:
+                            request.kernel.io.progress(length, i)
+
+                        if isinstance(response, FailureResponse) and (
+                                middleware.stop_on_failure == MIDDLEWARE_OPTION_VALUE_ALLWAYS
+                                or (middleware.stop_on_failure == MIDDLEWARE_OPTION_VALUE_OPTIONAL
+                                    and "stop_on_failure" in function_kwargs and function_kwargs["stop_on_failure"])
+                        ):
+                            # "Stop" does not mean "fail", so we just stop the process.
+                            return output
+
+            return output
+
+        context = ExecutionContext(
+            middleware=None,
+            command_wrapper=self.command_wrapper,
+            request=request,
+            function_kwargs=function_kwargs
+        )
+
+        return response_normalize(
+            kernel=self.kernel,
+            response=self.function(
+                **context.function_kwargs
+            )
+        )
+
+    async def _execute_passes_parallel(self, execution_contexts: List[ExecutionContext]) -> List[Any]:
+        """Execute multiple passes in parallel using asyncio.
+        
+        Args:
+            execution_contexts: List of ExecutionPass objects to execute in parallel
+            
+        Returns:
+            List of normalized responses from all executions
+        """
+        from wexample_app.helpers.response import response_normalize
+        from wexample_app.response.abstract_response import AbstractResponse
+
+        # Create a list to store all tasks
+        tasks = []
+
+        # Create an executor for running CPU-bound functions in a thread pool
+        executor = ThreadPoolExecutor(max_workers=min(32, len(execution_contexts)))
+
+        # Define a coroutine that executes a single pass
+        async def execute_single_pass(execution_context: ExecutionContext) -> "AbstractResponse":
+            from wexample_prompt.output.buffer_output_handler import BufferOutputHandler
+
+            output = BufferOutputHandler()
+            # Detach io manager to print log result at the end.
+            execution_context._init_io_manager(
+                output=output
+            )
+
+            # Run the function in a thread pool to avoid blocking the event loop
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(
+                executor,
+                lambda: self.function(**execution_context.function_kwargs)
+            )
+
+            self.kernel.io.print_responses(
+                output.buffer
+            )
+
+            # Normalize the response
+            return response_normalize(kernel=self.kernel, response=result)
+
+        # Create a task for each pass
+        for execution_context in execution_contexts:
+            task = asyncio.create_task(execute_single_pass(execution_context))
+            tasks.append(task)
+
+        # Wait for all tasks to complete
+        responses = await asyncio.gather(*tasks)
+
+        # Close the executor
+        executor.shutdown(wait=False)
+
+        return responses
+
+    def _parse_arguments(self, arguments: List[str]) -> ParsedArgs:
+        from wexample_helpers.helpers.cli import cli_argument_convert_value
+
+        """Parse raw command line arguments into a dictionary of option name to value."""
+        result: Dict[str, Any] = {}
+        skip_next = False
+
+        for i, arg in enumerate(arguments):
+            # Skip this iteration if we've already processed this argument as a value
+            if skip_next:
+                skip_next = False
+                continue
+
+            # Check if the argument is an option (starts with - or --)
+            if arg.startswith('--'):
+                # Long option name (e.g., --version)
+                option_name = arg[2:]
+                option = self.command_wrapper.find_option_by_kebab_name(option_name)
+
+                if not option:
+                    # Raise exception for unexpected argument
+                    raise CommandUnexpectedArgumentException(
+                        argument=arg,
+                        allowed_arguments=self.command_wrapper.get_options_names()
+                    )
+
+                # Process the option
+                if option.is_flag:
+                    result[option.name] = True
+                elif i + 1 < len(arguments) and not arguments[i + 1].startswith('-'):
+                    try:
+                        result[option.name] = cli_argument_convert_value(arguments[i + 1], option.type)
+                        skip_next = True
+                    except Exception as e:
+                        raise CommandArgumentConversionException(
+                            argument_name=option.name,
+                            value=arguments[i + 1],
+                            target_type=option.type,
+                            cause=e
+                        )
+                else:
+                    result[option.name] = option.default if option.default is not None else None
+
+            elif arg.startswith('-') and len(arg) > 1:
+                # Short option name (e.g., -v)
+                short_name = arg[1:]
+                option = self.command_wrapper.find_option_by_short_name(short_name)
+
+                if not option:
+                    # Raise exception for unexpected argument
+                    raise CommandUnexpectedArgumentException(
+                        argument=arg,
+                        allowed_arguments=self.command_wrapper.get_options_names()
+                    )
+
+                # Process the option
+                if option.is_flag:
+                    result[option.name] = True
+                elif i + 1 < len(arguments) and not arguments[i + 1].startswith('-'):
+                    try:
+                        result[option.name] = cli_argument_convert_value(arguments[i + 1], option.type)
+                        skip_next = True
+                    except Exception as e:
+                        raise CommandArgumentConversionException(
+                            argument_name=option.name,
+                            value=arguments[i + 1],
+                            target_type=option.type,
+                            cause=e
+                        )
+                else:
+                    result[option.name] = option.default if option.default is not None else None
+
+        return result
+
+    def _build_function_kwargs(self, request: "CommandRequest") -> Dict[str, Any]:
+        # Allow middleware to add extra options.
+        for middleware in self.command_wrapper.middlewares:
+            middleware.append_options(
+                request=request,
+                command_wrapper=self.command_wrapper,
+            )
+
+        """Execute the command with the given request arguments."""
+        # Parse and convert arguments to appropriate types
+        parsed_args = self._parse_arguments(request.arguments)
+
+        """Build the final kwargs dictionary for the function call."""
+        function_kwargs = {}
+
+        # Process all declared options
+        for option in self.command_wrapper.options:
+            # If the option is in parsed args, use that value
+            if option.name in parsed_args:
+                option.value = function_kwargs[option.name] = parsed_args[option.name]
+            # Otherwise, use the default value if available
+            elif option.default is not None:
+                option.value = function_kwargs[option.name] = option.default
+            # If the option is required but not provided, raise an error
+            elif option.required:
+                raise CommandOptionMissingException(option_name=option.name)
+
+        return function_kwargs

wexample_wex_core/command/middlewares_registry.py

@@ -0,0 +1,42 @@
+from typing import TYPE_CHECKING, List, cast, Type
+
+from pydantic import BaseModel
+
+from wexample_helpers.service.mixins.registry_container_mixin import RegistryContainerMixin
+
+if TYPE_CHECKING:
+    from wexample_wex_core.middleware.abstract_middleware import AbstractMiddleware
+
+
+class MiddlewaresRegistry(RegistryContainerMixin, BaseModel):
+    """Middleware configuration for command execution.
+    
+    Middlewares can modify the behavior of commands, such as by iterating over
+    multiple values for a single option, running in parallel, etc.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self._init_middlewares()
+
+    def _init_middlewares(self):
+        self.register_items(
+            'middlewares',
+            self._get_middlewares_classes()
+        )
+
+    def _get_middlewares_classes(self) -> List[Type["AbstractMiddleware"]]:
+        from wexample_wex_core.middleware.each_directory_middleware import EachDirectoryMiddleware
+        from wexample_wex_core.middleware.each_file_middleware import EachFileMiddleware
+        from wexample_wex_core.middleware.each_path_middleware import EachPathMiddleware
+
+        return [
+            EachDirectoryMiddleware,
+            EachFileMiddleware,
+            EachPathMiddleware,
+        ]
+
+    def create_middleware_instance(self, name: str):
+        from wexample_app.service.service_registry import ServiceRegistry
+        cast(ServiceRegistry, self.get_registry('middlewares').get(name))

wexample_wex_core/command/option.py

@@ -0,0 +1,26 @@
+from typing import Any, Optional, Type
+
+from pydantic import BaseModel
+
+from wexample_helpers.helpers.string import string_to_kebab_case
+
+
+class Option(BaseModel):
+    name: str
+    kebab_name: Optional[str] = None
+    short_name: Optional[str] = None
+    type: Type
+    description: Optional[str] = None
+    required: bool = False
+    default: Any = None
+    is_flag: bool = False
+    # The computed value using input argument or default value.
+    value: Any = None
+
+    def __init__(self, **kwargs):
+        from wexample_wex_core.helpers.option import option_build_short_name
+
+        super().__init__(**kwargs)
+
+        self.kebab_name = string_to_kebab_case(self.name)
+        self.short_name = option_build_short_name(self.name)

wexample_wex_core/common/abstract_addon_manager.py

@@ -0,0 +1,41 @@
+from typing import Optional, List, Type
+
+from pydantic import BaseModel
+
+from wexample_app.common.abstract_kernel import AbstractKernel
+from wexample_app.common.abstract_kernel_child import AbstractKernelChild
+from wexample_filestate.mixins.with_workdir_mixin import WithWorkdirMixin
+from wexample_helpers.classes.mixin.has_snake_short_class_name_class_mixin import HasSnakeShortClassNameClassMixin
+from wexample_helpers.classes.mixin.has_two_steps_init import HasTwoStepInit
+from wexample_wex_core.middleware.abstract_middleware import AbstractMiddleware
+
+
+class AbstractAddonManager(
+    AbstractKernelChild,
+    HasTwoStepInit,
+    HasSnakeShortClassNameClassMixin,
+    BaseModel,
+    WithWorkdirMixin,
+):
+    def __init__(self, kernel: "AbstractKernel", **kwargs):
+        import inspect
+        import os.path
+
+        BaseModel.__init__(self, **kwargs)
+        AbstractKernelChild.__init__(self, kernel=kernel)
+
+        # Get the path of the actual addon manager class file
+        manager_file = inspect.getfile(self.__class__)
+
+        WithWorkdirMixin._init_workdir(
+            self,
+            entrypoint_path=os.path.dirname(manager_file),
+            io_manager=self.kernel.io
+        )
+
+    @classmethod
+    def get_class_name_suffix(cls) -> Optional[str]:
+        return "AddonManager"
+
+    def get_middlewares_classes(self) -> List[Type["AbstractMiddleware"]]:
+        return []

wexample_wex_core/common/command_method_wrapper.py

@@ -0,0 +1,55 @@
+from dataclasses import field
+from typing import List, Optional, Dict
+
+from pydantic import BaseModel
+
+from wexample_helpers.const.types import AnyCallable, Kwargs
+from wexample_wex_core.command.option import Option
+from wexample_wex_core.middleware.abstract_middleware import AbstractMiddleware
+
+
+class CommandMethodWrapper(BaseModel):
+    function: AnyCallable
+    options: List[Option] = field(default_factory=list)
+    middlewares: List[AbstractMiddleware] = field(default_factory=list)
+    middlewares_attributes: Dict[str, Kwargs] = field(default_factory=dict)
+
+    def set_option(self, option: "Option") -> None:
+        self.options.append(option)
+
+    def register_middleware(self, name: str, middleware_kwargs: "Kwargs") -> None:
+        self.middlewares_attributes[name] = middleware_kwargs
+
+    def set_middleware(self, middleware:AbstractMiddleware) -> None:
+        self.middlewares.append(middleware)
+
+        for option in middleware.normalized_options:
+            self.set_option(option)
+
+    def get_options_names(self) -> List[str]:
+        options = []
+        for option in self.options:
+            options.append(option.name)
+
+        return options
+
+    def find_option_by_name(self, name: str) -> Optional["Option"]:
+        """Find an option by its name."""
+        for option in self.options:
+            if option.name == name:
+                return option
+        return None
+
+    def find_option_by_kebab_name(self, kabab_name: str) -> Optional["Option"]:
+        """Find an option by its name."""
+        for option in self.options:
+            if option.kebab_name == kabab_name:
+                return option
+        return None
+
+    def find_option_by_short_name(self, short_name: str) -> Optional["Option"]:
+        """Find an option by its short name."""
+        for option in self.options:
+            if option.short_name == short_name:
+                return option
+        return None

wexample_wex_core/common/command_request.py

@@ -0,0 +1,10 @@
+from typing import TYPE_CHECKING
+
+from wexample_app.common.command_request import CommandRequest as BaseCommandRequest
+
+if TYPE_CHECKING:
+    pass
+
+
+class CommandRequest(BaseCommandRequest):
+    request_id: str

wexample_wex_core/common/execution_context.py

@@ -0,0 +1,36 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from wexample_app.common.abstract_kernel_child import AbstractKernelChild
+from wexample_helpers.const.types import Kwargs
+from wexample_prompt.mixins.with_required_io_manager import WithRequiredIoManager
+from wexample_wex_core.common.command_method_wrapper import CommandMethodWrapper
+from wexample_wex_core.common.command_request import CommandRequest
+from wexample_wex_core.middleware.abstract_middleware import AbstractMiddleware
+
+
+class ExecutionContext(
+    AbstractKernelChild,
+    WithRequiredIoManager,
+    BaseModel,
+):
+    command_wrapper: CommandMethodWrapper
+    function_kwargs: Kwargs = Field(default_factory=dict)
+    middleware: Optional[AbstractMiddleware]
+    request: CommandRequest
+
+    def __init__(self, **kwargs):
+        BaseModel.__init__(self, **kwargs)
+
+        AbstractKernelChild.__init__(
+            self,
+            kernel=self.request.kernel
+        )
+
+        WithRequiredIoManager.__init__(
+            self,
+            io=self.kernel.io
+        )
+
+        self.function_kwargs["context"] = self