orionis 0.80.0__py3-none-any.whl → 0.84.0__py3-none-any.whl

orionis/contracts/container/i_container.py

@@ -3,13 +3,6 @@ from typing import Any, Callable
 
 class IContainer(ABC):
 
-    @abstractmethod
-    def _newRequest(self) -> None:
-        """
-        Reset scoped instances at the beginning of a new request.
-        """
-        pass
-
     @abstractmethod
     def _ensureNotMain(self, concrete: Callable[..., Any]) -> str:
         """
@@ -83,6 +76,13 @@ class IContainer(ABC):
         """
         pass
 
+    @abstractmethod
+    def forgetScopedInstances(self) -> None:
+        """
+        Reset scoped instances at the beginning of a new request.
+        """
+        self._scoped_instances = {}
+
     @abstractmethod
     def bind(self, concrete: Callable[..., Any]) -> str:
         """

orionis/contracts/facades/commands/i_commands_facade.py

@@ -0,0 +1,40 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+class ICommand(ABC):
+    """
+    Interface for defining a CLI command.
+    Command class for managing and executing registered CLI commands.
+
+    This class provides a static method to invoke commands registered in the
+    `CacheCommands` singleton, passing the required signature and any additional
+    parameters.
+
+    Methods
+    -------
+    call(signature: str, vars: dict[str, Any] = {}, *args: Any, **kwargs: Any) -> Any
+        Executes the specified command with the provided arguments.
+    """
+
+    @abstractmethod
+    def call(signature: str, vars: dict[str, Any] = {}, *args: Any, **kwargs: Any) -> Any:
+        """
+        Calls a registered command using the `CLIRunner`.
+
+        Parameters
+        ----------
+        signature : str
+            The command signature (name) to execute.
+        vars : dict[str, Any], optional
+            A dictionary containing named arguments for the command (default is `{}`).
+        *args : Any
+            Additional positional arguments.
+        **kwargs : Any
+            Additional keyword arguments.
+
+        Returns
+        -------
+        Any
+            The output of the executed command.
+        """
+        pass

orionis/contracts/services/commands/i_reactor_commands_service.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+class IReactorCommandsService(ABC):
+    """
+    Interface for the ReactorCommandsService class.
+    Service responsible for executing and managing CLI commands in Orionis.
+
+    This service handles:
+    - Parsing command arguments.
+    - Executing commands and logging their output.
+    - Managing execution timing and error handling.
+    """
+
+    @abstractmethod
+    def execute(self, signature: Optional[str] = None, vars: dict = {}, *args, **kwargs):
+        """
+        Processes and executes a CLI command.
+
+        Determines if the command originates from `sys.argv` or is explicitly called,
+        then executes the appropriate command pipeline, handling success and errors.
+        """
+        pass

orionis/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.80.0"
+VERSION = "0.84.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

orionis/luminate/app.py

@@ -1,79 +1,274 @@
+from typing import Any, Callable
 from orionis.luminate.container.container import Container
 from orionis.luminate.bootstrap.config_bootstrapper import ConfigBootstrapper
 from orionis.luminate.bootstrap.command_bootstrapper import CommandsBootstrapper
 from orionis.luminate.bootstrap.environment_bootstrapper import EnvironmentBootstrapper
 from orionis.luminate.patterns.singleton import SingletonMeta
+from orionis.luminate.providers.commands.reactor_commands_service_provider import ReactorCommandsServiceProvider
 from orionis.luminate.providers.environment.environment__service_provider import EnvironmentServiceProvider
 from orionis.luminate.providers.config.config_service_provider import ConfigServiceProvider
 from orionis.luminate.providers.log.log_service_provider import LogServiceProvider
-from orionis.luminate.facades.log.log_facade import Log
+from orionis.luminate.facades.commands.commands_facade import Command
 
 class Application(metaclass=SingletonMeta):
+    """
+    The core Application class responsible for bootstrapping and managing the application lifecycle.
+
+    This class follows the Singleton pattern to ensure a single instance throughout the application.
+
+    Attributes
+    ----------
+    _config : dict
+        A dictionary to store application configuration.
+    _commands : dict
+        A dictionary to store application commands.
+    _environment_vars : dict
+        A dictionary to store environment variables.
+    container : Container
+        The dependency injection container for the application.
+
+    Methods
+    -------
+    boot()
+        Bootstraps the application by loading environment, configuration, and core providers.
+    _beforeBootstrapProviders()
+        Registers and boots essential providers required before bootstrapping.
+    _bootstraping()
+        Loads user-defined configuration, commands, and environment variables.
+    _afterBootstrapProviders()
+        Registers and boots additional providers after bootstrapping.
+    """
 
     def __init__(self, container: Container):
+        """
+        Initializes the Application instance.
 
