orionis 0.21.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

orionis/framework.py

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

orionis/luminate/bootstrap/config/register.py

@@ -28,7 +28,7 @@ class Register(IRegister):
         """
         self.cache = cache
 
-    def config(self, config_class: type) -> type:
+    def config(self, config_class: type) -> None:
         """
         Registers a configuration class and ensures it meets the required structure.
 

orionis/luminate/container/container.py

@@ -1,385 +1,420 @@
 import inspect
-from typing import Any, Callable
+from collections import deque
+from threading import Lock
+from typing import Callable, Any, Dict
+from orionis.luminate.container.exception import OrionisContainerException, OrionisContainerValueError, OrionisContainerTypeError
 from orionis.luminate.container.types import Types
-from orionis.luminate.tools.dot_dict import DotDict
 from orionis.luminate.contracts.container.container_interface import IContainer
-from orionis.luminate.container.exception import OrionisContainerException, OrionisContainerValueError
+
+BINDING = 'binding'
+TRANSIENT = 'transient'
+SINGLETON = 'singleton'
+SCOPED = 'scoped'
+INSTANCE = 'instance'
 
 class Container(IContainer):
-    """Service container and dependency injection."""
+    """
+    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()
 
     def __new__(cls):
         if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._config = {}
-            
-            cls._instance._bindings = {}
-            cls._instance._transients = {}
-            cls._instance._singletons = {}
-            cls._instance._scoped_services = {}
-            cls._instance._instances = {}
-            cls._instance._aliases = {}
-            cls._instance._scoped_instances = {}
-            cls._instance._conditional_bindings = {}
-            # Initialize the PrimitiveTypes validator
-            cls._instance._primitive_types_validator = Types()
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._bindings = {}
+                    cls._instance._transients = {}
+                    cls._instance._singletons = {}
+                    cls._instance._scoped_services = {}
+                    cls._instance._instances = {}
+                    cls._instance._aliases = {}
+                    cls._instance._scoped_instances = {}
+                    cls._instance._validate_types = Types()
         return cls._instance
 
-    def config(self, section: str, data: dict):
+    def _newRequest(self) -> None:
         """
-        Registers a configuration section in the container.
-
-        Args:
-            section (str): _description_
-            data (dict): _description_
+        Reset scoped instances at the beginning of a new request.
         """
+        self._scoped_instances = {}
 
-        # Validate that data is a dictionary
-        if not isinstance(data, dict):
-            raise OrionisContainerValueError("The 'data' parameter must be a dictionary.")
-
-        # Validate that the section is a string
-        if not isinstance(section, str):
-            raise OrionisContainerValueError("The 'section' parameter must be a string.")
-
-        if section not in self._config:
-            self._config[section] = data
-        else:
-            self._config[section].update(data)
+    def _ensureNotMain(self, 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."
+            )
+        return f"{concrete.__module__}.{concrete.__name__}"
 
-    def bind(self, abstract: str, concrete: Callable[..., Any]) -> None:
-        """Registers a service with a specific implementation.
+    def _ensureUniqueService(self, obj: Any) -> None:
+        """
+        Ensure that a service is not already registered.
 
-        Args:
-            abstract (str): Name or key of the service to register.
-            concrete (Callable[..., Any]): Concrete implementation of the service.
+        Parameters
+        ----------
+        obj : Any
+            The service to check.
 
-        Raises:
-            OrionisContainerException: If the service is already registered.
-            TypeError: If the implementation is not a callable or instantiable class.
+        Raises
+        ------
+        OrionisContainerValueError
+            If the service is already registered.
         """
+        if self.has(obj):
+            raise OrionisContainerValueError("The service is already registered in the container.")
 
-        # Validate that the abstract name is not a primitive type
-        self._primitiveTypeValidator(abstract)
+    def _ensureIsCallable(self, concrete: Callable[..., Any]) -> None:
+        """
+        Ensure that the given implementation is callable or instantiable.
 
-        if self.has(abstract):
-            raise OrionisContainerException(f"The service '{abstract}' is already registered in the container.")
+        Parameters
+        ----------
+        concrete : Callable[..., Any]
+            The implementation to check.
 
+        Raises
+        ------
+        OrionisContainerTypeError
+            If the implementation is not callable.
+        """
         if not callable(concrete):
-            raise TypeError(f"The implementation of '{abstract}' must be a callable or instantiable class.")
-
-        self._bindings[abstract] = concrete
-
-    def transient(self, abstract: str, concrete: Callable[..., Any]) -> None:
-        """Registers a service as Transient, creating a new instance on each request.
+            raise OrionisContainerTypeError(
+                f"The implementation '{str(concrete)}' must be callable or an instantiable class."
+            )
 
-        Args:
-            abstract (str): Name or key of the service to register.
-            concrete (Callable[..., Any]): Concrete implementation of the service.
-
-        Raises:
-            OrionisContainerException: If the service is already registered.
-            TypeError: If the implementation is not a callable or instantiable class.
+    def _ensureIsInstance(self, instance: Any) -> None:
         """
+        Ensure that the given instance is a valid object.
 
-        # Validate that the abstract name is not a primitive type
-        self._primitiveTypeValidator(abstract)
+        Parameters
+        ----------
+        instance : Any
+            The instance to check.
 
