lm-deluge 0.0.12__py3-none-any.whl → 0.0.14__py3-none-any.whl

lm_deluge/computer_use/anthropic_tools.py

@@ -0,0 +1,75 @@
+from typing import Literal
+
+ToolVersion = Literal["2024-10-22", "2025-01-24", "2025-04-29"]
+ToolType = Literal["bash", "computer", "editor"]
+
+
+def model_to_version(model: str) -> ToolVersion:
+    if "opus" not in model and "sonnet" not in model:
+        raise ValueError("cannot use computer tools with incompatible model")
+    if "claude-4" in model:
+        return "2025-04-29"
+    elif "3.7" in model:
+        return "2025-01-24"
+    else:
+        return "2024-10-22"
+
+
+def get_anthropic_cu_tools(
+    model: str,
+    display_width: int,
+    display_height: int,
+    exclude_tools: list[ToolType] | None = None,
+):
+    version = model_to_version(model)
+    if version == "2024-10-22":
+        result = [
+            {
+                "name": "computer",
+                "type": "computer_20241022",
+                "display_width_px": display_width,
+                "display_height_px": display_height,
+                "display_number": None,
+            },
+            {"name": "str_replace_editor", "type": "text_editor_20250429"},
+            {"type": "bash_20250124", "name": "bash"},
+        ]
+    elif version == "2025-01-24":
+        result = [
+            {
+                "name": "computer",
+                "type": "computer_20250124",
+                "display_width_px": display_width,
+                "display_height_px": display_height,
+                "display_number": None,
+            },
+            {"name": "str_replace_editor", "type": "text_editor_20250124"},
+            {"type": "bash_20250124", "name": "bash"},
+        ]
+    elif version == "2025-04-29":
+        result = [
+            {
+                "name": "computer",
+                "type": "computer_20250124",
+                "display_width_px": display_width,
+                "display_height_px": display_height,
+                "display_number": None,
+            },
+            {"name": "str_replace_based_edit_tool", "type": "text_editor_20250429"},
+            {
+                "name": "bash",
+                "type": "bash_20250124",
+            },
+        ]
+    else:
+        raise ValueError("invalid tool version")
+
+    if exclude_tools is None:
+        return result
+    if "bash" in exclude_tools:
+        result = [x for x in result if x["name"] != "bash"]
+    if "editor" in exclude_tools:
+        result = [x for x in result if "edit" not in x["name"]]
+    if "computer" in exclude_tools:
+        result = [x for x in result if "computer" not in x["name"]]
+    return result

lm_deluge/{sampling_params.py → config.py}

@@ -1,14 +1,16 @@
-from dataclasses import dataclass
 from typing import Literal
 
+from pydantic import BaseModel
 
-@dataclass
-class SamplingParams:
+
+class SamplingParams(BaseModel):
     temperature: float = 0.0
     top_p: float = 1.0
     json_mode: bool = False
     max_new_tokens: int = 512
-    reasoning_effort: Literal["low", "medium", "high", None] = None
+    reasoning_effort: Literal["low", "medium", "high", "none", None] = None
+    logprobs: bool = False
+    top_logprobs: int | None = None
 
     def to_vllm(self):
         try:
@@ -23,3 +25,9 @@ class SamplingParams:
             top_p=self.top_p,
             max_tokens=self.max_new_tokens,
         )
+
+
+class ComputerUseParams(BaseModel):
+    enabled: bool = False
+    display_width: int = 1024
+    display_height: int = 768

lm_deluge/embed.py

@@ -1,12 +1,14 @@
 ### specific utility for cohere rerank api
-import os
-import numpy as np
-import aiohttp
-from tqdm.auto import tqdm
 import asyncio
+import os
 import time
-from typing import Any
 from dataclasses import dataclass
