orionis 0.44.0__py3-none-any.whl → 0.47.0__py3-none-any.whl

orionis/{luminate/installer/output.py → installer/installer_output.py}

@@ -1,10 +1,11 @@
 import os
 import sys
 import datetime
+import traceback
+from orionis.contracts.installer.i_installer_output import IInstallerOutput
 from orionis.framework import NAME, VERSION, DOCS
-from orionis.luminate.contracts.installer.output_interface import IOutput
 
-class Output(IOutput):
+class InstallerOutput(IInstallerOutput):
     """
     Class for displaying various types of messages to the console, including:
     - Welcome messages
@@ -60,7 +61,7 @@ class Output(IOutput):
         try:
             # Try loading and printing ASCII art from the file
             dir_path = os.path.dirname(__file__)
-            path = os.path.join(dir_path, 'icon.ascii')
+            path = os.path.join(dir_path, '..', 'static', 'ascii', 'icon.ascii')
             with open(path, 'r', encoding='utf-8') as file:
                 content = file.read()
 
@@ -95,7 +96,7 @@ class Output(IOutput):
         try:
             # Try loading and printing ASCII art from the file
             dir_path = os.path.dirname(__file__)
-            path = os.path.join(dir_path, 'info.ascii')
+            path = os.path.join(dir_path, '..', 'static', 'ascii', 'info.ascii')
             with open(path, 'r', encoding='utf-8') as file:
                 content = file.read()
 
@@ -132,7 +133,7 @@ class Output(IOutput):
         Displays the starting message when the installation begins.
         This includes a welcoming message and the ASCII art.
         """
-        Output.asciiIco()
+        InstallerOutput.asciiIco()
         print(f'\u001b[32m{NAME}\u001b[0m: Thank you for using the framework!')
 
     @staticmethod
@@ -154,7 +155,7 @@ class Output(IOutput):
         message : str, optional
             The message to display. Defaults to an empty string.
         """
-        Output._print("INFO", message, "44")
+        InstallerOutput._print("INFO", message, "44")
 
     @staticmethod
     def fail(message: str = ''):
@@ -166,10 +167,10 @@ class Output(IOutput):
         message : str, optional
             The message to display. Defaults to an empty string.
         """
-        Output._print("FAIL", message, "43")
+        InstallerOutput._print("FAIL", message, "43")
 
     @staticmethod
-    def error(message: str = ''):
+    def error(message: str = '', e = None):
         """
         Displays an error message to the console and terminates the program.
 
@@ -183,6 +184,11 @@ class Output(IOutput):
         SystemExit
             Terminates the program with a non-zero exit code, indicating an error occurred.
         """
-        Output._print("ERROR", message, "41")
-        print("\n")
+
+        InstallerOutput._print("ERROR", message, "41")
+
+        if isinstance(e, BaseException):
+            print("\n--- Traceback (most recent call last) ---")
+            traceback.print_exc()
+
         sys.exit(1)

orionis/{luminate/installer/setup.py → installer/installer_setup.py}

@@ -2,14 +2,12 @@ import re
 import os
 import sys
 import shutil
-import tempfile
 import subprocess
 from unicodedata import normalize
 from orionis.framework import SKELETON, DOCS
-from orionis.luminate.installer.output import Output
-from orionis.luminate.contracts.installer.setup_interface import ISetup
+from orionis.installer.installer_output import InstallerOutput
 
-class Setup(ISetup):
+class InstallerSetup:
     """
     A class to initialize a Orionis project by performing the following setup actions:
     1. Sanitize the folder name.
@@ -30,19 +28,19 @@ class Setup(ISetup):
     Attributes
     ----------
     output : Output
-        An instance of Output used for logging information.
+        An instance of Output used for console information.
     name_app_folder : str
         The sanitized folder name for the application.
     """
 
