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

orionis/framework.py

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

orionis/luminate/application.py

@@ -1,404 +1,254 @@
-from typing import Any, Callable
+import asyncio
+import inspect
+from typing import Dict, List, Type
 from contextlib import contextmanager
-from orionis.luminate.contracts.foundation.i_bootstraper import IBootstrapper
+from orionis.luminate.contracts.application import IApplication
+from orionis.luminate.contracts.container.container import IContainer
+from orionis.luminate.contracts.foundation.bootstraper import IBootstrapper
 from orionis.luminate.container.container import Container
+from orionis.luminate.contracts.providers.service_provider import IServiceProvider
 from orionis.luminate.foundation.config.config_bootstrapper import ConfigBootstrapper
 from orionis.luminate.foundation.console.command_bootstrapper import CommandsBootstrapper
 from orionis.luminate.foundation.environment.environment_bootstrapper import EnvironmentBootstrapper
+from orionis.luminate.foundation.exceptions.exception_bootstrapper import BootstrapRuntimeError
 from orionis.luminate.foundation.providers.service_providers_bootstrapper import ServiceProvidersBootstrapper
 from orionis.luminate.patterns.singleton import SingletonMeta
-from orionis.luminate.providers.service_provider import ServiceProvider
 
 class Application(metaclass=SingletonMeta):
     """
-    The core Application class responsible for bootstrapping and managing the application lifecycle.
+    Main application class that follows the Singleton pattern.
 
-    This class follows the Singleton pattern to ensure a single instance throughout the application.
+    This class manages service providers, environment variables, configurations,
+    and commands for the application lifecycle.
 
     Attributes
     ----------
+    _booted : bool
+        Indicates whether the application has been booted.
+    _custom_providers : List[Type[ServiceProvider]]
+        Custom service providers defined by the developer.
+    _service_providers : List[Type[ServiceProvider]]
+        Core application service providers.
     _config : dict
-        A dictionary to store application configuration.
+        Configuration settings of the application.
     _commands : dict
-        A dictionary to store application commands.
-    _environment_vars : dict
-        A dictionary to store environment variables.
-    container : Container
-        The dependency injection container for the application.
-
-    Methods
-    -------
-    boot()
-        Bootstraps the application by loading environment, configuration, and core providers.
-    _beforeBootstrapProviders()
-        Registers and boots essential providers required before bootstrapping.
-    _bootstraping()
-        Loads user-defined configuration, commands, and environment variables.
-    _afterBootstrapProviders()
-        Registers and boots additional providers after bootstrapping.
+        Registered console commands.
+    _env : dict
+        Environment variables.
+    _container : IContainer
+        The service container instance.
     """
-    booted = False
+
+    _booted: bool = False
+
+    def __init__(self):
+        """
+        Initializes the application by setting up service providers, environment variables,
+        configuration, and the service container.
+        """
+        self._custom_providers: List[Type[IServiceProvider]] = []
+        self._service_providers: List[Type[IServiceProvider]] = []
+        self._config: Dict = {}
+        self._commands: Dict = {}
+        self._env: Dict = {}
+        self._container: IContainer = Container()
+
+        # Register the application instance in the service container
+        self._container.instance(IApplication, self)
 
     @classmethod
-    def started(cls):
+    def boot(cls) -> None:
         """
         Marks the application as booted.
         """
-        cls.booted = True
+        cls._booted = True
+
+    @classmethod
+    def isRunning(cls) -> bool:
+        """
+        Checks if the application has been booted.
+
+        Returns
+        -------
+        bool
+            True if the application is running, otherwise False.
+        """
+        return cls._booted
 
     @classmethod
-    def getCurrentInstance(cls):
+    def getInstance(cls) -> "Application":
         """
-        Returns the existing application instance if available.
+        Retrieves the singleton instance of the Application.
 
         Returns
         -------
         Application
-            The current singleton instance of the application.
+            The current application instance.
 
         Raises
         ------
         RuntimeError
-            If no instance has been initialized yet.
+            If the application has not been initialized yet.
         """
         if cls not in SingletonMeta._instances:
             raise RuntimeError("Application has not been initialized yet. Please create an instance first.")
         return SingletonMeta._instances[cls]
 
     @classmethod
-    def reset(cls):
+    def destroy(cls) -> None:
         """
-        Resets the application instance if it exists.
-
-        This method is used to reset the application instance and clear the singleton instances
-        stored in the `SingletonMeta` class.
+        Destroys the singleton instance of the Application.
         """
         if cls in SingletonMeta._instances:
             del SingletonMeta._instances[cls]
 
