orionis 0.532.0__py3-none-any.whl → 0.534.0__py3-none-any.whl

orionis/console/commands/make_listener.py

@@ -0,0 +1,57 @@
+from orionis.console.base.command import BaseCommand
+from orionis.console.contracts.reactor import IReactor
+from orionis.console.exceptions import CLIOrionisRuntimeError
+from rich.console import Console
+from rich.panel import Panel
+
+class MakeListenerCommand(BaseCommand):
+    """
+    Este comando se encarga de crear los listener tando para CLI como para otro tipo de Eventos.
+    """
+
+    # Indicates whether timestamps will be shown in the command output
+    timestamps: bool = False
+
+    # Command signature and description
+    signature: str = "make:listener"
+
+    # Command description
+    description: str = "Displays usage information, examples, and a list of available commands in the Orionis CLI."
+
+    def handle(self) -> dict:
+        """
+        Displays usage information and a list of available commands for the Orionis CLI.
+
+        Parameters
+        ----------
+        reactor : IReactor
+            The reactor instance providing command metadata via the `info()` method.
+
+        Returns
+        -------
+        dict
+            A dictionary containing the list of available commands, each with its signature and description.
+
+        Raises
+        ------
+        CLIOrionisRuntimeError
+            If an unexpected error occurs during help information generation or display.
+        """
+        try:
+
+            # Solicitar el nombre del listener al usuario
+            ans = self.choice(
+                question="Tipo de Listener",
+                choices=[
+                    "Listener para eventos CLI",
+                    "Listener para eventos de Schedule",
+                ],
+                default_index=0
+            )
+
+            print(ans)
+
+        except Exception as e:
+
+            # Raise a custom runtime error if any exception occurs
+            raise CLIOrionisRuntimeError(f"An unexpected error occurred: {e}") from e

orionis/console/core/reactor.py

@@ -114,6 +114,7 @@ class Reactor(IReactor):
         from orionis.console.commands.cache import CacheClearCommand
         from orionis.console.commands.scheduler_work import ScheduleWorkCommand
         from orionis.console.commands.scheduler_list import ScheduleListCommand
+        from orionis.console.commands.make_listener import MakeListenerCommand
 
         # List of core command classes to load (extend this list as more core commands are added)
         core_commands = [
@@ -124,7 +125,8 @@ class Reactor(IReactor):
             WorkFlowGithubCommand,
             CacheClearCommand,
             ScheduleWorkCommand,
-            ScheduleListCommand
+            ScheduleListCommand,
+            MakeListenerCommand
         ]
 
         # Iterate through the core command classes and register them

orionis/console/tasks/schedule.py

@@ -37,6 +37,7 @@ from orionis.console.exceptions import CLIOrionisRuntimeError
 from orionis.console.exceptions.cli_orionis_value_error import CLIOrionisValueError
 from orionis.failure.contracts.catch import ICatch
 from orionis.foundation.contracts.application import IApplication
+from orionis.services.asynchrony.coroutines import Coroutine
 from orionis.services.log.contracts.log_service import ILogger
 
 class Schedule(ISchedule):
@@ -478,44 +479,13 @@ class Schedule(ISchedule):
             # If is Callable
             if callable(listener):
 
+                # Invoke the listener, handling both coroutine and regular functions
                 try:
 
-                    # If the listener is a coroutine, handle it properly
-                    if asyncio.iscoroutinefunction(listener):
+                    # Use Coroutine to handle both sync and async listeners
+                    Coroutine(listener).invoke(event_data, self)
 
-                        try:
-
-                            # Try to get the current running event loop
-                            loop = asyncio.get_running_loop()
-
-                            # Schedule the coroutine as a task in the current loop
-                            loop.create_task(listener(event_data, self))
-
-                        except RuntimeError:
-
-                            # No running event loop, create a new one
-                            try:
-
-                                # Create and run the coroutine in a new event loop
-                                asyncio.run(listener(event_data, self))
-
-                            except Exception as e:
-
-                                # Handle exceptions during coroutine execution
-                                error_msg = f"Failed to run async listener for '{scheduler_event}': {str(e)}"
-                                self.__logger.error(error_msg)
-                                raise CLIOrionisRuntimeError(error_msg) from e
-
-                    else:
-
-                        # Call the regular listener function directly
-                        listener(event_data, self)
-
-                except Exception as e:
-
-                    # Re-raise CLIOrionisRuntimeError exceptions
-                    if isinstance(e, CLIOrionisRuntimeError):
-                        raise e
+                except BaseException as e:
 
                     # Construct and log error message
                     error_msg = f"An error occurred while invoking the listener for event '{scheduler_event}': {str(e)}"
