orionis 0.435.0__py3-none-any.whl → 0.437.0__py3-none-any.whl

orionis/foundation/contracts/config.py

@@ -2,22 +2,30 @@ from abc import ABC, abstractmethod
 
 class IConfig(ABC):
     """
-    An abstract base class that defines an interface for classes that must have
-    a `config` attribute.
+    Abstract base class for configuration holders.
 
-    The subclass is required to implement the `config` attribute, which should be
-    a dataclass instance representing the configuration data.
+    This interface enforces the presence of a `config` attribute in subclasses,
+    which must return a dataclass instance containing configuration data.
 
     Attributes
     ----------
     config : object
-        A dataclass instance representing the configuration.
+        Dataclass instance representing the configuration data.
     """
 
     @property
     @abstractmethod
     def config(self):
         """
-        Should return a dataclass instance representing the configuration.
+        Get the configuration dataclass instance.
+
+        Returns
+        -------
+        object
+            Dataclass instance containing the configuration data.
+
+        Notes
+        -----
+        Subclasses must implement this property to provide access to their configuration.
         """
         pass

orionis/foundation/providers/console_provider.py

@@ -4,36 +4,37 @@ from orionis.container.providers.service_provider import ServiceProvider
 
 class ConsoleProvider(ServiceProvider):
     """
-    ConsoleProvider
-    ===============
-
-    Registers the console output service in the application container.
-    Provides access to various console output features, including information, warnings, errors, debug messages, tables, confirmations, and password prompts.
-
-    Methods
-    -------
-    register()
-        Registers the console service in the application container.
-    boot()
-        Performs post-registration initialization if needed.
+    Provides and registers the console output service within the application container.
+
+    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.
     """
 
     def register(self) -> None:
         """
-        Registers the console service in the application container.
+        Register the console output service in the application container.
+
+        Binds the IConsole interface to the Console implementation as a transient service,
+        with the alias "core.orionis.console".
 
         Returns
         -------
         None
         """
+
         self.app.transient(IConsole, Console, alias="core.orionis.console")
 
     def boot(self) -> None:
         """
-        Performs post-registration initialization if needed.
+        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.
 
         Returns
         -------
         None
         """
-        pass
+
+        pass

orionis/foundation/providers/dumper_provider.py

@@ -4,36 +4,48 @@ from orionis.container.providers.service_provider import ServiceProvider
 
 class DumperProvider(ServiceProvider):
     """
-    DumperProvider
-    ==============
+    Service provider for registering the debug message service.
 
-    Registers the debug message service in the application container.
-    Provides access to debug message printing, error reporting, and other console diagnostics.
+    This provider registers the debug service in the application container,
+    enabling debug message printing, error reporting, and console diagnostics.
+
+    Attributes
+    ----------
+    app : Application
+        The application container instance where services are registered.
 
     Methods
     -------
     register()
-        Registers the debug service in the application container.
+        Register the debug service in the application container.
     boot()
-        Performs post-registration initialization if needed.
+        Perform post-registration initialization if required.
     """
 
     def register(self) -> None:
         """
-        Registers the debug service in the application container.
+        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".
 
         Returns
         -------
         None
         """
+
         self.app.transient(IDebug, Debug, alias="core.orionis.dumper")
 
     def boot(self) -> None:
         """
-        Performs post-registration initialization if needed.
+        Perform post-registration initialization if required.
+
+        This method is a placeholder for any initialization logic that
+        should occur after the service has been registered.
 
         Returns
         -------
         None
         """
+
         pass

orionis/foundation/providers/logger_provider.py

@@ -4,36 +4,41 @@ from orionis.services.log.log_service import LoggerService
 
 class LoggerProvider(ServiceProvider):
     """
-    LoggerProvider
-    ==============
-
-    Registers the logging service in the application container.
-    Provides a `LoggerService` instance for application-wide logging.
-
-    Methods
-    -------
-    register()
-        Registers the logging service in the application container.
-    boot()
-        Performs post-registration initialization if needed.
+    Provides and registers the logging service within the application container.
+
+    This provider binds an implementation of `ILoggerService` to the application,
+    making a `LoggerService` instance available for application-wide logging.
+
+    Attributes
+    ----------
+    app : Application
+        The application container instance where services are registered.
     """
 
     def register(self) -> None:
         """
-        Registers the logging service in the application container.
+        Register the logging service in the application container.
+
+        This method binds the `LoggerService` implementation to the `ILoggerService`
+        contract in the application container, using the application's logging configuration.
 
         Returns
         -------
         None
         """