-    def __init__(self, name: str = 'example-app', output = Output):
+    def __init__(self, name: str = 'example-app', output = InstallerOutput):
         """
         Initialize OrionislInit class.
 
         Parameters
         ----------
-        output : Output
-            An instance of Output to handle logging.
+        output : InstallerOutput
+            An instance of InstallerOutput.
         name_app : str, optional
             Name of the application. If not provided, defaults to "example-app".
         """
@@ -79,7 +77,7 @@ class Setup(ISetup):
             If the sanitized folder name is empty or contains invalid characters.
         """
         if not name:
-            self.output.error("Folder name cannot be empty.")
+            raise ValueError("Folder name cannot be empty.")
 
         # Strip leading and trailing whitespace
         name = name.strip()
@@ -101,10 +99,10 @@ class Setup(ISetup):
 
         # Validate against allowed characters
         if not re.match(r'^[a-z0-9_-]+$', name):
-            self.output.error("The folder name can only contain letters, numbers, underscores, and hyphens.")
+            raise ValueError("The folder name can only contain letters, numbers, underscores, and hyphens.")
 
         if not name:
-            self.output.error("The sanitized folder name is empty after processing.")
+            raise ValueError("The sanitized folder name is empty after processing.")
 
         return name
 
@@ -130,7 +128,7 @@ class Setup(ISetup):
         try:
             # Validate Folder
             if os.path.exists(self.name_app_folder) and os.path.isdir(self.name_app_folder):
-                self.output.error(f"The folder '{self.name_app_folder}' already exists.")
+                raise ValueError(f"The folder '{self.name_app_folder}' already exists.")
 
             # Clone the repository
             self.output.info(f"Cloning the repository into '{self.name_app_folder}'... (Getting Latest Version)")
@@ -152,7 +150,7 @@ class Setup(ISetup):
 
             # Check if requirements.txt exists
             if not os.path.exists("requirements.txt"):
-                self.output.error(f"'requirements.txt' not found. Please visit the Orionis Docs for more details: {DOCS}")
+                raise ValueError(f"'requirements.txt' not found. Please visit the Orionis Docs for more details: {DOCS}")
 
             # Install dependencies from requirements.txt
             self.output.info("Installing dependencies from 'requirements.txt'...")
@@ -171,21 +169,11 @@ class Setup(ISetup):
             # Remove .git origin
             subprocess.run(["git", "remote", "remove", "origin"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
-            # Invalidate Cache File
-            try:
-                temp_dir = tempfile.gettempdir()
-                for filename in os.listdir(temp_dir):
-                    if filename.endswith('started.lab'):
-                        file_path = os.path.join(temp_dir, filename)
-                        os.remove(file_path)
-            except Exception as e:
-                self.output.fail("Unable to delete temporary files created by the framework on the device.")
-
             # Finish Process Message
             self.output.info(f"Project '{self.name_app_folder}' successfully created at '{os.path.abspath(project_path)}'.")
             self.output.endInstallation()
 
         except subprocess.CalledProcessError as e:
-            self.output.error(f"Error while executing command: {e}")
+            raise ValueError(f"Error while executing command: {e}")
         except Exception as e:
-            self.output.error(f"An unexpected error occurred: {e}")
+            raise RuntimeError(f"An unexpected error occurred: {e}")

orionis/luminate/app.py

@@ -1,8 +1,6 @@
 import traceback
 from orionis.luminate.container.container import Container
-from orionis.luminate.cache.app.config import CacheConfig
-from orionis.luminate.bootstrap.config.register import Register
-from orionis.luminate.bootstrap.config.bootstrapper import Bootstrapper
+from orionis.luminate.bootstrap.config_bootstrapper import Bootstrapper as BootstrapperConfig
 from orionis.luminate.patterns.singleton import SingletonMeta
 
 class Application(metaclass=SingletonMeta):
@@ -37,6 +35,16 @@ class Application(metaclass=SingletonMeta):
         self.booted = False
         self.error_info = None
 
+        self._config = {}
+
+    def register(self):
+        """
+        Registers all necessary service bindings with the application container.
+
+        This method is intended to be overridden by the user to define custom service bindings.
+        """
+        pass
+
     def boot(self):
         """
         Boots the application and registers necessary dependencies.
