orionis 0.321.0__py3-none-any.whl → 0.322.0__py3-none-any.whl

orionis/container/container.py

@@ -1,5 +1,6 @@
 import threading
 from typing import Any, Callable
+from orionis.container.context.manager import ScopeManager
 from orionis.container.contracts.container import IContainer
 from orionis.container.entities.binding import Binding
 from orionis.container.enums.lifetimes import Lifetime
@@ -430,7 +431,7 @@ class Container(IContainer):
         # Return True to indicate successful registration
         return True
 
-    def function(
+    def callable(
         self,
         alias: str,
         fn: Callable[..., Any],
@@ -633,4 +634,26 @@ class Container(IContainer):
             binding,
             *args,
             **kwargs
-        )
+        )
+
+    def createContext(self) -> ScopeManager:
+        """
+        Creates a new context for managing scoped services.
+
+        This method returns a context manager that can be used with a 'with' statement
+        to control the lifecycle of scoped services.
+
+        Returns
+        -------
+        ScopeManager
+            A context manager for scoped services.
+
+        Usage
+        -------
+        with container.createContext():
+            # Scoped services created here will be disposed when exiting this block
+            service = container.make(IScopedService)
+            ...
+        # Scoped services are automatically disposed here
+        """
+        return ScopeManager()

orionis/container/context/manager.py

@@ -0,0 +1,94 @@
+from orionis.container.context.scope import ScopedContext
+
+class ScopeManager:
+    """
+    A context manager to manage scoped lifetimes in the container.
+    """
+    def __init__(self):
+        """
+        Initialize a new ScopeManager with an empty instances dictionary.
+        """
+        self._instances = {}
+
+    def __getitem__(self, key):
+        """
+        Get an instance by key.
+
+        Parameters
+        ----------
+        key : hashable
+            The key of the instance to retrieve.
+
+        Returns
+        -------
+        object or None
+            The instance associated with the key or None if not found.
+        """
+        return self._instances.get(key)
+
+    def __setitem__(self, key, value):
+        """
+        Store an instance by key.
+
+        Parameters
+        ----------
+        key : hashable
+            The key to associate with the instance.
+        value : object
+            The instance to store.
+        """
+        self._instances[key] = value
+
+    def __contains__(self, key):
+        """
+        Check if a key exists in this scope.
+
+        Parameters
+        ----------
+        key : hashable
+            The key to check.
+
+        Returns
+        -------
+        bool
+            True if the key exists in the scope, False otherwise.
+        """
+        return key in self._instances
+
+    def clear(self):
+        """
+        Clear all instances from this scope.
+        """
+        self._instances.clear()
+
+    def __enter__(self):
+        """
+        Enter the scope context.
+
+        Sets this scope as the current active scope.
+
+        Returns
+        -------
+        ScopeManager
+            This scope manager instance.
+        """
+        ScopedContext.setCurrentScope(self)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """
+        Exit the scope context.
+
+        Clears this scope and the active scope reference.
+
+        Parameters
+        ----------
+        exc_type : type or None
+            The exception type if an exception was raised, None otherwise.
+        exc_val : Exception or None
+            The exception instance if an exception was raised, None otherwise.
+        exc_tb : traceback or None
+            The exception traceback if an exception was raised, None otherwise.
+        """
+        self.clear()
+        ScopedContext.clear()

orionis/container/context/scope.py

@@ -0,0 +1,40 @@
+import contextvars
+
+class ScopedContext:
+    """
+    Holds scoped instances for the current context.
+    """
+    _active_scope = contextvars.ContextVar("orionis_scope", default=None)
+
+    @classmethod
+    def getCurrentScope(cls):
+        """
+        Get the currently active scope.
+
+        Returns
+        -------
+        object or None
+            The current active scope or None if no scope is active.
+        """
+        return cls._active_scope.get()
+
+    @classmethod
+    def setCurrentScope(cls, scope):
+        """
+        Set the current active scope.
+
+        Parameters
+        ----------
+        scope : object
+            The scope object to set as active.
+        """
+        cls._active_scope.set(scope)
+
+    @classmethod
+    def clear(cls):
+        """
+        Clear the current active scope.
+
+        Sets the active scope to None.
+        """
+        cls._active_scope.set(None)

orionis/container/contracts/container.py

@@ -131,7 +131,7 @@ class IContainer(ABC):
         pass
 
     @abstractmethod
