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

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/foundation/providers/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/environment/environment_facade.py

@@ -2,30 +2,6 @@ from orionis.luminate.contracts.facades.environment.environment_facade import IE
 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

orionis/luminate/foundation/exceptions/exception_providers.py

@@ -0,0 +1,54 @@
+class ProvidersException(Exception):
+    """
+    Exception related to the providers module.
+
+    Parameters
+    ----------
+    message : str
+        The error message describing the issue.
+
+    Attributes
+    ----------
+    message : str
+        The stored error message.
+
+    Methods
+    -------
+    __str__()
+        Returns a user-friendly string representation of the exception.
+    __repr__()
+        Returns a detailed representation for debugging purposes.
+    """
+
+    def __init__(self, message: str):
+        """
+        Initialize the exception with a message.
+
+        Parameters
+        ----------
+        message : str
+            The error message describing the issue.
+        """
+        super().__init__(f"[ProvidersException]: {message}")
+
+    def __str__(self) -> str:
+        """
+        Returns a user-friendly string representation.
+
+        Returns
+        -------
+        str
+            A formatted error message.
+        """
+        return self.args[0]
+
+    def __repr__(self) -> str:
+        """
+        Returns a detailed representation for debugging.
+
+        Returns
+        -------
+        str
+            A detailed string representation including the exception name.
+        """
+        return f"{self.__class__.__name__}({self.args[0]!r})"

orionis/luminate/foundation/providers/service_providers_bootstrapper.py

@@ -1,17 +1,28 @@
 import importlib
 import inspect
 import pathlib
+from typing import List, Type
 from orionis.luminate.contracts.foundation.providers.service_providers_bootstrapper import IServiceProvidersBootstrapper
-from orionis.luminate.container.container import Container
 from orionis.luminate.foundation.exceptions.exception_bootstrapper import BootstrapRuntimeError
 from orionis.luminate.providers.service_provider import ServiceProvider
 
 class ServiceProvidersBootstrapper(IServiceProvidersBootstrapper):
+    """
+    Bootstrapper for loading and managing service providers.
 
-    def __init__(self, container : Container) -> None:
-        self._container = container
-        self._before_providers = []
-        self._after_providers = []
+    This class is responsible for scanning directories, loading service provider classes,
+    and registering them in the container.
+    """
+
+    def __init__(self, custom_providers: List[Type[ServiceProvider]] = None) -> None:
+        """
+        Initializes the ServiceProvidersBootstrapper.
+
+        Args:
+            providers (List[Type[ServiceProvider]]): A list of service provider classes to register manually.
+        """
+        self._service_providers: List[Type[ServiceProvider]] = []
+        self._custom_providers = custom_providers or []
         self._autoload()
 
     def _autoload(self) -> None:
@@ -21,26 +32,27 @@ class ServiceProvidersBootstrapper(IServiceProvidersBootstrapper):
         This method searches for Python files in the specified directories, imports them,
         and registers any class that inherits from `ServiceProvider`.
 
-        Raises
-        ------
-        BootstrapRuntimeError
-            If there is an error loading a module.
+        Raises:
+            BootstrapRuntimeError: If there is an error loading a module.
         """
-
+        # Base path for the project
         base_path = pathlib.Path.cwd()
 
-        command_dirs = [
+        # Directories to scan for provider classes (Core Providers)
+        provider_dirs = [
             pathlib.Path(__file__).resolve().parent.parent.parent / "providers"
         ]
 
-        for cmd_dir in command_dirs:
-            if not cmd_dir.is_dir():
+        # Scan directories for provider classes
+        for provider_dir in provider_dirs:
+            if not provider_dir.is_dir():
                 continue
 
-            for file_path in cmd_dir.rglob("*.py"):
+            for file_path in provider_dir.rglob("*.py"):
                 if file_path.name == "__init__.py":
                     continue
 
+                # Convert file path to module path
                 module_path = ".".join(file_path.relative_to(base_path).with_suffix("").parts)
 
                 # Remove 'site-packages.' prefix if present
@@ -48,51 +60,47 @@ class ServiceProvidersBootstrapper(IServiceProvidersBootstrapper):
                     module_path = module_path.split('site-packages.')[1]
 
                 try:
+                    # Import the module
                     module = importlib.import_module(module_path.strip())
 
-                    # Find and register command classes
-                    for name, concrete in inspect.getmembers(module, inspect.isclass):
+                    # Find and register provider classes
+                    for _, concrete in inspect.getmembers(module, inspect.isclass):
                         if issubclass(concrete, ServiceProvider) and concrete is not ServiceProvider:
                             self._register(concrete)
                 except Exception as e:
-                    raise BootstrapRuntimeError(f"Error loading {module_path}") from e
+                    raise BootstrapRuntimeError(f"Error loading module {module_path}: {str(e)}") from e
+
+        # Register manually provided service providers
+        try:
+            for concrete in self._custom_providers:
+                if issubclass(concrete, ServiceProvider) and concrete is not ServiceProvider:
+                    self._register(concrete)
+        except Exception as e:
+            raise BootstrapRuntimeError(f"Error loading provider classes: {str(e)}") from e
 
-    def _register(self, concrete: ServiceProvider) -> None:
+    def _register(self, concrete: Type[ServiceProvider]) -> None:
         """
         Validates and registers a service provider class.
 
         This method ensures that the provided class is valid (inherits from `ServiceProvider`,
-        has a `register` and `boot` method) and registers it in the
-        `_service_providers` dictionary.
+        has a `register` and `boot` method) and registers it in the appropriate list.
 