@@ -58,14 +66,10 @@ class Application(metaclass=SingletonMeta):
             return self
 
         try:
-            # Register core services as singletons
-            self.container.singleton(CacheConfig)
-            self.container.singleton(Register)
-            self.container.singleton(Bootstrapper)
-
-            # Resolve the registered dependencies
-            self.container.make(Register)
-            self.container.make(Bootstrapper)
+            # Config Bootstrapper and retrieve application configuration
+            boot_config = self.container.singleton(BootstrapperConfig)
+            app_config = self.container.make(boot_config)
+            self._config = app_config.get()
 
             self.booted = True
             return self

orionis/luminate/bootstrap/command_bootstrapper.py

@@ -0,0 +1,150 @@
+import pathlib
+import importlib
+import inspect
+from typing import Any, Callable, Dict, List
+from orionis.contracts.bootstrap.i_command_bootstrapper import ICommandsBootstrapper
+from orionis.luminate.bootstrap.exception_bootstrapper import BootstrapRuntimeError
+from orionis.luminate.console.base.command import BaseCommand
+
+class CommandsBootstrapper(ICommandsBootstrapper):
+    """
+    A class responsible for loading and registering console commands dynamically.
+
+    This class scans specified directories for Python files, imports them, and registers
+    command classes that inherit from `BaseCommand`. It ensures that commands are loaded
+    only once and provides methods to access and manage them.
+
+    Attributes
+    ----------
+    _commands : Dict[str, Dict[str, Any]]
+        A dictionary to store registered commands, where the key is the command signature
+        and the value is a dictionary containing the command class, arguments, description,
+        and signature.
+
+    Methods
+    -------
+    __init__()
+        Initializes the `CommandsBootstrapper` and triggers the autoload process.
+    _autoload()
+        Scans the command directories and loads command classes.
+    _register(concrete: Callable[..., Any])
+        Validates and registers a command class.
+    """
+
+    def __init__(self) -> None:
+        """
+        Initializes the `CommandsBootstrapper` and triggers the autoload process.
+
+        The `_commands` dictionary is initialized to store command data, and the
+        `_autoload` method is called to load commands from the specified directories.
+        """
+        self._commands: Dict[str, Dict[str, Any]] = {}
+        self._autoload()
+
+    def _autoload(self) -> None:
+        """
+        Scans the command directories and loads command classes.
+
+        This method searches for Python files in the specified directories, imports them,
+        and registers any class that inherits from `BaseCommand`.
+
+        Raises
+        ------
+        BootstrapRuntimeError
+            If there is an error loading a module.
+        """
+        base_path = pathlib.Path.cwd()
+
+        # Define the directories to scan for commands
+        command_dirs = [
+            base_path / "app" / "console" / "commands",  # Developer-defined commands
+            pathlib.Path(__file__).resolve().parent.parent.parent / "console" / "commands"  # Core commands
+        ]
+
+        for cmd_dir in command_dirs:
+            if not cmd_dir.is_dir():
+                continue
+
+            for file_path in cmd_dir.rglob("*.py"):
+                if file_path.name == "__init__.py":
+                    continue
+
+                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:
+                    module = importlib.import_module(module_path.strip())
+
+                    # Find and register command classes
+                    for name, concrete in inspect.getmembers(module, inspect.isclass):
+                        if issubclass(concrete, BaseCommand) and concrete is not BaseCommand:
+                            self._register(concrete)
+                except Exception as e:
+                    raise BootstrapRuntimeError(f"Error loading {module_path}") from e
+
+    def _register(self, concrete: Callable[..., Any]) -> None:
+        """
+        Validates and registers a command class.
+
+        This method ensures that the provided class is valid (inherits from `BaseCommand`,
+        has a `signature`, `description`, and `handle` method) and registers it in the
+        `_commands` dictionary.
+
+        Parameters
+        ----------
+        concrete : Callable[..., Any]
+            The command class to register.
+
+        Raises
+        ------
+        TypeError
+            If the input is not a class or does not inherit from `BaseCommand`.
+        ValueError
+            If the class does not have required attributes or methods.
+        """
+        if not isinstance(concrete, type):
+            raise TypeError(f"Expected a class, but got {type(concrete).__name__}.")
+
+        # Validate 'signature' attribute
+        if not hasattr(concrete, 'signature') or not isinstance(concrete.signature, str):
+            raise ValueError(f"Class {concrete.__name__} must have a 'signature' attribute as a string.")
+
+        signature = concrete.signature.strip()
+
+        # Validate signature format
+        if not signature or ' ' in signature or not all(c.isalnum() or c == ":" for c in signature):
+            raise ValueError(f"Invalid signature format: '{signature}'. Only letters, numbers, and ':' are allowed, with no spaces.")
+
+        # Validate 'description' attribute
+        if not hasattr(concrete, 'description') or not isinstance(concrete.description, str):
+            raise ValueError(f"Class {concrete.__name__} must have a 'description' attribute as a string.")
+
+        description = concrete.description.strip()
+
+        # Validate 'handle' method
+        if not hasattr(concrete, 'handle') or not callable(getattr(concrete, 'handle')):
+            raise ValueError(f"Class {concrete.__name__} must implement a 'handle' method.")
+
+        # Validate 'arguments' method (optional)
+        arguments: List[Any] = []
+        if hasattr(concrete, 'arguments') and callable(getattr(concrete, 'arguments')):
+            arguments = concrete().arguments()
+
+        # Validate inheritance from 'BaseCommand'
+        if not issubclass(concrete, BaseCommand):
+            raise TypeError(f"Class {concrete.__name__} must inherit from 'BaseCommand'.")
+
+        # Ensure the command signature is unique
+        if signature in self._commands:
+            raise ValueError(f"Command '{signature}' is already registered. Please ensure signatures are unique.")
+
+        # Register the command
+        self._commands[signature] = {
+            'concrete': concrete,
+            'arguments': arguments,
+            'description': description,
+            'signature': signature
+        }

