orionis 0.448.0__py3-none-any.whl → 0.449.0__py3-none-any.whl

orionis/console/output/contracts/executor.py

@@ -0,0 +1,93 @@
+from abc import ABC, abstractmethod
+
+class IExecutor(ABC):
+
+    @abstractmethod
+    def running(self, program: str, time: str = ''):
+        """
+        Logs the execution of a program in a "RUNNING" state with console output formatting.
+
+        This method outputs a formatted console message indicating that a program or process
+        is currently running. It uses ANSI color coding to highlight the running state with
+        a warning color (typically yellow/orange) to draw attention to active processes.
+        The output includes timestamp, program name, optional execution time, and colored
+        state indicator in a structured format.
+
+        Parameters
+        ----------
+        program : str
+            The name of the program or process that is currently being executed.
+            This will be displayed in the console output to identify which process
+            is in the running state.
+        time : str, optional
+            The current execution time duration with appropriate units (e.g., '30s', '2m 15s').
+            If not provided, defaults to an empty string and no time information will be
+            displayed in the output. Default is ''.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It prints the formatted running state
+            message directly to the console output via the private __ansiOutput method.
+        """
+        pass
+
+    @abstractmethod
+    def done(self, program: str, time: str = ''):
+        """
+        Logs the execution of a program in a "DONE" state with console output formatting.
+
+        This method outputs a formatted console message indicating that a program or process
+        has completed successfully. It uses ANSI color coding to highlight the completion state
+        with a success color (typically green) to indicate successful execution. The output
+        includes timestamp, program name, optional execution time, and colored state indicator
+        in a structured format consistent with other execution state methods.
+
+        Parameters
+        ----------
+        program : str
+            The name of the program or process that has completed execution.
+            This will be displayed in the console output to identify which process
+            has finished successfully.
+        time : str, optional
+            The total execution time duration with appropriate units (e.g., '30s', '2m 15s').
+            If not provided, defaults to an empty string and no time information will be
+            displayed in the output. Default is ''.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It prints the formatted completion state
+            message directly to the console output via the private __ansiOutput method.
+        """
+        pass
+
+    @abstractmethod
+    def fail(self, program: str, time: str = ''):
+        """
+        Logs the execution of a program in a "FAIL" state with console output formatting.
+
+        This method outputs a formatted console message indicating that a program or process
+        has failed during execution. It uses ANSI color coding to highlight the failure state
+        with an error color (typically red) to clearly indicate unsuccessful execution. The output
+        includes timestamp, program name, optional execution time, and colored state indicator
+        in a structured format consistent with other execution state methods.
+
+        Parameters
+        ----------
+        program : str
+            The name of the program or process that has failed during execution.
+            This will be displayed in the console output to identify which process
+            encountered an error or failure.
+        time : str, optional
+            The execution time duration before failure with appropriate units (e.g., '30s', '2m 15s').
+            If not provided, defaults to an empty string and no time information will be
+            displayed in the output. Default is ''.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It prints the formatted failure state
+            message directly to the console output via the private __ansiOutput method.
+        """
+        pass

orionis/console/output/executor.py

