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

orionis/luminate/contracts/files/paths_interface.py

@@ -1,29 +0,0 @@
-from abc import ABC, abstractmethod
-
-class ISkeletonPath(ABC):
-    """
-    Resolves the absolute path for a given relative directory based on the script's execution directory.
-    Ensures that the requested path is a valid directory.
-
-    Attributes
-    ----------
-    route : str
-        The resolved absolute path to the directory.
-
-    Methods
-    -------
-    __str__():
-        Returns the absolute path as a string.
-    """
-
-    @abstractmethod
-    def resolve(self) -> str:
-        """
-        Returns the absolute path as a string.
-
-        Returns
-        -------
-        str
-            The absolute directory path.
-        """
-        pass

orionis/luminate/contracts/installer/output_interface.py

@@ -1,125 +0,0 @@
-from abc import ABC, abstractmethod
-
-class IOutput(ABC):
-    """
-    Interface defining the contract for the Output class.
-
-    This interface ensures that any implementing class provides methods for
-    displaying messages, ASCII-based framework information, and handling errors.
-
-    Methods
-    -------
-    asciiIco() -> None
-        Displays the framework's ASCII icon along with relevant information.
-    asciiInfo() -> None
-        Displays additional ASCII-based information about the framework.
-    startInstallation() -> None
-        Shows a welcome message when installation starts.
-    endInstallation() -> None
-        Shows a completion message when installation finishes.
-    info(message: str) -> None
-        Displays an informational message.
-    fail(message: str) -> None
-        Displays a failure message.
-    error(message: str) -> None
-        Displays an error message and terminates the program.
-    """
-
-    @abstractmethod
-    def asciiIco(self) -> None:
-        """
-        Displays the framework's ASCII icon along with relevant information.
-
-        Raises
-        ------
-        Exception
-            If an error occurs while displaying the ASCII art.
-        """
-        pass
-
-    @abstractmethod
-    def asciiInfo(self) -> None:
-        """
-        Displays additional ASCII-based information about the framework.
-
-        Raises
-        ------
-        Exception
-            If an error occurs while displaying the ASCII information.
-        """
-        pass
-
-    @abstractmethod
-    def startInstallation(self) -> None:
-        """
-        Shows a welcome message when installation starts.
-
-        Raises
-        ------
-        Exception
-            If an error occurs during message display.
-        """
-        pass
-
-    @abstractmethod
-    def endInstallation(self) -> None:
-        """
-        Shows a completion message when installation finishes.
-
-        Raises
-        ------
-        Exception
-            If an error occurs during message display.
-        """
-        pass
-
-    @abstractmethod
-    def info(self, message: str) -> None:
-        """
-        Displays an informational message.
-
-        Parameters
-        ----------
-        message : str
-            The message to display.
-
-        Raises
-        ------
-        Exception
-            If an error occurs while displaying the message.
-        """
-        pass
-
-    @abstractmethod
-    def fail(self, message: str) -> None:
-        """
-        Displays a failure message.
-
-        Parameters
-        ----------
-        message : str
-            The message to display.
-
-        Raises
-        ------
-        Exception
-            If an error occurs while displaying the message.
-        """
-        pass
-
-    @abstractmethod
-    def error(self, message: str) -> None:
-        """
-        Displays an error message and terminates the program.
-
-        Parameters
-        ----------
-        message : str
-            The message to display.
-
-        Raises
-        ------
-        SystemExit
-            Terminates the program with an exit code.
-        """
-        pass

orionis/luminate/contracts/installer/setup_interface.py

@@ -1,29 +0,0 @@
-from abc import ABC, abstractmethod
-
-class ISetup(ABC):
-    """
-    Abstract base class for setup operations.
-
-    This interface defines a contract for setup classes, requiring the implementation
-    of the `handle` method to execute setup logic.
-
-    Methods
-    -------
-    handle()
-        Abstract method that must be implemented by subclasses to define setup behavior.
-    """
-
-    @abstractmethod
-    def handle(self):
-        """
-        Execute the setup process.
-
-        This method must be implemented by any subclass to perform the necessary
-        setup actions. The specific implementation details depend on the subclass.
-
-        Raises
-        ------
-        NotImplementedError
-            If the method is not implemented in a subclass.
-        """
-        pass

orionis/luminate/contracts/installer/upgrade_interface.py

@@ -1,24 +0,0 @@
-from abc import ABC, abstractmethod
-
-class IUpgrade(ABC):
-    """
-    Interface for the Upgrade process in Orionis.
-
-    This interface enforces the implementation of methods required to handle
-    upgrading Orionis to the latest version.
-    """
-
-    @abstractmethod
-    def execute() -> None:
-        """
-        Executes the upgrade process for Orionis.
-
-        This method should be implemented to define the upgrade logic, ensuring
-        the application is updated to the latest available version.
-
-        Raises
-        ------
-        ValueError
-            If the upgrade process fails or encounters any error during execution.
-        """
-        pass

