Skip to content

armgit / burr

Public Imported from GitHub
0

Build applications that make decisions (chatbots, agents, simulations, etc...). Monitor, trace, persist, and execute on your own infrastructure.

Adds async utils files

elijahbenizzyb2eef9eb027f
diff --git a/burr/common/async_utils.py b/burr/common/async_utils.py
new file mode 100644
index 00000000..94e573cd
--- /dev/null
+++ b/burr/common/async_utils.py
@@ -0,0 +1,40 @@
+import inspect
+from typing import AsyncGenerator, AsyncIterable, Generator, List, TypeVar, Union
+
+T = TypeVar("T")
+
+GenType = TypeVar("GenType")
+ReturnType = TypeVar("ReturnType")
+
+SyncOrAsyncIterable = Union[AsyncIterable[T], List[T]]
+SyncOrAsyncGenerator = Union[Generator[GenType, None, None], AsyncGenerator[GenType, None]]
+SyncOrAsyncGeneratorOrItemOrList = Union[SyncOrAsyncGenerator[GenType], List[GenType], GenType]
+
+
+async def asyncify_generator(
+ generator: SyncOrAsyncGenerator[GenType],
+) -> AsyncGenerator[GenType, None]:
+ """Convert a sync generator to an async generator.
+
+ :param generator: sync generator
+ :return: async generator
+ """
+ if inspect.isasyncgen(generator):
+ async for item in generator:
+ yield item
+ else:
+ for item in generator:
+ yield item
+
+
+async def arealize(maybe_async_generator: SyncOrAsyncGenerator[GenType]) -> List[GenType]:
+ """Realize an async generator or async iterable to a list.
+
+ :param maybe_async_generator: async generator or async iterable
+ :return: list
+ """
+ if inspect.isasyncgen(maybe_async_generator):
+ out = [item async for item in maybe_async_generator]
+ else:
+ out = [item for item in maybe_async_generator]
+ return out
diff --git a/tests/common/test_async_utils.py b/tests/common/test_async_utils.py
new file mode 100644
index 00000000..62ec9182
--- /dev/null
+++ b/tests/common/test_async_utils.py
@@ -0,0 +1,93 @@
+from typing import AsyncGenerator, Generator
+
+from burr.common.async_utils import arealize, asyncify_generator
+
+
+async def test_asyncify_generator_with_sync_generator():
+ def sync_gen() -> Generator[int, None, None]:
+ for i in range(5):
+ yield i
+
+ generator = sync_gen()
+ async_generator = asyncify_generator(generator)
+
+ result = [item async for item in async_generator]
+ assert result == [0, 1, 2, 3, 4], "Should convert sync generator to async generator"
+
+
+async def test_asyncify_generator_with_async_generator():
+ async def async_gen() -> AsyncGenerator[int, None]:
+ for i in range(5):
+ yield i
+
+ generator = async_gen()
+ async_generator = asyncify_generator(generator)
+
+ result = [item async for item in async_generator]
+ assert result == [0, 1, 2, 3, 4], "Should pass through async generator unchanged"
+
+
+# Test cases for arealize
+async def test_arealize_with_sync_generator():
+ def sync_gen() -> Generator[int, None, None]:
+ for i in range(5):
+ yield i
+
+ generator = sync_gen()
+ result = await arealize(generator)
+ assert result == [0, 1, 2, 3, 4], "Should convert sync generator to list"
+
+
+async def test_arealize_with_async_generator():
+ async def async_gen() -> AsyncGenerator[int, None]:
+ for i in range(5):
+ yield i
+
+ generator = async_gen()
+ result = await arealize(generator)
+ assert result == [0, 1, 2, 3, 4], "Should realize async generator to list"
+
+
+# Edge cases
+async def test_asyncify_generator_empty_sync_generator():
+ def sync_gen() -> Generator[int, None, None]:
+ if False: # No items to yield
+ yield
+
+ generator = sync_gen()
+ async_generator = asyncify_generator(generator)
+
+ result = [item async for item in async_generator]
+ assert result == [], "Should handle empty sync generator"
+
+
+async def test_arealize_empty_sync_generator():
+ def sync_gen() -> Generator[int, None, None]:
+ if False: # No items to yield
+ yield
+
+ generator = sync_gen()
+ result = await arealize(generator)
+ assert result == [], "Should handle empty sync generator to list"
+
+
+async def test_asyncify_generator_empty_async_generator():
+ async def async_gen() -> AsyncGenerator[int, None]:
+ if False: # No items to yield
+ yield
+
+ generator = async_gen()
+ async_generator = asyncify_generator(generator)
+
+ result = [item async for item in async_generator]
+ assert result == [], "Should handle empty async generator"
+
+
+async def test_arealize_empty_async_generator():
+ async def async_gen() -> AsyncGenerator[int, None]:
+ if False: # No items to yield
+ yield
+
+ generator = async_gen()
+ result = await arealize(generator)
+ assert result == [], "Should handle empty async generator to list"