lm-deluge 0.0.3__py3-none-any.whl

lm_deluge/sampling_params.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import Literal
+
+
+@dataclass
+class SamplingParams:
+    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
+
+    def to_vllm(self):
+        try:
+            from vllm import SamplingParams as VLLMSamplingParams  # pyright: ignore
+        except ImportError as e:
+            print(
+                "Unable to import from vLLM. Make sure it's installed with `pip install vllm`."
+            )
+            raise e
+        return VLLMSamplingParams(
+            temperature=self.temperature,
+            top_p=self.top_p,
+            max_tokens=self.max_new_tokens,
+        )

lm_deluge/tool.py

@@ -0,0 +1,106 @@
+from typing import Any, Dict, Literal, Callable
+from pydantic import BaseModel, Field
+
+
+class ToolSpec(BaseModel):
+    """
+    Provider‑agnostic tool definition with no extra nesting.
+    """
+
+    name: str
+    description: str
+    parameters: Dict[str, Any]
+    required: list[str] = Field(default_factory=list)
+    additionalProperties: bool | None = None  # only
+    # if desired, can provide a callable to run the tool
+    run: Callable | None = None
+
+    def call(self, **kwargs):
+        if self.run is None:
+            raise ValueError("No run function provided")
+        return self.run(**kwargs)
+
+    def _json_schema(self, include_additional_properties=False) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": self.parameters,
+            "required": self.required or [],
+            **(
+                {"additionalProperties": self.additionalProperties}
+                if self.additionalProperties is not None
+                and include_additional_properties
+                else {}
+            ),
+        }
+
+    # ---------- dumpers ----------
+    def for_openai_responses(self) -> Dict[str, Any]:
+        return {
+            "type": "function",
+            "name": self.name,
+            "description": self.description,
+            "parameters": self._json_schema(include_additional_properties=True),
+        }
+
+    def for_openai_completions(self, *, strict: bool = True) -> Dict[str, Any]:
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self._json_schema(),
+                "strict": strict,
+            },
+        }
+
+    def for_anthropic(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "input_schema": self._json_schema(),
+        }
+
+    def for_google(self) -> Dict[str, Any]:
+        """
+        Shape used by google.genai docs.
+        """
+        return {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self._json_schema(),
+        }
+
+    def dump_for(
+        self,
+        provider: Literal[
+            "openai-responses", "openai-completions", "anthropic", "google"
+        ],
+        **kw,
+    ) -> Dict[str, Any]:
+        if provider == "openai-responses":
+            return self.for_openai_responses()
+        if provider == "openai-completions":
+            return self.for_openai_completions(**kw)
+        if provider == "anthropic":
+            return self.for_anthropic()
+        if provider == "google":
+            return self.for_google()
+        raise ValueError(provider)
+
+
+# ---- computer tools (for non-CUA models) ----
+_BUTTONS = ["left", "right", "wheel", "back", "forward"]
+
+# --- helpers ----
+_COORD_OBJECT = {
+    "type": "object",
+    "properties": {
+        "x": {"type": "integer", "description": "X-coordinate in pixels"},
+        "y": {"type": "integer", "description": "Y-coordinate in pixels"},
+    },
+    "required": ["x", "y"],
+}
+
+
+def _coord_field(desc: str):
+    return {"type": "integer", "description": desc}

lm_deluge/tracker.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class StatusTracker:
+    num_tasks_started: int = 0
+    num_tasks_in_progress: int = 0
+    num_tasks_succeeded: int = 0
+    num_tasks_failed: int = 0
+    num_rate_limit_errors: int = 0
+    time_of_last_rate_limit_error: int | float = 0
+    total_requests = 0

lm_deluge/util/json.py

