lm-deluge 0.0.8__py3-none-any.whl → 0.0.9__py3-none-any.whl

lm_deluge/prompt.py

@@ -4,14 +4,14 @@ import tiktoken
 import xxhash
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Literal, Sequence
+from typing import Literal
 from lm_deluge.models import APIModel
 from lm_deluge.image import Image
 
 ###############################################################################
 # 1. Low-level content blocks – either text or an image                       #
 ###############################################################################
-Role = Literal["system", "user", "assistant"]
+Role = Literal["system", "user", "assistant", "tool"]
 
 
 @dataclass(slots=True)
@@ -40,18 +40,235 @@ class Text:
         return {"type": "text", "text": self.text}
 
 
+@dataclass(slots=True)
+class ToolCall:
+    id: str  # unique identifier
+    name: str  # function name
+    arguments: dict  # parsed arguments
+    type: str = field(init=False, default="tool_call")
+
+    @property
+    def fingerprint(self) -> str:
+        return xxhash.xxh64(
+            f"{self.id}:{self.name}:{json.dumps(self.arguments, sort_keys=True)}".encode()
+        ).hexdigest()
+
+    # ── provider-specific emission ────────────────────────────────────────────
+    def oa_chat(self) -> dict:  # OpenAI Chat Completions
+        return {
+            "id": self.id,
+            "type": "function",
+            "function": {"name": self.name, "arguments": json.dumps(self.arguments)},
+        }
+
+    def oa_resp(self) -> dict:  # OpenAI Responses
+        return {
+            "type": "function_call",
+            "id": self.id,
+            "name": self.name,
+            "arguments": self.arguments,
+        }
+
+    def anthropic(self) -> dict:  # Anthropic Messages
+        return {
+            "type": "tool_use",
+            "id": self.id,
+            "name": self.name,
+            "input": self.arguments,
+        }
+
+    def gemini(self) -> dict:
+        return {"functionCall": {"name": self.name, "args": self.arguments}}
+
+    def mistral(self) -> dict:
+        return {
+            "type": "tool_call",
+            "id": self.id,
+            "function": {"name": self.name, "arguments": json.dumps(self.arguments)},
+        }
+
+
+@dataclass(slots=True)
+class ToolResult:
+    tool_call_id: str  # references the ToolCall.id
+    result: str  # tool execution result
+    type: str = field(init=False, default="tool_result")
+
+    @property
+    def fingerprint(self) -> str:
+        return xxhash.xxh64(f"{self.tool_call_id}:{self.result}".encode()).hexdigest()
+
+    # ── provider-specific emission ────────────────────────────────────────────
+    def oa_chat(
+        self,
+    ) -> dict:  # OpenAI Chat Completions - tool results are separate messages
+        return {"tool_call_id": self.tool_call_id, "content": self.result}
+
+    def oa_resp(self) -> dict:  # OpenAI Responses
+        return {
+            "type": "function_result",
+            "call_id": self.tool_call_id,
+            "result": self.result,
+        }
+
+    def anthropic(self) -> dict:  # Anthropic Messages
+        return {
+            "type": "tool_result",
+            "tool_use_id": self.tool_call_id,
+            "content": self.result,
+        }
+
+    def gemini(self) -> dict:
+        return {
+            "functionResponse": {
+                "name": self.tool_call_id,  # Gemini uses name field for ID
+                "response": {"result": self.result},
+            }
+        }
+
+    def mistral(self) -> dict:
+        return {
+            "type": "tool_result",
+            "tool_call_id": self.tool_call_id,
+            "content": self.result,
+        }
+
+
+@dataclass(slots=True)
+class Thinking:
+    content: str  # reasoning content (o1, Claude thinking, etc.)
+    type: str = field(init=False, default="thinking")
+
+    @property
+    def fingerprint(self) -> str:
+        return xxhash.xxh64(self.content.encode()).hexdigest()
+
+    # ── provider-specific emission ────────────────────────────────────────────
+    def oa_chat(self) -> dict:  # OpenAI Chat Completions
+        # Thinking is typically not emitted back, but if needed:
+        return {"type": "text", "text": f"[Thinking: {self.content}]"}
+
+    def oa_resp(self) -> dict:  # OpenAI Responses
+        return {"type": "reasoning", "content": self.content}
+
+    def anthropic(self) -> dict:  # Anthropic Messages
+        return {"type": "thinking", "thinking": self.content}
+
+    def gemini(self) -> dict:
+        return {"text": f"[Thinking: {self.content}]"}
+
+    def mistral(self) -> dict:
+        return {"type": "text", "text": f"[Thinking: {self.content}]"}
+
+
+Part = Text | Image | ToolCall | ToolResult | Thinking
+
+
 ###############################################################################
 # 2. One conversational turn (role + parts)                                   #
 ###############################################################################
 @dataclass(slots=True)
 class Message:
     role: Role
