orionis 0.254.0__tar.gz → 0.255.0__tar.gz

{orionis-0.254.0/orionis.egg-info → orionis-0.255.0}/PKG-INFO

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

{orionis-0.254.0 → orionis-0.255.0}/orionis/framework.py

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

{orionis-0.254.0 → orionis-0.255.0}/orionis/luminate/app.py

@@ -1,4 +1,4 @@
-from orionis.luminate.foundation.config.configuration import Configuration
+from orionis.luminate.foundation.config.startup import Configuration
 
 class Orionis:
 

{orionis-0.254.0 → orionis-0.255.0}/orionis/luminate/console/output/console.py

@@ -4,7 +4,7 @@ import os
 import sys
 from orionis.luminate.console.output.styles import ANSIColors
 from orionis.luminate._contracts.console.output.console import IConsole
-from orionis.luminate.support.parsers.exception_parser import ExceptionParser
+from orionis.luminate.services.parsers.serializer import Parser
 
 class Console(IConsole):
     """
@@ -533,7 +533,7 @@ class Console(IConsole):
         This method prints the exception type, message, and a detailed stack trace.
         """
 
-        errors = ExceptionParser(e).toDict()
+        errors = Parser.exception(e).toDict()
         error_type = str(errors.get("error_type")).split(".")[-1]
         error_message = str(errors.get("error_message")).replace(error_type, "").replace("[]", "").strip()
         stack_trace = errors.get("stack_trace")

orionis-0.255.0/orionis/luminate/services/asynchrony/async_io.py

@@ -0,0 +1,31 @@
+import asyncio
+from typing import Any, Coroutine, TypeVar, Union
+
+T = TypeVar("T")
+
+def run_coroutine(coro: Coroutine[Any, Any, T]) -> Union[T, asyncio.Future]:
+    """
+    Executes the given coroutine object, adapting to the current execution context.
+    If there is an active event loop, it uses `asyncio.ensure_future` to schedule the coroutine.
+    If there is no active event loop, it uses `asyncio.run` to run the coroutine directly.
+    If the coroutine is already running, it returns a `Future` object that can be awaited.
+
+    Parameters
+    ----------
+    coro : Coroutine[Any, Any, T]
+        The coroutine object
+    """
+    from inspect import iscoroutine
+
+    if not iscoroutine(coro):
+        raise TypeError("Expected a coroutine object.")
+
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)
+
+    if loop.is_running():
+        return asyncio.ensure_future(coro)
+    else:
+        return loop.run_until_complete(coro)

{orionis-0.254.0 → orionis-0.255.0}/orionis/luminate/services/environment/contracts/env.py

