orionis 0.223.0__tar.gz → 0.225.0__tar.gz

{orionis-0.223.0/orionis.egg-info → orionis-0.225.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: orionis
-Version: 0.223.0
+Version: 0.225.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.223.0 → orionis-0.225.0}/orionis/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.223.0"
+VERSION = "0.225.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

{orionis-0.223.0 → orionis-0.225.0}/orionis/luminate/application.py

@@ -9,8 +9,7 @@ from orionis.luminate.foundation.console.command_bootstrapper import CommandsBoo
 from orionis.luminate.foundation.environment.environment_bootstrapper import EnvironmentBootstrapper
 from orionis.luminate.foundation.exceptions.exception_bootstrapper import BootstrapRuntimeError
 from orionis.luminate.foundation.providers.service_providers_bootstrapper import ServiceProvidersBootstrapper
-from orionis.luminate.patterns.singleton import SingletonMeta
-from orionis.luminate.support.async.async_io import AsyncExecutor
+from orionis.luminate.support.patterns.singleton import SingletonMeta
 
 class Application(metaclass=SingletonMeta):
     """
@@ -156,7 +155,7 @@ class Application(metaclass=SingletonMeta):
         """
         self._bootstrapping()
         self._loadCommands()
-        AsyncExecutor.run(self._bootServiceProviders())
+        # AsyncExecutor.run(self._bootServiceProviders())
         Application.boot()
 
     async def _bootServiceProviders(self) -> None:

{orionis-0.223.0 → orionis-0.225.0}/orionis/luminate/container/resolve.py

@@ -1,7 +1,6 @@
 from typing import Any, Callable
 from orionis.luminate.container.container import Container
 from orionis.luminate.container.exception import OrionisContainerValueError
-from orionis.luminate.support.async.async_io import AsyncExecutor
 
 class Resolve:
     """
@@ -62,4 +61,4 @@ class Resolve:
             )
 
         # Resolve and return the service associated with the abstract or alias
-        return AsyncExecutor.run(container.make(abstract_or_alias))
+        # return AsyncExecutor.run(container.make(abstract_or_alias))

{orionis-0.223.0 → orionis-0.225.0}/orionis/luminate/foundation/environment/environment_bootstrapper.py

@@ -1,6 +1,7 @@
 from typing import Dict
 from orionis.luminate.contracts.foundation.environment.environment_bootstrapper import IEnvironmentBootstrapper
-from orionis.luminate.services.environment.environment_service import EnvironmentService
+from orionis.luminate.support.environment.env import Env
+# from orionis.luminate.services.environment.environment_service import EnvironmentService
 
 class EnvironmentBootstrapper(IEnvironmentBootstrapper):
     """
@@ -43,7 +44,7 @@ class EnvironmentBootstrapper(IEnvironmentBootstrapper):
         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.
         """
-        environment_service = EnvironmentService()
+        environment_service =Env()
         self._environment_vars = environment_service.all()
 
     def get(self, key: str = None) -> str:

orionis-0.225.0/orionis/luminate/support/environment/env.py

@@ -0,0 +1,104 @@
+import os
+from typing import Any, Optional, Union
+from dotenv import set_key, unset_key, dotenv_values
+from orionis.luminate.support.environment.functions import (
+    _initialize,
+    _parse_value,
+    _serialize_value,
+)
+
+class Env:
+    """
+    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

orionis-0.225.0/orionis/luminate/support/environment/functions.py

@@ -0,0 +1,41 @@
+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)

orionis-0.225.0/orionis/luminate/support/environment/helper.py

@@ -0,0 +1,26 @@
+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-0.225.0/orionis/luminate/support/paths/contracts/resolver.py

