orionis 0.419.0__py3-none-any.whl → 0.420.0__py3-none-any.whl

orionis/_foundation/exceptions/exception_providers.py

@@ -1,54 +0,0 @@
-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/_foundation/foundation/config/config_bootstrapper.py

@@ -1,209 +0,0 @@
-import importlib
-import pathlib
-from dataclasses import asdict
-from typing import Any, Dict
-from orionis._contracts.foundation.config.config_bootstrapper import IConfigBootstrapper
-from orionis._contracts.config.config import IConfig
-from orionis._foundation.exceptions.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
-
-    def get(self, key: str = None, default: Any = None) -> Any:
-        """
-        Retrieves configuration data.
-
-        If a key is provided, it retrieves the value associated with the key using dot notation.
-        If no key is provided, it returns the entire configuration dictionary.
-
-        Parameters
-        ----------
-        key : str, optional
-            The key to retrieve the value for, using dot notation (default is None).
-        default : Any, optional
-            The default value to return if the key is not found (default is None).
-
-        Returns
-        -------
-        Any
-            The configuration value associated with the key, or the entire configuration dictionary
-            if no key is provided. If the key is not found, returns the default value.
-
-        Raises
-        ------
-        KeyError
-            If the key is not found and no default value is provided.
-        """
-        if key is None:
-            return self._config
-
-        keys = key.split('.')
-        value = self._config
-
-        try:
-            for k in keys:
-                value = value[k]
-        except KeyError:
-            if default is not None:
-                return default
-            raise KeyError(f"Key '{key}' not found in configuration.")
-
-        return value

orionis/_foundation/providers/service_providers_bootstrapper.py

