orionis 0.331.0__tar.gz → 0.333.0__tar.gz

{orionis-0.331.0/orionis.egg-info → orionis-0.333.0}/PKG-INFO

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

{orionis-0.331.0 → orionis-0.333.0}/orionis/metadata/framework.py

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

{orionis-0.331.0 → orionis-0.333.0}/orionis/services/asynchrony/coroutines.py

@@ -1,8 +1,8 @@
 import asyncio
-from inspect import iscoroutine
 from typing import Any, Coroutine as TypingCoroutine, TypeVar, Union
 from orionis.services.asynchrony.contracts.coroutines import ICoroutine
 from orionis.services.asynchrony.exceptions.coroutine_exception import OrionisCoroutineException
+from orionis.services.introspection.inspection import Inspection
 
 T = TypeVar("T")
 
@@ -36,10 +36,12 @@ class Coroutine(ICoroutine):
         OrionisCoroutineException
             If the provided object is not a coroutine.
         """
-        if not iscoroutine(func):
+        if not Inspection(func).isCoroutine():
             raise OrionisCoroutineException(
                 f"Expected a coroutine object, but got {type(func).__name__}."
             )
+
+        # Store the coroutine function
         self.__func = func
 
     def run(self) -> Union[T, asyncio.Future]:
@@ -57,15 +59,21 @@ class Coroutine(ICoroutine):
         - If called from within an event loop, it will schedule the coroutine and return a Future.
         """
         try:
+
             # Get the current event loop
             loop = asyncio.get_running_loop()
+
         except RuntimeError:
+
             # No running event loop, run synchronously
             return asyncio.run(self.__func)
 
         if loop.is_running():
+
             # Inside an event loop, schedule as a Future
             return asyncio.ensure_future(self.__func)
+
         else:
+
             # No running loop, run synchronously
             return loop.run_until_complete(self.__func)

{orionis-0.331.0 → orionis-0.333.0}/orionis/services/environment/dot_env.py

@@ -45,45 +45,6 @@ class DotEnv(metaclass=Singleton):
         except OSError as e:
             raise OSError(f"Failed to create or access the .env file at {self._resolved_path}: {e}")
 
-    def get(self, key: str, default: Optional[Any] = None) -> Any:
-        """
-        Get the value of an environment variable.
-
-        Parameters
-        ----------
-        key : str
-            Name of the environment variable to retrieve.
-        default : Any, optional
-            Value to return if the key is not found. Default is None.
-
-        Returns
-        -------
-        Any
-            Parsed value of the environment variable, or `default` if not found.
-
-        Raises
-        ------
-        OrionisEnvironmentValueError
-            If `key` is not a string.
-        """
-        with self._lock:
-
-            # Ensure the key is a string.
-            if not isinstance(key, str):
-                raise OrionisEnvironmentValueError(
-                    f"Key must be a string, got {type(key).__name__}."
-                )
-
-            # Get the value from the .env file or the current environment.
-            value = dotenv_values(self._resolved_path).get(key)
-
-            # If the value is not found in the .env file, check the current environment variables.
-            if value is None:
-                value = os.getenv(key)
-
-            # Parse the value using the internal __parseValue method and return it
-            return self.__parseValue(value) if value is not None else default
-
     def __parseValue(self, value: Any) -> Any:
         """
         Parse and convert the input value to an appropriate Python data type with enhanced features.
@@ -142,6 +103,85 @@ class DotEnv(metaclass=Singleton):
         except (ValueError, SyntaxError):
             return value_str
 
+    def __serializeValue(self, value: Any, type_hint: str = None) -> str:
+        """
+        Parameters
+        ----------
+        value : Any
+            The value to serialize.
+        type_hint : str, optional
+            An optional type hint to guide serialization.
+        Returns
+        -------
+        str
+            The serialized string representation of the value.
+        Notes
+        -----
+        - If `value` is None, returns "null".
+        - If `type_hint` is provided, uses `EnvTypes` to serialize.
+        - Uses `repr()` for lists, dicts, tuples, and sets.
+        - Falls back to `str()` for other types.
+        """
+
+        if value is None:
+            return "null"
+
+        if type_hint:
+            return EnvTypes(value).to(type_hint)
+
+        if isinstance(value, str):
+            return value.strip()
+
+        if isinstance(value, bool):
+            return str(value).lower()
+
+        if isinstance(value, int, float):
+            return str(value)
+
+        if isinstance(value, (list, dict, tuple, set)):
+            return repr(value)
+
+        return str(value)
+
+    def get(self, key: str, default: Optional[Any] = None) -> Any:
+        """
+        Get the value of an environment variable.
+
+        Parameters
+        ----------
+        key : str
+            Name of the environment variable to retrieve.
+        default : Any, optional
+            Value to return if the key is not found. Default is None.
+
+        Returns
+        -------
+        Any
+            Parsed value of the environment variable, or `default` if not found.
+
+        Raises
+        ------
+        OrionisEnvironmentValueError
+            If `key` is not a string.
+        """
+        with self._lock:
+
+            # Ensure the key is a string.
+            if not isinstance(key, str):
+                raise OrionisEnvironmentValueError(
+                    f"Key must be a string, got {type(key).__name__}."
+                )
+
+            # Get the value from the .env file or the current environment.
+            value = dotenv_values(self._resolved_path).get(key)
+
+            # If the value is not found in the .env file, check the current environment variables.
+            if value is None:
+                value = os.getenv(key)
+
+            # Parse the value using the internal __parseValue method and return it
+            return self.__parseValue(value) if value is not None else default
+
     def set(self, key: str, value: Union[str, int, float, bool, list, dict, tuple, set], type_hint: str = None) -> bool:
         """
         Set an environment variable with the specified key and value.
