orionis 0.534.0__tar.gz → 0.536.0__tar.gz

{orionis-0.534.0/orionis.egg-info → orionis-0.536.0}/PKG-INFO

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

{orionis-0.534.0 → orionis-0.536.0}/orionis/console/tasks/schedule.py

@@ -707,7 +707,7 @@ class Schedule(ISchedule):
             and listener invocation for the job error event.
         """
         # Log an error message indicating that the job raised an exception
-        self.__logger.error(f"Task {event.job_id} raised an exception: {event.exception}")
+        self.__logger.error(f"Task '{event.job_id}' raised an exception: {event.exception}")
 
         # If a listener is registered for this job ID, invoke the listener with the event details
         job_event_data = self.__getTaskFromSchedulerById(event.job_id)
@@ -758,7 +758,7 @@ class Schedule(ISchedule):
         """
 
         # Log an informational message indicating that the job has been submitted
-        self.__logger.info(f"Task {event.job_id} submitted to executor.")
+        self.__logger.info(f"Task '{event.job_id}' submitted to executor.")
 
         # Create entity for job submitted event
         data_event = self.__getTaskFromSchedulerById(event.job_id, event.code)
@@ -793,7 +793,7 @@ class Schedule(ISchedule):
         """
 
         # Log an informational message indicating that the job has been executed
-        self.__logger.info(f"Task {event.job_id} executed.")
+        self.__logger.info(f"Task '{event.job_id}' executed.")
 
         # Create entity for job executed event
         data_event = self.__getTaskFromSchedulerById(event.job_id, event.code)
@@ -828,7 +828,7 @@ class Schedule(ISchedule):
         """
 
         # Log a warning indicating that the job was missed
-        self.__logger.warning(f"Task {event.job_id} was missed. It was scheduled to run at {event.scheduled_run_time}.")
+        self.__logger.warning(f"Task '{event.job_id}' was missed. It was scheduled to run at {event.scheduled_run_time}.")
 
         # Create entity for job missed event
         data_event = self.__getTaskFromSchedulerById(event.job_id, event.code)
@@ -863,7 +863,7 @@ class Schedule(ISchedule):
         """
 
         # Log an error message indicating that the job exceeded maximum instances
-        self.__logger.error(f"Task {event.job_id} exceeded maximum instances")
+        self.__logger.error(f"Task '{event.job_id}' exceeded maximum instances")
 
         # Create entity for job max instances event
         data_event = self.__getTaskFromSchedulerById(event.job_id, event.code)
@@ -897,7 +897,7 @@ class Schedule(ISchedule):
         """
 
         # Log the removal of the job
-        self.__logger.info(f"Task {event.job_id} has been removed.")
+        self.__logger.info(f"Task '{event.job_id}' has been removed.")
 
         # Create entity for job removed event
         data_event = self.__getTaskFromSchedulerById(event.job_id, event.code)

{orionis-0.534.0 → orionis-0.536.0}/orionis/foundation/application.py

@@ -24,6 +24,7 @@ from orionis.foundation.config.testing.entities.testing import Testing
 from orionis.foundation.contracts.application import IApplication
 from orionis.foundation.exceptions import OrionisTypeError, OrionisRuntimeError, OrionisValueError
 from orionis.foundation.providers.logger_provider import LoggerProvider
+from orionis.services.asynchrony.coroutines import Coroutine
 from orionis.services.log.contracts.log_service import ILogger
 
 class Application(Container, IApplication):
@@ -342,7 +343,7 @@ class Application(Container, IApplication):
             # Register the provider in the container
             # Check if register is a coroutine function
             if asyncio.iscoroutinefunction(class_provider.register):
-                asyncio.run(class_provider.register())
+                Coroutine(class_provider.register).run()
             else:
                 class_provider.register()
 
@@ -379,7 +380,7 @@ class Application(Container, IApplication):
             if hasattr(provider, 'boot') and callable(getattr(provider, 'boot')):
                 # Check if boot is a coroutine function
                 if asyncio.iscoroutinefunction(provider.boot):
-                    asyncio.run(provider.boot())
+                    Coroutine(provider.boot).run()
                 else:
                     provider.boot()
 

{orionis-0.534.0 → orionis-0.536.0}/orionis/metadata/framework.py

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

orionis-0.536.0/orionis/services/asynchrony/contracts/coroutines.py

@@ -0,0 +1,76 @@
+from abc import ABC, abstractmethod
+import asyncio
+from typing import TypeVar, Union
+
+T = TypeVar("T")
+
+class ICoroutine(ABC):
+
+    @abstractmethod
+    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
+        ----------
+        *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 an error occurs during coroutine execution.
+        RuntimeError
+            If an error occurs during callable execution that is not coroutine-related.
+
+        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
+        """
+        pass
+
+    @abstractmethod
+    def run(self) -> Union[T, asyncio.Future]:
+        """
+        Executes the wrapped coroutine, adapting to the current event loop context.
+
+        Returns
+        -------
+        T or asyncio.Future
+            The result of the coroutine if executed synchronously, or an asyncio.Future if scheduled asynchronously.
+
+        Raises
+        ------
+        RuntimeError
+            If the coroutine cannot be executed due to event loop issues.
+
+        Notes
+        -----
+        - If called outside an active event loop, the coroutine is executed synchronously and its result is returned.
+        - If called within an active event loop, the coroutine is scheduled for asynchronous execution and a Future is returned.
+        - The method automatically detects the execution context and chooses the appropriate execution strategy.
+        """
+        pass

{orionis-0.534.0 → orionis-0.536.0/orionis.egg-info}/PKG-INFO

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

orionis-0.534.0/orionis/services/asynchrony/contracts/coroutines.py

@@ -1,28 +0,0 @@
-from abc import ABC, abstractmethod
-import asyncio
-from typing import TypeVar, Union
-
-T = TypeVar("T")
-
-class ICoroutine(ABC):
-
-    @abstractmethod
-    def run(self) -> Union[T, asyncio.Future]:
-        """
-        Execute the wrapped coroutine either synchronously or asynchronously, depending on the execution context.
-
-        Returns
-        -------
-        T or asyncio.Future
-            If called outside of an event loop, returns the result of the coroutine execution (type T).
-            If called within an event loop, returns an asyncio.Future representing the scheduled coroutine.
-
-        Notes
-        -----
-        - Executes the coroutine synchronously and returns its result when called outside an event loop.
-        - Schedules the coroutine for asynchronous execution and returns a Future when called inside an event loop.
-        - The caller is responsible for awaiting the Future if asynchronous execution is used.
-        """
-
-        # This method should be implemented by subclasses to handle coroutine execution.
-        pass