@@ -0,0 +1,153 @@
+from datetime import datetime
+from orionis.console.output.contracts.executor import IExecutor
+from orionis.console.output.enums.styles import ANSIColors
+
+class Executor(IExecutor):
+
+    def __ansiOutput(self, program: str, state: str, state_color: str, time: str = ''):
+        """
+        Outputs a formatted console message with timestamp, program name, and execution state using ANSI colors.
+
+        This private method creates a structured log line that displays execution information
+        in a consistent format. The output includes a timestamp, program name, dotted line
+        separator, optional execution time, and colored state indicator.
+
+        Parameters
+        ----------
+        program : str
+            The name of the program or process being executed.
+        state : str
+            The current execution state (e.g., 'RUNNING', 'DONE', 'FAIL').
+        state_color : str
+            The ANSI color code used to colorize the state text.
+        time : str, optional
+            The execution time duration with units (e.g., '30s', '2m 15s').
+            Default is an empty string if no time information is available.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It prints the formatted message
+            directly to the console output.
+        """
+        # Define the total width for the formatted output line
+        width = 60
+
+        # Calculate the length of state and time strings for spacing calculations
+        len_state = len(state)
+        len_time = len(time)
+
+        # Create a dotted line that fills the remaining space between program name and state/time
+        line = '.' * (width - (len(program) + len_state + len_time))
+
+        # Format the timestamp with muted color and current date/time
+        timestamp = f"{ANSIColors.TEXT_MUTED.value}{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}{ANSIColors.DEFAULT.value}"
+
+        # Keep program name without additional formatting
+        program_formatted = f"{program}"
+
+        # Format time with muted color if provided, otherwise use empty string
+        time_formatted = f"{ANSIColors.TEXT_MUTED.value}{time}{ANSIColors.DEFAULT.value}" if time else ""
+
+        # Format state with the specified color and reset to default
+        state_formatted = f"{state_color}{state}{ANSIColors.DEFAULT.value}"
+
+        # Add line breaks for RUNNING state at start, for other states at end
+        start = "\n\r" if state == 'RUNNING' else ''
+        end = "\n\r" if state != 'RUNNING' else ''
+
+        # Print the complete formatted message to console
+        print(f"{start}{timestamp} | {program_formatted} {line} {time_formatted} {state_formatted}{end}")
+
+    def running(self, program: str, time: str = ''):
+        """
+        Logs the execution of a program in a "RUNNING" state with console output formatting.
+
+        This method outputs a formatted console message indicating that a program or process
+        is currently running. It uses ANSI color coding to highlight the running state with
+        a warning color (typically yellow/orange) to draw attention to active processes.
+        The output includes timestamp, program name, optional execution time, and colored
+        state indicator in a structured format.
+
+        Parameters
+        ----------
+        program : str
+            The name of the program or process that is currently being executed.
+            This will be displayed in the console output to identify which process
+            is in the running state.
+        time : str, optional
+            The current execution time duration with appropriate units (e.g., '30s', '2m 15s').
+            If not provided, defaults to an empty string and no time information will be
+            displayed in the output. Default is ''.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It prints the formatted running state
+            message directly to the console output via the private __ansiOutput method.
+        """
+
+        # Call the private ANSI output method with RUNNING state and warning color formatting
+        self.__ansiOutput(program, "RUNNING", ANSIColors.TEXT_BOLD_WARNING.value, time)
+
+    def done(self, program: str, time: str = ''):
+        """
+        Logs the execution of a program in a "DONE" state with console output formatting.
+
+        This method outputs a formatted console message indicating that a program or process
+        has completed successfully. It uses ANSI color coding to highlight the completion state
+        with a success color (typically green) to indicate successful execution. The output
+        includes timestamp, program name, optional execution time, and colored state indicator
+        in a structured format consistent with other execution state methods.
+
+        Parameters
+        ----------
+        program : str
+            The name of the program or process that has completed execution.
+            This will be displayed in the console output to identify which process
+            has finished successfully.
+        time : str, optional
+            The total execution time duration with appropriate units (e.g., '30s', '2m 15s').
+            If not provided, defaults to an empty string and no time information will be
+            displayed in the output. Default is ''.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It prints the formatted completion state
+            message directly to the console output via the private __ansiOutput method.
+        """
+
+        # Call the private ANSI output method with DONE state and success color formatting
+        self.__ansiOutput(program, "DONE", ANSIColors.TEXT_BOLD_SUCCESS.value, time)
+
+    def fail(self, program: str, time: str = ''):
+        """
+        Logs the execution of a program in a "FAIL" state with console output formatting.
+
+        This method outputs a formatted console message indicating that a program or process
+        has failed during execution. It uses ANSI color coding to highlight the failure state
+        with an error color (typically red) to clearly indicate unsuccessful execution. The output
+        includes timestamp, program name, optional execution time, and colored state indicator
+        in a structured format consistent with other execution state methods.
+
+        Parameters
+        ----------
+        program : str
+            The name of the program or process that has failed during execution.
+            This will be displayed in the console output to identify which process
+            encountered an error or failure.
+        time : str, optional
+            The execution time duration before failure with appropriate units (e.g., '30s', '2m 15s').
+            If not provided, defaults to an empty string and no time information will be
+            displayed in the output. Default is ''.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It prints the formatted failure state
+            message directly to the console output via the private __ansiOutput method.
+        """
+
+        # Call the private ANSI output method with FAIL state and error color formatting
+        self.__ansiOutput(program, "FAIL", ANSIColors.TEXT_BOLD_ERROR.value, time)