-    parts: list[Text | Image]
+    parts: list[Part]
 
     @property
     def fingerprint(self) -> str:
         return self.role + "," + ",".join(part.fingerprint for part in self.parts)
 
+    @property
+    def completion(self) -> str | None:
+        """Extract text content from the first Text part, for backward compatibility."""
+        for part in self.parts:
+            if isinstance(part, Text):
+                return part.text
+        return None
+
+    @property
+    def tool_calls(self) -> list["ToolCall"]:
+        """Get all tool call parts with proper typing."""
+        return [part for part in self.parts if part.type == "tool_call"]  # type: ignore
+
+    @property
+    def tool_results(self) -> list["ToolResult"]:
+        """Get all tool result parts with proper typing."""
+        return [part for part in self.parts if part.type == "tool_result"]  # type: ignore
+
+    @property
+    def text_parts(self) -> list["Text"]:
+        """Get all text parts with proper typing."""
+        return [part for part in self.parts if part.type == "text"]  # type: ignore
+
+    @property
+    def images(self) -> list[Image]:
+        """Get all image parts with proper typing."""
+        return [part for part in self.parts if part.type == "image"]  # type: ignore
+
+    @property
+    def thinking_parts(self) -> list["Thinking"]:
+        """Get all thinking parts with proper typing."""
+        return [part for part in self.parts if part.type == "thinking"]  # type: ignore
+
+    def to_log(self) -> dict:
+        """
+        Return a JSON-serialisable dict that fully captures the message.
+        """
+        content_blocks: list[dict] = []
+        for p in self.parts:
+            if isinstance(p, Text):
+                content_blocks.append({"type": "text", "text": p.text})
+            elif isinstance(p, Image):  # Image – redact the bytes, keep a hint
+                w, h = p.size
+                content_blocks.append({"type": "image", "tag": f"<Image ({w}×{h})>"})
+            elif isinstance(p, ToolCall):
+                content_blocks.append(
+                    {
+                        "type": "tool_call",
+                        "id": p.id,
+                        "name": p.name,
+                        "arguments": p.arguments,
+                    }
+                )
+            elif isinstance(p, ToolResult):
+                content_blocks.append(
+                    {
+                        "type": "tool_result",
+                        "tool_call_id": p.tool_call_id,
+                        "result": p.result,
+                    }
+                )
+            elif isinstance(p, Thinking):
+                content_blocks.append({"type": "thinking", "content": p.content})
+
+        return {"role": self.role, "content": content_blocks}
+
+    @classmethod
+    def from_log(cls, data: dict) -> "Message":
+        """Re-hydrate a Message previously produced by `to_log()`."""
+        role: Role = data["role"]
+        parts: list[Part] = []
+
+        for p in data["content"]:
+            if p["type"] == "text":
+                parts.append(Text(p["text"]))
+            elif p["type"] == "image":
+                # We only stored a placeholder tag, so keep that placeholder.
+                parts.append(Image(p["tag"], detail="low"))
+            elif p["type"] == "tool_call":
+                parts.append(
+                    ToolCall(id=p["id"], name=p["name"], arguments=p["arguments"])
+                )
+            elif p["type"] == "tool_result":
+                parts.append(
+                    ToolResult(tool_call_id=p["tool_call_id"], result=p["result"])
+                )
+            elif p["type"] == "thinking":
+                parts.append(Thinking(content=p["content"]))
+            else:
+                raise ValueError(f"Unknown part type {p['type']!r}")
+
+        return cls(role, parts)
+
     def add_text(self, content: str) -> "Message":
         """Append a text block and return self for chaining."""
         self.parts.append(Text(content))
