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

orionis/_contracts/support/reflection.py

@@ -1,352 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, List, Optional
-
-class IReflection(ABC):
-
-    @abstractmethod
-    def safeImport(self):
-        """
-        Safely imports the specified module and assigns the class object if a classname is provided.
-
-        This method raises a ValueError if the module cannot be imported or if the class does not exist
-        within the module.
-
-        Raises
-        ------
-        ValueError
-            If the module cannot be imported or the class does not exist in the module.
-        """
-        pass
-
-    @abstractmethod
-    def getFile(self) -> str:
-        """
-        Retrieves the file path where the class is defined.
-
-        Returns
-        -------
-        str
-            The file path if the class is found, otherwise raises an error.
-
-        Raises
-        ------
-        ValueError
-            If the class has not been loaded yet.
-        """
-        pass
-
-    @abstractmethod
-    def hasClass(self) -> bool:
-        """
-        Checks whether the class object is available.
-
-        Returns
-        -------
-        bool
-            True if the class is loaded, False otherwise.
-        """
-        pass
-
-    @abstractmethod
-    def hasMethod(self, method_name: str) -> bool:
-        """
-        Checks whether the specified method exists in the class.
-
-        Parameters
-        ----------
-        method_name : str
-            The name of the method to check.
-
-        Returns
-        -------
-        bool
-            True if the method exists, False otherwise.
-        """
-        pass
-
-    @abstractmethod
-    def hasProperty(self, prop: str) -> bool:
-        """
-        Checks whether the specified property exists in the class.
-
-        Parameters
-        ----------
-        prop : str
-            The name of the property to check.
-
-        Returns
-        -------
-        bool
-            True if the property exists, False otherwise.
-        """
-        pass
-
-    @abstractmethod
-    def hasConstant(self, constant: str) -> bool:
-        """
-        Checks whether the specified constant exists in the class.
-
-        Parameters
-        ----------
-        constant : str
-            The name of the constant to check.
-
-        Returns
-        -------
-        bool
-            True if the constant exists, False otherwise.
-        """
-        pass
-
-    @abstractmethod
-    def getAttributes(self) -> List[str]:
-        """
-        Retrieves a list of all attributes (including methods and properties) of the class.
-
-        Returns
-        -------
-        list
-            A list of attribute names in the class.
-        """
-        pass
-
-    @abstractmethod
-    def getConstructor(self):
-        """
-        Retrieves the constructor (__init__) of the class.
-
-        Returns
-        -------
-        function or None
-            The constructor method if available, otherwise None.
-        """
-        pass
-
-    @abstractmethod
-    def getDocComment(self) -> Optional[str]:
-        """
-        Retrieves the docstring of the class.
-
-        Returns
-        -------
-        str or None
-            The docstring of the class if available, otherwise None.
-        """
-        pass
-
-    @abstractmethod
-    def getFileName(self, remove_extension: bool = False) -> str:
-        """
-        Retrieves the file name where the class is defined, the same as `get_file()`.
-
-        Parameters
-        ----------
-        remove_extension : bool, optional
-            If True, the file extension will be removed from the filename. Default is False.
-
-        Returns
-        -------
-        str
-            The file name of the class definition.
-        """
-        pass
-
-    @abstractmethod
-    def getMethod(self, method_name: str):
-        """
-        Retrieves the specified method from the class.
-
-        Parameters
-        ----------
-        method_name : str
-            The name of the method to retrieve.
-
-        Returns
-        -------
-        function or None
-            The method if it exists, otherwise None.
-        """
-        pass
-
-    @abstractmethod
-    def getMethods(self) -> List[str]:
-        """
-        Retrieves a list of all methods in the class.
-
-        Returns
-        -------
-        list
-            A list of method names in the class.
-        """
-        pass
-
-    @abstractmethod
-    def getName(self) -> str:
-        """
-        Retrieves the name of the class.
-
-        Returns
-        -------
-        str or None
-            The name of the class if available, otherwise None.
-        """
-        pass
-
-    @abstractmethod
-    def getParentClass(self) -> Optional[tuple]:
-        """
-        Retrieves the parent classes (base classes) of the class.
-
-        Returns
-        -------
-        tuple or None
-            A tuple of base classes if available, otherwise None.
-        """
-        pass
-
-    @abstractmethod
-    def getProperties(self) -> List[str]:
-        """
-        Retrieves a list of all properties of the class.
-
-        Returns
-        -------
-        list
-            A list of property names in the class.
-        """
-        pass
-
-    @abstractmethod
-    def getProperty(self, prop: str):
-        """
-        Retrieves the specified property from the class.
-
-        Parameters
-        ----------
-        prop : str
-            The name of the property to retrieve.
-
-        Returns
-        -------
-        property or None
-            The property if it exists, otherwise None.
-        """
-        pass
-
-    @abstractmethod
-    def isAbstract(self) -> bool:
-        """
-        Checks whether the class is abstract.
-
-        Returns
-        -------
-        bool
-            True if the class is abstract, False otherwise.
-        """
-        pass
-
-    @abstractmethod
-    def isEnum(self) -> bool:
-        """
-        Checks whether the class is an enumeration.
-
-        Returns
-        -------
-        bool
-            True if the class is a subclass of Enum, False otherwise.
-        """
-        pass
-
-    @abstractmethod
-    def isSubclassOf(self, parent: type) -> bool:
-        """
-        Checks whether the class is a subclass of the specified parent class.
-
-        Parameters
-        ----------
-        parent : type
-            The parent class to check against.
-
-        Returns
-        -------
-        bool
-            True if the class is a subclass of the parent, False otherwise.
-        """
-        pass
-
-    @abstractmethod
-    def isInstanceOf(self, instance: Any) -> bool:
-        """
-        Checks whether the class is an instance of the specified class.
-
-        Parameters
-        ----------
-        parent : type
-            The class to check against.
-
-        Returns
-        -------
-        bool
-            True if the class is a subclass of the parent, False otherwise.
-        """
-        pass
-
-    @abstractmethod
-    def isIterable(self) -> bool:
-        """
-        Checks whether the class is iterable.
-
-        Returns
-        -------
-        bool
-            True if the class is iterable, False otherwise.
-        """
-        pass
-
-    @abstractmethod
-    def isInstantiable(self) -> bool:
-        """
-        Checks whether the class can be instantiated.
-
-        Returns
-        -------
-        bool
-            True if the class is callable and not abstract, False otherwise.
-        """
-        pass
-
-    @abstractmethod
-    def newInstance(self, *args, **kwargs):
-        """
-        Creates a new instance of the class if it is instantiable.
-
-        Parameters
-        ----------
-        args : tuple
-            Arguments to pass to the class constructor.
-        kwargs : dict
-            Keyword arguments to pass to the class constructor.
-
-        Returns
-        -------
-        object
-            A new instance of the class.
-
-        Raises
-        ------
-        TypeError
-            If the class is not instantiable.
-        """
-        pass
-
-    @abstractmethod
-    def __str__(self) -> str:
-        """
-        Returns a string representation of the Reflection instance.
-
-        Returns
-        -------
-        str
-            A string describing the class and module.
-        """
-        pass