orionis/foundation/application.py

@@ -177,6 +177,8 @@ class Application(Container, IApplication):
         from orionis.foundation.providers.progress_bar_provider import ProgressBarProvider
         from orionis.foundation.providers.workers_provider import WorkersProvider
         from orionis.foundation.providers.testing_provider import TestingProvider
+        from orionis.foundation.providers.inspirational_provider import InspirationalProvider
+        from orionis.foundation.providers.executor_provider import ConsoleExecuteProvider
 
         # Core framework providers
         core_providers = [
@@ -185,7 +187,9 @@ class Application(Container, IApplication):
             ProgressBarProvider,
             WorkersProvider,
             LoggerProvider,
-            TestingProvider
+            TestingProvider,
+            InspirationalProvider,
+            ConsoleExecuteProvider
         ]
 
         # Register each core provider
@@ -1927,7 +1931,7 @@ class Application(Container, IApplication):
             self.__loadFrameworksKernel()
 
             # Retrieve logger and console instances from the container
-            logger: ILoggerService = self.make('core.orionis.logger')
+            logger: ILoggerService = self.make('x-orionis.services.log.log_service')
 
             # Calculate elapsed time in milliseconds since application start
             elapsed_ms = (time.time_ns() - self.startAt) // 1_000_000

orionis/foundation/providers/console_provider.py

@@ -4,37 +4,62 @@ from orionis.container.providers.service_provider import ServiceProvider
 
 class ConsoleProvider(ServiceProvider):
     """
-    Provides and registers the console output service within the application container.
+    Console output service provider for the Orionis framework.
 
-    This provider binds the console output interface to its concrete implementation,
-    enabling access to various console output features such as information, warnings,
-    errors, debug messages, tables, confirmations, and password prompts.
+    This service provider is responsible for registering and configuring the console
+    output service within the application's dependency injection container. It binds
+    the IConsole interface to its concrete Console implementation, enabling the
+    application to access comprehensive console output functionality including
+    informational messages, warnings, errors, debug output, tabular data display,
+    user confirmations, and secure password input prompts.
+
+    The provider follows the standard service provider pattern, implementing both
+    registration and boot phases for proper initialization within the application
+    lifecycle.
     """
 
     def register(self) -> None:
         """
-        Register the console output service in the application container.
+        Register the console output service in the application's dependency injection container.
+
+        This method binds the IConsole interface to its concrete Console implementation,
+        making console output functionality available throughout the application. The
+        service is registered as a transient dependency, meaning a new instance will
+        be created each time it is requested from the container.
 
-        Binds the IConsole interface to the Console implementation as a transient service,
-        with the alias "core.orionis.console".
+        The registration uses a predefined alias to ensure consistent service
+        identification across the framework and facilitate easy service resolution.
 
         Returns
         -------
         None
+            This method does not return any value. It performs side effects by
+            modifying the application's service container.
         """
 
-        self.app.transient(IConsole, Console, alias="core.orionis.console")
+        self.app.transient(IConsole, Console, alias="x-orionis.console.output.console")
 
     def boot(self) -> None:
         """
         Perform post-registration initialization for the console provider.
 
-        This method is a placeholder for any additional setup required after
-        registration. Currently, it does not perform any actions.
+        This method is called after the registration phase is complete and all services
+        have been registered in the container. It provides an opportunity to perform
+        any additional setup, configuration, or initialization that depends on other
+        services being available in the container.
+
+        Currently, this implementation serves as a placeholder and does not perform
+        any specific initialization tasks. The console service is fully functional
+        after registration and does not require additional boot-time configuration.
+
+        This method is part of the service provider lifecycle and is automatically
+        invoked by the framework during application startup.
 
         Returns
         -------
         None
+            This method does not return any value and is called for its side effects
+            during the service provider boot phase.
         """
 
         pass

orionis/foundation/providers/dumper_provider.py

