orionis 0.43.0__py3-none-any.whl → 0.46.0__py3-none-any.whl

orionis/luminate/bootstrap/commands/bootstrapper.py

@@ -1,101 +0,0 @@
-import pathlib
-import importlib
-import inspect
-from orionis.luminate.bootstrap.cli_exception import BootstrapRuntimeError
-from orionis.luminate.bootstrap.commands.register import Register
-from orionis.luminate.console.base.command import BaseCommand
-from orionis.luminate.contracts.bootstrap.commands.bootstrapper_interface import IBootstrapper
-
-class Bootstrapper(IBootstrapper):
-    """
-    Manages the automatic loading and registration of command classes
-    from Python files located in predefined directories.
-
-    The `Bootstrapper` class scans specific directories for Python files, dynamically
-    imports them, and registers classes that inherit from `BaseCommand`.
-
-    Attributes
-    ----------
-    register : Register
-        An instance of the `Register` class used to register command classes.
-
-    Methods
-    -------
-    __init__(register: Register) -> None
-        Initializes the `Bootstrapper` with a `Register` instance and triggers autoloading.
-    _autoload() -> None
-        Scans predefined directories for Python files, dynamically imports modules,
-        and registers classes that extend `BaseCommand`.
-    """
-
-    def __init__(self, register: Register) -> None:
-        """
-        Initializes the `Bootstrapper` with a `Register` instance and triggers autoloading.
-
-        Parameters
-        ----------
-        register : Register
-            An instance of the `Register` class used to register command classes.
-        """
-        self.register = register
-        self._autoload()
-
-    def _autoload(self) -> None:
-        """
-        Autoloads command modules from specified directories and registers command classes.
-
-        This method searches for Python files in the predefined command directories,
-        dynamically imports the modules, and registers classes that inherit from `BaseCommand`.
-
-        The command directories searched are:
-        - `app/console/commands` relative to the current working directory.
-        - `console/commands` relative to the parent directory of the current file.
-
-        It skips `__init__.py` files and ignores directories that do not exist.
-
-        Raises
-        ------
-        BootstrapRuntimeError
-            If an error occurs while loading a module.
-        """
-
-        # Define the base project path
-        base_path = pathlib.Path.cwd()
-
-        # Define the command directories to search
-        command_dirs = [
-            base_path / "app" / "console" / "commands",
-            pathlib.Path(__file__).resolve().parent.parent.parent / "console" / "commands"
-        ]
-
-        # Iterate over each command directory
-        for cmd_dir in command_dirs:
-
-            # Skip if the directory does not exist
-            if not cmd_dir.is_dir():
-                continue
-
-            # Iterate over Python files in the directory (recursive search)
-            for file_path in cmd_dir.rglob("*.py"):
-
-                # Skip `__init__.py` files
-                if file_path.name == "__init__.py":
-                    continue
-
-                # Convert file path to a Python module import path
-                module_path = ".".join(file_path.relative_to(base_path).with_suffix("").parts)
-                if 'site-packages.' in module_path:
-                    module_path = module_path.split('site-packages.')[1]
-
-                try:
-                    # Dynamically import the module
-                    module = importlib.import_module(module_path.strip())
-
-                    # Find classes that inherit from `BaseCommand`
-                    for name, obj in inspect.getmembers(module, inspect.isclass):
-                        if issubclass(obj, BaseCommand) and obj is not BaseCommand:
-                            # Register the class
-                            self.register.command(obj)
-
-                except Exception as e:
-                    raise BootstrapRuntimeError(f"Error loading {module_path}") from e

orionis/luminate/bootstrap/commands/register.py