@@ -195,46 +235,6 @@ class DotEnv(metaclass=Singleton):
             # Return True to indicate success.
             return True
 
-    def __serializeValue(self, value: Any, type_hint: str = None) -> str:
-        """
-        Parameters
-        ----------
-        value : Any
-            The value to serialize.
-        type_hint : str, optional
-            An optional type hint to guide serialization.
-        Returns
-        -------
-        str
-            The serialized string representation of the value.
-        Notes
-        -----
-        - If `value` is None, returns "null".
-        - If `type_hint` is provided, uses `EnvTypes` to serialize.
-        - Uses `repr()` for lists, dicts, tuples, and sets.
-        - Falls back to `str()` for other types.
-        """
-
-        if value is None:
-            return "null"
-
-        if type_hint:
-            return EnvTypes(value).to(type_hint)
-
-        if isinstance(value, str):
-            return value.strip()
-
-        if isinstance(value, bool):
-            return str(value).lower()
-
-        if isinstance(value, int, float):
-            return str(value)
-
-        if isinstance(value, (list, dict, tuple, set)):
-            return repr(value)
-
-        return str(value)
-
     def unset(self, key: str) -> bool:
         """
         Remove the specified environment variable from both the .env file and the current process environment.

{orionis-0.331.0 → orionis-0.333.0}/orionis/services/environment/types.py

@@ -73,6 +73,55 @@ class EnvTypes(IEnvTypes):
             # If raw is not a string, treat it as a value with no type hint
             self.__value_raw = raw
 
+    def get(self):
+        """
+        Returns the value corresponding to the specified type hint.
+
+        Checks if the provided type hint is valid and then dispatches the call to the appropriate
+        method for handling the type.
+
+        Supported type hints include: 'path:', 'str:', 'int:', 'float:', 'bool:', 'list:', 'dict:', 'tuple:', and 'set:'.
+
+        Returns
+        -------
+        Any
+            The value converted or processed according to the specified type hint.
+
+        Raises
+        ------
+        OrionisEnvironmentValueError
+            If the type hint is not one of the supported options.
+        """
+        if not self.__type_hint in self.OPTIONS:
+            raise OrionisEnvironmentValueError(f"Invalid type hint: {self.__type_hint}. Must be one of {self.OPTIONS}.")
+
+        if self.__type_hint == 'path':
+            return self.__parsePath()
+
+        if self.__type_hint == 'str':
+            return self.__parseStr()
+
+        if self.__type_hint == 'int':
+            return self.__parseInt()
+
+        if self.__type_hint == 'float':
+            return self.__parseFloat()
+
+        if self.__type_hint == 'bool':
+            return self.__parseBool()
+
+        if self.__type_hint == 'list':
+            return self.__parseList()
+
+        if self.__type_hint == 'dict':
+            return self.__parseDict()
+
+        if self.__type_hint == 'tuple':
+            return self.__parseTuple()
+
+        if self.__type_hint == 'set':
+            return self.__parseSet()
+
     def to(self, type_hint: str):
         """
         Set the type hint for the Type instance.
