sunholo 0.101.2__tar.gz → 0.101.5__tar.gz

{sunholo-0.101.2 → sunholo-0.101.5}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.101.2
+Version: 0.101.5
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.101.2.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.101.5.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0

{sunholo-0.101.2 → sunholo-0.101.5}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-version = '0.101.2'
+version = '0.101.5'
 
 setup(
     name='sunholo',

{sunholo-0.101.2 → sunholo-0.101.5}/sunholo/invoke/async_class.py

@@ -8,17 +8,23 @@ from tenacity import AsyncRetrying, retry_if_exception_type, wait_random_exponen
 log = setup_logging("sunholo_AsyncTaskRunner")
 
 class AsyncTaskRunner:
-    def __init__(self, retry_enabled=False, retry_kwargs=None):
+    def __init__(self, retry_enabled=False, retry_kwargs=None, timeout=120):
         self.tasks = []
         self.retry_enabled = retry_enabled
         self.retry_kwargs = retry_kwargs or {}
+        self.timeout = timeout
 
-    def add_task(self, func: Callable[..., Any], *args: Any):
+    def add_task(self, func: Callable[..., Any], *args: Any, **kwargs: Any):
         """
-        Adds a task to the list of tasks to be executed.
+        Adds a task to the list of tasks to be executed, supporting both positional and keyword arguments.
+
+        Args:
+            func: The function to be executed.
+            *args: Positional arguments for the function.
+            **kwargs: Keyword arguments for the function.
         """
-        log.info(f"Adding task: {func.__name__} with args: {args}")
-        self.tasks.append((func.__name__, func, args))
+        log.info(f"Adding task: {func.__name__} with args: {args}, kwargs: {kwargs}")
+        self.tasks.append((func.__name__, func, args, kwargs))
 
     async def run_async_as_completed(self) -> AsyncGenerator[Dict[str, Any], None]:
         """
@@ -26,53 +32,36 @@ class AsyncTaskRunner:
         while periodically sending heartbeat messages.
         """
         log.info("Running tasks asynchronously and yielding results as they complete")
-
-        # Create a queue for inter-coroutine communication
         queue = asyncio.Queue()
-
-        # List to keep track of all running tasks and their heartbeats
         task_infos = []
 
-        # Start all tasks and their corresponding heartbeats
-        for name, func, args in self.tasks:
-            # Create an event to signal task completion to the heartbeat
+        for name, func, args, kwargs in self.tasks:
+            log.info(f"Executing task: {name=}, {func=} with args: {args}, kwargs: {kwargs}")
             completion_event = asyncio.Event()
-
-            # Start the main task with retries
-            task_coro = self._run_with_retries(name, func, *args, queue=queue, completion_event=completion_event)
+            task_coro = self._run_with_retries_and_timeout(name, func, args, kwargs, queue, completion_event)            
             task = asyncio.create_task(task_coro)
-
-            # Start the heartbeat coroutine
             heartbeat_coro = self._send_heartbeat(name, completion_event, queue)
             heartbeat_task = asyncio.create_task(heartbeat_coro)
-
-            # Store task information for management
             task_infos.append({
                 'name': name,
                 'task': task,
                 'heartbeat_task': heartbeat_task,
                 'completion_event': completion_event
             })
-
             log.info(f"Started task '{name}' and its heartbeat")
 
         log.info(f"Started async run with {len(self.tasks)} tasks and heartbeats")
-
-        # Create a monitor task to detect when all tasks and heartbeats are done
         monitor = asyncio.create_task(self._monitor_tasks(task_infos, queue))
 
-        # Continuously yield messages from the queue until sentinel is received
         while True:
             message = await queue.get()
             if message is None:
                 log.info("Received sentinel. Exiting message loop.")
-                break  # Sentinel received, all tasks and heartbeats are done
+                break
             log.info(f"Received message from queue: {message}")
             yield message
 
-        # Wait for the monitor to finish
         await monitor
-
         log.info("All tasks and heartbeats have completed")
 
     async def _monitor_tasks(self, task_infos, queue):
@@ -94,15 +83,18 @@ class AsyncTaskRunner:
                 pass
             log.info(f"Monitor: Heartbeat for task '{info['name']}' has been canceled")
 
-        # Send a sentinel to indicate completion
         await queue.put(None)
         log.info("Monitor: Sent sentinel to queue")
 
-    async def _run_with_retries(self, name: str, func: Callable[..., Any], *args: Any, queue: asyncio.Queue, completion_event: asyncio.Event) -> None:
-        """
-        Executes a task with optional retries and sends completion or error messages to the queue.
-        """
+    async def _run_with_retries_and_timeout(self, 
+                                            name: str,
+                                            func: Callable[..., Any], 
+                                            args: tuple,
+                                            kwargs: dict,
+                                            queue: asyncio.Queue, 
+                                            completion_event: asyncio.Event) -> None:
         try:
+            log.info(f"run_with_retries_and_timeout: {name=}, {func=} with args: {args}, kwargs: {kwargs}")
             if self.retry_enabled:
                 retry_kwargs = {
                     'wait': wait_random_exponential(multiplier=1, max=60),
@@ -113,39 +105,41 @@ class AsyncTaskRunner:
                 async for attempt in AsyncRetrying(**retry_kwargs):
                     with attempt:
                         log.info(f"Starting task '{name}' with retry")
-                        result = await self._execute_task(func, *args)
+                        result = await asyncio.wait_for(self._execute_task(func, *args, **kwargs), timeout=self.timeout)
                         await queue.put({'type': 'task_complete', 'func_name': name, 'result': result})
                         log.info(f"Sent 'task_complete' message for task '{name}'")
                         return
             else:
                 log.info(f"Starting task '{name}' with no retry")
-                result = await self._execute_task(func, *args)
+                result = await asyncio.wait_for(self._execute_task(func, *args, **kwargs), timeout=self.timeout)
                 await queue.put({'type': 'task_complete', 'func_name': name, 'result': result})
                 log.info(f"Sent 'task_complete' message for task '{name}'")
+        except asyncio.TimeoutError:
+            log.error(f"Task '{name}' timed out after {self.timeout} seconds")
+            await queue.put({'type': 'task_error', 'func_name': name, 'error': f'Task timed out after {self.timeout} seconds'})
         except Exception as e:
             log.error(f"Error in task '{name}': {e}\n{traceback.format_exc()}")
             await queue.put({'type': 'task_error', 'func_name': name, 'error': f'{e}\n{traceback.format_exc()}'})
-            log.info(f"Sent 'task_error' message for task '{name}'")
         finally:
             log.info(f"Task '{name}' completed.")
-            # Set the completion event after sending the message
             completion_event.set()
 
-    async def _execute_task(self, func: Callable[..., Any], *args: Any) -> Any:
+    async def _execute_task(self, func: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
         """
         Executes the given task function and returns its result.
 
         Args:
             func (Callable): The callable to execute.
-            *args: Arguments to pass to the callable.
+            *args: Positional arguments to pass to the callable.
+            **kwargs: Keyword arguments to pass to the callable.
 
         Returns:
             Any: The result of the task.
         """
         if asyncio.iscoroutinefunction(func):
-            return await func(*args)
+            return await func(*args, **kwargs)
         else:
-            return await asyncio.to_thread(func, *args)
+            return await asyncio.to_thread(func, *args, **kwargs)
 
     async def _send_heartbeat(self, func_name: str, completion_event: asyncio.Event, queue: asyncio.Queue, interval: int = 2):
         """
@@ -174,5 +168,4 @@ class AsyncTaskRunner:
         except asyncio.CancelledError:
             log.info(f"Heartbeat for task '{func_name}' has been canceled")
         finally:
-            log.info(f"Heartbeat for task '{func_name}' stopped")
-
+            log.info(f"Heartbeat for task '{func_name}' stopped")

{sunholo-0.101.2 → sunholo-0.101.5}/sunholo.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.101.2
+Version: 0.101.5
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.101.2.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.101.5.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0

{sunholo-0.101.2 → sunholo-0.101.5}/tests/test_async.py

@@ -33,6 +33,10 @@ def format_token_output(func_name, tokens, result=None, error=None):
 async def count_tokens(result):
     return len(result.split())
 
+async def kwargs_function(required_arg, **kwargs):
+    await asyncio.sleep(3)  # Simulate a medium-running task
+    return f"Required arg: {required_arg}, Optional args: {kwargs}"
+
 # Example usage
 async def main():
     runner = AsyncTaskRunner(retry_enabled=True)
@@ -41,6 +45,7 @@ async def main():
     runner.add_task(google_search, "<original user question>...", "<config>")
     runner.add_task(use_pdfs, "<original user question>...", None, None)
     runner.add_task(process_urls, "please give me a forecast of ppas for spain using wind energy")
+    runner.add_task(kwargs_function, "required_value", optional_arg1="test", optional_arg2=42)
     
     callback = MockCallback()
     answers = {}