orionis 0.1.0__py3-none-any.whl

orionis/luminate/config/environment.py

@@ -0,0 +1,110 @@
+import os
+import threading
+from pathlib import Path
+from dotenv import set_key, unset_key, dotenv_values
+from orionis.luminate.contracts.config.environment_interface import IEnvironment
+
+class Environment(IEnvironment):
+    """
+    Singleton class to manage environment variables from a .env file.
+    Ensures a single instance handles environment variable access,
+    modification, and deletion.
+    """
+
+    # Singleton instance
+    _instance = None
+
+    # Thread lock to control instance creation
+    _lock = threading.Lock()
+
+    def __new__(cls, path: str = None):
+        """
+        Creates or returns the singleton instance.
+        Ensures thread-safe initialization using a lock.
+
+        Parameters
+        ----------
+        path : str, optional
+            Path to the .env file. Defaults to None.
+
+        Returns
+        -------
+        _Environment
+            The singleton instance of _Environment.
+        """
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+                cls._instance._initialize(path)
+        return cls._instance
+
+    def _initialize(self, path: str = None):
+        """
+        Initializes the instance by setting the path to the .env file.
+        If no path is provided, defaults to a `.env` file in the current directory.
+
+        Parameters
+        ----------
+        path : str, optional
+            Path to the .env file. Defaults to None.
+        """
+        self.path = Path(path) if path else Path(os.getcwd()) / ".env"
+
+        # Ensure the .env file exists
+        if not self.path.exists():
+            self.path.touch()
+
+    def get(self, key: str, default=None) -> str:
+        """
+        Retrieves the value of an environment variable from the .env file
+        or from system environment variables if not found.
+
+        Parameters
+        ----------
+        key : str
+            The key of the environment variable.
+        default : optional
+            Default value if the key does not exist. Defaults to None.
+
+        Returns
+        -------
+        str
+            The value of the environment variable or the default value.
+        """
+        value = dotenv_values(self.path).get(key)
+        return value if value is not None else os.getenv(key, default)
+
+    def set(self, key: str, value: str) -> None:
+        """
+        Sets 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.
+        """
+        set_key(str(self.path), key, value)
+
+    def unset(self, key: str) -> None:
+        """
+        Removes an environment variable from the .env file.
+
+        Parameters
+        ----------
+        key : str
+            The key of the environment variable to remove.
+        """
+        unset_key(str(self.path), key)
+
+    def all(self) -> dict:
+        """
+        Retrieves all environment variable values from the .env file.
+
+        Returns
+        -------
+        dict
+            A dictionary of all environment variables and their values.
+        """
+        return dotenv_values(self.path)

orionis/luminate/config/sections.py

@@ -0,0 +1,37 @@
+# ------------------------------------------------------------------------------
+# Authorized Configuration Sections for Bootstrapping
+# ------------------------------------------------------------------------------
+# This tuple defines the only allowed configuration sections that can be used
+# during the application's bootstrapping process.
+#
+# Each section represents a core component of the framework, ensuring that only
+# predefined and necessary configurations are loaded at startup. This prevents
+# unauthorized modifications or unintended settings from being injected.
+#
+# Sections:
+# - app        : General application settings.
+# - auth       : Authentication and authorization settings.
+# - cache      : Configuration for caching mechanisms.
+# - cors       : Cross-Origin Resource Sharing (CORS) policies.
+# - database   : Database connection and ORM settings.
+# - filesystems: File storage configurations.
+# - logging    : Logging and monitoring settings.
+# - mail       : Email sending and SMTP configurations.
+# - queue      : Queue system settings for background tasks.
+# - session    : Session management configurations.
+#
+# Any configuration outside these sections will be ignored or rejected.
+# ------------------------------------------------------------------------------
+
+SECTIONS = (
+    'app',
+    'auth',
+    'cache',
+    'cors',
+    'database',
+    'filesystems',
+    'logging',
+    'mail',
+    'queue',
+    'session'
+)

orionis/luminate/console/base/command.py