-        if self.has(abstract):
-            raise OrionisContainerException(f"The service '{abstract}' is already registered in the container.")
-
-        if not callable(concrete):
-            raise TypeError(f"The implementation of '{abstract}' must be a callable or instantiable class.")
-
-        self._transients[abstract] = concrete
-
-    def singleton(self, abstract: str, concrete: Callable[..., Any]) -> None:
-        """Registers a service as Singleton, ensuring a single shared instance.
+        Raises
+        ------
+        OrionisContainerValueError
+            If the instance is not a valid object.
+        """
+        if not isinstance(instance, object) or instance.__class__.__module__ in ['builtins', 'abc']:
+            raise OrionisContainerValueError(
+                f"The instance '{str(instance)}' must be a valid object."
+            )
 
+    def bind(self, concrete: Callable[..., Any]) -> str:
+        """
+        Bind a callable to the container.
+        This method ensures that the provided callable is not the main function,
+        is unique within the container, and is indeed callable. It then creates
+        a unique key for the callable based on its module and name, and stores
+        the callable in the container's bindings.
         Args:
-            abstract (str): Name or key of the service to register.
-            concrete (Callable[..., Any]): Concrete implementation of the service.
-
-        Raises:
-            OrionisContainerException: If the service is already registered.
-            TypeError: If the implementation is not a callable or instantiable class.
+            concrete (Callable[..., Any]): The callable to be bound to the container.
+        Returns:
+            str: The unique key generated for the callable.
         """
+        self._ensureNotMain(concrete)
+        self._ensureUniqueService(concrete)
+        self._ensureIsCallable(concrete)
 
-        # Validate that the abstract name is not a primitive type
-        self._primitiveTypeValidator(abstract)
-
-        if self.has(abstract):
-            raise OrionisContainerException(f"The service '{abstract}' is already registered in the container.")
-
-        if not callable(concrete):
-            raise TypeError(f"The implementation of '{abstract}' must be a callable or instantiable class.")
-
-        self._singletons[abstract] = concrete
+        key = f"{concrete.__module__}.{concrete.__name__}"
+        self._bindings[key] = {
+            'callback': concrete,
+            'module': concrete.__module__,
+            'name': concrete.__name__,
+            'type': BINDING
+        }
 
-    def scoped(self, abstract: str, concrete: Callable[..., Any]) -> None:
-        """Registers a service as Scoped, shared within the same request.
+        return key
 
+    def transient(self, concrete: Callable[..., Any]) -> str:
+        """
+        Registers a transient service in the container.
+        A transient service is created each time it is requested.
         Args:
-            abstract (str): Name or key of the service to register.
-            concrete (Callable[..., Any]): Concrete implementation of the service.
-
-        Raises:
-            OrionisContainerException: If the service is already registered.
-            TypeError: If the implementation is not a callable or instantiable class.
+            concrete (Callable[..., Any]): The callable that defines the service.
+        Returns:
+            str: The unique key generated for the callable.
         """
+        self._ensureNotMain(concrete)
+        self._ensureUniqueService(concrete)
+        self._ensureIsCallable(concrete)
 
-        # Validate that the abstract name is not a primitive type
-        self._primitiveTypeValidator(abstract)
+        key = f"{concrete.__module__}.{concrete.__name__}"
+        self._transients[key] = {
+            'callback': concrete,
+            'module': concrete.__module__,
+            'name': concrete.__name__,
+            'type': TRANSIENT
+        }
 
-        if self.has(abstract):
-            raise OrionisContainerException(f"The service '{abstract}' is already registered in the container.")
-
-        if not callable(concrete):
-            raise TypeError(f"The implementation of '{abstract}' must be a callable or instantiable class.")
-
-        self._scoped_services[abstract] = concrete
-
-    def instance(self, abstract: str, instance: Any) -> None:
-        """Registers a specific instance in the container, allowing it to be reused.
+        return key
 
+    def singleton(self, concrete: Callable[..., Any]) -> str:
+        """
+        Registers a callable as a singleton in the container.
+        This method ensures that the provided callable is not the main module,
+        is unique within the container, and is indeed callable. It then registers
+        the callable as a singleton, storing it in the container's singleton registry.
         Args:
-            abstract (str): Name or key of the service to register.
-            instance (Any): Specific instance of the service to register.
-
-        Raises:
-            OrionisContainerException: If the instance is already registered.
-            ValueError: If the provided instance is of an unexpected or invalid type.
+            concrete (Callable[..., Any]): The callable to be registered as a singleton.
+        Returns:
+            str: The key under which the singleton is registered in the container.
         """
+        self._ensureNotMain(concrete)
+        self._ensureUniqueService(concrete)
+        self._ensureIsCallable(concrete)
 
-        # Validate that the abstract name is not a primitive type
-        self._primitiveTypeValidator(abstract)
-
-        if abstract in self._instances:
-            raise OrionisContainerException(f"The instance '{abstract}' is already registered in the container.")
-
-        if not isinstance(instance, object):
-            raise ValueError(f"The instance of '{abstract}' must be a valid object.")
-
-        self._instances[abstract] = instance
+        key = f"{concrete.__module__}.{concrete.__name__}"
+        self._singletons[key] = {
+            'callback': concrete,
+            'module': concrete.__module__,
+            'name': concrete.__name__,
+            'type': SINGLETON
+        }
 
