orionis 0.613.0__py3-none-any.whl → 0.615.0__py3-none-any.whl

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")

orionis/foundation/providers/testing_provider.py

@@ -3,52 +3,21 @@ from orionis.test.contracts.unit_test import IUnitTest
 from orionis.test.core.unit_test import UnitTest
 
 class TestingProvider(ServiceProvider):
-    """
-    Provides comprehensive unit testing environment services for the Orionis framework.
-
-    This service provider integrates a native unit testing framework into the Orionis
-    application ecosystem, enabling advanced testing capabilities with configurable
-    execution modes, parallel processing, and persistent result storage. The provider
-    registers the testing service as a singleton within the application's dependency
-    injection container, making it available throughout the application lifecycle.
-
-    The TestingProvider handles the complete lifecycle of testing services, from
-    initial configuration and test discovery to storage preparation and service
-    registration. It supports various testing patterns, execution strategies, and
-    reporting mechanisms to accommodate different testing scenarios and requirements.
-
-    Attributes
-    ----------
-    app : Application
-        The Orionis application container instance that manages service registration,
-        configuration access, and dependency injection throughout the framework.
-
-    Notes
-    -----
-    This provider follows the Orionis service provider pattern, implementing both
-    register() and boot() methods to ensure proper service initialization and
-    post-registration setup. The testing service is registered with the interface
-    binding IUnitTest and can be resolved using the alias "x-orionis.test.core.unit_test".
-
-    The provider requires a valid testing configuration section in the application
-    configuration, which should include settings for verbosity, execution mode,
-    worker configuration, and storage paths.
-    """
 
     def register(self) -> None:
         """
-        Register and configure the unit testing service in the application container.
+        Registers and configures the unit testing service within the application container.
 
-        This method loads the testing configuration from the application, instantiates
-        and configures a UnitTest service, and registers it as a singleton in the
-        dependency injection container. The service is bound to the IUnitTest interface
-        and is accessible via the alias "x-orionis.test.core.unit_test".
+        This method retrieves the application's testing configuration, creates an instance
+        of the UnitTest service, and registers it as a singleton in the dependency injection
+        container. The service is bound to the `IUnitTest` interface and is accessible via
+        the alias `"x-orionis.test.contracts.unit_test.IUnitTest"`.
 
         The registration process includes:
-            - Retrieving testing configuration from the application settings.
-            - Instantiating the UnitTest service with the appropriate configuration.
+            - Retrieving the testing configuration from the application settings.
+            - Instantiating the UnitTest service with the retrieved configuration.
             - Registering the UnitTest service as a singleton in the container.
-            - Binding the service to the IUnitTest interface and alias.
+            - Binding the service to the `IUnitTest` interface and an alias for resolution.
 
         Returns
         -------
@@ -59,19 +28,4 @@ class TestingProvider(ServiceProvider):
 
         # Register the UnitTest service as a singleton in the application container.
         # The service is bound to the IUnitTest interface and can be resolved using the alias.
-        self.app.singleton(IUnitTest, UnitTest, alias=f"x-{IUnitTest.__module__}.{IUnitTest.__name__}")
-
-    def boot(self) -> None:
-        """
-        Finalize initialization for the testing provider after service registration.
-
-        This method is called after the registration phase to allow for any additional
-        setup required for the testing environment. In this implementation, no further
-        actions are performed during the boot phase.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-        pass
+        self.app.singleton(IUnitTest, UnitTest, alias="x-orionis.test.contracts.unit_test.IUnitTest")

orionis/foundation/providers/workers_provider.py

