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

orionis/container/container.py

@@ -5,6 +5,14 @@ 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.validators.implements import ImplementsAbstractMethods
+from orionis.container.validators.is_abstract_class import IsAbstractClass
+from orionis.container.validators.is_callable import IsCallable
+from orionis.container.validators.is_concrete_class import IsConcreteClass
+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.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
@@ -51,10 +59,20 @@ class Container(IContainer):
         Container
             The singleton instance of the class.
         """
+
+        # Check if the class has an existing instance
         if cls._instance is None:
+
+            # Acquire the lock to ensure thread safety during instance creation
             with cls._lock:
+
+                # If the instance is still None, create a new instance
                 if cls._instance is None:
+
+                    # Call the superclass's __new__ method to create a new instance
                     cls._instance = super(Container, cls).__new__(cls)
+
+        # Return the existing instance of the class
         return cls._instance
 
     def __init__(
@@ -75,362 +93,19 @@ class Container(IContainer):
         - Initialization occurs only once per class, regardless of the number of instances.
         - The container registers itself under the IContainer interface to allow for dependency injection.
         """
+
+        # Check if the class has been initialized
         if not self.__class__._initialized:
+
+            # Initialize the container's internal state
             self.__bindings = {}
             self.__aliasses = {}
-            self.__class__._initialized = True
-            self.instance(IContainer, self)
-
-    def __dropService(
-        self,
-        abstract: Callable[..., Any] = None,
-        alias: str = None
-    ) -> None:
-        """
-        Drops a service from the container.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The abstract type or interface to be removed.
-        alias : str, optional
-            The alias of the service to be removed. If not provided, the service will be removed by its abstract type.
-
-        Raises
-        ------
-        OrionisContainerException
-            If the service does not exist in the container.
-        """
-
-        # If abstract is provided
-        if abstract:
-
-            # Remove the abstract service from the bindings if it exists
-            if abstract in self.__bindings:
-                del self.__bindings[abstract]
-
-            # Remove the default alias (module + class name) from aliases if it exists
-            abs_alias = ReflectionAbstract(abstract).getModuleWithClassName()
-            if abs_alias in self.__aliasses:
-                del self.__aliasses[abs_alias]
-
-        # If a custom alias is provided
-        if alias:
-
-            # Remove it from the aliases dictionary if it exists
-            if alias in self.__aliasses:
-                del self.__aliasses[alias]
-
-            # Remove the binding associated with the alias
-            if alias in self.__bindings:
-                del self.__bindings[alias]
-
-    def __ensureIsCallable(
-        self,
-        value: Any
-    ) -> None:
-        """
-        Ensures that the provided value is callable.
-
-        Parameters
-        ----------
-        value : Any
-            The value to check.
-
-        Raises
-        ------
-        OrionisContainerTypeError
-            If the value is not callable.
-        """
-
-        if not callable(value):
-            raise OrionisContainerTypeError(
-                f"Expected a callable type, but got {type(value).__name__} instead."
-            )
-
-    def __ensureAliasType(
-        self,
-        value: Any
-    ) -> None:
-        """
-        Ensures that the provided value is a valid alias of type str and does not contain invalid characters.
-
-        Parameters
-        ----------
-        value : Any
-            The value to check.
-
-        Raises
-        ------
-        OrionisContainerTypeError
-            If the value is not of type str or contains invalid characters.
-
-        Notes
-        -----
-        This method validates that a given value is a string and does not contain characters
-        that could cause errors when resolving dependencies (e.g., whitespace, special symbols).
-        """
-
-        # Check if the value is a string
-        if not isinstance(value, str):
-            raise OrionisContainerTypeError(
-                f"Expected a string type for alias, but got {type(value).__name__} instead."
-            )
-
-        # Define a set of invalid characters for aliases
-        invalid_chars = set(' \t\n\r\x0b\x0c!@#$%^&*()[]{};:,/<>?\\|`~"\'')
-        if any(char in invalid_chars for char in value):
-            raise OrionisContainerTypeError(
-                f"Alias '{value}' contains invalid characters. "
-                "Aliases must not contain whitespace or special symbols."
-            )
-
-    def __ensureAbstractClass(
-        self,
-        abstract: Callable[..., Any],
-        lifetime: str
-    ) -> None:
-        """
-        Ensures that the provided abstract is an abstract class.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The class intended to represent the abstract type.
-        lifetime : str
-            The service lifetime descriptor, used for error messages.
-
-        Raises
-        ------
-        OrionisContainerTypeError
-            If the abstract class check fails.
-        """
-        try:
-            ReflectionAbstract.ensureIsAbstractClass(abstract)
-        except Exception as e:
-            raise OrionisContainerTypeError(
-                f"Unexpected error registering {lifetime} service: {e}"
-            ) from e
-
-    def __ensureConcreteClass(
-        self,
-        concrete: Callable[..., Any],
-        lifetime: str
-    ) -> None:
-        """
-        Ensures that the provided concrete is a concrete (non-abstract) class.
-
-        Parameters
-        ----------
-        concrete : Callable[..., Any]
-            The class intended to represent the concrete implementation.
-        lifetime : str
-            The service lifetime descriptor, used for error messages.
-
-        Raises
-        ------
-        OrionisContainerTypeError
-            If the concrete class check fails.
-        """
-        try:
-            ReflectionConcrete.ensureIsConcreteClass(concrete)
-        except Exception as e:
-            raise OrionisContainerTypeError(
-                f"Unexpected error registering {lifetime} service: {e}"
-            ) from e
-
-    def __ensureIsSubclass(
-        self,
-        abstract: Callable[..., Any],
-        concrete: Callable[..., Any]
-    ) -> None:
-        """
-        Validates that the concrete class is a subclass of the provided abstract class.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The abstract base class or interface.
-        concrete : Callable[..., Any]
-            The concrete implementation class to check.
-
-        Raises
-        ------
-        OrionisContainerException
-            If the concrete class is NOT a subclass of the abstract class.
-
-        Notes
-        -----
-        This method ensures that the concrete implementation inherits from the abstract class,
-        which is required for proper dependency injection and interface enforcement.
-        """
-        if not issubclass(concrete, abstract):
-            raise OrionisContainerException(
-                "The concrete class must inherit from the provided abstract class. "
-                "Please ensure that the concrete class is a subclass of the specified abstract class."
-            )
-
-    def __ensureIsNotSubclass(
-        self,
-        abstract: Callable[..., Any],
-        concrete: Callable[..., Any]
-    ) -> None:
-        """
-        Validates that the concrete class is NOT a subclass of the provided abstract class.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The abstract base class or interface.
-        concrete : Callable[..., Any]
-            The concrete implementation class to check.
-
-        Raises
-        ------
-        OrionisContainerException
-            If the concrete class IS a subclass of the abstract class.
-
-        Notes
-        -----
-        This method ensures that the concrete implementation does NOT inherit from the abstract class.
-        """
-        if issubclass(concrete, abstract):
-            raise OrionisContainerException(
-                "The concrete class must NOT inherit from the provided abstract class. "
-                "Please ensure that the concrete class is not a subclass of the specified abstract class."
-            )
-
-    def __ensureInstance(
-        self,
-        instance: Any
-    ) -> None:
-        """
-        Ensures that the provided object is a valid instance.
-
-        Parameters
-        ----------
-        instance : Any
-            The object to be validated as an instance.
-
-        Raises
-        ------
-        OrionisContainerTypeError
-            If the provided object is not a valid instance.
-
-        Notes
-        -----
-        This method uses ReflectionInstance to verify that the given object
-        is a proper instance (not a class or abstract type). If the check fails,
-        an OrionisContainerTypeError is raised with a descriptive message.
-        """
-        try:
-            ReflectionInstance.ensureIsInstance(instance)
-        except Exception as e:
-            raise OrionisContainerTypeError(
-                f"Error registering instance: {e}"
-            ) from e
-
-    def __ensureImplementation(
-        self,
-        *,
-        abstract: Callable[..., Any] = None,
-        concrete: Callable[..., Any] = None,
-        instance: Any = None
-    ) -> None:
-        """
-        Ensures that a concrete class or instance implements all abstract methods defined in an abstract class.
-
-        Parameters
-        ----------
-        abstract : Callable[..., Any]
-            The abstract class containing abstract methods.
-        concrete : Callable[..., Any], optional
-            The concrete class that should implement the abstract methods.
-        instance : Any, optional
-            The instance that should implement the abstract methods.
-
-        Raises
-        ------
-        OrionisContainerException
-            If the concrete class or instance does not implement all abstract methods defined in the abstract class.
-
-        Notes
-        -----
-        This method checks that all abstract methods in the given abstract class are implemented
-        in the provided concrete class or instance. If any methods are missing, an exception is raised with
-        details about the missing implementations.
-        """
-        if abstract is None:
-            raise OrionisContainerException("Abstract class must be provided for implementation check.")
-
-        abstract_methods = getattr(abstract, '__abstractmethods__', set())
-        if not abstract_methods:
-            raise OrionisContainerException(
-                f"The abstract class '{abstract.__name__}' does not define any abstract methods. "
-                "An abstract class must have at least one abstract method."
-            )
-
-        target = concrete if concrete is not None else instance
-        if target is None:
-            raise OrionisContainerException("Either concrete class or instance must be provided for implementation check.")
-
-        target_class = target if Reflection.isClass(target) else target.__class__
-        target_name = target_class.__name__
-        abstract_name = abstract.__name__
-
-        not_implemented = []
-        for method in abstract_methods:
-            if not hasattr(target, str(method).replace(f"_{abstract_name}", f"_{target_name}")):
-                not_implemented.append(method)
-
-        if not_implemented:
-            formatted_methods = "\n  • " + "\n  • ".join(not_implemented)
-            raise OrionisContainerException(
-                f"'{target_name}' does not implement the following abstract methods defined in '{abstract_name}':{formatted_methods}\n"
-                "Please ensure that all abstract methods are implemented."
-            )
-
-    def __getService(
-        self,
-        abstract_or_alias: Any
-    ) -> Binding:
-        """
-        Retrieves the binding for the requested abstract type or alias.
-
-        Parameters
-        ----------
-        abstract_or_alias : Any
-            The abstract class, interface, or alias (str) to retrieve.
-
-        Returns
-        -------
-        Binding
-            The binding associated with the requested abstract type or alias.
-        """
-        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.
+            # Set the initialized flag to True to prevent re-initialization
+            self.__class__._initialized = True
 