orionis/luminate/bootstrap/config_bootstrapper.py

@@ -0,0 +1,168 @@
+import importlib
+import pathlib
+from dataclasses import asdict
+from typing import Any, Dict
+from orionis.contracts.bootstrap.i_config_bootstrapper import IConfigBootstrapper
+from orionis.contracts.config.i_config import IConfig
+from orionis.luminate.bootstrap.exception_bootstrapper import BootstrapRuntimeError
+
+class ConfigBootstrapper(IConfigBootstrapper):
+    """
+    A class responsible for loading and registering application configurations dynamically.
+
+    This class scans a specified directory for Python files, imports them, and registers
+    configuration classes that inherit from `IConfig`. It ensures that configurations
+    are loaded only once and provides methods to access and modify them.
+
+    Attributes
+    ----------
+    _config : Dict[str, Any]
+        A dictionary to store registered configuration sections and their data.
+
+    Methods
+    -------
+    __init__()
+        Initializes the `ConfigBootstrapper` and triggers the autoload process.
+    _autoload()
+        Scans the configuration directory and loads configuration classes.
+    _set(concrete: Any, section: str)
+        Validates and registers a configuration class.
+    _parse(data: Any) -> Dict[str, Any]
+        Converts the 'config' attribute of a class into a dictionary.
+    _register(section: str, data: Dict[str, Any])
+        Registers a configuration section.
+    set(key: str, value: Any)
+        Dynamically sets a configuration value using dot notation.
+    get(key: str, default: Optional[Any] = None) -> Any
+        Retrieves a configuration value using dot notation.
+    """
+
+    def __init__(self) -> None:
+        """
+        Initializes the `ConfigBootstrapper` and triggers the autoload process.
+
+        The `_config` dictionary is initialized to store configuration data, and the
+        `_autoload` method is called to load configurations from the default directory.
+        """
+        self._config: Dict[str, Any] = {}
+        self._autoload()
+
+    def _autoload(self) -> None:
+        """
+        Scans the configuration directory and loads configuration classes.
+
+        This method searches for Python files in the specified directory, imports them,
+        and registers any class named `Config` that inherits from `IConfig`.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the configuration directory does not exist.
+        BootstrapRuntimeError
+            If there is an error loading a module.
+        """
+        directory = "config"
+        base_path = pathlib.Path(directory).resolve()
+
+        if not base_path.exists():
+            raise FileNotFoundError(f"Directory {directory} does not exist.")
+
+        for file_path in base_path.rglob("*.py"):
+            if file_path.name == "__init__.py":
+                continue
+
+            module_path = ".".join(file_path.relative_to(base_path).with_suffix("").parts)
+
+            try:
+                module = importlib.import_module(f"{directory}.{module_path}")
+                if hasattr(module, "Config"):
+                    self._set(
+                        concrete=getattr(module, "Config"),
+                        section=module_path
+                    )
+            except Exception as e:
+                raise BootstrapRuntimeError(f"Error loading module {module_path}") from e
+
+    def _set(self, concrete: Any, section: str) -> None:
+        """
+        Validates and registers a configuration class.
+
+        This method ensures that the provided class is valid (inherits from `IConfig`
+        and has a `config` attribute) and registers it in the `_config` dictionary.
+
+        Parameters
+        ----------
+        concrete : Any
+            The configuration class to register.
+        section : str
+            The section name under which the configuration will be registered.
+
+        Raises
+        ------
+        TypeError
+            If the input is not a class or does not inherit from `IConfig`.
+        ValueError
+            If the class does not have a `config` attribute.
+        """
+        if not isinstance(concrete, type):
+            raise TypeError(f"Expected a class, but got {type(concrete).__name__}.")
+
+        if not hasattr(concrete, "config"):
+            raise ValueError(f"Class {concrete.__name__} must have a 'config' attribute.")
+
+        if not issubclass(concrete, IConfig):
+            raise TypeError(f"Class {concrete.__name__} must inherit from 'IConfig'.")
+
+        self._register(
+            section=section,
+            data=self._parse(concrete.config)
+        )
+
+    def _parse(self, data: Any) -> Dict[str, Any]:
+        """
+        Converts the 'config' attribute of a class into a dictionary.
+
+        If the input is already a dictionary, it is returned as-is. If the input is a
+        dataclass, it is converted to a dictionary using `asdict`.
+
+        Parameters
+        ----------
+        data : Any
+            The data to convert into a dictionary.
+
+        Returns
+        -------
+        Dict[str, Any]
+            The converted dictionary.
+
+        Raises
+        ------
+        TypeError
+            If the data cannot be converted to a dictionary.
+        """
+        if isinstance(data, dict):
+            return data
+        try:
+            return asdict(data)
+        except TypeError as e:
+            raise TypeError(f"Error: The 'config' attribute could not be converted to a dictionary. {str(e)}")
+
+    def _register(self, section: str, data: Dict[str, Any]) -> None:
+        """
+        Registers a configuration section.
+
+        Parameters
+        ----------
+        section : str
+            The name of the configuration section.
+        data : Dict[str, Any]
+            The configuration data to register.
+
+        Raises
+        ------
+        ValueError
+            If the section is already registered.
+        """
+        if section in self._config:
+            raise ValueError(f"Configuration section '{section}' is already registered.")
+        self._config[section] = data