@@ -4,48 +4,76 @@ from orionis.container.providers.service_provider import ServiceProvider
 
 class DumperProvider(ServiceProvider):
     """
-    Service provider for registering the debug message service.
+    Service provider for registering debug and dumper services in the application container.
 
-    This provider registers the debug service in the application container,
-    enabling debug message printing, error reporting, and console diagnostics.
+    This provider is responsible for binding debug-related interfaces to their concrete
+    implementations within the application's dependency injection container. It enables
+    comprehensive debug message printing, error reporting, console diagnostics, and
+    data dumping functionality throughout the application.
+
+    The provider follows the service provider pattern, ensuring that debug services
+    are properly registered and available for dependency injection across all
+    application components that require debugging capabilities.
 
     Attributes
     ----------
     app : Application
-        The application container instance where services are registered.
+        The application container instance used for service registration and
+        dependency injection management.
 
     Methods
     -------
-    register()
-        Register the debug service in the application container.
-    boot()
-        Perform post-registration initialization if required.
+    register() -> None
+        Register the debug service interface binding in the application container.
+    boot() -> None
+        Perform any post-registration initialization tasks for the dumper services.
+
+    Notes
+    -----
+    This provider registers services as transient, meaning new instances are created
+    for each resolution request, ensuring isolated debugging contexts.
     """
 
     def register(self) -> None:
         """
         Register the debug service in the application container.
 
-        Registers the `IDebug` interface with the `Debug` implementation
-        as a transient service, using the alias "core.orionis.dumper".
+        This method binds the IDebug interface to its concrete implementation (Debug class)
+        in the application's dependency injection container. The service is registered as
+        transient, meaning a new instance will be created each time it is requested.
+        The service is also assigned an alias for easy retrieval throughout the application.
+
+        The registration enables the application to resolve debug-related dependencies
+        and provides access to debugging, error reporting, and console diagnostic
+        functionality via the registered alias.
 
         Returns
         -------
         None
+            This method does not return any value. It performs side effects by
+            modifying the application container's service registry.
         """
 
-        self.app.transient(IDebug, Debug, alias="core.orionis.dumper")
+        self.app.transient(IDebug, Debug, alias="x-orionis.console.dumper.dump")
 
     def boot(self) -> None:
         """
-        Perform post-registration initialization if required.
+        Perform post-registration initialization for the dumper service provider.
+
+        This method is called after all service providers have been registered
+        in the application container. It provides an opportunity to perform
+        additional setup, configuration, or initialization logic that depends
+        on other services being available in the container.
 
-        This method is a placeholder for any initialization logic that
-        should occur after the service has been registered.
+        Currently, this method contains no implementation as the dumper service
+        does not require any post-registration initialization. The debug service
+        registration is sufficient and complete during the register() phase.
 
         Returns
         -------
         None
+            This method does not return any value and performs no operations
+            in the current implementation.
         """
 
         pass

orionis/foundation/providers/executor_provider.py

@@ -0,0 +1,80 @@
+from orionis.console.output.contracts.executor import IExecutor
+from orionis.console.output.executor import Executor
+from orionis.container.providers.service_provider import ServiceProvider
+
+class ConsoleExecuteProvider(ServiceProvider):
+    """
+    Console executor service provider for dependency injection container registration.
+
+    This service provider is responsible for registering and configuring console executor
+    services within the application's dependency injection container. It binds the
+    IExecutor interface to its concrete Executor implementation, enabling standardized
+    console operations throughout the application including command execution, output
+    formatting, and process management.
+
+    The provider follows the standard service provider lifecycle pattern, implementing
+    both registration and boot phases to ensure proper service initialization and
+    configuration within the application container.
+
+    Attributes
+    ----------
+    app : Container
+        The application's dependency injection container instance used for service
+        registration and binding management.
+
+    Methods
+    -------
+    register() -> None
+        Registers the console executor service binding in the container.
+    boot() -> None
+        Performs post-registration initialization and configuration tasks.
+
+    Notes
+    -----
+    This provider registers services as transient bindings to ensure isolated
+    execution contexts for each console operation request.
+    """
+
+    def register(self) -> None:
+        """
+        Register the console executor service in the application container.
+
+        This method binds the IExecutor interface to its concrete Executor implementation
+        as a transient service. The transient binding ensures that a new instance of
+        the Executor is created each time it is requested from the container, providing
+        isolated execution contexts for console operations.
+
+        The service is registered with the alias "x-orionis.console.output.executor" to
+        enable easy retrieval and identification within the dependency injection container.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It performs the side effect of
+            registering the executor service binding in the application container.
+        """
+
+        self.app.transient(IExecutor, Executor, alias="x-orionis.console.output.executor")
+
+    def boot(self) -> None:
+        """
+        Perform post-registration initialization for the console executor provider.
+
+        This method is called after the service registration phase and provides
+        an opportunity to perform additional setup, configuration, or initialization
+        tasks that depend on the registered services. It follows the service provider
+        lifecycle pattern where registration occurs first, followed by booting.
+
+        Currently, this implementation serves as a placeholder and does not perform
+        any specific initialization tasks. Subclasses or future implementations may
+        override this method to add custom boot logic such as service validation,
+        configuration setup, or dependent service initialization.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It performs initialization
+            side effects only.
+        """
+
+        pass

