orionis 0.68.0__tar.gz → 0.70.0__tar.gz

{orionis-0.68.0/orionis.egg-info → orionis-0.70.0}/PKG-INFO

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

{orionis-0.68.0 → orionis-0.70.0}/orionis/framework.py

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

{orionis-0.68.0 → orionis-0.70.0}/orionis/luminate/app.py

@@ -1,33 +1,51 @@
-import json
 from orionis.luminate.container.container import Container
 from orionis.luminate.bootstrap.config_bootstrapper import ConfigBootstrapper
 from orionis.luminate.bootstrap.command_bootstrapper import CommandsBootstrapper
 from orionis.luminate.bootstrap.environment_bootstrapper import EnvironmentBootstrapper
 from orionis.luminate.patterns.singleton import SingletonMeta
+from orionis.luminate.providers.environment.environment_provider import EnvironmentProvider
 
 class Application(metaclass=SingletonMeta):
 
     def __init__(self):
 
+        # Atributos de la clase
         self._config = {}
         self._commands = {}
+        self._environment = {}
 
+        # Inicializar el contenedor de la aplicacion
         self.container = Container()
         self.container.instance(self.container)
+
+        # Cargar el servidor de entorno
+        self._loadServiceProviderEnvironment()
+
+        # Cargar dinamicamente la configurcion de la aplicacion.
         self._bootstraping()
 
+    def _loadServiceProviderEnvironment(self):
+
+        # Cargar el proveedor de entorno
+        _environment_provider = EnvironmentProvider(app=self.container)
+        _environment_provider.register()
+        _environment_provider.boot()
+
     def _bootstraping(self):
+
+        # Cargar la configuracion de la aplicacion
         config_bootstrapper_key = self.container.singleton(ConfigBootstrapper)
         config_bootstrapper: ConfigBootstrapper = self.container.make(config_bootstrapper_key)
         self._config = config_bootstrapper.get()
 
+        # Cargar los comandos propios y definidos por el desarrollador
         commands_bootstrapper_key = self.container.singleton(CommandsBootstrapper)
         commands_bootstrapper: CommandsBootstrapper = self.container.make(commands_bootstrapper_key)
         self._commands = commands_bootstrapper.get()
 
+        # Cargar las variables de entorno solo desde el archivo .env (No se carga desde el sistema operativo, por seguridad)
         environment_bootstrapper_key = self.container.singleton(EnvironmentBootstrapper)
         environment_bootstrapper: EnvironmentBootstrapper = self.container.make(environment_bootstrapper_key)
         self._environment = environment_bootstrapper.get()
 
-    def isBooted(self):
-        return True
+        print(self._config)

orionis-0.70.0/orionis/luminate/bootstrap/environment_bootstrapper.py

@@ -0,0 +1,76 @@
+from typing import Dict
+from orionis.contracts.bootstrap.i_environment_bootstrapper import IEnvironmentBootstrapper
+from orionis.luminate.facades.app import app
+from orionis.luminate.services.environment.environment_service import EnvironmentService
+
+class EnvironmentBootstrapper(IEnvironmentBootstrapper):
+    """
+    A class responsible for loading and managing environment variables from a `.env` file.
+
+    This class implements the `IEnvironment` interface and provides functionality to
+    automatically load environment variables from a `.env` file located in the current
+    working directory. If the file does not exist, it creates it.
+
+    Attributes
+    ----------
+    _environment_vars : Dict[str, str]
+        A dictionary to store the loaded environment variables.
+    path : Path
+        The path to the `.env` file.
+
+    Methods
+    -------
+    __init__()
+        Initializes the `EnvironmentBootstrapper` and triggers the autoload process.
+    _autoload()
+        Loads environment variables from the `.env` file or creates the file if it does not exist.
+    """
+
+    def __init__(self) -> None:
+        """
+        Initializes the `EnvironmentBootstrapper` and triggers the autoload process.
+
+        The `_environment_vars` dictionary is initialized to store environment variables,
+        and the `_autoload` method is called to load variables from the `.env` file.
+        """
+        self._environment_vars: Dict[str, str] = {}
+        self._autoload()
+
+    def _autoload(self) -> None:
+        """
+        Loads environment variables from the `.env` file or creates the file if it does not exist.
+
+        This method checks if the `.env` file exists in the current working directory.
+        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 = app(EnvironmentService)
+        self._environment_vars = environment_service.all()
+
+    def get(self, key: str = None) -> str:
+        """
+        Retrieves the value of an environment variable by its key.
+
+        Parameters
+        ----------
+        key : str
+            The key of the environment variable to retrieve.
+
+        Returns
+        -------
+        str
+            The value of the environment variable.
+
+        Raises
+        ------
+        KeyError
+            If the environment variable does not exist.
+        """
+
+        if not key:
+            return self._environment_vars
+
+        if key not in self._environment_vars:
+            raise KeyError(f"Environment variable {key} not found")
+
+        return self._environment_vars[key]

{orionis-0.68.0 → orionis-0.70.0}/orionis/luminate/services/environment/environment_service.py

@@ -1,5 +1,7 @@
+import ast
 import os
 from pathlib import Path
+from typing import Any
 from dotenv import set_key, unset_key, dotenv_values
 from orionis.contracts.services.environment.i_environment_service import IEnvironmentService
 
@@ -51,11 +53,16 @@ class EnvironmentService(IEnvironmentService):
         str
             The value of the environment variable or the default value.
         """
+
         # Get the value from the .env file
         value = dotenv_values(self.path).get(key)
 