orionis/luminate/contracts/log/logger_interface.py

@@ -1,33 +0,0 @@
-from abc import ABC, abstractmethod
-
-class ILogger(ABC):
-    """
-    Abstract base class for a logger.
-
-    This defines the contract that any concrete logger class must implement.
-    """
-
-    @abstractmethod
-    def info(self, message: str) -> None:
-        """Logs an informational message."""
-        pass
-
-    @abstractmethod
-    def error(self, message: str) -> None:
-        """Logs an error message."""
-        pass
-
-    @abstractmethod
-    def success(self, message: str) -> None:
-        """Logs a success message (treated as info)."""
-        pass
-
-    @abstractmethod
-    def warning(self, message: str) -> None:
-        """Logs a warning message."""
-        pass
-
-    @abstractmethod
-    def debug(self, message: str) -> None:
-        """Logs a debug message."""
-        pass

orionis/luminate/contracts/pipelines/cli_pipeline_interface.py

@@ -1,84 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Dict, Optional
-
-class ICLIPipeline(ABC):
-    """
-    Interface for CLIPipeline, defining the structure for handling CLI command retrieval,
-    argument parsing, and execution.
-
-    Methods
-    -------
-    getCommand(signature: str) -> "ICLIPipeline"
-        Retrieves a command from the cache based on its signature.
-
-    parseArguments(vars: Optional[Dict[str, Any]] = None, *args, **kwargs) -> "ICLIPipeline"
-        Parses command-line arguments using the framework's argument parser.
-
-    execute() -> Any
-        Executes the retrieved command using parsed arguments.
-    """
-
-    @abstractmethod
-    def getCommand(self, signature: str) -> "ICLIPipeline":
-        """
-        Retrieves a command from the cache based on its signature.
-
-        Parameters
-        ----------
-        signature : str
-            The unique identifier of the command.
-
-        Returns
-        -------
-        ICLIPipeline
-            The current instance of the pipeline for method chaining.
-
-        Raises
-        ------
-        ValueError
-            If the command signature is not found in the cache.
-        """
-        pass
-
-    @abstractmethod
-    def parseArguments(self, vars: Optional[Dict[str, Any]] = None, *args, **kwargs) -> "ICLIPipeline":
-        """
-        Parses command-line arguments using the framework's argument parser.
-
-        Parameters
-        ----------
-        vars : dict, optional
-            A dictionary of predefined variables to be included in parsing.
-        *args
-            Positional arguments for the parser.
-        **kwargs
-            Keyword arguments for the parser.
-
-        Returns
-        -------
-        ICLIPipeline
-            The current instance of the pipeline for method chaining.
-
-        Raises
-        ------
-        ValueError
-            If an error occurs during argument parsing.
-        """
-        pass
-
-    @abstractmethod
-    def execute(self) -> Any:
-        """
-        Executes the retrieved command using parsed arguments.
-
-        Returns
-        -------
-        Any
-            The output of the command execution.
-
-        Raises
-        ------
-        ValueError
-            If the command instance is invalid.
-        """
-        pass

orionis/luminate/contracts/publisher/pypi_publisher_interface.py

@@ -1,36 +0,0 @@
-from abc import ABC, abstractmethod
-
-class IPypiPublisher(ABC):
-    """
-    Interface for managing the publishing process of a package to PyPI
-    and handling repository operations.
-    """
-
-    @abstractmethod
-    def gitPush(self):
-        """
-        Commits and pushes changes to the Git repository if modifications are detected.
-        """
-        pass
-
-    @abstractmethod
-    def publish(self):
-        """
-        Uploads the package to PyPI using Twine.
-
-        The PyPI token should be retrieved from the environment variable or
-        passed during initialization.
-        """
-        pass
-
-    @abstractmethod
-    def clearRepository(self):
-        """
-        Deletes temporary directories created during the publishing process.
-
-        The following directories should be removed:
-        - build
-        - dist
-        - orionis.egg-info
-        """
-        pass

orionis/luminate/contracts/test/unit_test_interface.py