@@ -1,92 +0,0 @@
-from typing import Any, Callable
-from orionis.luminate.console.base.command import BaseCommand
-from orionis.luminate.cache.console.commands import CacheCommands
-from orionis.luminate.contracts.bootstrap.commands.register_interface import IRegister
-
-class Register(IRegister):
-    """
-    A class to register and manage command classes.
-
-    Attributes
-    ----------
-    commands : dict
-        A dictionary storing registered command classes.
-    """
-
-    def __init__(self, cache : CacheCommands):
-        """
-        Initializes the Register instance and prepares the cache commands system.
-        """
-        self.cache_commands = cache
-
-    def command(self, command_class: Callable[..., Any]) -> None:
-        """
-        Registers a command class after validating its structure.
-
-        Parameters
-        ----------
-        command_class : type
-            The command class to register. It must:
-            - Have a 'signature' attribute (str, containing only letters, numbers, and ':', with no spaces).
-            - Have a 'description' attribute (str).
-            - Implement a 'handle' method.
-            - Inherit from 'BaseCommand'.
-
-        Returns
-        -------
-        type
-            The registered command class.
-
-        Raises
-        ------
-        ValueError
-            If 'signature' is missing, invalid, contains spaces, or is not a string.
-            If 'description' is missing or not a string.
-            If 'handle' method is missing.
-        TypeError
-            If the class does not inherit from 'BaseCommand'.
-        """
-
-        # Ensure 'command_class' is actually a class
-        if not isinstance(command_class, type):
-            raise TypeError(f"Expected a class, but got {type(command_class).__name__}.")
-
-        # Validate 'signature' attribute
-        if not hasattr(command_class, 'signature') or not isinstance(command_class.signature, str):
-            raise ValueError(f"Class {command_class.__name__} must have a 'signature' attribute as a string.")
-
-        # Sanitaze signature
-        signature = command_class.signature.strip()
-
-        # Ensure signature contains only letters, numbers, and ':', with no spaces
-        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(command_class, 'description') or not isinstance(command_class.description, str):
-            raise ValueError(f"Class {command_class.__name__} must have a 'description' attribute as a string.")
-
-        # Sanitaze signature
-        description = command_class.description.strip()
-
-        # Validate 'handle' method
-        if not hasattr(command_class, 'handle') or not callable(getattr(command_class, 'handle')):
-            raise ValueError(f"Class {command_class.__name__} must implement a 'handle' method.")
-
-        # Validate 'arguments' method
-        if hasattr(command_class, 'arguments') and callable(getattr(command_class, 'arguments')):
-            arguments = command_class().arguments()
-        else:
-            arguments = []
-
-        # Validate inheritance from 'BaseCommand'
-        if not issubclass(command_class, BaseCommand):
-            raise TypeError(f"Class {command_class.__name__} must inherit from 'BaseCommand'.")
-
-        # Register the command
-        self.cache_commands.register(
-            concrete=command_class,
-            arguments=arguments,
-            description=description,
-            signature=signature
-        )

orionis/luminate/bootstrap/config/bootstrapper.py

@@ -1,79 +0,0 @@
-import importlib
-import pathlib
-from orionis.luminate.bootstrap.cli_exception import BootstrapRuntimeError
-from orionis.luminate.bootstrap.config.register import Register
-from orionis.luminate.contracts.bootstrap.config.bootstrapper_interface import IBootstrapper
-
-class Bootstrapper(IBootstrapper):
-    """
-    Manages the automatic loading and registration of configuration classes
-    from Python files located in a specified directory.
-
-    The `Bootstrapper` class scans directories for Python files and dynamically
-    imports them to find configuration classes. Once found, the classes are
-    registered using the provided `Register` instance.
-
-    Attributes
-    ----------
-    register : Register
-        An instance of the `Register` class used to register configuration classes.
-
-    Methods
-    -------
-    __init__(register: Register) -> None
-        Initializes the `Bootstrapper` with a `Register` instance.
-
-    _autoload(directory: str) -> None
-        Scans a directory for Python files, imports them, finds configuration classes,
-        and registers them using the `Register` instance.
-    """
-
-    def __init__(self, register: Register) -> None:
-        """
-        Initializes the `Bootstrapper` with a `Register` instance.
-
-        Parameters
-        ----------
-        register : Register
-            An instance of the `Register` class used to register configuration classes.
-        """
-        self.register = register
-        self._autoload()
-
-    def _autoload(self, directory: str = 'config') -> None:
-        """
-        Automatically registers configuration classes found in a given directory.
-
-        This method walks through the specified directory, imports all Python files,
-        and scans for class definitions. If a class is found, it is registered using
-        the `Register` instance. Only classes defined in Python files (excluding
-        `__init__.py`) are considered.
-
-        Parameters
-        ----------
-        directory : str
-            The directory to scan for Python configuration files.
-
-        Raises
-        ------
-        FileNotFoundError
-            If the provided directory does not exist.
-        """
-        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.register.config(getattr(module, "Config"))
-            except Exception as e:
-                raise BootstrapRuntimeError(f"Error loading module {module_path}") from e
-