@@ -527,52 +576,3 @@ class EnvTypes(IEnvTypes):
         if not isinstance(self.__value_raw, set):
             raise OrionisEnvironmentValueError(f"Value must be a set to convert to set, got {type(self.__value_raw).__name__} instead.")
         return f"{self.__type_hint}:{repr(self.__value_raw)}"
-
-    def get(self):
-        """
-        Returns the value corresponding to the specified type hint.
-
-        Checks if the provided type hint is valid and then dispatches the call to the appropriate
-        method for handling the type.
-
-        Supported type hints include: 'path:', 'str:', 'int:', 'float:', 'bool:', 'list:', 'dict:', 'tuple:', and 'set:'.
-
-        Returns
-        -------
-        Any
-            The value converted or processed according to the specified type hint.
-
-        Raises
-        ------
-        OrionisEnvironmentValueError
-            If the type hint is not one of the supported options.
-        """
-        if not self.__type_hint in self.OPTIONS:
-            raise OrionisEnvironmentValueError(f"Invalid type hint: {self.__type_hint}. Must be one of {self.OPTIONS}.")
-
-        if self.__type_hint == 'path':
-            return self.__parsePath()
-
-        if self.__type_hint == 'str':
-            return self.__parseStr()
-
-        if self.__type_hint == 'int':
-            return self.__parseInt()
-
-        if self.__type_hint == 'float':
-            return self.__parseFloat()
-
-        if self.__type_hint == 'bool':
-            return self.__parseBool()
-
-        if self.__type_hint == 'list':
-            return self.__parseList()
-
-        if self.__type_hint == 'dict':
-            return self.__parseDict()
-
-        if self.__type_hint == 'tuple':
-            return self.__parseTuple()
-
-        if self.__type_hint == 'set':
-            return self.__parseSet()

orionis-0.333.0/orionis/services/introspection/inspection.py

