orionis 0.8.0__tar.gz → 0.9.0__tar.gz

{orionis-0.8.0/orionis.egg-info → orionis-0.9.0}/PKG-INFO

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

{orionis-0.8.0 → orionis-0.9.0}/orionis/framework.py

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

{orionis-0.8.0 → orionis-0.9.0}/orionis/luminate/container/container.py

@@ -1,8 +1,10 @@
 import inspect
 from typing import Any, Callable
+from orionis.luminate.container.types import Types
+from orionis.luminate.contracts.container.container_interface import IContainer
 from orionis.luminate.container.exception import OrionisContainerException, OrionisContainerValueError
 
-class Container:
+class Container(IContainer):
     """Service container and dependency injection."""
 
     _instance = None
@@ -18,6 +20,8 @@ class Container:
             cls._instance._aliases = {}
             cls._instance._scoped_instances = {}
             cls._instance._conditional_bindings = {}
+            # Initialize the PrimitiveTypes validator
+            cls._instance._primitive_types_validator = Types()
         return cls._instance
 
     def bind(self, abstract: str, concrete: Callable[..., Any]) -> None:
@@ -31,6 +35,10 @@ class Container:
             OrionisContainerException: If the service is already registered.
             TypeError: If the implementation is not a callable or instantiable class.
         """
+
+        # 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.")
 
@@ -50,6 +58,10 @@ class Container:
             OrionisContainerException: If the service is already registered.
             TypeError: If the implementation is not a callable or instantiable class.
         """
+
+        # 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.")
 
@@ -69,6 +81,10 @@ class Container:
             OrionisContainerException: If the service is already registered.
             TypeError: If the implementation is not a callable or instantiable class.
         """
+
+        # 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.")
 
@@ -88,6 +104,10 @@ class Container:
             OrionisContainerException: If the service is already registered.
             TypeError: If the implementation is not a callable or instantiable class.
         """
+
+        # 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.")
 
@@ -107,6 +127,10 @@ class Container:
             OrionisContainerException: If the instance is already registered.
             ValueError: If the provided instance is of an unexpected or invalid type.
         """
+
+        # 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.")
 
@@ -151,6 +175,10 @@ class Container:
             OrionisContainerException: If the original service is not registered.
             ValueError: If the alias is not a valid string or is already in use.
         """
+
+        # 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.")
@@ -214,6 +242,57 @@ class Container:
 
         raise OrionisContainerValueError(f"No definition found for '{abstract}'. Ensure the service is registered.")
 
+    def call(self, instance: Any, method_name: str, **overrides):
+        """Llama a un método del objeto resolviendo automáticamente las dependencias registradas.
+
+        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.
+
+        Returns:
+            Any: El resultado de ejecutar el método con las dependencias resueltas.
+
+        Raises:
+            AttributeError: Si el método no existe en la instancia.
+        """
+        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)
+
+
+    def _primitiveTypeValidator(self, abstract: str) -> None:
+        """Validates that the abstract name is not a primitive type.
+
+        Args:
+            abstract (str): Name of the service to validate.
+
+        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}'.")
+
     def _resolve(self, concrete: Callable[..., Any]):
         """Automatically resolves the dependencies of a service, handling its constructor dependencies.
 
@@ -242,25 +321,31 @@ class Container:
                 if name == "self" or param.kind in (param.VAR_POSITIONAL, param.VAR_KEYWORD):
                     continue
 
-                # If the parameter has a default value, use it directly
                 param_type = param.annotation
 
-                # If the parameter type is not specified, try to resolve it by name
+                # 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
+                    else:
+                        raise OrionisContainerValueError(f"Parameter type {name} not specified in {concrete.__name__}")
 
-                    raise OrionisContainerValueError(f"Parameter type {name} not specified in {concrete.__name__}")
-
-                # If the parameter type is a primitive, use it directly
-                dep_name = param_type.__name__
-
-                # 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])
+                # 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
                 else:
-                    dependencies[name] = self.make(dep_name)
+                    dep_name = param_type.__name__
+
+                    # 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)
 
             return concrete(**dependencies)
 

orionis-0.9.0/orionis/luminate/container/types.py

