dataroom-client 1.0.4.post12.dev0__tar.gz → 1.0.5.post2.dev0__tar.gz

{dataroom_client-1.0.4.post12.dev0 → dataroom_client-1.0.5.post2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: dataroom-client
-Version: 1.0.4.post12.dev0
+Version: 1.0.5.post2.dev0
 Summary: A python client to interface with the Dataroom backend API
 Author: Ales Kocjancic
 Author-email: hi@ales.io
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: httpx (>=0.28.0,<1)
 Description-Content-Type: text/markdown
 

{dataroom_client-1.0.4.post12.dev0 → dataroom_client-1.0.5.post2.dev0}/dataroom_client/client.py

@@ -3,6 +3,7 @@ import functools
 import inspect
 import threading
 import atexit
+import queue
 from datetime import datetime
 import json as json_module
 import logging
@@ -1814,6 +1815,17 @@ class AsyncRunner:
         future = asyncio.run_coroutine_threadsafe(coro, cls._loop)
         return future.result()
 
+    @classmethod
+    def submit(cls, coro):
+        """
+        Schedule a coroutine on the shared background event loop and return the Future.
+
+        Unlike run(), this does not wait for the result; useful for producers feeding queues.
+        """
+        if cls._thread is None:
+            cls._initialize()
+        return asyncio.run_coroutine_threadsafe(coro, cls._loop)
+
     @classmethod
     def shutdown(cls) -> None:
         """
@@ -1866,6 +1878,9 @@ class DataRoomClientSync:
             result = attr(*args, **kwargs)
             if inspect.isawaitable(result):
                 return AsyncRunner.run(result)
+            # If the result is an async generator or async iterable, wrap it into a blocking iterator
+            if inspect.isasyncgen(result) or hasattr(result, "__aiter__"):
+                return self._wrap_async_iterable(result)
             return result
 
         return sync_wrapper
@@ -1886,4 +1901,69 @@ class DataRoomClientSync:
         @return: A DataRoomFile instance containing the downloaded image.
         """
         # Class methods are not covered by the automatic wrapping of async methods in __getattr__.
-        return AsyncRunner.run(DataRoomClient.download_image_from_url(*args, **kwargs))
+        return AsyncRunner.run(DataRoomClient.download_image_from_url(*args, **kwargs))
+
+    @staticmethod
+    def _wrap_async_iterable(async_iterable):
+        """
+        Convert an AsyncIterable into a synchronous, blocking Python iterator.
+        Items are streamed via a thread-safe queue from a background task.
+        """
+        sentinel = object()
+        q: queue.Queue = queue.Queue(maxsize=10)
+        stop_flag = {"stop": False}
+
+        async def aclose_safe(ait):
+            aclose = getattr(ait, "aclose", None)
+            if aclose is not None:
+                try:
+                    await aclose()
+                except Exception:  # pragma: no cover - best effort cleanup
+                    pass
+
+        async def producer():
+            try:
+                async for item in async_iterable:
+                    if stop_flag["stop"]:
+                        await aclose_safe(async_iterable)
+                        break
+                    while True:
+                        try:
+                            q.put_nowait(item)
+                            break
+                        except queue.Full:
+                            if stop_flag["stop"]:
+                                await aclose_safe(async_iterable)
+                                return
+                            await asyncio.sleep(0.01)
+            except Exception as e:
+                # pass exception to consumer then terminate
+                try:
+                    q.put_nowait(e)
+                except queue.Full:
+                    # If full, block briefly in thread to ensure delivery
+                    q.put(e)
+            finally:
+                # Signal completion
+                try:
+                    q.put_nowait(sentinel)
+                except queue.Full:
+                    q.put(sentinel)
+
+        # Start the producer without blocking
+        AsyncRunner.submit(producer())
+
+        def iterator():
+            try:
+                while True:
+                    item = q.get()
+                    if item is sentinel:
+                        break
+                    if isinstance(item, Exception):
+                        raise item
+                    yield item
+            finally:
+                # Signal producer to stop; it will close the async generator promptly
+                stop_flag["stop"] = True
+
+        return iterator()

{dataroom_client-1.0.4.post12.dev0 → dataroom_client-1.0.5.post2.dev0}/pyproject.toml

@@ -6,7 +6,7 @@ authors = [
 ]
 readme = "README.md"
 dynamic = []
-version = "1.0.4.post12.dev0"
+version = "1.0.5.post2.dev0"
 
 [tool.poetry]