-    def has(self, abstract: str) -> bool:
-        """Checks if a service is registered in the container.
+        return key
 
-        Args:
-            abstract (str): Name or key of the service to check.
-
-        Returns:
-            bool: True if the service is registered, False otherwise.
-
-        Raises:
-            ValueError: If the service name (abstract) is not a valid string.
+    def scoped(self, concrete: Callable[..., Any]) -> str:
         """
-        # Check that 'abstract' is a string
-        if not isinstance(abstract, str):
-            raise ValueError(f"The service name '{abstract}' must be a string.")
-
-        # Efficient check if the service is in any of the containers
-        return any(abstract in container for container in [
-            self._bindings,
-            self._transients,
-            self._singletons,
-            self._scoped_services,
-            self._instances
-        ])
-
-    def alias(self, abstract: str, alias: str) -> None:
-        """Creates an alias for a registered service, allowing access to the service using an alternative name.
-
+        Registers a callable as a scoped service.
+        This method ensures that the provided callable is not the main service,
+        is unique, and is indeed callable. It then registers the callable in the
+        scoped services dictionary with relevant metadata.
         Args:
-            abstract (str): Name or key of the original service.
-            alias (str): The alias to assign to the service.
-
-        Raises:
-            OrionisContainerException: If the original service is not registered.
-            ValueError: If the alias is not a valid string or is already in use.
+            concrete (Callable[..., Any]): The callable to be registered as a scoped service.
+        Returns:
+            str: The key under which the callable is registered in the scoped services dictionary.
         """
+        self._ensureNotMain(concrete)
+        self._ensureUniqueService(concrete)
+        self._ensureIsCallable(concrete)
 
-        # Validate that the abstract name is not a primitive type
-        self._primitiveTypeValidator(abstract)
-
-        # Validate alias type
-        if not isinstance(alias, str) or not alias:
-            raise ValueError("The alias must be a non-empty string.")
-
-        # Check if the original service is registered
-        if not self.has(abstract):
-            raise OrionisContainerException(f"The service '{abstract}' is not registered in the container.")
-
-        # Check if the alias is already in use
-        if alias in self._aliases:
-            raise ValueError(f"The alias '{alias}' is already in use.")
+        key = f"{concrete.__module__}.{concrete.__name__}"
+        self._scoped_services[key] = {
+            'callback': concrete,
+            'module': concrete.__module__,
+            'name': concrete.__name__,
+            'type': SCOPED
+        }
 
-        self._aliases[alias] = abstract
-
-    def make(self, abstract: str):
-        """Automatically resolves a dependency, handling instances, singletons, scoped, transients, and aliases.
-
-        This method resolves the dependencies of a service and handles the following service types:
-        1. **Instances**: Returns a specific instance.
-        2. **Singletons**: Returns the same unique instance each time.
-        3. **Scoped**: Returns a shared instance within the same request.
-        4. **Transients**: Creates a new instance each time.
-        5. **Aliases**: Resolves an alias to the original service.
+        return key
 
+    def instance(self, instance: Any) -> str:
+        """
+        Registers an instance as a singleton in the container.
         Args:
-            abstract (str): Name or key of the service to resolve.
-
+            instance (Any): The instance to be registered as a singleton.
         Returns:
-            Any: The resolved instance or service.
-
+            str: The key under which the instance is registered in the container.
+        """
+        self._ensureNotMain(instance.__class__)
+        self._ensureUniqueService(instance)
+        self._ensureIsInstance(instance)
+
+        concrete = instance.__class__
+        key = f"{concrete.__module__}.{concrete.__name__}"
+        self._instances[key] = {
+            'instance': instance,
+            'module': concrete.__module__,
+            'name': concrete.__name__,
+            'type': INSTANCE
+        }
+
+        return key
+
+    def alias(self, alias: str, concrete: Any) -> None:
+        """
+        Creates an alias for a registered service.
+        Args:
+            alias (str): The alias name to be used for the service.
+            concrete (Any): The actual service instance or callable to be aliased.
         Raises:
-            OrionisContainerException: If the service is not found.
+            OrionisContainerException: If the concrete instance is not a valid object or if the alias is a primitive type.
         """
-        # If the service is a specific instance, return it directly
-        if abstract in self._instances:
-            return self._instances[abstract]
+        if not callable(concrete) and not isinstance(concrete, object):
+            raise OrionisContainerException(f"The instance '{str(concrete)}' must be a valid object.")
 
-        # If it is a singleton, return the same instance or resolve it if it is not yet resolved
-        if abstract in self._singletons:
-            if abstract not in self._instances:
-                self._instances[abstract] = self._resolve(self._singletons[abstract])
-            return self._instances[abstract]
+        if self._instance._validate_types.isPrimitive(alias):
+            raise OrionisContainerException(f"Cannot use primitive type '{alias}' as an alias.")
 
-        # If it is a scoped service, validate that it is in the same request context
-        if abstract in self._scoped_services:
-            if abstract not in self._scoped_instances:
-                self._scoped_instances[abstract] = self._resolve(self._scoped_services[abstract])
-            return self._scoped_instances[abstract]
+        if isinstance(concrete, object) and concrete.__class__.__module__ not in ['builtins', 'abc']:
+            cls_concrete = concrete.__class__
+            current_key = f"{cls_concrete.__module__}.{cls_concrete.__name__}"
+        elif callable(concrete):
+            current_key = f"{concrete.__module__}.{concrete.__name__}"
 
-        # If it is a transient service, create a new instance each time
-        if abstract in self._transients:
-            return self._resolve(self._transients[abstract])
+        self._aliases[alias] = current_key
 
-        # If it is a regular binding, resolve it directly
-        if abstract in self._bindings:
-            return self._resolve(self._bindings[abstract])
+    def has(self, obj: Any) -> bool:
+        """
+        Checks if a service is registered in the container.
 
