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

orionis/_container/container_integrity.py

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

orionis/_container/exception.py

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

orionis/_container/lifetimes.py

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

orionis/_container/resolve.py

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