orionis 0.652.0__py3-none-any.whl → 0.654.0__py3-none-any.whl

orionis/container/container.py

@@ -88,37 +88,38 @@ class Container(IContainer):
 
     def __init__(self) -> None:
         """
-        Initializes a new instance of the container.
+        Initializes the internal state of the container instance.
 
-        This constructor sets up the internal dictionaries for bindings and aliases,
-        ensuring that these are only initialized once per instance. The initialization
-        is guarded by checking if the instance already has the required attributes.
+        This constructor sets up the internal dictionaries for service bindings, aliases,
+        singleton cache, and resolution cache. Initialization is performed only once per
+        instance, even if `__init__` is called multiple times due to inheritance or other
+        instantiation patterns. The container also registers itself under the `IContainer`
+        interface for dependency injection.
 
         Notes
         -----
-        - The `__bindings` dictionary is used to store service bindings.
-        - The `__aliases` dictionary is used to store service aliases.
-        - Initialization occurs only once per instance, regardless of how many times __init__ is called.
-        - The container registers itself under the IContainer interface to allow for dependency injection.
+        - The `__bindings` dictionary stores service bindings by abstract type.
+        - The `__aliases` dictionary maps aliases to their corresponding bindings.
+        - The `__singleton_cache` dictionary caches singleton instances.
+        - The `__resolution_cache` dictionary tracks types being resolved to prevent circular dependencies.
+        - Initialization is guarded to ensure it only occurs once per instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
         """
 
-        # Check if the instance has already been initialized
+        # Only initialize if this instance hasn't been initialized before
         if not hasattr(self, '_Container__initialized'):
 
-            # Current Project Namespaces
-            # Get current project namespace from the working directory
-            current_project_namespace = Path().cwd().name
+            # Set up the container's internal dictionaries for service management
+            self.__bindings = {}          # Stores service bindings by abstract type
+            self.__aliases = {}           # Maps aliases to bindings
+            self.__resolution_cache = {}  # Tracks types currently being resolved
+            self.__singleton_cache = {}   # Caches singleton instances
 