@@ -81,6 +298,21 @@ class Message:
         self.parts.append(img)
         return self
 
+    def add_tool_call(self, id: str, name: str, arguments: dict) -> "Message":
+        """Append a tool call block and return self for chaining."""
+        self.parts.append(ToolCall(id=id, name=name, arguments=arguments))
+        return self
+
+    def add_tool_result(self, tool_call_id: str, result: str) -> "Message":
+        """Append a tool result block and return self for chaining."""
+        self.parts.append(ToolResult(tool_call_id=tool_call_id, result=result))
+        return self
+
+    def add_thinking(self, content: str) -> "Message":
+        """Append a thinking block and return self for chaining."""
+        self.parts.append(Thinking(content=content))
+        return self
+
     # -------- convenient constructors --------
     @classmethod
     def user(
@@ -118,16 +350,32 @@ class Message:
             if msg["role"] in ["developer", "system"]
             else ("user" if msg["role"] == "user" else "assistant")
         )
-        parts: Sequence[Text | Image] = []
+        parts: list[Part] = []
         content = msg["content"]
         if isinstance(content, str):
-            parts.append(Text(content))
+            parts = [Text(content)]
         else:
+            part_list = []
             for item in content:
                 if item["type"] == "text":
-                    parts.append(Text(item["text"]))
+                    part_list.append(Text(item["text"]))
                 elif item["type"] == "image_url":
-                    parts.append(Image(data=item["image_url"]["url"]))
+                    part_list.append(Image(data=item["image_url"]["url"]))
+            parts = part_list
+
+        # Handle tool calls (assistant messages)
+        if "tool_calls" in msg:
+            part_list = list(parts) if parts else []
+            for tool_call in msg["tool_calls"]:
+                part_list.append(
+                    ToolCall(
+                        id=tool_call["id"],
+                        name=tool_call["function"]["name"],
+                        arguments=json.loads(tool_call["function"]["arguments"]),
+                    )
+                )
+            parts = part_list
+
         return cls(role, parts)
 
     @classmethod
@@ -140,10 +388,35 @@ class Message:
 
     # ───── provider-specific emission ─────
     def oa_chat(self) -> dict:
-        content = []
-        for p in self.parts:
-            content.append(p.oa_chat())
-        return {"role": self.role, "content": content}
+        if self.role == "tool":
+            # For tool messages, we expect a single ToolResult part (after splitting in to_openai)
+            tool_results = [p for p in self.parts if isinstance(p, ToolResult)]
+            if len(tool_results) == 1:
+                tool_result = tool_results[0]
+                return {
+                    "role": "tool",
+                    "tool_call_id": tool_result.tool_call_id,
+                    "content": tool_result.result,
+                }
+            else:
+                raise ValueError(
+                    f"Tool role messages must contain exactly one ToolResult part for OpenAI, got {len(tool_results)}"
+                )
+        else:
+            content = []
+            tool_calls = []
+
+            for p in self.parts:
+                if isinstance(p, ToolCall):
+                    tool_calls.append(p.oa_chat())
+                else:
+                    content.append(p.oa_chat())
+
+            result = {"role": self.role, "content": content}
+            if tool_calls:
+                result["tool_calls"] = tool_calls
+
+            return result
 
     def oa_resp(self) -> dict:
         content = [p.oa_resp() for p in self.parts]
@@ -155,7 +428,7 @@ class Message:
             raise ValueError("Anthropic keeps system outside message list")
         content = [p.anthropic() for p in self.parts]
         # Shortcut: single text becomes a bare string
-        if len(content) == 1 and content[0]["type"] == "text":
+        if len(content) == 1 and content[0].get("type") == "text":
             content = content[0]["text"]
         return {"role": self.role, "content": content}
 
@@ -210,9 +483,34 @@ class Conversation:
         self.messages.append(msg)
         return self
 
+    def add_tool_result(self, tool_call_id: str, result: str) -> "Conversation":
+        """Add a tool result to the conversation.
+
+        If the conversation ends with a tool message, append to it (for parallel tool calls).
+        Otherwise, create a new tool message.
+        """
+        if self.messages and self.messages[-1].role == "tool":
+            # Append to existing tool message (parallel tool calls)
+            self.messages[-1].add_tool_result(tool_call_id, result)
+        else:
+            # Create new tool message
+            tool_msg = Message("tool", [])
+            tool_msg.add_tool_result(tool_call_id, result)
+            self.messages.append(tool_msg)
+        return self
+
     # ── conversions -----------------------------------------------------------
     def to_openai(self) -> list[dict]:
