orionis 0.139.0__tar.gz → 0.152.0__tar.gz

{orionis-0.139.0/orionis.egg-info → orionis-0.152.0}/PKG-INFO

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

{orionis-0.139.0 → orionis-0.152.0}/orionis/framework.py

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

orionis-0.152.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.139.0 → orionis-0.152.0}/orionis/luminate/console/base/command.py

@@ -1,4 +1,4 @@
-from orionis.luminate.contracts.console.base.i_command import IBaseCommand
+from orionis.luminate.contracts.console.base.command import IBaseCommand
 from orionis.luminate.console.output.console import Console
 from orionis.luminate.console.output.progress_bar import ProgressBar
 
@@ -8,9 +8,12 @@ class BaseCommand(IBaseCommand):
     various types (success, info, warning, etc.) in different styles (e.g., text, bold, colored).
 
     This class acts as a foundation for command classes, offering utility methods to interact with the console.
-    """
 
-    # Command arguments
+    Parameters
+    ----------
+    args : dict, optional
+        A dictionary containing the command arguments (default is an empty dictionary).
+    """
     args = {}
 
     def success(self, message: str = '', timestamp: bool = True):

{orionis-0.139.0 → orionis-0.152.0}/orionis/luminate/console/command_filter.py

@@ -1,4 +1,4 @@
-from orionis.luminate.contracts.console.i_command_filter import ICommandFilter
+from orionis.luminate.contracts.console.command_filter import ICommandFilter
 
 # List of commands to exclude from output formatting
 EXCLUDED_COMMANDS = [

{orionis-0.139.0 → orionis-0.152.0}/orionis/luminate/console/commands/cache_clear.py

@@ -44,9 +44,10 @@ class CacheClearCommand(BaseCommand):
             # Recursively traverse directories starting from the base path
             for root, dirs, files in os.walk(base_path, topdown=True):
 
-                # Skip the 'venv' directory and its subdirectories
-                if 'venv' in dirs:
-                    dirs.remove('venv')
+                # Skip common environment directories (e.g., venv, env, vendor, node_modules)
+                for env_dir in ['venv', 'env', 'virtualenv', 'venv3', 'env3', 'venv2', 'env2', 'vendor', 'node_modules', 'environment']:
+                    if env_dir in dirs:
+                        dirs.remove(env_dir)
 
                 # Check for __pycache__ directories
                 if '__pycache__' in dirs:

{orionis-0.139.0 → orionis-0.152.0}/orionis/luminate/console/commands/schedule_work.py

@@ -1,7 +1,7 @@
 import importlib
 from orionis.luminate.console.base.command import BaseCommand
 from orionis.luminate.console.exceptions.cli_exception import CLIOrionisRuntimeError
-from orionis.luminate.contracts.console.i_task_manager import ITaskManager
+from orionis.luminate.contracts.console.task_manager import ITaskManager
 from orionis.luminate.facades.commands.scheduler_facade import Schedule
 
 

{orionis-0.139.0 → orionis-0.152.0}/orionis/luminate/console/kernel.py

@@ -1,6 +1,5 @@
 from typing import Any
-from orionis.luminate.contracts.console.i_kernel import ICLIKernel
-from orionis.luminate.console.runner import CLIRunner
+from orionis.luminate.contracts.console.kernel import ICLIKernel
 
 class CLIKernel(ICLIKernel):
     """

{orionis-0.139.0 → orionis-0.152.0}/orionis/luminate/console/output/console.py

@@ -2,7 +2,7 @@ import os
 import sys
 import getpass
 import datetime
-from orionis.luminate.contracts.console.output.i_console import IConsole
+from orionis.luminate.contracts.console.output.console import IConsole
 from orionis.luminate.console.output.styles import ANSIColors
 from orionis.luminate.support.exception_to_dict import ExceptionsToDict
 

{orionis-0.139.0 → orionis-0.152.0}/orionis/luminate/console/output/executor.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from orionis.luminate.contracts.console.output.i_executor import IExecutor
+from orionis.luminate.contracts.console.output.executor import IExecutor
 from orionis.luminate.console.output.styles import ANSIColors
 
 class Executor(IExecutor):

{orionis-0.139.0 → orionis-0.152.0}/orionis/luminate/console/output/progress_bar.py

@@ -1,5 +1,5 @@
 import sys
-from orionis.luminate.contracts.console.output.i_progress_bar import IProgressBar
+from orionis.luminate.contracts.console.output.progress_bar import IProgressBar
 
 class ProgressBar(IProgressBar):
     """

{orionis-0.139.0 → orionis-0.152.0}/orionis/luminate/console/parser.py

@@ -3,7 +3,7 @@ import types
 import argparse
 from contextlib import redirect_stderr
 from io import StringIO
-from orionis.luminate.contracts.console.i_parser import IParser
+from orionis.luminate.contracts.console.parser import IParser
 
 class Parser(IParser):
     """