orionis 0.151.0__tar.gz → 0.153.0__tar.gz

{orionis-0.151.0/orionis.egg-info → orionis-0.153.0}/PKG-INFO

@@ -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

{orionis-0.151.0 → orionis-0.153.0}/orionis/framework.py

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

orionis-0.153.0/orionis/luminate/application.py

@@ -0,0 +1,254 @@
+import asyncio
+import inspect
+from typing import Dict, List, Type
+from contextlib import contextmanager
+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
+
+class Application(metaclass=SingletonMeta):
+    """
+    Main application class that follows the Singleton pattern.
+
+    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
+        Configuration settings of the application.
+    _commands : dict
+        Registered console commands.
+    _env : dict
+        Environment variables.
+    _container : IContainer
+        The service container instance.
+    """
+
+    _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 boot(cls) -> None:
+        """
+        Marks the application as booted.
+        """
+        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 getInstance(cls) -> "Application":
+        """
+        Retrieves the singleton instance of the Application.
+
+        Returns
+        -------
+        Application
+            The current application instance.
+
+        Raises
+        ------
+        RuntimeError
+            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 destroy(cls) -> None:
+        """
+        Destroys the singleton instance of the Application.
+        """
+        if cls in SingletonMeta._instances:
+            del SingletonMeta._instances[cls]
+
+    def withProviders(self, providers: List[Type[IServiceProvider]] = None) -> None:
+        """
+        Sets custom service providers.
+
+        Parameters
+        ----------
+        providers : List[Type[IServiceProvider]], optional
+            List of service providers, by default None.
+        """
+        self._custom_providers = providers or []
+
+    def container(self) -> IContainer:
+        """
+        Returns the service container instance.
+
+        Returns
+        -------
+        IContainer
+            The service container.
+        """
+        return self._container
+
+    def create(self) -> None:
+        """
+        Initializes and boots the application, including loading commands
+        and service providers.
+        """
+
+        # Boot the application
+        self._bootstrapping()
+
+        # Load commands and service providers
+        self._loadCommands()
+
+        # Boot service providers
+        asyncio.run(self._bootServiceProviders())
+
+        # Change the application status to booted
+        Application.boot()
+
+    async def _bootServiceProviders(self) -> None:
+        """
+        Boots all registered service providers.
+        """
+        for service in self._service_providers:
+            provider: IServiceProvider = service(app=self._container)
+            provider.register()
+
+            # 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 _bootstrapping(self) -> None:
+        """
+        Loads essential components such as environment variables,
+        configurations, commands, and service providers.
+        """
+        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)},
+        ]
+
+        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
+
+    def _loadCommands(self) -> None:
+        """
+        Registers application commands in the service container.
+        """
+        for command, data_command in self._commands.items():
+            self._container.transient(data_command.get('signature'), data_command.get('concrete'))
+
+
+
+
+
+
+
+
+
+
+# @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.
+
+#     Yields
+#     ------
+#     Application
+#         The initialized Orionis application instance.
+
+#     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()
+
+#         # Yield the application instance
+#         yield app
+
+#     finally:
+
+#         # Close Context Manager
+#         pass
+
+# def app_booted():
+#     """
+#     Check if the application has been 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.
+
+#     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.
+#     """
+#     Application.reset()
+
+#     return Application()

{orionis-0.151.0 → orionis-0.153.0}/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-0.151.0 → orionis-0.153.0}/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",

orionis-0.153.0/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-0.153.0/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-0.151.0 → orionis-0.153.0}/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-0.151.0 → orionis-0.153.0}/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-0.153.0/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-0.153.0/orionis/luminate/foundation/providers/service_providers_bootstrapper.py

@@ -0,0 +1,106 @@
+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.foundation.exceptions.exception_bootstrapper import BootstrapRuntimeError
+from orionis.luminate.providers.service_provider import ServiceProvider
+
+class ServiceProvidersBootstrapper(IServiceProvidersBootstrapper):
+    """
+    Bootstrapper for loading and managing service 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:
+        """
+        Scans the provider directories and loads provider classes.
+
+        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.
+        """
+        # Base path for the project
+        base_path = pathlib.Path.cwd()
+
+        # Directories to scan for provider classes (Core Providers)
+        provider_dirs = [
+            pathlib.Path(__file__).resolve().parent.parent.parent / "providers"
+        ]
+
+        # Scan directories for provider classes
+        for provider_dir in provider_dirs:
+            if not provider_dir.is_dir():
+                continue
+
+            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
+                if 'site-packages.' in module_path:
+                    module_path = module_path.split('site-packages.')[1]
+
+                try:
+                    # Import the module
+                    module = importlib.import_module(module_path.strip())
+
+                    # 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 {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: 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 appropriate list.
+
+        Args:
+            concrete (Type[ServiceProvider]): The service provider class to register.
+
+        Raises:
+            BootstrapRuntimeError: If the provider class is invalid.
+        """
+        if not hasattr(concrete, "register") or not callable(concrete.register):
+            raise BootstrapRuntimeError(f"Service provider {concrete.__name__} must implement a 'register' method.")
+
+        self._service_providers.append(concrete)
+
+    def get(self) -> List[Type[ServiceProvider]]:
+        """
+        Retrieve the registered service providers that should run before bootstrapping.
+
+        Returns:
+            List[Type[ServiceProvider]]: A list of service providers to run before bootstrapping.
+        """
+        return self._service_providers

{orionis-0.151.0 → orionis-0.153.0}/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)