@@ -588,45 +558,14 @@ class Schedule(ISchedule):
                     # Retrieve the method from the listener
                     listener_method = getattr(listener, scheduler_event)
 
+                    # Invoke the listener method, handling both coroutine and regular functions
                     try:
 
-                        # If the listener_method is a coroutine, handle it properly
-                        if asyncio.iscoroutinefunction(listener_method):
-
-                            try:
-
-                                # Try to get the current running event loop
-                                loop = asyncio.get_running_loop()
-
-                                # Schedule the coroutine as a task in the current loop
-                                loop.create_task(listener_method(event_data, self))
-
-                            except RuntimeError:
-
-                                # No running event loop, create a new one
-                                try:
-
-                                    # Create and run the coroutine in a new event loop
-                                    asyncio.run(listener_method(event_data, self))
-
-                                except Exception as e:
-
-                                    # Handle exceptions during coroutine execution
-                                    error_msg = f"Failed to run async listener_method for '{scheduler_event}': {str(e)}"
-                                    self.__logger.error(error_msg)
-                                    raise CLIOrionisRuntimeError(error_msg) from e
-
-                        else:
-
-                            # Call the regular listener_method function directly
-                            listener_method(event_data, self)
+                        # Use Coroutine to handle both sync and async listener methods
+                        Coroutine(listener_method).invoke(event_data, self)
 
                     except Exception as e:
 
-                        # Re-raise CLIOrionisRuntimeError exceptions
-                        if isinstance(e, CLIOrionisRuntimeError):
-                            raise e
-
                         # Construct and log error message
                         error_msg = f"An error occurred while invoking the listener_method for event '{scheduler_event}': {str(e)}"
                         self.__logger.error(error_msg)
@@ -1081,52 +1020,99 @@ class Schedule(ISchedule):
         func: Callable[..., Awaitable[Any]]
     ) -> Callable[..., Any]:
         """
-        Wrap an asynchronous function to be called in a synchronous context.
+        Wrap an asynchronous function to be executed in a synchronous context.
 
-        This method takes an asynchronous function (a coroutine) and returns a synchronous
-        wrapper function that can be called in a non-async context. The wrapper function
-        ensures that the asynchronous function is executed within the appropriate event loop.
+        This method creates a synchronous wrapper around an asynchronous function (coroutine)
+        that enables its execution within non-async contexts. The wrapper leverages the
+        Coroutine utility class to handle the complexities of asyncio event loop management
+        and provides proper error handling with detailed logging and custom exception
+        propagation.
+
+        The wrapper is particularly useful when integrating asynchronous functions with
+        synchronous APIs or frameworks that do not natively support async operations,
+        such as the APScheduler job execution environment.
 
         Parameters
         ----------
         func : Callable[..., Awaitable[Any]]
-            The asynchronous function (coroutine) to be wrapped. This function should be
-            defined using the `async def` syntax and return an awaitable object.
+            The asynchronous function (coroutine) to be wrapped. This function must be
+            defined using the `async def` syntax and return an awaitable object. The
+            function can accept any number of positional and keyword arguments.
 
         Returns
         -------
         Callable[..., Any]
-            A synchronous wrapper function that can be called in a non-async context.
-            When invoked, this wrapper will execute the original asynchronous function
-            within the appropriate event loop.
+            A synchronous wrapper function that executes the original asynchronous
+            function and returns its result. The wrapper function accepts the same
+            arguments as the original async function and forwards them appropriately.
+            The return type depends on what the wrapped asynchronous function returns.
 
         Raises
         ------
         CLIOrionisRuntimeError
-            If the provided `func` is not an asynchronous function or execution fails.
+            If the asynchronous function execution fails or if the provided `func`
+            parameter is not a valid asynchronous function. The original exception
+            is wrapped to provide additional context for debugging.
+
+        Notes
+        -----
+        This method relies on the Coroutine utility class from the orionis.services.asynchrony
+        module to handle the execution of the wrapped asynchronous function. The wrapper
+        uses the instance logger for comprehensive error reporting and debugging information.
         """
 
         def sync_wrapper(*args, **kwargs) -> Any:
