lm-deluge 0.0.38__tar.gz → 0.0.40__tar.gz

{lm_deluge-0.0.38/src/lm_deluge.egg-info → lm_deluge-0.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.38
+Version: 0.0.40
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10
@@ -111,14 +111,17 @@ await client.process_prompts_async(
 
 ### Queueing individual prompts
 
-You can queue prompts one at a time and track progress explicitly:
+You can queue prompts one at a time and track progress explicitly. Iterate over
+results as they finish with `as_completed` (or gather them all at once with
+`wait_for_all`):
 
 ```python
 client = LLMClient("gpt-4.1-mini", progress="tqdm")
 client.open()
-task_id = client.start_nowait("hello there")
+client.start_nowait("hello there")
 # ... queue more tasks ...
-results = await client.wait_for_all()
+async for task_id, result in client.as_completed():
+    print(task_id, result.completion)
 client.close()
 ```
 

{lm_deluge-0.0.38 → lm_deluge-0.0.40}/README.md

@@ -84,14 +84,17 @@ await client.process_prompts_async(
 
 ### Queueing individual prompts
 
-You can queue prompts one at a time and track progress explicitly:
+You can queue prompts one at a time and track progress explicitly. Iterate over
+results as they finish with `as_completed` (or gather them all at once with
+`wait_for_all`):
 
 ```python
 client = LLMClient("gpt-4.1-mini", progress="tqdm")
 client.open()
-task_id = client.start_nowait("hello there")
+client.start_nowait("hello there")
 # ... queue more tasks ...
-results = await client.wait_for_all()
+async for task_id, result in client.as_completed():
+    print(task_id, result.completion)
 client.close()
 ```
 

{lm_deluge-0.0.38 → lm_deluge-0.0.40}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "lm_deluge"
-version = "0.0.38"
+version = "0.0.40"
 authors = [{ name = "Benjamin Anderson", email = "ben@trytaylor.ai" }]
 description = "Python utility for using LLM API models."
 readme = "README.md"

{lm_deluge-0.0.38 → lm_deluge-0.0.40}/src/lm_deluge/client.py

@@ -1,6 +1,6 @@
 import asyncio
 import random
-from typing import Any, Literal, Self, Sequence, Callable, overload
+from typing import Any, AsyncGenerator, Callable, Literal, Self, Sequence, overload
 
 import numpy as np
 import yaml
@@ -375,16 +375,16 @@ class _LLMClient(BaseModel):
 
         # Main dispatch loop - using original pattern but with all prompts
         next_context = None  # Persist across iterations like original
+        next_is_retry = False  # Track whether next_context is a retry
         prompts_not_finished = True
         prompts_iter = iter(zip(ids, prompts))
 
         while True:
             # Get next context (retry or new) - only if we don't already have one waiting
-            retry_request = False
             if next_context is None:
                 if not retry_queue.empty():
                     next_context = retry_queue.get_nowait()
-                    retry_request = True
+                    next_is_retry = True
                     print(f"Retrying request {next_context.task_id}.")
                 elif prompts_not_finished:
                     try:
@@ -405,6 +405,8 @@ class _LLMClient(BaseModel):
                             extra_headers=self.extra_headers,
                             force_local_mcp=self.force_local_mcp,
                         )
+
+                        next_is_retry = False
                     except StopIteration:
                         prompts_not_finished = False
 
@@ -413,7 +415,7 @@ class _LLMClient(BaseModel):
 
             # Dispatch if capacity available - original logic
             if next_context:
-                if tracker.check_capacity(next_context.num_tokens, retry=retry_request):
+                if tracker.check_capacity(next_context.num_tokens, retry=next_is_retry):
                     tracker.set_limiting_factor(None)
 
                     # Launch simplified request processing
@@ -441,16 +443,16 @@ class _LLMClient(BaseModel):
 
                     asyncio.create_task(process_and_store(next_context))
                     next_context = None  # Reset after successful dispatch
+                    next_is_retry = False
 
             # Update progress - original logic
             tracker.update_pbar()
 
-            # Check completion - original logic
-            if (
-                tracker.num_tasks_in_progress == 0
-                and not prompts_not_finished
-                and retry_queue.empty()
-            ):
+            # Check completion: consider final outcomes, not in-progress count
+            # This avoids rare hangs if in-progress is miscounted (e.g., double-increment).
+            if (tracker.num_tasks_succeeded + tracker.num_tasks_failed) >= len(
+                prompts
+            ) and retry_queue.empty():
                 break
 
             # Sleep - original logic
@@ -555,6 +557,42 @@ class _LLMClient(BaseModel):
             task_ids = list(self._tasks.keys())
         return [await self.wait_for(tid) for tid in task_ids]
 
+    async def as_completed(
+        self, task_ids: Sequence[int] | None = None
+    ) -> AsyncGenerator[tuple[int, APIResponse | None], None]:
+        """Yield ``(task_id, result)`` pairs as tasks complete.
+
+        Args:
+            task_ids: Optional sequence of task IDs to wait on. If ``None``,
+                all queued tasks are watched.
+
+        Yields:
+            Tuples of task ID and ``APIResponse`` as each task finishes.
+        """
+
+        if task_ids is None:
+            tasks_map: dict[asyncio.Task, int] = {
+                task: tid for tid, task in self._tasks.items()
+            }
+        else:
+            tasks_map = {
+                self._tasks[tid]: tid for tid in task_ids if tid in self._tasks
+            }
+
+        # Yield any tasks that have already completed
+        for task in list(tasks_map.keys()):
+            if task.done():
+                tid = tasks_map.pop(task)
+                yield tid, self._results.get(tid, await task)
+
+        while tasks_map:
+            done, _ = await asyncio.wait(
+                set(tasks_map.keys()), return_when=asyncio.FIRST_COMPLETED
+            )
+            for task in done:
+                tid = tasks_map.pop(task)
+                yield tid, self._results.get(tid, await task)
+
     async def stream(
         self,
         prompt: str | Conversation,
@@ -616,7 +654,7 @@ class _LLMClient(BaseModel):
             if last_response is None or last_response.content is None:
                 break
 
-            conversation.add(last_response.content)
+            conversation = conversation.with_message(last_response.content)
 
             tool_calls = last_response.content.tool_calls
             if not tool_calls:

{lm_deluge-0.0.38 → lm_deluge-0.0.40}/src/lm_deluge/prompt.py

@@ -658,6 +658,11 @@ class Conversation:
         self.messages.append(msg)
         return self
 
+    # another way of doing the same thing
+    def add(self, msg: Message) -> "Conversation":
+        self.messages.append(msg)
+        return self
+
     def with_tool_result(
         self, tool_call_id: str, result: str | list[ToolResultPart]
     ) -> "Conversation":

{lm_deluge-0.0.38 → lm_deluge-0.0.40}/src/lm_deluge/tracker.py

@@ -10,6 +10,7 @@ from rich.progress import (
     MofNCompleteColumn,
     Progress,
     SpinnerColumn,
+    TaskID,
     TextColumn,
 )
 from rich.text import Text
@@ -44,7 +45,7 @@ class StatusTracker:
     _rich_console: Console | None = None
     _rich_live: object | None = None
     _rich_progress: Progress | None = None
-    _rich_task_id: int | None = None
+    _rich_task_id: TaskID | None = None
     _rich_display_task: asyncio.Task | None = None
     _rich_stop_event: asyncio.Event | None = None
 
@@ -244,9 +245,7 @@ class StatusTracker:
         """Initialize manual progress printer."""
         self.progress_bar_total = total
         self._manual_stop_event = asyncio.Event()
-        self._manual_display_task = asyncio.create_task(
-            self._manual_display_updater()
-        )
+        self._manual_display_task = asyncio.create_task(self._manual_display_updater())
 
     async def _manual_display_updater(self):
         if self._manual_stop_event is None:

{lm_deluge-0.0.38 → lm_deluge-0.0.40/src/lm_deluge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.38
+Version: 0.0.40
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10
@@ -111,14 +111,17 @@ await client.process_prompts_async(
 
 ### Queueing individual prompts
 
-You can queue prompts one at a time and track progress explicitly:
+You can queue prompts one at a time and track progress explicitly. Iterate over
+results as they finish with `as_completed` (or gather them all at once with
+`wait_for_all`):
 
 ```python
 client = LLMClient("gpt-4.1-mini", progress="tqdm")
 client.open()
-task_id = client.start_nowait("hello there")
+client.start_nowait("hello there")
 # ... queue more tasks ...
-results = await client.wait_for_all()
+async for task_id, result in client.as_completed():
+    print(task_id, result.completion)
 client.close()
 ```