@@ -59,17 +59,6 @@ class IEnv(ABC):
         """
         pass
 
-    @staticmethod
-    @abstractmethod
-    def destroy() -> bool:
-        """
-        Clears the entire environment.
-
-        Returns:
-            True if successful, False otherwise
-        """
-        pass
-
     @staticmethod
     @abstractmethod
     def toJson() -> str:

orionis-0.255.0/orionis/luminate/services/environment/dot_env.py

@@ -0,0 +1,217 @@
+import os
+import ast
+import threading
+from pathlib import Path
+from typing import Any, Optional, Union
+from dotenv import dotenv_values, load_dotenv, set_key, unset_key
+from orionis.luminate.patterns.singleton.meta_class import Singleton
+
+class DotEnv(metaclass=Singleton):
+    """
+    DotEnv is a singleton class for managing environment variables using a `.env` file.
+    This class provides methods to load, get, set, unset, and list environment variables,
+    with automatic serialization and deserialization of common Python data types.
+    It ensures that changes to the `.env` file are reflected in the current process's
+    environment variables and vice versa.
+    """
+
+    _lock = threading.RLock()
+
+    def __init__(self, path: str = None) -> None:
+        """
+        Initializes the environment service by resolving the path to the `.env` file, ensuring its existence,
+        and loading environment variables from it.
+        Args:
+            path (str, optional): The path to the `.env` file. If not provided, defaults to a `.env` file
+                in the current working directory.
+        Raises:
+            OSError: If the `.env` file cannot be created when it does not exist.
+        """
+
+        with self._lock:
+            if path:
+                self._resolved_path = Path(path).expanduser().resolve()
+            else:
+                self._resolved_path = Path(os.getcwd()) / ".env"
+
+            if not self._resolved_path.exists():
+                self._resolved_path.touch()
+
+            load_dotenv(self._resolved_path)
+
+    def get(self, key: str, default: Optional[Any] = None) -> Any:
+        """
+        Retrieve the value of an environment variable by key.
+
+        This method first attempts to fetch the value from the dotenv file specified by
+        `self._resolved_path`. If the key is not found in the dotenv file, it falls back
+        to the system environment variables. If the key is not found in either location,
+        the provided `default` value is returned.
+
+        The returned value is parsed using the internal `__parseValue` method if found.
+
+        Args:
+            key (str): The name of the environment variable to retrieve.
+            default (Optional[Any], optional): The value to return if the key is not found.
+                Defaults to None.
+
+        Returns:
+            Any: The parsed value of the environment variable, or the default if not found.
+        """
+        with self._lock:
+            value = dotenv_values(self._resolved_path).get(key)
+            if value is None:
+                value = os.getenv(key)
+            return self.__parseValue(value) if value is not None else default
+
+    def set(self, key: str, value: Union[str, int, float, bool, list, dict]) -> bool:
+        """
+        Sets an environment variable with the specified key and value.
+
+        This method serializes the given value and updates both the .env file and the current process's environment variables.
+
+        Args:
+            key (str): The name of the environment variable to set.
+            value (Union[str, int, float, bool, list, dict]): The value to assign to the environment variable. Supported types include string, integer, float, boolean, list, and dictionary.
+
+        Returns:
+            bool: True if the environment variable was successfully set.
+        """
+        with self._lock:
+            serialized_value = self.__serializeValue(value)
+            set_key(str(self._resolved_path), key, serialized_value)
+            os.environ[key] = str(value)
+            return True
+
+    def unset(self, key: str) -> bool:
+        """
+        Removes the specified environment variable from both the .env file and the current process environment.
+
+        Args:
+            key (str): The name of the environment variable to unset.
+
+        Returns:
+            bool: True if the operation was successful.
+        """
+        with self._lock:
+            unset_key(str(self._resolved_path), key)
+            os.environ.pop(key, None)
+            return True
+
+    def all(self) -> dict:
+        """
+        Retrieves all environment variables from the resolved .env file.
+
+        Returns:
+            dict: A dictionary containing all environment variable key-value pairs,
+                  with values parsed using the internal __parseValue method.
+        """
+        with self._lock:
+            raw_values = dotenv_values(self._resolved_path)
+            return {k: self.__parseValue(v) for k, v in raw_values.items()}
+
+    def toJson(self) -> str:
+        """
+        Serializes all environment variables managed by this instance to a JSON-formatted string.
+
+        Returns:
+            str: A JSON string representation of all environment variables, formatted with indentation for readability.
+        """
+        import json
+        with self._lock:
+            return json.dumps(self.all(), indent=4)
+
+    def toBase64(self) -> str:
+        """
+        Serializes all environment variables to a JSON string and encodes it in Base64.
+
+        Returns:
+            str: A Base64-encoded string representation of all environment variables.
+        """
+        import base64
+        import json
+        with self._lock:
+            return base64.b64encode(json.dumps(self.all()).encode()).decode()
+
+    def __parseValue(self, value: Any) -> Any:
+        """
+        Parses and converts the input value to an appropriate Python data type.
+
+        Args:
+            value (Any): The value to parse and convert.
+
+        Returns:
+            Any: The parsed value, which may be of type None, bool, int, float, or the original string.
+                - Returns None for None, empty strings, or strings like 'none', 'null', 'nan' (case-insensitive).
+                - Returns a boolean for 'true'/'false' strings (case-insensitive).
+                - Returns an int if the string represents an integer.
+                - Returns a float if the string represents a float.
+                - Attempts to evaluate the string as a Python literal (e.g., list, dict, tuple).
+                - Returns the original string if no conversion is possible.
+        """
+        if value is None:
+            return None
+        if isinstance(value, (bool, int, float)):
+            return value
+        value_str = str(value).strip()
+        if not value_str or value_str.lower() in {'none', 'null', 'nan'}:
+            return None
+        if value_str.lower() == 'true':
+            return True
+        if value_str.lower() == 'false':
+            return False
+        try:
+            if value_str.isdigit() or (value_str.startswith('-') and value_str[1:].isdigit()):
+                return int(value_str)
+        except Exception:
+            pass
+        try:
+            float_val = float(value_str)
+            if '.' in value_str or 'e' in value_str.lower():
+                return float_val
+        except Exception:
+            pass
+        try:
+            return ast.literal_eval(value_str)
+        except Exception:
+            pass
+        return value_str
+
+    def __serializeValue(self, value: Any) -> str:
+        """
+        Serializes a given value to a string suitable for storage in a .env file.
+
+        Parameters:
+            value (Any): The value to serialize. Supported types are None, str, bool, int, float, list, and dict.
+
+        Returns:
+            str: The serialized string representation of the value.
+
+        Raises:
+            ValueError: If a float value is in scientific notation.
+            TypeError: If the value's type is not serializable for .env files.
+        """
+        if value is None:
+            return "None"
+        if isinstance(value, str):
+            return value
+        if isinstance(value, bool):
+            return str(value).lower()
+        if isinstance(value, int):
+            return str(value)
+        if isinstance(value, float):
+            value = str(value)
+            if 'e' in value or 'E' in value:
+                raise ValueError('scientific notation is not supported, use a string instead')
+            return value
+        if isinstance(value, (list, dict)):
+            return repr(value)
+        if hasattr(value, '__dict__'):
+            raise TypeError(f"Type {type(value).__name__} is not serializable for .env")
+        if not isinstance(value, (list, dict, bool, int, float, str)):
+            raise TypeError(f"Type {type(value).__name__} is not serializable for .env")
+        if isinstance(value, (list, dict, bool, int, float, str)):
+            if type(value).__module__ != "builtins" and not isinstance(value, str):
+                raise TypeError(f"Type {type(value).__name__} is not serializable for .env")
+            return repr(value) if not isinstance(value, str) else value
+        raise TypeError(f"Type {type(value).__name__} is not serializable for .env")

{orionis-0.254.0 → orionis-0.255.0}/orionis/luminate/services/environment/env.py

@@ -51,17 +51,6 @@ class Env(IEnv):
         """
         return Env._dotenv().all()
 
