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

orionis/cli_manager.py

@@ -1,47 +1,33 @@
 import argparse
-from orionis.luminate.console.scripts.management import Management
+from orionis.installer.installer_manager import InstallerManager
+from orionis.installer.installer_output import InstallerOutput
 
+# Main entry point for the Orionis CLI tool.
 def main():
-    """
-    Main entry point for the Orionis CLI tool.
-    """
 
-    # Create the argument parser for CLI commands
+    # Initialize the argument parser
     parser = argparse.ArgumentParser(description="Orionis Command Line Tool")
-
-    # Optional argument for displaying the current Orionis version
     parser.add_argument('--version', action='store_true', help="Show Orionis version.")
-
-    # Optional argument for upgrading Orionis to the latest version
     parser.add_argument('--upgrade', action='store_true', help="Upgrade Orionis to the latest version.")
-
-    # Command to create a new Orionis app (requires an app name)
     parser.add_argument('command', nargs='?', choices=['new'], help="Available command: 'new'.")
-
-    # Name of the application to be created (defaults to 'example-app')
     parser.add_argument('name', nargs='?', help="The name of the Orionis application to create.", default="example-app")
 
     # Parse the provided arguments
     args = parser.parse_args()
 
     # Initialize the Orionis tools for handling operations
-    cli_manager = Management()
-
-    # Handle the version command
-    if args.version:
-        cli_manager.displayVersion()
-
-    # Handle the upgrade command
-    elif args.upgrade:
-        cli_manager.executeUpgrade()
-
-    # Handle the 'new' command to create a new app
-    elif args.command == 'new':
-        cli_manager.createNewApp(args.name or 'example-app')
-
-    # If no valid command is provided, show the help message
-    else:
-        cli_manager.displayInfo()
+    try:
+        installer = InstallerManager()
+        if args.version:
+            installer.handleVersion()
+        elif args.upgrade:
+            installer.handleUpgrade()
+        elif args.command == 'new':
+            installer.handleNewApp(args.name)
+        else:
+            installer.handleInfo()
+    except Exception as e:
+        InstallerOutput.error(f"An error occurred: {e}", e)
 
 # Execute the main function if the script is run directly
 if __name__ == "__main__":

orionis/contracts/bootstrap/i_command_bootstrapper.py

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

orionis/contracts/bootstrap/i_config_bootstrapper.py

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