-        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
+            # Register the container itself as a service
+            self.instance(IContainer, self)
 
     def transient(
         self,
@@ -472,28 +147,28 @@ class Container(IContainer):
         """
 
         # Ensure that abstract is an abstract class
-        self.__ensureAbstractClass(abstract, Lifetime.TRANSIENT)
+        IsAbstractClass(abstract, Lifetime.TRANSIENT)
 
         # Ensure that concrete is a concrete class
-        self.__ensureConcreteClass(concrete, Lifetime.TRANSIENT)
+        IsConcreteClass(concrete, Lifetime.TRANSIENT)
 
         # Ensure that concrete is NOT a subclass of abstract
         if enforce_decoupling:
-            self.__ensureIsNotSubclass(abstract, concrete)
+            IsNotSubclass(abstract, concrete)
 
         # Validate that concrete is a subclass of abstract
         else:
-            self.__ensureIsSubclass(abstract, concrete)
+            IsSubclass(abstract, concrete)
 
         # Ensure implementation
-        self.__ensureImplementation(
+        ImplementsAbstractMethods(
             abstract=abstract,
             concrete=concrete
         )
 
         # Ensure that the alias is a valid string if provided
         if alias:
-            self.__ensureAliasType(alias)
+            IsValidAlias(alias)
 
         # Extract the module and class name for the alias
         else:
@@ -501,7 +176,7 @@ class Container(IContainer):
             alias = rf_asbtract.getModuleWithClassName()
 
         # If the service is already registered, drop it
-        self.__dropService(abstract, alias)
+        self.drop(abstract, alias)
 
         # Register the service with transient lifetime
         self.__bindings[abstract] = Binding(
@@ -557,34 +232,34 @@ class Container(IContainer):
         """
 
         # Ensure that abstract is an abstract class
-        self.__ensureAbstractClass(abstract, Lifetime.SINGLETON)
+        IsAbstractClass(abstract, Lifetime.SINGLETON)
 
         # Ensure that concrete is a concrete class
-        self.__ensureConcreteClass(concrete, Lifetime.SINGLETON)
+        IsConcreteClass(concrete, Lifetime.SINGLETON)
 
         # Ensure that concrete is NOT a subclass of abstract
         if enforce_decoupling:
-            self.__ensureIsNotSubclass(abstract, concrete)
+            IsNotSubclass(abstract, concrete)
 
         # Validate that concrete is a subclass of abstract
         else:
-            self.__ensureIsSubclass(abstract, concrete)
+            IsSubclass(abstract, concrete)
 
         # Ensure implementation
-        self.__ensureImplementation(
+        ImplementsAbstractMethods(
             abstract=abstract,
             concrete=concrete
         )
 
         # Ensure that the alias is a valid string if provided
         if alias:
-            self.__ensureAliasType(alias)
+            IsValidAlias(alias)
         else:
             rf_asbtract = ReflectionAbstract(abstract)
             alias = rf_asbtract.getModuleWithClassName()
 
         # If the service is already registered, drop it
-        self.__dropService(abstract, alias)
+        self.drop(abstract, alias)
 
         # Register the service with singleton lifetime
         self.__bindings[abstract] = Binding(
@@ -640,34 +315,34 @@ class Container(IContainer):
         """
 
         # Ensure that abstract is an abstract class
-        self.__ensureAbstractClass(abstract, Lifetime.SCOPED)
+        IsAbstractClass(abstract, Lifetime.SCOPED)
 
         # Ensure that concrete is a concrete class
-        self.__ensureConcreteClass(concrete, Lifetime.SCOPED)
+        IsConcreteClass(concrete, Lifetime.SCOPED)
 
         # Ensure that concrete is NOT a subclass of abstract
         if enforce_decoupling:
-            self.__ensureIsNotSubclass(abstract, concrete)
+            IsNotSubclass(abstract, concrete)
 
         # Validate that concrete is a subclass of abstract
         else:
-            self.__ensureIsSubclass(abstract, concrete)
+            IsSubclass(abstract, concrete)
 
         # Ensure implementation
-        self.__ensureImplementation(
+        ImplementsAbstractMethods(
             abstract=abstract,
             concrete=concrete
         )
 
         # Ensure that the alias is a valid string if provided
         if alias:
-            self.__ensureAliasType(alias)
+            IsValidAlias(alias)
         else:
             rf_asbtract = ReflectionAbstract(abstract)
             alias = rf_asbtract.getModuleWithClassName()
 
         # If the service is already registered, drop it
-        self.__dropService(abstract, alias)
+        self.drop(abstract, alias)
 
         # Register the service with scoped lifetime
         self.__bindings[abstract] = Binding(
@@ -721,34 +396,34 @@ class Container(IContainer):
         """
 
         # Ensure that the abstract is an abstract class
-        self.__ensureAbstractClass(abstract, f"Instance {Lifetime.SINGLETON}")
+        IsAbstractClass(abstract, f"Instance {Lifetime.SINGLETON}")
 
         # Ensure that the instance is a valid instance
-        self.__ensureInstance(instance)
+        IsInstance(instance)
 
         # Ensure that instance is NOT a subclass of abstract
         if enforce_decoupling:
-            self.__ensureIsNotSubclass(abstract, instance.__class__)
+            IsNotSubclass(abstract, instance.__class__)
 
         # Validate that instance is a subclass of abstract
         else:
-            self.__ensureIsSubclass(abstract, instance.__class__)
+            IsSubclass(abstract, instance.__class__)
 
         # Ensure implementation
-        self.__ensureImplementation(
+        ImplementsAbstractMethods(
             abstract=abstract,
             instance=instance
         )
 
         # Ensure that the alias is a valid string if provided
         if alias:
-            self.__ensureAliasType(alias)
+            IsValidAlias(alias)
         else:
             rf_asbtract = ReflectionAbstract(abstract)
             alias = rf_asbtract.getModuleWithClassName()
 
         # If the service is already registered, drop it
-        self.__dropService(abstract, alias)
+        self.drop(abstract, alias)
 
         # Register the instance with the abstract type
         self.__bindings[abstract] = Binding(
@@ -813,10 +488,10 @@ class Container(IContainer):
                 )
 
         # Ensure that the alias is a valid string
-        self.__ensureAliasType(alias)
+        IsValidAlias(alias)
 
         # Validate that the function is callable
-        self.__ensureIsCallable(fn)
+        IsCallable(fn)
 
         # Inspect the function signature
         params = ReflectionCallable(fn).getDependencies()
@@ -828,7 +503,7 @@ class Container(IContainer):
             )
 
         # If the service is already registered, drop it
-        self.__dropService(None, alias)
+        self.drop(None, alias)
 
         # Register the function with the specified alias and lifetime
         self.__bindings[alias] = Binding(
@@ -869,6 +544,99 @@ class Container(IContainer):
             or abstract_or_alias in self.__aliasses
         )
 
+    def __getService(
+        self,
+        abstract_or_alias: Any
+    ) -> Binding:
+        """
+        Retrieves the binding for the requested abstract type or alias.
+
+        Parameters
+        ----------
+        abstract_or_alias : Any
+            The abstract class, interface, or alias (str) to retrieve.
+
+        Returns
+        -------
+        Binding
+            The binding associated with the requested abstract type or alias.
+        """
+        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,
+        alias: str = None
+    ) -> None:
+        """
+        Drops a service from the container by removing its bindings and aliases.
+        This method allows removing registered services from the dependency injection container,
+        either by their abstract type or by their alias. When a service is dropped,
+        all its bindings and aliases are removed from the container.
+
+        Warning
+        -------
+        Using this method irresponsibly can severely damage the system's logic.
+        Only use it when you are certain about the consequences, as removing
+        critical services may lead to system failures and unexpected behavior.
+        abstract : Callable[..., Any], optional
+            The abstract type or interface to be removed from the container.
+            If provided, both the binding and the default alias for this type will be removed.
+            The alias of the service to be removed. If provided, both the alias entry
+            and any associated binding will be removed.
+
+        Notes
+        -----
+        At least one parameter (abstract or alias) must be provided for the method to take effect.
+        If both are provided, both will be processed independently.
+        """
+
+        # If abstract is provided
+        if abstract:
+
+            # Remove the abstract service from the bindings if it exists
+            if abstract in self.__bindings:
+                del self.__bindings[abstract]
+
+            # Remove the default alias (module + class name) from aliases if it exists
+            abs_alias = ReflectionAbstract(abstract).getModuleWithClassName()
+            if abs_alias in self.__aliasses:
+                del self.__aliasses[abs_alias]
+
+        # If a custom alias is provided
+        if alias:
+
+            # Remove it from the aliases dictionary if it exists
+            if alias in self.__aliasses:
+                del self.__aliasses[alias]
+
+            # Remove the binding associated with the alias
+            if alias in self.__bindings:
+                del self.__bindings[alias]
+
     def make(
         self,
         abstract_or_alias: Any,

orionis/container/resolver.py

@@ -0,0 +1,28 @@
+from orionis.container.contracts.container import IContainer
+from orionis.container.entities.binding import Binding
+from orionis.container.enums.lifetimes import Lifetime
+
+
+class Resolver:
+    """
+    Resolver class for handling dependency resolution in the container.
+    """
+
+    def __init__(
+        self,
+        container:IContainer,
+        lifetime:Lifetime
+    ):
+        self.container = container
+        self.lifetime = lifetime
+
+    def transient(
+        self,
+        binding:Binding,
+        *args,
+        **kwargs
+    ):
+        """
+        Register a transient service.
+        """
+        return self.container.transient(service, implementation, **kwargs)

orionis/container/validators/implements.py

@@ -0,0 +1,67 @@
+from typing import Callable, Any
+from orionis.services.introspection.reflection import Reflection
+from orionis.container.exceptions.container_exception import OrionisContainerException
+
+class _ImplementsAbstractMethods:
+    """
+    Validator that ensures a concrete class or instance implements all abstract methods of an abstract class.
+    """
+
+    def __call__(
+        self,
+        *,
+        abstract: Callable[..., Any] = None,
+        concrete: Callable[..., Any] = None,
+        instance: Any = None
+    ) -> None:
+        """
+        Validates that a concrete class or instance implements all abstract methods defined in an abstract class.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base class.
+        concrete : Callable[..., Any], optional
+            The class expected to implement the abstract methods.
+        instance : Any, optional
+            The instance expected to implement the abstract methods.
+
+        Raises
+        ------
+        OrionisContainerException
+            If any abstract method is not implemented.
+        """
+        if abstract is None:
+            raise OrionisContainerException("Abstract class must be provided for implementation check.")
+
+        abstract_methods = getattr(abstract, '__abstractmethods__', set())
+        if not abstract_methods:
+            raise OrionisContainerException(
+                f"The abstract class '{abstract.__name__}' does not define any abstract methods. "
+                "An abstract class must have at least one abstract method."
+            )
+
+        target = concrete if concrete is not None else instance
+        if target is None:
+            raise OrionisContainerException("Either concrete class or instance must be provided for implementation check.")
+
+        target_class = target if Reflection.isClass(target) else target.__class__
+        target_name = target_class.__name__
+        abstract_name = abstract.__name__
+
+        not_implemented = []
+        for method in abstract_methods:
+            # Considera métodos renombrados en clases concretas (_Abstract.m → _Concrete.m)
+            expected_method = str(method).replace(f"_{abstract_name}", f"_{target_name}")
+            if not hasattr(target, expected_method):
+                not_implemented.append(method)
+
+        if not_implemented:
+            formatted = "\n  • " + "\n  • ".join(not_implemented)
+            raise OrionisContainerException(
+                f"'{target_name}' does not implement the following abstract methods defined in '{abstract_name}':{formatted}\n"
+                "Please ensure that all abstract methods are implemented."
+            )
+
+# Exported singleton instance
+ImplementsAbstractMethods = _ImplementsAbstractMethods()

orionis/container/validators/is_abstract_class.py

@@ -0,0 +1,34 @@
+from typing import Callable, Any
+from orionis.services.introspection.abstract.reflection_abstract import ReflectionAbstract
+from orionis.container.exceptions.type_error_exception import OrionisContainerTypeError
+
+class _IsAbstractClass:
+    """
+    Validator that ensures a class is an abstract class.
+    """
+
+    def __call__(self, abstract: Callable[..., Any], lifetime: str) -> None:
+        """
+        Ensures that the provided class is an abstract class.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The class intended to represent the abstract type.
+        lifetime : str
+            A string indicating the service lifetime, used in error messages.
+
+        Raises
+        ------
+        OrionisContainerTypeError
+            If the class is not abstract.
+        """
+        try:
+            ReflectionAbstract.ensureIsAbstractClass(abstract)
+        except Exception as e:
+            raise OrionisContainerTypeError(
+                f"Unexpected error registering {lifetime} service: {e}"
+            ) from e
+
+# Exported singleton instance
+IsAbstractClass = _IsAbstractClass()

orionis/container/validators/is_callable.py

@@ -0,0 +1,30 @@
+from typing import Any
+from orionis.container.exceptions.type_error_exception import OrionisContainerTypeError
+
+class _IsCallable:
+    """
+    Validator that checks if a value is callable.
+    Can be used directly like a function: `IsCallable(value)`
+    """
+
+    def __call__(self, value: Any) -> None:
+        """
+        Ensures that the provided value is callable.
+
+        Parameters
+        ----------
+        value : Any
+            The value to check.
+
+        Raises
+        ------
+        OrionisContainerTypeError
+            If the value is not callable.
+        """
+        if not callable(value):
+            raise OrionisContainerTypeError(
+                f"Expected a callable type, but got {type(value).__name__} instead."
+            )
+
+# Exported singleton instance
+IsCallable = _IsCallable()

orionis/container/validators/is_concrete_class.py

@@ -0,0 +1,34 @@
+from typing import Callable, Any
+from orionis.services.introspection.concretes.reflection_concrete import ReflectionConcrete
+from orionis.container.exceptions.type_error_exception import OrionisContainerTypeError
+
+class _IsConcreteClass:
+    """
+    Validator that ensures a class is a concrete (non-abstract) class.
+    """
+
+    def __call__(self, concrete: Callable[..., Any], lifetime: str) -> None:
+        """
+        Ensures that the provided class is a concrete (non-abstract) class.
+
+        Parameters
+        ----------
+        concrete : Callable[..., Any]
+            The class intended to represent the concrete implementation.
+        lifetime : str
+            A string indicating the service lifetime, used in error messages.
+
+        Raises
+        ------
+        OrionisContainerTypeError
+            If the class is abstract or invalid.
+        """
+        try:
+            ReflectionConcrete.ensureIsConcreteClass(concrete)
+        except Exception as e:
+            raise OrionisContainerTypeError(
+                f"Unexpected error registering {lifetime} service: {e}"
+            ) from e
+
+# Exported singleton instance
+IsConcreteClass = _IsConcreteClass()

orionis/container/validators/is_instance.py

@@ -0,0 +1,32 @@
+from typing import Any
+from orionis.services.introspection.instances.reflection_instance import ReflectionInstance
+from orionis.container.exceptions.type_error_exception import OrionisContainerTypeError
+
+class _IsInstance:
+    """
+    Validator that ensures the provided object is a valid instance (not a class or abstract type).
+    """
+
+    def __call__(self, instance: Any) -> None:
+        """
+        Ensures that the provided object is a valid instance.
+
+        Parameters
+        ----------
+        instance : Any
+            The object to be validated.
+
+        Raises
+        ------
+        OrionisContainerTypeError
+            If the object is not a valid instance.
+        """
+        try:
+            ReflectionInstance.ensureIsInstance(instance)
+        except Exception as e:
+            raise OrionisContainerTypeError(
+                f"Error registering instance: {e}"
+            ) from e
+
+# Exported singleton instance
+IsInstance = _IsInstance()

orionis/container/validators/is_not_subclass.py

@@ -0,0 +1,32 @@
+from typing import Callable
+from orionis.container.exceptions.container_exception import OrionisContainerException
+
+class _IsNotSubclass:
+    """
+    Validator that ensures a class is NOT a subclass of another class.
+    """
+
+    def __call__(self, abstract: Callable[..., any], concrete: Callable[..., any]) -> None:
+        """
+        Validates that the concrete class is NOT a subclass of the abstract class.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The supposed base class or interface.
+        concrete : Callable[..., Any]
+            The implementation class to check.
+
+        Raises
+        ------
+        OrionisContainerException
+            If the concrete class IS a subclass of the abstract class.
+        """
+        if issubclass(concrete, abstract):
+            raise OrionisContainerException(
+                "The concrete class must NOT inherit from the provided abstract class. "
+                "Please ensure that the concrete class is not a subclass of the specified abstract class."
+            )
+
+# Exported singleton instance
+IsNotSubclass = _IsNotSubclass()

orionis/container/validators/is_subclass.py

@@ -0,0 +1,32 @@
+from typing import Callable
+from orionis.container.exceptions.container_exception import OrionisContainerException
+
+class _IsSubclass:
+    """
+    Validator that ensures a class is a subclass of a given abstract class.
+    """
+
+    def __call__(self, abstract: Callable[..., any], concrete: Callable[..., any]) -> None:
+        """
+        Validates that the concrete class is a subclass of the abstract class.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The base or abstract class.
+        concrete : Callable[..., Any]
+            The class to verify.
+
+        Raises
+        ------
+        OrionisContainerException
+            If the concrete class is NOT a subclass of the abstract class.
+        """
+        if not issubclass(concrete, abstract):
+            raise OrionisContainerException(
+                "The concrete class must inherit from the provided abstract class. "
+                "Please ensure that the concrete class is a subclass of the specified abstract class."
+            )
+
+# Exported singleton instance
+IsSubclass = _IsSubclass()

orionis/container/validators/is_valid_alias.py

@@ -0,0 +1,37 @@
+from typing import Any
+from orionis.container.exceptions.type_error_exception import OrionisContainerTypeError
+
+class _IsValidAlias:
+    """
+    Validator that checks if a value is a valid alias string.
+    """
+
+    _INVALID_CHARS = set(' \t\n\r\x0b\x0c!@#$%^&*()[]{};:,/<>?\\|`~"\'')
+
+    def __call__(self, value: Any) -> None:
+        """
+        Ensures that the provided value is a valid alias of type str and does not contain invalid characters.
+
+        Parameters
+        ----------
+        value : Any
+            The value to check.
+
+        Raises
+        ------
+        OrionisContainerTypeError
+            If the value is not of type str or contains invalid characters.
+        """
+        if not isinstance(value, str):
+            raise OrionisContainerTypeError(
+                f"Expected a string type for alias, but got {type(value).__name__} instead."
+            )
+
+        if any(char in self._INVALID_CHARS for char in value):
+            raise OrionisContainerTypeError(
+                f"Alias '{value}' contains invalid characters. "
+                "Aliases must not contain whitespace or special symbols."
+            )
+
+# Exported singleton instance
+IsValidAlias = _IsValidAlias()

orionis/metadata/framework.py

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

{orionis-0.319.0.dist-info → orionis-0.320.0.dist-info}/METADATA

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

{orionis-0.319.0.dist-info → orionis-0.320.0.dist-info}/RECORD

@@ -135,13 +135,23 @@ orionis/console/output/console.py,sha256=TE_Hl720ADd82dbERFSWhkoQRukDQZmETSw4nkw
 orionis/console/output/executor.py,sha256=bdvkzW2-buy0BPpy2r5qUGrRFW2Ay6k-5rSeHb0gQ3o,3352
 orionis/console/output/progress_bar.py,sha256=vFy582z6VJS46LV6tuyrmr9qvdVeTEtw3hyNcEHezeg,3088
 orionis/console/output/styles.py,sha256=6a4oQCOBOKMh2ARdeq5GlIskJ3wjiylYmh66tUKKmpQ,4053
-orionis/container/container.py,sha256=ZL3S0HyAt8Hm58dPjltNMCSMNNP30VR61ByslzmCGgs,45066
+orionis/container/container.py,sha256=HHEXnObv1Q_022dfGpTOx6cwyRPa7ooD8FfqJ_cDCro,37291
+orionis/container/resolver.py,sha256=9nojqjrYYXw2kQUzyuLkHs-os5dDxq6ntZ8e8IbYIu0,704
 orionis/container/contracts/container.py,sha256=LkZ5til_3Um8ctCVTwuO36HkysL59saKwUzXR5cWUBs,5750
 orionis/container/entities/binding.py,sha256=Qp6Lf4XUDp2NjqXDAC2lzvhOFQWiBDKiGFcKfwb4axw,4342
 orionis/container/enums/lifetimes.py,sha256=RqQmugMIB1Ev_j_vFLcWorndm-to7xg4stQ7yKFDdDw,190
 orionis/container/exceptions/container_exception.py,sha256=goTDEwC70xTMD2qppN8KV-xyR0Nps218OD4D1LZ2-3s,470
 orionis/container/exceptions/type_error_exception.py,sha256=cYuvoXVOgRYj3tZPfK341aUERkf33-buOiI2eXxcrAw,470
 orionis/container/exceptions/value_exception.py,sha256=hjY0YEusoL3DurME1ornxvIv1wyGaf6tBggLFlGHblo,472
+orionis/container/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/container/validators/implements.py,sha256=iSoDxxTalQKhyKjvsojFlkROhBFvAjvJxRvPJlmGrSg,2843
+orionis/container/validators/is_abstract_class.py,sha256=Q-Lqyrrps6oj2XWI0KFRp-hDZf4_sgbZlEbfBXj5XT4,1169
+orionis/container/validators/is_callable.py,sha256=8Bi5AflNmXhpgtk1ieirE3xgCKzq3mcgyqokCU3GHN8,843
+orionis/container/validators/is_concrete_class.py,sha256=BMhJ7vCQ2ccBA3qrRJPlsYDTSqBpqLZFfrdEGO5mlr4,1215
+orionis/container/validators/is_instance.py,sha256=vUwWIMeG1zLMsGX9GyoOU-LZtCgqBDZ9hUNDj_KyuYo,999
+orionis/container/validators/is_not_subclass.py,sha256=-iZw5ZCYnQtlU-xPO-o7lUj5DxPkN0G67-bLbLVhwtw,1167
+orionis/container/validators/is_subclass.py,sha256=O2aF0KLg5ZnDutKQ1xDvet34kentftlqgEkRNvumCoM,1135
+orionis/container/validators/is_valid_alias.py,sha256=avm6uz-huVi_kRov4BksSToslIHQfz-MLynjkzhdSRM,1246
 orionis/foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/startup.py,sha256=JKAH2ZRhlAZgkD2w11LR1-TVktfjSH9cHo3PsZXOLrg,8275
@@ -233,7 +243,7 @@ orionis/foundation/contracts/config.py,sha256=Rpz6U6t8OXHO9JJKSTnCimytXE-tfCB-1i
 orionis/foundation/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/exceptions/integrity.py,sha256=mc4pL1UMoYRHEmphnpW2oGk5URhu7DJRREyzHaV-cs8,472
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=MyXQ31_zvD5irlN_XvuSicVccDNBPb64XCKc8qujCEc,4960
+orionis/metadata/framework.py,sha256=sBQIEDehFdisleRXQSFyOhHx2bVTGjprHNNBI_Famsw,4960
 orionis/metadata/package.py,sha256=tqLfBRo-w1j_GN4xvzUNFyweWYFS-qhSgAEc-AmCH1M,5452
 orionis/patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/patterns/singleton/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -345,7 +355,7 @@ orionis/test/suite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 orionis/test/suite/test_unit.py,sha256=MWgW8dRCRyT1XZ5LsbXQ7-KVPReasoXwzEEL1EWWfE4,52190
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=jXZkbITBknbUwm_mD8bcTiwLDvsFkrO9qrf0ZgPwqxc,4903
-orionis-0.319.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.320.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/test_example.py,sha256=kvWgiW3ADEZf718dGsMPtDh_rmOSx1ypEInKm7_6ZPQ,601
@@ -446,8 +456,8 @@ tests/support/wrapper/test_services_wrapper_docdict.py,sha256=yeVwl-VcwkWSQYyxZu
 tests/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/test_testing_result.py,sha256=MrGK3ZimedL0b5Ydu69Dg8Iul017AzLTm7VPxpXlpfU,4315
 tests/testing/test_testing_unit.py,sha256=DjLBtvVn8B1KlVJNNkstBT8_csA1yeaMqnGrbanN_J4,7438
-orionis-0.319.0.dist-info/METADATA,sha256=426gql1AFezl4n3-_ORGM8wdkUYcEsZr8n3ykl6ruOI,4772
-orionis-0.319.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-orionis-0.319.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.319.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.319.0.dist-info/RECORD,,
+orionis-0.320.0.dist-info/METADATA,sha256=J4HkjZk_1Wa2wuK0UZboolNPepT3CA4uflTNQrXlGk0,4772
+orionis-0.320.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+orionis-0.320.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.320.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.320.0.dist-info/RECORD,,