orionis 0.1.0__py3-none-any.whl

orionis/cli_manager.py

@@ -0,0 +1,48 @@
+import argparse
+from orionis.luminate.console.scripts.management import Management
+
+def main():
+    """
+    Main entry point for the Orionis CLI tool.
+    """
+
+    # Create the argument parser for CLI commands
+    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()
+
+# Execute the main function if the script is run directly
+if __name__ == "__main__":
+    main()

orionis/framework.py

@@ -0,0 +1,45 @@
+#--------------------------------------------------------------------------
+# Name of the project or framework
+#--------------------------------------------------------------------------
+NAME = "orionis"
+
+#--------------------------------------------------------------------------
+# Current version of the project or framework
+#--------------------------------------------------------------------------
+VERSION = "0.1.0"
+
+#--------------------------------------------------------------------------
+# Full name of the author or maintainer of the project
+#--------------------------------------------------------------------------
+AUTHOR = "Raul Mauricio Uñate Castro"
+
+#--------------------------------------------------------------------------
+# Email address of the author or maintainer for contact purposes
+#--------------------------------------------------------------------------
+AUTHOR_EMAIL = "raulmauriciounate@gmail.com"
+
+#--------------------------------------------------------------------------
+# Short description of the project or framework
+#--------------------------------------------------------------------------
+DESCRIPTION = "Orionis Framework – Elegant, Fast, and Powerful."
+
+#--------------------------------------------------------------------------
+# URL to the project's skeleton or template repository
+# This is typically used for initial project setup
+#--------------------------------------------------------------------------
+SKELETON = "https://github.com/orionis-framework/skeleton"
+
+#--------------------------------------------------------------------------
+# URL to the project's framework repository
+#--------------------------------------------------------------------------
+FRAMEWORK = "https://github.com/orionis-framework/framework"
+
+#--------------------------------------------------------------------------
+# URL to the project's documentation
+#--------------------------------------------------------------------------
+DOCS = "https://github.com/orionis-framework/docs"
+
+#--------------------------------------------------------------------------
+# Minimum Python version required to run the project
+#--------------------------------------------------------------------------
+PYTHON_REQUIRES = ">=3.12"

orionis/luminate/bootstrap/parser.py

@@ -0,0 +1,49 @@
+from typing import Any
+from dataclasses import asdict
+from orionis.luminate.contracts.bootstrap.parser_interface import IParser
+
+class Parser(IParser):
+    """
+    A class responsible for parsing configuration objects into dictionaries.
+
+    This class implements the `IParser` interface and provides a method
+    to convert configuration instances into a dictionary format.
+
+    Methods
+    -------
+    toDict(instance: Any) -> dict
+        Converts the `config` attribute of an instance into a dictionary.
+    """
+
+    @staticmethod
+    def toDict(instance: Any) -> dict:
+        """
+        Converts the `config` attribute of a given instance into a dictionary.
+
+        This method uses `asdict()` to transform a dataclass-based configuration
+        into a dictionary, ensuring that all attributes are properly serialized.
+
+        Parameters
+        ----------
+        instance : Any
+            The object containing a `config` attribute to be converted.
+
+        Returns
+        -------
+        dict
+            A dictionary representation of the `config` attribute.
+
+        Raises
+        ------
+        AttributeError
+            If the provided instance does not have a `config` attribute.
+        TypeError
+            If the `config` attribute cannot be converted to a dictionary.
+        """
+        try:
+            # Convert dataclass using asdict()
+            return asdict(instance.config)
+        except AttributeError as e:
+            raise AttributeError("The provided instance does not have a 'config' attribute.") from e
+        except TypeError as e:
+            raise TypeError(f"Error: The 'config' attribute could not be converted to a dictionary. {str(e)}")

orionis/luminate/bootstrap/register.py