@@ -0,0 +1,67 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+class IResolver(ABC):
+    """
+    Interface for a utility class that resolves file and directory paths relative to a base path.
+    """
+
+    @abstractmethod
+    def __init__(self, root_path: Optional[str] = None):
+        """
+        Initializes the resolver with an optional root path.
+
+        Parameters
+        ----------
+        root_path : str, optional
+            The root directory to resolve relative paths from.
+        """
+        pass
+
+    @abstractmethod
+    def relativePath(self, relative_path: str):
+        """
+        Resolves a relative path into an absolute one and validates its existence.
+
+        Parameters
+        ----------
+        relative_path : str
+            The relative path to resolve.
+
+        Returns
+        -------
+        ResolverInterface
+            The instance itself for method chaining.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the resolved path does not exist.
+        ValueError
+            If the resolved path is neither a file nor a directory.
+        """
+        pass
+
+    @abstractmethod
+    def toString(self) -> str:
+        """
+        Returns the resolved path as a string.
+
+        Returns
+        -------
+        str
+            The resolved path.
+        """
+        pass
+
+    @abstractmethod
+    def __str__(self) -> str:
+        """
+        Returns the resolved path as a string (for print or str()).
+
+        Returns
+        -------
+        str
+            The resolved path.
+        """
+        pass

orionis-0.225.0/orionis/luminate/support/paths/resolver.py

@@ -0,0 +1,83 @@
+import os
+from pathlib import Path
+from orionis.luminate.support.paths.contracts.resolver import IResolver
+
+class Resolver(IResolver):
+    """
+    A utility class for resolving file and directory paths relative to the project's root directory.
+    """
+
+    def __init__(self, root_path: str = None):
+        """
+        Initializes the Resolver instance with the project's root directory.
+
+        Parameters
+        ----------
+        root_path : str, optional
+            The root directory of the project. If not provided, it defaults to the current working directory.
+        """
+        self.base_path = Path(root_path).resolve() if root_path else Path(os.getcwd()).resolve()
+        self.resolved_path = None
+
+    def relativePath(self, relative_path: str) -> 'Resolver':
+        """
+        Resolves a given relative path to an absolute path and validates its existence.
+
+        This method combines the project's root directory with the provided relative path,
+        resolves it to an absolute path, and ensures it exists as either a directory or a file.
+
+        Parameters
+        ----------
+        relative_path : str
+            The relative path to a directory or file to be resolved.
+
+        Returns
+        -------
+        Resolver
+            The current instance of the Resolver class with the resolved path.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the resolved path does not exist.
+        ValueError
+            If the resolved path is neither a valid directory nor a file.
+        """
+        # Combine the base path with the relative path and resolve it
+        resolved_path = (self.base_path / relative_path).resolve()
+
+        # Validate that the path exists
+        if not resolved_path.exists():
+            raise FileNotFoundError(f"The requested path does not exist: {resolved_path}")
+
+        # Validate that the path is either a directory or a file
+        if not (resolved_path.is_dir() or resolved_path.is_file()):
+            raise ValueError(f"The requested path is neither a valid directory nor a file: {resolved_path}")
+
+        # Store the resolved path in the instance variable
+        self.resolved_path = resolved_path
+
+        # Return the current instance
+        return self
+
+    def toString(self) -> str:
+        """
+        Returns the string representation of the resolved path.
+
+        Returns
+        -------
+        str
+            The resolved path as a string.
+        """
+        return str(self.resolved_path)
+
+    def __str__(self) -> str:
+        """
+        Returns the string representation of the resolved path.
+
+        Returns
+        -------
+        str
+            The resolved path as a string.
+        """
+        return str(self.resolved_path)

{orionis-0.223.0 → orionis-0.225.0/orionis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: orionis
-Version: 0.223.0
+Version: 0.225.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.223.0 → orionis-0.225.0}/orionis.egg-info/SOURCES.txt

@@ -161,10 +161,6 @@ orionis/luminate/services/commands/reactor_commands_service.py
 orionis/luminate/services/commands/scheduler_service.py
 orionis/luminate/services/config/__init__.py
 orionis/luminate/services/config/config_service.py
-orionis/luminate/services/environment/__init__.py
-orionis/luminate/services/environment/environment_service.py
-orionis/luminate/services/files/__init__.py
-orionis/luminate/services/files/path_resolver_service.py
 orionis/luminate/services/log/__init__.py
 orionis/luminate/services/log/log_service.py
 orionis/luminate/support/__init__.py
@@ -172,7 +168,12 @@ orionis/luminate/support/adapters/__init__.py
 orionis/luminate/support/adapters/dot_dict.py
 orionis/luminate/support/asynchrony/__init__.py
 orionis/luminate/support/asynchrony/async_io.py