@@ -1,51 +0,0 @@
-from abc import ABC, abstractmethod
-
-class IUnitTest(ABC):
-    """
-    A testing framework for discovering and running unit tests in a structured way.
-
-    Attributes
-    ----------
-    loader : unittest.TestLoader
-        A test loader instance used to discover tests.
-    suite : unittest.TestSuite
-        A test suite that holds all discovered tests.
-
-    Methods
-    -------
-    add_folder_tests(folder_path: str, pattern: str = 'test_*.py') -> None
-        Adds test cases from a specified folder to the test suite.
-    run_tests() -> None
-        Executes all tests in the test suite and raises an exception if any fail.
-    """
-
-    @abstractmethod
-    def addFolderTests(self, folder_path: str, pattern: str = "test_*.py") -> None:
-        """
-        Adds all test cases from a specified folder to the test suite.
-
-        Parameters
-        ----------
-        folder_path : str
-            The relative path to the folder containing test files.
-        pattern : str, optional
-            A pattern to match test files (default is 'test_*.py').
-
-        Raises
-        ------
-        ValueError
-            If the folder path is invalid or no tests are found.
-        """
-        pass
-
-    @abstractmethod
-    def run(self) -> None:
-        """
-        Runs all tests added to the test suite.
-
-        Raises
-        ------
-        OrionisTestFailureException
-            If one or more tests fail.
-        """
-        pass

orionis/luminate/facades/config.py

@@ -1,10 +0,0 @@
-from orionis.luminate.container.container import Container
-from orionis.luminate.cache.app.config import CacheConfig
-from orionis.luminate.app import OrionisContext
-
-class Config:
-
-    @staticmethod
-    def get():
-        with OrionisContext() as ctx:
-            return ctx.container.make(CacheConfig).config

orionis/luminate/facades/log.py

@@ -1,56 +0,0 @@
-import logging
-from typing import Optional
-from orionis.luminate.log.logger import Logguer
-from orionis.luminate.contracts.log.logger_interface import ILogger
-from orionis.luminate.contracts.facades.log_interface import ILogFacade
-
-class Log(ILogFacade):
-    """
-    Facade for accessing the Logguer instance.
-
-    Provides a simplified interface for logging messages.
-    """
-
-    @staticmethod
-    def info(message: str) -> None:
-        """Logs an informational message."""
-        Logguer().info(message)
-
-    @staticmethod
-    def error(message: str) -> None:
-        """Logs an error message."""
-        Logguer().error(message)
-
-    @staticmethod
-    def success(message: str) -> None:
-        """Logs a success message (treated as info)."""
-        Logguer().success(message)
-
-    @staticmethod
-    def warning(message: str) -> None:
-        """Logs a warning message."""
-        Logguer().warning(message)
-
-    @staticmethod
-    def debug(message: str) -> None:
-        """Logs a debug message."""
-        Logguer().debug(message)
-
-    @staticmethod
-    def configure(path: Optional[str] = None, level: int = logging.INFO) -> ILogger:
-        """
-        Configures and returns the Logguer instance.
-
-        Parameters
-        ----------
-        path : str, optional
-            The file path where logs will be stored. If None, a default path is used.
-        level : int, optional
-            The logging level (default is logging.INFO).
-
-        Returns
-        -------
-        ILogger
-            Configured logger instance.
-        """
-        return Logguer(path, level)

orionis/luminate/files/paths.py

@@ -1,56 +0,0 @@
-import os
-from pathlib import Path as SysPath
-from orionis.luminate.contracts.files.paths_interface import ISkeletonPath
-
-class SkeletonPath(ISkeletonPath):
-    """
-    Resolves the absolute path for a given relative directory based on the script's execution directory.
-    Ensures that the requested path is a valid directory.
-
-    Attributes
-    ----------
-    route : str
-        The resolved absolute path to the directory.
-
-    Methods
-    -------
-    __str__():
-        Returns the absolute path as a string.
-    """
-
-    def __init__(self, route: str):
-        """
-        Initializes the Path class, resolving the absolute path for a given relative directory.
-
-        The path is resolved relative to the script's execution directory.
-
-        Parameters
-        ----------
-        route : str
-            The relative directory path to be resolved.
-
-        Raises
-        ------
-        ValueError
-            If the path does not exist or is not a directory.
-        """
-        # Get the absolute path based on the script's execution directory
-        base_path = SysPath(os.getcwd())  # Get the directory where the script is executed
-        real_path = (base_path / route).resolve()  # Combine base path with the relative route
-
-        # Validate that the path exists and is a directory or file
-        if real_path.is_dir() or real_path.is_file():
-            self.route = str(real_path)
-        else:
-            raise ValueError(f"The requested directory does not exist or is not a directory: {real_path}")
-
-    def resolve(self) -> str:
-        """
-        Returns the absolute path as a string.
-
-        Returns
-        -------
-        str
-            The absolute directory path.
-        """
-        return self.route

orionis/luminate/installer/upgrade.py