-    def function(
+    def callable(
         self,
         alias: str,
         fn: Callable[..., Any],

orionis/container/resolver.py

@@ -1,4 +1,5 @@
 from typing import Any, Callable
+from orionis.container.context.scope import ScopedContext
 from orionis.container.contracts.container import IContainer
 from orionis.container.entities.binding import Binding
 from orionis.container.enums.lifetimes import Lifetime
@@ -61,10 +62,7 @@ class Resolver:
         elif binding.lifetime == Lifetime.SINGLETON:
             return self.__resolveSingleton(binding, *args, **kwargs)
         elif binding.lifetime == Lifetime.SCOPED:
-            # TODO: Implement scoped lifetime resolution
-            raise OrionisContainerException(
-                "Scoped lifetime resolution is not yet implemented."
-            )
+            return self.__resolveScoped(binding, *args, **kwargs)
 
     def __resolveTransient(self, binding: Binding, *args, **kwargs) -> Any:
         """
@@ -153,6 +151,58 @@ class Resolver:
                 "Cannot resolve singleton binding: neither a concrete class, instance, nor function is defined."
             )
 
+    def __resolveScoped(self, binding: Binding, *args, **kwargs) -> Any:
+        """
+        Resolves a service with scoped lifetime.
+
+        Parameters
+        ----------
+        binding : Binding
+            The binding to resolve.
+        *args : tuple
+            Positional arguments to pass to the constructor.
+        **kwargs : dict
+            Keyword arguments to pass to the constructor.
+
+        Returns
+        -------
+        Any
+            The scoped instance of the requested service.
+
+        Raises
+        ------
+        OrionisContainerException
+            If no scope is active or service can't be resolved.
+        """
+        scope = ScopedContext.getCurrentScope()
+        if scope is None:
+            raise OrionisContainerException(
+                f"No active scope found while resolving scoped service '{binding.alias}'. "
+                f"Use 'with container.createContext():' to create a scope context."
+            )
+
+        if binding.alias in scope:
+            return scope[binding.alias]
+
+        # Create a new instance
+        if binding.concrete:
+            if args or kwargs:
+                instance = self.__instantiateConcreteWithArgs(binding.concrete, *args, **kwargs)
+            else:
+                instance = self.__instantiateConcreteReflective(binding.concrete)
+        elif binding.function:
+            if args or kwargs:
+                instance = self.__instantiateCallableWithArgs(binding.function, *args, **kwargs)
+            else:
+                instance = self.__instantiateCallableReflective(binding.function)
+        else:
+            raise OrionisContainerException(
+                "Cannot resolve scoped binding: neither a concrete class nor a function is defined."
+            )
+
+        scope[binding.alias] = instance
+        return instance
+
     def __instantiateConcreteWithArgs(self, concrete: Callable[..., Any], *args, **kwargs) -> Any:
         """
         Instantiates a concrete class with the provided arguments.
@@ -401,4 +451,3 @@ class Resolver:
 
             # Raise a more informative exception
             raise OrionisContainerException(error_msg) from e
-

orionis/metadata/framework.py

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

{orionis-0.321.0.dist-info → orionis-0.322.0.dist-info}/METADATA

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

{orionis-0.321.0.dist-info → orionis-0.322.0.dist-info}/RECORD

@@ -2,12 +2,6 @@ orionis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/_application.py,sha256=dMjJ0nFcIIOBGb5zr-tHNzcgTOZ1vJ7iMdFAlqSQph0,9405
 orionis/application.py,sha256=Off5uOUj-IYvvR8DcqLUoBW_98opWa7MQrtqTr0SZGc,292
 orionis/unittesting.py,sha256=_NU3_sm3R6bUUH_Y-KSPgNVBajUGCtKo_CGgjB1YD5k,2094
-orionis/_container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/_container/container.py,sha256=0AOqTNwpN_OtWbq9mBI99qfJ7LMkN71y0lP0JWKzut0,18289
-orionis/_container/container_integrity.py,sha256=vrqZrkJaP6ghbiAzr-nEul9f_lEWVa2nMUSugQXDfWk,10095
-orionis/_container/exception.py,sha256=ap1SqYEjQEEHXJJTNmL7V1jrmRjgT5_7geZ95MYkhMA,1691
-orionis/_container/lifetimes.py,sha256=2lbdiV7R2WlJf1cLD6eBxLnJud_lZvX1IhQH2Djy3Ww,375
-orionis/_container/resolve.py,sha256=5qVE--fBpbVFiTYM_jXKbjHNssm28aM4cwd49AhiLkY,2231
 orionis/_contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/_contracts/application.py,sha256=ltuDA1mN5P73l89jJto_A96ePJWE02OZ_B2NOPpfeWs,1061
 orionis/_contracts/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -135,9 +129,12 @@ orionis/console/output/console.py,sha256=TE_Hl720ADd82dbERFSWhkoQRukDQZmETSw4nkw
 orionis/console/output/executor.py,sha256=bdvkzW2-buy0BPpy2r5qUGrRFW2Ay6k-5rSeHb0gQ3o,3352
 orionis/console/output/progress_bar.py,sha256=vFy582z6VJS46LV6tuyrmr9qvdVeTEtw3hyNcEHezeg,3088
 orionis/console/output/styles.py,sha256=6a4oQCOBOKMh2ARdeq5GlIskJ3wjiylYmh66tUKKmpQ,4053
-orionis/container/container.py,sha256=eBVQMzfSvXcxrdm-0hq0gmXZzxf3uabIcxbGVvGZmIo,22342
-orionis/container/resolver.py,sha256=iuyTWCnCqWXQCtWvFXPdS9cR_g3Q58_wjHVn0Yg0YNM,16209
-orionis/container/contracts/container.py,sha256=ksMn6ZLnFkIxd9_hbUGz3OpHzaYTA5izcDtH959kOow,7603
+orionis/container/container.py,sha256=dIfHPCC28_Eho7kgp0AUFS1S5iaCD4ws7udCy_jQ6sE,23112
+orionis/container/resolver.py,sha256=bR26v1bAtg9FgDtfs6zP30-g75aWrSO43UJPweJ7jfo,18014
+orionis/container/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/container/context/manager.py,sha256=9yODWkHBoJ2kgJZ5ONLqcEcex50vaWuMcxsvmDgnQo4,2437
+orionis/container/context/scope.py,sha256=CWFiLLTAC_IdmeFKWX-jrphdxB0_TMEVBlz6lQVMPC8,937
+orionis/container/contracts/container.py,sha256=hOO3w2yqVhp2nPTeS1uJEYgXSTbM3xwezDCOSNMC_a0,7603
 orionis/container/entities/binding.py,sha256=Qp6Lf4XUDp2NjqXDAC2lzvhOFQWiBDKiGFcKfwb4axw,4342
 orionis/container/enums/lifetimes.py,sha256=RqQmugMIB1Ev_j_vFLcWorndm-to7xg4stQ7yKFDdDw,190
 orionis/container/exceptions/container_exception.py,sha256=goTDEwC70xTMD2qppN8KV-xyR0Nps218OD4D1LZ2-3s,470
@@ -244,7 +241,7 @@ orionis/foundation/contracts/config.py,sha256=Rpz6U6t8OXHO9JJKSTnCimytXE-tfCB-1i
 orionis/foundation/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/exceptions/integrity.py,sha256=mc4pL1UMoYRHEmphnpW2oGk5URhu7DJRREyzHaV-cs8,472
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=gv-aVbvyQwRvOTPPCJTIwJffZOEd9Ak6L9jdwT46oOE,4960
+orionis/metadata/framework.py,sha256=-G5Ox-3m6R7JXyXZxf3c-6gmJ37J674tYlWjc8-Ar6k,4960
 orionis/metadata/package.py,sha256=tqLfBRo-w1j_GN4xvzUNFyweWYFS-qhSgAEc-AmCH1M,5452
 orionis/patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/patterns/singleton/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -356,7 +353,7 @@ orionis/test/suite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 orionis/test/suite/test_unit.py,sha256=MWgW8dRCRyT1XZ5LsbXQ7-KVPReasoXwzEEL1EWWfE4,52190
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=jXZkbITBknbUwm_mD8bcTiwLDvsFkrO9qrf0ZgPwqxc,4903
-orionis-0.321.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.322.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/test_example.py,sha256=kvWgiW3ADEZf718dGsMPtDh_rmOSx1ypEInKm7_6ZPQ,601
@@ -457,8 +454,8 @@ tests/support/wrapper/test_services_wrapper_docdict.py,sha256=yeVwl-VcwkWSQYyxZu
 tests/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/test_testing_result.py,sha256=MrGK3ZimedL0b5Ydu69Dg8Iul017AzLTm7VPxpXlpfU,4315
 tests/testing/test_testing_unit.py,sha256=DjLBtvVn8B1KlVJNNkstBT8_csA1yeaMqnGrbanN_J4,7438
-orionis-0.321.0.dist-info/METADATA,sha256=kQ_DamwqrnAqkqPJQZd6mR4u-U_ERbRLwEw8FqTgTwE,4772
-orionis-0.321.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-orionis-0.321.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.321.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.321.0.dist-info/RECORD,,
+orionis-0.322.0.dist-info/METADATA,sha256=AU8sCGe16NBNt6PHdMNm_gcUrv3R8mwDPArdt-WH0qU,4772
+orionis-0.322.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+orionis-0.322.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.322.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.322.0.dist-info/RECORD,,

orionis/_container/container.py

@@ -1,543 +0,0 @@
-import inspect
-from threading import Lock
-from typing import Callable, Any, Dict, Deque, Optional, Type, get_origin, get_args
-from collections import deque
-from orionis._container.container_integrity import ContainerIntegrity
-from orionis._container.lifetimes import Lifetime
-from orionis._container.exception import OrionisContainerException, OrionisContainerValueError, OrionisContainerTypeError
-from orionis._contracts.container.container import IContainer
-
-class Container(IContainer):
-    """
-    Service container and dependency injection manager.
-
-    This class follows the singleton pattern to manage service bindings, instances,
-    and different lifecycle types such as transient, singleton, and scoped.
-    """
-
-    _instance = None
-    _lock = Lock()
-
-    @classmethod
-    def destroy(cls):
-        """
-        Destroys the container instance.
-        """
-        cls._instance = None
-
-    def __new__(cls):
-        """
-        Create a new instance of the container.
-        """
-        if cls._instance is None:
-            with cls._lock:
-                if cls._instance is None:
-                    cls._instance = super().__new__(cls)
-                    cls._instance._scoped_instances = {}
-                    cls._instance._singleton_instances = {}
-                    cls._instance._instances_services = {}
-                    cls._instance._transient_services = {}
-                    cls._instance._scoped_services = {}
-                    cls._instance._singleton_services = {}
-                    cls._instance._aliases_services = {}
-                    cls._instance.instance(IContainer, cls._instance)
-        return cls._instance
-
-    def bind(self, abstract: Callable[..., Any], concrete: Callable[..., Any], lifetime: str = Lifetime.TRANSIENT.value) -> None:
-        """
-        Binds an abstract type to a concrete implementation with a specified lifetime.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The abstract base type or alias to be bound.
-        concrete : Callable[..., Any]
-            The concrete implementation to associate with the abstract type.
-        lifetime : str
-            The lifecycle of the binding. Must be one of 'transient', 'scoped', or 'singleton'.
-
-        Raises
-        ------
-        OrionisContainerValueError
-            If an invalid lifetime is provided or the concrete implementation is None.
-
-        Examples
-        --------
-        >>> container.bind(MyService, MyServiceImplementation, "singleton")
-        """
-        if lifetime not in [member.value for member in Lifetime]:
-            raise OrionisContainerValueError(f"Invalid lifetime type '{lifetime}'.")
-
-        if concrete is None:
-            raise OrionisContainerValueError("Concrete implementation cannot be None when binding a service.")
-
-        abstract = abstract or concrete
-        ContainerIntegrity.ensureIsCallable(concrete)
-        ContainerIntegrity.ensureNotMain(concrete)
-
-        service_entry = {
-            "concrete": concrete,
-            "async": inspect.iscoroutinefunction(concrete)
-        }
-
-        service_registry = {
-            Lifetime.TRANSIENT.value: self._transient_services,
-            Lifetime.SCOPED.value: self._scoped_services,
-            Lifetime.SINGLETON.value: self._singleton_services
-        }
-
-        if ContainerIntegrity.isAbstract(abstract):
-            ContainerIntegrity.ensureImplementation(abstract, concrete)
-            service_registry[lifetime][abstract] = service_entry
-            return
-
-        if ContainerIntegrity.isAlias(abstract):
-            service_registry[lifetime][abstract] = service_entry
-            return
-
-        raise OrionisContainerValueError(f"Invalid abstract type '{abstract}'. It must be a valid alias or an abstract class.")
-
-    def transient(self, abstract: Callable[..., Any], concrete: Callable[..., Any]) -> None:
-        """
-        Registers a service with a transient lifetime.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The abstract base type or alias to be bound.
-        concrete : Callable[..., Any]
-            The concrete implementation to associate with the abstract type.
-
-        Examples
-        --------
-        >>> container.transient(MyService, MyServiceImplementation)
-        """
-
-        self.bind(abstract, concrete, Lifetime.TRANSIENT.value)
-
-    def scoped(self, abstract: Callable[..., Any], concrete: Callable[..., Any]) -> None:
-        """
-        Registers a service with a scoped lifetime.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The abstract base type or alias to be bound.
-        concrete : Callable[..., Any]
-            The concrete implementation to associate with the abstract type.
-
-        Examples
-        --------
-        >>> container.scoped(MyService, MyServiceImplementation)
-        """
-
-        self.bind(abstract, concrete, Lifetime.SCOPED.value)
-
-    def singleton(self, abstract: Callable[..., Any], concrete: Callable[..., Any]) -> None:
-        """
-        Registers a service with a singleton lifetime.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The abstract base type or alias to be bound.
-        concrete : Callable[..., Any]
-            The concrete implementation to associate with the abstract type.
-
-        Examples
-        --------
-        >>> container.singleton(MyService, MyServiceImplementation)
-        """
-
-        self.bind(abstract, concrete, Lifetime.SINGLETON.value)
-
-    def instance(self, abstract: Callable[..., Any], instance: Any) -> None:
-        """
-        Registers an already instantiated object in the container.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The abstract base type or alias to be bound.
-        instance : Any
-            The instance to be stored.
-
-        Raises
-        ------
-        OrionisContainerValueError
-            If the instance is None.
-
-        Examples
-        --------
-        >>> container.instance(MyService, my_service_instance)
-        """
-
-        if instance is None:
-            raise OrionisContainerValueError("The provided instance cannot be None.")
-
-        ContainerIntegrity.ensureIsInstance(instance)
-
-        if ContainerIntegrity.isAbstract(abstract):
-            ContainerIntegrity.ensureImplementation(abstract, instance.__class__)
-            self._instances_services[abstract] = instance
-            return
-
-        if ContainerIntegrity.isAlias(abstract):
-            self._instances_services[abstract] = instance
-            return
-
-        raise OrionisContainerValueError(f"Invalid abstract type '{abstract}'. It must be a valid alias or an abstract class.")
-
-    def bound(self, abstract_or_alias: Callable[..., Any]) -> bool:
-        """
-        Checks if a service or alias is bound in the container.
-
-        Parameters
-        ----------
-        abstract_or_alias : Callable[..., Any]
-            The abstract type or alias to check.
-
-        Returns
-        -------
-        bool
-            True if the service is bound, False otherwise.
-
-        Examples
-        --------
-        >>> container.bound(MyService)
-        True
-        """
-
-        service_dicts = [
-            self._instances_services,
-            self._transient_services,
-            self._scoped_services,
-            self._singleton_services,
-            self._aliases_services
-        ]
-        return any(abstract_or_alias in service_dict for service_dict in service_dicts)
-
-    def has(self, abstract_or_alias: Callable[..., Any]) -> bool:
-        """
-        Alias for `bound()` method.
-
-        Parameters
-        ----------
-        abstract_or_alias : Callable[..., Any]
-            The abstract type or alias to check.
-
-        Returns
-        -------
-        bool
-            True if the service is bound, False otherwise.
-
-        Examples
-        --------
-        >>> container.has(MyService)
-        True
-        """
-
-        return self.bound(abstract_or_alias)
-
-    def alias(self, alias: Callable[..., Any], abstract: Callable[..., Any]) -> None:
-        """
-        Creates an alias for an existing abstract binding.
-
-        Parameters
-        ----------
-        alias : Callable[..., Any]
-            The alias name.
-        abstract : Callable[..., Any]
-            The existing abstract type to alias.
-
-        Raises
-        ------
-        OrionisContainerValueError
-            If the abstract type is not registered or the alias is already in use.
-
-        Examples
-        --------
-        >>> container.alias("DatabaseService", MyDatabaseService)
-        """
-
-        if not self.has(abstract):
-            raise OrionisContainerValueError(f"Abstract '{abstract}' is not registered in the container.")
-
-        if alias in self._aliases_services:
-            raise OrionisContainerValueError(f"Alias '{alias}' is already in use.")
-
-        if not ContainerIntegrity.isAlias(abstract):
-            raise OrionisContainerValueError(f"Invalid target abstract type: {abstract}. It must be an alias.")
-
-        self._aliases_services[alias] = abstract
-
-    def isAlias(self, name: str) -> bool:
-        """
-        Checks if a given name is an alias.
-
-        Parameters
-        ----------
-        name : str
-            The name to check.
-
-        Returns
-        -------
-        bool
-            True if the name is an alias, False otherwise.
-
-        Raises
-        ------
-        OrionisContainerTypeError
-            If the name is not a string.
-
-        Examples
-        --------
-        >>> container.isAlias("DatabaseService")
-        True
-        """
-
-        if not isinstance(name, str):
-            raise OrionisContainerTypeError("The name must be a valid string.")
-        return name in self._aliases_services
-
-    def getBindings(self) -> Dict[str, Any]:
-        """
-        Retrieves all registered service bindings.
-
-        Returns
-        -------
-        dict
-            A dictionary containing all instances, transient, scoped, singleton, and alias services.
-
-        Examples
-        --------
-        >>> container.getBindings()
-        """
-
-        return {
-            "instances": self._instances_services,
-            "transient": self._transient_services,
-            "scoped": self._scoped_services,
-            "singleton": self._singleton_services,
-            "aliases": self._aliases_services
-        }
-
-    def getAlias(self, name: str) -> Callable[..., Any]:
-        """
-        Retrieves the abstract type associated with an alias.
-
-        Parameters
-        ----------
-        name : str
-            The alias name.
-
-        Returns
-        -------
-        Callable[..., Any]
-            The abstract type associated with the alias.
-
-        Raises
-        ------
-        OrionisContainerValueError
-            If the alias is not registered.
-
-        Examples
-        --------
-        >>> container.getAlias("DatabaseService")
-        <class 'MyDatabaseService'>
-        """
-
-        if not isinstance(name, str):
-            raise OrionisContainerValueError("The name must be a valid string.")
-
-        if name not in self._aliases_services:
-            raise OrionisContainerValueError(f"Alias '{name}' is not registered in the container.")
-
-        return self._aliases_services[name]
-
-    def forgetScopedInstances(self) -> None:
-        """
-        Clears all scoped instances.
-
-        Examples
-        --------
-        >>> container.forgetScopedInstances()
-        """
-
-        self._scoped_instances = {}
-
-    def newRequest(self) -> None:
-        """
-        Resets scoped instances to handle a new request.
-
-        Examples
-        --------
-        >>> container.newRequest()
-        """
-
-        self.forgetScopedInstances()
-
-    async def make(self, abstract_or_alias: Callable[..., Any]) -> Any:
-        """
-        Resolves and instantiates a service from the container.
-
-        Parameters
-        ----------
-        abstract_or_alias : Callable[..., Any]
-            The abstract type or alias to resolve.
-
-        Returns
-        -------
-        Any
-            The instantiated service.
-
-        Raises
-        ------
-        OrionisContainerException
-            If the service is not found.
-
-        Examples
-        --------
-        >>> service = await container.make(MyService)
-        """
-        if abstract_or_alias in self._aliases_services:
-            abstract_or_alias = self._aliases_services[abstract_or_alias]
-
-        if abstract_or_alias in self._instances_services:
-            return self._instances_services[abstract_or_alias]
-
-        if abstract_or_alias in self._singleton_services:
-            if abstract_or_alias not in self._singleton_instances:
-                service = self._singleton_services[abstract_or_alias]
-                self._singleton_instances[abstract_or_alias] = await self._resolve(service['concrete'])
-            return self._singleton_instances[abstract_or_alias]
-
-        if abstract_or_alias in self._scoped_services:
-            if abstract_or_alias not in self._scoped_instances:
-                service = self._scoped_services[abstract_or_alias]
-                self._scoped_instances[abstract_or_alias] = await self._resolve(service['concrete'])
-            return self._scoped_instances[abstract_or_alias]
-
-        if abstract_or_alias in self._transient_services:
-            service = self._transient_services[abstract_or_alias]
-            return await self._resolve(service['concrete'])
-
-        raise OrionisContainerException(f"No binding found for '{abstract_or_alias}' in the container.")
-
-    async def _resolve(self, concrete: Callable[..., Any], resolving: Optional[Deque[Type]] = None) -> Any:
-        """
-        Asynchronous method to resolve dependencies recursively and instantiate a class.
-
-        Parameters
-        ----------
-        concrete : Callable[..., Any]
-            The concrete implementation to instantiate.
-        resolving : Optional[Deque[Type]], optional
-            A queue to track resolving dependencies and prevent circular dependencies.
-
-        Returns
-        -------
-        Any
-            The instantiated object.
-
-        Raises
-        ------
-        OrionisContainerException
-            If circular dependencies are detected or instantiation fails.
-
-        Examples
-        --------
-        >>> instance = await container._resolve(MyClass)
-        """
-        if resolving is None:
-            resolving = deque()
-
-        if concrete in resolving:
-            raise OrionisContainerException(f"Circular dependency detected for {concrete}.")
-
-        resolving.append(concrete)
-
-        try:
-            signature = inspect.signature(concrete)
-        except ValueError as e:
-            raise OrionisContainerException(f"Unable to inspect signature of {concrete}: {str(e)}")
-
-        resolved_dependencies: Dict[str, Any] = {}
-        unresolved_dependencies = deque()
-
-        for param_name, param in signature.parameters.items():
-            if param_name == 'self':
-                continue
-
-            if param.kind in (param.VAR_POSITIONAL, param.VAR_KEYWORD):
-                continue
-
-            if param.annotation is param.empty and param.default is param.empty:
-                unresolved_dependencies.append(param_name)
-                continue
-
-            if param.default is not param.empty:
-                resolved_dependencies[param_name] = param.default
-                continue
-
-            if param.annotation is not param.empty:
-                param_type = param.annotation
-
-                if get_origin(param_type) is not None:
-                    param_type = get_args(param_type)[0]
-
-                if isinstance(param_type, type) and not issubclass(param_type, (int, str, bool, float)):
-                    if self.has(param_type):
-                        resolved_dependencies[param_name] = await self.make(param_type)
-                    else:
-                        resolved_dependencies[param_name] = await self._resolve_dependency(param_type, resolving)
-                else:
-                    resolved_dependencies[param_name] = param_type
-
-        while unresolved_dependencies:
-            dep_name = unresolved_dependencies.popleft()
-            if dep_name not in resolved_dependencies:
-                resolved_dependencies[dep_name] = await self._resolve_dependency(dep_name, resolving)
-
-        try:
-            instance = concrete(**resolved_dependencies)
-            resolving.pop()
-            return instance
-        except Exception as e:
-            raise OrionisContainerException(f"Failed to instantiate {concrete}: {str(e)}")
-
-    async def _resolve_dependency(self, dep_type: Any, resolving: Optional[Deque[Type]] = None) -> Any:
-        """
-        Asynchronously resolves a dependency by instantiating or retrieving it from the container.
-
-        Parameters
-        ----------
-        dep_type : Any
-            The dependency type to resolve.
-        resolving : Optional[Deque[Type]], optional
-            A queue to track resolving dependencies.
-
-        Returns
-        -------
-        Any
-            The resolved dependency.
-
-        Raises
-        ------
-        OrionisContainerException
-            If the dependency cannot be resolved.
-
-        Examples
-        --------
-        >>> dependency = await container._resolve_dependency(MyDependency)
-        """
-        if resolving is None:
-            resolving = deque()
-
-        if isinstance(dep_type, type):
-            if self.has(dep_type):
-                return await self.make(dep_type)
-            else:
-                return await self._resolve(dep_type, resolving)
-
-        raise OrionisContainerException(f"Cannot resolve dependency of type {dep_type}")

orionis/_container/container_integrity.py

@@ -1,292 +0,0 @@
-import re
-import inspect
-from abc import ABC
-from typing import Any, Callable, Set, Type
-from orionis._container.exception import OrionisContainerValueError, OrionisContainerTypeError
-from orionis._contracts.container.container_integrity import IContainerIntegrity
-
-class ContainerIntegrity(IContainerIntegrity):
-
-    @staticmethod
-    def ensureImplementation(abstract: Type, concrete: Type, raise_exception: bool = True) -> bool:
-        """
-        Strictly verify that 'concrete' implements all abstract methods of 'abstract'.
-
-        Args:
-            abstract: Abstract class or interface to verify against
-            concrete: Concrete class that should implement the abstract class
-
-        Raises:
-            OrionisContainerTypeError: If concrete doesn't properly implement abstract
-        """
-
-        # Check if abstract is a class
-        if not inspect.isclass(abstract):
-            if raise_exception:
-                raise OrionisContainerTypeError(
-                    f"Abstract must be a class, got {type(abstract).__name__}"
-                )
-            return False
-
-        # Check if concrete is a class
-        if not inspect.isclass(concrete):
-            if raise_exception:
-                raise OrionisContainerTypeError(
-                    f"Concrete must be a class, got {type(concrete).__name__}"
-                )
-            return False
-
-        # Check if concrete inherits from abstract
-        if not issubclass(concrete, abstract):
-            if raise_exception:
-                raise OrionisContainerTypeError(
-                    f"{concrete.__name__} must inherit from {abstract.__name__}"
-                )
-            return False
-
-        abstract_methods: Set[str] = set()
-        for base in abstract.__mro__:
-            if hasattr(base, '__abstractmethods__'):
-                abstract_methods.update(base.__abstractmethods__)
-
-        if not abstract_methods:
-            return  # No abstract methods to implement
-            
-        class_methods = {
-            name for name, member in inspect.getmembers(concrete)
-            if not name.startswith("_") and inspect.isfunction(member)
-        }
-        
-        missing_methods = abstract_methods - class_methods
-        if missing_methods:
-            raise OrionisContainerTypeError(
-                f"{concrete.__name__} must implement: {sorted(missing_methods)}"
-            )
-            
-    def ensureImplementation(abstract: Type, concrete: Type) -> None:
-        """
-        Verify at runtime if `concrete` implements all methods of `abstract`.
-
-        :param abstract: Abstract class or interface.
-        :param concrete: Concrete class that should implement the abstract class.
-        :raises TypeError: If `concrete` does not implement all methods of `abstract`.
-        """
-        # Get public methods of the interface (excluding magic methods)
-        interface_methods = {
-            name for name, func in inspect.getmembers(abstract, predicate=inspect.isfunction)
-            if not name.startswith("_")
-        }
-
-        # Get public methods of the concrete class
-        class_methods = {
-            name for name, func in inspect.getmembers(concrete, predicate=inspect.isfunction)
-            if not name.startswith("_")
-        }
-
-        # Verify that all interface methods are in the concrete class
-        if not interface_methods.issubset(class_methods):
-            missing_methods = interface_methods - class_methods
-            raise OrionisContainerTypeError(f"{concrete.__name__} does not implement the required methods of {abstract.__name__}: {missing_methods}")
-
-
-    @staticmethod
-    def ensureIsAbstract(abstract: Callable[..., Any]) -> None:
-        """
-        Ensure that the given abstract is a valid abstract class.
-
-        :param abstract: Class to check
-        :raises OrionisContainerValueError: If the class is not a valid abstract interface
-        """
-        if not isinstance(abstract, type) or not issubclass(abstract, ABC) or abstract is ABC:
-            raise OrionisContainerValueError("The provided class must inherit from ABC and not be ABC itself.")
-
-        if not any(getattr(attr, "__isabstractmethod__", False) for attr in abstract.__dict__.values()):
-            raise OrionisContainerValueError("The provided class must define at least one abstract method.")
-
-    @staticmethod
-    def ensureIsCallable(concrete: Callable[..., Any]) -> None:
-        """
-        Ensure that the given implementation is callable or instantiable.
-
-        Parameters
-        ----------
-        concrete : Callable[..., Any]
-            The implementation to check.
-
-        Raises
-        ------
-        OrionisContainerTypeError
-            If the implementation is not callable.
-        """
-        if not callable(concrete):
-            raise OrionisContainerTypeError(f"The implementation '{str(concrete)}' must be callable or an instantiable class.")
-
-    @staticmethod
-    def ensureIsInstance(instance: Any) -> None:
-        """
-        Ensure that the given instance is a valid object.
-
-        Parameters
-        ----------
-        instance : Any
-            The instance to check.
-
-        Raises
-        ------
-        OrionisContainerValueError
-            If the instance is not a valid object.
-        """
-        if not isinstance(instance, object):
-            raise OrionisContainerValueError(f"The instance '{str(instance)}' must be a valid object.")
-
-        module = type(instance).__module__
-        if module in ['builtins', 'abc']:
-            raise OrionisContainerValueError(f"The instance '{str(instance)}' is not a valid user-defined object. It belongs to the '{module}' module.")
-
-    @staticmethod
-    def ensureNotMain(concrete: Callable[..., Any]) -> str:
-        """
-        Ensure that a class is not defined in the main script.
-
-        Parameters
-        ----------
-        concrete : Callable[..., Any]
-            The class or function to check.
-
-        Returns
-        -------
-        str
-            The fully qualified name of the class.
-
-        Raises
-        ------
-        OrionisContainerValueError
-            If the class is defined in the main module.
-        """
-        if concrete.__module__ == "__main__":
-            raise OrionisContainerValueError("Cannot register a class from the (__main__) module in the container.")
-
-    @staticmethod
-    def ensureIsAlias(name: str) -> bool:
-        """
-        Ensure that the given alias name is a valid string, with no special characters or spaces, 
-        and it is not a primitive type.
-
-        Parameters
-        ----------
-        name : str
-            The alias name to check.
-
-        Raises
-        ------
-        OrionisContainerValueError
-            If the alias is invalid.
-        """
-        if not isinstance(name, str):
-            raise OrionisContainerValueError(f"The alias '{name}' must be a string.")
-
-        if not re.match(r'^[a-zA-Z0-9_:]+$', name):
-            raise OrionisContainerValueError(
-                f"The alias '{name}' can only contain letters, numbers, underscores, and colons, without spaces or other special characters."
-            )
-
-        if name in {
-            int, "int",
-            float, "float",
-            str, "str",
-            bool, "bool",
-            bytes, "bytes",
-            type(None), "None",
-            complex, "complex",
-            list, "list",
-            tuple, "tuple",
-            dict, "dict",
-            set, "set",
-            frozenset, "frozenset"
-        }:
-            raise OrionisContainerValueError(f"The alias '{name}' cannot be a primitive type.")
-
-    @staticmethod
-    def isAlias(name: str) -> bool:
-        """
-        Check if the given alias name is a valid string, with no special characters or spaces,
-        and it is not a primitive type.
-
-        Parameters
-        ----------
-        name : str
-            The alias name to check.
-
-        Returns
-        -------
-        bool
-            True if the alias is valid, False otherwise.
-        """
-        try:
-            ContainerIntegrity.ensureIsAlias(name)
-            return True
-        except OrionisContainerValueError:
-            return False
-
-    @staticmethod
-    def isCallable(concrete: Callable[..., Any]) -> bool:
-        """
-        Check if the given implementation is callable or instantiable.
-
-        Parameters
-        ----------
-        concrete : Callable[..., Any]
-            The implementation to check.
-
-        Returns
-        -------
-        bool
-            True if the implementation is callable, False otherwise.
-        """
-        try:
-            ContainerIntegrity.ensureIsCallable(concrete)
-            return True
-        except OrionisContainerTypeError:
-            return False
-
-    @staticmethod
-    def isInstance(instance: Any) -> bool:
-        """
-        Check if the given instance is a valid object.
-
-        Parameters
-        ----------
-        instance : Any
-            The instance to check.
-
-        Returns
-        -------
-        bool
-            True if the instance is valid, False otherwise.
-        """
-        try:
-            ContainerIntegrity.ensureIsInstance(instance)
-            return True
-        except OrionisContainerValueError:
-            return False
-
-    @staticmethod
-    def isAbstract(abstract: Callable[..., Any]) -> bool:
-        """
-        Check if the given abstract is a valid abstract class.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The class to check.
-
-        Returns
-        -------
-        bool
-            True if the class is a valid abstract interface, False otherwise.
-        """
-        try:
-            ContainerIntegrity.ensureIsAbstract(abstract)
-            return True
-        except OrionisContainerValueError:
-            return False

orionis/_container/exception.py

@@ -1,54 +0,0 @@
-class OrionisContainerException(Exception):
-    """
-    Excepción personalizada para errores relacionados con el contenedor de inyección de dependencias Orionis.
-    """
-
-    def __init__(self, message: str) -> None:
-        """
-        Inicializa la excepción con un mensaje de error.
-
-        Args:
-            message (str): Mensaje descriptivo del error.
-        """
-        super().__init__(message)
-
-    def __str__(self) -> str:
-        """Retorna una representación en cadena de la excepción."""
-        return f"[OrionisContainerException] {self.args[0]}"
-
-
-class OrionisContainerValueError(ValueError):
-    """
-    Excepción personalizada para errores de tipo ValueError en el contenedor Orionis.
-    """
-
-    def __init__(self, message: str) -> None:
-        """
-        Inicializa la excepción con un mensaje de error.
-
-        Args:
-            message (str): Mensaje descriptivo del error.
-        """
-        super().__init__(message)
-
-    def __str__(self) -> str:
-        """Retorna una representación en cadena de la excepción."""
-        return f"[OrionisContainerValueError] {self.args[0]}"
-
-class OrionisContainerTypeError(TypeError):
-    """
-    Custom exception for TypeError related to the Orionis container.
-    """
-
-    def __init__(self, message: str) -> None:
-        """
-        Initializes the exception with an error message.
-
-        Args:
-            message (str): Descriptive error message.
-        """
-        super().__init__(message)
-
-    def __str__(self) -> str:
-        """Returns a string representation of the exception."""
-        return f"[OrionisContainerTypeError] {self.args[0]}"

orionis/_container/lifetimes.py

@@ -1,13 +0,0 @@
-from enum import Enum
-
-class Lifetime(Enum):
-    """Defines the lifecycle types for dependency injection."""
-
-    # Creates a new instance every time it is requested
-    TRANSIENT = "transient"
-
-    # A single instance is shared throughout the application
-    SINGLETON = "singleton"
-
-    # A new instance is created per request or context
-    SCOPED = "scoped"

orionis/_container/resolve.py

@@ -1,64 +0,0 @@
-from typing import Any, Callable
-from orionis._container.container import Container
-from orionis._container.exception import OrionisContainerValueError
-
-class Resolve:
-    """
-    A class to resolve dependencies from the dependency injection container.
-
-    This class ensures that a given abstract class or alias exists in the container
-    and resolves the associated service when an instance is created.
-
-    Parameters
-    ----------
-    abstract_or_alias : Callable[..., Any] or str
-        The abstract class, alias, or callable to resolve from the container.
-
-    Returns
-    -------
-    Any
-        The service associated with the abstract class or alias.
-
-    Raises
-    ------
-    OrionisContainerValueError
-        If the abstract class or alias is not found in the container.
-
-    Examples
-    --------
-    >>> container = Container()
-    >>> container.bind("my_service", MyService)
-    >>> container.alias("my_alias", "my_service")
-    >>> service = Resolve("my_alias")  # Returns the service associated with "my_alias"
-    >>> service = Resolve(MyService)  # Returns the service associated with MyService
-    """
-
-    def __new__(cls, abstract_or_alias: Callable[..., Any] | str):
-        """
-        Create an instance of Resolve and return the resolved service.
-
-        Parameters
-        ----------
-        abstract_or_alias : Callable[..., Any] or str
-            The abstract class, alias, or callable to resolve from the container.
-
-        Returns
-        -------
-        Any
-            The service associated with the abstract class or alias.
-
-        Raises
-        ------
-        OrionisContainerValueError
-            If the abstract class or alias is not found in the container.
-        """
-
-        # Validate that the abstract or alias exists in the container
-        container = Container()
-        if not container.bound(abstract_or_alias):
-            raise OrionisContainerValueError(
-                f"Service or alias '{abstract_or_alias}' not found in the container."
-            )
-
-        # Resolve and return the service associated with the abstract or alias
-        # return AsyncExecutor.run(container.make(abstract_or_alias))