-    def __init__(self, container: Container):
+    def withProviders(self, providers: List[Type[IServiceProvider]] = None) -> None:
         """
-        Initializes the Application instance.
+        Sets custom service providers.
 
         Parameters
         ----------
-        container : Container
-            The dependency injection container for the application.
+        providers : List[Type[IServiceProvider]], optional
+            List of service providers, by default None.
         """
-        # Class attributes
-        self._before_boot_service_providers: list = []
-        self._after_boot_service_providers: list = []
-        self._config: dict = {}
-        self._commands: dict = {}
-        self._environment_vars: dict = {}
-        self._booted: bool = False
-
-        # Initialize the application container
-        self.container = container
-        self.container.instance(container)
-
-    def isBooted(self) -> bool:
-        """
-        Check if the application has been booted.
+        self._custom_providers = providers or []
 
-        Returns
-        -------
-        bool
-            True if the application has been booted, False otherwise.
+    def container(self) -> IContainer:
         """
-        return self._booted
-
-    def bind(self, concrete: Callable[..., Any]) -> str:
-        """
-        Bind a callable to the container.
-        This method ensures that the provided callable is not the main function,
-        is unique within the container, and is indeed callable. It then creates
-        a unique key for the callable based on its module and name, and stores
-        the callable in the container's bindings.
-        Args:
-            concrete (Callable[..., Any]): The callable to be bound to the container.
-        Returns:
-            str: The unique key generated for the callable.
-        """
-        return self.container.bind(concrete)
-
-    def transient(self, concrete: Callable[..., Any]) -> str:
-        """
-        Registers a transient service in the container.
-        A transient service is created each time it is requested.
-        Args:
-            concrete (Callable[..., Any]): The callable that defines the service.
-        Returns:
-            str: The unique key generated for the callable.
-        """
-        return self.container.transient(concrete)
-
-    def singleton(self, concrete: Callable[..., Any]) -> str:
-        """
-        Registers a callable as a singleton in the container.
-        This method ensures that the provided callable is not the main module,
-        is unique within the container, and is indeed callable. It then registers
-        the callable as a singleton, storing it in the container's singleton registry.
-        Args:
-            concrete (Callable[..., Any]): The callable to be registered as a singleton.
-        Returns:
-            str: The key under which the singleton is registered in the container.
-        """
-        return self.container.singleton(concrete)
-
-    def scoped(self, concrete: Callable[..., Any]) -> str:
-        """
-        Registers a callable as a scoped service.
-        This method ensures that the provided callable is not the main service,
-        is unique, and is indeed callable. It then registers the callable in the
-        scoped services dictionary with relevant metadata.
-        Args:
-            concrete (Callable[..., Any]): The callable to be registered as a scoped service.
-        Returns:
-            str: The key under which the callable is registered in the scoped services dictionary.
-        """
-        return self.container.scoped(concrete)
-
-    def instance(self, instance: Any) -> str:
-        """
-        Registers an instance as a singleton in the container.
-        Args:
-            instance (Any): The instance to be registered as a singleton.
-        Returns:
-            str: The key under which the instance is registered in the container.
-        """
-        return self.container.instance(instance)
-
-    def alias(self, alias: str, concrete: Any) -> None:
-        """
-        Creates an alias for a registered service.
-        Args:
-            alias (str): The alias name to be used for the service.
-            concrete (Any): The actual service instance or callable to be aliased.
-        Raises:
-            OrionisContainerException: If the concrete instance is not a valid object or if the alias is a primitive type.
-        """
-        return self.container.alias(alias, concrete)
-
-    def has(self, obj: Any) -> bool:
-        """
-        Checks if a service is registered in the container.
-
-        Parameters
-        ----------
-        obj : Any
-            The service class, instance, or alias to check.
+        Returns the service container instance.
 
         Returns
         -------
-        bool
-            True if the service is registered, False otherwise.
+        IContainer
+            The service container.
         """
-        return self.container.has(obj)
+        return self._container
 
-    def make(self, abstract: Any) -> Any:
+    def create(self) -> None:
+        """
+        Initializes and boots the application, including loading commands
+        and service providers.
         """
-        Create and return an instance of a registered service.
 
-        Parameters
-        ----------
-        abstract : Any
-            The service class or alias to instantiate.
+        # Boot the application
+        self._bootstrapping()
 
-        Returns
-        -------
-        Any
-            An instance of the requested service.
+        # Load commands and service providers
+        self._loadCommands()
 
-        Raises
-        ------
-        OrionisContainerException
-            If the service is not found in the container.
-        """
-        return self.container.make(abstract)
+        # Boot service providers
+        asyncio.run(self._bootServiceProviders())
 
-    def forgetScopedInstances(self) -> None:
-        """
-        Reset scoped instances at the beginning of a new request.
-        """
-        return self.container.forgetScopedInstances()
+        # Change the application status to booted
+        Application.boot()
 
-    def boot(self):
+    async def _bootServiceProviders(self) -> None:
         """