-    @staticmethod
-    def destroy() -> bool:
-        """
-        Destroys the current environment by resetting the DotEnv instance.
-        """
-        if Env._dotenv_instance is not None:
-            result = Env._dotenv_instance.destroy()
-            Env._dotenv_instance = None
-            return result
-        return False
-
     @staticmethod
     def toJson() -> str:
         """

orionis-0.255.0/orionis/luminate/services/introspection/dependencies/entities/class_dependencies.py

@@ -0,0 +1,59 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from orionis.luminate.support.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
+
+@dataclass(frozen=True, kw_only=True)
+class ClassDependency:
+    """
+    Represents the dependencies of a class, separating resolved and unresolved dependencies.
+
+    Attributes:
+        resolved (Dict[ResolvedDependency, Any]):
+            A dictionary mapping resolved dependency descriptors to their corresponding resolved instances or values.
+            All keys must be ResolvedDependency instances.
+        unresolved (List[str]):
+            A list of dependency names or identifiers that could not be resolved.
+            Must contain only strings.
+    """
+    resolved: Dict[ResolvedDependency, Any]
+    unresolved: List[str]
+
+    def __post_init__(self):
+        """
+        Validates types of attributes during initialization.
+
+        Raises:
+            TypeError: If types don't match the expected:
+                - resolved: Dict[ResolvedDependency, Any]
+                - unresolved: List[str]
+            ValueError: If resolved contains None keys or unresolved contains empty strings
+        """
+        # Validate 'resolved' is a dict with ResolvedDependency keys
+        if not isinstance(self.resolved, dict):
+            raise TypeError(
+                f"'resolved' must be a dict, got {type(self.resolved).__name__}"
+            )
+
+        for key in self.resolved:
+            if not isinstance(key, ResolvedDependency):
+                raise TypeError(
+                    f"All keys in 'resolved' must be ResolvedDependency, "
+                    f"found {type(key).__name__}"
+                )
+            if key is None:
+                raise ValueError("'resolved' cannot contain None keys")
+
+        # Validate 'unresolved' is a list of non-empty strings
+        if not isinstance(self.unresolved, list):
+            raise TypeError(
+                f"'unresolved' must be a list, got {type(self.unresolved).__name__}"
+            )
+
+        for item in self.unresolved:
+            if not isinstance(item, str):
+                raise TypeError(
+                    f"All items in 'unresolved' must be str, "
+                    f"found {type(item).__name__}"
+                )
+            if not item.strip():
+                raise ValueError("'unresolved' cannot contain empty strings")

orionis-0.255.0/orionis/luminate/services/introspection/dependencies/entities/method_dependencies.py

@@ -0,0 +1,64 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from orionis.luminate.support.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
+
+@dataclass(frozen=True, kw_only=True)
+class MethodDependency:
+    """
+    Represents the dependencies of a method, separating resolved and unresolved dependencies.
+
+    Attributes:
+        resolved (Dict[ResolvedDependency, Any]):
+            A dictionary mapping resolved dependency descriptors to their corresponding
+            resolved instances or values for the method.
+            All keys must be ResolvedDependency instances.
+        unresolved (List[str]):
+            A list of method parameter names or dependency identifiers that could not be resolved.
+            Must contain only non-empty strings.
+    """
+    resolved: Dict[ResolvedDependency, Any]
+    unresolved: List[str]
+
+    def __post_init__(self):
+        """
+        Validates types and values of attributes during initialization.
+
+        Raises:
+            TypeError: If types don't match the expected:
+                - resolved: Dict[ResolvedDependency, Any]
+                - unresolved: List[str]
+            ValueError: If resolved contains None keys or unresolved contains empty strings
+        """
+        # Validate 'resolved' is a dict with proper key types
+        if not isinstance(self.resolved, dict):
+            raise TypeError(
+                f"'resolved' must be a dict, got {type(self.resolved).__name__}"
+            )
+
+        for dependency in self.resolved:
+            if not isinstance(dependency, ResolvedDependency):
+                raise TypeError(
+                    f"All keys in 'resolved' must be ResolvedDependency instances, "
+                    f"found {type(dependency).__name__}"
+                )
+            if dependency is None:
+                raise ValueError("'resolved' cannot contain None keys")
+
+        # Validate 'unresolved' is a list of valid parameter names
+        if not isinstance(self.unresolved, list):
+            raise TypeError(
+                f"'unresolved' must be a list, got {type(self.unresolved).__name__}"
+            )
+
+        for param in self.unresolved:
+            if not isinstance(param, str):
+                raise TypeError(
+                    f"All items in 'unresolved' must be strings, "
+                    f"found {type(param).__name__}"
+                )
+            if not param.strip():
+                raise ValueError("'unresolved' cannot contain empty parameter names")
+            if not param.isidentifier():
+                raise ValueError(
+                    f"Parameter name '{param}' must be a valid Python identifier"
+                )

orionis-0.255.0/orionis/luminate/services/introspection/dependencies/entities/resolved_dependencies.py

@@ -0,0 +1,60 @@
+from dataclasses import dataclass
+from typing import Type, Any
+
+@dataclass(frozen=True, kw_only=True)
+class ResolvedDependency:
+    """
+    Represents a fully resolved dependency with complete type information.
+
+    Attributes:
+        module_name (str):
+            The name of the module where the dependency is defined.
+            Must be a non-empty string without spaces.
+        class_name (str):
+            The name of the class/type being resolved.
+            Must be a valid Python identifier.
+        type (Type):
+            The actual Python type object of the resolved dependency.
+        full_class_path (str):
+            The full import path to the class (e.g., 'package.module.ClassName').
+            Must match 'module_name.class_name' pattern.
+    """
+    module_name: str
+    class_name: str
+    type: Type[Any]
+    full_class_path: str
+
+    def __post_init__(self):
+        """
+        Validates all fields during initialization.
+
+        Raises:
+            TypeError: If any field has incorrect type.
+            ValueError: If string fields are empty or don't meet format requirements.
+        """
+        # Validate module_name
+        if not isinstance(self.module_name, str):
+            raise TypeError(f"module_name must be str, got {type(self.module_name).__name__}")
+        if not self.module_name:
+            raise ValueError("module_name cannot be empty")
+        if any(c.isspace() for c in self.module_name):
+            raise ValueError("module_name cannot contain whitespace")
+
+        # Validate class_name
+        if not isinstance(self.class_name, str):
+            raise TypeError(f"class_name must be str, got {type(self.class_name).__name__}")
+        if not self.class_name.isidentifier():
+            raise ValueError(f"class_name must be valid Python identifier, got '{self.class_name}'")
+
+        # Validate type
+        if not isinstance(self.type, type):
+            raise TypeError(f"type must be a type object, got {type(self.type).__name__}")
+
+        # Validate full_class_path
+        if not isinstance(self.full_class_path, str):
+            raise TypeError(f"full_class_path must be str, got {type(self.full_class_path).__name__}")
+        expected_path = f"{self.module_name}.{self.class_name}"
+        if self.full_class_path != expected_path:
+            raise ValueError(
+                f"full_class_path must be '{expected_path}', got '{self.full_class_path}'"
+            )

{orionis-0.254.0/orionis/luminate/support → orionis-0.255.0/orionis/luminate/services}/introspection/dependencies/reflect_dependencies.py

@@ -1,9 +1,9 @@
 import inspect
 from typing import Any, Dict, List
-from orionis.luminate.support.introspection.dependencies.contracts.reflect_dependencies import IReflectDependencies
-from orionis.luminate.support.introspection.dependencies.entities.class_dependencies import ClassDependency
-from orionis.luminate.support.introspection.dependencies.entities.method_dependencies import MethodDependency
-from orionis.luminate.support.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
+from orionis.luminate.services.introspection.dependencies.contracts.reflect_dependencies import IReflectDependencies
+from orionis.luminate.services.introspection.dependencies.entities.class_dependencies import ClassDependency
+from orionis.luminate.services.introspection.dependencies.entities.method_dependencies import MethodDependency
+from orionis.luminate.services.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
 
 class ReflectDependencies(IReflectDependencies):
     """

