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

orionis/luminate/contracts/container/container.py

@@ -0,0 +1,346 @@
+from abc import ABC, abstractmethod
+
+class IContainer(ABC):
+
+    @abstractmethod
+    def bind(self, abstract, concrete, lifetime):
+        """
+        Binds an abstract type to a concrete implementation with a specified lifetime.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base type or alias to be bound.
+        concrete : Callable[..., Any]
+            The concrete implementation to associate with the abstract type.
+        lifetime : str
+            The lifecycle of the binding. Must be one of 'transient', 'scoped', or 'singleton'.
+
+        Raises
+        ------
+        OrionisContainerValueError
+            If an invalid lifetime is provided or the concrete implementation is None.
+
+        Examples
+        --------
+        >>> container.bind(MyService, MyServiceImplementation, "singleton")
+        """
+        pass
+
+    @abstractmethod
+    def transient(self, abstract, concrete):
+        """
+        Registers a service with a transient lifetime.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base type or alias to be bound.
+        concrete : Callable[..., Any]
+            The concrete implementation to associate with the abstract type.
+
+        Examples
+        --------
+        >>> container.transient(MyService, MyServiceImplementation)
+        """
+        pass
+
+    @abstractmethod
+    def scoped(self, abstract, concrete):
+        """
+        Registers a service with a scoped lifetime.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base type or alias to be bound.
+        concrete : Callable[..., Any]
+            The concrete implementation to associate with the abstract type.
+
+        Examples
+        --------
+        >>> container.scoped(MyService, MyServiceImplementation)
+        """
+        pass
+
+    @abstractmethod
+    def singleton(self, abstract, concrete):
+        """
+        Registers a service with a singleton lifetime.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base type or alias to be bound.
+        concrete : Callable[..., Any]
+            The concrete implementation to associate with the abstract type.
+
+        Examples
+        --------
+        >>> container.singleton(MyService, MyServiceImplementation)
+        """
+        pass
+
+    @abstractmethod
+    def instance(self, abstract, instance):
+        """
+        Registers an already instantiated object in the container.
+
+        Parameters
+        ----------
+        abstract : Callable[..., Any]
+            The abstract base type or alias to be bound.
+        instance : Any
+            The instance to be stored.
+
+        Raises
+        ------
+        OrionisContainerValueError
+            If the instance is None.
+
+        Examples
+        --------
+        >>> container.instance(MyService, my_service_instance)
+        """
+        pass
+
+    @abstractmethod
+    def bound(self, abstract_or_alias):
+        """
+        Checks if a service or alias is bound in the container.
+
+        Parameters
+        ----------
+        abstract_or_alias : Callable[..., Any]
+            The abstract type or alias to check.
+
+        Returns
+        -------
+        bool
+            True if the service is bound, False otherwise.
+
+        Examples
+        --------
+        >>> container.bound(MyService)
+        True
+        """
+        pass
+
+    @abstractmethod
+    def has(self, abstract_or_alias):
+        """
+        Alias for `bound()` method.
+
+        Parameters
+        ----------
+        abstract_or_alias : Callable[..., Any]
+            The abstract type or alias to check.
+
+        Returns
+        -------
+        bool
+            True if the service is bound, False otherwise.
+
+        Examples
+        --------
+        >>> container.has(MyService)
+        True
+        """
+        pass
+
+    @abstractmethod
+    def alias(self, alias, abstract):
+        """
+        Creates an alias for an existing abstract binding.
+
+        Parameters
+        ----------
+        alias : Callable[..., Any]
+            The alias name.
+        abstract : Callable[..., Any]
+            The existing abstract type to alias.
+
+        Raises
+        ------
+        OrionisContainerValueError
+            If the abstract type is not registered or the alias is already in use.
+
+        Examples
+        --------
+        >>> container.alias("DatabaseService", MyDatabaseService)
+        """
+        pass
+
+    @abstractmethod
+    def isAlias(self, name):
+        """
+        Checks if a given name is an alias.
+
+        Parameters
+        ----------
+        name : str
+            The name to check.
+
+        Returns
+        -------
+        bool
+            True if the name is an alias, False otherwise.
+
+        Raises
+        ------
+        OrionisContainerTypeError
+            If the name is not a string.
+
+        Examples
+        --------
+        >>> container.isAlias("DatabaseService")
+        True
+        """
+        pass
+
+    @abstractmethod
+    def getBindings(self):
+        """
+        Retrieves all registered service bindings.
+
+        Returns
+        -------
+        dict
+            A dictionary containing all instances, transient, scoped, singleton, and alias services.
+
+        Examples
+        --------
+        >>> container.getBindings()
+        """
+        pass
+
+    @abstractmethod
+    def getAlias(self, name):
+        """
+        Retrieves the abstract type associated with an alias.
+
+        Parameters
+        ----------
+        name : str
+            The alias name.
+
+        Returns
+        -------
+        Callable[..., Any]
+            The abstract type associated with the alias.
+
+        Raises
+        ------
+        OrionisContainerValueError
+            If the alias is not registered.
+
+        Examples
+        --------
+        >>> container.getAlias("DatabaseService")
+        <class 'MyDatabaseService'>
+        """
+        pass
+
+    @abstractmethod
+    def forgetScopedInstances(self):
+        """
+        Clears all scoped instances.
+
+        Examples
+        --------
+        >>> container.forgetScopedInstances()
+        """
+        pass
+
+    @abstractmethod
+    def newRequest(self):
+        """
+        Resets scoped instances to handle a new request.
+
+        Examples
+        --------
+        >>> container.newRequest()
+        """
+        pass
+
+    @abstractmethod
+    async def make(self, abstract_or_alias):
+        """
+        Resolves and instantiates a service from the container.
+
+        Parameters
+        ----------
+        abstract_or_alias : Callable[..., Any]
+            The abstract type or alias to resolve.
+
+        Returns
+        -------
+        Any
+            The instantiated service.
+
+        Raises
+        ------
+        OrionisContainerException
+            If the service is not found.
+
+        Examples
+        --------
+        >>> service = await container.make(MyService)
+        """
+        pass
+
+    @abstractmethod
+    def _resolve(self, concrete, resolving=None):
+        """
+        Resolves dependencies recursively and instantiates a class.
+
+        Parameters
+        ----------
+        concrete : Callable[..., Any]
+            The concrete implementation to instantiate.
+        resolving : Optional[Deque[Type]], optional
+            A queue to track resolving dependencies and prevent circular dependencies.
+
+        Returns
+        -------
+        Any
+            The instantiated object.
+
+        Raises
+        ------
+        OrionisContainerException
+            If circular dependencies are detected or instantiation fails.
+
+        Examples
+        --------
+        >>> instance = container._resolve(MyClass)
+        """
+        pass
+
+    @abstractmethod
+    def _resolve_dependency(self, dep_type, resolving=None):
+        """
+        Resolves a dependency by instantiating or retrieving it from the container.
+
+        Parameters
+        ----------
+        dep_type : Any
+            The dependency type to resolve.
+        resolving : Optional[Deque[Type]], optional
+            A queue to track resolving dependencies.
+
+        Returns
+        -------
+        Any
+            The resolved dependency.
+
+        Raises
+        ------
+        OrionisContainerException
+            If the dependency cannot be resolved.
+
+        Examples
+        --------
+        >>> dependency = container._resolve_dependency(MyDependency)
+        """
+        pass