-        # Atributos de la clase
-        self._config = {}
-        self._commands = {}
-        self._environment_vars = {}
+        Parameters
+        ----------
+        container : Container
+            The dependency injection container for the application.
+        """
+        # Class attributes
+        self._config: dict = {}
+        self._commands: dict = {}
+        self._environment_vars: dict = {}
+        self._booted: bool = False
 
-        # Inicializar el contenedor de la aplicacion
+        # Initialize the application container
         self.container = container
         self.container.instance(container)
+        self.boot()
+
+    def isBooted(self) -> bool:
+        """
+        Check if the application has been booted.
+
+        Returns
+        -------
+        bool
+            True if the application has been booted, False otherwise.
+        """
+        return self._booted
+
+    def bind(self, concrete: Callable[..., Any]) -> str:
+        """
+        Bind a callable to the container.
+        This method ensures that the provided callable is not the main function,
+        is unique within the container, and is indeed callable. It then creates
+        a unique key for the callable based on its module and name, and stores
+        the callable in the container's bindings.
+        Args:
+            concrete (Callable[..., Any]): The callable to be bound to the container.
+        Returns:
+            str: The unique key generated for the callable.
+        """
+        return self.container.bind(concrete)
+
+    def transient(self, concrete: Callable[..., Any]) -> str:
+        """
+        Registers a transient service in the container.
+        A transient service is created each time it is requested.
+        Args:
+            concrete (Callable[..., Any]): The callable that defines the service.
+        Returns:
+            str: The unique key generated for the callable.
+        """
+        return self.container.transient(concrete)
+
+    def singleton(self, concrete: Callable[..., Any]) -> str:
+        """
+        Registers a callable as a singleton in the container.
+        This method ensures that the provided callable is not the main module,
+        is unique within the container, and is indeed callable. It then registers
+        the callable as a singleton, storing it in the container's singleton registry.
+        Args:
+            concrete (Callable[..., Any]): The callable to be registered as a singleton.
+        Returns:
+            str: The key under which the singleton is registered in the container.
+        """
+        return self.container.singleton(concrete)
+
+    def scoped(self, concrete: Callable[..., Any]) -> str:
+        """
+        Registers a callable as a scoped service.
+        This method ensures that the provided callable is not the main service,
+        is unique, and is indeed callable. It then registers the callable in the
+        scoped services dictionary with relevant metadata.
+        Args:
+            concrete (Callable[..., Any]): The callable to be registered as a scoped service.
+        Returns:
+            str: The key under which the callable is registered in the scoped services dictionary.
+        """
+        return self.container.scoped(concrete)
+
+    def instance(self, instance: Any) -> str:
+        """
+        Registers an instance as a singleton in the container.
+        Args:
+            instance (Any): The instance to be registered as a singleton.
+        Returns:
+            str: The key under which the instance is registered in the container.
+        """
+        return self.container.instance(instance)
+
+    def alias(self, alias: str, concrete: Any) -> None:
+        """
+        Creates an alias for a registered service.
+        Args:
+            alias (str): The alias name to be used for the service.
+            concrete (Any): The actual service instance or callable to be aliased.
+        Raises:
+            OrionisContainerException: If the concrete instance is not a valid object or if the alias is a primitive type.
+        """
+        return self.container.alias(alias, concrete)
+
+    def has(self, obj: Any) -> bool:
+        """
+        Checks if a service is registered in the container.
 
-        # Cargar el servidor de entorno
-        self._loadServiceProviderEnvironment()
+        Parameters
+        ----------
+        obj : Any
+            The service class, instance, or alias to check.
 
-        # Cargar dinamicamente la configurcion de la aplicacion.
+        Returns
+        -------
+        bool
+            True if the service is registered, False otherwise.
+        """
+        return self.container.has(obj)
+
+    def make(self, abstract: Any) -> Any:
+        """
+        Create and return an instance of a registered service.
+
+        Parameters
+        ----------
+        abstract : Any
+            The service class or alias to instantiate.
+
+        Returns
+        -------
+        Any
+            An instance of the requested service.
+
+        Raises
+        ------
+        OrionisContainerException
+            If the service is not found in the container.
+        """
+        return self.container.make(abstract)
+
+    def forgetScopedInstances(self) -> None:
+        """
+        Reset scoped instances at the beginning of a new request.
+        """
+        return self.container.forgetScopedInstances()
+
+    def boot(self):
+        """
+        Bootstraps the application.
+
+        This method is responsible for loading the environment, configuration, and core providers.
+        It ensures the application is ready to handle requests or commands.
+        """
+        # Load environment server
+        self._beforeBootstrapProviders()
+
+        # Dynamically load application configuration
         self._bootstraping()
 
-        # Registrrar los comandos en el contenedor
-        self._registerCommands()
+        # Load core providers
+        self._afterBootstrapProviders()
 
-        # Cargar de provedores core
-        self._loadServiceProviderCore()
+        # Set the booted flag to True
+        self._booted = True
 
-    def _loadServiceProviderEnvironment(self):
+    def _beforeBootstrapProviders(self):
+        """
+        Registers and boots essential providers required before bootstrapping.
 
-        # Cargar el proveedor de entorno
+        This method ensures that environment variables are loaded and available
+        for use during the bootstrapping process.
+        """
+        # Load the environment provider, which is responsible for returning values from the .env file.
+        # This provider is essential as it must be loaded first to resolve environment variables.
+        # Developers can interact with it through the facade "orionis.luminate.facades.environment.environment_facade.Env".
         _environment_provider = EnvironmentServiceProvider(app=self.container)
         _environment_provider.register()
         _environment_provider.boot()
 
     def _bootstraping(self):
+        """
+        Loads user-defined configuration, commands, and environment variables.
 