-        # If it is an alias, resolve the alias recursively
-        if abstract in self._aliases:
-            return self.make(self._aliases[abstract])
+        Parameters
+        ----------
+        obj : Any
+            The service class, instance, or alias to check.
 
-        raise OrionisContainerValueError(f"No definition found for '{abstract}'. Ensure the service is registered.")
+        Returns
+        -------
+        bool
+            True if the service is registered, False otherwise.
+        """
+        if isinstance(obj, str):
+            return obj in self._aliases or obj in (
+                self._bindings | self._transients | self._singletons | self._scoped_services | self._instances
+            )
 
-    def call(self, instance: Any, method_name: str, **overrides):
-        """Llama a un método del objeto resolviendo automáticamente las dependencias registradas.
+        if isinstance(obj, object) and obj.__class__.__module__ not in {'builtins', 'abc'}:
+            key = f"{obj.__class__.__module__}.{obj.__class__.__name__}"
+            return key in self._instances
 
-        Args:
-            instance (Any): Instancia del objeto en el cual se ejecutará el método.
-            method_name (str): Nombre del método a llamar.
-            **overrides: Argumentos que se deben pasar manualmente en lugar de resolverlos automáticamente.
+        if callable(obj):
+            key = f"{obj.__module__}.{obj.__name__}"
+            return key in (
+                self._bindings | self._transients | self._singletons | self._scoped_services | self._aliases
+            )
 
-        Returns:
-            Any: El resultado de ejecutar el método con las dependencias resueltas.
+        return False
 
-        Raises:
-            AttributeError: Si el método no existe en la instancia.
+    def make(self, abstract: Any) -> Any:
         """
-        if not hasattr(instance, method_name):
-            raise AttributeError(f"'{instance.__class__.__name__}' has no method '{method_name}'")
-
-        method = getattr(instance, method_name)
-        signature = inspect.signature(method)
-        dependencies = {}
-
-        for name, param in signature.parameters.items():
-            if name in overrides:
-                dependencies[name] = overrides[name]
-            elif param.annotation != inspect.Parameter.empty:
-                # Check if the type is primitive
-                if isinstance(param.annotation, type):
-                    # It is a primitive type like str, int, etc.
-                    dependencies[name] = param.default if param.default != inspect.Parameter.empty else param.annotation()
-                else:
-                    dependencies[name] = self.make(param.annotation.__name__)
-            elif param.default != inspect.Parameter.empty:
-                dependencies[name] = param.default
-            else:
-                raise OrionisContainerValueError(f"Cannot resolve parameter '{name}' in method '{method_name}'")
-
-        return method(**dependencies)
-
+        Create and return an instance of a registered service.
+
+        Parameters
+        ----------
+        abstract : Any
+            The service class or alias to instantiate.
+
+        Returns
+        -------
+        Any
+            An instance of the requested service.
+
+        Raises
+        ------
+        OrionisContainerException
+            If the service is not found in the container.
+        """
+        key = self._aliases.get(abstract, abstract)
 
-    def _primitiveTypeValidator(self, abstract: str) -> None:
-        """Validates that the abstract name is not a primitive type.
+        if key in self._instances:
+            return self._instances[key]['instance']
 
-        Args:
-            abstract (str): Name of the service to validate.
+        if key in self._singletons:
+            self._instances[key] = {'instance': self._resolve(self._singletons[key]['callback'])}
+            return self._instances[key]['instance']
 
-        Raises:
-            OrionisContainerException: If the service name matches a primitive type.
-        """
-        if self._primitive_types_validator.isPrimitive(abstract):
-            raise OrionisContainerException(f"Cannot register a service with a name equal to a primitive type: '{abstract}'.")
+        if key in self._scoped_services:
+            if key not in self._scoped_instances:
+                self._scoped_instances[key] = self._resolve(self._scoped_services[key]['callback'])
+            return self._scoped_instances[key]
 
-    def _resolve(self, concrete: Callable[..., Any]):
-        """Automatically resolves the dependencies of a service, handling its constructor dependencies.
+        if key in self._transients:
+            return self._resolve(self._transients[key]['callback'])
 
-        If the service is a class, it recursively resolves its dependencies (constructor parameters).
+        if key in self._bindings:
+            return self._resolve(self._bindings[key]['callback'])
 
-        Args:
-            concrete (Callable[..., Any]): Concrete implementation of the service.
+        raise OrionisContainerException(f"Service '{abstract}' is not registered in the container.")
 
-        Returns:
-            Any: The resolved service instance.
-
-        Raises:
-            ValueError: If there is a constructor parameter whose type cannot be resolved.
+    def _resolve(self, concrete: Callable[..., Any]) -> Any:
         """