+            """
+            Synchronous wrapper function that executes asynchronous functions in a thread-safe manner.
+
+            This wrapper provides a uniform interface for executing asynchronous functions within
+            synchronous contexts by leveraging the Coroutine utility class. It handles the complexity
+            of managing async/await patterns and provides proper error handling with detailed logging
+            and custom exception propagation.
+
+            The wrapper is particularly useful when integrating asynchronous functions with
+            synchronous APIs or frameworks that do not natively support async operations.
+
+            Parameters
+            ----------
+            *args : tuple
+            Variable length argument list to pass to the wrapped asynchronous function.
+            These arguments are forwarded directly to the original function.
+            **kwargs : dict
+            Arbitrary keyword arguments to pass to the wrapped asynchronous function.
+            These keyword arguments are forwarded directly to the original function.
+
+            Returns
+            -------
+            Any
+            The return value from the executed asynchronous function. The type depends
+            on what the wrapped function returns and can be any Python object.
+
+            Raises
+            ------
+            CLIOrionisRuntimeError
+            When the asynchronous function execution fails, wrapping the original
+            exception with additional context and error details for better debugging.
+
+            Notes
+            -----
+            This function relies on the Coroutine utility class to handle the execution
+            of the wrapped asynchronous function and uses the instance logger for comprehensive
+            error reporting and debugging information.
+            """
 
             try:
-
-                # Try to get the current event loop
-                try:
-
-                    # If we're already in an event loop, create a task
-                    loop = asyncio.get_running_loop()
-                    task = loop.create_task(func(*args, **kwargs))
-                    return task
-
-                except RuntimeError:
-
-                    # No running loop, so we can run the coroutine directly
-                    return asyncio.run(func(*args, **kwargs))
+                # Execute the asynchronous function using the Coroutine utility class
+                # The Coroutine class handles the event loop management and async execution
+                return Coroutine(func).invoke(*args, **kwargs)
 
             except Exception as e:
 
-                # Log the error and re-raise
+                # Log the error with detailed information for debugging purposes
                 self.__logger.error(f"Error executing async function: {str(e)}")
+
+                # Re-raise the exception wrapped in a custom exception type
+                # This provides better error context and maintains the original stack trace
                 raise CLIOrionisRuntimeError(f"Failed to execute async function: {str(e)}") from e
 
         # Return the synchronous wrapper function

orionis/failure/base/handler.py

@@ -8,12 +8,12 @@ from orionis.services.log.contracts.log_service import ILogger
 class BaseExceptionHandler(IBaseExceptionHandler):
 
     # Exceptions that should not be caught by the handler
