orionis 0.1.0__tar.gz

orionis-0.1.0/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 - 2025 RAÚL MAURICIO UÑATE CASTRO
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

orionis-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include orionis *.py *.stub *.png *.ascii

orionis-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.2
+Name: orionis
+Version: 0.1.0
+Summary: Orionis Framework – Elegant, Fast, and Powerful.
+Home-page: https://github.com/orionis-framework/framework
+Author: Raul Mauricio Uñate Castro
+Author-email: raulmauriciounate@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: apscheduler>=3.11.0
+Requires-Dist: python-dotenv>=1.0.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# **Orionis Framework – An Opinionated Python Framework**
+**⚡ Orionis Framework – Elegant, Fast, and Powerful 🚀**

orionis-0.1.0/README.md

@@ -0,0 +1,2 @@
+# **Orionis Framework – An Opinionated Python Framework**
+**⚡ Orionis Framework – Elegant, Fast, and Powerful 🚀**

orionis-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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)