orionis 0.472.0__tar.gz → 0.473.0__tar.gz

{orionis-0.472.0/orionis.egg-info → orionis-0.473.0}/PKG-INFO

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

{orionis-0.472.0 → orionis-0.473.0}/orionis/console/core/reactor.py

@@ -520,7 +520,7 @@ class Reactor(IReactor):
                 command_instance._args = {}
 
             # Call the handle method of the command instance
-            output =  self.__app.call(command_instance, 'handle')
+            output = self.__app.call(command_instance, 'handle')
 
             # Log the command execution completion with DONE state
             elapsed_time = round(time.perf_counter() - start_time, 2)

{orionis-0.472.0 → orionis-0.473.0}/orionis/container/container.py

@@ -1,4 +1,5 @@
 import abc
+import asyncio
 import inspect
 import threading
 import typing
@@ -106,6 +107,122 @@ class Container(IContainer):
             # Mark this instance as initialized
             self.__initialized = True
 
+    def __handleSyncAsyncResult(
+        self,
+        result: Any
+    ) -> Any:
+        """
+        Universal helper to handle both synchronous and asynchronous results.
+
+        This method automatically detects if a result is a coroutine and handles
+        it appropriately based on the current execution context.
+
+        Parameters
+        ----------
+        result : Any
+            The result to handle, which may be a coroutine or regular value.
+
+        Returns
+        -------
+        Any
+            The resolved result. If the result was a coroutine, it will be awaited
+            if possible, or scheduled appropriately.
+        """
+
+        # If the result is not a coroutine, return it directly
+        if not asyncio.iscoroutine(result):
+            return result
+
+        try:
+
+            # Check if we're currently in an event loop
+            loop = asyncio.get_running_loop()
+
+            # If we're in an async context, we need to let the caller handle the coroutine
+            # Since we can't await here, we'll create a task and get the result synchronously
+            # This is a compromise for mixed sync/async environments
+            if loop.is_running():
+
+                # For running loops, we create a new thread to run the coroutine
+                import concurrent.futures
+
+                # Define a function to run the coroutine in a new event loop
+                def run_coroutine():
+
+                    # Create a new event loop for this thread
+                    new_loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(new_loop)
+
+                    # Run the coroutine until completion
+                    try:
+                        return new_loop.run_until_complete(result)
+
+                    # Finally, ensure the loop is closed to free resources
+                    finally:
+                        new_loop.close()
+
+                # Use ThreadPoolExecutor to run the coroutine in a separate thread
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(run_coroutine)
+                    return future.result()
+
+            else:
+                # If loop exists but not running, we can run the coroutine
+                return loop.run_until_complete(result)
+
+        except RuntimeError:
+
+            # No event loop running, we can run the coroutine directly
+            return asyncio.run(result)
+
+    def __invokeCallableUniversal(
+        self,
+        fn: Callable[..., Any],
+        *args,
+        **kwargs
+    ) -> Any:
+        """
+        Universal callable invoker that handles both sync and async callables.
+
+        Parameters
+        ----------
+        fn : Callable[..., Any]
+            The callable to invoke.
+        *args : tuple
+            Positional arguments to pass to the callable.
+        **kwargs : dict
+            Keyword arguments to pass to the callable.
+
+        Returns
+        -------
+        Any
+            The result of the callable invocation.
+
+        Raises
+        ------
+        OrionisContainerException
+            If the callable invocation fails.
+        """
+
+        try:
+
+            # Check if the callable is a coroutine function
+            result = fn(*args, **kwargs)
+            return self.__handleSyncAsyncResult(result)
+
+        except TypeError as e:
+
+            # If invocation fails, use ReflectionCallable for better error messaging
+            rf_callable = ReflectionCallable(fn)
+            function_name = rf_callable.getName()
+            signature = rf_callable.getSignature()
+
+            # Raise a more informative exception with the function name and signature
+            raise OrionisContainerException(
+                f"Failed to invoke function [{function_name}] with the provided arguments: {e}\n"
+                f"Expected function signature: [{signature}]"
+            ) from e
+
     def transient(
         self,
         abstract: Callable[..., Any],
@@ -1284,6 +1401,7 @@ class Container(IContainer):
     ) -> Any:
         """
         Invokes a callable with the provided arguments.
+        Supports both synchronous and asynchronous callables automatically.
 
         Parameters
         ----------
@@ -1297,27 +1415,10 @@ class Container(IContainer):
         Returns
         -------
         Any
-            The result of the callable.
+            The result of the callable. If the callable is async,
+            the coroutine will be handled automatically.
         """