-        Bootstraps the application by loading environment configuration and core providers.
-        Notes
-        -----
-        The bootstrapping process involves several steps:
-        1. Loading essential services.
-        2. Executing pre-bootstrap provider hooks.
-        3. Initializing core components.
-        4. Executing post-bootstrap provider hooks.
-        5. Loading command-line interface commands.
-        After these steps, the application is marked as booted.
+        Boots all registered service providers.
         """
-        # Mark the application as booted
-        Application.started()
+        for service in self._service_providers:
+            provider: IServiceProvider = service(app=self._container)
+            provider.register()
 
-        # Bootstrapping process
-        self._bootServices()
-        self._beforeBootstrapProviders()
-        self._bootstrapping()
-        self._afterBootstrapProviders()
-        self._loadCommands()
+            # If the provider has a boot method, execute it (sync or async)
+            if hasattr(provider, 'boot') and callable(provider.boot):
+                if inspect.iscoroutinefunction(provider.boot):
+                    await provider.boot()
+                else:
+                    provider.boot()
 
-    def _bootServices(self):
+    def _bootstrapping(self) -> None:
         """
-        Bootstraps the application services.
-
-        This method is responsible for loading the application's services. It reads all the
-        ServiceProviders from the Core and those defined by the developer. Then, it stores
-        in class dictionaries the services that need to be loaded before and after the Bootstrap.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
+        Loads essential components such as environment variables,
+        configurations, commands, and service providers.
         """
-        services_bootstrapper_key = self.singleton(ServiceProvidersBootstrapper)
-        services_bootstrapper: ServiceProvidersBootstrapper = self.make(services_bootstrapper_key)
-        self._before_boot_service_providers = services_bootstrapper.getBeforeServiceProviders()
-        self._after_boot_service_providers = services_bootstrapper.getAfterServiceProviders()
+        bootstrappers = [
+            {'property': self._env, 'instance': EnvironmentBootstrapper()},
+            {'property': self._config, 'instance': ConfigBootstrapper()},
+            {'property': self._commands, 'instance': CommandsBootstrapper()},
+            {'property': self._service_providers, 'instance': ServiceProvidersBootstrapper(self._custom_providers)},
+        ]
 
-    def _beforeBootstrapProviders(self):
-        """
-        Loads and registers essential services before bootstrapping.
+        for bootstrapper in bootstrappers:
+            try:
+                property_ref: Dict = bootstrapper["property"]
+                bootstrapper_instance: IBootstrapper = bootstrapper["instance"]
+                property_ref.update(bootstrapper_instance.get())
+            except Exception as e:
+                raise BootstrapRuntimeError(f"Error bootstrapping {type(bootstrapper_instance).__name__}: {str(e)}") from e
 
-        This method is responsible for loading and registering the services that are
-        required before the main bootstrapping process. It iterates through the list
-        of service providers that need to be initialized early, registers them, and
-        then boots them to make sure they are ready for use.
+    def _loadCommands(self) -> None:
         """
-        for service in self._before_boot_service_providers:
-            _environment_provider : ServiceProvider = service(app=self.container)
-            _environment_provider.register()
-            _environment_provider.boot()
-
-    def _bootstrapping(self):
+        Registers application commands in the service container.
         """
-        Loads configuration, commands, environment variables, and other bootstrappers.
+        for command, data_command in self._commands.items():
+            self._container.transient(data_command.get('signature'), data_command.get('concrete'))
 
-        This method initializes and updates the class dictionaries with the results
-        from various bootstrappers. It ensures that the application has the necessary
-        configuration, commands, and environment variables loaded before proceeding
-        with the rest of the bootstrapping process.
-        """
-        singletons_bootstrappers = [
-            (self._config, ConfigBootstrapper),
-            (self._commands, CommandsBootstrapper),
-            (self._environment_vars, EnvironmentBootstrapper)
-        ]
-        for bootstrapper in singletons_bootstrappers:
-            property_cls, bootstrapper_class = bootstrapper
-            bootstrapper_key = self.singleton(bootstrapper_class)
-            bootstrapper_instance : IBootstrapper = self.make(bootstrapper_key)
-            property_cls.update(bootstrapper_instance.get())
 
-    def _loadCommands(self):
-        """
-        Loads CLI commands, including both core system commands and those defined by the developer.
 
-        This method iterates over the commands stored in the `_commands` attribute, binds each command 
-        to its corresponding concrete implementation, and registers the command alias.
 
-        Parameters
-        ----------
-        None
 