orionis/_foundation/console/command_bootstrapper.py

@@ -1,175 +0,0 @@
-import pathlib
-import importlib
-import inspect
-from typing import Any, Callable, Dict, List
-from orionis._contracts.foundation.console.command_bootstrapper import ICommandsBootstrapper
-from orionis._foundation.exceptions.exception_bootstrapper import BootstrapRuntimeError
-from orionis._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
-        }
-
-    def get(self, signature: str = None) -> Dict[str, Any]:
-        """
-        Retrieves a registered command by its signature.
-
-        Parameters
-        ----------
-        signature : str
-            The command signature to retrieve.
-
-        Returns
-        -------
-        Dict[str, Any]
-            A dictionary containing the command class, arguments, description, and signature.
-
-        Raises
-        ------
-        KeyError
-            If the command signature is not found.
-        """
-        if signature is None:
-            return self._commands
-        if signature not in self._commands:
-            raise KeyError(f"Command '{signature}' not found.")
-        return self._commands[signature]

orionis/_foundation/environment/environment_bootstrapper.py

@@ -1,76 +0,0 @@
-from typing import Dict
-from orionis._contracts.foundation.environment.environment_bootstrapper import IEnvironmentBootstrapper
-# from orionis.support.environment.env import Env
-# from orionis.services.environment.environment_service import EnvironmentService
-
-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.
-        """
-        environment_service =Env() # type: ignore
-        self._environment_vars = environment_service.all()
-
-    def get(self, key: str = None) -> str:
-        """
-        Retrieves the value of an environment variable by its key.
-
-        Parameters
-        ----------
-        key : str
-            The key of the environment variable to retrieve.
-
-        Returns
-        -------
-        str
-            The value of the environment variable.
-
-        Raises
-        ------
-        KeyError
-            If the environment variable does not exist.
-        """
-
-        if not key:
-            return self._environment_vars
-
-        if key not in self._environment_vars:
-            raise KeyError(f"Environment variable {key} not found")
-
-        return self._environment_vars[key]

orionis/_foundation/exceptions/exception_bootstrapper.py

@@ -1,54 +0,0 @@
-class BootstrapRuntimeError(RuntimeError):
-    """
-    Exception raised for errors related to dumping Orionis data.
-
-    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"[BootstrapRuntimeError]: {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})"