-            # Add the current project namespace to valid namespaces
-            self.__valid_namespaces = set(('app', 'orionis', 'requests', 'rich', 'apscheduler', 'dotenv', current_project_namespace))
-
-            # Initialize the container's internal state
-            self.__bindings = {}
-            self.__aliases = {}
-            self.__resolution_cache = {}
-            self.__singleton_cache = {}
-
-            # Mark this instance as initialized
+            # Mark this instance as initialized to prevent re-initialization
             self.__initialized = True
 
     def __handleSyncAsyncResult(
@@ -487,6 +488,12 @@ class Container(IContainer):
         """
         Registers a service with a transient lifetime.
 
+        This method binds a concrete implementation to an abstract base type or interface
+        in the container, ensuring that a new instance of the concrete class is created
+        each time the service is requested. It validates the abstract and concrete types,
+        enforces decoupling rules if specified, checks that all abstract methods are implemented,
+        and manages service aliases.
+
         Parameters
         ----------
         abstract : Callable[..., Any]
@@ -497,13 +504,14 @@ class Container(IContainer):
             An alternative name to register the service under. If not provided, a default alias is generated
             using the abstract's module and class name.
         enforce_decoupling : bool, optional
-            If True, enforces that the concrete class does NOT inherit from the abstract class. If False,
-            requires that the concrete class is a subclass of the abstract.
+            If True, enforces that the concrete class does NOT inherit from the abstract class.
+            If False, requires that the concrete class is a subclass of the abstract.
 
         Returns
         -------
         bool or None
-            Returns True if the service was registered successfully. Returns None if registration fails.
+            Returns True if the service was registered successfully.
+            Returns None if registration fails due to an exception.
 
         Raises
         ------
@@ -514,11 +522,12 @@ class Container(IContainer):
 
         Notes
         -----
-        This method registers the given concrete implementation to the abstract type with a transient lifetime,
-        meaning a new instance will be created each time the service is requested. The method validates the
-        abstract and concrete types, checks decoupling rules, ensures all abstract methods are implemented,
-        and manages service aliases. If a service is already registered under the same abstract or alias,
-        it is removed before registering the new binding.
+        - Registers the given concrete implementation to the abstract type with a transient lifetime,
+          meaning a new instance will be created each time the service is requested.
+        - Validates the abstract and concrete types, checks decoupling rules, ensures all abstract methods
+          are implemented, and manages service aliases.
+        - If a service is already registered under the same abstract or alias, it is removed before registering
+          the new binding.
         """
 
         try:
@@ -529,11 +538,10 @@ class Container(IContainer):
             # Ensure that concrete is a concrete class
             ReflectionConcrete.ensureIsConcreteClass(concrete)
 
-            # Ensure that concrete is NOT a subclass of abstract if decoupling is enforced,
-            # otherwise ensure it is a subclass
+            # Enforce decoupling or subclass relationship as specified
             self.__decouplingCheck(abstract, concrete, enforce_decoupling)
 
-            # Ensure that all abstract methods are implemented by the concrete class
+            # Ensure all abstract methods are implemented by the concrete class
             self.__implementsAbstractMethods(
                 abstract=abstract,
                 concrete=concrete
@@ -581,7 +589,8 @@ class Container(IContainer):
         This method validates the abstract type, the instance, and the alias (if provided).
         It ensures that the instance is a valid implementation of the abstract class or interface,
         optionally enforces decoupling, and registers the instance in the container under both
-        the abstract type and the alias.
+        the abstract type and the alias. The registered instance will be shared across all resolutions
+        of the abstract type or alias.
 
         Parameters
         ----------
@@ -614,7 +623,7 @@ class Container(IContainer):
         -----
         - The instance is registered with singleton lifetime, meaning it will be shared
           across all resolutions of the abstract type or alias.
-        - The method ensures that all abstract methods are implemented by the instance.
+        - All abstract methods must be implemented by the instance.
         - If a service is already registered under the same abstract or alias, it is removed
           before registering the new instance.
         """
@@ -639,7 +648,7 @@ class Container(IContainer):
             # Validate and generate the alias key (either provided or default)
             alias = self.__makeAliasKey(abstract, alias)
 
-            # If the service is already registered, remove the existing binding
+            # Remove any existing binding for this abstract or alias
             self.drop(abstract, alias)
 
             # Register the instance with singleton lifetime
@@ -664,14 +673,6 @@ class Container(IContainer):
                 f"Unexpected error registering instance: {e}"
             ) from e
 
-
-
-
-
-
-
-
-
     def singleton(
         self,
         abstract: Callable[..., Any],
@@ -683,76 +684,91 @@ class Container(IContainer):
         """
         Registers a service with a singleton lifetime.
 
+        This method binds a concrete implementation to an abstract base type or interface
+        in the container, ensuring that only one instance of the concrete class is created
+        and shared throughout the application's lifetime. It validates the abstract and
+        concrete types, enforces decoupling rules if specified, checks that all abstract
+        methods are implemented, and manages service aliases.
+
         Parameters
         ----------
         abstract : Callable[..., Any]
-            The abstract base type or interface to be bound.
+            The abstract base type or interface to be bound. Must be an abstract class or interface.
         concrete : Callable[..., Any]
-            The concrete implementation to associate with the abstract type.
+            The concrete implementation to associate with the abstract type. Must be a concrete class.
         alias : str, optional
-            An alternative name to register the service under. If not provided, the abstract's class name is used.
+            An alternative name to register the service under. If not provided, a default alias is generated
+            using the abstract's module and class name.
+        enforce_decoupling : bool, optional
+            If True, enforces that the concrete class does NOT inherit from the abstract class.
+            If False, requires that the concrete class is a subclass of the abstract.
 
         Returns
         -------
-        bool
-            True if the service was registered successfully.
+        bool or None
+            Returns True if the service was registered successfully.
+            Returns None if registration fails due to an exception.
 
         Raises
         ------
         OrionisContainerTypeError
-            If the abstract or concrete class checks fail.
+            If the abstract or concrete class validation fails.
         OrionisContainerException
-            If the concrete class inherits from the abstract class.
+            If the decoupling check fails or if an unexpected error occurs during registration.
 
         Notes
         -----
-        Registers the given concrete implementation to the abstract type with a singleton lifetime,
-        meaning a single instance will be created and shared. Optionally, an alias can be provided for registration.
+        - Registers the given concrete implementation to the abstract type with a singleton lifetime,
+          meaning a single instance will be created and shared for all resolutions.
+        - If a service is already registered under the same abstract or alias, it is removed before registering the new binding.
+        - All abstract methods must be implemented by the concrete class.
+        - Aliases are validated and managed for lookup.
         """
 
-        # Ensure that abstract is an abstract class
-        IsAbstractClass(abstract, Lifetime.SINGLETON)
+        try:
 
-        # Ensure that concrete is a concrete class
-        IsConcreteClass(concrete, Lifetime.SINGLETON)
+            # Ensure that abstract is an abstract class
+            ReflectionAbstract.ensureIsAbstractClass(abstract)
 
-        # Ensure that concrete is NOT a subclass of abstract
-        if enforce_decoupling:
-            IsNotSubclass(abstract, concrete)
+            # Ensure that concrete is a concrete class
+            ReflectionConcrete.ensureIsConcreteClass(concrete)
 
-        # Validate that concrete is a subclass of abstract
-        else:
-            IsSubclass(abstract, concrete)
+            # Enforce decoupling or subclass relationship as specified
+            self.__decouplingCheck(abstract, concrete, enforce_decoupling)
 
-        # Ensure implementation
-        ImplementsAbstractMethods(
-            abstract=abstract,
-            concrete=concrete
-        )
+            # Ensure all abstract methods are implemented by the concrete class
+            self.__implementsAbstractMethods(
+                abstract=abstract,
+                concrete=concrete
+            )
 
-        # Ensure that the alias is a valid string if provided
-        if alias:
-            IsValidAlias(alias)
-        else:
-            alias = f"{abstract.__module__}.{abstract.__name__}"
+            # Validate and generate the alias key (either provided or default)
+            alias = self.__makeAliasKey(abstract, alias)
 
-        # If the service is already registered, drop it
-        self.drop(abstract, alias)
+            # If the service is already registered, remove the existing binding
+            self.drop(abstract, alias)
 
-        # Register the service with singleton lifetime
-        self.__bindings[abstract] = Binding(
-            contract = abstract,
-            concrete = concrete,
-            lifetime = Lifetime.SINGLETON,
-            enforce_decoupling = enforce_decoupling,
-            alias = alias
-        )
+            # Register the service with singleton lifetime
+            self.__bindings[abstract] = Binding(
+                contract = abstract,
+                concrete = concrete,
+                lifetime = Lifetime.SINGLETON,
+                enforce_decoupling = enforce_decoupling,
+                alias = alias
+            )
 
-        # Register the alias
-        self.__aliases[alias] = self.__bindings[abstract]
+            # Register the alias for lookup
+            self.__aliases[alias] = self.__bindings[abstract]
 
-        # Return True to indicate successful registration
-        return True
+            # Return True to indicate successful registration
+            return True
+
+        except Exception as e:
+
+            # Raise a container exception with details if registration fails
+            raise OrionisContainerException(
+                f"Unexpected error registering {Lifetime.SINGLETON} service: {e}"
+            ) from e
 
     def scoped(
         self,
@@ -765,76 +781,101 @@ class Container(IContainer):
         """
         Registers a service with a scoped lifetime.
 
+        This method binds a concrete implementation to an abstract base type or interface
+        in the container, ensuring that a new instance of the concrete class is created
+        for each scope context. It validates the abstract and concrete types, enforces
+        decoupling rules if specified, checks that all abstract methods are implemented,
+        and manages service aliases.
+
         Parameters
         ----------
         abstract : Callable[..., Any]
-            The abstract base type or interface to be bound.
+            The abstract base type or interface to be bound. Must be an abstract class or interface.
         concrete : Callable[..., Any]
-            The concrete implementation to associate with the abstract type.
+            The concrete implementation to associate with the abstract type. Must be a concrete class.
         alias : str, optional
-            An alternative name to register the service under. If not provided, the abstract's class name is used.
+            An alternative name to register the service under. If not provided, a default alias is generated
+            using the abstract's module and class name.
+        enforce_decoupling : bool, optional
+            If True, enforces that the concrete class does NOT inherit from the abstract class.
+            If False, requires that the concrete class is a subclass of the abstract.
 
         Returns
         -------
-        bool
-            True if the service was registered successfully.
+        bool or None
+            Returns True if the service was registered successfully.
+            Returns None if registration fails due to an exception.
 
         Raises
         ------
         OrionisContainerTypeError
-            If the abstract or concrete class checks fail.
+            If the abstract or concrete class validation fails.
         OrionisContainerException
-            If the concrete class inherits from the abstract class.
+            If the decoupling check fails or if an unexpected error occurs during registration.
 
         Notes
         -----
-        Registers the given concrete implementation to the abstract type with a scoped lifetime,
-        meaning a new instance will be created per scope. Optionally, an alias can be provided for registration.
+        - Registers the given concrete implementation to the abstract type with a scoped lifetime,
+          meaning a new instance will be created for each scope context.
+        - Validates the abstract and concrete types, checks decoupling rules, ensures all abstract methods
+          are implemented, and manages service aliases.
+        - If a service is already registered under the same abstract or alias, it is removed before registering
+          the new binding.
         """
 
-        # Ensure that abstract is an abstract class
-        IsAbstractClass(abstract, Lifetime.SCOPED)
+        try:
+
+            # Ensure that abstract is an abstract class
+            ReflectionAbstract.ensureIsAbstractClass(abstract)
+
+            # Ensure that concrete is a concrete class
+            ReflectionConcrete.ensureIsConcreteClass(concrete)
+
+            # Enforce decoupling or subclass relationship as specified
+            self.__decouplingCheck(abstract, concrete, enforce_decoupling)
+
+            # Ensure all abstract methods are implemented by the concrete class
+            self.__implementsAbstractMethods(
+                abstract=abstract,
+                concrete=concrete
+            )
+
+            # Validate and generate the alias key (either provided or default)
+            alias = self.__makeAliasKey(abstract, alias)
+
+            # If the service is already registered, remove the existing binding
+            self.drop(abstract, alias)
+
+            # Register the service with scoped lifetime
+            self.__bindings[abstract] = Binding(
+                contract = abstract,
+                concrete = concrete,
+                lifetime = Lifetime.SCOPED,
+                enforce_decoupling = enforce_decoupling,
+                alias = alias
+            )
+
+            # Register the alias for lookup
+            self.__aliases[alias] = self.__bindings[abstract]
+
+            # Return True to indicate successful registration
+            return True
+
+        except Exception as e:
+
+            # Raise a container exception with details if registration fails
+            raise OrionisContainerException(
+                f"Unexpected error registering {Lifetime.SCOPED} service: {e}"
+            ) from e
 
-        # Ensure that concrete is a concrete class
-        IsConcreteClass(concrete, Lifetime.SCOPED)
 
-        # Ensure that concrete is NOT a subclass of abstract
-        if enforce_decoupling:
-            IsNotSubclass(abstract, concrete)
 
-        # Validate that concrete is a subclass of abstract
-        else:
-            IsSubclass(abstract, concrete)
 
-        # Ensure implementation
-        ImplementsAbstractMethods(
-            abstract=abstract,
-            concrete=concrete
-        )
 
-        # Ensure that the alias is a valid string if provided
-        if alias:
-            IsValidAlias(alias)
-        else:
-            alias = f"{abstract.__module__}.{abstract.__name__}"
 
-        # If the service is already registered, drop it
-        self.drop(abstract, alias)
 
-        # Register the service with scoped lifetime
-        self.__bindings[abstract] = Binding(
-            contract = abstract,
-            concrete = concrete,
-            lifetime = Lifetime.SCOPED,
-            enforce_decoupling = enforce_decoupling,
-            alias = alias
-        )
 
-        # Register the alias
-        self.__aliases[alias] = self.__bindings[abstract]
 
-        # Return True to indicate successful registration
-        return True
 
     def scopedInstance(
         self,
@@ -1635,6 +1676,7 @@ class Container(IContainer):
             The singleton instance to store cross-references for.
         """
 
+        # Determine the primary cache key for this binding
         primary_key = self.__getSingletonCacheKey(binding)
 
         # Store cross-reference for contract if it's not the primary key
@@ -1997,6 +2039,7 @@ class Container(IContainer):
         """
 
         try:
+
             # If there are no dependencies, return empty dict
             if not dependencies:
                 return {}
@@ -2013,6 +2056,7 @@ class Container(IContainer):
             for param_name, dep in dependencies.resolved.items():
                 params[param_name] = self.__resolveSingleDependency(name, param_name, dep)
 
+            # Return the dictionary of resolved parameters
             return params
 
         except Exception as e:
@@ -2146,43 +2190,61 @@ class Container(IContainer):
         **kwargs
     ) -> Any:
         """
-        Forces resolution of a type whether it's registered in the container or not.
+        Resolves and instantiates a type or callable regardless of its registration in the container.
+
+        This method attempts to instantiate or invoke the provided type or callable, even if it is not
+        registered in the container. It first tries direct instantiation/invocation if arguments are provided,
+        then attempts auto-resolution for eligible types, and finally falls back to reflection-based instantiation.
+        If the type cannot be resolved by any means, an exception is raised.
 
         Parameters
         ----------
         type_ : Callable[..., Any]
-            The type or callable to resolve.
+            The class or callable to resolve and instantiate.
         *args : tuple
-            Positional arguments to pass to the constructor/callable.
+            Positional arguments to pass to the constructor or callable.
         **kwargs : dict
-            Keyword arguments to pass to the constructor/callable.
+            Keyword arguments to pass to the constructor or callable.
 
         Returns
         -------
         Any
-            The resolved instance.
+            The instantiated object or the result of the callable. If the type is a class, a new instance is returned.
+            If the type is a callable, the result of its invocation is returned.
 
         Raises
         ------
         OrionisContainerException
-            If the type cannot be resolved.
+            If the type cannot be resolved, is not a concrete class or callable, or if an error occurs during instantiation.
+
+        Notes
+        -----
+        - Direct instantiation/invocation is prioritized when arguments are provided.
+        - Auto-resolution is attempted for types eligible for automatic dependency resolution.
+        - Reflection-based instantiation is used as a fallback for concrete classes or callables.
+        - If none of the resolution strategies succeed, an exception is raised.
         """
+
         try:
-            # If args or kwargs are provided, use them directly
+
+            # If explicit arguments are provided, attempt direct instantiation or invocation
             if args or kwargs:
                 if isinstance(type_, type):
+                    # Instantiate the class directly with provided arguments
                     return type_(*args, **kwargs)
                 elif callable(type_):
+                    # Invoke the callable directly with provided arguments
                     return type_(*args, **kwargs)
 
-            # Try auto-resolution first for unregistered types
+            # Attempt auto-resolution for eligible types
             if self.__canAutoResolve(type_):
                 return self.__autoResolve(type_)
 
-            # Use the unified reflection-based instantiation
+            # Use reflection-based instantiation for concrete classes
             if ReflectionConcrete.isConcreteClass(type_):
                 return self.__instantiateWithReflection(type_, is_class=True)
 
+            # Use reflection-based invocation for callables that are not classes
             if callable(type_) and not isinstance(type_, type):
                 return self.__instantiateWithReflection(type_, is_class=False)
 
@@ -2192,9 +2254,12 @@ class Container(IContainer):
             )
 
         except Exception as e:
+
+            # Re-raise container exceptions directly
             if isinstance(e, OrionisContainerException):
                 raise e from None
 
+            # Wrap other exceptions in an OrionisContainerException with context
             raise OrionisContainerException(
                 f"Error resolving '{getattr(type_, '__name__', str(type_))}': {str(e)}"
             ) from e
@@ -2259,26 +2324,34 @@ class Container(IContainer):
 
     def __isValidNamespace(self, type_: type) -> bool:
         """
-        Checks if a type belongs to a valid namespace for auto-resolution.
+        Determines if a type belongs to a valid namespace for auto-resolution.
+
+        This method checks whether the provided type is defined within one of the namespaces
+        considered valid for automatic dependency resolution by the container. Valid namespaces
+        are typically application-specific modules or packages that are explicitly allowed
+        for auto-resolution. Built-in types and types from external libraries are excluded.
 
         Parameters
         ----------
         type_ : type
-            The type to check for valid namespace.
+            The type to check for valid namespace membership.
 
         Returns
         -------
         bool
-            True if the type belongs to a valid namespace, False otherwise.
-        """
+            True if the type belongs to a valid namespace (i.e., its `__module__` attribute
+            matches one of the namespaces in `self.__valid_namespaces`), otherwise False.
 
-        # Verify that the module name starts with any of the valid namespace prefixes
-        if hasattr(type_, '__module__'):
-            module_name = type_.__module__
-            return any(module_name.startswith(namespace) for namespace in self.__valid_namespaces)
+        Notes
+        -----
+        - The method relies on the presence of the `__module__` attribute on the type.
+        - If the type does not have a `__module__` attribute, it cannot be considered valid.
+        - The set of valid namespaces is initialized in the container and may include
+          application modules, framework modules, and the current project namespace.
+        """
 
-        # If the type has no module information, it cannot be auto-resolved
-        return False
+        # Ensure the type has a __module__ attribute before checking namespace validity
+        return hasattr(type_, '__module__')
 
     def __isInstantiable(self, type_: type) -> bool:
         """
@@ -2330,6 +2403,7 @@ class Container(IContainer):
                 return self.__canQuickInstantiate(type_)
 
         except Exception:
+
             # If any check fails with an exception, consider it non-instantiable
             return False
 
@@ -2354,22 +2428,31 @@ class Container(IContainer):
 
         # Check if it inherits from ABC (safely)
         try:
+
+            # Check if it inherits from abc.ABC
             if issubclass(type_, abc.ABC):
                 return True
+
+        # type_ is not a class, so it can't be abstract
         except TypeError:
-            # type_ is not a class, so it can't be abstract
             pass
 
         # Check if it has abstract methods
         try:
             # Try to get abstract methods using reflection
             for attr_name in dir(type_):
+
+                # Get the attribute
                 attr = getattr(type_, attr_name)
+
+                # Check if the attribute is marked as an abstract method
                 if hasattr(attr, '__isabstractmethod__') and attr.__isabstractmethod__:
                     return True
+
         except Exception:
             pass
 
+        # If none of the checks matched, it's not abstract
         return False
 
     def __isGenericType(self, type_: type) -> bool:
@@ -2403,6 +2486,7 @@ class Container(IContainer):
         if hasattr(typing, 'TypeVar') and isinstance(type_, typing.TypeVar):
             return True
 
+        # If none of the checks matched, it's not a generic type
         return False
 
     def __isProtocolOrTyping(self, type_: type) -> bool:
@@ -2435,9 +2519,12 @@ class Container(IContainer):
 
         # Check for common typing constructs that shouldn't be instantiated
         typing_constructs = ['Union', 'Optional', 'Any', 'Callable', 'Type']
+
+        # If the type's name matches a known typing construct, it's not instantiable
         if hasattr(type_, '__name__') and type_.__name__ in typing_constructs:
             return True
 
+        # If none of the checks matched, it's not a protocol or typing construct
         return False
 
     def __hasRequiredConstructorParams(self, type_: type) -> bool:
@@ -2499,6 +2586,7 @@ class Container(IContainer):
         """
 
         try:
+
             # For safety, first check if the constructor signature suggests it's safe to instantiate
             try:
 
@@ -2523,8 +2611,10 @@ class Container(IContainer):
             # Attempt to create an instance only if it seems safe
             instance = type_()
 
-            # If successful, clean up and return True
+            # If successful, clean up
             del instance
+
+            # Return True if instantiation succeeded
             return True
 
         except Exception:
@@ -2569,6 +2659,7 @@ class Container(IContainer):
             )
 
         try:
+
             # Mark this type as being resolved to prevent circular dependencies
             self.__resolution_cache[type_key] = True
 
@@ -2594,17 +2685,21 @@ class Container(IContainer):
                 )
 
         except Exception as e:
+
             # Remove the type from the resolution cache on error
             self.__resolution_cache.pop(type_key, None)
 
+            # If the exception is already an OrionisContainerException, re-raise it
             if isinstance(e, OrionisContainerException):
                 raise
-            else:
-                raise OrionisContainerException(
-                    f"Failed to auto-resolve '{type_.__name__}': {str(e)}"
-                ) from e
+
+            # Otherwise, raise a new OrionisContainerException with additional context
+            raise OrionisContainerException(
+                f"Failed to auto-resolve '{type_.__name__}': {str(e)}"
+            ) from e
 
         finally:
+
             # Always clean up the resolution cache after resolution attempt
             self.__resolution_cache.pop(type_key, None)
 

orionis/foundation/application.py

@@ -2198,11 +2198,7 @@ class Application(Container, IApplication):
         if not self.__booted:
 
             # Register the application instance in the container
-            self.instance(
-                IApplication,
-                self,
-                alias="x-orionis.foundation.contracts.application.IApplication"
-            )
+            self.instance(IApplication, self, alias="x-orionis.foundation.contracts.application.IApplication")
 
             # Load configuration if not already set
             self.__loadConfig()
@@ -2212,8 +2208,6 @@ class Application(Container, IApplication):
             self.__loadFrameworkProviders()
             self.__registerProviders()
             self.__bootProviders()
