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

orionis/container/container.py

@@ -1,10 +1,11 @@
 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
 from orionis.container.exceptions.container_exception import OrionisContainerException
-from orionis.container.exceptions.type_error_exception import OrionisContainerTypeError
+from orionis.container.resolver import Resolver
 from orionis.container.validators.implements import ImplementsAbstractMethods
 from orionis.container.validators.is_abstract_class import IsAbstractClass
 from orionis.container.validators.is_callable import IsCallable
@@ -13,12 +14,9 @@ from orionis.container.validators.is_instance import IsInstance
 from orionis.container.validators.is_not_subclass import IsNotSubclass
 from orionis.container.validators.is_subclass import IsSubclass
 from orionis.container.validators.is_valid_alias import IsValidAlias
+from orionis.container.validators.lifetime import LifetimeValidator
 from orionis.services.introspection.abstract.reflection_abstract import ReflectionAbstract
 from orionis.services.introspection.callables.reflection_callable import ReflectionCallable
-from orionis.services.introspection.concretes.reflection_concrete import ReflectionConcrete
-from orionis.services.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
-from orionis.services.introspection.instances.reflection_instance import ReflectionInstance
-from orionis.services.introspection.reflection import Reflection
 
 class Container(IContainer):
 
@@ -37,9 +35,7 @@ class Container(IContainer):
     _initialized = False
 
     def __new__(
-        cls,
-        *args,
-        **kwargs
+        cls
     ) -> 'Container':
         """
         Creates and returns a singleton instance of the class.
@@ -48,12 +44,7 @@ class Container(IContainer):
         of the class exists. If an instance does not exist, it acquires a lock to
         ensure thread safety and creates the instance. Subsequent calls return the
         existing instance.
-        Parameters
-        ----------
-        *args : tuple
-            Variable length argument list.
-        **kwargs : dict
-            Arbitrary keyword arguments.
+
         Returns
         -------
         Container
@@ -440,7 +431,7 @@ class Container(IContainer):
         # Return True to indicate successful registration
         return True
 
-    def function(
+    def callable(
         self,
         alias: str,
         fn: Callable[..., Any],
@@ -471,21 +462,9 @@ class Container(IContainer):
         OrionisContainerException
             If the lifetime is not allowed for the function signature.
         """
+
         # Normalize and validate the lifetime parameter
-        if not isinstance(lifetime, Lifetime):
-            if isinstance(lifetime, str):
-                lifetime_key = lifetime.strip().upper()
-                if lifetime_key in Lifetime.__members__:
-                    lifetime = Lifetime[lifetime_key]
-                else:
-                    valid = ', '.join(Lifetime.__members__.keys())
-                    raise OrionisContainerTypeError(
-                        f"Invalid lifetime '{lifetime}'. Valid options are: {valid}."
-                    )
-            else:
-                raise OrionisContainerTypeError(
-                    f"Lifetime must be of type str or Lifetime enum, got {type(lifetime).__name__}."
-                )
+        lifetime = LifetimeValidator(lifetime)
 
         # Ensure that the alias is a valid string
         IsValidAlias(alias)
@@ -544,7 +523,7 @@ class Container(IContainer):
             or abstract_or_alias in self.__aliasses
         )
 