-        # Cargar la configuracion de la aplicacion
-        config_bootstrapper_key = self.container.singleton(ConfigBootstrapper)
-        config_bootstrapper: ConfigBootstrapper = self.container.make(config_bootstrapper_key)
+        This method initializes the configuration, commands, and environment variables
+        required for the application to function.
+        """
+        # This initializer loads the user-defined configuration from the "config" folder.
+        # It extracts configuration values and stores them as class properties for future use.
+        config_bootstrapper_key = self.singleton(ConfigBootstrapper)
+        config_bootstrapper: ConfigBootstrapper = self.make(config_bootstrapper_key)
         self._config = config_bootstrapper.get()
 
-        # Cargar los comandos propios y definidos por el desarrollador
-        commands_bootstrapper_key = self.container.singleton(CommandsBootstrapper)
-        commands_bootstrapper: CommandsBootstrapper = self.container.make(commands_bootstrapper_key)
+        # This initializer dynamically searches for all user-defined commands in the "commands" folder,
+        # both from the framework core and developer-defined commands.
+        # It stores them in a dictionary and registers them in the container.
+        commands_bootstrapper_key = self.singleton(CommandsBootstrapper)
+        commands_bootstrapper: CommandsBootstrapper = self.make(commands_bootstrapper_key)
         self._commands = commands_bootstrapper.get()
+        for command in self._commands.keys():
+            _key_instance_container = self.bind(self._commands[command].get('concrete'))
+            self.alias(alias=command, concrete=_key_instance_container)
 
-        # Cargar las variables de entorno solo desde el archivo .env (No se carga desde el sistema operativo, por seguridad)
-        environment_bootstrapper_key = self.container.singleton(EnvironmentBootstrapper)
-        environment_bootstrapper: EnvironmentBootstrapper = self.container.make(environment_bootstrapper_key)
+        # Load environment variables and store them as class properties.
+        # This is useful for executing future tasks conditioned on environment values.
+        environment_bootstrapper_key = self.singleton(EnvironmentBootstrapper)
+        environment_bootstrapper: EnvironmentBootstrapper = self.make(environment_bootstrapper_key)
         self._environment_vars = environment_bootstrapper.get()
 
-    def _registerCommands(self):
-
-        # Registrar los comandos en el contenedor
-        for command in self._commands:
-            _key_instance_container = self.container.bind(self._commands[command].get('concrete'))
-            self.container.alias(alias=command, concrete=_key_instance_container)
+    def _afterBootstrapProviders(self):
+        """
+        Registers and boots additional providers after bootstrapping.
 
-    def _loadServiceProviderCore(self):
-
-        # Cargar el proveedor de configuracion
+        This method ensures that configuration and logging providers are loaded
+        and available for use in the application.
+        """
+        # Load the configuration provider, which is responsible for returning configuration values.
+        # Developers can interact with it through the facade "orionis.luminate.facades.config.config_facade.Config".
         _environment_provider = ConfigServiceProvider(app=self.container)
         _environment_provider.register()
         _environment_provider.boot()
 
-        # Cargar el proveedor de log
+
+        # Load the log provider based on the application configuration defined by the developer.
+        # Developers can interact with it through the facade "orionis.luminate.facades.log.log_facade.Log".
         _log_provider = LogServiceProvider(app=self.container)
         _log_provider.register()
         _log_provider.boot()
 
-        Log.info('Application is ready to run')
+        # Load the commands provider, which is responsible for executing and managing CLI commands.
+        # Developers can interact with it through the facade "orionis.luminate.facades.commands.commands_facade.Commands".
+        _commands_provider = ReactorCommandsServiceProvider(app=self.container)
+        _commands_provider.register()
+        _commands_provider.boot()

orionis/luminate/bootstrap/command_bootstrapper.py

@@ -170,4 +170,4 @@ class CommandsBootstrapper(ICommandsBootstrapper):
         """
         if signature is None:
             return self._commands
-        return self._commands[signature]
+        return self._commands[signature] or {}

orionis/luminate/container/container.py

@@ -38,12 +38,6 @@ class Container(IContainer):
                     cls._instance._validate_types = Types()
         return cls._instance
 
-    def _newRequest(self) -> None:
-        """
-        Reset scoped instances at the beginning of a new request.
-        """
-        self._scoped_instances = {}
-
     def _ensureNotMain(self, concrete: Callable[..., Any]) -> str:
         """
         Ensure that a class is not defined in the main script.
@@ -117,6 +111,12 @@ class Container(IContainer):
         if not isinstance(instance, object) or instance.__class__.__module__ in ['builtins', 'abc']:
             raise OrionisContainerValueError(f"The instance '{str(instance)}' must be a valid object.")
 
+    def forgetScopedInstances(self) -> None:
+        """
+        Reset scoped instances at the beginning of a new request.
+        """
+        self._scoped_instances = {}
+
     def bind(self, concrete: Callable[..., Any]) -> str:
         """
         Bind a callable to the container.

orionis/luminate/facades/app.py

@@ -1,6 +1,6 @@
 from typing import Any
 from orionis.luminate.container.container import Container