+
         self.app.instance(ILoggerService, LoggerService(self.app.config('logging')), alias="core.orionis.logger")
 
     def boot(self) -> None:
         """
-        Performs post-registration initialization if needed.
+        Perform post-registration initialization for the logging service.
+
+        This method is a placeholder for any additional setup required after
+        the logging service has been registered.
 
         Returns
         -------
         None
         """
+
         pass

orionis/foundation/providers/path_resolver_provider.py

@@ -4,37 +4,40 @@ from orionis.services.paths.resolver import Resolver
 
 class PathResolverProvider(ServiceProvider):
     """
-    PathResolverProvider
-    ===================
-
     Registers the path resolution service in the application container.
-    Provides compatibility with the file system for resolving paths.
-
-    Methods
-    -------
-    register()
-        Registers the path resolver service in the application container.
-    boot()
-        Performs post-registration initialization if needed.
-    """
 
+    This provider binds the `IResolver` interface to the `Resolver` implementation,
+    allowing the application to resolve file system paths through dependency injection.
+
+    Attributes
+    ----------
+    app : Application
+        The application container instance inherited from ServiceProvider.
+    """
 
     def register(self) -> None:
         """
-        Registers the path resolver service in the application container.
+        Register the path resolver service in the application container.
+
+        Binds the `IResolver` interface to the `Resolver` implementation as a transient
+        service, with the alias "core.orionis.path_resolver".
 
         Returns
         -------
         None
         """
+
         self.app.transient(IResolver, Resolver, alias="core.orionis.path_resolver")
 
     def boot(self) -> None:
         """
-        Performs post-registration initialization if needed.
+        Perform post-registration initialization if needed.
+
+        This method is a placeholder for any actions required after service registration.
 
         Returns
         -------
         None
         """
+
         pass

orionis/foundation/providers/progress_bar_provider.py

@@ -4,36 +4,37 @@ from orionis.container.providers.service_provider import ServiceProvider
 
 class ProgressBarProvider(ServiceProvider):
     """
-    ProgressBarProvider
-    ===================
-
-    Registers the dynamic progress bar service in the application container.
-    Provides a console progress bar for visual feedback during operations.
-
-    Methods
-    -------
-    register()
-        Registers the progress bar service in the application container.
-    boot()
-        Performs post-registration initialization if needed.
+    Service provider for registering the dynamic progress bar.
+
+    This provider registers the `IProgressBar` interface with the `ProgressBar`
+    implementation in the application container, allowing for dependency injection
+    and usage of a console-based progress bar for visual feedback during operations.
     """
 
     def register(self) -> None:
         """
-        Registers the progress bar service in the application container.
+        Register the progress bar service in the application container.
+
+        Registers the `IProgressBar` interface to resolve to the `ProgressBar`
+        implementation, with the alias "core.orionis.progress_bar".
 
         Returns
         -------
         None
         """
+
         self.app.transient(IProgressBar, ProgressBar, alias="core.orionis.progress_bar")
 
     def boot(self) -> None:
         """
-        Performs post-registration initialization if needed.
+        Perform post-registration initialization.
+
+        This method is called after all providers have been registered. No additional
+        initialization is required for the progress bar service.
 
         Returns
         -------
         None
         """
+
         pass

orionis/foundation/providers/testing_provider.py

@@ -4,36 +4,42 @@ from orionis.test.core.unit_test import UnitTest
 
 class TestingProvider(ServiceProvider):
     """
-    TestingProvider
-    ===============
-
-    Registers the unit testing environment service in the application container.
-    Provides a native unit testing framework for Orionis with features beyond common frameworks.
-
-    Methods
-    -------
-    register()
-        Registers the unit testing service in the application container.
-    boot()
-        Performs post-registration initialization if needed.
+    Provides and registers the unit testing environment service in the application container.
+
+    This provider integrates a native unit testing framework for Orionis,
+    enabling advanced testing features and registering the service as a singleton
+    within the application's dependency injection container.
+
+    Attributes
+    ----------
+    app : Application
+        The application container instance where services are registered.
     """
 
     def register(self) -> None:
         """