-    def __getService(
+    def getBinding(
         self,
         abstract_or_alias: Any
     ) -> Binding:
@@ -563,29 +542,6 @@ class Container(IContainer):
         """
         return self.__bindings.get(abstract_or_alias) or self.__aliasses.get(abstract_or_alias)
 
-    def __getFirstService(
-        self,
-        abstract_or_aliasses: list
-    ) -> Binding:
-        """
-        Retrieves the first binding from a list of abstract types or aliases.
-
-        Parameters
-        ----------
-        abstract_or_aliasses : list
-            A list of abstract classes, interfaces, or aliases (str) to retrieve.
-
-        Returns
-        -------
-        Binding
-            The first binding found in the container for the provided abstract types or aliases.
-        """
-        for item in abstract_or_aliasses:
-            binding = self.__getService(item)
-            if binding:
-                return binding
-        return None
-
     def drop(
         self,
         abstract: Callable[..., Any] = None,
@@ -665,341 +621,39 @@ class Container(IContainer):
         OrionisContainerException
             If the requested service is not registered in the container.
         """
-        # Retrieve the binding for the requested abstract or alias
-        binding = self.__getService(abstract_or_alias)
-
-        # Check if the requested service is registered in the container
-        if not binding:
+        if not self.bound(abstract_or_alias):
             raise OrionisContainerException(
                 f"The requested service '{abstract_or_alias}' is not registered in the container."
             )
 
-        # Handle based on binding type and lifetime
-        if binding.lifetime == Lifetime.TRANSIENT:
-            return self.__resolveTransient(binding, *args, **kwargs)
-        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."
-            )
-
-    def __resolveTransient(self, binding: Binding, *args, **kwargs) -> Any:
-        """
-        Resolves a service with transient 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
-            A new instance of the requested service.
-        """
-
-        # Check if the binding has a concrete class or function defined
-        if binding.concrete:
-            if args or kwargs:
-                return self.__instantiateConcreteWithArgs(binding.concrete, *args, **kwargs)
-            else:
-                return self.__instantiateConcreteReflective(binding.concrete)
-
-        # If the binding has a function defined
-        elif binding.function:
-            if args or kwargs:
-                return self.__instantiateCallableWithArgs(binding.function, *args, **kwargs)
-            else:
-                return self.__instantiateCallableReflective(binding.function)
-
-        # If neither concrete class nor function is defined
-        else:
-            raise OrionisContainerException(
-                "Cannot resolve transient binding: neither a concrete class nor a function is defined."
-            )
-
-    def __resolveSingleton(self, binding: Binding, *args, **kwargs) -> Any:
-        """
-        Resolves a service with singleton lifetime.
-
-        Parameters
-        ----------
-        binding : Binding
-            The binding to resolve.
-        *args : tuple
-            Positional arguments to pass to the constructor (only used if instance doesn't exist yet).
-        **kwargs : dict
-            Keyword arguments to pass to the constructor (only used if instance doesn't exist yet).
-
-        Returns
-        -------
-        Any
-            The singleton instance of the requested service.
-        """
-        # Return existing instance if available
-        if binding.instance:
-            return binding.instance
-
-        # Create instance if needed
-        if binding.concrete:
-            if args or kwargs:
-                binding.instance = self.__instantiateConcreteWithArgs(binding.concrete, *args, **kwargs)
-            else:
-                binding.instance = self.__instantiateConcreteReflective(binding.concrete)
-            return binding.instance
-
-        # If the binding has a function defined
-        elif binding.function:
-            if args or kwargs:
-                result = self.__instantiateCallableWithArgs(binding.function, *args, **kwargs)
-            else:
-                result = self.__instantiateCallableReflective(binding.function)
-
-            # Store the result directly as the singleton instance
-            # We don't automatically invoke factory function results anymore
-            binding.instance = result
-            return binding.instance
-
-        # If neither concrete class nor function is defined
-        else:
-            raise OrionisContainerException(
-                "Cannot resolve singleton binding: neither a concrete class, instance, nor function is defined."
-            )
-
-    def __instantiateConcreteWithArgs(self, concrete: Callable[..., Any], *args, **kwargs) -> Any:
-        """
-        Instantiates a concrete class with the provided arguments.
-
-        Parameters
-        ----------
-        concrete : Callable[..., Any]
-            Class to instantiate.
-        *args : tuple
-            Positional arguments to pass to the constructor.
-        **kwargs : dict
-            Keyword arguments to pass to the constructor.
-
-        Returns
-        -------
-        object
-            A new instance of the specified concrete class.
-        """
-
-        # try to instantiate the concrete class with the provided arguments
-        try:
-
-            # If the concrete is a class, instantiate it directly
-            return concrete(*args, **kwargs)
-
-        except TypeError as e:
-
-            # If instantiation fails, use ReflectionConcrete to get class name and constructor signature
-            rf_concrete = ReflectionConcrete(concrete)
-            class_name = rf_concrete.getClassName()
-            signature = rf_concrete.getConstructorSignature()
-
-            # Raise an exception with detailed information about the failure
-            raise OrionisContainerException(
-                f"Failed to instantiate [{class_name}] with the provided arguments: {e}\n"
-                f"Expected constructor signature: [{signature}]"
-            ) from e
-
-    def __instantiateCallableWithArgs(self, fn: Callable[..., Any], *args, **kwargs) -> Any:
-        """
-        Invokes a callable with the provided arguments.
-
-        Parameters
-        ----------
-        fn : Callable[..., Any]
-            The callable to invoke.
-        *args : tuple
-            Positional arguments to pass to the callable.
-        **kwargs : dict
-            Keyword arguments to pass to the callable.
-
-        Returns
-        -------
-        Any
-            The result of the callable.
-        """
-
-        # Try to invoke the callable with the provided arguments
-        try:
-
-            # If the callable is a function, invoke it directly
-            return fn(*args, **kwargs)
-
-        except TypeError as e:
-
-            # If invocation fails, use ReflectionCallable to get function name and signature
-            rf_callable = ReflectionCallable(fn)
-            function_name = rf_callable.getName()
-            signature = rf_callable.getSignature()
-
-            # Raise an exception with detailed information about the failure
-            raise OrionisContainerException(
-                f"Failed to invoke function [{function_name}] with the provided arguments: {e}\n"
-                f"Expected function signature: [{signature}]"
-            ) from e
+        # Get the binding for the requested abstract type or alias
+        binding = self.getBinding(abstract_or_alias)
 