-        return [m.oa_chat() for m in self.messages]
+        result = []
+        for m in self.messages:
+            if m.role == "tool" and len(m.tool_results) > 1:
+                # Split tool messages with multiple results into separate messages for OpenAI
+                for tool_result in m.tool_results:
+                    tool_msg = Message("tool", [tool_result])
+                    result.append(tool_msg.oa_chat())
+            else:
+                result.append(m.oa_chat())
+        return result
 
     def to_openai_responses(self) -> dict:
         # OpenAI Responses = single “input” array, role must be user/assistant
@@ -227,7 +525,16 @@ class Conversation:
             ),
             None,
         )
-        other = [m.anthropic() for m in self.messages if m.role != "system"]
+        other = []
+        for m in self.messages:
+            if m.role == "system":
+                continue
+            elif m.role == "tool":
+                # Convert tool messages to user messages for Anthropic
+                user_msg = Message("user", m.parts)
+                other.append(user_msg.anthropic())
+            else:
+                other.append(m.anthropic())
         return system_msg, other
 
     def to_gemini(self) -> tuple[str | None, list[dict]]:
@@ -295,11 +602,30 @@ class Conversation:
             for p in msg.parts:
                 if isinstance(p, Text):
                     content_blocks.append({"type": "text", "text": p.text})
-                else:  # Image – redact the bytes, keep a hint
+                elif isinstance(p, Image):  # Image – redact the bytes, keep a hint
                     w, h = p.size
                     content_blocks.append(
                         {"type": "image", "tag": f"<Image ({w}×{h})>"}
                     )
+                elif isinstance(p, ToolCall):
+                    content_blocks.append(
+                        {
+                            "type": "tool_call",
+                            "id": p.id,
+                            "name": p.name,
+                            "arguments": p.arguments,
+                        }
+                    )
+                elif isinstance(p, ToolResult):
+                    content_blocks.append(
+                        {
+                            "type": "tool_result",
+                            "tool_call_id": p.tool_call_id,
+                            "result": p.result,
+                        }
+                    )
+                elif isinstance(p, Thinking):
+                    content_blocks.append({"type": "thinking", "content": p.content})
             serialized.append({"role": msg.role, "content": content_blocks})
 
         return {"messages": serialized}
@@ -311,7 +637,7 @@ class Conversation:
 
         for m in payload.get("messages", []):
             role: Role = m["role"]  # 'system' | 'user' | 'assistant'
-            parts: list[Text | Image] = []
+            parts: list[Text | Image | ToolCall | ToolResult | Thinking] = []
 
             for p in m["content"]:
                 if p["type"] == "text":
@@ -320,6 +646,16 @@ class Conversation:
                     # We only stored a placeholder tag, so keep that placeholder.
                     # You could raise instead if real image bytes are required.
                     parts.append(Image(p["tag"], detail="low"))
+                elif p["type"] == "tool_call":
+                    parts.append(
+                        ToolCall(id=p["id"], name=p["name"], arguments=p["arguments"])
+                    )
+                elif p["type"] == "tool_result":
+                    parts.append(
+                        ToolResult(tool_call_id=p["tool_call_id"], result=p["result"])
+                    )
+                elif p["type"] == "thinking":
+                    parts.append(Thinking(content=p["content"]))
                 else:
                     raise ValueError(f"Unknown part type {p['type']!r}")
 

lm_deluge/tool.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Literal, Callable
+from typing import Any, Literal, Callable
 from pydantic import BaseModel, Field
 
 
@@ -9,7 +9,7 @@ class ToolSpec(BaseModel):
 
     name: str
     description: str
-    parameters: Dict[str, Any]
+    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
@@ -20,21 +20,20 @@ class ToolSpec(BaseModel):
             raise ValueError("No run function provided")
         return self.run(**kwargs)
 