-from orionis.luminate.container.exception import OrionisContainerException, OrionisContainerTypeError
+from orionis.luminate.container.exception import OrionisContainerTypeError
 
 def app(concrete: Any = None):
     """
@@ -33,8 +33,6 @@ def app(concrete: Any = None):
 
     # If concrete is provided (not None), attempt to resolve it from the container
     if concrete is not None:
-        if not isinstance(concrete, type):
-            raise OrionisContainerTypeError(f"The provided concrete must be a class or service, got {type(concrete)}.")
         return container.make(concrete)
 
     # If concrete is None, return the container instance

orionis/luminate/facades/commands/commands_facade.py

@@ -0,0 +1,42 @@
+from typing import Any
+from orionis.contracts.facades.commands.i_commands_facade import ICommand
+from orionis.luminate.facades.app import app
+from orionis.luminate.services.commands.reactor_commands_service import ReactorCommandsService
+
+class Command(ICommand):
+    """
+    Command class for managing and executing registered CLI commands.
+
+    This class provides a static method to invoke commands registered in the
+    `CacheCommands` singleton, passing the required signature and any additional
+    parameters.
+
+    Methods
+    -------
+    call(signature: str, vars: dict[str, Any] = {}, *args: Any, **kwargs: Any) -> Any
+        Executes the specified command with the provided arguments.
+    """
+
+    @staticmethod
+    def call(signature: str, vars: dict[str, Any] = {}, *args: Any, **kwargs: Any) -> Any:
+        """
+        Calls a registered command using the `CLIRunner`.
+
+        Parameters
+        ----------
+        signature : str
+            The command signature (name) to execute.
+        vars : dict[str, Any], optional
+            A dictionary containing named arguments for the command (default is `{}`).
+        *args : Any
+            Additional positional arguments.
+        **kwargs : Any
+            Additional keyword arguments.
+
+        Returns
+        -------
+        Any
+            The output of the executed command.
+        """
+        _commands_provider : ReactorCommandsService = app(ReactorCommandsService)
+        return _commands_provider.execute(signature, vars, *args, **kwargs)

orionis/luminate/providers/commands/reactor_commands_service_provider.py

@@ -0,0 +1,19 @@
+from orionis.luminate.providers.service_provider import ServiceProvider
+from orionis.luminate.services.commands.reactor_commands_service import ReactorCommandsService
+
+class ReactorCommandsServiceProvider(ServiceProvider):
+
+    def register(self) -> None:
+        """
+        Registers services or bindings into the given container.
+        """
+        self._container_id = self.app.singleton(ReactorCommandsService)
+
+    def boot(self,) -> None:
+        """
+        Boot the service provider.
+
+        This method is intended to be overridden by subclasses to perform
+        any necessary bootstrapping or initialization tasks.
+        """
+        self.app.make(self._container_id)

orionis/luminate/services/commands/reactor_commands_service.py

@@ -0,0 +1,155 @@
+import time
+from typing import Any, Dict, Optional
+from orionis.contracts.services.commands.i_reactor_commands_service import IReactorCommandsService
+from orionis.luminate.bootstrap.command_bootstrapper import CommandsBootstrapper
+from orionis.luminate.console.base.command import BaseCommand
+from orionis.luminate.console.command_filter import CommandFilter
+from orionis.luminate.console.exceptions.cli_exception import CLIOrionisException
+from orionis.luminate.console.output.console import Console
+from orionis.luminate.console.output.executor import Executor
+from orionis.luminate.console.parser import Parser
+from orionis.luminate.facades.app import app
+from orionis.luminate.facades.log.log_facade import Log
+
+class ReactorCommandsService(IReactorCommandsService):
+    """
+    Service responsible for executing and managing CLI commands in Orionis.
+
+    This service handles:
+    - Parsing command arguments.
+    - Executing commands and logging their output.
+    - Managing execution timing and error handling.
+    """
+
+    def __init__(
+        self,
+        commands_bootstrapper: CommandsBootstrapper,
+        command_filter: CommandFilter,
+        log: Log,
+        executor: Executor,
+        console: Console,
+    ):
+        """
+        Initializes the ReactorCommandsService instance.
+
+        Assigns provided services to internal attributes for later use in command
+        execution, filtering, and logging.
+        """
+        self.commands_bootstrapper = commands_bootstrapper
+        self.command_filter = command_filter
+        self.log = log
+        self.console_executor = executor
+        self.console_output = console
+
+    def _parse_arguments(
+        self, arguments, vars: Optional[Dict[str, Any]] = None, *args, **kwargs
+    ):
+        """
+        Parses command-line arguments using the Orionis argument parser.
+
+        Utilizes an internal parser to convert raw arguments into structured data.
+        Handles exceptions to ensure errors are properly raised and managed.
+        """
+        try:
+            arg_parser = Parser(vars=vars or {}, args=args, kwargs=kwargs)
+            arg_parser.setArguments(arguments=arguments)
+            arg_parser.recognize()
+            return arg_parser.get()
+        except Exception as e:
+            raise ValueError(f"Error parsing arguments: {e}")
+
+    def _extract_arguments(self, args_dict:Any):
+        """
+        Extracts the arguments from the provided dictionary.
+
+        Parameters
+        ----------
+        args_dict : Any
+            A dictionary containing the arguments to extract.
+        """
+        try:
+            return vars(args_dict)
+        except Exception as e:
+            raise ValueError(f"Error parsing arguments: {e}")
+
+    def _call(self, signature: str, args_dict: Any) -> Any:
+        """
+        Executes the specified command with the provided arguments.
+
+        Parameters
+        ----------
+        signature : str
+            The command signature (name) to execute.
+        args_dict : Any
+            A dictionary containing named arguments for the command.
+        """
+
+        command_instance: BaseCommand = app(signature)
+        command_instance.setArgs(args_dict)
+        return command_instance.handle(**self._extract_arguments(args_dict))
+
+    def execute(self, signature: Optional[str] = None, vars: dict = {}, *args, **kwargs):
+        """
+        Processes and executes a CLI command.
+
+        Determines if the command originates from `sys.argv` or is explicitly called,
+        then executes the appropriate command pipeline, handling success and errors.
+        """
+        try:
+
+            # Determine if command is excluded from running
+            exclude_running = self.command_filter.isExcluded(signature)
+            sys_argv = signature is None
+
+            # Start timing execution
+            start_time = time.perf_counter()
+
+            # Extract signature and arguments from command-line input
+            if sys_argv:
+                if not args or len(args[0]) <= 1:
+                    raise CLIOrionisException("No command signature specified. Please provide a valid command to execute.")
+                args_list = args[0]
+                signature, *args = args_list[1:]
+
+            # Log command execution
+            self.log.info(f"Running command: {signature}")
+
+            # Notify console
+            if not exclude_running:
+                self.console_executor.running(program=signature)
+
+            # Retrieve command from bootstrapper
+            command = self.commands_bootstrapper.get(signature)
+
+            # Parse command arguments dynamically based on execution context
+            args_dict = self._parse_arguments(command.get('arguments', []), vars, *args, **kwargs)
+
+            # Exception handling for command execution
+            output = self._call(signature, args_dict)
+
+            # Log successful command execution
+            self.log.success(f"Command executed successfully: {signature}")
+
+            # Finalize execution and report elapsed time
+            if not exclude_running:
+                elapsed_time = round(time.perf_counter() - start_time, 2)
+                self.console_executor.done(program=signature, time=f"{elapsed_time}s")
+
+            # Return command output
+            return output
+
+        except ValueError as e:
+            # Handle parsing errors
+            self.log.error(f"Command failed: {signature or 'Unknown'}, Value Error: {e}")
+            if not exclude_running:
+                self.console_output.error(message=f"Value Error: {e}")
+                elapsed_time = round(time.perf_counter() - start_time, 2)
+                self.console_executor.fail(program=signature or "Unknown", time=f"{elapsed_time}s")
+
+        except Exception as e:
+            # Handle unexpected execution errors
+            self.log.error(f"Command failed: {signature or 'Unknown'}, Execution Error: {e}")
+            if not exclude_running:
+                self.console_output.error(message=f"Execution Error: {e}")
+                elapsed_time = round(time.perf_counter() - start_time, 2)
+                self.console_executor.fail(program=signature or "Unknown", time=f"{elapsed_time}s")

{orionis-0.80.0.dist-info → orionis-0.84.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: orionis
-Version: 0.80.0
+Version: 0.84.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.80.0.dist-info → orionis-0.84.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 orionis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/cli_manager.py,sha256=0bM-hABXJSoPGuvEgnqeaj9qcLP8VjTQ3z9Mb0TSEUI,1381
-orionis/framework.py,sha256=I1IFU4kjM_IdHGzyYiW4hp7PtIDRKZUsxIFUhdGsE4k,1386
+orionis/framework.py,sha256=weWLOElszFX_SP5tDJ7CW2cmc0DET5KgviqJDFMIleY,1386
 orionis/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/contracts/bootstrap/i_command_bootstrapper.py,sha256=cfpYWSlNhOY1q_C9o0H7F381OoM0Oh0qaeqP-c85nzk,2457
 orionis/contracts/bootstrap/i_config_bootstrapper.py,sha256=d2TXT74H2fCBbzWgrt9-ZG11S_H_YPQOEcJoIOrsgb0,4462
@@ -20,9 +20,11 @@ orionis/contracts/console/output/i_executor.py,sha256=MGMTTPSwF8dgCjHD3A4CKtYDaC
 orionis/contracts/console/output/i_progress_bar.py,sha256=sOkQzQsliFemqZHMyzs4fWhNJfXDTk5KH3aExReetSE,1760
 orionis/contracts/console/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/contracts/console/tasks/i_schedule.py,sha256=_dsR0gCvJ7_67lwPUAzBwQFHNvWM6jVjcg1EdPqDIIo,10117
-orionis/contracts/container/i_container.py,sha256=c_QRQHXGIujiDnYXyt--3J2LKXngVtoB3O-qchPmFDQ,6899
+orionis/contracts/container/i_container.py,sha256=MSJkVNawcovxSUAG-nrEctMYLT8H0OJq15pL5UwJeqA,6932
 orionis/contracts/container/i_types.py,sha256=GCH7x3PjpXKPET3l84GcXbcM8cpne8AGrmTw-uFaT24,526
 orionis/contracts/facades/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/contracts/facades/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/contracts/facades/commands/i_commands_facade.py,sha256=LpSfZb3lTmhgMx0H42NmFbKLvcOqSDIbpQrkQpF9RPY,1274
 orionis/contracts/facades/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/contracts/facades/config/i_config_facade.py,sha256=Yzc0mB4W9XF8cZTdTO78AKUiyGaiShl1k8nJiecvKTc,970
 orionis/contracts/facades/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -40,6 +42,8 @@ orionis/contracts/installer/i_installer_setup.py,sha256=enXOusaAJVWamTpH9FjXpJf-
 orionis/contracts/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/contracts/providers/i_service_provider.py,sha256=zoBAsGE-KrNfCsF3u876oxoa518zMuBD9npRK7BixUs,791
 orionis/contracts/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/contracts/services/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/contracts/services/commands/i_reactor_commands_service.py,sha256=msIOfwOYASFNuS4shhwsnukPH5_XnuxNBHW9f6q-Lqo,795
 orionis/contracts/services/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/contracts/services/config/i_config_service.py,sha256=TdlEEsd8jvzBGozwaZtQ9KYHisY4ACL-VUOtydidHeE,989
 orionis/contracts/services/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -56,10 +60,10 @@ orionis/installer/installer_manager.py,sha256=Hb6T0bmSl39T30maY-nUWkrLhG77JdrKe4
 orionis/installer/installer_output.py,sha256=LeKxzuXpnHOKbKpUtx3tMGkCi2bGcPV1VNnfBxwfxUU,7161
 orionis/installer/installer_setup.py,sha256=c2HtVklSa-2_-YVonc7fwtoK-RTDqBS2Ybvbekgfqtc,6970
 orionis/luminate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/luminate/app.py,sha256=-s56Fvnsd5KZxwLZI2dNDI3ZuHcNpZU5Wq0XCzT1gJE,3484
+orionis/luminate/app.py,sha256=GZccClZ3kvi9o5qLmBbKMLSZDPP9h0iiM5QlbTwonYw,11702
 orionis/luminate/app_context.py,sha256=XREVkOHU6aP8UB2daA2QbFcOCB8HRmcGXjVbrlW1AHQ,1827
 orionis/luminate/bootstrap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/luminate/bootstrap/command_bootstrapper.py,sha256=OU0hDMtG1xqVbvCneq4C5mlOUu9OmfkxqbvGH59QsUw,6919
+orionis/luminate/bootstrap/command_bootstrapper.py,sha256=JJkWWOS2R2Zg7mC7-VMtZ0wAgxlegMkdnqudpbAjxwk,6925
 orionis/luminate/bootstrap/config_bootstrapper.py,sha256=Gw83UtPAOggwzqmz062JfJcpIfmZvmIQyZJfgVFiIcQ,7474
 orionis/luminate/bootstrap/environment_bootstrapper.py,sha256=GTZ-mBumoNlxYcqsQksw4XyH3TRfPkWAU62mB3wFKLk,2777
 orionis/luminate/bootstrap/exception_bootstrapper.py,sha256=wDKfEW295c7-bavr7YUHK2CLYcTSZgjT9ZRSBne6GOE,1356
@@ -79,7 +83,6 @@ orionis/luminate/console/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 orionis/luminate/console/command_filter.py,sha256=os5BxR6Rcmihrv34pD-fFTkRms_nZzCIrV7vr4RNuIU,1322
 orionis/luminate/console/kernel.py,sha256=uh3IeR3qI3X0esyw9dxE0LzQ6ueSd_2suMijtQn3HWM,939
 orionis/luminate/console/parser.py,sha256=qif0eR54bwaVOiugVQh-NUks35XD2VofWbJlRpfR8lg,5579
-orionis/luminate/console/runner.py,sha256=7oLEZpJ4lPf4YkP9bj7wvgT9GJ2gUJv81JKXEdD0gA0,4820
 orionis/luminate/console/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/console/base/command.py,sha256=YGHd5xVYILcNhQumi74IRnzvagvjufEO2Bx1CwHRToY,12544
 orionis/luminate/console/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -97,11 +100,13 @@ orionis/luminate/console/output/progress_bar.py,sha256=ssi8Drryr-shl7OxweTgGOhvR
 orionis/luminate/console/output/styles.py,sha256=2e1_FJdNpKaVqmdlCx-udzTleH_6uEFE9_TjH7T1ZUk,3696
 orionis/luminate/console/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/console/tasks/scheduler.py,sha256=zt4p2VGUYGGrG2-E-MxyheKjBqGDJB2c0irULDsBgIw,22678
-orionis/luminate/container/container.py,sha256=RlGsAgUqSZa2bAvaxCtD3babXNUse7f3t9dDjz1scSg,16419
+orionis/luminate/container/container.py,sha256=Ruyhs5OAiO6nMFhGDm7TNQD4qqFO0lh_phqUFDit_bE,16429
 orionis/luminate/container/exception.py,sha256=ap1SqYEjQEEHXJJTNmL7V1jrmRjgT5_7geZ95MYkhMA,1691
 orionis/luminate/container/types.py,sha256=BDcXN0__voRNHZ5Gr5dF0sWIYAQyNk4TxAwILBWyDAA,1735
 orionis/luminate/facades/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/luminate/facades/app.py,sha256=20ai-4ggQSBLNz2zpaESKsJ7NhnTQ-XvnRoT_WGNcxk,1486
+orionis/luminate/facades/app.py,sha256=DHwCdhfU-Mfj0gPX5nwXR_cgnkvg6agMP2WBa-L0JE8,1294
+orionis/luminate/facades/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/luminate/facades/commands/commands_facade.py,sha256=xy-5sW5_fDXhS2y0c0CCbBOfrOR0mJQLVTwBe3J8WTk,1561
 orionis/luminate/facades/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/facades/config/config_facade.py,sha256=xpyVdH_-CeOvtMuf-Pjl9SFZWOflXzx9lyDy_fYOmxU,1353
 orionis/luminate/facades/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -114,10 +119,10 @@ orionis/luminate/facades/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 orionis/luminate/facades/tests/tests_facade.py,sha256=eH_fyXjzEVw8aqEwxAgSujFUItz2woau6hc2Mf4VlkE,1660
 orionis/luminate/patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/patterns/singleton.py,sha256=b3U0nubKSQWyal5wTXADVPtOztkaTk-M8Zwy-bje1L0,1425
-orionis/luminate/pipelines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/luminate/pipelines/cli_pipeline.py,sha256=xpdwxArZrYqaeo4h375RQwY329V14S8DJC9z1w_Ar1s,4218
 orionis/luminate/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/providers/service_provider.py,sha256=Ave9V10KPVCI6bt3HwJ51322P-_RnQuHXkC-ltlAOOA,1537
+orionis/luminate/providers/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/luminate/providers/commands/reactor_commands_service_provider.py,sha256=3HX3wwPCH_Y9OsoTyfC4_LrNlPW_-UaffDcz3Wehuvk,701
 orionis/luminate/providers/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/providers/config/config_service_provider.py,sha256=NLKB3Vcu4kqZ0WyeImMG3CsclSu_P4aWs6yXitcv474,659
 orionis/luminate/providers/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -125,6 +130,8 @@ orionis/luminate/providers/environment/environment__service_provider.py,sha256=L
 orionis/luminate/providers/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/providers/log/log_service_provider.py,sha256=tcWDEI-fubi1mWSS-IKiRReuc0pRMHpxvbvuDgs2Uy0,654
 orionis/luminate/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/luminate/services/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/luminate/services/commands/reactor_commands_service.py,sha256=UgWBPsApDpZPJOqgMa0wd0v9H9ACOYtf8fOjiD3KpJw,6347
 orionis/luminate/services/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/services/config/config_service.py,sha256=sVqX3UBxZA5whjiVFgfo5fzAb8QxD0NT0OYYlgZUK0g,2223
 orionis/luminate/services/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -153,9 +160,9 @@ tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/tools/class_example.py,sha256=dIPD997Y15n6WmKhWoOFSwEldRm9MdOHTZZ49eF1p3c,1056
 tests/tools/test_reflection.py,sha256=bhLQ7VGVod4B8sv-rW9AjnOumvaBVsoxieA3sdoM2yM,5244
-orionis-0.80.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
-orionis-0.80.0.dist-info/METADATA,sha256=OG3pCfV-jo1_4JcCHxnqCVbbCzccudkBjAr-FqoOmyQ,2978
-orionis-0.80.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-orionis-0.80.0.dist-info/entry_points.txt,sha256=eef1_CVewfokKjrGBynXa06KabSJYo7LlDKKIKvs1cM,53
-orionis-0.80.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.80.0.dist-info/RECORD,,
+orionis-0.84.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.84.0.dist-info/METADATA,sha256=fpTYuip02QzdiMKwz0_XgzwBrcLt-KiHapU1vtRpmGE,2978
+orionis-0.84.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+orionis-0.84.0.dist-info/entry_points.txt,sha256=eef1_CVewfokKjrGBynXa06KabSJYo7LlDKKIKvs1cM,53
+orionis-0.84.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.84.0.dist-info/RECORD,,

orionis/luminate/console/runner.py

@@ -1,127 +0,0 @@
-# import time
-# from orionis.luminate.facades.log import Log
-# from orionis.luminate.console.output.console import Console
-# from orionis.luminate.console.output.executor import Executor
-# from orionis.luminate.pipelines.cli_pipeline import CLIPipeline
-# from orionis.luminate.console.command_filter import CommandFilter
-# from orionis.luminate.contracts.console.runner_interface import ICLIRunner
-
-class CLIRunner:
-    pass
-    # """
-    # CLIRunner manages the execution of CLI commands in Orionis.
-
-    # This class:
-    # - Parses command-line arguments or function parameters.
-    # - Executes commands through the `CLIPipeline`.
-    # - Logs execution status and errors.
-
-    # Methods
-    # -------
-    # handle(signature: str = None, vars: dict = {}, *args, **kwargs)
-    #     Processes and executes a CLI command based on provided arguments.
-    # """
-
-    # @staticmethod
-    # def handle(signature: str = None, vars: dict = {}, *args, **kwargs):
-    #     """
-    #     Processes and executes a CLI command.
-
-    #     This method:
-    #     - Determines whether the command is invoked from `sys.argv` or as a function.
-    #     - Extracts the command signature and arguments.
-    #     - Executes the command pipeline.
-    #     - Logs execution status and handles errors.
-
-    #     Parameters
-    #     ----------
-    #     signature : str, optional
-    #         The command signature (default is None, meaning it is extracted from `sys.argv`).
-    #     vars : dict, optional
-    #         Named arguments for the command (default is an empty dictionary).
-    #     *args
-    #         Additional arguments for the command.
-    #     **kwargs
-    #         Additional keyword arguments for the command.
-
-    #     Returns
-    #     -------
-    #     Any
-    #         The output of the executed command.
-
-    #     Raises
-    #     ------
-    #     ValueError
-    #         If no command signature is provided.
-    #     Exception
-    #         If an unexpected error occurs during execution.
-    #     """
-
-    #     try:
-
-    #         # Exclude commands from Printing
-    #         exclude_running = CommandFilter.isExcluded(signature)
-
-    #         # Determine if command is being executed from sys.argv
-    #         sys_argv = signature is None
-
-    #         # Start execution timer
-    #         start_time = time.perf_counter()
-
-    #         # Handle command signature extraction from sys.argv
-    #         if sys_argv:
-
-    #             # Extract command signature and arguments from sys.argv
-    #             if not args or len(args[0]) <= 1:
-    #                 raise ValueError("No command signature specified.")
-
-    #             # Extract command signature and arguments
-    #             args_list = args[0]
-    #             signature, *args = args_list[1:]
-
-    #         # Log command execution start
-    #         Log.info(f"Running command: {signature}")
-
-    #         if not exclude_running:
-    #             Executor.running(program=signature)
-
-    #         # Initialize command pipeline
-    #         pipeline = CLIPipeline().getCommand(signature)
-
-    #         # Parse arguments based on invocation type
-    #         if sys_argv:
-    #             pipeline.parseArguments(*args)
-    #         else:
-    #             pipeline.parseArguments(vars, *args, **kwargs)
-
-    #         # Execute the command
-    #         output = pipeline.execute()
-
-    #         # Log successful execution
-    #         Log.success(f"Command executed successfully: {signature}")
-
-    #         # Calculate execution time
-    #         if not exclude_running:
-    #             elapsed_time = round(time.perf_counter() - start_time, 2)
-    #             Executor.done(program=signature, time=f"{elapsed_time}s")
-
-    #         # Return command output
-    #         return output
-
-    #     except ValueError as e:
-
-    #         # Handle missing or invalid command signature
-    #         Log.error(f"Command failed: {signature or 'Unknown'}, Value Error: {e}")
-    #         if not exclude_running:
-    #             Console.error(message=f"Value Error: {e}")
-    #             elapsed_time = round(time.perf_counter() - start_time, 2)
-    #             Executor.fail(program=signature or "Unknown", time=f"{elapsed_time}s")
-
-    #     except Exception as e:
-
-    #         # Handle unexpected errors
-    #         Log.error(f"Command failed: {signature or 'Unknown'}, Execution Error: {e}")
-    #         if not exclude_running:
-    #             Console.error(message=f"Execution Error: {e}")
-    #             elapsed_time = round(time.perf_counter() - start_time, 2)
-    #             Executor.fail(program=signature or "Unknown", time=f"{elapsed_time}s")