orionis/luminate/bootstrap/environment_bootstrapper.py

@@ -0,0 +1,67 @@
+import os
+from pathlib import Path
+from typing import Dict
+from dotenv import dotenv_values
+from orionis.contracts.bootstrap.i_environment_bootstrapper import IEnvironmentBootstrapper
+from orionis.luminate.bootstrap.exception_bootstrapper import BootstrapRuntimeError
+
+class EnvironmentBootstrapper(IEnvironmentBootstrapper):
+    """
+    A class responsible for loading and managing environment variables from a `.env` file.
+
+    This class implements the `IEnvironment` interface and provides functionality to
+    automatically load environment variables from a `.env` file located in the current
+    working directory. If the file does not exist, it creates it.
+
+    Attributes
+    ----------
+    _environment_vars : Dict[str, str]
+        A dictionary to store the loaded environment variables.
+    path : Path
+        The path to the `.env` file.
+
+    Methods
+    -------
+    __init__()
+        Initializes the `EnvironmentBootstrapper` and triggers the autoload process.
+    _autoload()
+        Loads environment variables from the `.env` file or creates the file if it does not exist.
+    """
+
+    def __init__(self) -> None:
+        """
+        Initializes the `EnvironmentBootstrapper` and triggers the autoload process.
+
+        The `_environment_vars` dictionary is initialized to store environment variables,
+        and the `_autoload` method is called to load variables from the `.env` file.
+        """
+        self._environment_vars: Dict[str, str] = {}
+        self._autoload()
+
+    def _autoload(self) -> None:
+        """
+        Loads environment variables from the `.env` file or creates the file if it does not exist.
+
+        This method checks if the `.env` file exists in the current working directory.
+        If the file does not exist, it creates an empty `.env` file. If the file exists,
+        it loads the environment variables into the `_environment_vars` dictionary.
+
+        Raises
+        ------
+        PermissionError
+            If the `.env` file cannot be created or read due to insufficient permissions.
+        """
+        # Set the path to the `.env` file
+        path: Path = Path(os.getcwd()) / ".env"
+
+        # Create the `.env` file if it does not exist
+        if not path.exists():
+            try:
+                path.touch()  # Create an empty `.env` file if it does not exist
+            except PermissionError as e:
+                raise PermissionError(f"Cannot create `.env` file at {path}: {str(e)}")
+
+        try:
+            self._environment_vars = dotenv_values(path)  # Load environment variables
+        except Exception as e:
+            raise BootstrapRuntimeError(f"Error loading environment variables from {path}: {str(e)}")