-        Parameters
-        ----------
-        concrete : ServiceProvider
-            The service provider class to register
-        """
-        if concrete.beferoBootstrapping:
-            self._before_providers.append(concrete)
-        else:
-            self._after_providers.append(concrete)
+        Args:
+            concrete (Type[ServiceProvider]): The service provider class to register.
 
-    def getBeforeServiceProviders(self) -> list:
+        Raises:
+            BootstrapRuntimeError: If the provider class is invalid.
         """
-        Retrieve the registered service providers.
+        if not hasattr(concrete, "register") or not callable(concrete.register):
+            raise BootstrapRuntimeError(f"Service provider {concrete.__name__} must implement a 'register' method.")
 
-        Returns
-        -------
-        list
-            A list of registered service providers
-        """
-        return self._before_providers
+        self._service_providers.append(concrete)
 
-    def getAfterServiceProviders(self) -> list:
+    def get(self) -> List[Type[ServiceProvider]]:
         """
-        Retrieve the registered service providers.
+        Retrieve the registered service providers that should run before bootstrapping.
 
-        Returns
-        -------
-        list
-            A list of registered service providers
+        Returns:
+            List[Type[ServiceProvider]]: A list of service providers to run before bootstrapping.
         """
-        return self._after_providers
+        return self._service_providers

orionis/luminate/providers/commands/reactor_commands_service_provider.py

@@ -8,13 +8,13 @@ class ReactorCommandsServiceProvider(ServiceProvider):
         """
         Registers services or bindings into the given container.
         """
-        self._container_id = self.app.singleton(IReactorCommandsService, ReactorCommandsService)
+        self.app.singleton(IReactorCommandsService, ReactorCommandsService)
 
-    def boot(self,) -> None:
+    def boot(self) -> None:
         """
         Boot the service provider.
 
         This method is intended to be overridden by subclasses to perform
         any necessary bootstrapping or initialization tasks.
         """
-        self.app.make(self._container_id)
+        self.app.make(IReactorCommandsService)

orionis/luminate/providers/commands/scheduler_provider.py

@@ -8,13 +8,4 @@ class ScheduleServiceProvider(ServiceProvider):
         """
         Registers services or bindings into the given container.
         """
-        self._container_id = self.app.scoped(IScheduleService, ScheduleService)
-
-    def boot(self,) -> None:
-        """
-        Boot the service provider.
-
-        This method is intended to be overridden by subclasses to perform
-        any necessary bootstrapping or initialization tasks.
-        """
-        self.app.make(self._container_id)
+        self.app.scoped(IScheduleService, ScheduleService)

orionis/luminate/providers/config/config_service_provider.py

@@ -8,13 +8,4 @@ class ConfigServiceProvider(ServiceProvider):
         """
         Registers services or bindings into the given container.
         """
-        self._container_id = self.app.scoped(IConfigService, ConfigService)
-
-    def boot(self,) -> None:
-        """
-        Boot the service provider.
-
-        This method is intended to be overridden by subclasses to perform
-        any necessary bootstrapping or initialization tasks.
-        """
-        self.app.make(self._container_id)
+        self.app.scoped(IConfigService, ConfigService)

orionis/luminate/providers/environment/environment__service_provider.py

@@ -5,13 +5,11 @@ from orionis.luminate.services.files.path_resolver_service import PathResolverSe
 
 class EnvironmentServiceProvider(ServiceProvider):
 
-    beferoBootstrapping = True
-
     def register(self) -> None:
         """
         Registers services or bindings into the given container.
         """
-        self._container_id = self.app.singleton(IEnvironmentService, EnvironmentService)
+        self.app.singleton(IEnvironmentService, EnvironmentService)
 
     def boot(self) -> None:
         """
@@ -20,4 +18,4 @@ class EnvironmentServiceProvider(ServiceProvider):
         This method is intended to be overridden by subclasses to perform
         any necessary bootstrapping or initialization tasks.
         """
-        self.app.make(self._container_id)
+        self.app.make(IEnvironmentService)

orionis/luminate/providers/files/paths_provider.py

@@ -4,13 +4,11 @@ from orionis.luminate.services.files.path_resolver_service import PathResolverSe
 
 class PathResolverProvider(ServiceProvider):
 
-    beferoBootstrapping = True
-
     def register(self) -> None:
         """
         Registers services or bindings into the given container.
         """
-        self._container_id = self.app.singleton(IPathResolverService, PathResolverService)
+        self.app.singleton(IPathResolverService, PathResolverService)
 
     def boot(self) -> None:
         """