orionis/luminate/bootstrap/config/parser.py

@@ -1,53 +0,0 @@
-from typing import Any
-from dataclasses import asdict
-from orionis.luminate.contracts.bootstrap.config.parser_interface import IParser
-
-class Parser(IParser):
-    """
-    A class responsible for parsing configuration objects into dictionaries.
-
-    This class implements the `IParser` interface and provides a method
-    to convert configuration instances into a dictionary format.
-
-    Methods
-    -------
-    toDict(instance: Any) -> dict
-        Converts the `config` attribute of an instance into a dictionary.
-    """
-
-    @staticmethod
-    def toDict(instance: Any) -> dict:
-        """
-        Converts the `config` attribute of a given instance into a dictionary.
-
-        This method uses `asdict()` to transform a dataclass-based configuration
-        into a dictionary, ensuring that all attributes are properly serialized.
-
-        Parameters
-        ----------
-        instance : Any
-            The object containing a `config` attribute to be converted.
-
-        Returns
-        -------
-        dict
-            A dictionary representation of the `config` attribute.
-
-        Raises
-        ------
-        AttributeError
-            If the provided instance does not have a `config` attribute.
-        TypeError
-            If the `config` attribute cannot be converted to a dictionary.
-        """
-        try:
-            # Check if instance is a dictionary
-            if isinstance(instance.config, dict):
-                return instance
-            # Check if instance is a dataclass
-            elif hasattr(instance.config, '__dataclass_fields__'):
-                return asdict(instance.config)
-        except AttributeError as e:
-            raise AttributeError("The provided instance does not have a 'config' attribute.") from e
-        except TypeError as e:
-            raise TypeError(f"Error: The 'config' attribute could not be converted to a dictionary. {str(e)}")

orionis/luminate/bootstrap/config/register.py

@@ -1,76 +0,0 @@
-from orionis.luminate.bootstrap.config.parser import Parser
-from orionis.luminate.cache.app.config import CacheConfig
-from orionis.luminate.contracts.bootstrap.config.register_interface import IRegister
-from orionis.luminate.contracts.config.config_interface import IConfig
-from orionis.luminate.tools.reflection import Reflection
-
-class Register(IRegister):
-    """
-    Handles the registration of configuration classes within the application.
-
-    This class ensures that only valid configuration classes are registered
-    while enforcing structure and type safety.
-
-    Methods
-    -------
-    config(config_class: type) -> type
-        Registers a configuration class and ensures it meets the necessary criteria.
-    """
-
-    def __init__(self, cache : CacheConfig) -> None:
-        """
-        Initializes the Register instance with a cache configuration.
-
-        Parameters
-        ----------
-        container : Container
-            The container instance to be used for configuration registration.
-        """
-        self.cache = cache
-
-    def config(self, config_class: type) -> None:
-        """
-        Registers a configuration class and ensures it meets the required structure.
-
-        This method performs multiple validation steps, including checking if the input
-        is a class, verifying the existence of a `config` attribute, and confirming
-        inheritance from `IConfig`.
-
-        Parameters
-        ----------
-        config_class : type
-            The class to be registered as a configuration.
-
-        Returns
-        -------
-        type
-            The same class passed as an argument, if registration is successful.
-
-        Raises
-        ------
-        TypeError
-            If `config_class` is not a class or does not inherit from `IConfig`.
-        ValueError
-            If `config_class` does not have a `config` attribute or is already registered.
-        """
-
-        # Validate input type
-        if not isinstance(config_class, type):
-            raise TypeError(f"Expected a class, but got {type(config_class).__name__}.")
-
-        # Validate config attribute
-        if not hasattr(config_class, 'config'):
-            raise ValueError(f"Class {config_class.__name__} must have a 'config' attribute.")
-
-        # Extract module name
-        section = Reflection(config_class).getFileName(remove_extension=True)
-
-        # Validate inheritance
-        if not issubclass(config_class, IConfig):
-            raise TypeError(f"Class {config_class.__name__} must inherit from 'IConfig'.")
-
-        # Register configuration
-        self.cache.register(
-            section=section,
-            data=Parser.toDict(config_class)
-        )