-    def __instantiateConcreteReflective(self, concrete: Callable[..., Any]) -> Any:
-        """
-        Instantiates a concrete class reflectively, resolving its dependencies from the container.
-
-        Parameters
-        ----------
-        concrete : Callable[..., Any]
-            The concrete class to instantiate.
-
-        Returns
-        -------
-        Any
-            A new instance of the concrete class.
-        """
-        # Resolve dependencies for the concrete class
-        params = self.__resolveDependencies(concrete, is_class=True)
-
-        # Instantiate the concrete class with resolved dependencies
-        return concrete(**params)
+        # Resolve the binding using the Resolver class
+        return Resolver(self).resolve(
+            binding,
+            *args,
+            **kwargs
+        )
 
-    def __instantiateCallableReflective(self, fn: Callable[..., Any]) -> Any:
+    def createContext(self) -> ScopeManager:
         """
-        Invokes a callable reflectively, resolving its dependencies from the container.
+        Creates a new context for managing scoped services.
 
-        Parameters
-        ----------
-        fn : Callable[..., Any]
-            The callable to invoke.
+        This method returns a context manager that can be used with a 'with' statement
+        to control the lifecycle of scoped services.
 
         Returns
         -------
-        Any
-            The result of the callable.
-        """
-
-        # Resolve dependencies for the callable
-        params = self.__resolveDependencies(fn, is_class=False)
-
-        # Invoke the callable with resolved dependencies
-        return fn(**params)
-
-    def __resolveDependencies(
-        self,
-        target: Callable[..., Any],
-        *,
-        is_class: bool = False
-    ) -> dict:
-        """
-        Resolves dependencies for a target callable or class.
-
-        Parameters
-        ----------
-        target : Callable[..., Any]
-            The target callable or class whose dependencies to resolve.
-        is_class : bool, optional
-            Whether the target is a class (True) or a callable (False).
+        ScopeManager
+            A context manager for scoped services.
 
-        Returns
+        Usage
         -------
-        dict
-            A dictionary of resolved dependencies.
+        with container.createContext():
+            # Scoped services created here will be disposed when exiting this block
+            service = container.make(IScopedService)
+            ...
+        # Scoped services are automatically disposed here
         """