@@ -3,80 +3,16 @@ from orionis.services.system.contracts.workers import IWorkers
 from orionis.services.system.workers import Workers
 
 class WorkersProvider(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 IWorkers interface contract and its concrete
-    Workers implementation, enabling consistent worker 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 worker service with transient lifetime, ensuring
-    that each request for worker functionality receives a fresh instance. This
-    approach is optimal for worker operations that may maintain temporary state
-    or require isolation between different execution contexts.
-    """
 
     def register(self) -> None:
         """
-        Register the worker management service in the application container.
-
-        This method registers the concrete Workers implementation as the service
-        provider for the IWorkers interface contract. The service is configured
-        as transient, meaning a new instance will be created each time it is
-        requested from the container. The registration includes a descriptive
-        alias for easy identification and retrieval.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
-            This method does not return any value. It performs registration
-            side effects on the application container.
-
-        Notes
-        -----
-        The service is registered with transient lifetime, which means:
-        - A new instance is created for each resolution request
-        - No instance caching or singleton behavior is applied
-        - Suitable for stateless or short-lived worker operations
-        """
-
-        self.app.transient(IWorkers, Workers, alias=f"x-{IWorkers.__module__}.{IWorkers.__name__}")
-
-    def boot(self) -> None:
-        """
-        Perform post-registration initialization for the worker management service.
-
-        This method is called after all services have been registered in the container
-        and provides an opportunity to perform any additional setup, configuration,
-        or initialization logic that depends on other services being available.
-
-        The boot phase occurs after the registration phase and allows for:
-        - Cross-service dependency configuration
-        - Service warm-up operations
-        - Additional service binding or decoration
-        - Runtime configuration validation
+        Registers the worker management service in the application container.
 
-        Currently, this implementation serves as a placeholder with no specific
-        initialization requirements for the worker service. Future enhancements
-        may include worker pool initialization, background task setup, or
-        performance monitoring configuration.
+        This method binds the `IWorkers` interface to its concrete implementation
+        `Workers` within the application's dependency injection container. The
+        registration uses a transient lifetime, ensuring that a new instance of
+        `Workers` is created each time the service is resolved. An alias is also
+        provided for convenient identification and retrieval.
 
         Parameters
         ----------
@@ -85,14 +21,19 @@ class WorkersProvider(ServiceProvider):
         Returns
         -------
         None
-            This method performs initialization side effects only and does not
-            return any value.
+            This method does not return any value. It performs a side effect by
+            registering the service in the application container.
 
         Notes
         -----
-        This method is automatically called by the service provider framework
-        during the application boot sequence. It should not be called manually
-        in application code.
+        - The service is registered with a transient lifetime:
+            - A new instance is created for each resolution request.
+            - No instance is cached or reused.
+            - This is suitable for stateless or short-lived worker operations.
+        - The alias used for registration is
+          "x-orionis.services.system.contracts.workers.IWorkers".
         """
 
-        pass
+        # Register the Workers implementation as a transient service for IWorkers.
+        # Each resolution will create a new instance.
+        self.app.transient(IWorkers, Workers, alias="x-orionis.services.system.contracts.workers.IWorkers")

orionis/metadata/framework.py

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

orionis/support/facades/application.py

@@ -1,24 +1,22 @@
 from orionis.container.facades.facade import Facade
-from orionis.foundation.contracts.application import IApplication
 
 class Application(Facade):
 
     @classmethod
     def getFacadeAccessor(cls) -> str:
         """
-        Get the registered service container binding key for the console component.
+        Retrieve the service container binding key for the application component.
 
-        This method returns the specific binding key that is used to resolve the
-        console output service from the dependency injection container. The facade
-        pattern uses this key to locate and instantiate the underlying console
-        service implementation.
+        This class method provides the unique string identifier (binding key) that is registered
+        in the service container for the application interface. The facade uses this key to resolve
+        and access the underlying application service implementation from the dependency injection container.
 
         Returns
         -------
         str
-            The string identifier "x-orionis.foundation.contracts.application.IApplication" used as the
-            binding key to resolve the console service from the service container.
+            The binding key "x-orionis.foundation.contracts.application.IApplication" used to resolve
+            the application service from the service container.
         """
 
-        # Return the predefined binding key for the console output service
-        return f"x-{IApplication.__module__}.{IApplication.__name__}"
+        # Return the predefined binding key for the application service
+        return "x-orionis.foundation.contracts.application.IApplication"

orionis/support/facades/console.py

@@ -1,4 +1,3 @@
-from orionis.console.contracts.console import IConsole
 from orionis.container.facades.facade import Facade
 
 class Console(Facade):
@@ -6,19 +5,19 @@ class Console(Facade):
     @classmethod
     def getFacadeAccessor(cls) -> str:
         """
-        Get the registered service container binding key for the console component.
+        Returns the binding key used to resolve the console service from the service container.
 
-        This method returns the specific binding key that is used to resolve the
-        console output service from the dependency injection container. The facade
-        pattern uses this key to locate and instantiate the underlying console
-        service implementation.
+        This method provides the unique string identifier associated with the console output
+        service in the dependency injection container. The facade uses this key to retrieve
+        the underlying implementation of the console service, enabling decoupled access to
+        console output functionality throughout the application.
 
         Returns
         -------
         str
-            The string identifier 'x-orionis.console.contracts.console.IConsole' used as the
-            binding key to resolve the console service from the service container.
+            The binding key 'x-orionis.console.contracts.console.IConsole' that identifies
+            the console service in the service container.
         """
 
         # Return the predefined binding key for the console output service
-        return f"x-{IConsole.__module__}.{IConsole.__name__}"
+        return "x-orionis.console.contracts.console.IConsole"

orionis/support/facades/directory.py

@@ -1,22 +1,23 @@
 from orionis.container.facades.facade import Facade
-from orionis.services.file.contracts.directory import IDirectory
 
 class Directory(Facade):
 
     @classmethod
     def getFacadeAccessor(cls):
         """
-        Get the registered name of the component in the service container.
+        Returns the binding key used by the service container to resolve the directory service.
 
-        This method provides the binding key that the service container uses to
-        resolve the workers service implementation. It serves as the bridge between
-        the facade and the underlying service registration.
+        This method provides the unique identifier (binding key) that the service container uses
+        to locate and instantiate the implementation of the directory service. It acts as a bridge
+        between the facade and the underlying service registration, ensuring that the correct
+        service is retrieved when requested.
 
         Returns
         -------
         str
-            The service container binding key 'x-orionis.services.file.contracts.directory.IDirectory'
-            that identifies the workers service implementation.
+            The binding key for the directory service implementation:
+            'x-orionis.services.file.contracts.directory.IDirectory'.
         """
 
-        return f"x-{IDirectory.__module__}.{IDirectory.__name__}"
+        # Return the unique binding key for the directory service in the container
+        return "x-orionis.services.file.contracts.directory.IDirectory"

orionis/support/facades/dumper.py

@@ -1,4 +1,3 @@
-from orionis.console.contracts.debug import IDebug
 from orionis.container.facades.facade import Facade
 
 class Dumper(Facade):
@@ -6,18 +5,18 @@ class Dumper(Facade):
     @classmethod
     def getFacadeAccessor(cls) -> str:
         """
-        Get the registered name of the component in the service container.
+        Retrieves the binding key for the dumper service in the application's service container.
 
-        This method defines the binding key used to resolve the dumper service
-        from the application's service container. The dumper facade provides
+        This method specifies the unique identifier used by the service container to resolve
+        the dumper service instance. The returned binding key allows the facade to provide
         a static interface to the underlying dumper service implementation.
 
         Returns
         -------
         str
-            The service container binding key "x-orionis.console.contracts.debug.IDebug"
-            that identifies the dumper service instance.
+            The string "x-orionis.console.contracts.debug.IDebug", which is the binding key
+            used to identify and resolve the dumper service from the service container.
         """
 
-        # Return the specific binding key for the dumper service in the container
-        return f"x-{IDebug.__module__}.{IDebug.__name__}"
+        # Return the unique binding key for the dumper service in the container
+        return "x-orionis.console.contracts.debug.IDebug"

orionis/support/facades/executor.py

@@ -1,4 +1,3 @@
-from orionis.console.contracts.executor import IExecutor
 from orionis.container.facades.facade import Facade
 
 class ConsoleExecutor(Facade):
@@ -6,20 +5,20 @@ class ConsoleExecutor(Facade):
     @classmethod
     def getFacadeAccessor(cls) -> str:
         """
-        Get the registered service container binding key for the executor facade.
+        Retrieves the binding key used by the service container to resolve the executor service.
 
-        This method provides the specific binding key that the service container
-        uses to resolve and instantiate the executor service. The executor is
-        responsible for handling command-line operations and console output
-        management within the Orionis framework.
+        This method returns the unique string identifier associated with the executor service
+        in the Orionis framework's dependency injection container. The executor service is
+        responsible for managing command-line operations and console output within the framework.
+        By providing this binding key, the facade enables the framework to locate and instantiate
+        the correct executor implementation.
 
         Returns
         -------
         str
-            The string identifier 'x-orionis.console.contracts.executor.IExecutor' used as
-            the binding key to locate and resolve the executor service instance
-            from the dependency injection container.
+            The binding key 'x-orionis.console.contracts.executor.IExecutor' that identifies
+            the executor service in the service container.
         """
 
-        # Return the predefined binding key for the executor service
-        return f"x-{IExecutor.__module__}.{IExecutor.__name__}"
+        # Return the predefined binding key for the executor service in the container
+        return "x-orionis.console.contracts.executor.IExecutor"

orionis/support/facades/inspire.py

@@ -1,24 +1,23 @@
 from orionis.container.facades.facade import Facade
-from orionis.services.inspirational.contracts.inspire import IInspire
 
 class Inspire(Facade):
 
     @classmethod
     def getFacadeAccessor(cls):
         """
-        Get the registered name of the component.
+        Retrieves the service container binding key for the inspirational service.
 
-        This method returns the service container binding key that identifies the
-        inspirational service implementation. The facade system uses this accessor
-        to resolve the underlying service instance from the IoC container when
-        facade methods are called.
+        This method provides the unique identifier used by the facade system to resolve
+        the underlying inspirational service implementation from the IoC container. The
+        returned binding key allows the facade to delegate method calls to the correct
+        service instance registered within the application.
 
         Returns
         -------
         str
-            The service container binding key 'x-orionis.services.inspirational.contracts.inspire.IInspire'
-            used to resolve the inspirational service instance.
+            The binding key 'x-orionis.services.inspirational.contracts.inspire.IInspire'
+            that identifies the inspirational service in the service container.
         """
 
-        # Return the service container binding key for the inspirational service
-        return f"x-{IInspire.__module__}.{IInspire.__name__}"
+        # Return the unique binding key for the inspirational service in the IoC container
+        return "x-orionis.services.inspirational.contracts.inspire.IInspire"

orionis/support/facades/logger.py

@@ -1,24 +1,24 @@
 from orionis.container.facades.facade import Facade
-from orionis.services.log.contracts.log_service import ILogger
 
 class Log(Facade):
 
     @classmethod
     def getFacadeAccessor(cls) -> str:
         """
-        Get the registered name of the component.
+        Retrieves the service container binding key for the logger service.
 
-        This method returns the service container binding key that identifies
-        the logger service implementation. It serves as the bridge between the
-        facade and the actual service instance registered in the container.
+        This method returns the unique string identifier used by the service container
+        to resolve and provide the logger service implementation. The returned key acts
+        as a bridge between the facade and the actual logger service instance registered
+        in the dependency injection container.
 
         Returns
         -------
         str
-            The service container binding key "x-orionis.services.log.contracts.log_service.ILogger"
-            used to resolve the logger service instance from the dependency
-            injection container.
+            The string identifier
+            "x-orionis.services.log.contracts.log_service.ILogger"
+            which is used to resolve the logger service instance from the service container.
         """
 
-        # Return the service container binding key for the logger service
-        return f"x-{ILogger.__module__}.{ILogger.__name__}"
+        # Return the unique binding key for the logger service in the container
+        return f"x-orionis.services.log.contracts.log_service.ILogger"

orionis/support/facades/performance_counter.py

@@ -1,22 +1,23 @@
 from orionis.container.facades.facade import Facade
-from orionis.support.performance.contracts.counter import IPerformanceCounter
 
 class PerformanceCounter(Facade):
 
     @classmethod
     def getFacadeAccessor(cls):
         """
-        Get the registered name of the component in the service container.
+        Returns the registered binding key for the performance counter service in the service container.
 
-        This method provides the binding key that the service container uses to
-        resolve the workers service implementation. It serves as the bridge between
-        the facade and the underlying service registration.
+        This method provides the unique string identifier used by the service container to resolve
+        and retrieve the implementation of the performance counter service. It acts as the connection
+        point between the facade and the underlying service registration, ensuring that the correct
+        service is accessed when requested through the facade.
 
         Returns
         -------
         str
-            The service container binding key 'x-orionis.support.performance.contracts.counter.IPerformanceCounter
-            that identifies the workers service implementation.
+            The binding key 'x-orionis.support.performance.contracts.counter.IPerformanceCounter'
+            which identifies the performance counter service implementation in the service container.
         """
 
-        return f"x-{IPerformanceCounter.__module__}.{IPerformanceCounter.__name__}"
+        # Return the unique binding key for the performance counter service
+        return "x-orionis.support.performance.contracts.counter.IPerformanceCounter"

orionis/support/facades/progress_bar.py

@@ -1,22 +1,24 @@
 from orionis.container.facades.facade import Facade
-from orionis.console.contracts.progress_bar import IProgressBar
 
 class ProgressBar(Facade):
 
     @classmethod
     def getFacadeAccessor(cls):
         """
-        Get the registered name of the component.
+        Returns the service container binding key for the progress bar component.
 
-        This method returns the binding key that identifies the progress bar service
-        within the service container. The facade uses this key to resolve the actual
-        progress bar implementation when static methods are called.
+        This method provides the unique string identifier used by the service container
+        to resolve and retrieve the progress bar implementation. The facade relies on
+        this binding key to delegate static method calls to the underlying progress bar
+        service.
 
         Returns
         -------
         str
-            The service container binding key 'x-orionis.console.contracts.progress_bar.IProgressBar
-            used to retrieve the progress bar service instance.
+            The string 'x-orionis.console.contracts.progress_bar.IProgressBar', which
+            is the binding key used to obtain the progress bar service instance from
+            the service container.
         """
 
-        return f"x-{IProgressBar.__module__}.{IProgressBar.__name__}"
+        # Return the binding key for the progress bar service in the container
+        return "x-orionis.console.contracts.progress_bar.IProgressBar"

orionis/support/facades/reactor.py

@@ -1,23 +1,23 @@
 from orionis.container.facades.facade import Facade
-from orionis.console.contracts.reactor import IReactor
 
 class Reactor(Facade):
 
     @classmethod
     def getFacadeAccessor(cls) -> str:
         """
-        Get the registered name of the component.
+        Returns the service container binding key for the reactor component.
 
-        This method returns the service container binding key that identifies
-        the testing component implementation. The facade uses this key to
-        resolve the appropriate testing service from the container when
-        static methods are called on the facade.
+        This method provides the unique identifier used by the service container
+        to resolve the implementation of the reactor component. The facade uses
+        this key to retrieve the appropriate service instance whenever static
+        methods are invoked on the facade.
 
         Returns
         -------
         str
-            The service container binding key "x-orionis.console.contracts.reactor.IReactor"
-            used to resolve the testing component implementation.
+            The string "x-orionis.console.contracts.reactor.IReactor", which is
+            the binding key for the reactor component in the service container.
         """
 
-        return f"x-{IReactor.__module__}.{IReactor.__name__}"
+        # Return the binding key for the reactor component in the service container
+        return "x-orionis.console.contracts.reactor.IReactor"