-        if inspect.isclass(concrete):
-            constructor = inspect.signature(concrete.__init__)
-            parameters = constructor.parameters
-
-            # If the class has no parameters in its constructor, instantiate it directly
-            if len(parameters) == 0 or (len(parameters) == 1 and "self" in parameters):
-                return concrete()
+        Resolve and instantiate a given service class or function.
 
-            # Resolve the dependencies of the class constructor
-            dependencies = {}
-            for name, param in parameters.items():
-                if name == "self" or param.kind in (param.VAR_POSITIONAL, param.VAR_KEYWORD):
-                    continue
+        This method analyzes the constructor of the given class (or callable),
+        retrieves its dependencies, and resolves them recursively, while respecting
+        the service lifecycle.
+        """
 
+        # Step 1: Retrieve the constructor signature of the class or callable.
+        try:
+            signature = inspect.signature(concrete)
+        except ValueError as e:
+            raise OrionisContainerException(f"Unable to inspect signature of {concrete}: {str(e)}")
+
+        # Step 2: Prepare a dictionary for resolved dependencies and a queue for unresolved ones.
+        resolved_dependencies: Dict[str, Any] = {}
+        unresolved_dependencies = deque()
+
+        # Step 3: Iterate through the parameters of the constructor.
+        for param_name, param in signature.parameters.items():
+            if param_name == 'self':
+                # Skip 'self' in methods
+                continue
+
+            # If parameter has no annotation and no default value, it's unresolved
+            if param.annotation is param.empty and param.default is param.empty:
+                unresolved_dependencies.append(param_name)
+                continue
+
+            # Resolve dependencies based on annotations (excluding primitive types)
+            if param.annotation is not param.empty:
                 param_type = param.annotation
-
-                # If the parameter has a default value, use it directly
-                if param_type == param.empty:
-                    if param.default != param.empty:
-                        # Use the default value if available
-                        dependencies[name] = param.default
-                        continue
+                # Check if it's a registered service, if so, resolve it through the container
+                if isinstance(param_type, type) and not isinstance(param_type, (int, str, bool, float)) and not issubclass(param_type, (int, str, bool, float)):
+                    # Check if the service is registered in the container
+                    if self.has(param_type):
+                        resolved_dependencies[param_name] = self.make(f"{param_type.__module__}.{param_type.__name__}")
                     else:
-                        raise OrionisContainerValueError(f"Parameter type {name} not specified in {concrete.__name__}")
-
-                # If the parameter type is a primitive (str, int, etc.), pass it as is
-                if isinstance(param_type, type):
-                    if param.default != param.empty:
-                        dependencies[name] = param.default if param.default != param.empty else param_type()
-                    else:
-                        dependencies[name] = param_type()  # Provide default value for primitive types if not specified
+                        resolved_dependencies[param_name] = self._resolve_dependency(param_type)
                 else:
-                    dep_name = param_type.__name__
+                    resolved_dependencies[param_name] = param_type  # It's a primitive, use as-is
 
-                    # Conditional resolution of dependencies, if registered
-                    if concrete in self._conditional_bindings and dep_name in self._conditional_bindings[concrete]:
-                        dependencies[name] = self.make(self._conditional_bindings[concrete][dep_name])
-                    else:
-                        dependencies[name] = self.make(dep_name)
+            # Resolve parameters with default values (without annotations)
+            elif param.default is not param.empty:
+                resolved_dependencies[param_name] = param.default
 
-            return concrete(**dependencies)
+        # Step 4: Resolve any remaining unresolved dependencies.
+        while unresolved_dependencies:
+            dep_name = unresolved_dependencies.popleft()
+            if dep_name not in resolved_dependencies:
+                resolved_dependencies[dep_name] = self._resolve_dependency(dep_name)
 
-        return concrete(self)
+        # Step 5: Instantiate the class with resolved dependencies.
+        try:
+            return concrete(**resolved_dependencies)
+        except Exception as e:
+            raise OrionisContainerException(f"Failed to instantiate {concrete}: {str(e)}")
 
-    def startRequest(self):
-        """Starts a new request and clears the Scoped instances.
+    def _resolve_dependency(self, dep_type: Any) -> Any:
+        """
+        Resolves a dependency based on the provided type.
 
-        This method should be called at the beginning of each request to ensure that
-        scoped services do not persist between requests.
+        This method looks for the type in the container and returns the instance,
+        respecting the lifecycle of the service (transient, singleton, etc.).
         """
-        self._scoped_instances = {}
+        # Check if the dependency exists in the container or create it if necessary
+        # If it's a class type
+        if isinstance(dep_type, type):
+            if self.has(dep_type):
+                # Resolves the service through the container
+                return self.make(f"{dep_type.__module__}.{dep_type.__name__}")
+            else:
+                # Instantiate the class if not found in the container
+                return self._resolve(dep_type)
+
+        raise OrionisContainerException(f"Cannot resolve dependency of type {dep_type}")

orionis/luminate/container/exception.py

@@ -34,3 +34,21 @@ class OrionisContainerValueError(ValueError):
     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/luminate/contracts/bootstrap/config/register_interface.py

@@ -14,12 +14,12 @@ class IRegister(ABC):
 
     Methods
     -------
-    config(config_class: type) -> type
+    config(config_class: type) -> None
         Registers a configuration class and ensures it meets the necessary criteria.
     """
 
     @abstractmethod
-    def config(self, config_class: type) -> type:
+    def config(self, config_class: type) -> None:
         """
         Registers a configuration class and ensures it meets the required structure.
 