-        try:
-
-            # Use ReflectionConcrete for classes and ReflectionCallable for callables
-            if is_class:
-                reflection = ReflectionConcrete(target)
-                dependencies = reflection.getConstructorDependencies()
-                name = reflection.getClassName()
-
-            # If the target is a callable, use ReflectionCallable
-            else:
-                reflection = ReflectionCallable(target)
-                dependencies = reflection.getDependencies()
-                name = reflection.getName()
-
-            # Check for unresolved dependencies
-            if dependencies.unresolved:
-                unresolved_args = ', '.join(dependencies.unresolved)
-                raise OrionisContainerException(
-                    f"Cannot resolve '{name}' because the following required arguments are missing: [{unresolved_args}]."
-                )
-
-            # Resolve dependencies
-            params = {}
-            for param_name, dep in dependencies.resolved.items():
-
-                # If the dependency is a ResolvedDependency, resolve it
-                if isinstance(dep, ResolvedDependency):
-
-                    # If the dependency is a built-in type, raise an exception
-                    if dep.module_name == 'builtins':
-                        raise OrionisContainerException(
-                            f"Cannot resolve '{name}' because parameter '{param_name}' depends on built-in type '{dep.type.__name__}'."
-                        )
-
-                    # Try to resolve from container
-                    service = self.__getFirstService([dep.type, dep.full_class_path])
-                    if service:
-                        params[param_name] = self.make(service.alias)
-
-                    # Try to instantiate directly if it's a concrete class
-                    elif ReflectionConcrete.isConcreteClass(dep.type):
-                        params[param_name] = dep.type(**self.__resolveDependencies(dep.type, is_class=True))
-
-                    # Try to call directly if it's a callable
-                    elif callable(dep.type) and not isinstance(dep.type, type):
-                        params[param_name] = dep.type(**self.__resolveDependencies(dep.type, is_class=False))
-
-                    # If the dependency cannot be resolved, raise an exception
-                    else:
-                        raise OrionisContainerException(
-                            f"Cannot resolve dependency '{param_name}' of type '{dep.type.__name__}' for '{name}'."
-                        )
-                else:
-                    # Use default value
-                    params[param_name] = dep
-
-            # Return the resolved parameters
-            return params
-
-        except ImportError as e:
-
-            # Extract module name from the error message if possible
-            import_msg = str(e)
-            module_name = target.__module__ if hasattr(target, '__module__') else "unknown module"
-
-            # Check for potential circular import patterns
-            if "circular import" in import_msg.lower() or "cannot import name" in import_msg.lower():
-                raise OrionisContainerException(
-                    f"Circular import detected while resolving dependencies for '{target.__name__}' in module '{module_name}'.\n"
-                    f"This typically happens when two modules import each other. Consider:\n"
-                    f"1. Restructuring your code to avoid circular dependencies\n"
-                    f"2. Using delayed imports inside methods rather than at module level\n"
-                    f"3. Using dependency injection to break the cycle\n"
-                    f"Original error: {import_msg}"
-                ) from e
-            else:
-                raise OrionisContainerException(
-                    f"Import error while resolving dependencies for '{target.__name__}' in module '{module_name}':\n"
-                    f"{import_msg}"
-                ) from e
-
-        except Exception as e:
-
-            # Get more context about where the error occurred
-            target_type = "class" if isinstance(target, type) else "function"
-            target_name = target.__name__ if hasattr(target, '__name__') else str(target)
-            module_name = target.__module__ if hasattr(target, '__module__') else "unknown module"
-
-            raise OrionisContainerException(
-                f"Error resolving dependencies for {target_type} '{target_name}' in '{module_name}':\n"
-                f"{str(e)}\n"
-                f"Check that all dependencies are properly registered in the container."
-            ) from e
+        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)