orionis/luminate/contracts/container/container_integrity.py

@@ -0,0 +1,168 @@
+from abc import ABC, abstractmethod
+from typing import Any, Callable, Type
+
+class IContainerIntegrity(ABC):
+
+    @abstractmethod
+    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`.
+        """
+        pass
+
+    @abstractmethod
+    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
+        """
+        pass
+
+    @abstractmethod
+    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.
+        """
+        pass
+
+    @abstractmethod
+    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.
+        """
+        pass
+
+    @abstractmethod
+    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.
+        """
+        pass
+
+    @abstractmethod
+    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.
+        """
+        pass
+
+    @abstractmethod
+    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.
+        """
+        pass
+
+    @abstractmethod
+    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.
+        """
+        pass
+
+    @abstractmethod
+    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.
+        """
+        pass
+
+    @abstractmethod
+    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.
+        """
+        pass

orionis/luminate/contracts/foundation/providers/{i_service_providers_bootstrapper.py → service_providers_bootstrapper.py}

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+from typing import List, Type
 from orionis.luminate.providers.service_provider import ServiceProvider
 
 class IServiceProvidersBootstrapper(ABC):
@@ -19,7 +20,7 @@ class IServiceProvidersBootstrapper(ABC):
         pass
 
     @abstractmethod
-    def _register(self, concrete: ServiceProvider) -> None:
+    def _register(self, concrete: Type[ServiceProvider]) -> None:
         """
         Validates and registers a service provider class.
 
@@ -35,7 +36,7 @@ class IServiceProvidersBootstrapper(ABC):
         pass
 
     @abstractmethod
-    def getBeforeServiceProviders(self) -> list:
+    def getBeforeServiceProviders(self) -> List[Type[ServiceProvider]]:
         """
         Retrieve the registered service providers.
 
@@ -47,7 +48,7 @@ class IServiceProvidersBootstrapper(ABC):
         pass
 
     @abstractmethod
-    def getAfterServiceProviders(self) -> list:
+    def getAfterServiceProviders(self) -> List[Type[ServiceProvider]]:
         """
         Retrieve the registered service providers.
 

orionis/luminate/facades/commands/commands_facade.py

@@ -1,5 +1,5 @@
 from typing import Any
-from orionis.luminate.contracts.facades.commands.i_commands_facade import ICommand
+from orionis.luminate.contracts.facades.commands.commands_facade import ICommand
 from orionis.luminate.facades.app_facade import app
 from orionis.luminate.services.commands.reactor_commands_service import ReactorCommandsService
 

orionis/luminate/facades/commands/scheduler_facade.py

@@ -1,5 +1,5 @@
 from typing import Any
-from orionis.luminate.contracts.facades.commands.i_scheduler_facade import ISchedule
+from orionis.luminate.contracts.facades.commands.scheduler_facade import ISchedule
 from orionis.luminate.facades.app_facade import app
 from orionis.luminate.services.commands.scheduler_service import ScheduleService
 

orionis/luminate/facades/config/config_facade.py

@@ -1,5 +1,5 @@
 from typing import Any, Optional
-from orionis.luminate.contracts.facades.config.i_config_facade import IConfig
+from orionis.luminate.contracts.facades.config.config_facade import IConfig
 from orionis.luminate.facades.app_facade import app
 from orionis.luminate.services.config.config_service import ConfigService
 

orionis/luminate/facades/environment/environment_facade.py

@@ -1,34 +1,9 @@
-from orionis.luminate.contracts.facades.environment.i_environment_facade import IEnv
+from orionis.luminate.contracts.facades.environment.environment_facade import IEnv
 from orionis.luminate.facades.app_facade import app
 from orionis.luminate.services.environment.environment_service import EnvironmentService
 
-def env(key: str, default=None) -> str:
-    """
-    Retrieves the value of an environment variable.
-
-    This function provides a convenient way to access environment variables
-    stored in the application context. If the variable does not exist, it
-    returns the specified default value.
-
-    Parameters
-    ----------
-    key : str
-        The name of the environment variable to retrieve.
-    default : Any, optional
-        The default value to return if the environment variable does not exist.
-        Defaults to None.
-
-    Returns
-    -------
-    str
-        The value of the environment variable, or the default value if the variable
-        does not exist.
-    """
-    return Env.get(key, default)
-
 class Env(IEnv):
 
-
     @staticmethod
     def get(key: str, default=None) -> str:
         """

orionis/luminate/facades/files/path_facade.py

@@ -1,5 +1,5 @@
 import os
-from orionis.luminate.contracts.facades.files.i_path_facade import IPath
+from orionis.luminate.contracts.facades.files.path_facade import IPath
 from orionis.luminate.services.files.path_resolver_service import PathResolverService
 
 class Path(IPath):

orionis/luminate/facades/log/log_facade.py

@@ -1,4 +1,4 @@
-from orionis.luminate.contracts.facades.log.i_log_facade import ILog
+from orionis.luminate.contracts.facades.log.log_facade import ILog
 from orionis.luminate.facades.app_facade import app
 from orionis.luminate.services.log.log_service import LogguerService
 

orionis/luminate/facades/tests/tests_facade.py

@@ -1,5 +1,5 @@
 import os
-from orionis.luminate.contracts.facades.tests.i_tests_facade import IUnitTests
+from orionis.luminate.contracts.facades.tests.tests_facade import IUnitTests
 from orionis.luminate.test.unit_test import UnitTest
 
 class UnitTests(IUnitTests):

orionis/luminate/foundation/config/config_bootstrapper.py

@@ -2,7 +2,7 @@ import importlib
 import pathlib
 from dataclasses import asdict
 from typing import Any, Dict
-from orionis.luminate.contracts.foundation.config.i_config_bootstrapper import IConfigBootstrapper
+from orionis.luminate.contracts.foundation.config.config_bootstrapper import IConfigBootstrapper
 from orionis.luminate.contracts.config.i_config import IConfig
 from orionis.luminate.foundation.exceptions.exception_bootstrapper import BootstrapRuntimeError
 

orionis/luminate/foundation/console/command_bootstrapper.py

@@ -2,7 +2,7 @@ import pathlib
 import importlib
 import inspect
 from typing import Any, Callable, Dict, List
-from orionis.luminate.contracts.foundation.console.i_command_bootstrapper import ICommandsBootstrapper
+from orionis.luminate.contracts.foundation.console.command_bootstrapper import ICommandsBootstrapper
 from orionis.luminate.foundation.exceptions.exception_bootstrapper import BootstrapRuntimeError
 from orionis.luminate.console.base.command import BaseCommand
 

orionis/luminate/foundation/environment/environment_bootstrapper.py

@@ -1,5 +1,5 @@
 from typing import Dict
-from orionis.luminate.contracts.foundation.environment.i_environment_bootstrapper import IEnvironmentBootstrapper
+from orionis.luminate.contracts.foundation.environment.environment_bootstrapper import IEnvironmentBootstrapper
 from orionis.luminate.services.environment.environment_service import EnvironmentService
 
 class EnvironmentBootstrapper(IEnvironmentBootstrapper):