orionis 0.246.0__py3-none-any.whl → 0.248.0__py3-none-any.whl

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,139 +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
-)
-from orionis.luminate.support.patterns.singleton import SingletonMeta
-
-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)