@@ -0,0 +1,25 @@
+from orionis.luminate.contracts.container.types_interface import ITypes
+
+class Types(ITypes):
+    """A class that handles validation of primitive types to prevent registering services with primitive-type names."""
+
+    # A set of common primitive types in Python
+    _primitive_types = {
+        int, float, str, bool, bytes, type(None), complex,
+        list, tuple, dict, set, frozenset,
+        "int", "float", "str", "bool", "bytes", "None", "complex",
+        "list", "tuple", "dict", "set", "frozenset"
+    }
+
+    def isPrimitive(self, name: str) -> None:
+        """Checks if the provided name corresponds to a primitive type.
+
+        Args:
+            name (str): The name of the service or alias to check.
+
+        Raises:
+            OrionisContainerException: If the name matches a primitive type.
+        """
+        if name in self._primitive_types:
+            return True
+        return False

orionis-0.9.0/orionis/luminate/contracts/container/container_interface.py

@@ -0,0 +1,152 @@
+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.
+
+        Raises:
+            OrionisContainerException: If the service is already registered.
+            TypeError: If the implementation is not a callable or instantiable class.
+        """
+        pass
+
+    @abstractmethod
+    def transient(self, abstract: str, concrete: Callable[..., Any]) -> None:
+        """Registers a service as Transient, creating a new instance on each request.
+
+        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.
+        """
+        pass
+
+    @abstractmethod
+    def singleton(self, abstract: str, concrete: Callable[..., Any]) -> None:
+        """Registers a service as Singleton, ensuring a single shared instance.
+
+        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.
+        """
+        pass
+
+    @abstractmethod
+    def scoped(self, abstract: str, concrete: Callable[..., Any]) -> None:
+        """Registers a service as Scoped, shared within the same request.
+
+        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.
+        """
+        pass
+
+    @abstractmethod
+    def instance(self, abstract: str, instance: Any) -> None:
+        """Registers a specific instance in the container, allowing it to be reused.
+
+        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.
+        """
+        pass
+
+    @abstractmethod
+    def has(self, abstract: str) -> bool:
+        """Checks if a service is registered in the container.
+
+        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.
+        """
+        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.
+
+        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.
+        """
+        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.
+
+        Args:
+            abstract (str): Name or key of the service to resolve.
+
+        Returns:
+            Any: The resolved instance or service.
+
+        Raises:
+            OrionisContainerException: If the service is not found.
+        """
+        pass
+
+    @abstractmethod
+    def call(self, instance: Any, method_name: str, **overrides):
+        """Llama a un método del objeto resolviendo automáticamente las dependencias registradas.
+
+        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.
+
+        Returns:
+            Any: El resultado de ejecutar el método con las dependencias resueltas.
+
+        Raises:
+            AttributeError: Si el método no existe en la instancia.
+        """
+        pass
+
+    @abstractmethod
+    def startRequest(self):
+        """Starts a new request and clears the Scoped instances.
+
+        This method should be called at the beginning of each request to ensure that
+        scoped services do not persist between requests.
+        """
+        pass

orionis-0.9.0/orionis/luminate/contracts/container/types_interface.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+
+class ITypes(ABC):
+    """A class that handles validation of primitive types to prevent registering services with primitive-type names."""
+
+    @abstractmethod
+    def isPrimitive(self, name: str) -> None:
+        """Checks if the provided name corresponds to a primitive type.
+
+        Args:
+            name (str): The name of the service or alias to check.
+
+        Raises:
+            OrionisContainerException: If the name matches a primitive type.
+        """
+    pass

{orionis-0.8.0 → orionis-0.9.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.8.0 → orionis-0.9.0}/orionis.egg-info/SOURCES.txt

@@ -64,6 +64,7 @@ orionis/luminate/console/tasks/__init__.py
 orionis/luminate/console/tasks/scheduler.py
 orionis/luminate/container/container.py
 orionis/luminate/container/exception.py
+orionis/luminate/container/types.py
 orionis/luminate/contracts/__init__.py
 orionis/luminate/contracts/bootstrap/parser_interface.py
 orionis/luminate/contracts/cache/__init__.py
@@ -86,6 +87,8 @@ orionis/luminate/contracts/console/register_interface.py
 orionis/luminate/contracts/console/runner_interface.py
 orionis/luminate/contracts/console/schedule_interface.py
 orionis/luminate/contracts/console/task_manager_interface.py
+orionis/luminate/contracts/container/container_interface.py
+orionis/luminate/contracts/container/types_interface.py
 orionis/luminate/contracts/facades/__init__.py
 orionis/luminate/contracts/facades/env_interface.py
 orionis/luminate/contracts/facades/log_interface.py