orionis 0.245.0__py3-none-any.whl → 0.247.0__py3-none-any.whl

tests/support/inspection/test_reflect_abstract.py

@@ -1,4 +1,5 @@
 from abc import ABC
+import json
 from orionis.luminate.support.introspection.reflection import Reflection
 from orionis.luminate.test import TestCase
 from tests.support.inspection.fakes.fake_reflect_abstract import FakeAbstractClass
@@ -62,10 +63,70 @@ class TestReflectAbstract(TestCase):
         - Return type is correct
         """
         attributes = Reflection.abstract(FakeAbstractClass).getAllAttributes()
-        self.print(attributes)
+        self.assertIn('__private_class_attribute', attributes.private)
+        self.assertIn('_protected_class_attribute', attributes.protected)
+        self.assertIn('public_class_attribute', attributes.public)
 
+    async def testReflectionAbstractGetAttribute(self):
+        """Test getAttribute() method.
 
+        Verifies that:
+        - Correct attribute is returned
+        - Attribute type is correct
+        """
+        attr = Reflection.abstract(FakeAbstractClass).getAttributes()
+        self.assertIn('__private_class_attribute', attr)
+        self.assertIn('_protected_class_attribute', attr)
+        self.assertIn('public_class_attribute', attr)
+
+    async def testReflectionAbstractGetPublicAttributes(self):
+        """Test getPublicAttributes() method.
+
+        Verifies that:
+        - Only public attributes are returned
+        - No private/protected attributes are included
+        """
+        public_attributes = Reflection.abstract(FakeAbstractClass).getPublicAttributes()
+        self.assertIn('public_class_attribute', public_attributes)
+        self.assertNotIn('_protected_class_attribute', public_attributes)
+        self.assertNotIn('__private_class_attribute', public_attributes)
+
+    async def testReflectionAbstractGetProtectedAttributes(self):
+        """Test getProtectedAttributes() method.
 