-        Registers the unit testing service in the application container.
+        Register the unit testing service in the application container.
+
+        Registers the IUnitTest interface to the UnitTest implementation as a singleton,
+        with the alias "core.orionis.testing".
 
         Returns
         -------
         None
         """
+
         self.app.singleton(IUnitTest, UnitTest, alias="core.orionis.testing")
 
     def boot(self) -> None:
         """
-        Performs post-registration initialization if needed.
+        Perform post-registration initialization if required.
+
+        This method is intended for any setup needed after service registration.
+        Currently, no additional initialization is performed.
 
         Returns
         -------
         None
         """
+
         pass

orionis/foundation/providers/workers_provider.py

@@ -4,36 +4,41 @@ from orionis.services.system.workers import Workers
 
 class WorkersProvider(ServiceProvider):
     """
-    WorkersProvider
-    ===============
-
-    Registers the worker management service in the application container.
-    Determines the optimal number of workers to start based on system analysis.
-
-    Methods
-    -------
-    register()
-        Registers the worker service in the application container.
-    boot()
-        Performs post-registration initialization if needed.
+    Provides and registers the worker management service within the application container.
+
+    This provider determines and registers the optimal worker management implementation,
+    making it available for dependency injection throughout the application.
+
+    Attributes
+    ----------
+    app : Application
+        The application container instance where services are registered.
     """
 
     def register(self) -> None:
         """
-        Registers the worker service in the application container.
+        Register the worker service in the application container.
+
+        Registers the `Workers` implementation as a transient service for the `IWorkers`
+        contract, with the alias "core.orionis.workers".
 
         Returns
         -------
         None
         """
+
         self.app.transient(IWorkers, Workers, alias="core.orionis.workers")
 
     def boot(self) -> None:
         """
-        Performs post-registration initialization if needed.
+        Perform post-registration initialization if required.
+
+        This method is a placeholder for any initialization logic that should occur
+        after the worker service has been registered.
 
         Returns
         -------
         None
         """
+
         pass

orionis/metadata/framework.py

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

orionis/services/asynchrony/contracts/coroutines.py

@@ -9,24 +9,20 @@ class ICoroutine(ABC):
     @abstractmethod
     def run(self) -> Union[T, asyncio.Future]:
         """
-        Executes the wrapped coroutine, either synchronously or asynchronously depending on the context.
-
-        Parameters
-        ----------
-        None
+        Execute the wrapped coroutine either synchronously or asynchronously, depending on the execution context.
 
         Returns
         -------
         T or asyncio.Future
-            If called outside an event loop, returns the result of the coroutine execution (type T).
+            If called outside of an event loop, returns the result of the coroutine execution (type T).
             If called within an event loop, returns an asyncio.Future representing the scheduled coroutine.
 
         Notes
         -----
-        - When invoked outside of an event loop, the coroutine is executed synchronously and its result is returned.
-        - When invoked inside an event loop, the coroutine is scheduled for asynchronous execution and a Future is returned.
+        - Executes the coroutine synchronously and returns its result when called outside an event loop.
+        - Schedules the coroutine for asynchronous execution and returns a Future when called inside an event loop.
         - The caller is responsible for awaiting the Future if asynchronous execution is used.
         """
 
         # This method should be implemented by subclasses to handle coroutine execution.
-        pass
+        pass

orionis/services/asynchrony/coroutines.py

@@ -10,28 +10,19 @@ class Coroutine(ICoroutine):
 
     def __init__(self, func: TypingCoroutine[Any, Any, T]) -> None:
         """
-        Initialize the Coroutine wrapper.
+        Wraps a coroutine object and validates its type.
 
         Parameters
         ----------
         func : Coroutine
-            The coroutine object to be wrapped. Must be an awaitable coroutine.
+            The coroutine object to be wrapped and managed.
 
         Raises
         ------
         OrionisCoroutineException
             If the provided object is not a coroutine.