-
-            # Mark as booted
             self.__booted = True
 
             # Load core framework kernels with app booted

orionis/metadata/framework.py

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

{orionis-0.652.0.dist-info → orionis-0.654.0.dist-info}/METADATA

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

{orionis-0.652.0.dist-info → orionis-0.654.0.dist-info}/RECORD

@@ -67,7 +67,7 @@ orionis/console/stubs/listener.stub,sha256=DbX-ghx2-vb73kzQ6L20lyg5vSKn58jSLTwFu
 orionis/console/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/tasks/schedule.py,sha256=ZeeuQ9Tbu5KNowKC5oIk7yWeJXzlDQiQ278mWEgoCXc,87989
 orionis/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/container/container.py,sha256=FgA-t4mTwyjvaVgnOXnPfhuVB2v288LgO3-gq6tZ0MM,106029
+orionis/container/container.py,sha256=3s1ej-wGeylBzG4qAJ9JOra1Lvt5M3QJyAeu8q23rP8,112421
 orionis/container/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/container/context/manager.py,sha256=I08K_jKXSKmrq18Pv33qYyMKIlAovVOwIgmfiVm-J7c,2971
 orionis/container/context/scope.py,sha256=p_oCzR7dDz-5ZAd16ab4vfLc3gBf34CaN0f4iR9D0bQ,1155
