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

orionis/luminate/console/command.py

@@ -1,40 +0,0 @@
-from typing import Any
-from orionis.luminate.console.runner import CLIRunner
-from orionis.luminate.contracts.console.command_interface import ICommand
-
-class Command(ICommand):
-    """
-    Command class for managing and executing registered CLI commands.
-
-    This class provides a static method to invoke commands registered in the
-    `CacheCommands` singleton, passing the required signature and any additional
-    parameters.
-
-    Methods
-    -------
-    call(signature: str, vars: dict[str, Any] = {}, *args: Any, **kwargs: Any) -> Any
-        Executes the specified command with the provided arguments.
-    """
-
-    @staticmethod
-    def call(signature: str, vars: dict[str, Any] = {}, *args: Any, **kwargs: Any) -> Any:
-        """
-        Calls a registered command using the `CLIRunner`.
-
-        Parameters
-        ----------
-        signature : str
-            The command signature (name) to execute.
-        vars : dict[str, Any], optional
-            A dictionary containing named arguments for the command (default is `{}`).
-        *args : Any
-            Additional positional arguments.
-        **kwargs : Any
-            Additional keyword arguments.
-
-        Returns
-        -------
-        Any
-            The output of the executed command.
-        """
-        return CLIRunner.handle(signature, vars, *args, **kwargs)

orionis/luminate/contracts/bootstrap/commands/bootstrapper_interface.py

@@ -1,44 +0,0 @@
-from abc import ABC, abstractmethod
-
-class IBootstrapper(ABC):
-    """
-    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`.
-    """
-
-    @abstractmethod
-    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.
-        """
-        pass

orionis/luminate/contracts/bootstrap/commands/register_interface.py

@@ -1,33 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Callable
-
-class IRegister(ABC):
-    """
-    Interface for a command register.
-    """
-
-    @abstractmethod
-    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.
-
-        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'.
-        """
-        pass

orionis/luminate/contracts/bootstrap/config/bootstrapper_interface.py

@@ -1,40 +0,0 @@
-from abc import ABC, abstractmethod
-
-class IBootstrapper(ABC):
-    """
-    Interface for managing the automatic loading and registration of configuration
-    classes from Python files located in a specified directory.
-
-    The `IBootstrapper` interface defines methods for scanning directories for
-    Python files and dynamically importing them to find configuration classes.
-    Implementations of this interface should provide the logic for registering
-    the found classes using a `Register` instance.
-
-    Methods
-    -------
-    autoload(directory: str) -> None
-        Scans a directory for Python files, imports them, finds configuration classes,
-        and registers them using the `Register` instance.
-    """
-
-    @abstractmethod
-    def _autoload(self, directory: str) -> 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.
-        """
-        pass

orionis/luminate/contracts/bootstrap/config/parser_interface.py

@@ -1,46 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any
-
-class IParser(ABC):
-    """
-    A class responsible for parsing an instance's configuration and outputting it as a dictionary.
-
-    This class uses Python's `dataclasses.asdict()` method to convert an instance's `config` attribute to a dictionary.
-
-    Methods
-    -------
-    parse(instance: Any) -> dict
-        Takes an instance with a `config` attribute and returns its dictionary representation.
-
-    Notes
-    -----
-    - This method expects the instance to have a `config` attribute that is a dataclass or any object that supports `asdict()`.
-    - The `asdict()` function will recursively convert dataclass fields into a dictionary format.
-    - If `instance.config` is not a dataclass, this could raise an exception depending on the type.
-    """
-
-    @abstractmethod
-    def toDict(self, instance: Any) -> dict:
-        """
-        Converts the `config` attribute of the provided instance to a dictionary and returns it.
-
-        Parameters
-        ----------
-        instance : Any
-            The instance to parse. It is expected that the instance has a `config` attribute
-            that is a dataclass or any object that supports `asdict()`.
-
-        Returns
-        -------
-        dict
-            The dictionary representation of the `config` attribute.
-
-        Raises
-        ------
-        AttributeError
-            If the `instance` does not have a `config` attribute.
-        TypeError
-            If the `instance.config` is not a valid dataclass or object that supports `asdict()`.
-        """
-        pass
-

orionis/luminate/contracts/bootstrap/config/register_interface.py

@@ -1,47 +0,0 @@
-from abc import ABC, abstractmethod
-
-class IRegister(ABC):
-    """
-    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.
-
-    Attributes
-    ----------
-    cache_config : CacheConfig
-        An instance of `CacheConfig` used to store registered configurations.
-
-    Methods
-    -------
-    config(config_class: type) -> None
-        Registers a configuration class and ensures it meets the necessary criteria.
-    """
-
-    @abstractmethod
-    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.
-        """
-        pass