@@ -0,0 +1,427 @@
+from orionis.luminate.console.output.console import Console
+from orionis.luminate.console.output.progress_bar import ProgressBar
+from orionis.luminate.contracts.console.base_command_interface import IBaseCommand
+
+class BaseCommand(IBaseCommand):
+    """
+    A base class for handling common console output functionalities. This class provides methods to print messages of
+    various types (success, info, warning, etc.) in different styles (e.g., text, bold, colored).
+
+    This class acts as a foundation for command classes, offering utility methods to interact with the console.
+    """
+
+    # Command arguments
+    args = {}
+
+    def success(self, message: str = '', timestamp: bool = True):
+        """
+        Prints a success message with a green background.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        timestamp : bool, optional
+            Whether to include a timestamp (default is True).
+        """
+        Console.success(message, timestamp)
+
+    def textSuccess(self, message: str = ''):
+        """
+        Prints a success message in green.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.textSuccess(message)
+
+    def textSuccessBold(self, message: str = ''):
+        """
+        Prints a bold success message in green.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.textSuccessBold(message)
+
+    def info(self, message: str = '', timestamp: bool = True):
+        """
+        Prints an informational message with a blue background.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        timestamp : bool, optional
+            Whether to include a timestamp (default is True).
+        """
+        Console.info(message, timestamp)
+
+    def textInfo(self, message: str = ''):
+        """
+        Prints an informational message in blue.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.textInfo(message)
+
+    def textInfoBold(self, message: str = ''):
+        """
+        Prints a bold informational message in blue.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.textInfoBold(message)
+
+    def warning(self, message: str = '', timestamp: bool = True):
+        """
+        Prints a warning message with a yellow background.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        timestamp : bool, optional
+            Whether to include a timestamp (default is True).
+        """
+        Console.warning(message, timestamp)
+
+    def textWarning(self, message: str = ''):
+        """
+        Prints a warning message in yellow.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.textWarning(message)
+
+    def textWarningBold(self, message: str = ''):
+        """
+        Prints a bold warning message in yellow.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.textWarningBold(message)
+
+    def fail(self, message: str = '', timestamp: bool = True):
+        """
+        Prints a failure message with a red background.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        timestamp : bool, optional
+            Whether to include a timestamp (default is True).
+        """
+        Console.fail(message, timestamp)
+
+    def error(self, message: str = '', timestamp: bool = True):
+        """
+        Prints an error message with a red background.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        timestamp : bool, optional
+            Whether to include a timestamp (default is True).
+        """
+        Console.error(message, timestamp)
+
+    def textError(self, message: str = ''):
+        """
+        Prints an error message in red.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.textError(message)
+
+    def textErrorBold(self, message: str = ''):
+        """
+        Prints a bold error message in red.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.textErrorBold(message)
+
+    def textMuted(self, message: str = ''):
+        """
+        Prints a muted (gray) message.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.textMuted(message)
+
+    def textMutedBold(self, message: str = ''):
+        """
+        Prints a bold muted (gray) message.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.textMutedBold(message)
+
+    def textUnderline(self, message: str = ''):
+        """
+        Prints an underlined message.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.textUnderline(message)
+
+    def clear(self):
+        """
+        Clears the console screen.
+        """
+        Console.clear()
+
+    def clearLine(self):
+        """
+        Clears the current console line.
+        """
+        Console.clearLine()
+
+    def line(self, message: str = ''):
+        """
+        Prints a line of text.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.line(message)
+
+    def newLine(self, count: int = 1):
+        """
+        Prints multiple new lines.
+
+        Parameters
+        ----------
+        count : int, optional
+            The number of new lines to print (default is 1).
+        """
+        Console.newLine(count)
+
+    def write(self, message: str = ''):
+        """
+        Prints a message without moving to the next line.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.write(message)
+
+    def writeLine(self, message: str = ''):
+        """
+        Prints a message and moves to the next line.
+
+        Parameters
+        ----------
+        message : str, optional
+            The message to display (default is an empty string).
+        """
+        Console.writeLine(message)
+
+    def ask(self, question: str) -> str:
+        """
+        Prompts the user for input and returns the response.
+
+        Parameters
+        ----------
+        question : str
+            The question to ask the user.
+
+        Returns
+        -------
+        str
+            The user's input.
+        """
+        return Console.ask(question)
+
+    def confirm(self, question: str, default: bool = False) -> bool:
+        """
+        Asks a confirmation question and returns True/False based on the user's response.
+
+        Parameters
+        ----------
+        question : str
+            The confirmation question to ask.
+        default : bool, optional
+            The default response if the user presses Enter without typing a response (default is False).
+
+        Returns
+        -------
+        bool
+            The user's response.
+        """
+        return Console.ask(question, default)
+
+    def secret(self, question: str) -> str:
+        """
+        Prompts for hidden input (e.g., password).
+
+        Parameters
+        ----------
+        question : str
+            The prompt to ask the user.
+
+        Returns
+        -------
+        str
+            The user's hidden input.
+        """
+        return Console.secret(question)
+
+    def table(self, headers: list, rows: list):
+        """
+        Prints a formatted table in the console.
+
+        Parameters
+        ----------
+        headers : list of str
+            The column headers for the table.
+        rows : list of list of str
+            The rows of the table.
+
+        Raises
+        ------
+        ValueError
+            If headers or rows are empty.
+        """
+        Console.table(headers, rows)
+
+    def anticipate(self, question: str, options: list, default=None):
+        """
+        Provides autocomplete suggestions for user input.
+
+        Parameters
+        ----------
+        question : str
+            The prompt for the user.
+        options : list of str
+            The list of possible options for autocomplete.
+        default : str, optional
+            The default value if no matching option is found (default is None).
+
+        Returns
+        -------
+        str
+            The chosen option or the default value.
+        """
+        Console.anticipate(question, options, default)
+
+    def choice(self, question: str, choices: list, default_index: int = 0) -> str:
+        """
+        Prompts the user to select a choice from a list.
+
+        Parameters
+        ----------
+        question : str
+            The prompt for the user.
+        choices : list of str
+            The list of available choices.
+        default_index : int, optional
+            The index of the default choice (default is 0).
+
+        Returns
+        -------
+        str
+            The selected choice.
+
+        Raises
+        ------
+        ValueError
+            If `default_index` is out of the range of choices.
+        """
+        Console.choice(question, choices, default_index)
+
+    def createProgressBar(self, total: int = 100, width: int = 50) -> ProgressBar:
+        """
+        Creates and returns a new progress bar.
+
+        This method initializes a `ProgressBar` object with the specified total and width.
+
+        Parameters
+        ----------
+        total : int, optional
+            The total number of steps for the progress bar. Default is 100.
+        width : int, optional
+            The width (in characters) of the progress bar. Default is 50.
+
+        Returns
+        -------
+        ProgressBar
+            A new instance of the `ProgressBar` class, initialized with the specified `total` and `width`.
+
+        Notes
+        -----
+        The progress bar can be used to visually track the progress of a task.
+        The `total` parameter represents the number of steps to complete the task,
+        and the `width` parameter controls the number of characters used to represent the progress bar in the console.
+        """
+        return ProgressBar(total=total, width=width)
+
+    def setArgs(self, args):
+        """
+        Define the logic of setting command arguments.
+
+        Parameters
+        ----------
+        args : argparse.Namespace
+            Contain the arguments to be set for the command.
+        """
+        try:
+            # Convert arguments to a dictionary using vars(), if possible
+            self.args = vars(args)
+        except TypeError:
+            # Fallback to an empty dictionary if args is not compatible with vars()
+            self.args = {}
+
+
+    def handle(self, **kwargs):
+        """
+        Abstract method to define the logic of the command.
+
+        This method must be overridden in subclasses.
+
+        Arguments:
+            **kwargs: Arbitrary keyword arguments.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in a subclass. This ensures that all command classes
+                                adhere to the expected structure.
+        """
+        raise NotImplementedError("The 'handle' method must be implemented in the child class.")

orionis/luminate/console/cache.py

@@ -0,0 +1,132 @@
+import os
+from threading import Lock
+from orionis.luminate.tools.reflection import Reflection
+from orionis.luminate.cache.console.commands import CacheCommands
+from orionis.luminate.contracts.console.cli_cache_interface import ICLICache
+
+class CLICache(ICLICache):
+    """
+    Singleton 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. It is designed to follow
+    the Singleton pattern, meaning only one instance of this class will exist in the application lifecycle.
+
+    Attributes
+    ----------
+    _instance : CLICache
+        The singleton instance of the CLICache class.
+    _lock : threading.Lock
+        A lock used to ensure thread-safety during instance creation.
+    _initialized : bool
+        A flag indicating whether the class has been initialized.
+    paths : list
+        List of directories where commands are located.
+
+    Methods
+    -------
+    __new__ :
+        Creates and returns the singleton instance of the CLICache class.
+    __init__ :
+        Initializes the CLICache instance, loading commands if not already initialized.
+    _load_commands :
+        Loads command modules from predefined directories and imports them dynamically.
+    getCommands :
+        Returns the instance of CacheCommands containing the command cache.
+    """
+
+    _instance = None
+    _lock = Lock()
+
+    def __new__(cls):
+        """
+        Ensures only one instance of the CLICache class exists (Singleton pattern).
+
+        This method is responsible for controlling the instance creation process, ensuring that no more than one
+        CLICache instance is created in the system, even in multi-threaded environments.
+
+        Returns
+        -------
+        CLICache
+            The singleton instance of the CLICache class.
+        """
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(CLICache, cls).__new__(cls)
+                cls._instance._initialized = False
+        return cls._instance
+
+    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.
+        """
+        if self._initialized:
+            return
+
+        self.paths = []
+        self._load_commands()
+        self._initialized = True
+
+    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'):
+                            # Construct the module name and path
+                            module_name = file[:-3]  # Remove the '.py' extension
+                            module_path = f"{pre_module}.{module_name}".replace('venv.Lib.site-packages.', '')
+
+                            # Use Reflection to load the module dynamically
+                            Reflection(module=module_path)
+
+    def getCommands(self):
+        """
+        Returns the instance of the CacheCommands containing the command cache.
+
+        This method provides access to the CacheCommands instance, which holds the loaded commands cache
+        and makes it available for use.
+
+        Returns
+        -------
+        CacheCommands
+            The instance of CacheCommands that holds the cached commands.
+        """
+        return CacheCommands()