+        Verifies that:
+        - Only protected attributes are returned
+        - No private/public attributes are included
+        """
+        protected_attributes = Reflection.abstract(FakeAbstractClass).getProtectedAttributes()
+        self.assertIn('_protected_class_attribute', protected_attributes)
+        self.assertNotIn('__private_class_attribute', protected_attributes)
+        self.assertNotIn('public_class_attribute', protected_attributes)
+
+    async def testReflectionAbstractGetPrivateAttributes(self):
+        """Test getPrivateAttributes() method.
+
+        Verifies that:
+        - Only private attributes are returned
+        - No protected/public attributes are included
+        """
+        private_attributes = Reflection.abstract(FakeAbstractClass).getPrivateAttributes()
+        self.assertIn('__private_class_attribute', private_attributes)
+        self.assertNotIn('_protected_class_attribute', private_attributes)
+        self.assertNotIn('public_class_attribute', private_attributes)
+
+    async def testReflectionAbstractGetAllMethods(self):
+        """Test getAllMethods() method.
+
+        Verifies that:
+        - All methods are detected
+        - No private/protected methods are included
+        - Return type is correct
+        """
+        methods = Reflection.abstract(FakeAbstractClass).getAllMethods()
+        self.console().info(message="Hola")
+        # self.print(Reflection.abstract(FakeAbstractClass).getAllAttributes())
+        # self.dd(json.dumps(methods, indent=4))
 
 
 

tests/support/inspection/test_reflect_instance.py

@@ -37,7 +37,6 @@ class TestReflectInstance(TestCase):
         """Check that getAllAttributes returns all attributes of the class."""
         reflex = Reflection.instance(FakeClass())
         attributes = reflex.getAllAttributes()
-        self.print(attributes)
         self.assertTrue("public_attr" in attributes.public)
         self.assertTrue("__private_attr" in attributes.private)
         self.assertTrue("_protected_attr" in attributes.protected)

orionis/luminate/config/app.py

@@ -1,47 +0,0 @@
-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
-    custom: Dict[str, any] = field(default_factory=dict)

orionis/luminate/config/auth.py

@@ -1,15 +0,0 @@
-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: Dict[str, any] = field(default_factory=dict)

orionis/luminate/config/cache.py

@@ -1,51 +0,0 @@
-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/support/environment/contracts/env.py

@@ -1,68 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Optional, Union
-
-class IEnv(ABC):
-    """
-    Interface for a utility class to manage environment variables in a `.env` file.
-    """
-
-    @staticmethod
-    @abstractmethod
-    def get(key: str, default: Optional[Any] = None) -> Any:
-        """
-        Retrieve the value of an environment variable.
-
-        Parameters
-        ----------
-        key : str
-            Name of the environment variable.
-        default : Any, optional
-            Default value if variable is not found.
-
-        Returns
-        -------
-        Any
-            Parsed value or default.
-        """
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def set(key: str, value: Union[str, int, float, bool, list, dict]) -> None:
-        """
-        Set the value of an environment variable.
-
-        Parameters
-        ----------
-        key : str
-            Name of the environment variable.
-        value : str, int, float, bool, list, or dict
-            Value to assign, will be serialized.
-        """
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def unset(key: str) -> None:
-        """
-        Remove an environment variable.
-
-        Parameters
-        ----------
-        key : str
-            Name of the environment variable.
-        """
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def all() -> dict:
-        """
-        Retrieve all environment variables as a dictionary.
-
-        Returns
-        -------
-        dict
-            Dictionary of parsed environment variables.
-        """
-        pass

orionis/luminate/support/environment/env.py

@@ -1,138 +0,0 @@
-import os
-from typing import Any, Optional, Union
-from dotenv import set_key, unset_key, dotenv_values
-from orionis.luminate.support.environment.contracts.env import IEnv
-from orionis.luminate.support.environment.functions import (
-    _initialize,
-    _parse_value,
-    _serialize_value,
-    _delete_file
-)
-
-class Env(IEnv):
-    """
-    A utility class for managing environment variables stored in a `.env` file.
-    """
-
-    @staticmethod
-    def get(key: str, default: Optional[Any] = None) -> Any:
-        """
-        Retrieves the value of an environment variable from the `.env` file.
-
-        Parameters
-        ----------
-        path : str or Path, optional
-            The path to the `.env` file. If None, a default path is used.
-        key : str
-            The name of the environment variable to retrieve.
-        default : Any, optional
-            The default value to return if the variable is not found.
-
-        Returns
-        -------
-        Any
-            The value of the environment variable, parsed into its appropriate type,
-            or the default value if the variable is not found.
-        """
-        resolved_path = _initialize()
-        value = dotenv_values(resolved_path).get(key) or os.getenv(key)
-        return _parse_value(value) if value is not None else default
-
-    @staticmethod
-    def set(key: str, value: Union[str, int, float, bool, list, dict]) -> None:
-        """
-        Sets the value of an environment variable in the `.env` file.
-
-        Parameters
-        ----------
-        path : str or Path, optional
-            The path to the `.env` file. If None, a default path is used.
-        key : str
-            The name of the environment variable to set.
-        value : str, int, float, bool, list, or dict
-            The value to assign to the environment variable. It will be serialized
-            before being stored.
-
-        Returns
-        -------
-        None
-        """
-        resolved_path = _initialize()
-        serialized_value = _serialize_value(value)
-        set_key(str(resolved_path), key, serialized_value)
-
-    @staticmethod
-    def unset(key: str) -> None:
-        """
-        Removes an environment variable from the `.env` file.
-
-        Parameters
-        ----------
-        path : str or Path, optional
-            The path to the `.env` file. If None, a default path is used.
-        key : str
-            The name of the environment variable to remove.
-
-        Returns
-        -------
-        None
-        """
-        resolved_path = _initialize()
-        unset_key(str(resolved_path), key)
-
-    @staticmethod
-    def all() -> dict:
-        """
-        Retrieves all environment variables from the `.env` file.
-
-        Parameters
-        ----------
-        path : str or Path, optional
-            The path to the `.env` file. If None, a default path is used.
-
-        Returns
-        -------
-        dict
-            A dictionary containing all environment variables from the `.env` file,
-            with their values parsed into their appropriate types.
-        """
-        resolved_path = _initialize()
-        env_vars = {}
-        data = dotenv_values(resolved_path)
-
-        for key, value in data.items():
-            env_vars[key] = _parse_value(value)
-
-        return env_vars
-
-    @staticmethod
-    def initialize() -> None:
-        """
-        Initializes the `.env` file if it does not exist.
-
-        Parameters
-        ----------
-        path : str or Path, optional
-            The path to the `.env` file. If None, a default path is used.
-
-        Returns
-        -------
-        None
-        """
-        _initialize()
-
-    @staticmethod
-    def destroy() -> None:
-        """
-        Deletes the `.env` file.
-
-        Parameters
-        ----------
-        path : str or Path, optional
-            The path to the `.env` file. If None, a default path is used.
-
-        Returns
-        -------
-        None
-        """
-        _delete_file()

orionis/luminate/support/environment/functions.py

@@ -1,49 +0,0 @@
-import ast
-import os
-from pathlib import Path
-from typing import Any
-
-def _initialize() -> Path:
-    """
-    Inicializa la ruta al archivo `.env`.
-    """
-    resolved_path = Path(os.getcwd()) / ".env"
-
-    # Asegurarse de que el archivo .env exista
-    if not resolved_path.exists():
-        resolved_path.touch()
-
-    return resolved_path
-
-def _parse_value(value: Any) -> Any:
-    """
-    Parsea un valor de cadena en un tipo de dato de Python.
-    """
-    value = str(value).strip() if value is not None else None
-
-    if not value or value.lower() in {'none', 'null'}:
-        return None
-    if value.lower() in {'true', 'false'}:
-        return value.lower() == 'true'
-    if value.isdigit():
-        return int(value)
-    try:
-        return ast.literal_eval(value)
-    except (ValueError, SyntaxError):
-        return value
-
-def _serialize_value(value: Any) -> str:
-    """
-    Serializa un tipo de dato de Python en una cadena para almacenarlo en el archivo `.env`.
-    """
-    if isinstance(value, (list, dict, bool, int, float)):
-        return repr(value)
-    return str(value)
-
-def _delete_file() -> None:
-    """
-    Elimina el archivo especificado.
-    """
-    resolved_path = Path(os.getcwd()) / ".env"
-    if resolved_path.exists():
-        os.remove(resolved_path)

orionis/luminate/support/environment/helper.py

@@ -1,26 +0,0 @@
-from typing import Any
-from orionis.luminate.support.environment.env import Env
-
-def env(key: str, default = None) -> Any:
-    """
-    Retrieves the value of an environment variable.
-
-    This function 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
-    -------
-    Any
-        The value of the environment variable, or the default value if the variable
-        does not exist.
-    """
-    return Env.get(key, default)

orionis/luminate/support/patterns/singleton.py

@@ -1,44 +0,0 @@
-import threading
-
-class SingletonMeta(type):
-    """
-    A thread-safe metaclass for implementing the Singleton pattern.
-
-    This metaclass ensures that only one instance of a class is created,
-    even in a multithreaded environment, by using a lock to synchronize
-    instance creation.
-
-    Attributes
-    ----------
-    _instances : dict
-        A dictionary that holds the single instances of the classes using this metaclass.
-    _lock : threading.Lock
-        A lock to ensure thread-safe instance creation.
-    """
-    _instances = {}
-    _lock = threading.Lock()
-
-    def __call__(cls, *args, **kwargs):
-        """
-        Return the singleton instance of the class in a thread-safe manner.
-
-        If an instance does not already exist, it is created under the protection
-        of a lock; otherwise, the existing instance is returned.
-
-        Parameters
-        ----------
-        *args : list
-            Positional arguments for the class constructor.
-        **kwargs : dict
-            Keyword arguments for the class constructor.
-
-        Returns
-        -------
-        object
-            The singleton instance of the class.
-        """
-        if cls not in cls._instances:
-            with cls._lock:
-                if cls not in cls._instances:
-                    cls._instances[cls] = super().__call__(*args, **kwargs)
-        return cls._instances[cls]

tests/support/environment/test_env.py

@@ -1,91 +0,0 @@
-from orionis.luminate.support.environment.env import Env
-from orionis.luminate.test import TestCase
-
-class TestsEnvironment(TestCase):
-
-    async def testGetEnvVariable(self):
-        """
-        Test retrieving an environment variable from the `.env` file.
-        """
-
-        # Mock the environment setup
-        Env.set('TEST_KEY', 'TEST_VALUE')
-
-        # Test the get method
-        result = Env.get('TEST_KEY')
-        self.assertEqual(result, "TEST_VALUE")
-
-        # Test with a non-existent key
-        result = Env.get('NON_EXISTENT_KEY', True)
-        self.assertEqual(result, True)
-
-        # Delete File .env
-        Env.destroy()
-
-    async def testSetEnvVariable(self):
-        """
-        Test setting an environment variable in the `.env` file.
-        """
-
-        # Set the environment variable
-        Env.set('TEST_KEY', 'NEW_VALUE')
-
-        # Verify the value was set correctly
-        result = Env.get('TEST_KEY')
-        self.assertEqual(result, 'NEW_VALUE')
-
-        # Delete File .env
-        Env.destroy()
-
-    async def testUnsetEnvVariable(self):
-        """
-        Test removing an environment variable from the `.env` file.
-        """
-
-        # Set and then unset the environment variable
-        Env.set('TEST_KEY', "TEST_VALUE")
-        Env.unset('TEST_KEY')
-
-        # Verify the variable was removed
-        result = Env.get('TEST_KEY')
-        self.assertIsNone(result)
-
-        # Delete File .env
-        Env.destroy()
-
-    async def testGetEnvHelper(self):
-        """"
-        Test retrieving an environment variable using the env helper.
-        """
-
-        # Mock the environment setup
-        Env.set('FRAMEWORK', 'https://github.com/orionis-framework/framework')
-
-        # Import the env helper and retrieve the variable
-        from orionis.luminate.support.environment.helper import env as get_env
-        result = get_env('FRAMEWORK')
-
-        # Verify the result
-        self.assertEqual(result, 'https://github.com/orionis-framework/framework')
-
-        # Delete File .env
-        Env.destroy()
-
-    async def test_get_all_env_variables(self):
-        """
-        Test retrieving all environment variables from the `.env` file.
-        """
-
-        # Mock the environment setup
-        Env.set('KEY1', 'value1')
-        Env.set('KEY2', 'value2')
-
-        # Retrieve all environment variables
-        result = Env.all()
-
-        # Verify the result
-        self.assertEqual(result.get('KEY1'), 'value1')
-        self.assertEqual(result.get('KEY2'), 'value2')
-
-        # Delete File .env
-        Env.destroy()

tests/support/patterns/test_singleton.py

@@ -1,18 +0,0 @@
-from orionis.luminate.support.patterns.singleton import SingletonMeta
-from orionis.luminate.test import TestCase
-
-class TestsAsyncCoroutine(TestCase):
-
-    async def testSingletonMeta(self):
-        """
-        Test the SingletonMeta metaclass to ensure that only one instance of a class is created.
-        """
-        class SingletonClass(metaclass=SingletonMeta):
-            def __init__(self, value):
-                self.value = value
-
-        instance1 = SingletonClass(1)
-        instance2 = SingletonClass(2)
-
-        self.assertIs(instance1, instance2)
-        self.assertEqual(instance1.value, 1)