-    def _json_schema(self, include_additional_properties=False) -> Dict[str, Any]:
-        return {
+    def _json_schema(self, include_additional_properties=False) -> dict[str, Any]:
+        res = {
             "type": "object",
             "properties": self.parameters,
-            "required": self.required or [],
-            **(
-                {"additionalProperties": self.additionalProperties}
-                if self.additionalProperties is not None
-                and include_additional_properties
-                else {}
-            ),
+            # for openai all must be required
+            "required": list(self.parameters.keys()),
         }
+        if include_additional_properties:
+            res["additionalProperties"] = False
+
+        return res
 
     # ---------- dumpers ----------
-    def for_openai_responses(self) -> Dict[str, Any]:
+    def for_openai_responses(self) -> dict[str, Any]:
         return {
             "type": "function",
             "name": self.name,
@@ -42,25 +41,25 @@ class ToolSpec(BaseModel):
             "parameters": self._json_schema(include_additional_properties=True),
         }
 
-    def for_openai_completions(self, *, strict: bool = True) -> Dict[str, Any]:
+    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(),
+                "parameters": self._json_schema(include_additional_properties=True),
                 "strict": strict,
             },
         }
 
-    def for_anthropic(self) -> Dict[str, Any]:
+    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]:
+    def for_google(self) -> dict[str, Any]:
         """
         Shape used by google.genai docs.
         """
@@ -76,7 +75,7 @@ class ToolSpec(BaseModel):
             "openai-responses", "openai-completions", "anthropic", "google"
         ],
         **kw,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         if provider == "openai-responses":
             return self.for_openai_responses()
         if provider == "openai-completions":
@@ -86,21 +85,3 @@ class ToolSpec(BaseModel):
         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-0.0.8.dist-info → lm_deluge-0.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.8
+Version: 0.0.9
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10

{lm_deluge-0.0.8.dist-info → lm_deluge-0.0.9.dist-info}/RECORD

@@ -1,22 +1,23 @@
 lm_deluge/__init__.py,sha256=rndOr4Rcfnpttz-onWU3vVEm-MM0WDFgz6KexKPAx0k,222
 lm_deluge/cache.py,sha256=VB1kv8rM2t5XWPR60uhszFcxLDnVKOe1oA5hYjVDjIo,4375
-lm_deluge/client.py,sha256=ERH0SkNvdM1zc8HYS5dxRGxVxUb4CXpUhveG3mz-w2I,28533
+lm_deluge/client.py,sha256=rk0YAUvC5kF3OuxnmYlkT8I6NjAmEJ6TUfryQbRkmXw,28960
 lm_deluge/embed.py,sha256=m-X8UK4gV9KKD7Wv3yarAceMQaj7gR1JwzD_sB0MOQY,13183
 lm_deluge/errors.py,sha256=oHjt7YnxWbh-eXMScIzov4NvpJMo0-2r5J6Wh5DQ1tk,209
 lm_deluge/gemini_limits.py,sha256=V9mpS9JtXYz7AY6OuKyQp5TuIMRH1BVv9YrSNmGmHNA,1569
 lm_deluge/image.py,sha256=hFbRajqEVQbkirAfOxsTPkeq-27Zl-so4AWBFeUbpBI,7161
-lm_deluge/models.py,sha256=w_OqA4Jxcy8LCCcdPRsGzg8iLFv4S9fPS5b4oj82Bgs,42778
-lm_deluge/prompt.py,sha256=bhDAlfUQ_Fq6Wh-L9jOfoiMbDGyVKGkjGicnwKJWpcI,12680
+lm_deluge/models.py,sha256=qdUsHC1kz82ZwduUU_rBcvJP4j2JXCL3Q2RtbHWc1H8,44998
+lm_deluge/prompt.py,sha256=_pJYwgjL39lDzMNmae8pPIBoORm_ekSM_9qU2iGGpOc,25445
 lm_deluge/rerank.py,sha256=tW1c3gQCAqaF8Ez-r-4qxYAcdKqxnLMxwHApKOUKwk4,11289
 lm_deluge/sampling_params.py,sha256=E2kewh1vz-1Qcy5xNBCzihfGgT_GcHYMfzaWb3FLiXs,739