@@ -19,4 +17,4 @@ class PathResolverProvider(ServiceProvider):
         This method is intended to be overridden by subclasses to perform
         any necessary bootstrapping or initialization tasks.
         """
-        self.app.make(self._container_id)
+        self.app.make(IPathResolverService)

orionis/luminate/providers/log/log_service_provider.py

@@ -8,7 +8,7 @@ class LogServiceProvider(ServiceProvider):
         """
         Registers services or bindings into the given container.
         """
-        self._container_id = self.app.singleton(ILogguerService, LogguerService)
+        self.app.singleton(ILogguerService, LogguerService)
 
     def boot(self) -> None:
         """
@@ -17,4 +17,4 @@ class LogServiceProvider(ServiceProvider):
         This method is intended to be overridden by subclasses to perform
         any necessary bootstrapping or initialization tasks.
         """
-        self.app.make(self._container_id)
+        self.app.make(ILogguerService)

orionis/luminate/providers/service_provider.py

@@ -11,9 +11,6 @@ class ServiceProvider(IServiceProvider):
         The container instance to be used by the service provider.
     """
 
-    # Indicates whether the service provider is a bootstrapper.
-    beferoBootstrapping = False
-
     def __init__(self, app : Container) -> None:
         """
         Initialize the service provider with the given container.
@@ -51,4 +48,4 @@ class ServiceProvider(IServiceProvider):
         container : Container
             The container instance where services will be booted.
         """
-        raise NotImplementedError("This method should be overridden in the subclass")
+        pass

orionis/luminate/services/commands/reactor_commands_service.py

@@ -1,6 +1,6 @@
 import time
 from typing import Any, Dict, Optional
-from orionis.luminate.foundation.console.command_bootstrapper import CommandsBootstrapper
+from orionis.luminate.container.resolve import Resolve
 from orionis.luminate.console.base.command import BaseCommand
 from orionis.luminate.console.command_filter import CommandFilter
 from orionis.luminate.console.exceptions.cli_exception import CLIOrionisException
@@ -20,29 +20,20 @@ class ReactorCommandsService:
     - Managing execution timing and error handling.
     """
 
-    def __init__(
-        self,
-        commands_bootstrapper: CommandsBootstrapper,
-        command_filter: CommandFilter,
-        log: Log,
-        executor: Executor,
-        console: Console,
-    ):
+    def __init__(self, command_filter: CommandFilter, log: Log, executor: Executor, console: Console, app = Resolve('__orionis__')) -> None:
         """
         Initializes the ReactorCommandsService instance.
 
         Assigns provided services to internal attributes for later use in command
         execution, filtering, and logging.
         """
-        self.commands_bootstrapper = commands_bootstrapper
+        self.commands = app._commands if hasattr(app, '_commands') else {}
         self.command_filter = command_filter
         self.log = log
         self.console_executor = executor
         self.console_output = console
 
-    def _parse_arguments(
-        self, arguments, vars: Optional[Dict[str, Any]] = None, *args, **kwargs
-    ):
+    def _parse_arguments(self, arguments, vars: Optional[Dict[str, Any]] = None, *args, **kwargs):
         """
         Parses command-line arguments using the Orionis argument parser.
 
@@ -118,7 +109,7 @@ class ReactorCommandsService:
                 self.console_executor.running(program=signature)
 
             # Retrieve command from bootstrapper
-            command = self.commands_bootstrapper.get(signature)
+            command = self.commands.get(signature)
 
             # Parse command arguments dynamically based on execution context
             args_dict = self._parse_arguments(command.get('arguments', []), vars, *args, **kwargs)

orionis/luminate/services/config/config_service.py

@@ -1,17 +1,17 @@
 import copy
 from typing import Any, Optional
-from orionis.luminate.foundation.config.config_bootstrapper import ConfigBootstrapper
+from orionis.luminate.container.resolve import Resolve
 
 class ConfigService:
 
-    def __init__(self,  config_bootstrapper: ConfigBootstrapper) -> None:
+    def __init__(self,  app = Resolve('__orionis__')) -> None:
         """
         Initializes the ConfigService with the provided configuration.
 
         Args:
             config (dict): A dictionary containing configuration settings.
         """
-        real_config : dict = config_bootstrapper.get()
+        real_config : dict = app._config if hasattr(app, '_config') else {}
         self._config = copy.deepcopy(real_config)
 
     def set(self, key: str, value: Any) -> None:

orionis/luminate/services/environment/environment_service.py

@@ -4,6 +4,30 @@ from pathlib import Path
 from typing import Any
 from dotenv import set_key, unset_key, dotenv_values
 
+def env(key: str, default=None) -> Any:
+    """
+    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
+    -------
+    Any
+        The value of the environment variable, or the default value if the variable
+        does not exist.
+    """
+    return EnvironmentService().get(key, default)
+
 class EnvironmentService:
 
     def __init__(self, path: str = None):

{orionis-0.151.0.dist-info → orionis-0.153.0.dist-info}/METADATA

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