orionis/luminate/contracts/container/container_interface.py

@@ -2,151 +2,221 @@ from abc import ABC, abstractmethod
 from typing import Any, Callable
 
 class IContainer(ABC):
-    """Service container and dependency injection."""
 
     @abstractmethod
-    def bind(self, abstract: str, concrete: Callable[..., Any]) -> None:
-        """Registers a service with a specific implementation.
-
-        Args:
-            abstract (str): Name or key of the service to register.
-            concrete (Callable[..., Any]): Concrete implementation of the service.
+    def _newRequest(self) -> None:
+        """
+        Reset scoped instances at the beginning of a new request.
+        """
+        pass
 
-        Raises:
-            OrionisContainerException: If the service is already registered.
-            TypeError: If the implementation is not a callable or instantiable class.
+    @abstractmethod
+    def _ensureNotMain(self, 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.
         """
         pass
 
     @abstractmethod
-    def transient(self, abstract: str, concrete: Callable[..., Any]) -> None:
-        """Registers a service as Transient, creating a new instance on each request.
+    def _ensureUniqueService(self, obj: Any) -> None:
+        """
+        Ensure that a service is not already registered.
 
-        Args:
-            abstract (str): Name or key of the service to register.
-            concrete (Callable[..., Any]): Concrete implementation of the service.
+        Parameters
+        ----------
+        obj : Any
+            The service to check.
 
-        Raises:
-            OrionisContainerException: If the service is already registered.
-            TypeError: If the implementation is not a callable or instantiable class.
+        Raises
+        ------
+        OrionisContainerValueError
+            If the service is already registered.
         """
         pass
 
     @abstractmethod
-    def singleton(self, abstract: str, concrete: Callable[..., Any]) -> None:
-        """Registers a service as Singleton, ensuring a single shared instance.
+    def _ensureIsCallable(self, concrete: Callable[..., Any]) -> None:
+        """
+        Ensure that the given implementation is callable or instantiable.
 
-        Args:
-            abstract (str): Name or key of the service to register.
-            concrete (Callable[..., Any]): Concrete implementation of the service.
+        Parameters
+        ----------
+        concrete : Callable[..., Any]
+            The implementation to check.
 
-        Raises:
-            OrionisContainerException: If the service is already registered.
-            TypeError: If the implementation is not a callable or instantiable class.
+        Raises
+        ------
+        OrionisContainerTypeError
+            If the implementation is not callable.
         """
         pass
 
     @abstractmethod
-    def scoped(self, abstract: str, concrete: Callable[..., Any]) -> None:
-        """Registers a service as Scoped, shared within the same request.
+    def _ensureIsInstance(self, instance: Any) -> None:
+        """
+        Ensure that the given instance is a valid object.
 
-        Args:
-            abstract (str): Name or key of the service to register.
-            concrete (Callable[..., Any]): Concrete implementation of the service.
+        Parameters
+        ----------
+        instance : Any
+            The instance to check.
 
-        Raises:
-            OrionisContainerException: If the service is already registered.
-            TypeError: If the implementation is not a callable or instantiable class.
+        Raises
+        ------
+        OrionisContainerValueError
+            If the instance is not a valid object.
         """
         pass
 
     @abstractmethod
-    def instance(self, abstract: str, instance: Any) -> None:
-        """Registers a specific instance in the container, allowing it to be reused.
-
+    def bind(self, concrete: Callable[..., Any]) -> str:
+        """
+        Bind a callable to the container.
+        This method ensures that the provided callable is not the main function,
+        is unique within the container, and is indeed callable. It then creates
+        a unique key for the callable based on its module and name, and stores
+        the callable in the container's bindings.
         Args:
-            abstract (str): Name or key of the service to register.
-            instance (Any): Specific instance of the service to register.
-
-        Raises:
-            OrionisContainerException: If the instance is already registered.
-            ValueError: If the provided instance is of an unexpected or invalid type.
+            concrete (Callable[..., Any]): The callable to be bound to the container.
+        Returns:
+            str: The unique key generated for the callable.
         """
         pass
 
     @abstractmethod
-    def has(self, abstract: str) -> bool:
-        """Checks if a service is registered in the container.
-
+    def transient(self, concrete: Callable[..., Any]) -> str:
+        """
+        Registers a transient service in the container.
+        A transient service is created each time it is requested.
         Args:
-            abstract (str): Name or key of the service to check.
-
+            concrete (Callable[..., Any]): The callable that defines the service.
         Returns:
-            bool: True if the service is registered, False otherwise.
-
-        Raises:
-            ValueError: If the service name (abstract) is not a valid string.
+            str: The unique key generated for the callable.
         """
         pass
 
     @abstractmethod
-    def alias(self, abstract: str, alias: str) -> None:
-        """Creates an alias for a registered service, allowing access to the service using an alternative name.
-
+    def singleton(self, concrete: Callable[..., Any]) -> str:
+        """
+        Registers a callable as a singleton in the container.
+        This method ensures that the provided callable is not the main module,
+        is unique within the container, and is indeed callable. It then registers
+        the callable as a singleton, storing it in the container's singleton registry.
         Args:
-            abstract (str): Name or key of the original service.
-            alias (str): The alias to assign to the service.
-
-        Raises:
-            OrionisContainerException: If the original service is not registered.
-            ValueError: If the alias is not a valid string or is already in use.
+            concrete (Callable[..., Any]): The callable to be registered as a singleton.
+        Returns:
+            str: The key under which the singleton is registered in the container.
         """
         pass
 
     @abstractmethod