-        # Return the value or the default value
-        return value if value is not None else os.getenv(key, default)
+        # Get the value from the system environment variables if not found
+        if value is None:
+            value = os.getenv(key)
+
+        # Parse the value and return it
+        return self._parse_value(value) if value is not None else default
 
     def set(self, key: str, value: str) -> None:
         """
@@ -93,4 +100,32 @@ class EnvironmentService(IEnvironmentService):
             A dictionary of all environment variables and their values.
         """
         # Return all environment variables
-        return dotenv_values(self.path)
+        env_vars = {}
+
+        # Get all environment variables from the .env file
+        data =  dotenv_values(self.path)
+        for key, value in data.items():
+            # Parse the value and add it to the dictionary
+            env_vars[key] = self._parse_value(value)
+
+        # Get all environment variables from the system environment variables
+        return env_vars
+
+    def _parse_value(self, value : Any):
+
+        # Strip leading and trailing whitespace from the value
+        value = str(value).strip() if value is not None else None
+
+        # Parse common types and Python literals
+        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)
+
+        # Attempt to parse Python literals (e.g., lists, dictionaries)
+        try:
+            return ast.literal_eval(value)
+        except (ValueError, SyntaxError):
+            return value

{orionis-0.68.0 → orionis-0.70.0/orionis.egg-info}/PKG-INFO

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

orionis-0.68.0/orionis/luminate/bootstrap/environment_bootstrapper.py

@@ -1,138 +0,0 @@
-import ast
-import os
-from pathlib import Path
-from typing import Dict
-from dotenv import dotenv_values
-from orionis.contracts.bootstrap.i_environment_bootstrapper import IEnvironmentBootstrapper
-from orionis.luminate.bootstrap.exception_bootstrapper import BootstrapRuntimeError
-
-class EnvironmentBootstrapper(IEnvironmentBootstrapper):
-    """
-    A class responsible for loading and managing environment variables from a `.env` file.
-
-    This class implements the `IEnvironment` interface and provides functionality to
-    automatically load environment variables from a `.env` file located in the current
-    working directory. If the file does not exist, it creates it.
-
-    Attributes
-    ----------
-    _environment_vars : Dict[str, str]
-        A dictionary to store the loaded environment variables.
-    path : Path
-        The path to the `.env` file.
-
-    Methods
-    -------
-    __init__()
-        Initializes the `EnvironmentBootstrapper` and triggers the autoload process.
-    _autoload()
-        Loads environment variables from the `.env` file or creates the file if it does not exist.
-    """
-
-    def __init__(self) -> None:
-        """
-        Initializes the `EnvironmentBootstrapper` and triggers the autoload process.
-
-        The `_environment_vars` dictionary is initialized to store environment variables,
-        and the `_autoload` method is called to load variables from the `.env` file.
-        """
-        self._environment_vars: Dict[str, str] = {}
-        self._autoload()
-
-    def _autoload(self) -> None:
-        """
-        Loads environment variables from the `.env` file or creates the file if it does not exist.
-
-        This method checks if the `.env` file exists in the current working directory.
-        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.
-
-        Raises
-        ------
-        PermissionError
-            If the `.env` file cannot be created or read due to insufficient permissions.
-        """
-        # Set the path to the `.env` file
-        path: Path = Path(os.getcwd()) / ".env"
-
-        # Create the `.env` file if it does not exist
-        if not path.exists():
-            try:
-                path.touch()  # Create an empty `.env` file if it does not exist
-            except PermissionError as e:
-                raise PermissionError(f"Cannot create `.env` file at {path}: {str(e)}")
-
-        try:
-            all_vars = dotenv_values(path)
-            for key, value in all_vars.items():
-                self._environment_vars[key] = self._parse_value(value)
-        except Exception as e:
-            raise BootstrapRuntimeError(f"Error loading environment variables from {path}: {str(e)}")
-
-    def _parse_value(self, value):
-        """
-        Parse and convert a string value into its appropriate Python data type.
-
-        This function handles conversion for common types such as `None`, booleans (`True`/`False`),
-        integers, and Python literals (e.g., lists, dictionaries). If the value cannot be parsed
-        into a specific type, it is returned as-is.
-
-        Parameters
-        ----------
-        value : str or None
-            The value to be parsed. If `None`, it is returned as `None`.
-
-        Returns
-        -------
-        any
-            The parsed value. Possible return types include:
-            - `None` if the value is empty, `None`, `'None'`, or `'null'`.
-            - `bool` if the value is `'True'`, `'true'`, `'False'`, or `'false'`.
-            - `int` if the value is a digit string (e.g., `'123'`).
-            - Python literals (e.g., lists, dictionaries) if the value can be evaluated as such.
-            - The original value if no conversion is applicable.
-        """
-        # Strip leading and trailing whitespace from the value
-        value = str(value).strip() if value is not None else None
-
-        # Parse common types and Python literals
-        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)
-
-        # Attempt to parse Python literals (e.g., lists, dictionaries)
-        try:
-            return ast.literal_eval(value)
-        except (ValueError, SyntaxError):
-            return value
-
-    def get(self, key: str = None) -> str:
-        """
-        Retrieves the value of an environment variable by its key.
-
-        Parameters
-        ----------
-        key : str
-            The key of the environment variable to retrieve.
-
-        Returns
-        -------
-        str
-            The value of the environment variable.
-
-        Raises
-        ------
-        KeyError
-            If the environment variable does not exist.
-        """
-
-        if not key:
-            return self._environment_vars
-
-        if key not in self._environment_vars:
-            raise KeyError(f"Environment variable {key} not found")
-
-        return self._environment_vars[key]