@@ -0,0 +1,246 @@
+import inspect
+from typing import Any
+
+class Inspection:
+
+    def __init__(self, target: Any):
+        """
+        Initialize an inspection instance.
+
+        Parameters
+        ----------
+        target : Any
+            The object to be inspected.
+        """
+        self.__target = target
+
+    def isAbstract(self) -> bool:
+        """
+        Check if the object is an abstract base class.
+
+        Returns
+        -------
+        bool
+            True if the object is abstract, False otherwise.
+        """
+        return inspect.isabstract(self.__target)
+
+    def isAsyncGen(self) -> bool:
+        """
+        Check if the object is an asynchronous generator.
+
+        Returns
+        -------
+        bool
+            True if the object is an async generator, False otherwise.
+        """
+        return inspect.isasyncgen(self.__target)
+
+    def isAsyncGenFunction(self) -> bool:
+        """
+        Check if the object is an asynchronous generator function.
+
+        Returns
+        -------
+        bool
+            True if the object is an async generator function, False otherwise.
+        """
+        return inspect.isasyncgenfunction(self.__target)
+
+    def isAwaitable(self) -> bool:
+        """
+        Check if the object can be awaited.
+
+        Returns
+        -------
+        bool
+            True if the object is awaitable, False otherwise.
+        """
+        return inspect.isawaitable(self.__target)
+
+    def isBuiltin(self) -> bool:
+        """
+        Check if the object is a built-in function or method.
+
+        Returns
+        -------
+        bool
+            True if the object is a built-in, False otherwise.
+        """
+        return inspect.isbuiltin(self.__target)
+
+    def isClass(self) -> bool:
+        """
+        Check if the object is a class.
+
+        Returns
+        -------
+        bool
+            True if the object is a class, False otherwise.
+        """
+        return inspect.isclass(self.__target)
+
+    def isCode(self) -> bool:
+        """
+        Check if the object is a code object.
+
+        Returns
+        -------
+        bool
+            True if the object is a code object, False otherwise.
+        """
+        return inspect.iscode(self.__target)
+
+    def isCoroutine(self) -> bool:
+        """
+        Check if the object is a coroutine.
+
+        Returns
+        -------
+        bool
+            True if the object is a coroutine, False otherwise.
+        """
+        return inspect.iscoroutine(self.__target)
+
+    def isCoroutineFunction(self) -> bool:
+        """
+        Check if the object is a coroutine function.
+
+        Returns
+        -------
+        bool
+            True if the object is a coroutine function, False otherwise.
+        """
+        return inspect.iscoroutinefunction(self.__target)
+
+    def isDataDescriptor(self) -> bool:
+        """
+        Check if the object is a data descriptor.
+
+        Returns
+        -------
+        bool
+            True if the object is a data descriptor, False otherwise.
+        """
+        return inspect.isdatadescriptor(self.__target)
+
+    def isFrame(self) -> bool:
+        """
+        Check if the object is a frame object.
+
+        Returns
+        -------
+        bool
+            True if the object is a frame object, False otherwise.
+        """
+        return inspect.isframe(self.__target)
+
+    def isFunction(self) -> bool:
+        """
+        Check if the object is a Python function.
+
+        Returns
+        -------
+        bool
+            True if the object is a function, False otherwise.
+        """
+        return inspect.isfunction(self.__target)
+
+    def isGenerator(self) -> bool:
+        """
+        Check if the object is a generator.
+
+        Returns
+        -------
+        bool
+            True if the object is a generator, False otherwise.
+        """
+        return inspect.isgenerator(self.__target)
+
+    def isGeneratorFunction(self) -> bool:
+        """
+        Check if the object is a generator function.
+
+        Returns
+        -------
+        bool
+            True if the object is a generator function, False otherwise.
+        """
+        return inspect.isgeneratorfunction(self.__target)
+
+    def isGetSetDescriptor(self) -> bool:
+        """
+        Check if the object is a getset descriptor.
+
+        Returns
+        -------
+        bool
+            True if the object is a getset descriptor, False otherwise.
+        """
+        return inspect.isgetsetdescriptor(self.__target)
+
+    def isMemberDescriptor(self) -> bool:
+        """
+        Check if the object is a member descriptor.
+
+        Returns
+        -------
+        bool
+            True if the object is a member descriptor, False otherwise.
+        """
+        return inspect.ismemberdescriptor(self.__target)
+
+    def isMethod(self) -> bool:
+        """
+        Check if the object is a method.
+
+        Returns
+        -------
+        bool
+            True if the object is a method, False otherwise.
+        """
+        return inspect.ismethod(self.__target)
+
+    def isMethodDescriptor(self) -> bool:
+        """
+        Check if the object is a method descriptor.
+
+        Returns
+        -------
+        bool
+            True if the object is a method descriptor, False otherwise.
+        """
+        return inspect.ismethoddescriptor(self.__target)
+
+    def isModule(self) -> bool:
+        """
+        Check if the object is a module.
+
+        Returns
+        -------
+        bool
+            True if the object is a module, False otherwise.
+        """
+        return inspect.ismodule(self.__target)
+
+    def isRoutine(self) -> bool:
+        """
+        Check if the object is a user-defined or built-in function or method.
+
+        Returns
+        -------
+        bool
+            True if the object is a routine, False otherwise.
+        """
+        return inspect.isroutine(self.__target)
+
+    def isTraceback(self) -> bool:
+        """
+        Check if the object is a traceback object.
+
+        Returns
+        -------
+        bool
+            True if the object is a traceback object, False otherwise.
+        """
+        return inspect.istraceback(self.__target)

{orionis-0.331.0 → orionis-0.333.0}/orionis/services/introspection/instances/reflection_instance.py

@@ -606,6 +606,34 @@ class ReflectionInstance(IReflectionInstance):
         # If the method is not callable, raise an error
         raise ReflectionAttributeError(f"Method '{name}' is not callable on '{self.getClassName()}'.")
 
+    def getMethodDocstring(self, name: str) -> Optional[str]:
+        """
+        Get the docstring of a method.
+
+        Parameters
+        ----------
+        name : str
+            Name of the method
+
+        Returns
+        -------
+        Optional[str]
+            The method docstring, or None if not available
+        """
+
+        # Handle private method name mangling
+        if name.startswith("__") and not name.endswith("__"):
+            class_name = self.getClassName()
+            name = f"_{class_name}{name}"
+
+        # Check if the method exists and is callable
+        method = getattr(self._instance.__class__, name, None)
+        if callable(method):
+            return method.__doc__
+
+        # If the method is not callable, raise an error
+        raise ReflectionAttributeError(f"Method '{name}' does not exist on '{self.getClassName()}'.")
+
     def getMethods(self) -> List[str]:
         """
         Get all method names of the instance.