orionis/luminate/cache/app/config.py

@@ -1,91 +0,0 @@
-from typing import Dict, Any
-from orionis.luminate.contracts.cache.app.config_interface import ICacheConfig
-
-class CacheConfig(ICacheConfig):
-    """
-    CacheConfig is a class that manages the registration, unregistration, and retrieval of configuration sections.
-
-    Methods
-    -------
-    __init__()
-        Initializes a new instance of the class with an empty configuration dictionary.
-    register(section: str, data: Dict[str, Any])
-        Registers a configuration section with its associated data.
-    unregister(section: str)
-        Unregisters a previously registered configuration section.
-    get(section: str)
-        Retrieves the configuration data for a specific section.
-    """
-
-    def __init__(self) -> None:
-        """
-        Initializes a new instance of the class with an empty configuration dictionary.
-
-        Attributes:
-            config (dict): A dictionary to store configuration settings.
-        """
-        self.config = {}
-
-    def register(self, section: str, data: Dict[str, Any]) -> None:
-        """
-        Registers a configuration section.
-
-        Parameters
-        ----------
-        section : str
-            The name of the configuration section to register.
-        data : dict
-            The configuration data associated with the section.
-
-        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
-
-    def unregister(self, section: str) -> None:
-        """
-        Unregisters a previously registered configuration section.
-
-        Parameters
-        ----------
-        section : str
-            The name of the configuration section to remove.
-
-        Raises
-        ------
-        KeyError
-            If the section is not found in the registered configurations.
-        """
-        if section not in self.config:
-            raise KeyError(f"Configuration section '{section}' is not registered.")
-
-        del self.config[section]
-
-    def get(self, section: str) -> Dict[str, Any]:
-        """
-        Retrieves the configuration for a specific section.
-
-        Parameters
-        ----------
-        section : str
-            The name of the configuration section to retrieve.
-
-        Returns
-        -------
-        dict
-            The configuration data for the specified section.
-
-        Raises
-        ------
-        KeyError
-            If the requested section is not found.
-        """
-        if section not in self.config:
-            raise KeyError(f"Configuration section '{section}' is not registered.")
-
-        return self.config[section]

orionis/luminate/cache/console/commands.py

@@ -1,97 +0,0 @@
-from typing import Any, Callable
-from orionis.luminate.contracts.cache.console.commands_interface import ICacheCommands
-
-class CacheCommands(ICacheCommands):
-    """
-    CacheCommands is a class that manages the registration, unregistration, and retrieval of command instances.
-
-    Methods
-    -------
-    __init__()
-        Initializes the command cache with an empty dictionary.
-    register(signature: str, description: str, arguments: list, concrete: Callable[..., Any])
-        Register a new command with its signature, description, and class instance.
-    unregister(signature: str)
-        Unregister an existing command by its signature.
-    get(signature: str)
-        Retrieve the information of a registered command by its signature.
-    """
-
-    def __init__(self):
-
-        """
-        Initializes the command cache.
-
-        This constructor sets up an empty dictionary to store commands.
-        """
-        self.commands = {}
-
-    def register(self, signature: str, description: str, arguments: list, concrete: Callable[..., Any]):
-        """
-        Register a new command with its signature, description, and class instance.
-
-        Parameters
-        ----------
-        signature : str
-            The unique identifier (signature) for the command.
-        description : str
-            A brief description of what the command does.
-        concrete : class
-            The class or callable instance that defines the command behavior.
-
-        Raises
-        ------
-        ValueError
-            If a command with the given signature already exists.
-        """
-        if signature in self.commands:
-            raise ValueError(f"Command '{signature}' is already registered. Please ensure signatures are unique.")
-
-        self.commands[signature] = {
-            'concrete':concrete,
-            'arguments':arguments,
-            'description':description,
-            'signature':signature
-        }
-
-    def unregister(self, signature: str):
-        """
-        Unregister an existing command by its signature.
-
-        Parameters
-        ----------
-        signature : str
-            The unique identifier (signature) for the command to unregister.
-
-        Raises
-        ------
-        KeyError
-            If the command with the given signature does not exist.
-        """
-        if signature not in self.commands:
-            raise KeyError(f"Command '{signature}' not found.")
-        del self.commands[signature]
-
-    def get(self, signature: str):
-        """
-        Retrieve the information of a registered command by its signature.
-
-        Parameters
-        ----------
-        signature : str
-            The unique identifier (signature) for the command.
-
-        Returns
-        -------
-        dict
-            A dictionary containing the class, signature, and description of the command.
-
-        Raises
-        ------
-        KeyError
-            If the command with the given signature does not exist.
-        """
-        command = self.commands.get(signature)
-        if not command:
-            raise KeyError(f"Command with signature '{signature}' not found.")
-        return command

orionis/luminate/console/cache.py

@@ -1,87 +0,0 @@
-import os
-from orionis.luminate.tools.reflection import Reflection
-
-class CLICache:
-    """
-    Class responsible for managing the loading and execution of commands within the framework.
-
-    This class ensures that commands are loaded only once and are accessible for execution.
-
-    Attributes
-    ----------
-    paths : list
-        List of directories where commands are located.
-
-    Methods
-    -------
-    __init__ :
-        Initializes the CLICache instance, loading commands if not already initialized.
-    _load_commands :
-        Loads command modules from predefined directories and imports them dynamically.
-    """
-
-
-    def __init__(self) -> None:
-        """
-        Initializes the CLICache instance by loading commands if not already initialized.
-
-        This method will load command modules only once, ensuring that the commands are available for execution
-        across the application. It should not be called directly multiple times.
-
-        Attributes
-        ----------
-        paths : list
-            List of directories containing command files to be loaded.
-        """
-        self.paths = []
-        self._load_commands()
-
-    def _load_commands(self):
-        """
-        Dynamically loads command modules from predefined directories.
-
-        This method traverses the specified directories, locates Python files, and imports them as modules. 
-        It ensures that only the main directories are iterated over, avoiding subdirectories.
-
-        Directories searched:
-        ---------------------
-        - app/console/commands (relative to the base path)
-        - Current directory of the module (this file's directory)
-        """
-        paths = []
-
-        # Define the base path of the application
-        base_path = os.getcwd()
-
-        # Define command directories to be searched
-        command_dirs = [
-            os.path.join(base_path, 'app', 'console', 'commands'),
-            os.path.join(os.path.dirname(__file__), 'commands')
-        ]
-
-        # Add valid directories to paths list
-        for command_dir in command_dirs:
-            if os.path.isdir(command_dir):
-                paths.append(command_dir)
-
-        # Iterate over each valid directory
-        for path in paths:
-            for current_directory, _, files in os.walk(path):
-                # Ensure to only iterate through the top-level directories
-                if current_directory == path:
-                    pre_module = current_directory.replace(base_path, '').replace(os.sep, '.').lstrip('.')
-                    for file in files:
-                        if file.endswith('.py'):
-
-                            # Remove the '.py' extension
-                            module_name = file[:-3]
-
-                            # Construct the full module path
-                            module_path = f"{pre_module}.{module_name}"
-
-                            # Remove the 'site-packages' prefix from the module path
-                            if 'site-packages.' in module_path:
-                                module_path = module_path.split('site-packages.')[1]
-
-                            # Use Reflection to load the module dynamically
-                            Reflection(module=module_path)