orionis 0.139.0__py3-none-any.whl → 0.152.0__py3-none-any.whl

orionis/luminate/container/container_integrity.py

@@ -0,0 +1,235 @@
+import re
+import inspect
+from abc import ABC
+from typing import Any, Callable, Type
+from orionis.luminate.container.exception import OrionisContainerValueError, OrionisContainerTypeError
+from orionis.luminate.contracts.container.container_integrity import IContainerIntegrity
+
+class ContainerIntegrity(IContainerIntegrity):
+
+    @staticmethod
+    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, and underscores, 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/luminate/container/lifetimes.py

@@ -0,0 +1,13 @@
+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/luminate/container/resolve.py

@@ -0,0 +1,74 @@
+import asyncio
+from typing import Any, Callable
+from orionis.luminate.container.container import Container
+from orionis.luminate.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.
+        """
+        container = Container()
+
+        # Validate that the abstract or alias exists in the 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
+        try:
+            # Try to get the running event loop
+            loop = asyncio.get_running_loop()
+            # If there is a running event loop, resolve the service asynchronously
+            return loop.run_until_complete(container.make(abstract_or_alias))
+        except RuntimeError:
+            # If no event loop is running, create a new one and resolve the service
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            return loop.run_until_complete(container.make(abstract_or_alias))

orionis/luminate/contracts/application.py

@@ -0,0 +1,41 @@
+from abc import ABC, abstractmethod
+from typing import List, Type
+from orionis.luminate.contracts.container.container import IContainer
+from orionis.luminate.contracts.providers.service_provider import IServiceProvider
+
+class IApplication(ABC):
+    """
+    Abstract base class for the Application.
+    """
+
+    @abstractmethod
+    def withProviders(self, providers: List[Type["IServiceProvider"]]) -> None:
+        """
+        Sets custom service providers.
+
+        Parameters
+        ----------
+        providers : List[Type[ServiceProvider]]
+            List of service providers.
+        """
+        pass
+
+    @abstractmethod
+    def container(self) -> "IContainer":
+        """
+        Returns the service container instance.
+
+        Returns
+        -------
+        IContainer
+            The service container.
+        """
+        pass
+
+    @abstractmethod
+    def create(self) -> None:
+        """
+        Initializes and boots the application, including loading commands
+        and service providers.
+        """
+        pass

orionis/luminate/contracts/console/{i_parser.py → parser.py}

@@ -2,7 +2,6 @@ from abc import ABC, abstractmethod
 from typing import List, Tuple, Dict, Any
 import argparse
 
-
 class IParser(ABC):
     """
     Interface for a command-line argument parser.