orionis/foundation/providers/inspirational_provider.py

@@ -4,22 +4,29 @@ from orionis.services.inspirational.inspire import Inspire
 
 class InspirationalProvider(ServiceProvider):
     """
-    Provides and registers the inspirational service within the application container.
+    Service provider for registering inspirational services in the application container.
 
-    This provider is responsible for determining and registering the appropriate
-    implementation of the inspirational service. It ensures that the service is
-    available for dependency injection throughout the application by binding the
-    `IInspire` contract to its concrete implementation.
+    The InspirationalProvider handles the registration and configuration of inspirational
+    services within the application's dependency injection container. This provider follows
+    the service provider pattern, ensuring that inspirational service implementations are
+    properly bound to their corresponding contracts and made available for dependency
+    injection throughout the application lifecycle.
+
+    The provider manages the binding of the IInspire contract to its concrete Inspire
+    implementation, configuring it as a transient service to ensure fresh instances
+    are created for each resolution request.
 
     Attributes
     ----------
     app : Application
-        The application container instance where services are registered.
+        The application container instance used for service registration and dependency
+        injection management.
 
-    Returns
-    -------
-    None
-        This class does not return a value; it registers services within the container.
+    Notes
+    -----
+    This provider inherits from ServiceProvider and implements the standard service
+    provider lifecycle methods (register and boot) to properly integrate inspirational
+    services into the application's service container architecture.
     """
 
     def register(self) -> None:
@@ -27,35 +34,48 @@ class InspirationalProvider(ServiceProvider):
         Registers the inspirational service in the application container.
 
         This method binds the `IInspire` contract to its concrete implementation `Inspire`
-        as a transient service within the application's service container. The service is
-        also registered with the alias "core.orionis.inspire" to allow for convenient
-        resolution elsewhere in the application.
+        as a transient service within the application's service container. Transient
+        services are created each time they are requested from the container, ensuring
+        fresh instances for each resolution. The service is also registered with an
+        alias to enable convenient resolution and identification throughout the application.
 
-        Parameters
-        ----------
-        None
+        The registration establishes the dependency injection mapping that allows other
+        parts of the application to receive the inspirational service implementation
+        when requesting the `IInspire` interface.
 
         Returns
         -------
         None
-            This method does not return a value. It performs service registration as a side effect.
+            This method performs service registration as a side effect and does not
+            return any value.
         """
 
-        self.app.transient(IInspire, Inspire, alias="core.orionis.inspire")
+        self.app.transient(IInspire, Inspire, alias="x-orionis.services.inspirational.inspire")
 
     def boot(self) -> None:
         """
         Executes post-registration initialization for the inspirational service.
 
-        This method is intended for any setup or initialization logic that should
-        occur after the inspirational service has been registered in the application
-        container. By default, it does nothing, but it can be overridden in subclasses
-        to perform additional configuration or resource allocation as needed.
+        This method is called after all services have been registered in the
+        application container and provides an opportunity to perform any additional
+        setup, configuration, or initialization logic specific to the inspirational
+        service. It follows the service provider lifecycle pattern where registration
+        happens first, followed by booting for final setup tasks.
+
+        The boot phase is particularly useful for operations that depend on other
+        services being available in the container, cross-service configuration,
+        or initialization of resources that require the complete service graph
+        to be established.
+
+        By default, this implementation performs no operations, but subclasses
+        can override this method to implement custom initialization logic as
+        required by specific use cases.
 
         Returns
         -------
         None
-            This method does not return any value. It is intended for side effects only.
+            This method does not return any value. It performs initialization
+            operations as side effects only.
         """
 
         pass