+orionis/luminate/support/asynchrony/contracts/__init__.py
 orionis/luminate/support/asynchrony/contracts/async_coroutine.py
+orionis/luminate/support/environment/__init__.py
+orionis/luminate/support/environment/env.py
+orionis/luminate/support/environment/functions.py
+orionis/luminate/support/environment/helper.py
 orionis/luminate/support/inspection/__init__.py
 orionis/luminate/support/inspection/container_integrity.py
 orionis/luminate/support/inspection/functions.py
@@ -191,6 +192,10 @@ orionis/luminate/support/parsers/__init__.py
 orionis/luminate/support/parsers/exception_parser.py
 orionis/luminate/support/parsers/contracts/__init__.py
 orionis/luminate/support/parsers/contracts/exception_parser.py
+orionis/luminate/support/paths/__init__.py
+orionis/luminate/support/paths/resolver.py
+orionis/luminate/support/paths/contracts/__init__.py
+orionis/luminate/support/paths/contracts/resolver.py
 orionis/luminate/support/patterns/__init__.py
 orionis/luminate/support/patterns/singleton.py
 orionis/luminate/support/standard/__init__.py
@@ -228,6 +233,9 @@ tests/support/adapters/fakes/__init__.py
 tests/support/adapters/fakes/fake_dict.py
 tests/support/async_io/__init__.py
 tests/support/async_io/test_async_coroutine.py
+tests/support/environment/__init__.py
+tests/support/environment/test_env.py
+tests/support/environment/test_helper.py
 tests/support/inspection/__init__.py
 tests/support/inspection/test_reflection_abstract.py
 tests/support/inspection/test_reflection_concrete.py
@@ -244,6 +252,8 @@ tests/support/parsers/__init__.py
 tests/support/parsers/test_exception_parser.py
 tests/support/parsers/fakes/__init__.py
 tests/support/parsers/fakes/fake_custom_error.py
+tests/support/path/__init__.py
+tests/support/path/test_resolver.py
 tests/support/patterns/__init__.py
 tests/support/patterns/test_singleton.py
 tests/support/standard/__init__.py

orionis-0.225.0/tests/support/environment/test_env.py

@@ -0,0 +1,64 @@
+from orionis.luminate.support.environment.env import Env
+from orionis.luminate.test.test_case 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)
+
+    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')
+
+    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)
+
+    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')
+
+        Env.unset('KEY1')
+        Env.unset('KEY2')

orionis-0.225.0/tests/support/environment/test_helper.py

@@ -0,0 +1,11 @@
+from orionis.luminate.support.environment.helper import env
+from orionis.luminate.test.test_case import TestCase
+
+class TestsEnvironmentHelper(TestCase):
+
+    async def testGetEnvHelper(self):
+        """"
+        Test retrieving an environment variable using the env helper.
+        """
+        result = env('FRAMEWORK')
+        self.assertEqual(result, 'https://github.com/orionis-framework/framework')

orionis-0.225.0/tests/support/path/test_resolver.py

@@ -0,0 +1,33 @@
+from orionis.luminate.support.paths.resolver import Resolver
+from orionis.luminate.test.test_case import TestCase
+
+class TestsResolver(TestCase):
+
+    async def testFileNotFound(self):
+        """
+        Test the Resolver class for a non-existent file path.
+        """
+        file_path = "non_existent_file.txt"
+        with self.assertRaises(FileNotFoundError):
+            Resolver().relativePath(file_path)
+
+    async def testValidFilePath(self):
+        """
+        Test the Resolver class for a valid file path.
+        """
+        path = Resolver().relativePath('orionis/luminate/test/test_suite.py').toString()
+        self.assertTrue(path.endswith('test_suite.py'))
+
+    async def testOtherBasePath(self):
+        """
+        Test the Resolver class for a different base path.
+        """
+        path = Resolver('orionis/luminate/test').relativePath('test_suite.py').toString()
+        self.assertTrue(path.endswith('test_suite.py'))
+
+    async def testEqualOutputString(self):
+        """
+        Test the Resolver class for a string representation of the resolved path.
+        """
+        path = Resolver().relativePath('orionis/luminate/test/test_suite.py')
+        self.assertEqual(path.toString(), str(path))