orionis 0.612.0__py3-none-any.whl → 0.614.0__py3-none-any.whl

orionis/foundation/providers/executor_provider.py

@@ -3,49 +3,21 @@ 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.
+        Registers the console executor service within 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.
+        This method binds the `IExecutor` interface to its concrete `Executor` implementation
+        as a transient service. Each time the service is requested from the container, a new
+        instance of `Executor` is created, ensuring isolated execution contexts for console
+        operations. The service is registered with the alias
+        `"x-orionis.console.contracts.executor.IExecutor"` for convenient retrieval and
+        identification within the dependency injection container.
 
-        The service is registered with the alias "x-orionis.console.output.executor" to
-        enable easy retrieval and identification within the dependency injection container.
+        Parameters
+        ----------
+        None
 
         Returns
         -------
@@ -54,27 +26,6 @@ class ConsoleExecuteProvider(ServiceProvider):
             registering the executor service binding in the application container.
         """
 
-        self.app.transient(IExecutor, Executor, alias=f"x-{IExecutor.__module__}.{IExecutor.__name__}")
-
-    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
+        # Bind the IExecutor interface to the Executor implementation as a transient service.
+        # This ensures a new Executor instance is created on each request.
+        self.app.transient(IExecutor, Executor, alias="x-orionis.console.contracts.executor.IExecutor")

orionis/foundation/providers/inspirational_provider.py

@@ -3,79 +3,26 @@ from orionis.services.inspirational.contracts.inspire import IInspire
 from orionis.services.inspirational.inspire import Inspire
 
 class InspirationalProvider(ServiceProvider):
-    """
-    Service provider for registering inspirational services in the application container.
-
-    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 used for service registration and dependency
-        injection management.
-
-    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:
         """
-        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. 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.
-
-        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 performs service registration as a side effect and does not
-            return any value.
-        """
-
-        self.app.transient(IInspire, Inspire, alias=f"x-{IInspire.__module__}.{IInspire.__name__}")
-
-    def boot(self) -> None:
-        """
-        Executes post-registration initialization for the inspirational service.
-
-        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.
+        Registers the inspirational service as a transient binding in the application container.
 
-        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.
+        This method binds the `IInspire` interface to its concrete implementation `Inspire`
+        as a transient service within the application's service container. Each time the
+        service is requested, a new instance of `Inspire` will be provided. The service is
+        also registered with a specific alias to facilitate convenient resolution and
+        identification throughout the application.
 
-        By default, this implementation performs no operations, but subclasses
-        can override this method to implement custom initialization logic as
-        required by specific use cases.
+        This registration enables dependency injection, allowing other components to
+        receive an instance of `Inspire` whenever the `IInspire` contract is requested.
 
         Returns
         -------
         None
-            This method does not return any value. It performs initialization
-            operations as side effects only.
+            This method does not return any value. It performs service registration as a side effect.
         """
 
-        pass
+        # Register the IInspire contract to the Inspire implementation as a transient service.
+        # Each resolution from the container will provide a new instance.
+        self.app.transient(IInspire, Inspire, alias="x-orionis.services.inspirational.contracts.inspire.IInspire")

orionis/foundation/providers/logger_provider.py

@@ -3,42 +3,20 @@ from orionis.services.log.contracts.log_service import ILogger
 from orionis.services.log.log_service import Logger
 
 class LoggerProvider(ServiceProvider):
-    """
-    Service provider for logging functionality within the Orionis framework.
-
-    The LoggerProvider is responsible for registering and configuring the logging
-    service implementation in the application's dependency injection container.
-    It binds the concrete Logger to the ILogger interface, enabling
-    application-wide access to structured logging capabilities.
-
-    This provider handles the initialization of the logging service with the
-    application's configuration and ensures proper registration under both the
-    interface contract and an internal framework alias for service resolution.
-
-    Attributes
-    ----------
-    app : Application
-        The application container instance used for service registration and
-        configuration retrieval. Inherited from the base ServiceProvider class.
-
-    Notes
-    -----
-    This provider follows the two-phase initialization pattern:
-    - register(): Performs service binding and container registration
-    - boot(): Handles post-registration initialization and setup
-    """
 
     def register(self) -> None:
         """
-        Register the logging service in the application container.
+        Registers the Logger service implementation in the application container.
 
-        This method binds the `Logger` implementation to the `ILogger`
-        contract within the application's dependency injection container. The service
-        is initialized with the application's logging configuration and registered
-        with a specific alias for internal framework identification.
+        This method binds the `Logger` class to the `ILogger` contract within the application's
+        dependency injection container. It retrieves the logging configuration from the application,
+        creates a `Logger` instance using this configuration, and registers it with an alias for
+        internal framework identification. This setup allows the logging service to be resolved
+        and used throughout the application via the container.
 
-        The registration enables application-wide access to logging functionality
-        through the container's service resolution mechanism.
+        Parameters
+        ----------
+        None
 
         Returns
         -------
@@ -47,33 +25,12 @@ class LoggerProvider(ServiceProvider):
             as a side effect on the application container.
         """
 