@@ -0,0 +1,95 @@
+from orionis.luminate.bootstrap.parser import Parser
+from orionis.luminate.config.sections import SECTIONS
+from orionis.luminate.tools.reflection import Reflection
+from orionis.luminate.cache.app.config import CacheConfig
+from orionis.luminate.contracts.config.config_interface import IConfig
+
+class Register:
+    """
+    Handles the registration of configuration classes within the application.
+
+    This class ensures that only valid configuration classes are registered
+    while enforcing structure and type safety.
+
+    Attributes
+    ----------
+    cache_config : CacheConfig
+        An instance of `CacheConfig` used to store registered configurations.
+
+    Methods
+    -------
+    config(config_class: type) -> type
+        Registers a configuration class and ensures it meets the necessary criteria.
+    """
+
+    def __init__(self, cache: CacheConfig = None):
+        """
+        Initializes the Register instance with a cache configuration.
+
+        Parameters
+        ----------
+        cache : CacheConfig, optional
+            The cache configuration instance to be used (default is a new instance of `CacheConfig`).
+        """
+        self.cache_config = cache or CacheConfig()
+
+    def config(self, config_class: type) -> type:
+        """
+        Registers a configuration class and ensures it meets the required structure.
+
+        This method performs multiple validation steps, including checking if the input
+        is a class, verifying the existence of a `config` attribute, and confirming
+        inheritance from `IConfig`.
+
+        Parameters
+        ----------
+        config_class : type
+            The class to be registered as a configuration.
+
+        Returns
+        -------
+        type
+            The same class passed as an argument, if registration is successful.
+
+        Raises
+        ------
+        TypeError
+            If `config_class` is not a class or does not inherit from `IConfig`.
+        ValueError
+            If `config_class` does not have a `config` attribute or is already registered.
+        """
+
+        if not isinstance(config_class, type):
+            raise TypeError(f"Expected a class, but got {type(config_class).__name__}.")
+
+        if not hasattr(config_class, 'config'):
+            raise ValueError(f"Class {config_class.__name__} must have a 'config' attribute.")
+
+        # Extract module name
+        section = Reflection(config_class).getFileName(remove_extension=True)
+
+        # Validate section
+        if section not in SECTIONS:
+            raise ValueError(
+                f"Invalid configuration section '{section}'. Allowed sections: {SECTIONS}"
+            )
+
+        # Validate inheritance
+        if not issubclass(config_class, IConfig):
+            raise TypeError(f"Class {config_class.__name__} must inherit from 'IConfig'.")
+
+        # Check if section is already registered
+        if section in self.cache_config.config:
+            raise ValueError(f"Configuration section '{section}' is already registered.")
+
+        # Register configuration
+        self.cache_config.register(
+            section=section,
+            data=Parser.toDict(config_class)
+        )
+
+        # Return the original class
+        return config_class
+
+# Create a global Register instance
+register = Register()

orionis/luminate/cache/app/config.py