orionis/luminate/contracts/cache/app/config_interface.py

@@ -1,76 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Dict, Any
-
-class ICacheConfig(ABC):
-    """
-    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.
-    """
-
-    @abstractmethod
-    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.
-        """
-        pass
-
-    @abstractmethod
-    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.
-        """
-        pass
-
-    @abstractmethod
-    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.
-        """
-        pass

orionis/luminate/contracts/cache/console/commands_interface.py

@@ -1,78 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Callable
-
-class ICacheCommands(ABC):
-    """
-    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.
-    """
-
-    @abstractmethod
-    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.
-        """
-        pass
-
-    @abstractmethod
-    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.
-        """
-        pass
-
-    @abstractmethod
-    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.
-        """
-        pass

orionis/luminate/contracts/config/environment_interface.py

@@ -1,64 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Optional, Dict
-
-class IEnvironment(ABC):
-    """
-    Interface for managing environment variables from a .env file.
-    """
-
-    @abstractmethod
-    def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
-        """
-        Retrieve the value of an environment variable.
-
-        Parameters
-        ----------
-        key : str
-            The key of the environment variable.
-        default : Optional[str], optional
-            Default value if the key does not exist, by default None.
-
-        Returns
-        -------
-        Optional[str]
-            The value of the environment variable or the default value.
-        """
-        pass
-
-    @abstractmethod
-    def set(self, key: str, value: str) -> None:
-        """
-        Set the value of an environment variable in the .env file.
-
-        Parameters
-        ----------
-        key : str
-            The key of the environment variable.
-        value : str
-            The value to set.
-        """
-        pass
-
-    @abstractmethod
-    def unset(self, key: str) -> None:
-        """
-        Remove an environment variable from the .env file.
-
-        Parameters
-        ----------
-        key : str
-            The key of the environment variable to remove.
-        """
-        pass
-
-    @abstractmethod
-    def all(self) -> Dict[str, str]:
-        """
-        Retrieve all environment variable values from the .env file.
-
-        Returns
-        -------
-        Dict[str, str]
-            A dictionary of all environment variables and their values.
-        """
-        pass

orionis/luminate/contracts/console/command_interface.py

@@ -1,36 +0,0 @@
-from typing import Any
-from abc import ABC, abstractmethod
-
-class ICommand(ABC):
-    """
-    Interface for managing and executing registered commands.
-
-    This interface ensures that any class implementing it will provide a method
-    for executing commands from a cache by their signature.
-    """
-
-    @abstractmethod
-    def call(signature: str, vars: dict[str, Any] = {}, *args: Any, **kwargs: Any) -> Any:
-        """
-        Calls a registered command from the CacheCommands singleton.
-
-        This method retrieves the command class associated with the given
-        signature, instantiates it, and executes the `handle` method of
-        the command instance.
-
-        Parameters
-        ----------
-        signature : str
-            The unique identifier (signature) of the command to be executed.
-        **kwargs : dict
-            Additional keyword arguments to be passed to the command instance
-            when it is created.
-
-        Raises
-        ------
-        KeyError
-            If no command with the given signature is found in the cache.
-        RuntimeError
-            If an error occurs while executing the command.
-        """
-        pass

orionis/luminate/contracts/console/runner_interface.py