@@ -1,107 +0,0 @@
-import importlib
-import inspect
-import pathlib
-from typing import List, Type
-from orionis._contracts.foundation.providers.service_providers_bootstrapper import IServiceProvidersBootstrapper
-from orionis._contracts.providers.service_provider import IServiceProvider
-from orionis._foundation.exceptions.exception_bootstrapper import BootstrapRuntimeError
-from orionis._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[IServiceProvider]] = None) -> None:
-        """
-        Initializes the ServiceProvidersBootstrapper.
-
-        Args:
-            providers (List[Type[IServiceProvider]]): A list of service provider classes to register manually.
-        """
-        self._service_providers: List[Type[IServiceProvider]] = []
-        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 `IServiceProvider`.
-
-        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[IServiceProvider]) -> None:
-        """
-        Validates and registers a service provider class.
-
-        This method ensures that the provided class is valid (inherits from `IServiceProvider`,
-        has a `register` and `boot` method) and registers it in the appropriate list.
-
-        Args:
-            concrete (Type[IServiceProvider]): 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[IServiceProvider]]:
-        """
-        Retrieve the registered service providers that should run before bootstrapping.
-
-        Returns:
-            List[Type[IServiceProvider]]: A list of service providers to run before bootstrapping.
-        """
-        return self._service_providers

orionis/_services/commands/reactor_commands_service.py

@@ -1,148 +0,0 @@
-import time
-from typing import Any, Dict, Optional
-from orionis._console.base.command import BaseCommand
-from orionis._console.command_filter import CommandFilter
-from orionis._console.exceptions.cli_exception import CLIOrionisException
-from orionis._console.output.console import Console
-from orionis._console.output.executor import Executor
-from orionis._console.parser import Parser
-from orionis._contracts.application import IApplication
-from orionis._contracts.services.log.log_service import ILogguerService
-from orionis._facades.app_facade import app
-
-class ReactorCommandsService:
-    """
-    Service responsible for executing and managing CLI commands in Orionis.
-
-    This service handles:
-    - Parsing command arguments.
-    - Executing commands and logging their output.
-    - Managing execution timing and error handling.
-    """
-
-    def __init__(self, command_filter: CommandFilter, log: ILogguerService, executor: Executor, console: Console, app : IApplication) -> None:
-        """
-        Initializes the ReactorCommandsService instance.
-
-        Assigns provided services to internal attributes for later use in command
-        execution, filtering, and logging.
-        """
-        self.commands = app._commands if hasattr(app, '_commands') else {}
-        self.command_filter = command_filter
-        self.log = log
-        self.console_executor = executor
-        self.console_output = console
-
-    def _parse_arguments(self, arguments, vars: Optional[Dict[str, Any]] = None, *args, **kwargs):
-        """
-        Parses command-line arguments using the Orionis argument parser.
-
-        Utilizes an internal parser to convert raw arguments into structured data.
-        Handles exceptions to ensure errors are properly raised and managed.
-        """
-        try:
-            arg_parser = Parser(vars=vars or {}, args=args, kwargs=kwargs)
-            arg_parser.setArguments(arguments=arguments)
-            arg_parser.recognize()
-            return arg_parser.get()
-        except Exception as e:
-            raise ValueError(f"Error parsing arguments: {e}")
-
-    def _extract_arguments(self, args_dict:Any):
-        """
-        Extracts the arguments from the provided dictionary.
-
-        Parameters
-        ----------
-        args_dict : Any
-            A dictionary containing the arguments to extract.
-        """
-        try:
-            return vars(args_dict)
-        except Exception as e:
-            raise ValueError(f"Error parsing arguments: {e}")
-
-    def _call(self, signature: str, args_dict: Any) -> Any:
-        """
-        Executes the specified command with the provided arguments.
-
-        Parameters
-        ----------
-        signature : str
-            The command signature (name) to execute.
-        args_dict : Any
-            A dictionary containing named arguments for the command.
-        """
-
-        command_instance: BaseCommand = app(signature)
-        command_instance.setArgs(args_dict)
-        return command_instance.handle(**self._extract_arguments(args_dict))
-
-    def execute(self, signature: Optional[str] = None, vars: dict = {}, *args, **kwargs):
-        """
-        Processes and executes a CLI command.
-
-        Determines if the command originates from `sys.argv` or is explicitly called,
-        then executes the appropriate command pipeline, handling success and errors.
-        """
-        try:
-
-            # Determine if command is excluded from running
-            exclude_running = self.command_filter.isExcluded(signature)
-            sys_argv = signature is None
-
-            # Start timing execution
-            start_time = time.perf_counter()
-
-            # Extract signature and arguments from command-line input
-            if sys_argv:
-                if not args or len(args[0]) <= 1:
-                    raise CLIOrionisException("No command signature specified. Please provide a valid command to execute.")
-                args_list = args[0]
-                signature, *args = args_list[1:]
-
-            # Log command execution
-            self.log.info(f"Running command: {signature}")
-
-            # Notify console
-            if not exclude_running:
-                self.console_executor.running(program=signature)
-
-            # Retrieve command from bootstrapper
-            command = self.commands.get(signature)
-
-            # Parse command arguments dynamically based on execution context
-            args_dict = self._parse_arguments(command.get('arguments', []), vars, *args, **kwargs)
-
-            # Exception handling for command execution
-            output = self._call(signature, args_dict)
-
-            # Log successful command execution
-            self.log.success(f"Command executed successfully: {signature}")
-
-            # Finalize execution and report elapsed time
-            if not exclude_running:
-                elapsed_time = round(time.perf_counter() - start_time, 2)
-                self.console_executor.done(program=signature, time=f"{elapsed_time}s")
-
-            # Return command output
-            return output
-
-        except ValueError as e:
-            # Handle parsing errors
-            self.log.error(f"Command failed: {signature or 'Unknown'}, Value Error: {e}")
-            if not exclude_running:
-                self.console_output.error(message=f"Value Error: {e}")
-                elapsed_time = round(time.perf_counter() - start_time, 2)
-                self.console_executor.fail(program=signature or "Unknown", time=f"{elapsed_time}s")
-            self.console_output.exception(e)
-
-        except Exception as e:
-            # Handle unexpected execution errors
-            self.log.error(f"Command failed: {signature or 'Unknown'}, Execution Error: {e}")
-            if not exclude_running:
-                self.console_output.error(message=f"Execution Error: {e}")
-                elapsed_time = round(time.perf_counter() - start_time, 2)
-                self.console_executor.fail(program=signature or "Unknown", time=f"{elapsed_time}s")
-            self.console_output.exception(e)
-