-
-        # Try to invoke the callable with the provided arguments
-        try:
-
-            # If the callable is a function, invoke it directly
-            return fn(*args, **kwargs)
-
-        except TypeError as e:
-
-            # If invocation fails, use ReflectionCallable to get function name and signature
-            rf_callable = ReflectionCallable(fn)
-            function_name = rf_callable.getName()
-            signature = rf_callable.getSignature()
-
-            # Raise an exception with detailed information about the failure
-            raise OrionisContainerException(
-                f"Failed to invoke function [{function_name}] with the provided arguments: {e}\n"
-                f"Expected function signature: [{signature}]"
-            ) from e
+        return self.__invokeCallableUniversal(fn, *args, **kwargs)
 
     def __instantiateConcreteReflective(
         self,
@@ -1359,13 +1460,13 @@ class Container(IContainer):
 
         # Try simple call first for functions without parameters
         try:
-
             # Use ReflectionCallable to get dependencies
             dependencies = ReflectionCallable(fn).getDependencies()
 
             # If there are no required parameters, call directly
             if not dependencies or (not dependencies.resolved and not dependencies.unresolved):
-                return fn()
+                result = fn()
+                return self.__handleSyncAsyncResult(result)
 
             # If there are unresolved dependencies, raise an exception
             if dependencies.unresolved:
@@ -1379,13 +1480,19 @@ class Container(IContainer):
                 getattr(fn, '__name__', str(fn)),
                 dependencies
             )
-            return fn(**resolved_params)
+
+            # Invoke the callable with resolved parameters
+            result = fn(**resolved_params)
+
+            # Handle the result, which may be a coroutine
+            return self.__handleSyncAsyncResult(result)
 
         except Exception as inspect_error:
 
             # If inspection fails, try direct call as last resort
             try:
-                return fn()
+                result = fn()
+                return self.__handleSyncAsyncResult(result)
 
             # If direct call fails, raise inspection error
             except TypeError:
@@ -1533,6 +1640,7 @@ class Container(IContainer):
             return params
 
         except Exception as e:
+
             # If the exception is already an OrionisContainerException, re-raise it
             if isinstance(e, OrionisContainerException):
                 raise e from None
@@ -1621,6 +1729,7 @@ class Container(IContainer):
     ) -> Any:
         """
         Helper method to instantiate a target with reflection-based dependency resolution.
+        Supports both synchronous and asynchronous callables automatically.
 
         Parameters
         ----------
@@ -1632,13 +1741,20 @@ class Container(IContainer):
         Returns
         -------
         Any
-            The instantiated object or callable result.
+            The instantiated object or callable result. If the callable is async,
+            the coroutine will be handled automatically.
         """
 
+        # Reflect the target to get its dependencies
         resolved_params = self.__resolveDependencies(
             *self.__reflectTarget(target, is_class=is_class)
         )