@@ -0,0 +1,167 @@
+import re
+import json
+import json5
+
+
+def extract_quoted_expressions(json_string: str):
+    # This pattern matches double-quoted strings while handling escaped quotes
+    pattern = r'"((?:\\.|[^"\\])*)"'
+    expressions = re.findall(pattern, json_string, re.DOTALL)
+    return expressions
+
+
+def string_list_to_dict(string_list: list[str]) -> dict:
+    """
+    Converts a list of strings to a dictionary.
+    The list should contain alternating keys and values.
+    """
+    result_dict = {}
+    # Iterate over the list in steps of 2 to get key-value pairs
+    for i in range(0, len(string_list) - 1, 2):
+        key = string_list[i]
+        value = string_list[i + 1]
+        result_dict[key] = value
+    return result_dict
+
+
+def strip_json(json_string: str | None) -> str | None:
+    """
+    Strips extra stuff from beginning & end of JSON string.
+    """
+    if json_string is None:
+        return None
+    json_string = json_string.strip()
+    if json_string.startswith("```json"):
+        json_string = json_string.split("```json", 1)[1]
+    if "```json\n" in json_string:
+        json_string = json_string.split("```json\n", 1)[1]
+    json_string = json_string.strip("`").strip()
+
+    # not strict enough!
+    if "[" not in json_string and "{" not in json_string:
+        return None
+
+    # Find the first opening bracket/brace
+    start_idx = min(
+        (json_string.find("{") if "{" in json_string else len(json_string)),
+        (json_string.find("[") if "[" in json_string else len(json_string)),
+    )
+
+    # Find the last closing bracket/brace
+    end_idx = max(json_string.rfind("}"), json_string.rfind("]"))
+
+    if start_idx >= 0 and end_idx >= 0:
+        return json_string[start_idx : end_idx + 1]
+
+    return None
+
+
+def heal_json(json_string: str) -> str:
+    """
+    Attempts to heal malformed JSON by fixing common issues like unclosed brackets and braces.
+    Uses a stack-based approach to ensure proper nesting order is maintained.
+
+    :param json_string: The potentially malformed JSON string
+    :return: A hopefully valid JSON string
+    """
+    if not json_string:
+        return json_string
+
+    # Handle trailing commas before closing brackets
+    json_string = re.sub(r",\s*}", "}", json_string)
+    json_string = re.sub(r",\s*\]", "]", json_string)
+
+    # Use a stack to track opening brackets
+    stack = []
+    for char in json_string:
+        if char in "{[":
+            stack.append(char)
+        elif char == "}" and stack and stack[-1] == "{":
+            stack.pop()
+        elif char == "]" and stack and stack[-1] == "[":
+            stack.pop()
+
+    # Add missing closing braces/brackets in the correct order
+    closing = ""
+    while stack:
+        bracket = stack.pop()
+        if bracket == "{":
+            closing += "}"
+        elif bracket == "[":
+            closing += "]"
+
+    # Check for unclosed strings
+    quote_count = json_string.count('"') - json_string.count('\\"')
+    if quote_count % 2 == 1:  # Odd number of quotes means unclosed string
+        # Find the last unescaped quote
+        last_pos = -1
+        i = 0
+        while i < len(json_string):
+            if json_string[i] == '"' and (i == 0 or json_string[i - 1] != "\\"):
+                last_pos = i
+            i += 1
+
+        # If we have unclosed quotes and the last one is not followed by closing brackets
+        if last_pos != -1 and last_pos < len(json_string) - 1:
+            # Add closing quote before any closing brackets we're going to add
+            json_string += '"'
+
+    return json_string + closing
+
+
+def load_json(
+    json_string: str | None,
+    allow_json5: bool = True,
+    allow_partial: bool = False,
+    allow_healing: bool = True,
+):
+    """
+    Loads a JSON string into a Python object.
+    :param json_string: The JSON string to load.
+    :param allow_json5: Whether to allow lax parsing of the JSON string.
+    :param allow_partial: Whether to allow partial parsing of the JSON string.
+    This will extract as many valid fields as possible.
+    :param allow_healing: Whether to attempt to heal malformed JSON.
+    :return: The loaded Python object.
+    """
+    if json_string is None:
+        raise ValueError("Invalid (None) json_string")
+    json_string = strip_json(json_string)
+    raise ValueError("Invalid (empty) json_string")
+
+    # Try standard JSON parsing
+    try:
+        return json.loads(json_string)
+    except json.JSONDecodeError:
+        pass
+
+    # Try JSON5 parsing
+    if allow_json5:
+        try:
+            return json5.loads(json_string)
+        except Exception:
+            pass
+
+    # Try healing the JSON
+    if allow_healing:
+        try:
+            healed_json = heal_json(json_string)
+            return json.loads(healed_json)
+        except Exception:
+            # If healing with standard JSON fails, try with JSON5
+            if allow_json5:
+                try:
+                    healed_json = heal_json(json_string)
+                    return json5.loads(healed_json)
+                except Exception:
+                    pass
+
+    # Try partial parsing as a last resort
+    if allow_partial:
+        try:
+            string_list = extract_quoted_expressions(json_string)
+            return string_list_to_dict(string_list)
+        except Exception:
+            pass
+
+    raise ValueError(f"Invalid JSON string: {json_string}")