orionis/contracts/bootstrap/i_environment_bootstrapper.py

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+class IEnvironmentBootstrapper(ABC):
+    """
+    Attributes
+    ----------
+    _environment_vars : Dict[str, str]
+        A dictionary to store the loaded environment variables.
+    path : Path
+        The path to the `.env` file.
+
+    Methods
+    -------
+    _autoload()
+        Loads environment variables from the `.env` file or creates the file if it does not exist.
+    """
+
+    @abstractmethod
+    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.
+
+        Raises
+        ------
+        PermissionError
+            If the `.env` file cannot be created or read due to insufficient permissions.
+        """
+        pass

orionis/{luminate/contracts/console/base/base_command_interface.py → contracts/console/base/i_command.py}

@@ -1,6 +1,5 @@
 from abc import ABC, abstractmethod
 from typing import List
-
 from orionis.luminate.console.output.progress_bar import ProgressBar
 
 class IBaseCommand(ABC):

orionis/contracts/facades/config/i_config_facade.py

@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+class IConfig(ABC):
+
+    @abstractmethod
+    def set(key: str, value: Any) -> None:
+        """
+        Dynamically sets a configuration value using dot notation.
+
+        Parameters
+        ----------
+        key : str
+            The configuration key (e.g., 'app.debug').
+        value : Any
+            The value to set.
+        """
+        pass
+
+    @abstractmethod
+    def get(key: str, default: Optional[Any] = None) -> Any:
+        """
+        Retrieves a configuration value using dot notation.
+
+        Parameters
+        ----------
+        key : str
+            The configuration key (e.g., 'app.debug').
+        default : Optional[Any]
+            The default value to return if the key is not found.
+
+        Returns
+        -------
+        Any
+            The configuration value or the default value if the key is not found.
+        """
+        pass

orionis/contracts/facades/environment/i_environment_facade.py

@@ -0,0 +1,40 @@
+
+from abc import ABC, abstractmethod
+
+class IEnv(ABC):
+    """
+    A facade class for accessing environment variables.
+
+    This class provides a static method to retrieve environment variables
+    stored in the application context. It implements the `IEnv` interface.
+
+    Methods
+    -------
+    get(key: str, default=None) -> str
+        Retrieves the value of an environment variable.
+    """
+
+    @abstractmethod
+    def get(key: str, default=None) -> str:
+        """
+        Retrieves the value of an environment variable.
+
+        This method provides a convenient way to access environment variables
+        stored in the application context. If the variable does not exist, it
+        returns the specified default value.
+
+        Parameters
+        ----------
+        key : str
+            The name of the environment variable to retrieve.
+        default : Any, optional
+            The default value to return if the environment variable does not exist.
+            Defaults to None.
+
+        Returns
+        -------
+        str
+            The value of the environment variable, or the default value if the variable
+            does not exist.
+        """
+        pass

orionis/{luminate/contracts/facades/paths_interface.py → contracts/facades/files/i_path_facade.py}

@@ -1,25 +1,32 @@
 from abc import ABC, abstractmethod
 
 class IPath(ABC):
-
-    @abstractmethod
-    def _resolve_directory(directory: str, file: str = None):
-        """
-        Internal helper function to resolve an absolute path for a given directory.
-
-        Parameters
-        ----------
-        directory : str
-            The base directory to resolve the path from.
-        file : str, optional
-            The relative file path inside the directory (default is an empty string).
-
-        Returns
-        -------
-        SkeletonPath
-            The resolved absolute path wrapped in a SkeletonPath object.
-        """
-        pass
+    """
+    A facade class for resolving absolute paths to various application directories.
+
+    This class provides static methods to resolve paths to common directories such as
+    'app', 'config', 'database', 'resources', 'routes', 'storage', and 'tests'.
+    It uses the `PathService` to resolve and validate paths.
+
+    Methods
+    -------
+    _resolve_directory(directory: str, file: str = None) -> SkeletonPath
+        Resolves the absolute path for a given directory and optional file.
+    app(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'app' directory.
+    config(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'config' directory.
+    database(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'database' directory.
+    resource(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'resource' directory.
+    routes(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'routes' directory.
+    storage(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'storage' directory.
+    tests(file: str = None) -> SkeletonPath
+        Returns the absolute path for a file inside the 'tests' directory.
+    """
 
     @abstractmethod
     def app(file: str = None):
@@ -138,4 +145,4 @@ class IPath(ABC):
         SkeletonPath
             The resolved path wrapped in a SkeletonPath object.
         """
-        pass
+        pass

orionis/contracts/facades/log/i_log_facade.py

@@ -0,0 +1,83 @@
+from abc import ABC, abstractmethod
+
+class ILog(ABC):
+    """
+    A facade class for logging messages with different severity levels.
+
+    This class provides static methods to log messages using the `LogguerService`.
+    It simplifies the process of logging by abstracting the service resolution
+    and providing a clean interface for logging.
+
+    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.
+    warning(message: str) -> None
+        Logs a warning message.
+    debug(message: str) -> None
+        Logs a debug message.
+    """
+
+    @abstractmethod
+    def info(message: str) -> None:
+        """
+        Logs an informational message.
+
+        Parameters
+        ----------
+        message : str
+            The message to log.
+        """
+        pass
+
+    @abstractmethod
+    def error(message: str) -> None:
+        """
+        Logs an error message.
+
+        Parameters
+        ----------
+        message : str
+            The message to log.
+        """
+        pass
+
+    @abstractmethod
+    def success(message: str) -> None:
+        """
+        Logs a success message.
+
+        Parameters
+        ----------
+        message : str
+            The message to log.
+        """
+        pass
+
+    @abstractmethod
+    def warning(message: str) -> None:
+        """
+        Logs a warning message.
+
+        Parameters
+        ----------
+        message : str
+            The message to log.
+        """
+        pass
+
+    @abstractmethod
+    def debug(message: str) -> None:
+        """
+        Logs a debug message.
+
+        Parameters
+        ----------
+        message : str
+            The message to log.
+        """
+        pass

orionis/{luminate/contracts/facades/tests_interface.py → contracts/facades/tests/i_tests_facade.py}

@@ -2,16 +2,13 @@ from abc import ABC, abstractmethod
 
 class IUnitTests(ABC):
     """
-    Interface for executing unit tests in a specified directory.
-
-    This class defines the abstract structure for any unit test executor,
-    enforcing the implementation of the 'execute' method in any subclass.
+    Interface for executing unit tests based on a specified pattern.
 
     Methods
     -------
     execute(pattern: str) -> dict
-        Executes the unit tests in the 'tests' directory and subdirectories,
-        using a file pattern for filtering test files.
+        Executes unit tests by iterating over the 'tests' directory and its subdirectories,
+        matching test files based on the provided pattern.
     """
 
     @abstractmethod

orionis/{luminate/contracts/console/scripts/management_interface.py → contracts/installer/i_installer_manager.py}

@@ -1,28 +1,30 @@
+
 from abc import ABC, abstractmethod
 
-class IManagement(ABC):
+class IInstallerManager(ABC):
     """
-    Interface defining the contract for the Management class.
-
-    This interface ensures that any implementing class provides methods for
-    displaying the framework version, upgrading the framework, creating a new
-    application, and displaying additional information.
+    Interface for the InstallerManager class.
     """
 
     @abstractmethod
-    def displayVersion(self) -> str:
+    def handleVersion(self) -> str:
         """
-        Display the current version of the framework.
+        Display the current version of the framework in ASCII format.
 
         Returns
         -------
         str
             The ASCII representation of the framework version.
+
+        Raises
+        ------
+        Exception
+            If an error occurs while generating the ASCII version output.
         """
         pass
 
     @abstractmethod
-    def executeUpgrade(self) -> None:
+    def handleUpgrade(self) -> None:
         """
         Execute the framework upgrade process to the latest version.
 
@@ -33,15 +35,16 @@ class IManagement(ABC):
         """
         pass
 
+
     @abstractmethod
-    def createNewApp(self, name_app: str) -> None:
+    def handleNewApp(self, name_app: str = "example-app") -> None:
         """
-        Create a new application with the given name.
+        Create a new application with the specified name.
 
         Parameters
         ----------
-        name_app : str
-            The name of the new application.
+        name_app : str, optional
+            The name of the new application (default is "example-app").
 
         Raises
         ------
@@ -51,13 +54,13 @@ class IManagement(ABC):
         pass
 
     @abstractmethod
-    def displayInfo(self) -> None:
+    def handleInfo(self) -> None:
         """
-        Display additional information about the framework.
+        Display additional framework information in ASCII format.
 
         Raises
         ------
         Exception
             If an error occurs while displaying information.
         """
-        pass
+        pass