-    def make(self, abstract: str):
-        """Automatically resolves a dependency, handling instances, singletons, scoped, transients, and aliases.
-
-        This method resolves the dependencies of a service and handles the following service types:
-        1. **Instances**: Returns a specific instance.
-        2. **Singletons**: Returns the same unique instance each time.
-        3. **Scoped**: Returns a shared instance within the same request.
-        4. **Transients**: Creates a new instance each time.
-        5. **Aliases**: Resolves an alias to the original service.
-
+    def scoped(self, concrete: Callable[..., Any]) -> str:
+        """
+        Registers a callable as a scoped service.
+        This method ensures that the provided callable is not the main service,
+        is unique, and is indeed callable. It then registers the callable in the
+        scoped services dictionary with relevant metadata.
         Args:
-            abstract (str): Name or key of the service to resolve.
+            concrete (Callable[..., Any]): The callable to be registered as a scoped service.
+        Returns:
+            str: The key under which the callable is registered in the scoped services dictionary.
+        """
+        pass
 
+    @abstractmethod
+    def instance(self, instance: Any) -> str:
+        """
+        Registers an instance as a singleton in the container.
+        Args:
+            instance (Any): The instance to be registered as a singleton.
         Returns:
-            Any: The resolved instance or service.
+            str: The key under which the instance is registered in the container.
+        """
+        pass
 
+    @abstractmethod
+    def alias(self, alias: str, concrete: Any) -> None:
+        """
+        Creates an alias for a registered service.
+        Args:
+            alias (str): The alias name to be used for the service.
+            concrete (Any): The actual service instance or callable to be aliased.
         Raises:
-            OrionisContainerException: If the service is not found.
+            OrionisContainerException: If the concrete instance is not a valid object or if the alias is a primitive type.
         """
         pass
 
     @abstractmethod
-    def call(self, instance: Any, method_name: str, **overrides):
-        """Llama a un método del objeto resolviendo automáticamente las dependencias registradas.
+    def has(self, obj: Any) -> bool:
+        """
+        Checks if a service is registered in the container.
 
-        Args:
-            instance (Any): Instancia del objeto en el cual se ejecutará el método.
-            method_name (str): Nombre del método a llamar.
-            **overrides: Argumentos que se deben pasar manualmente en lugar de resolverlos automáticamente.
+        Parameters
+        ----------
+        obj : Any
+            The service class, instance, or alias to check.
 
-        Returns:
-            Any: El resultado de ejecutar el método con las dependencias resueltas.
+        Returns
+        -------
+        bool
+            True if the service is registered, False otherwise.
+        """
+        pass
 
-        Raises:
-            AttributeError: Si el método no existe en la instancia.
+    @abstractmethod
+    def make(self, abstract: Any) -> Any:
+        """
+        Create and return an instance of a registered service.
+
+        Parameters
+        ----------
+        abstract : Any
+            The service class or alias to instantiate.
+
+        Returns
+        -------
+        Any
+            An instance of the requested service.
+
+        Raises
+        ------
+        OrionisContainerException
+            If the service is not found in the container.
         """
         pass
 
     @abstractmethod
-    def startRequest(self):
-        """Starts a new request and clears the Scoped instances.
+    def _resolve(self, concrete: Callable[..., Any]) -> Any:
+        """
+        Resolve and instantiate a given service class or function.
+
+        This method analyzes the constructor of the given class (or callable),
+        retrieves its dependencies, and resolves them recursively, while respecting
+        the service lifecycle.
+        """
+        pass
+
+    @abstractmethod
+    def _resolve_dependency(self, dep_type: Any) -> Any:
+        """
+        Resolves a dependency based on the provided type.
 