-    dont_cathc: List[type[BaseException]] = [
+    dont_catch: List[type[BaseException]] = [
         # Add specific exceptions that should not be caught
         # Example: OrionisContainerException
     ]
 
-    def destructureException(self, e: BaseException) -> Throwable:
+    async def destructureException(self, e: BaseException) -> Throwable:
         """
         Converts an exception into a structured `Throwable` object containing detailed information.
 
@@ -41,7 +41,7 @@ class BaseExceptionHandler(IBaseExceptionHandler):
             traceback=getattr(e, '__traceback__', None)     # The traceback object, if available
         )
 
-    def shouldIgnoreException(self, e: BaseException) -> bool:
+    async def shouldIgnoreException(self, e: BaseException) -> bool:
         """
         Determines if the exception should be ignored (not handled) by the handler.
 
@@ -61,12 +61,12 @@ class BaseExceptionHandler(IBaseExceptionHandler):
             raise TypeError(f"Expected BaseException, got {type(e).__name__}")
 
         # Convert the exception into a structured Throwable object
-        throwable = self.destructureException(e)
+        throwable = await self.destructureException(e)
 
         # Check if the exception type is in the list of exceptions to ignore
-        return hasattr(self, 'dont_cathc') and throwable.classtype in self.dont_cathc
+        return hasattr(self, 'dont_catch') and throwable.classtype in self.dont_catch
 
-    def report(self, exception: BaseException, log: ILogger) -> Any:
+    async def report(self, exception: BaseException, log: ILogger) -> Any:
         """
         Report or log an exception.
 
@@ -84,7 +84,7 @@ class BaseExceptionHandler(IBaseExceptionHandler):
             raise TypeError(f"Expected BaseException, got {type(exception).__name__}")
 
         # Convert the exception into a structured Throwable object
-        throwable = self.destructureException(exception)
+        throwable = await self.destructureException(exception)
 
         # Log the exception details
         log.error(f"[{throwable.classtype.__name__}] {throwable.message}")
@@ -92,7 +92,7 @@ class BaseExceptionHandler(IBaseExceptionHandler):
         # Return the structured exception
         return throwable
 
-    def renderCLI(self, request: CLIRequest, exception: BaseException, log: ILogger, console: IConsole) -> Any:
+    async def renderCLI(self, request: CLIRequest, exception: BaseException, log: ILogger, console: IConsole) -> Any:
         """
         Render the exception message for CLI output.
 
@@ -109,11 +109,15 @@ class BaseExceptionHandler(IBaseExceptionHandler):
         if not isinstance(exception, BaseException):
             raise TypeError(f"Expected BaseException, got {type(exception).__name__}")
 
+        # Ensure the request is a CLIRequest
+        if not isinstance(request, CLIRequest):
+            raise TypeError(f"Expected CLIRequest, got {type(request).__name__}")
+
         # Convert the exception into a structured Throwable object
-        throwable = self.destructureException(exception)
+        throwable = await self.destructureException(exception)
 
-        args = request.args if isinstance(request, CLIRequest) and request.args else []
-        string_args = ' '.join(args)
+        # Convert the request arguments to a string for logging
+        string_args = ' '.join(request.args)
 
         # Log the CLI error message with arguments
         log.error(f"CLI Error: {throwable.message} (Args: {string_args})")

orionis/failure/catch.py

@@ -5,7 +5,9 @@ from orionis.console.tasks.schedule import Schedule
 from orionis.failure.contracts.catch import ICatch
 from orionis.failure.contracts.handler import IBaseExceptionHandler
 from orionis.foundation.contracts.application import IApplication
+from orionis.services.asynchrony.coroutines import Coroutine
 from orionis.services.log.contracts.log_service import ILogger
+import asyncio
 
 class Catch(ICatch):
 
@@ -74,21 +76,89 @@ class Catch(ICatch):
         If a valid kernel is provided, the exception details are rendered to the CLI.
         """
 
-        # Check if the exception should be ignored by the handler
-        if self.__exception_handler.shouldIgnoreException(e):
-            return
-
-        # Report the exception using the application's exception handler and logger
-        self.__exception_handler.report(
-            exception=e,
-            log=self.__logger
-        )
-
-        # If a kernel is provided, render the exception details to the CLI
-        if isinstance(kernel, KernelCLI) or isinstance(kernel, Schedule):
-            return self.__exception_handler.renderCLI(
-                request=request,
-                exception=e,
-                log=self.__logger,
-                console=self.__console
-            )
+        async def handle():
+            """
+            Handles exceptions asynchronously using the provided exception handler.
+
+            This method performs the following steps:
+            1. Determines if the exception should be ignored by invoking the `shouldIgnoreException` method
+               of the exception handler. This method supports both coroutine and regular functions.
+            2. Reports the exception using the `report` method of the exception handler. This method
+               also supports both coroutine and regular functions.
+            3. If the kernel is of type `KernelCLI` or `Any`, it attempts to render the exception
+               for the CLI using the `renderCLI` method of the exception handler. This method supports
+               both coroutine and regular functions.
+
+            Parameters
+            ----------
+            None
+
+            Returns
+            -------
+            Any or None
+            The result of the `renderCLI` method if applicable, otherwise `None`.
+
+            Notes
+            -----
+            - The `self.__exception_handler` is expected to have the methods `shouldIgnoreException`,
+              `report`, and `renderCLI`.
+            - The `self.__logger` is passed to the `report` and `renderCLI` methods for logging purposes.
+            - The `self.__console` is passed to the `renderCLI` method for CLI rendering.
+            """
+
+            # Check if the `shouldIgnoreException` method is a coroutine function
+            if asyncio.iscoroutinefunction(self.__exception_handler.shouldIgnoreException):
+
+                # If it is, await its result to determine if the exception should be ignored
+                if await self.__exception_handler.shouldIgnoreException(e):
+                    return
+
+            else:
+
+                # If it is not a coroutine, call it directly
+                if self.__exception_handler.shouldIgnoreException(e):
+                    return
+
+            # Check if the `report` method is a coroutine function
+            if asyncio.iscoroutinefunction(self.__exception_handler.report):
+
+                # If it is, await its execution to report the exception
+                await self.__exception_handler.report(
+                    exception=e,
+                    log=self.__logger
+                )
+
+            else:
+
+                # If it is not a coroutine, call it directly
+                self.__exception_handler.report(
+                    exception=e,
+                    log=self.__logger
+                )
+
+            # Check if the kernel is of type `KernelCLI` or `Any`
+            if isinstance(kernel, KernelCLI) or isinstance(kernel, Schedule):
+
+                # Check if the `renderCLI` method is a coroutine function
+                if asyncio.iscoroutinefunction(self.__exception_handler.renderCLI):
+
+                    # If it is, await its execution to render the exception for the CLI
+                    return await self.__exception_handler.renderCLI(
+                        request=request,
+                        exception=e,
+                        log=self.__logger,
+                        console=self.__console
+                    )
+
+                else:
+
+                    # If it is not a coroutine, call it directly
+                    return self.__exception_handler.renderCLI(
+                        request=request,
+                        exception=e,
+                        log=self.__logger,
+                        console=self.__console
+                    )
+
+        # Execute the exception handling logic using the Coroutine wrapper
+        Coroutine(handle()).run()

orionis/failure/contracts/handler.py

@@ -7,7 +7,7 @@ from orionis.services.log.contracts.log_service import ILogger
 class IBaseExceptionHandler:
 
     @abstractmethod
-    def destructureException(self, e: BaseException):
+    async def destructureException(self, e: BaseException):
         """
         Converts an exception into a structured `Throwable` object containing detailed information.
 
@@ -29,7 +29,7 @@ class IBaseExceptionHandler:
         pass
 
     @abstractmethod
-    def shouldIgnoreException(self, e: BaseException) -> bool:
+    async def shouldIgnoreException(self, e: BaseException) -> bool:
         """
         Determines if the exception should be ignored (not handled) by the handler.
 
@@ -46,7 +46,7 @@ class IBaseExceptionHandler:
         pass
 
     @abstractmethod
-    def report (self, exception: BaseException, log: ILogger) -> Any:
+    async def report (self, exception: BaseException, log: ILogger) -> Any:
         """
         Report or log an exception.
 
@@ -62,7 +62,7 @@ class IBaseExceptionHandler:
         pass
 
     @abstractmethod
-    def renderCLI(self, request: CLIRequest, exception: BaseException, log: ILogger, console: IConsole) -> Any:
+    async def renderCLI(self, request: CLIRequest, exception: BaseException, log: ILogger, console: IConsole) -> Any:
         """
         Render the exception message for CLI output.
 

orionis/metadata/framework.py

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

orionis/services/asynchrony/coroutines.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Any, Coroutine as TypingCoroutine, TypeVar, Union
+from typing import Any, Callable, Coroutine as TypingCoroutine, TypeVar, Union
 from orionis.services.asynchrony.contracts.coroutines import ICoroutine
 from orionis.services.asynchrony.exceptions import OrionisCoroutineException
 from orionis.services.introspection.objects.types import Type
@@ -8,29 +8,128 @@ T = TypeVar("T")
 
 class Coroutine(ICoroutine):
 
-    def __init__(self, func: TypingCoroutine[Any, Any, T]) -> None:
+    def __init__(self, func: Union[TypingCoroutine[Any, Any, T], Callable[..., TypingCoroutine[Any, Any, T]]]) -> None:
         """
-        Wraps a coroutine object and validates its type.
+        Initialize a Coroutine wrapper for managing and executing coroutine objects.
+
+        This constructor accepts either a coroutine object directly or a callable that
+        returns a coroutine when invoked. The wrapped coroutine can later be executed
+        using the run() method with automatic context detection.
+
+        Parameters
+        ----------
+        func : Union[TypingCoroutine[Any, Any, T], Callable[..., TypingCoroutine[Any, Any, T]]]
+            The coroutine object to be wrapped and managed, or a callable that returns
+            a coroutine. This will be stored internally for later execution.
+
+        Returns
+        -------
+        None
+            This is a constructor method and does not return any value.
+
+        Notes
+        -----
+        - The coroutine type validation is performed during execution in the run() method,
+          not during initialization.
+        - Both coroutine objects and coroutine functions are accepted as valid input.
+        """
+
+        # Store the coroutine object or callable for later execution
+        self.__func = func
+
+    def invoke(self, *args, **kwargs) -> Union[T, asyncio.Task, None]:
+        """
+        Invoke the callable coroutine function with the provided arguments.
+
+        This method executes a callable coroutine function or regular function with the given
+        arguments and keyword arguments. It automatically detects the execution context and
+        handles both synchronous and asynchronous execution appropriately.
 
         Parameters
         ----------
-        func : Coroutine
-            The coroutine object to be wrapped and managed.
+        *args : tuple
+            Positional arguments to pass to the callable function.
+        **kwargs : dict
+            Keyword arguments to pass to the callable function.
+
+        Returns
+        -------
+        Union[T, asyncio.Task, None]
+            - T: The result of the coroutine if executed synchronously
+            - asyncio.Task: A task object if scheduled for asynchronous execution
+            - None: If the callable is not a coroutine function
 
         Raises
         ------
         OrionisCoroutineException
-            If the provided object is not a coroutine.
-        """
+            If an error occurs during coroutine execution.
+        RuntimeError
+            If an error occurs during callable execution that is not coroutine-related.
 
-        # Validate that the provided object is a coroutine
-        if not Type(func).isCoroutine():
+        Notes
+        -----
+        - Only callable objects can be invoked with this method
+        - For coroutine functions, execution context is automatically detected
+        - Non-coroutine callables are executed directly and return None
+        - Exceptions are wrapped with appropriate context information
+
+        Examples
+        --------
+        >>> async def my_coro(x, y):
+        ...     return x + y
+        >>> coro = Coroutine(my_coro)
+        >>> result = coro.invoke(1, 2)  # Returns Task or result depending on context
+        """
+        if not callable(self.__func):
             raise OrionisCoroutineException(
-                f"Expected a coroutine object, but got {type(func).__name__}."
+                f"Cannot invoke non-callable object of type {type(self.__func).__name__}"
             )
 
-        # Store the coroutine object for later execution
-        self.__func = func
+        try:
+
+            # Check if the callable is a coroutine function
+            if asyncio.iscoroutinefunction(self.__func):
+
+                # Create the coroutine object
+                coroutine_obj = self.__func(*args, **kwargs)
+
+                try:
+
+                    # Check if we're inside a running event loop
+                    loop = asyncio.get_running_loop()
+                    return loop.create_task(coroutine_obj)
+
+                except RuntimeError:
+
+                    # No running event loop, execute synchronously
+                    try:
+
+                        # Use asyncio.run to execute the coroutine and return its result
+                        return asyncio.run(coroutine_obj)
+
+                    except Exception as e:
+
+                        # Wrap and raise any exceptions that occur during execution
+                        raise OrionisCoroutineException(
+                            f"Failed to execute coroutine synchronously: {str(e)}"
+                        ) from e
+
+            else:
+
+                # Execute regular callable directly
+                return self.__func(*args, **kwargs)
+
+        except OrionisCoroutineException:
+
+            # Re-raise our custom exceptions as-is
+            raise
+
+        except Exception as e:
+
+            # Wrap and raise any other exceptions that occur during invocation
+            raise RuntimeError(
+                f"Unexpected error during callable invocation: {str(e)}"
+            ) from e
 
     def run(self) -> Union[T, asyncio.Future]:
         """
@@ -53,6 +152,12 @@ class Coroutine(ICoroutine):
         - The method automatically detects the execution context and chooses the appropriate execution strategy.
         """
 
+        # Validate that the provided object is a coroutine
+        if not Type(self.__func).isCoroutine():
+            raise OrionisCoroutineException(
+                f"Expected a coroutine object, but got {type(self.__func).__name__}."
+            )
+
         # Attempt to get the currently running event loop
         try:
             loop = asyncio.get_running_loop()

{orionis-0.532.0.dist-info → orionis-0.534.0.dist-info}/METADATA

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

{orionis-0.532.0.dist-info → orionis-0.534.0.dist-info}/RECORD

@@ -13,6 +13,7 @@ orionis/console/base/scheduler_event_listener.py,sha256=tmdAMPzTmT8z0BcpyoIZwyTR
 orionis/console/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/commands/cache.py,sha256=8DsYoRzSBLn0P9qkGVItRbo0R6snWBDBg0_Xa7tmVhs,2322
 orionis/console/commands/help.py,sha256=zfSw0pYaOnFN-_Ozdn4veBQDYMgSSDY10nPDCi-7tTY,3199
+orionis/console/commands/make_listener.py,sha256=iPOMCc41njwUKurxSwatZUTjpp-bBLdO9nN-w2FJ4mI,1921
 orionis/console/commands/publisher.py,sha256=FUg-EUzK7LLXsla10ZUZro8V0Z5S-KjmsaSdRHSSGbA,21381
 orionis/console/commands/scheduler_list.py,sha256=A2N_mEXEJDHO8DX2TDrL1ROeeRhFSkWD3rCw64Hrf0o,4763
 orionis/console/commands/scheduler_work.py,sha256=mzSFes8Wl1gCf253tNYClij0abT5HlpW1QZVFrU5EXo,6445
@@ -28,7 +29,7 @@ orionis/console/contracts/schedule.py,sha256=17cfPYtLo-jqF8FxYOhh4epJZnxw5mMPuLG
 orionis/console/contracts/schedule_event_listener.py,sha256=7fQdPh6X_npfGpQW_2x81D7-5Pe40jIog9uDeEU0kro,4390
 orionis/console/contracts/scheduler.py,sha256=OW-a_YDDNPrenYT9z8Tv71VjyZ1aSzqzqhTBhTCZhGM,7698
 orionis/console/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/console/core/reactor.py,sha256=AG2i38YRTHSRG-eO2lNCy9P-Qfll297EvxYHCT_wvV0,30512
+orionis/console/core/reactor.py,sha256=cUYZwOyWjKai885peSaRRu3vM0IpWxskCNyl9IangHs,30626
 orionis/console/dumper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/dumper/dump.py,sha256=CATERiQ6XuIrKQsDaWcVxzTtlAJI9qLJX44fQxEX8ws,22443
 orionis/console/dumper/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -83,7 +84,7 @@ orionis/console/request/cli_request.py,sha256=7-sgYmNUCipuHLVAwWLJiHv0cJCDmsM1Lu
 orionis/console/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console/tasks/event.py,sha256=l4J-HEPaj1mxB_PYQMgG9dRHUe01wUag8fKLLnR2N2M,164395
 orionis/console/tasks/listener.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/console/tasks/schedule.py,sha256=oezk-Z0L2hyB13c0KdWYnLL1mcQVzXBPmqgcbAapJ1w,82546
+orionis/console/tasks/schedule.py,sha256=lou90LaOWw4_tw2ONrplVOEUI9A5esKspFL900EIUBI,82842
 orionis/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/container/container.py,sha256=aF_b6lTUpG4YCo9yFJEzsntTdIzgMMXFW5LyWqAJVBQ,87987
 orionis/container/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -116,12 +117,12 @@ orionis/container/validators/is_subclass.py,sha256=4sBaGLoRs8nUhuWjlP0VJqyTwVHYq
 orionis/container/validators/is_valid_alias.py,sha256=4uAYcq8xov7jZbXnpKpjNkxcZtlTNnL5RRctVPMwJes,1424
 orionis/container/validators/lifetime.py,sha256=IQ43fDNrxYHMlZH2zlYDJnlkLO_eS4U7Fs3UJgQBidI,1844
 orionis/failure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/failure/catch.py,sha256=Tk2IE6lpt2n3jHn4--3U-QLyDrBIwUnNnKi7ZRmGnOg,3715
+orionis/failure/catch.py,sha256=kmw2mbkGrFNw9s8jrr2NdJeGlbJVvXQQSlnjltwC4oM,6819
 orionis/failure/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/failure/base/handler.py,sha256=L6jB2_2f8ZKBuys8o_iXTwMM_yjQHY7iXNF1Q3X8BGY,4661
+orionis/failure/base/handler.py,sha256=a7fQJMWVjALwFiITRsMYg3s7WSO6zcbmq171iQRWy48,4867
 orionis/failure/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/failure/contracts/catch.py,sha256=e2wM1p6VxbvAjgWm-MwoM9p2ystSsyBu8Qnt6Ehr6Vc,1179
-orionis/failure/contracts/handler.py,sha256=4N9yMkMgdhtHbRGAyCtuTx3GmkPP74vhqdRLmwl-ckQ,2216
+orionis/failure/contracts/handler.py,sha256=drNE8iu8RUHi3TgKn-lUEIfVsZeGsMTUecTZOfay19E,2240
 orionis/failure/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/failure/entities/throwable.py,sha256=ogys062uhim5QMYU62ezlnumRAnYQlUf_vZvQY47S3U,1227
 orionis/foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -241,11 +242,11 @@ orionis/foundation/providers/scheduler_provider.py,sha256=1do4B09bU_6xbFHHVYYTGM
 orionis/foundation/providers/testing_provider.py,sha256=SrJRpdvcblx9WvX7x9Y3zc7OQfiTf7la0HAJrm2ESlE,3725
 orionis/foundation/providers/workers_provider.py,sha256=oa_2NIDH6UxZrtuGkkoo_zEoNIMGgJ46vg5CCgAm7wI,3926
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=w2kA3Bwp6FiLOMcy7SJ7LlQTYV53dTXsZaNAfgJrq80,4109
+orionis/metadata/framework.py,sha256=nuA2nefeGQ2B3VGS-om5qZigBmEBbAZwhTnm54CFJn0,4109
 orionis/metadata/package.py,sha256=k7Yriyp5aUcR-iR8SK2ec_lf0_Cyc-C7JczgXa-I67w,16039
 orionis/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/asynchrony/coroutines.py,sha256=8pSSgo-U9ncPLisJqIiu1BKRlWg6p6T6TFrVvh7UMVE,2594
+orionis/services/asynchrony/coroutines.py,sha256=M1o4Al5dk8BR85CWHHUgymVQaD_6PgirenQMeITUoZQ,6863
 orionis/services/asynchrony/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/contracts/coroutines.py,sha256=rVy1HO58RFKliGeaf6GUC7mGtPZXimIhzkFHR1EWRoc,1082
 orionis/services/asynchrony/exceptions/__init__.py,sha256=COm6RhSiuwWqy3YcJ_0gVu6XHjn5P3zVaiUp5Pw_h48,99
@@ -419,7 +420,7 @@ orionis/test/validators/web_report.py,sha256=n9BfzOZz6aEiNTypXcwuWbFRG0OdHNSmCNu
 orionis/test/validators/workers.py,sha256=rWcdRexINNEmGaO7mnc1MKUxkHKxrTsVuHgbnIfJYgc,1206
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=f-zNhtKSg9R5Njqujbg2l2amAs2-mRVESneLIkWOZjU,4082
-orionis-0.532.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
+orionis-0.534.0.dist-info/licenses/LICENCE,sha256=JhC-z_9mbpUrCfPjcl3DhDA8trNDMzb57cvRSam1avc,1463
 tests/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/context/test_manager.py,sha256=wOwXpl9rHNfTTexa9GBKYMwK0_-KSQPbI-AEyGNkmAE,1356
@@ -512,7 +513,7 @@ tests/metadata/test_metadata_framework.py,sha256=vOsp5owDMMoL5dtgiN9EC5Sdj8pemXV
 tests/metadata/test_metadata_package.py,sha256=AcD5rlkD5MeX2tJvQkIHeGeAl88k0tsF2wOU5v4JVN0,4894
 tests/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/services/asynchrony/test_services_asynchrony_coroutine.py,sha256=34Y0D6w2bVo_dm3oj0wzedMIJuSYieUG9Y2J1EQmZeo,3439
+tests/services/asynchrony/test_services_asynchrony_coroutine.py,sha256=xWdH5CKrXQ8zGSFadEDN_7LoNEAcDWWIBdm2TVQPuLo,3445
 tests/services/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/environment/test_services_environment.py,sha256=8gbF2vK238lracBipHCHgiYxThRnfLtN9pj--rFald0,9570
 tests/services/introspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -565,8 +566,8 @@ tests/testing/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 tests/testing/validators/test_testing_validators.py,sha256=WPo5GxTP6xE-Dw3X1vZoqOMpb6HhokjNSbgDsDRDvy4,16588
 tests/testing/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/view/test_render.py,sha256=tnnMBwS0iKUIbogLvu-7Rii50G6Koddp3XT4wgdFEYM,1050
-orionis-0.532.0.dist-info/METADATA,sha256=LmSfofSx_TzRb1Jptb5XE96fBBqmDlL4ylFo1aeHmQ0,4801
-orionis-0.532.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.532.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.532.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.532.0.dist-info/RECORD,,
+orionis-0.534.0.dist-info/METADATA,sha256=R7FBw3jg3tfT8gujp8PmJLFqoTJK6oXImdwynE9zV9c,4801
+orionis-0.534.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.534.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.534.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.534.0.dist-info/RECORD,,

tests/services/asynchrony/test_services_asynchrony_coroutine.py

@@ -82,4 +82,4 @@ class TestServicesAsynchronyCoroutine(AsyncTestCase):
 
         # Assert that passing a non-coroutine raises OrionisCoroutineException
         with self.assertRaises(OrionisCoroutineException):
-            Coroutine(sample_no_coroutine())
+            Coroutine(sample_no_coroutine()).run()