-        Returns
-        -------
-        None
-        """
-        for command in self._commands.keys():
-            data_command:dict = self._commands[command]
-            id_container_concrete = self.bind(data_command.get('concrete'))
-            self.alias(alias=command, concrete=id_container_concrete)
 
-    def _afterBootstrapProviders(self):
-        """
-        Loads services into the container that depend on the Bootstrap process being completed.
 
-        This method iterates over the list of service providers that need to be loaded after the
-        Bootstrap process. For each service provider, it creates an instance, registers it, and
-        then boots it.
 
-        Parameters
-        ----------
-        None
 
-        Returns
-        -------
-        None
-        """
-        for service in self._after_boot_service_providers:
-            _environment_provider : ServiceProvider = service(app=self.container)
-            _environment_provider.register()
-            _environment_provider.boot()
 
-@contextmanager
-def app_context():
-    """
-    Context manager for creating an instance of the Orionis application.
+# @contextmanager
+# def app_context():
+#     """
+#     Context manager for creating an instance of the Orionis application.
 
-    This function initializes the Orionis application with a new container,
-    ensuring that the application is properly set up before use.
+#     This function initializes the Orionis application with a new container,
+#     ensuring that the application is properly set up before use.
 
-    Yields
-    ------
-    Application
-        The initialized Orionis application instance.
+#     Yields
+#     ------
+#     Application
+#         The initialized Orionis application instance.
 
-    Raises
-    ------
-    RuntimeError
-        If the application has not been properly initialized.
-    """
-    try:
+#     Raises
+#     ------
+#     RuntimeError
+#         If the application has not been properly initialized.
+#     """
+#     try:
 
-        # Check if the application has been booted
-        if not Application.booted:
-            app = Application(Container()).boot()
-        else:
-            app = Application.getCurrentInstance()
+#         # Check if the application has been booted
+#         if not Application.booted:
+#             app = Application(Container()).boot()
+#         else:
+#             app = Application.getCurrentInstance()
 
-        # Yield the application instance
-        yield app
+#         # Yield the application instance
+#         yield app
 
-    finally:
+#     finally:
 
-        # Close Context Manager
-        pass
+#         # Close Context Manager
+#         pass
 
-def app_booted():
-    """
-    Check if the application has been booted.
+# def app_booted():
+#     """
+#     Check if the application has been booted.
 
-    Returns:
-        bool: True if the application has been booted, False otherwise.
-    """
-    return Application.booted
+#     Returns:
+#         bool: True if the application has been booted, False otherwise.
+#     """
+#     return Application.booted
 
-def orionis():
-    """
-    Creates a new instance of the Orionis application.
+# def orionis():
+#     """
+#     Creates a new instance of the Orionis application.
 
-    Ensures that any existing singleton instance of `Application` is removed before
-    creating a fresh instance. It resets the singleton instances stored in `SingletonMeta`
-    and `Container`.
+#     Ensures that any existing singleton instance of `Application` is removed before
+#     creating a fresh instance. It resets the singleton instances stored in `SingletonMeta`
+#     and `Container`.
 
-    Returns
-    -------
-    Application
-        A new instance of the Orionis application.
-    """
-    Container.reset()
-    Application.reset()
+#     Returns
+#     -------
+#     Application
+#         A new instance of the Orionis application.
+#     """
+#     Application.reset()
 
-    return Application(Container())
+#     return Application()

orionis/luminate/container/container.py

@@ -21,30 +21,9 @@ class Container(IContainer):
     @classmethod
     def destroy(cls):
         """
-        Destroys the current instance of the container.
-
-        This method resets the singleton instance, effectively clearing all registered
-        services and instances.
-
-        Examples
-        --------
-        >>> Container.destroy()
-        """
-        cls._instance = None
-
-    @classmethod
-    def reset(cls):
-        """
-        Resets the container to its initial state.
-
-        This method destroys the current instance and immediately creates a new one.
-
-        Examples
-        --------
-        >>> Container.reset()
+        Destroys the container instance.
         """
         cls._instance = None
-        super().__new__(cls)
 
     def __new__(cls):
         """
@@ -61,6 +40,7 @@ class Container(IContainer):
                     cls._instance._scoped_services = {}
                     cls._instance._singleton_services = {}
                     cls._instance._aliases_services = {}
+                    cls._instance.instance(IContainer, cls._instance)
         return cls._instance
 
     def bind(self, abstract: Callable[..., Any], concrete: Callable[..., Any], lifetime: str = Lifetime.TRANSIENT.value) -> None:

orionis/luminate/container/container_integrity.py

@@ -130,8 +130,8 @@ class ContainerIntegrity(IContainerIntegrity):
         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 and numbers, without spaces or special characters.")
+        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",