-        This method should be called at the beginning of each request to ensure that
-        scoped services do not persist between requests.
+        This method looks for the type in the container and returns the instance,
+        respecting the lifecycle of the service (transient, singleton, etc.).
         """
         pass

{orionis-0.21.0.dist-info → orionis-0.23.0.dist-info}/METADATA

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

{orionis-0.21.0.dist-info → orionis-0.23.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 orionis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/cli_manager.py,sha256=9wNVJxB0HyqUbNesUvkwlsqTyUbZwK6R46iVLE5WVBQ,1715
-orionis/framework.py,sha256=k_g_WMiIzgDUFiruVSieOBZuK9R93xSSJ6rtZh92Oqo,1386
+orionis/framework.py,sha256=erUuf0Lfq0_tWOuxBX6r_arQFnqBRgk7te6RPxymQRI,1386
 orionis/luminate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/app.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/bootstrap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/bootstrap/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/bootstrap/config/bootstrapper.py,sha256=R1ixec362o-Td-kNSvi-0ylVqspFWJq6L6IHYzWHPmg,4227
 orionis/luminate/bootstrap/config/parser.py,sha256=Ay8dh3aax9xhVgeLSHT71ubtZJiKAJAP85dLFF7djyA,1950
-orionis/luminate/bootstrap/config/register.py,sha256=SYG-wBCiVbRAJWr33iWYesqVdWzGEmqxszryuwJankI,2760
+orionis/luminate/bootstrap/config/register.py,sha256=uX0XGEWdo3iJou5B96vxvhZEjliTGC1HBaT8w9enMmk,2760
 orionis/luminate/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/cache/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/cache/app/config.py,sha256=tSHZ7sL_nYSz0aQOo_WkhYYchV1Q9ZdHOWUeHx7uwxE,2242
@@ -53,13 +53,13 @@ orionis/luminate/console/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRk
 orionis/luminate/console/scripts/management.py,sha256=KT6Bg8kyuUw63SNAtZo6tLH6syOEkxM9J70tCpKgrUw,2860
 orionis/luminate/console/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/console/tasks/scheduler.py,sha256=h3fRVTx6TuZVcY7zZ6oOzGDnlDAWaRwkj92pFTGUm6E,22686
-orionis/luminate/container/container.py,sha256=rgUQ1fJslFR-0nxzpubAGEMXAiZZlVd_TjONPOrXjv4,16498
-orionis/luminate/container/exception.py,sha256=Tf7KdfbEtr0YldhZ1WrKfkBlI5W_KvZO61xWAGFdF0A,1156
+orionis/luminate/container/container.py,sha256=O4AKaRQK2XfN0es70lIxUGkP0mxxemSsHOOuvtJVcUU,16212
+orionis/luminate/container/exception.py,sha256=ap1SqYEjQEEHXJJTNmL7V1jrmRjgT5_7geZ95MYkhMA,1691
 orionis/luminate/container/types.py,sha256=PbPNOJ8e4SGzCmu-zOmCQmDzt1b9I73v3fw_xzLq9RU,932
 orionis/luminate/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/contracts/bootstrap/config/bootstrapper_interface.py,sha256=De6nKQcZpN1dWsubXWUO229ZH4IbCoUaGtP5HOUw2Ps,2251
 orionis/luminate/contracts/bootstrap/config/parser_interface.py,sha256=7DLnp7yB7edayVkSm-piTi8JSf0QKaYYI82qDZudgM0,1641
-orionis/luminate/contracts/bootstrap/config/register_interface.py,sha256=600rNNM9SaYlVuDTSirfNpwEVHODdu_ZMj_dOx_vJkU,1506
+orionis/luminate/contracts/bootstrap/config/register_interface.py,sha256=7kMW04ptvQ51PnprtCIR-iLHljVSGiH58GN493igeuw,1506
 orionis/luminate/contracts/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/contracts/cache/cache_commands_interface.py,sha256=NhJAh2OZHXKMwbJ8nOU4IFJRZpuJNmfN9rtnpbCnuOo,1936
 orionis/luminate/contracts/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -80,7 +80,7 @@ orionis/luminate/contracts/console/register_interface.py,sha256=rhHI_as_3yNWtdgQ
 orionis/luminate/contracts/console/runner_interface.py,sha256=vWLtMhl0m1T6rfCUHZbxGQJl9ZWTXlp3HjcTfCAztGk,1644
 orionis/luminate/contracts/console/schedule_interface.py,sha256=_dsR0gCvJ7_67lwPUAzBwQFHNvWM6jVjcg1EdPqDIIo,10117
 orionis/luminate/contracts/console/task_manager_interface.py,sha256=sOmeifoncpWCG2WYh4q3QZ7M7w7P9Onb3Jxw9X2lpXE,1197
-orionis/luminate/contracts/container/container_interface.py,sha256=Pzvyu5guJkHCxqzHf0Z6JGSLVMwekhrLvccDkPXgC-0,5764
+orionis/luminate/contracts/container/container_interface.py,sha256=c_QRQHXGIujiDnYXyt--3J2LKXngVtoB3O-qchPmFDQ,6899
 orionis/luminate/contracts/container/types_interface.py,sha256=GCH7x3PjpXKPET3l84GcXbcM8cpne8AGrmTw-uFaT24,526
 orionis/luminate/contracts/facades/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/contracts/facades/env_interface.py,sha256=aN9dZdsuCpy3meZqMxyxLCYlKEIF7XkRNXmP7aS7eCw,1664
@@ -140,9 +140,9 @@ tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/tools/class_example.py,sha256=dIPD997Y15n6WmKhWoOFSwEldRm9MdOHTZZ49eF1p3c,1056
 tests/tools/test_reflection.py,sha256=dNN5p_xAosyEf0ddAElmmmTfhcTtBd4zBNl7qzgnsc0,5242
-orionis-0.21.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
-orionis-0.21.0.dist-info/METADATA,sha256=oLJmgUO2APvJ2njDurl99MM_4TBcWGLfuYprWUV99nE,2978
-orionis-0.21.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-orionis-0.21.0.dist-info/entry_points.txt,sha256=eef1_CVewfokKjrGBynXa06KabSJYo7LlDKKIKvs1cM,53
-orionis-0.21.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.21.0.dist-info/RECORD,,
+orionis-0.23.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.23.0.dist-info/METADATA,sha256=IBV6Pic2odjpNmHFEEZUIDIGrkjVPg48VsrQApR669c,2978
+orionis-0.23.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+orionis-0.23.0.dist-info/entry_points.txt,sha256=eef1_CVewfokKjrGBynXa06KabSJYo7LlDKKIKvs1cM,53
+orionis-0.23.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.23.0.dist-info/RECORD,,