@@ -1,42 +0,0 @@
-import sys
-import subprocess
-from orionis.luminate.installer.output import Output
-from orionis.luminate.contracts.installer.upgrade_interface import IUpgrade
-
-class Upgrade(IUpgrade):
-    """
-    A class responsible for handling the upgrade process of Orionis.
-
-    Methods
-    -------
-    execute() : None
-        Executes the upgrade process to install the latest version of Orionis.
-    """
-
-    @staticmethod
-    def execute():
-        """
-        Handle the --upgrade command to update Orionis to the latest version.
-
-        This method attempts to upgrade Orionis using the pip package manager.
-        It executes a command that installs the latest version of Orionis, ensuring
-        the application is up-to-date.
-
-        Raises
-        ------
-        ValueError
-            If the upgrade process fails or encounters any error during execution.
-
-        Notes
-        -----
-        The upgrade process uses `pip` via the command:
-        `python -m pip install --upgrade orionis`.
-        """
-        output = Output()
-        try:
-            output.info("Starting the upgrade process...")
-            subprocess.check_call([sys.executable, "-m", "pip", "install", "--upgrade", "orionis"])
-        except subprocess.CalledProcessError as e:
-            output.error(message=f"Upgrade failed: {e}")
-        except Exception as e:
-            output.error(message=e)

orionis/luminate/log/logger.py

@@ -1,116 +0,0 @@
-import os
-import logging
-import threading
-from pathlib import Path
-from typing import Optional
-from orionis.luminate.contracts.log.logger_interface import ILogger
-
-class Logguer(ILogger):
-    """
-    A thread-safe singleton logger class for logging messages.
-
-    Attributes
-    ----------
-    logger : logging.Logger
-        The logger instance used for logging messages.
-
-    Methods
-    -------
-    info(message: str)
-        Logs an informational message.
-    error(message: str)
-        Logs an error message.
-    success(message: str)
-        Logs a success message (treated as info).
-    warning(message: str)
-        Logs a warning message.
-    debug(message: str)
-        Logs a debug message.
-    """
-
-    # Singleton instance
-    _instance = None
-
-    # Thread-safe instance creation
-    _lock = threading.Lock()
-
-    def __new__(cls, path: Optional[str] = None, level: int = logging.INFO, filename: Optional[str] = 'orionis.log'):
-        """
-        Creates or returns the singleton instance of the Logguer class.
-
-        Parameters
-        ----------
-        path : str, optional
-            The file path where logs will be stored. If None, a default path is used.
-        level : int, optional
-            The logging level (default is logging.INFO).
-
-        Returns
-        -------
-        Logguer
-            The singleton instance of the logger.
-        """
-        with cls._lock:
-            if cls._instance is None:
-                cls._instance = super(Logguer, cls).__new__(cls)
-                cls._instance._initialize_logger(path, level, filename)
-        return cls._instance
-
-    def _initialize_logger(self, path: Optional[str], level: int, filename: Optional[str] = 'orionis.log'):
-        """
-        Initializes the logger with the specified log file path and logging level.
-
-        Parameters
-        ----------
-        path : str, optional
-            The file path where logs will be stored.
-        level : int
-            The logging level.
-        """
-        try:
-
-            if path is None:
-                base_path = Path(os.getcwd())
-                log_dir = base_path / "storage" / "logs"
-
-                # Check if the log directory exists
-                if log_dir.exists():
-                    path = log_dir / filename
-                else:
-                    path = base_path / filename
-
-            logging.basicConfig(
-                level=level,
-                format="%(asctime)s - %(message)s",
-                datefmt="%Y-%m-%d %H:%M:%S",
-                encoding="utf-8",
-                handlers=[
-                    logging.FileHandler(path)
-                    # logging.StreamHandler()
-                ]
-            )
-
-            self.logger = logging.getLogger(__name__)
-
-        except Exception as e:
-            raise RuntimeError(f"Failed to initialize logger: {e}")
-
-    def info(self, message: str) -> None:
-        """Logs an informational message."""
-        self.logger.info(f"[INFO] - {message}")
-
-    def error(self, message: str) -> None:
-        """Logs an error message."""
-        self.logger.error(f"[ERROR] - {message}")
-
-    def success(self, message: str) -> None:
-        """Logs a success message (treated as info)."""
-        self.logger.info(f"[SUCCESS] - {message}")
-
-    def warning(self, message: str) -> None:
-        """Logs a warning message."""
-        self.logger.warning(f"[WARNING] - {message}")
-
-    def debug(self, message: str) -> None:
-        """Logs a debug message."""
-        self.logger.debug(f"[DEBUG] - {message}")