-lm_deluge/tool.py,sha256=RVUW3E3FW11jCM-R7pIL1GpRs1YKCOjvTkL1D5xPetk,3196
+lm_deluge/tool.py,sha256=zXletfGtpgBCXuqietZn-eaOItbIyOROskTbaSjfwEk,2701
 lm_deluge/tracker.py,sha256=Dk99scN_NeDEO0gkLO5efXiZq11Ga-k6cerUHWN7IWY,1292
 lm_deluge/api_requests/__init__.py,sha256=_aSpD6CJL9g6OpLPoChXiHjl4MH_OlGcKgfZaW8cgLM,71
-lm_deluge/api_requests/anthropic.py,sha256=URbiD-ANn_P3StFJVP2JoDWuoloZVsAUly8CGSyV2Kw,6618
-lm_deluge/api_requests/base.py,sha256=Yt5Bxd5C5mZrbAMQYDghk0KRhUChSbTEsVI8DoThZBs,14805
-lm_deluge/api_requests/common.py,sha256=EjwTnKrvgBx-HnRVt0kSJZ9RM7CM-QyhlIQkr1jxP-4,220
-lm_deluge/api_requests/mistral.py,sha256=ThlV1jBfhpAwkaqPKhdUq-lIq2OienRbhEaSK4cctvI,5370
-lm_deluge/api_requests/openai.py,sha256=YgJMUio23ks6VLv6BDBZAW6Bnfd2fpidSidaHXzyXFY,6135
+lm_deluge/api_requests/anthropic.py,sha256=MMI_w9hVbevQpcqP3NVVindpTmLb2KHqjJQpIzCi5RM,7240
+lm_deluge/api_requests/base.py,sha256=w0MEOCIccxxy2c67Y2Y-QBox9rinIxQ7MLnp8953sjQ,15954
+lm_deluge/api_requests/bedrock.py,sha256=cvB85BFvL9HKTUsP9qFUCLQzJh83IQNAcLXuW6ReZK8,10520
+lm_deluge/api_requests/common.py,sha256=U0mX_wC3Tzg2-1u9nYUCTQqYzuYJqvLrICCNW_dbbJM,287
+lm_deluge/api_requests/mistral.py,sha256=gCi4R61oh759ZX6TKrT-fnQwIQaOGcPXhWrDsjJwPOY,5388
+lm_deluge/api_requests/openai.py,sha256=BuMiM_2zJQXfnUjTT94JxJi3ZX5V-KQQueRG-R0SGuc,7361
 lm_deluge/api_requests/deprecated/bedrock.py,sha256=WrcIShCoO8JCUSlFOCHxg6KQCNTZfw3TpYTvSpYk4mA,11320
 lm_deluge/api_requests/deprecated/cohere.py,sha256=KgDScD6_bWhAzOY5BHZQKSA3kurt4KGENqC4wLsGmcU,5142
 lm_deluge/api_requests/deprecated/deepseek.py,sha256=FEApI93VAWDwuaqTooIyKMgONYqRhdUmiAPBRme-IYs,4582
@@ -30,8 +31,8 @@ lm_deluge/util/json.py,sha256=dCeG9j1D17rXmQJbKJH79X0CGof4Wlqd55TDg4D6ky8,5388
 lm_deluge/util/logprobs.py,sha256=UkBZakOxWluaLqHrjARu7xnJ0uCHVfLGHJdnYlEcutk,11768
 lm_deluge/util/validation.py,sha256=hz5dDb3ebvZrZhnaWxOxbNSVMI6nmaOODBkk0htAUhs,1575
 lm_deluge/util/xml.py,sha256=Ft4zajoYBJR3HHCt2oHwGfymGLdvp_gegVmJ-Wqk4Ck,10547
-lm_deluge-0.0.8.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.8.dist-info/METADATA,sha256=sRRWcI9rQ0BlCENlRF6EdY-eJY-p9CTAFmak8tstGOM,8076
-lm_deluge-0.0.8.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-lm_deluge-0.0.8.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.8.dist-info/RECORD,,
+lm_deluge-0.0.9.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.9.dist-info/METADATA,sha256=hIv-9R30IJXuh6AHR0pZkktvsbSihThOuu9D9AniKIg,8076
+lm_deluge-0.0.9.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+lm_deluge-0.0.9.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.9.dist-info/RECORD,,