orionis/luminate/pipelines/cli_pipeline.py

@@ -1,122 +0,0 @@
-# import argparse
-# from typing import Dict, Any, Optional
-# from orionis.luminate.app_context import AppContext
-# from orionis.luminate.console.parser import Parser
-# from orionis.luminate.console.cache import CLICache
-# from orionis.luminate.console.base.command import BaseCommand
-# from orionis.luminate.contracts.pipelines.cli_pipeline_interface import ICLIPipeline
-
-class CLIPipeline:
-    pass
-    # """
-    # Handles the retrieval, parsing, and execution of CLI commands within the Orionis framework.
-
-    # This class is responsible for:
-    # - Retrieving command metadata from cache.
-    # - Parsing command-line arguments dynamically.
-    # - Executing the corresponding command with parsed arguments.
-
-    # Attributes
-    # ----------
-    # _command : dict
-    #     Stores the command's metadata, including its instance and expected arguments.
-    # _parsed_arguments : argparse.Namespace
-    #     Holds parsed arguments after processing user input.
-    # """
-
-    # def __init__(self):
-    #     """
-    #     Initializes the CLIPipeline instance with an empty command cache
-    #     and a default argument namespace.
-    #     """
-    #     self._command: Dict[str, Any] = {}
-    #     self._parsed_arguments: argparse.Namespace = argparse.Namespace()
-
-    # def getCommand(self, signature: str) -> "CLIPipeline":
-    #     """
-    #     Retrieves a command from the cache based on its signature.
-
-    #     Parameters
-    #     ----------
-    #     signature : str
-    #         The unique identifier of the command.
-
-    #     Returns
-    #     -------
-    #     CLIPipeline
-    #         The current instance of CLIPipeline for method chaining.
-
-    #     Raises
-    #     ------
-    #     ValueError
-    #         If the command signature is not found in the cache.
-    #     """
-    #     with AppContext() as app:
-    #         config_service : BaseCommand = app.container.run_command("config")
-    #         config_service.
-            
-    #     try:
-    #         cache = CLICache().getCommands()
-    #         self._command = cache.get(signature)
-    #         return self
-    #     except KeyError as e:
-    #         raise ValueError(e)
-
-    # def parseArguments(self, vars: Optional[Dict[str, Any]] = None, *args, **kwargs) -> "CLIPipeline":
-    #     """
-    #     Parses command-line arguments using the Orionis argument parser.
-
-    #     Parameters
-    #     ----------
-    #     vars : dict, optional
-    #         A dictionary of predefined variables to be included in parsing.
-    #     *args
-    #         Positional arguments for the parser.
-    #     **kwargs
-    #         Keyword arguments for the parser.
-
-    #     Returns
-    #     -------
-    #     CLIPipeline
-    #         The current instance of CLIPipeline for method chaining.
-
-    #     Raises
-    #     ------
-    #     ValueError
-    #         If an error occurs during argument parsing.
-    #     """
-    #     try:
-    #         arguments = self._command.get("arguments")
-    #         if arguments:
-    #             arg_parser = Parser(vars=vars or {}, args=args, kwargs=kwargs)
-    #             arg_parser.setArguments(arguments=arguments)
-    #             arg_parser.recognize()
-    #             self._parsed_arguments = arg_parser.get()
-
-    #         return self
-
-    #     except Exception as e:
-    #         raise ValueError(f"Error parsing arguments: {e}")
-
-    # def execute(self) -> Any:
-    #     """
-    #     Executes the retrieved command using parsed arguments.
-
-    #     This method:
-    #     - Instantiates the command class.
-    #     - Calls the `handle()` method, passing the parsed arguments.
-
-    #     Returns
-    #     -------
-    #     Any
-    #         The output of the command execution.
-
-    #     Raises
-    #     ------
-    #     ValueError
-    #         If the command instance is invalid.
-    #     """
-    #     command_class = self._command.get("instance")
-    #     command_instance: BaseCommand = command_class()
-    #     command_instance.setArgs(self._parsed_arguments)
-    #     return command_instance.handle(**vars(self._parsed_arguments))