-        return target(**resolved_params)
+
+        # If the target is a class, instantiate it with resolved parameters
+        result = target(**resolved_params)
+
+        # Handle the result, which may be a coroutine
+        return self.__handleSyncAsyncResult(result)
 
     def resolveWithoutContainer(
         self,
@@ -2118,6 +2234,7 @@ class Container(IContainer):
     ) -> Any:
         """
         Call a method on an instance with automatic dependency injection.
+        Supports both synchronous and asynchronous methods automatically.
 
         Parameters
         ----------
@@ -2133,13 +2250,84 @@ class Container(IContainer):
         Returns
         -------
         Any
-            The result of the method call.
+            The result of the method call. If the method is async,
+            the coroutine will be handled automatically.
+        """
+
+        # Validate inputs
+        self.__validateCallInputs(instance, method_name)
+
+        # Get the method
+        method = getattr(instance, method_name)
+
+        # Execute the method with appropriate handling
+        return self.__executeMethod(method, *args, **kwargs)
+
+    async def callAsync(
+        self,
+        instance: Any,
+        method_name: str,
+        *args,
+        **kwargs
+    ) -> Any:
+        """
+        Async version of call for when you're in an async context and need to await the result.
+
+        Parameters
+        ----------
+        instance : Any
+            The instance on which to call the method.
+        method_name : str
+            The name of the method to call.
+        *args : tuple
+            Positional arguments to pass to the method.
+        **kwargs : dict
+            Keyword arguments to pass to the method.
+
+        Returns
+        -------
+        Any
+            The result of the method call, properly awaited if async.
+        """
+
+        # Validate inputs
+        self.__validateCallInputs(instance, method_name)
+
+        # Get the method
+        method = getattr(instance, method_name)
+
+        # Execute the method with async handling
+        result = self.__executeMethod(method, *args, **kwargs)
+
+        # If the result is a coroutine, await it
+        if asyncio.iscoroutine(result):
+            return await result
+
+        # Otherwise, return the result directly
+        return result
+
+    def __validateCallInputs(self, instance: Any, method_name: str) -> None:
+        """
+        Validates the inputs for the call methods.
+
+        Parameters
+        ----------
+        instance : Any
+            The instance to validate.
+        method_name : str
+            The method name to validate.
+
+        Raises
+        ------
+        OrionisContainerException
+            If validation fails.
         """
 
         # Ensure the instance is a valid object (allow __main__ for development)
         if instance is None:
             raise OrionisContainerException("Instance cannot be None")
 
+        # Ensure the instance is a valid object with a class
         if not hasattr(instance, '__class__'):
             raise OrionisContainerException("Instance must be a valid object with a class")
 
@@ -2161,12 +2349,35 @@ class Container(IContainer):
                 f"Method '{method_name}' not found or not callable on instance '{type(instance).__name__}'."
             )
 
+    def __executeMethod(
+        self,
+        method: Callable,
+        *args,
+        **kwargs
+    ) -> Any:
+        """
+        Executes a method with automatic dependency injection and sync/async handling.
+
+        Parameters
+        ----------
+        method : Callable
+            The method to execute.
+        *args : tuple
+            Positional arguments to pass to the method.
+        **kwargs : dict
+            Keyword arguments to pass to the method.
+
+        Returns
+        -------
+        Any
+            The result of the method execution.
+        """
+
         # If args or kwargs are provided, use them directly
         if args or kwargs:
-            return self.__instantiateCallableWithArgs(method, *args, **kwargs)
+            return self.__invokeCallableUniversal(method, *args, **kwargs)
 
         # For methods without provided arguments, try simple call first
-        # This avoids reflection issues for simple methods
         try:
 
             # Get method signature to check if it needs parameters
@@ -2178,19 +2389,22 @@ class Container(IContainer):
 
             # If no required parameters, call directly
             if not params:
-                return method()
+                result = method()
+                return self.__handleSyncAsyncResult(result)
 
             # If has required parameters, try dependency injection
-            return self.__instantiateWithReflection(method, is_class=False)
+            result = self.__instantiateWithReflection(method, is_class=False)
+            return result
 
         except Exception as reflection_error:
 
             # If reflection fails, try simple call as fallback
             try:
-                return method()
+                result = method()
+                return self.__handleSyncAsyncResult(result)
 
-            # If simple call also fails, raise the original reflection error
+            # If both reflection and simple call fail, raise an exception
             except TypeError:
                 raise OrionisContainerException(
-                    f"Failed to call method '{method_name}': {reflection_error}"
-                ) from reflection_error
+                    f"Failed to call method '{method.__name__}': {reflection_error}"
+                ) from reflection_error

{orionis-0.472.0 → orionis-0.473.0}/orionis/metadata/framework.py

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

{orionis-0.472.0 → orionis-0.473.0/orionis.egg-info}/PKG-INFO

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

{orionis-0.472.0 → orionis-0.473.0}/orionis.egg-info/SOURCES.txt

@@ -372,6 +372,8 @@ tests/container/context/__init__.py
 tests/container/context/test_manager.py
 tests/container/context/test_scope.py
 tests/container/core/__init__.py