@@ -104,7 +104,7 @@ orionis/failure/contracts/handler.py,sha256=AeJfkJfD3hTkOIYAtADq6GnQfq-qWgDfUc7b
 orionis/failure/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/failure/entities/throwable.py,sha256=1zD-awcuAyEtlR-L7V7ZIfPSF4GpXkf-neL5sXul7dc,1240
 orionis/foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/foundation/application.py,sha256=hnl72VeiZm2FTsxI3UQvw6_It8cndqPZ0j0Z5T6Ut7s,94126
+orionis/foundation/application.py,sha256=5A93XNiYJi1FEu8hIv2UStxZu--ac4KanhcWsSU25hU,94028
 orionis/foundation/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/startup.py,sha256=btqvryeIf9lLNQ9fBff7bJMrfraEY8qrWi4y_5YAR0Q,9681
 orionis/foundation/config/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -217,7 +217,7 @@ orionis/foundation/providers/scheduler_provider.py,sha256=IrPQJwvQVLRm5Qnz0Cxon4
 orionis/foundation/providers/testing_provider.py,sha256=eI1p2lUlxl25b5Z487O4nmqLE31CTDb4c3Q21xFadkE,1615
 orionis/foundation/providers/workers_provider.py,sha256=GdHENYV_yGyqmHJHn0DCyWmWId5xWjD48e6Zq2PGCWY,1674
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=ZscG6dPe4ughRqIi4LSOzuDGUBUvjZdP7nRI8SNIMzo,4089
+orionis/metadata/framework.py,sha256=cxeQWRZy2fnzU53QvPzM6KYNMf4DDEQhu_iD33csm6E,4089
 orionis/metadata/package.py,sha256=k7Yriyp5aUcR-iR8SK2ec_lf0_Cyc-C7JczgXa-I67w,16039
 orionis/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -404,8 +404,8 @@ orionis/test/validators/workers.py,sha256=rWcdRexINNEmGaO7mnc1MKUxkHKxrTsVuHgbnI
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=R55ykeRs0wDKcdTf4O1YZ8GDHTFmJ0IK6VQkbJkYUvo,5571
 orionis/test/view/report.stub,sha256=QLqqCdRoENr3ECiritRB3DO_MOjRQvgBh5jxZ3Hs1r0,28189
-orionis-0.652.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
-orionis-0.652.0.dist-info/METADATA,sha256=9q56hxrhQy2XQerviQtEiL_8jeg5ooK9p7Aq8ooA2vI,4772
-orionis-0.652.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.652.0.dist-info/top_level.txt,sha256=lyXi6jArpqJ-0zzNqd_uwsH-z9TCEBVBL-pC3Ekv7hU,8
-orionis-0.652.0.dist-info/RECORD,,
+orionis-0.654.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
+orionis-0.654.0.dist-info/METADATA,sha256=MZG7617D7xqfB14CWjZdQ8sqkcMvxrkSucLHJlSTwsM,4772
+orionis-0.654.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.654.0.dist-info/top_level.txt,sha256=lyXi6jArpqJ-0zzNqd_uwsH-z9TCEBVBL-pC3Ekv7hU,8
+orionis-0.654.0.dist-info/RECORD,,