-        # Retrieve logging configuration from application config
+        # Retrieve the logging configuration from the application
         logging_config = self.app.config('logging')
 
-        # Create Logger instance with the retrieved configuration
-        logger_service = Logger(logging_config)
-
-        # Register the service instance in the container with interface binding and alias
-        self.app.instance(ILogger, logger_service, alias=f"x-{ILogger.__module__}.{ILogger.__name__}")
-
-    def boot(self) -> None:
-        """
-        Perform post-registration initialization for the logging service.
-
-        This method is called after all service providers have been registered
-        and allows for any additional configuration, setup, or initialization
-        logic that depends on other services being available in the container.
-
-        Currently, this method serves as a placeholder and performs no operations,
-        but it can be extended to include logging service initialization tasks
-        such as setting up log handlers, configuring formatters, or establishing
-        connections to external logging systems.
-
-        Returns
-        -------
-        None
-            This method does not return any value. It performs initialization
-            operations as side effects during the application boot process.
-        """
+        # Instantiate the Logger with the retrieved configuration
+        logger_instance = Logger(logging_config)
 
-        pass
+        # Register the Logger instance in the application container,
+        # binding it to the ILogger contract and assigning an alias
+        self.app.instance(ILogger, logger_instance, alias="x-orionis.services.log.contracts.log_service.ILogger")

orionis/foundation/providers/performance_counter_provider.py

@@ -8,14 +8,14 @@ class PerformanceCounterProvider(ServiceProvider):
         """
         Registers the performance counter service as a transient dependency in the application container.
 
-        This method binds the `IPerformanceCounter` interface contract to the `PerformanceCounter`
-        concrete implementation within the application's dependency injection container. The binding
-        is configured with a transient lifetime, ensuring that each resolution of the service yields
-        a new instance of `PerformanceCounter`. This approach is suitable for scenarios requiring
-        independent timing or measurement operations across different parts of the application.
+        This method binds the `IPerformanceCounter` interface to the `PerformanceCounter` implementation
+        within the application's dependency injection container. The binding uses a transient lifetime,
+        ensuring that each resolution of the service provides a new instance of `PerformanceCounter`.
+        This is useful for scenarios where independent timing or measurement operations are required
+        across different parts of the application.
 
-        Additionally, an alias `"x-orionis.support.performance.counter"` is assigned to this binding,
-        allowing for alternative resolution or referencing of the service.
+        An alias, `"x-orionis.support.performance.contracts.counter.IPerformanceCounter"`, is also
+        assigned to this binding, enabling alternative resolution or referencing of the service by name.
 
         Parameters
         ----------
@@ -24,41 +24,15 @@ class PerformanceCounterProvider(ServiceProvider):
         Returns
         -------
         None
-            This method performs service registration as a side effect and does not return any value.
+            This method does not return any value. It performs service registration as a side effect.
 
         Notes
         -----
-        - The transient lifetime ensures isolation between different consumers of the service.
-        - The alias facilitates flexible service resolution by name.
+        - The transient lifetime ensures that each consumer receives a separate instance of the service.
+        - The alias allows for flexible service resolution by a specific name.
         """
 
         # Register the IPerformanceCounter interface to the PerformanceCounter implementation
-        # with a transient lifetime and assign an alias for alternative resolution.
-        self.app.transient(IPerformanceCounter, PerformanceCounter, alias=f"x-{IPerformanceCounter.__module__}.{IPerformanceCounter.__name__}")
-
-    def boot(self) -> None:
-        """
-        Performs initialization and configuration tasks for the performance counter provider during the application's bootstrapping phase.
-
-        This method is automatically invoked when the provider is loaded by the application. It is intended for setting up or registering
-        any performance counters or related resources required by the application. By default, this implementation does not perform any
-        actions, but it can be extended in subclasses to include custom initialization logic as needed.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
-            This method does not return any value. It executes initialization logic as a side effect.
-
-        Notes
-        -----
-        - Override this method in subclasses to implement custom bootstrapping behavior for performance counters.
-        - This method is part of the provider lifecycle and is called after service registration.
-        """
-
-        # No initialization logic is required by default.
-        # Override this method in subclasses to perform custom setup.
-        pass
+        # with a transient lifetime. Each resolution yields a new instance.
+        # Assign an alias for alternative resolution by name.
+        self.app.transient(IPerformanceCounter, PerformanceCounter, alias="x-orionis.support.performance.contracts.counter.IPerformanceCounter")