+tests/container/core/test_advanced_async.py
+tests/container/core/test_async_optimizations.py
 tests/container/core/test_container.py
 tests/container/core/test_singleton.py
 tests/container/core/test_thread_safety.py
@@ -382,6 +384,8 @@ tests/container/enums/test_lifetimes.py
 tests/container/facades/__init__.py
 tests/container/facades/test_facade.py
 tests/container/mocks/__init__.py
+tests/container/mocks/mock_advanced_async.py
+tests/container/mocks/mock_async_optimizations.py
 tests/container/mocks/mock_auto_resolution.py
 tests/container/mocks/mock_complex_classes.py
 tests/container/mocks/mock_simple_classes.py

orionis-0.473.0/tests/container/core/test_advanced_async.py

@@ -0,0 +1,234 @@
+import time
+from orionis.container.container import Container
+from orionis.test.cases.asynchronous import AsyncTestCase
+from tests.container.mocks.mock_advanced_async import ErrorService, IPerformanceService, MixedConsumer, PerformanceService, simple_async, sync_returns_coroutine
+
+class TestContainer(AsyncTestCase):
+
+    async def testPerformanceComparison(self):
+        """
+        Measures and verifies the performance of synchronous service calls within the container.
+
+        This test performs the following steps:
+            - Instantiates a container and registers `PerformanceService` as a singleton for the `IPerformanceService` interface.
+            - Resolves the registered service from the container.
+            - Executes the synchronous operation multiple times using the container's `call` method, measuring the total elapsed time.
+            - Asserts that the synchronous operation returns the expected result.
+            - Asserts that the measured execution time is greater than zero, confirming that the operation duration is measurable.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate expected behavior.
+        """
+        # Create a container instance
+        container = Container()
+
+        # Register the PerformanceService as a singleton for the IPerformanceService interface
+        container.singleton(IPerformanceService, PerformanceService)
+
+        # Resolve the service instance from the container
+        service = container.make(IPerformanceService)
+
+        # Start timing the synchronous calls
+        start_time = time.time()
+
+        # Call the sync operation multiple times to measure performance
+        for i in range(3):
+            result = container.call(service, 'sync_operation')
+
+        # Calculate the total elapsed time for synchronous calls
+        sync_time = time.time() - start_time
+
+        # Assert that the sync operation returns the expected result
+        self.assertEqual(result, "Sync operation completed")
+
+        # Assert that the measured time is greater than zero
+        self.assertGreater(sync_time, 0, "Sync operation should take some time")
+
+    async def testAsyncPerformance(self):
+        """
+        Measures and verifies the performance of asynchronous service calls within the container.
+
+        This test performs the following steps:
+            - Instantiates a container and registers `PerformanceService` as a singleton for the `IPerformanceService` interface.
+            - Resolves the registered service from the container.
+            - Executes the asynchronous operation multiple times using both `call` and `callAsync` methods, measuring the total elapsed time.
+            - Asserts that the asynchronous operation returns the expected result.
+            - Asserts that the measured execution time is greater than zero, confirming that the operation duration is measurable.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate expected behavior.
+
+        Raises
+        ------
+        AssertionError
+            If the asynchronous operation does not return the expected result or if the measured time is not greater than zero.
+        """
+
+        # Create a container instance
+        container = Container()
+
+        # Register the PerformanceService as a singleton for the IPerformanceService interface
+        container.singleton(IPerformanceService, PerformanceService)
+
+        # Resolve the service instance from the container
+        service = container.make(IPerformanceService)
+
+        # Start timing the asynchronous calls
+        start_time = time.time()
+
+        # Call the async operation multiple times using the container's call method
+        for i in range(3):
+
+            # Await the result of the async operation
+            result = container.call(service, 'async_operation')
+
+        # Calculate the total elapsed time for asynchronous calls
+        async_time = time.time() - start_time
+
+        # Assert that the async operation returns the expected result
+        self.assertEqual(result, "Async operation completed")
+
+        # Call the async operation multiple times using the container's callAsync method
+        for i in range(3):
+            result = await container.callAsync(service, 'async_operation')
+
+        # Assert that the async operation returns the expected result
+        self.assertEqual(result, "Async operation completed")
+
+        # Assert that the measured time is greater than zero
+        self.assertGreater(async_time, 0, "Async operation should take some time")
+
+    async def testErrorHandling(self):
+        """
+        Tests the error handling capabilities of the container for both synchronous and asynchronous service methods.
+
+        This method performs the following steps:
+            - Instantiates a container and resolves the `ErrorService`.
+            - Invokes a synchronous method that is expected to raise an exception and asserts that the exception is raised.
+            - (Asynchronous error handling is tested elsewhere.)
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate that exceptions are properly raised.
+        """
+
+        # Create a container instance
+        container = Container()
+
+        # Resolve the ErrorService instance from the container
+        service = container.make(ErrorService)
+
+        # Test synchronous error handling: expect an exception to be raised
+        with self.assertRaises(Exception) as context:
+            container.call(service, 'sync_error_method')
+
+    async def testAsyncErrors(self):
+
+        # Create a container instance
+        container = Container()
+
+        # Resolve the ErrorService instance from the container
+        service = container.make(ErrorService)
+
+        # Call the async error method and await its result
+        with self.assertRaises(Exception) as context:
+            await container.callAsync(service, 'async_error_method')
+
+    async def testMixedDependencyInjection(self):
+        """
+        Tests the container's ability to perform mixed synchronous and asynchronous dependency injection.
+
+        This test performs the following steps:
+            - Instantiates a container and uses it to auto-resolve dependencies for the `MixedConsumer` class.
+            - Invokes a synchronous method with dependency injection and verifies its return value.
+            - (Asynchronous methods are tested elsewhere.)
+
+        The test asserts that:
+            - The synchronous method returns a string starting with "Sync:".
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate expected behavior.
+        """
+
+        # Create an instance of the container
+        container = Container()
+
+        # Auto-resolve dependencies for MixedConsumer
+        consumer = container.make(MixedConsumer)
+
+        # Test synchronous method with dependency injection
+        sync_result: str = container.call(consumer, 'sync_method')
+
+        # Assert that the result starts with "Sync:"
+        self.assertTrue(sync_result.startswith("Sync:"))
+
+    async def testAsyncWithDI(self):
+        """
+        Tests the container's capability to perform asynchronous dependency injection.
+
+        This test performs the following steps:
+            - Instantiates a container and uses it to auto-resolve dependencies for the `MixedConsumer` class.
+            - Invokes an asynchronous method with dependency injection and verifies its return value.
+
+        The test asserts that:
+            - The asynchronous method returns a string starting with "Mixed: ".
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate expected behavior.
+        """
+
+        # Create an instance of the container
+        container = Container()
+
+        # Auto-resolve dependencies for MixedConsumer
+        consumer = container.make(MixedConsumer)
+
+        # Call the asynchronous method with dependency injection
+        async_result: str = await container.callAsync(consumer, 'async_method')
+
+        # Assert that the result starts with "Mixed: "
+        self.assertTrue(async_result.startswith("Mixed: "))
+
+    async def testCallableAsyncSync(self):
+        """
+        Tests the container's ability to register and resolve both synchronous and asynchronous callable functions,
+        ensuring that both types return coroutine objects when resolved.
+
+        This method performs the following steps:
+            - Instantiates a container and registers two callable functions:
+                - A synchronous function that returns a coroutine.
+                - An asynchronous function.
+            - Resolves each callable from the container.
+            - Asserts that the resolved objects are coroutine objects by checking for the '__await__' attribute.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate that the resolved callables are coroutine objects.
+        """
+
+        # Create a container instance
+        container = Container()
+
+        # Register a synchronous function that returns a coroutine
+        container.callable("sync_returns_coro", sync_returns_coroutine)
+
+        # Register an asynchronous function
+        container.callable("simple_async", simple_async)
+
+        # Resolve the synchronous function and check if it returns a coroutine object
+        result1 = container.make("sync_returns_coro")
+        self.assertTrue(result1 == "Sync function returning coroutine")
+
+        # Resolve the asynchronous function and check if it returns a coroutine object
+        result2 = container.make("simple_async")
+        self.assertTrue(result2 == "Simple async callable")