+from typing import Any
+
+import aiohttp
+import numpy as np
+from tqdm.auto import tqdm
+
 from .tracker import StatusTracker
 
 registry = {
@@ -56,7 +58,6 @@ class EmbeddingRequest:
         texts: list[str],
         attempts_left: int,
         status_tracker: StatusTracker,
-        retry_queue: asyncio.Queue,
         request_timeout: int,
         pbar: tqdm | None = None,
         **kwargs,  # openai or cohere specific params
@@ -66,7 +67,6 @@ class EmbeddingRequest:
         self.texts = texts
         self.attempts_left = attempts_left
         self.status_tracker = status_tracker
-        self.retry_queue = retry_queue
         self.request_timeout = request_timeout
         self.pbar = pbar
         self.result = []
@@ -89,7 +89,8 @@ class EmbeddingRequest:
         print(error_to_print)
         if self.attempts_left > 0:
             self.attempts_left -= 1
-            self.retry_queue.put_nowait(self)
+            assert self.status_tracker.retry_queue
+            self.status_tracker.retry_queue.put_nowait(self)
             return
         else:
             print(f"Task {self.task_id} out of tries.")
@@ -243,7 +244,11 @@ async def embed_parallel_async(
 
     # initialize trackers
     retry_queue = asyncio.Queue()
-    status_tracker = StatusTracker()
+    status_tracker = StatusTracker(
+        max_tokens_per_minute=10_000_000,
+        max_requests_per_minute=max_requests_per_minute,
+        max_concurrent_requests=1_000,
+    )
     next_request = None  # variable to hold the next request to call
 
     # initialize available capacity counts
@@ -262,7 +267,8 @@ async def embed_parallel_async(
     while True:
         # get next request (if one is not already waiting for capacity)
         if next_request is None:
-            if not retry_queue.empty():
+            assert status_tracker.retry_queue
+            if not status_tracker.retry_queue.empty():
                 next_request = retry_queue.get_nowait()
                 print(f"Retrying request {next_request.task_id}.")
             elif prompts_not_finished:
@@ -285,7 +291,7 @@ async def embed_parallel_async(
 
                 except StopIteration:
                     prompts_not_finished = False
-                    print("API requests finished, only retries remain.")
+                    # print("API requests finished, only retries remain.")
 
         # update available capacity
         current_time = time.time()

lm_deluge/file.py

@@ -0,0 +1,149 @@
+import os
+import io
+import requests
+import base64
+import mimetypes
+import xxhash
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass(slots=True)
+class File:
+    # raw bytes, pathlike, http url, base64 data url, or file_id
+    data: bytes | io.BytesIO | Path | str
+    media_type: str | None = None  # inferred if None
+    filename: str | None = None  # optional filename for uploads
+    file_id: str | None = None  # for OpenAI file uploads or Anthropic file API
+    type: str = field(init=False, default="file")
+
+    # helpers -----------------------------------------------------------------
+    def _bytes(self) -> bytes:
+        if isinstance(self.data, bytes):
+            return self.data
+        elif isinstance(self.data, io.BytesIO):
+            return self.data.getvalue()
+        elif isinstance(self.data, str) and self.data.startswith("http"):
+            res = requests.get(self.data)
+            res.raise_for_status()
+            return res.content
+        elif isinstance(self.data, str) and os.path.exists(self.data):
+            with open(self.data, "rb") as f:
+                return f.read()
+        elif isinstance(self.data, Path) and self.data.exists():
+            return Path(self.data).read_bytes()
+        elif isinstance(self.data, str) and self.data.startswith("data:"):
+            header, encoded = self.data.split(",", 1)
+            return base64.b64decode(encoded)
+        else:
+            raise ValueError("unreadable file format")
+
+    def _mime(self) -> str:
+        if self.media_type:
+            return self.media_type
+        if isinstance(self.data, (Path, str)):
+            # For URL or path, try to guess from the string
+            path_str = str(self.data)
+            guess = mimetypes.guess_type(path_str)[0]
+            if guess:
+                return guess
+        return "application/pdf"  # default to PDF
+
+    def _filename(self) -> str:
+        if self.filename:
+            return self.filename
+        if isinstance(self.data, (Path, str)):
+            path_str = str(self.data)
+            if path_str.startswith("http"):
+                # Extract filename from URL
+                return path_str.split("/")[-1].split("?")[0] or "document.pdf"
+            else:
+                # Extract from local path
+                return os.path.basename(path_str) or "document.pdf"
+        return "document.pdf"
+
+    def _base64(self, include_header: bool = True) -> str:
+        encoded = base64.b64encode(self._bytes()).decode("utf-8")
+        if not include_header:
+            return encoded
+        return f"data:{self._mime()};base64,{encoded}"
+
+    @property
+    def fingerprint(self) -> str:
+        # Hash the file contents for fingerprinting
+        file_bytes = self._bytes()
+        return xxhash.xxh64(file_bytes).hexdigest()
+
+    @property
+    def size(self) -> int:
+        """Return file size in bytes."""
+        return len(self._bytes())
+
+    # ── provider-specific emission ────────────────────────────────────────────
+    def oa_chat(self) -> dict:
+        """For OpenAI Chat Completions - file content as base64 or file_id."""
+        if self.file_id:
+            return {
+                "type": "file",
+                "file": {
+                    "file_id": self.file_id,
+                },
+            }
+        else:
+            return {
+                "type": "file",
+                "file": {
+                    "filename": self._filename(),
+                    "file_data": self._base64(),
+                },
+            }
+
+    def oa_resp(self) -> dict:
+        """For OpenAI Responses API - file content as base64 or file_id."""
+        if self.file_id:
+            return {
+                "type": "input_file",
+                "file_id": self.file_id,
+            }
+        else:
+            return {
+                "type": "input_file",
+                "filename": self._filename(),
+                "file_data": self._base64(),
+            }
+
+    def anthropic(self) -> dict:
+        """For Anthropic Messages API - file content as base64 or file_id."""
+        if self.file_id:
+            return {
+                "type": "document",
+                "source": {
+                    "type": "file",
+                    "file_id": self.file_id,
+                },
+            }
+        else:
+            b64 = base64.b64encode(self._bytes()).decode()
+            return {
+                "type": "document",
+                "source": {
+                    "type": "base64",
+                    "media_type": self._mime(),
+                    "data": b64,
+                },
+            }
+
+    def anthropic_file_upload(self) -> tuple[str, bytes, str]:
+        """For Anthropic Files API - return tuple for file upload."""
+        filename = self._filename()
+        content = self._bytes()
+        media_type = self._mime()
+        return filename, content, media_type
+
+    def gemini(self) -> dict:
+        """For Gemini API - not yet supported."""
+        raise NotImplementedError("File support for Gemini is not yet implemented")
+
+    def mistral(self) -> dict:
+        """For Mistral API - not yet supported."""
+        raise NotImplementedError("File support for Mistral is not yet implemented")

lm_deluge/models.py

@@ -178,6 +178,21 @@ registry = {
     #                ░███
     #                █████
     #               ░░░░░
+    "openai-computer-use-preview": {
+        "id": "openai-computer-use-preview",
+        "name": "computer-use-preview",
+        "api_base": "https://api.openai.com/v1",
+        "api_key_env_var": "OPENAI_API_KEY",
+        "supports_json": True,
+        "supports_logprobs": False,
+        "supports_responses": True,
+        "api_spec": "openai-responses",
+        "input_cost": 2.0,
+        "output_cost": 8.0,
+        "requests_per_minute": 20,
+        "tokens_per_minute": 100_000,
+        "reasoning_model": False,
+    },
     "o3": {
         "id": "o3",
         "name": "o3-2025-04-16",
@@ -185,6 +200,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": False,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 10.0,
         "output_cost": 40.0,
@@ -199,6 +215,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": False,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 1.1,
         "output_cost": 4.4,
@@ -213,6 +230,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": True,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 2.0,
         "output_cost": 8.0,
@@ -227,6 +245,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": True,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 0.4,
         "output_cost": 1.6,
@@ -241,6 +260,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": True,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 0.1,
         "output_cost": 0.4,
@@ -255,6 +275,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": False,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 75.0,
         "output_cost": 150.0,
@@ -269,6 +290,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": False,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 1.1,
         "output_cost": 4.4,
@@ -283,6 +305,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": False,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 15.0,
         "output_cost": 60.0,
@@ -297,6 +320,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": False,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 15.0,
         "output_cost": 60.0,
@@ -311,6 +335,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": False,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 3.0,
         "output_cost": 15.0,
@@ -325,6 +350,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": True,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 5.0,
         "output_cost": 15.0,
@@ -338,6 +364,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": True,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 0.15,
         "output_cost": 0.6,
@@ -351,6 +378,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": True,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 0.0,
         "output_cost": 0.0,
@@ -364,6 +392,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": True,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 0.5,
         "output_cost": 1.5,
@@ -377,6 +406,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": True,
         "supports_logprobs": True,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 10.0,
         "output_cost": 30.0,
@@ -390,6 +420,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": False,
         "supports_logprobs": False,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 30.0,
         "output_cost": 60.0,
@@ -403,6 +434,7 @@ registry = {
         "api_key_env_var": "OPENAI_API_KEY",
         "supports_json": False,
         "supports_logprobs": False,
+        "supports_responses": True,
         "api_spec": "openai",
         "input_cost": 60.0,
         "output_cost": 120.0,
@@ -1093,6 +1125,7 @@ class APIModel:
     output_cost: float | None = 0  # $ per million output tokens
     supports_json: bool = False
     supports_logprobs: bool = False
+    supports_responses: bool = False
     reasoning_model: bool = False
     regions: list[str] | dict[str, int] = field(default_factory=list)
     tokens_per_minute: int | None = None