@@ -1,50 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any
-
-class ICLIRunner(ABC):
-    """
-    Interface for CLIRunner, defining the structure for handling CLI command execution.
-
-    This interface ensures that any implementing class properly processes and executes CLI commands.
-
-    Methods
-    -------
-    handle(signature: str = None, vars: dict = {}, *args, **kwargs) -> Any
-        Processes and executes a CLI command based on provided arguments.
-    """
-
-    @abstractmethod
-    def handle(self, signature: str = None, vars: dict = {}, *args, **kwargs) -> Any:
-        """
-        Processes and executes a CLI command.
-
-        This method:
-        - Determines whether the command is invoked from `sys.argv` or as a function.
-        - Extracts the command signature and arguments.
-        - Executes the command pipeline.
-        - Logs execution status and handles errors.
-
-        Parameters
-        ----------
-        signature : str, optional
-            The command signature (default is None, meaning it is extracted from `sys.argv`).
-        vars : dict, optional
-            Named arguments for the command (default is an empty dictionary).
-        *args
-            Additional arguments for the command.
-        **kwargs
-            Additional keyword arguments for the command.
-
-        Returns
-        -------
-        Any
-            The output of the executed command.
-
-        Raises
-        ------
-        ValueError
-            If no command signature is provided.
-        Exception
-            If an unexpected error occurs during execution.
-        """
-        pass

orionis/luminate/contracts/facades/env_interface.py

@@ -1,64 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Optional, Dict
-
-class IEnv(ABC):
-    """
-    Interface for managing environment variables from a .env file.
-    """
-
-    @abstractmethod
-    def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
-        """
-        Retrieve the value of an environment variable.
-
-        Parameters
-        ----------
-        key : str
-            The key of the environment variable.
-        default : Optional[str], optional
-            Default value if the key does not exist, by default None.
-
-        Returns
-        -------
-        Optional[str]
-            The value of the environment variable or the default value.
-        """
-        pass
-
-    @abstractmethod
-    def set(self, key: str, value: str) -> None:
-        """
-        Set the value of an environment variable in the .env file.
-
-        Parameters
-        ----------
-        key : str
-            The key of the environment variable.
-        value : str
-            The value to set.
-        """
-        pass
-
-    @abstractmethod
-    def unset(self, key: str) -> None:
-        """
-        Remove an environment variable from the .env file.
-
-        Parameters
-        ----------
-        key : str
-            The key of the environment variable to remove.
-        """
-        pass
-
-    @abstractmethod
-    def all(self) -> Dict[str, str]:
-        """
-        Retrieve all environment variable values from the .env file.
-
-        Returns
-        -------
-        Dict[str, str]
-            A dictionary of all environment variables and their values.
-        """
-        pass

orionis/luminate/contracts/facades/log_interface.py

@@ -1,48 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Optional
-import logging
-from orionis.luminate.contracts.log.logger_interface import ILogger
-
-class ILogFacade(ABC):
-    """
-    Facade interface for simplified access to logging operations.
-
-    Methods
-    -------
-    info(message: str) -> None
-        Logs an informational message.
-    error(message: str) -> None
-        Logs an error message.
-    success(message: str) -> None
-        Logs a success message (treated as info).
-    warning(message: str) -> None
-        Logs a warning message.
-    debug(message: str) -> None
-        Logs a debug message.
-    configure(path: Optional[str], level: int) -> ILogger
-        Configures and returns the logger instance.
-    """
-
-    @abstractmethod
-    def info(self, message: str) -> None:
-        pass
-
-    @abstractmethod
-    def error(self, message: str) -> None:
-        pass
-
-    @abstractmethod
-    def success(self, message: str) -> None:
-        pass
-
-    @abstractmethod
-    def warning(self, message: str) -> None:
-        pass
-
-    @abstractmethod
-    def debug(self, message: str) -> None:
-        pass
-
-    @abstractmethod
-    def configure(self, path: Optional[str] = None, level: int = logging.INFO) -> ILogger:
-        pass