@@ -0,0 +1,96 @@
+from typing import Dict, Any
+
+class CacheConfig:
+    """
+    Singleton class for managing application configuration caching.
+
+    This class ensures that configuration sections are registered only once
+    and provides methods to register, unregister, and retrieve configurations.
+
+    Attributes
+    ----------
+    _instance : CacheConfig
+        A private class attribute that holds the singleton instance.
+    config : dict
+        A dictionary storing registered configuration sections.
+    """
+
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        """
+        Ensures a single instance of CacheConfig (Singleton Pattern).
+
+        Returns
+        -------
+        CacheConfig
+            The singleton instance of the class.
+        """
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance.config = {}
+        return cls._instance
+
+    def register(self, section: str, data: Dict[str, Any]) -> None:
+        """
+        Registers a configuration section.
+
+        Parameters
+        ----------
+        section : str
+            The name of the configuration section to register.
+        data : dict
+            The configuration data associated with the section.
+
+        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 unregister(self, section: str) -> None:
+        """
+        Unregisters a previously registered configuration section.
+
+        Parameters
+        ----------
+        section : str
+            The name of the configuration section to remove.
+
+        Raises
+        ------
+        KeyError
+            If the section is not found in the registered configurations.
+        """
+        if section not in self.config:
+            raise KeyError(f"Configuration section '{section}' is not registered.")
+
+        del self.config[section]
+
+    def get(self, section: str) -> Dict[str, Any]:
+        """
+        Retrieves the configuration for a specific section.
+
+        Parameters
+        ----------
+        section : str
+            The name of the configuration section to retrieve.
+
+        Returns
+        -------
+        dict
+            The configuration data for the specified section.
+
+        Raises
+        ------
+        KeyError
+            If the requested section is not found.
+        """
+        if section not in self.config:
+            raise KeyError(f"Configuration section '{section}' is not registered.")
+
+        return self.config[section]

orionis/luminate/cache/console/commands.py

@@ -0,0 +1,98 @@
+from orionis.luminate.contracts.cache.cache_commands_interface import ICacheCommands
+
+class CacheCommands(ICacheCommands):
+    """
+    Singleton class for managing a cache of commands.
+
+    This class ensures that only one instance of the command cache exists
+    and provides methods for registering, unregistering, and retrieving commands.
+    """
+
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        """
+        Create or return the singleton instance of the CacheCommands class.
+
+        Ensures that only one instance of the CacheCommands class exists
+        during the lifetime of the application.
+
+        Returns
+        -------
+        CacheCommands
+            The singleton instance of the class.
+        """
+        if cls._instance is None:
+            cls._instance = super().__new__(cls, *args, **kwargs)
+            cls._instance.commands = {}
+        return cls._instance
+
+    def register(self, signature: str, description: str, arguments: list, instance):
+        """
+        Register a new command with its signature, description, and class instance.
+
+        Parameters
+        ----------
+        signature : str
+            The unique identifier (signature) for the command.
+        description : str
+            A brief description of what the command does.
+        instance : class
+            The class or callable instance that defines the command behavior.
+
+        Raises
+        ------
+        ValueError
+            If a command with the given signature already exists.
+        """
+        if signature in self.commands:
+            raise ValueError(f"Command '{signature}' is already registered. Please ensure signatures are unique.")
+
+        self.commands[signature] = {
+            'instance':instance,
+            'arguments':arguments,
+            'description':description,
+            'signature':signature
+        }
+
+    def unregister(self, signature: str):
+        """
+        Unregister an existing command by its signature.
+
+        Parameters
+        ----------
+        signature : str
+            The unique identifier (signature) for the command to unregister.
+
+        Raises
+        ------
+        KeyError
+            If the command with the given signature does not exist.
+        """
+        if signature not in self.commands:
+            raise KeyError(f"Command '{signature}' not found.")
+        del self.commands[signature]
+
+    def get(self, signature: str):
+        """
+        Retrieve the information of a registered command by its signature.
+
+        Parameters
+        ----------
+        signature : str
+            The unique identifier (signature) for the command.
+
+        Returns
+        -------
+        dict
+            A dictionary containing the class, signature, and description of the command.
+
+        Raises
+        ------
+        KeyError
+            If the command with the given signature does not exist.
+        """
+        command = self.commands.get(signature)
+        if not command:
+            raise KeyError(f"Command with signature '{signature}' not found.")
+        return command

orionis/luminate/config/dataclass/app.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass, field
+from typing import Dict
+
+@dataclass
+class App:
+    """
+    Represents the application's core configuration.
+
+    This class defines the essential settings for the application, including
+    its name, debugging mode, encryption settings, and server-related properties.
+
+    Attributes
+    ----------
+    name : str
+        The name of the application, used in logs, UI elements, and notifications.
+    debug : bool
+        Determines whether debugging mode is enabled. Should be `False` in production.
+    bytecode : bool
+        Indicates whether Python bytecode caching (.pyc files) is enabled.
+    timezone : str
+        The default timezone for the application, used for logging and scheduled tasks.
+    url : str
+        The base URL or host address where the application runs.
+    port : int
+        The port number the application listens on.
+    workers : int
+        The number of worker processes handling requests (affects performance).
+    reload : bool
+        Enables automatic server reloading when code changes (useful for development).
+    cipher : str
+        The encryption algorithm used for secure data handling (e.g., "AES-256-GCM").
+    key : str
+        The encryption key used for cryptographic operations.
+    custom : dict
+        A dictionary for storing additional custom properties. Defaults to an empty dictionary.
+    """
+
+    name: str
+    debug: bool
+    bytecode: bool
+    timezone: str
+    url: str
+    port: int
+    workers: int
+    reload: bool
+    cipher: str
+    key: str
+
+    # Holds additional custom properties, initialized as an empty dictionary
+    custom: Dict[str, any] = field(default_factory=dict)

orionis/luminate/config/dataclass/auth.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass, field
+from typing import Dict
+
+@dataclass
+class Auth:
+    """
+    Represents a class that holds custom properties in a dictionary.
+
+    Attributes
+    ----------
+    custom : dict
+        A dictionary to store any additional custom properties.
+        This field is initialized with an empty dictionary by default.
+    """
+
+    # Custom dictionary to hold dynamic or extra properties, initialized as an empty dict
+    custom: Dict[str, any] = field(default_factory=dict)

orionis/luminate/config/dataclass/cache.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass, field
+from typing import Dict, Any
+
+@dataclass
+class File:
+    """
+    Represents a file storage path.
+
+    Attributes
+    ----------
+    path : str
+        The file path used for caching.
+    """
+    path: str
+
+@dataclass
+class Stores:
+    """
+    Defines available cache stores.
+
+    Attributes
+    ----------
+    file : File
+        An instance of `File` representing file-based cache storage.
+    """
+    file: File
+
+@dataclass
+class Cache:
+    """
+    Configuration for a cache system.
+
+    Attributes
+    ----------
+    default : str
+        The default cache storage type (e.g., "ram" or "file").
+    stores : Stores
+        An instance of `Stores` containing cache storage configurations.
+    custom : Dict[str, Any], optional
+        A dictionary containing additional custom properties for cache configuration.
+        Defaults to an empty dictionary.
+
+    Notes
+    -----
+    - The `default` attribute defines the main cache type.
+    - The `stores` attribute holds configurations for different cache stores.
+    - The `custom` attribute allows for dynamic additional properties if needed.
+    """
+    default: str
+    stores: Stores = field(default_factory=lambda: Stores(File("")))
+    custom: Dict[str, Any] = field(default_factory=dict)

orionis/luminate/config/dataclass/cors.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Union, Dict
+
+@dataclass
+class Cors:
+    """
+    Interface that defines the structure for configuring Cross-Origin Resource Sharing (CORS)
+    for Starlette's CORSMiddleware.
+
+    Attributes
+    ----------
+    allowed_methods : List[str]
+        A list of HTTP methods (e.g., "GET", "POST", "PUT", etc.) that are allowed for cross-origin requests.
+
+    allowed_origins : Union[str, List[str]]
+        A single origin or a list of origins that are allowed to access the resources.
+        Example: "https://example.com" or ["https://example.com", "https://another-origin.com"].
+
+    allowed_headers : List[str]
+        A list of headers that can be included in the requests from the allowed origins.
+        Example: ["Content-Type", "X-Custom-Header"].
+
+    exposed_headers : List[str]
+        A list of headers that the browser can access from the response.
+        Example: ["X-Exposed-Header"].
+
+    max_age : Optional[int]
+        The maximum amount of time (in seconds) that the results of a preflight request can be cached by the browser.
+
+    custom : Dict[str, any]
+        A dictionary for any custom properties or additional configurations related to CORS.
+        This field is initialized with an empty dictionary by default.
+
+    Notes
+    -----
+    - `allowed_methods`, `allowed_headers`, and `exposed_headers` should always be lists of strings.
+    - `allowed_origins` can either be a single string or a list of strings.
+    - `max_age` should be an integer representing the duration in seconds.
+    - The `custom` attribute is for additional configurations or custom properties.
+    """
+
+    # List of allowed HTTP methods
+    allowed_methods: List[str]
+
+    # Single origin or list of origins allowed
+    allowed_origins: Union[str, List[str]]
+
+    # List of allowed headers
+    allowed_headers: List[str]
+
+    # List of headers that are accessible by the browser
+    exposed_headers: List[str]
+
+    # Time in seconds that the results of preflight requests can be cached
+    max_age: Optional[int]
+
+    # Custom properties or configurations for additional flexibility
+    custom: Dict[str, any] = field(default_factory=dict)