|
|
""" |
|
|
Async utilities for OpenEvolve |
|
|
""" |
|
|
|
|
|
import asyncio |
|
|
import functools |
|
|
import logging |
|
|
import time |
|
|
from typing import Any, Callable, Dict, List, Optional, TypeVar, Union |
|
|
|
|
|
logger = logging.getLogger(__name__) |
|
|
|
|
|
T = TypeVar("T") |
|
|
|
|
|
|
|
|
def run_in_executor(f: Callable) -> Callable: |
|
|
""" |
|
|
Decorator to run a synchronous function in an executor |
|
|
|
|
|
Args: |
|
|
f: Function to decorate |
|
|
|
|
|
Returns: |
|
|
Decorated function that runs in an executor |
|
|
""" |
|
|
|
|
|
@functools.wraps(f) |
|
|
async def wrapper(*args: Any, **kwargs: Any) -> Any: |
|
|
loop = asyncio.get_event_loop() |
|
|
return await loop.run_in_executor(None, functools.partial(f, *args, **kwargs)) |
|
|
|
|
|
return wrapper |
|
|
|
|
|
|
|
|
async def run_with_timeout( |
|
|
coro: Callable, timeout: float, *args: Any, timeout_error_value: Any = None, **kwargs: Any |
|
|
) -> Any: |
|
|
""" |
|
|
Run a coroutine with a timeout, returning a default value on timeout |
|
|
|
|
|
Args: |
|
|
coro: Coroutine function to run |
|
|
timeout: Timeout in seconds |
|
|
*args: Arguments to pass to the coroutine |
|
|
timeout_error_value: Value to return on timeout (default: {"error": 0.0, "timeout": True}) |
|
|
**kwargs: Keyword arguments to pass to the coroutine |
|
|
|
|
|
Returns: |
|
|
Result of the coroutine or timeout_error_value on timeout |
|
|
""" |
|
|
if timeout_error_value is None: |
|
|
timeout_error_value = {"error": 0.0, "timeout": True} |
|
|
|
|
|
try: |
|
|
return await asyncio.wait_for(coro(*args, **kwargs), timeout=timeout) |
|
|
except asyncio.TimeoutError: |
|
|
logger.warning(f"Operation timed out after {timeout}s") |
|
|
return timeout_error_value |
|
|
|
|
|
|
|
|
async def run_sync_with_timeout( |
|
|
func: Callable, timeout: float, *args: Any, timeout_error_value: Any = None, **kwargs: Any |
|
|
) -> Any: |
|
|
""" |
|
|
Run a synchronous function in an executor with a timeout |
|
|
|
|
|
Args: |
|
|
func: Synchronous function to run |
|
|
timeout: Timeout in seconds |
|
|
*args: Arguments to pass to the function |
|
|
timeout_error_value: Value to return on timeout (default: {"error": 0.0, "timeout": True}) |
|
|
**kwargs: Keyword arguments to pass to the function |
|
|
|
|
|
Returns: |
|
|
Result of the function or timeout_error_value on timeout |
|
|
""" |
|
|
if timeout_error_value is None: |
|
|
timeout_error_value = {"error": 0.0, "timeout": True} |
|
|
|
|
|
try: |
|
|
loop = asyncio.get_event_loop() |
|
|
task = loop.run_in_executor(None, functools.partial(func, *args, **kwargs)) |
|
|
return await asyncio.wait_for(task, timeout=timeout) |
|
|
except asyncio.TimeoutError: |
|
|
logger.warning(f"Sync operation timed out after {timeout}s") |
|
|
return timeout_error_value |
|
|
|
|
|
|
|
|
async def gather_with_concurrency( |
|
|
n: int, *tasks: asyncio.Future, return_exceptions: bool = False |
|
|
) -> List[Any]: |
|
|
""" |
|
|
Run tasks with a concurrency limit |
|
|
|
|
|
Args: |
|
|
n: Maximum number of tasks to run concurrently |
|
|
*tasks: Tasks to run |
|
|
return_exceptions: Whether to return exceptions instead of raising them |
|
|
|
|
|
Returns: |
|
|
List of task results |
|
|
""" |
|
|
semaphore = asyncio.Semaphore(n) |
|
|
|
|
|
async def sem_task(task: asyncio.Future) -> Any: |
|
|
async with semaphore: |
|
|
return await task |
|
|
|
|
|
return await asyncio.gather( |
|
|
*(sem_task(task) for task in tasks), return_exceptions=return_exceptions |
|
|
) |
|
|
|
|
|
|
|
|
async def retry_async( |
|
|
coro: Callable, |
|
|
*args: Any, |
|
|
retries: int = 3, |
|
|
delay: float = 1.0, |
|
|
backoff: float = 2.0, |
|
|
exceptions: Union[Exception, tuple] = Exception, |
|
|
**kwargs: Any, |
|
|
) -> Any: |
|
|
""" |
|
|
Retry an async function with exponential backoff |
|
|
|
|
|
Args: |
|
|
coro: Coroutine function to retry |
|
|
*args: Arguments to pass to the coroutine |
|
|
retries: Maximum number of retries |
|
|
delay: Initial delay between retries (seconds) |
|
|
backoff: Multiplier for delay between retries |
|
|
exceptions: Exception(s) to catch |
|
|
**kwargs: Keyword arguments to pass to the coroutine |
|
|
|
|
|
Returns: |
|
|
Result of the coroutine |
|
|
|
|
|
Raises: |
|
|
The last exception caught if all retries fail |
|
|
""" |
|
|
last_exception = None |
|
|
current_delay = delay |
|
|
|
|
|
for i in range(retries + 1): |
|
|
try: |
|
|
return await coro(*args, **kwargs) |
|
|
except exceptions as e: |
|
|
last_exception = e |
|
|
if i < retries: |
|
|
logger.warning( |
|
|
f"Retry {i+1}/{retries} failed with {type(e).__name__}: {str(e)}. " |
|
|
f"Retrying in {current_delay:.2f}s..." |
|
|
) |
|
|
await asyncio.sleep(current_delay) |
|
|
current_delay *= backoff |
|
|
else: |
|
|
logger.error( |
|
|
f"All {retries+1} attempts failed. Last error: {type(e).__name__}: {str(e)}" |
|
|
) |
|
|
|
|
|
if last_exception: |
|
|
raise last_exception |
|
|
|
|
|
return None |
|
|
|
|
|
|
|
|
class TaskPool: |
|
|
""" |
|
|
A simple task pool for managing and limiting concurrent tasks |
|
|
""" |
|
|
|
|
|
def __init__(self, max_concurrency: int = 10): |
|
|
self.max_concurrency = max_concurrency |
|
|
self._semaphore: Optional[asyncio.Semaphore] = None |
|
|
self.tasks: List[asyncio.Task] = [] |
|
|
|
|
|
@property |
|
|
def semaphore(self) -> asyncio.Semaphore: |
|
|
"""Lazy-initialize the semaphore when first needed""" |
|
|
if self._semaphore is None: |
|
|
self._semaphore = asyncio.Semaphore(self.max_concurrency) |
|
|
return self._semaphore |
|
|
|
|
|
async def run(self, coro: Callable, *args: Any, **kwargs: Any) -> Any: |
|
|
""" |
|
|
Run a coroutine in the pool |
|
|
|
|
|
Args: |
|
|
coro: Coroutine function to run |
|
|
*args: Arguments to pass to the coroutine |
|
|
**kwargs: Keyword arguments to pass to the coroutine |
|
|
|
|
|
Returns: |
|
|
Result of the coroutine |
|
|
""" |
|
|
async with self.semaphore: |
|
|
return await coro(*args, **kwargs) |
|
|
|
|
|
def create_task(self, coro: Callable, *args: Any, **kwargs: Any) -> asyncio.Task: |
|
|
""" |
|
|
Create and track a task in the pool |
|
|
|
|
|
Args: |
|
|
coro: Coroutine function to run |
|
|
*args: Arguments to pass to the coroutine |
|
|
**kwargs: Keyword arguments to pass to the coroutine |
|
|
|
|
|
Returns: |
|
|
Task object |
|
|
""" |
|
|
task = asyncio.create_task(self.run(coro, *args, **kwargs)) |
|
|
self.tasks.append(task) |
|
|
task.add_done_callback(lambda t: self.tasks.remove(t)) |
|
|
return task |
|
|
|
|
|
async def wait_all(self) -> None: |
|
|
"""Wait for all tasks in the pool to complete""" |
|
|
if self.tasks: |
|
|
await asyncio.gather(*self.tasks) |
|
|
|
|
|
async def cancel_all(self) -> None: |
|
|
"""Cancel all tasks in the pool""" |
|
|
for task in self.tasks: |
|
|
task.cancel() |
|
|
|
|
|
if self.tasks: |
|
|
await asyncio.gather(*self.tasks, return_exceptions=True) |
|
|
|
