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

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 orionis.luminate.contracts.foundation.providers.i_service_providers_bootstrapper import IServiceProvidersBootstrapper
-from orionis.luminate.container.container import Container
+from typing import List, Type
+from orionis.luminate.contracts.foundation.providers.service_providers_bootstrapper import IServiceProvidersBootstrapper
 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

@@ -1,3 +1,4 @@
+from orionis.luminate.contracts.services.commands.reactor_commands_service import IReactorCommandsService
 from orionis.luminate.providers.service_provider import ServiceProvider
 from orionis.luminate.services.commands.reactor_commands_service import ReactorCommandsService
 
@@ -7,13 +8,13 @@ class ReactorCommandsServiceProvider(ServiceProvider):
         """
         Registers services or bindings into the given container.
         """
-        self._container_id = self.app.singleton(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

@@ -1,3 +1,4 @@
+from orionis.luminate.contracts.services.commands.schedule_service import IScheduleService
 from orionis.luminate.providers.service_provider import ServiceProvider
 from orionis.luminate.services.commands.scheduler_service import ScheduleService
 
@@ -7,13 +8,4 @@ class ScheduleServiceProvider(ServiceProvider):
         """
         Registers services or bindings into the given container.
         """
-        self._container_id = self.app.scoped(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

@@ -1,3 +1,4 @@
+from orionis.luminate.contracts.services.config.config_service import IConfigService
 from orionis.luminate.providers.service_provider import ServiceProvider
 from orionis.luminate.services.config.config_service import ConfigService
 
@@ -7,13 +8,4 @@ class ConfigServiceProvider(ServiceProvider):
         """
         Registers services or bindings into the given container.
         """
-        self._container_id = self.app.scoped(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

@@ -1,16 +1,15 @@
+from orionis.luminate.contracts.services.environment.environment_service import IEnvironmentService
 from orionis.luminate.providers.service_provider import ServiceProvider
 from orionis.luminate.services.environment.environment_service import EnvironmentService
 from orionis.luminate.services.files.path_resolver_service import PathResolverService
 
 class EnvironmentServiceProvider(ServiceProvider):
 
-    beferoBootstrapping = True
-
     def register(self) -> None:
         """
         Registers services or bindings into the given container.
         """
-        self._container_id = self.app.singleton(EnvironmentService)
+        self.app.singleton(IEnvironmentService, EnvironmentService)
 
     def boot(self) -> None:
         """
@@ -19,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

@@ -1,15 +1,14 @@
+from orionis.luminate.contracts.services.files.path_resolver_service import IPathResolverService
 from orionis.luminate.providers.service_provider import ServiceProvider
 from orionis.luminate.services.files.path_resolver_service import PathResolverService
 
 class PathResolverProvider(ServiceProvider):
 
-    beferoBootstrapping = True
-
     def register(self) -> None:
         """
         Registers services or bindings into the given container.
         """
-        self._container_id = self.app.singleton(PathResolverService)
+        self.app.singleton(IPathResolverService, PathResolverService)
 
     def boot(self) -> None:
         """
@@ -18,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

@@ -1,3 +1,4 @@
+from orionis.luminate.contracts.services.log.log_service import ILogguerService
 from orionis.luminate.providers.service_provider import ServiceProvider
 from orionis.luminate.services.log.log_service import LogguerService
 
@@ -7,7 +8,7 @@ class LogServiceProvider(ServiceProvider):
         """
         Registers services or bindings into the given container.
         """
-        self._container_id = self.app.singleton(LogguerService)
+        self.app.singleton(ILogguerService, LogguerService)
 
     def boot(self) -> None:
         """
@@ -16,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

@@ -1,4 +1,4 @@
-from orionis.luminate.contracts.providers.i_service_provider import IServiceProvider
+from orionis.luminate.contracts.providers.service_provider import IServiceProvider
 from orionis.luminate.container.container import Container
 
 class ServiceProvider(IServiceProvider):
@@ -11,10 +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.
@@ -52,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,7 +1,6 @@
 import time
 from typing import Any, Dict, Optional
-from orionis.luminate.contracts.services.commands.i_reactor_commands_service import IReactorCommandsService
-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
@@ -11,7 +10,7 @@ from orionis.luminate.console.parser import Parser
 from orionis.luminate.facades.app_facade import app
 from orionis.luminate.facades.log.log_facade import Log
 
-class ReactorCommandsService(IReactorCommandsService):
+class ReactorCommandsService:
     """
     Service responsible for executing and managing CLI commands in Orionis.
 
@@ -21,29 +20,20 @@ class ReactorCommandsService(IReactorCommandsService):
     - 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.
 
@@ -119,7 +109,7 @@ class ReactorCommandsService(IReactorCommandsService):
                 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/commands/scheduler_service.py

@@ -7,11 +7,10 @@ from typing import Any
 from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.cron import CronTrigger
 from apscheduler.triggers.interval import IntervalTrigger
-from orionis.luminate.contracts.services.commands.i_schedule_service import IScheduleService
 from orionis.luminate.console.exceptions.cli_exception import CLIOrionisScheduleException
 from orionis.luminate.facades.commands.commands_facade import Command
 
-class ScheduleService(IScheduleService):
+class ScheduleService:
     """
     A class that manages the scheduling of tasks using the APScheduler.
 

orionis/luminate/services/config/config_service.py

@@ -1,18 +1,17 @@
 import copy
 from typing import Any, Optional
-from orionis.luminate.contracts.services.config.i_config_service import IConfigService
-from orionis.luminate.foundation.config.config_bootstrapper import ConfigBootstrapper
+from orionis.luminate.container.resolve import Resolve
 
-class ConfigService(IConfigService):
+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

@@ -3,9 +3,32 @@ import os
 from pathlib import Path
 from typing import Any
 from dotenv import set_key, unset_key, dotenv_values
-from orionis.luminate.contracts.services.environment.i_environment_service import IEnvironmentService
 
-class EnvironmentService(IEnvironmentService):
+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/luminate/services/files/path_resolver_service.py

@@ -1,8 +1,7 @@
 import os
 from pathlib import Path
-from orionis.luminate.contracts.services.files.i_path_resolver_service import IPathResolverService
 
-class PathResolverService(IPathResolverService):
+class PathResolverService:
 
     def __init__(self):
         """

orionis/luminate/services/log/log_service.py

@@ -4,10 +4,9 @@ from pathlib import Path
 import re
 from datetime import datetime
 from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
-from orionis.luminate.contracts.services.log.i_log_service import ILogguerService
 from orionis.luminate.services.config.config_service import ConfigService
 
-class LogguerService(ILogguerService):
+class LogguerService:
     """
     A service class for logging messages with different severity levels.
 

orionis/luminate/support/exception_to_dict.py

@@ -1,5 +1,5 @@
 import traceback
-from orionis.luminate.contracts.support.i_exception_to_dict import IExceptionsToDict
+from orionis.luminate.contracts.support.exception_to_dict import IExceptionsToDict
 
 class ExceptionsToDict(IExceptionsToDict):
     """

orionis/luminate/support/reflection.py

@@ -3,7 +3,7 @@ import inspect
 import importlib
 from enum import Enum
 from typing import Any, List, Optional
-from orionis.luminate.contracts.support.i_reflection import IReflection
+from orionis.luminate.contracts.support.reflection import IReflection
 
 class Reflection(IReflection):
     """

orionis/luminate/support/std.py

@@ -1,4 +1,4 @@
-from orionis.luminate.contracts.support.i_std import IStdClass
+from orionis.luminate.contracts.support.std import IStdClass
 
 class StdClass(IStdClass):
     """

{orionis-0.139.0.dist-info → orionis-0.152.0.dist-info}/METADATA

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