-
-        Returns
-        -------
-        None
-            This method does not return a value.
-
-        Notes
-        -----
-        This constructor validates that the provided object is a coroutine using the framework's type introspection.
-        If the validation fails, an exception is raised to prevent improper usage.
         """
+
         # Validate that the provided object is a coroutine
         if not Type(func).isCoroutine():
             raise OrionisCoroutineException(
@@ -43,17 +34,12 @@ class Coroutine(ICoroutine):
 
     def run(self) -> Union[T, asyncio.Future]:
         """
-        Executes the wrapped coroutine, either synchronously or asynchronously depending on the context.
-
-        Parameters
-        ----------
-        None
+        Executes the wrapped coroutine, adapting to the current event loop context.
 
         Returns
         -------
         T or asyncio.Future
-            If called outside an event loop, returns the result of the coroutine after synchronous execution.
-            If called within an event loop, returns an asyncio.Future representing the scheduled coroutine.
+            The result of the coroutine if executed synchronously, or an asyncio.Future if scheduled asynchronously.
 
         Raises
         ------
@@ -62,10 +48,11 @@ class Coroutine(ICoroutine):
 
         Notes
         -----
-        - When invoked outside an active event loop, the coroutine is executed synchronously and its result is returned.
-        - When invoked inside an active event loop, the coroutine is scheduled for asynchronous execution and a Future is returned.
-        - This method automatically detects the execution context and chooses the appropriate execution strategy.
+        - If called outside an active event loop, the coroutine is executed synchronously and its result is returned.
+        - If called within an active event loop, the coroutine is scheduled for asynchronous execution and a Future is returned.
+        - The method automatically detects the execution context and chooses the appropriate execution strategy.
         """
+
         # Attempt to get the currently running event loop
         try:
             loop = asyncio.get_running_loop()
@@ -80,4 +67,4 @@ class Coroutine(ICoroutine):
 
         # If no event loop is running, execute the coroutine synchronously using the loop
         else:
-            return loop.run_until_complete(self.__func)
+            return loop.run_until_complete(self.__func)

orionis/services/asynchrony/exceptions/exception.py

@@ -2,12 +2,12 @@ class OrionisCoroutineException(Exception):
 
     def __init__(self, msg: str):
         """
-        Initializes an OrionisCoroutineException with a descriptive error message.
+        Initialize the OrionisCoroutineException.
 
         Parameters
         ----------
         msg : str
-            Descriptive error message explaining the cause of the exception.
+            A descriptive error message explaining the cause of the exception.
         """
 
         # Call the base Exception constructor with the provided message
@@ -15,7 +15,7 @@ class OrionisCoroutineException(Exception):
 
     def __str__(self) -> str:
         """
-        Returns a formatted string representation of the exception message.
+        Return the string representation of the exception.
 
         Returns
         -------

orionis/services/environment/contracts/caster.py

@@ -10,24 +10,23 @@ class IEnvironmentCaster(ABC):
         Parameters
         ----------
         type_hint : str
-            The type hint to set, which must be one of the valid options defined in OPTIONS.
+            The type hint to assign. Must be one of the valid options defined in OPTIONS.
 
         Raises
         ------
         OrionisEnvironmentValueError
-            If the provided type hint is not one of the valid options.
+            If the provided type hint is not among the valid options.
         """
         pass
 
     @abstractmethod
     def get(self):
         """
-        Returns the value corresponding to the specified type hint.
+        Retrieve the value corresponding to the specified type hint.
 
-        Checks if the provided type hint is valid and then dispatches the call to the appropriate
-        method for handling the type.
-
-        Supported type hints include: 'path:', 'str:', 'int:', 'float:', 'bool:', 'list:', 'dict:', 'tuple:', and 'set:'.
+        Checks the validity of the provided type hint and dispatches the call to the appropriate
+        handler for the type. Supported type hints include: 'path:', 'str:', 'int:', 'float:',
+        'bool:', 'list:', 'dict:', 'tuple:', and 'set:'.
 
         Returns
         -------
@@ -37,6 +36,6 @@ class IEnvironmentCaster(ABC):
         Raises
         ------
         OrionisEnvironmentValueError
-            If the type hint is not one of the supported options.
+            If the type hint is not supported.
         """
-        pass
+        pass