orionis/luminate/config/helpers.py

@@ -0,0 +1,20 @@
+from orionis.luminate.support.environment import Environment
+
+def env(key: str, default=None) -> str:
+    """
+    Retrieves the value of an environment variable from the .env file
+    or from system environment variables if not found.
+
+    Parameters
+    ----------
+    key : str
+        The key of the environment variable.
+    default : optional
+        Default value if the key does not exist. Defaults to None.
+
+    Returns
+    -------
+    str
+        The value of the environment variable or the default value.
+    """
+    return Environment().get(key, default)

orionis/luminate/console/base/command.py

@@ -1,6 +1,6 @@
+from orionis.contracts.console.base.i_command import IBaseCommand
 from orionis.luminate.console.output.console import Console
 from orionis.luminate.console.output.progress_bar import ProgressBar
-from orionis.luminate.contracts.console.base.base_command_interface import IBaseCommand
 
 class BaseCommand(IBaseCommand):
     """
@@ -404,10 +404,8 @@ class BaseCommand(IBaseCommand):
             Contain the arguments to be set for the command.
         """
         try:
-            # Convert arguments to a dictionary using vars(), if possible
             self.args = vars(args)
         except TypeError:
-            # Fallback to an empty dictionary if args is not compatible with vars()
             self.args = {}
 
 

orionis/luminate/console/command_filter.py

@@ -1,6 +1,6 @@
-from orionis.luminate.contracts.console.command_filter_interface import ICommandFilter
+from orionis.contracts.console.i_command_filter import ICommandFilter
 
-# List of commands that should be excluded from output formatting
+# List of commands to exclude from output formatting
 EXCLUDED_COMMANDS = [
     'schedule:work',   # Command to handle scheduled work
     'help',            # Command to show help information