orionis/foundation/providers/progress_bar_provider.py

@@ -3,73 +3,16 @@ from orionis.console.dynamic.progress_bar import ProgressBar
 from orionis.container.providers.service_provider import ServiceProvider
 
 class ProgressBarProvider(ServiceProvider):
-    """
-    Service provider for dynamic progress bar functionality.
-
-    This provider is responsible for registering the dynamic progress bar service
-    within the application's dependency injection container. It binds the IProgressBar
-    interface to its concrete ProgressBar implementation, enabling the creation of
-    visual progress indicators for long-running operations in console applications.
-
-    The provider follows the transient lifetime pattern, ensuring that each request
-    for a progress bar service creates a new, independent instance. This approach
-    prevents state conflicts when multiple progress bars are used simultaneously
-    across different parts of the application.
-
-    Parameters
-    ----------
-    None
-        This class does not accept initialization parameters beyond those
-        inherited from the base ServiceProvider class.
-
-    Returns
-    -------
-    None
-        Service providers do not return values as they are used for
-        registration and configuration purposes only.
-
-    Notes
-    -----
-    The progress bar service is registered with the alias 'x-orionis.console.dynamic.progress_bar'
-    to enable specific identification and retrieval from the container when needed.
-    This provider requires the orionis container framework to be properly initialized
-    before registration can occur.
-    """
 
     def register(self) -> None:
         """
-        Register the progress bar service in the application container.
-
-        This method binds the IProgressBar interface to the ProgressBar concrete
-        implementation using transient lifetime management. The service is registered
-        with a specific alias for identification and retrieval within the container.
-
-        The transient lifetime ensures that a new instance of ProgressBar is created
-        each time the IProgressBar interface is resolved from the container.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
-            This method does not return any value. It performs service registration
-            as a side effect on the application container.
-        """
-
-        self.app.transient(IProgressBar, ProgressBar, alias=f"x-{IProgressBar.__module__}.{IProgressBar.__name__}")
-
-    def boot(self) -> None:
-        """
-        Perform post-registration initialization for the progress bar provider.
+        Registers the progress bar service in the application container.
 
-        This method is called after all service providers have been registered
-        in the application container. It provides an opportunity to perform
-        any additional setup or configuration that depends on other services
-        being available. For the progress bar provider, no additional
-        initialization steps are required as the service is fully configured
-        during registration.
+        This method binds the `IProgressBar` interface to its concrete implementation,
+        `ProgressBar`, using transient lifetime management. The service is registered
+        with a specific alias for easy identification and retrieval from the container.
+        Transient lifetime ensures that a new instance of `ProgressBar` is created
+        each time the `IProgressBar` interface is resolved.
 
         Parameters
         ----------
@@ -78,8 +21,10 @@ class ProgressBarProvider(ServiceProvider):
         Returns
         -------
         None
-            This method does not return any value. It serves as a lifecycle
-            hook for post-registration initialization.
+            This method does not return any value. It registers the service as a side effect
+            on the application container.
         """
 
-        pass
+        # Register the ProgressBar implementation as a transient service for IProgressBar.
+        # The alias allows for explicit retrieval from the container if needed.
+        self.app.transient(IProgressBar, ProgressBar, alias="x-orionis.console.contracts.progress_bar.IProgressBar")

orionis/foundation/providers/reactor_provider.py

@@ -3,40 +3,15 @@ from orionis.console.core.reactor import Reactor
 from orionis.container.providers.service_provider import ServiceProvider
 
 class ReactorProvider(ServiceProvider):