orionis-0.254.0/orionis/luminate/support/parsers/exception_parser.py → orionis-0.255.0/orionis/luminate/services/parsers/exception.py

@@ -1,6 +1,6 @@
 import traceback
 from typing import Any, Dict, List, Optional, Union
-from orionis.luminate.support.parsers.contracts.exception_parser import IExceptionParser
+from orionis.luminate.services.parsers.contracts.exception_parser import IExceptionParser
 
 class ExceptionParser(IExceptionParser):
     """

orionis-0.255.0/orionis/luminate/services/parsers/serializer.py

@@ -0,0 +1,15 @@
+from orionis.luminate.services.parsers.exception import ExceptionParser
+
+class Parser:
+
+    @staticmethod
+    def exception(exception: Exception) -> ExceptionParser:
+        """
+        Creates and returns an ExceptionParser instance for the given exception.
+        Args:
+            exception (Exception): The exception to be parsed.
+        Returns:
+            ExceptionParser: An instance of ExceptionParser initialized with the provided exception.
+        """
+
+        return ExceptionParser(exception)

{orionis-0.254.0 → orionis-0.255.0}/orionis/luminate/services/paths/resolver.py

@@ -1,6 +1,6 @@
 import os
 from pathlib import Path
-from orionis.luminate.support.paths.contracts.resolver import IResolver
+from orionis.luminate.services.paths.contracts.resolver import IResolver
 
 class Resolver(IResolver):
     """

{orionis-0.254.0/orionis/luminate/support → orionis-0.255.0/orionis/luminate/services}/standard/std.py

@@ -1,4 +1,4 @@
-from orionis.luminate.support.standard.contracts.std import IStdClass
+from orionis.luminate.services.standard.contracts.std import IStdClass
 
 class StdClass(IStdClass):
     """

orionis-0.255.0/orionis/luminate/services/system/contracts/imports.py

@@ -0,0 +1,31 @@
+from abc import ABC, abstractmethod
+
+class IImports(ABC):
+    """
+    Interface for a utility to collect and display information about currently loaded Python modules.
+    """
+
+    @abstractmethod
+    def collect(self):
+        """
+        Collects information about user-defined Python modules currently loaded in sys.modules.
+        Returns:
+            IImports: The current instance with updated imports information.
+        """
+        pass
+
+    @abstractmethod
+    def display(self) -> None:
+        """
+        Displays a formatted table of collected import statements.
+        Returns:
+            None
+        """
+        pass
+
+    @abstractmethod
+    def clear(self) -> None:
+        """
+        Clears the collected imports list.
+        """
+        pass