-    """
-    Service provider for worker management functionality within the Orionis framework.
-
-    This provider is responsible for registering and configuring the worker management
-    service implementation in the application's dependency injection container. It
-    establishes the binding between the IReactor interface contract and its concrete
-    Reactor implementation, enabling consistent reactor operations throughout the
-    application lifecycle.
-
-    The provider follows the standard service provider pattern, offering both
-    registration and boot phases for complete service lifecycle management.
-
-    Attributes
-    ----------
-    app : Application
-        The main application container instance used for service registration
-        and dependency injection management.
-
-    Notes
-    -----
-    This provider registers the reactor service with a transient lifetime, ensuring
-    that each request for reactor functionality receives a fresh instance. This
-    approach is optimal for operations that may maintain temporary state or require
-    isolation between different execution contexts.
-    """
 
     def register(self) -> None:
         """
-        Register the reactor management service in the application container.
+        Registers the reactor management service in the application container.
 
-        This method binds the IReactor interface to a new instance of the Reactor
-        implementation within the application's dependency injection container. The
-        service is registered with a transient lifetime, ensuring that each resolution
-        yields a new Reactor instance. An alias is provided for convenient retrieval.
+        This method binds the `IReactor` interface to the `Reactor` implementation
+        within the application's dependency injection container. The service is registered
+        as a singleton, ensuring that the same `Reactor` instance is returned for every
+        resolution. An alias is provided for convenient retrieval.
 
         Parameters
         ----------
@@ -45,44 +20,18 @@ class ReactorProvider(ServiceProvider):
         Returns
         -------
         None
-            This method does not return any value. It performs registration
+            This method does not return any value. It performs service registration
             as a side effect on the application container.
 
         Notes
         -----
-        - Each call to resolve IReactor will produce a new Reactor instance.
-        - No singleton or caching behavior is applied.
-        - The alias "x-orionis.console.core.reactor" can be used for explicit lookups.
-        """
-
-        # Register the Reactor service with the application container
-        # as a singleton, allowing it to be resolved throughout the application lifecycle
-        self.app.singleton(IReactor, Reactor, alias=f"x-{IReactor.__module__}.{IReactor.__name__}")
-    def boot(self) -> None:
-        """
-        Perform post-registration initialization for the reactor management service.
-
-        This method is invoked after all services have been registered in the container.
-        It provides an opportunity for additional setup, configuration, or initialization
-        logic that may depend on other services being available. Currently, this method
-        does not perform any actions but serves as a placeholder for future enhancements.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
-            This method does not return any value. It only performs initialization
-            side effects if required.
-
-        Notes
-        -----
-        - Called automatically during the application boot sequence.
-        - Intended for cross-service configuration or runtime setup.
-        - No initialization is currently required for the reactor service.
+        - The `IReactor` interface is bound to the `Reactor` implementation.
+        - The service is registered as a singleton, so only one instance of `Reactor`
+          will exist throughout the application lifecycle.
+        - The alias "x-orionis.console.contracts.reactor.IReactor" can be used to
+          retrieve the service explicitly from the container.
         """
 
-        # No additional initialization required at this time
-        pass
+        # Register the Reactor service as a singleton in the application container.
+        # This ensures only one instance of Reactor is created and shared.
+        self.app.singleton(IReactor, Reactor, alias="x-orionis.console.contracts.reactor.IReactor")

orionis/foundation/providers/scheduler_provider.py

@@ -3,49 +3,27 @@ from orionis.console.tasks.schedule import Schedule
 from orionis.container.providers.service_provider import ServiceProvider
 
 class ScheduleProvider(ServiceProvider):
-    """
-    Service provider responsible for registering and bootstrapping the application's scheduling system.
-
-    The ScheduleProvider binds the ISchedule interface to the Scheduler implementation as a singleton
-    within the application's service container. It also provides an alias for convenient access.
-    Override the `boot` method to configure and register scheduled tasks or jobs required by the application.
-
-    Methods
-    -------
-    register() :
-        Registers the Scheduler as a singleton service and binds it to the ISchedule interface.
-    boot() :
-        Initializes and configures scheduled tasks; intended to be overridden for custom jobs.
-    """
 
     def register(self) -> None:
         """
-        Register the Scheduler as a singleton service in the application container.
+        Registers the Scheduler as a singleton service in the application container.
 
-        This method binds the ISchedule interface to the Scheduler implementation,
-        making it available as a singleton throughout the application's lifecycle.
-        An alias "x-orionis.console.contracts.schedule" is also provided for
-        convenient access.
+        This method binds the `ISchedule` interface to the `Schedule` implementation,
+        ensuring that a single instance of the scheduler is used throughout the application's
+        lifecycle. Additionally, it provides an alias
+        ("x-orionis.console.contracts.schedule.ISchedule") for convenient access to the
+        scheduler service.
 
-        Returns
-        -------
+        Parameters
+        ----------
         None
-            This method does not return any value.
-        """
-        # Bind Scheduler as a singleton to the ISchedule interface with an alias
-        self.app.singleton(ISchedule, Schedule, alias=f"x-{ISchedule.__module__}.{ISchedule.__name__}")
-
-    def boot(self) -> None:
-        """
-        Initialize and configure any scheduled tasks or jobs required by the application.
-
-        This method is called automatically during the application's bootstrapping process.
-        Override this method to register custom scheduled tasks.
 
         Returns
         -------
         None
-            This method does not return any value.
+            This method does not return any value. It performs the registration as a side effect.
         """
-        # No scheduled tasks are registered by default; override to add custom jobs
-        pass
+
+        # Bind the Schedule implementation as a singleton to the ISchedule interface
+        # and provide an alias for easier access within the application container.
+        self.app.singleton(ISchedule, Schedule, alias="x-orionis.console.contracts.schedule.ISchedule")