lm-deluge 0.0.21__py3-none-any.whl → 0.0.23__py3-none-any.whl

lm_deluge/prompt.py

@@ -102,11 +102,14 @@ class ToolCall:
         }
 
 
+ToolResultPart = Text | Image
+
+
 @dataclass(slots=True)
 class ToolResult:
     tool_call_id: str  # references the ToolCall.id
     # tool execution result - can be string or list for images
-    result: str | dict | list[dict]
+    result: str | dict | list[ToolResultPart]
     type: str = field(init=False, default="tool_result")
     # NEW! instead of specific carve-out for computer use,
     # need to handle all built-ins for OpenAI
@@ -115,23 +118,64 @@ class ToolResult:
 
     @property
     def fingerprint(self) -> str:
-        result_str = (
-            json.dumps(self.result, sort_keys=True)
-            if isinstance(self.result, list) or isinstance(self.result, dict)
-            else str(self.result)
-        )
+        if isinstance(self.result, str):
+            result_str = self.result
+        elif isinstance(self.result, list):
+            result_str = json.dumps([part.fingerprint for part in self.result])
+        else:
+            raise ValueError("unsupported self.result type")
         return xxhash.xxh64(f"{self.tool_call_id}:{result_str}".encode()).hexdigest()
 
     # ── provider-specific emission ────────────────────────────────────────────
+    def get_images(self) -> list[Image]:
+        # for openai, we can't include images in tool result, so we have to
+        # include them in the next user message
+        if isinstance(self.result, str):
+            return []
+        elif isinstance(self.result, list):
+            images = []
+            for block in self.result:
+                if isinstance(block, Image):
+                    images.append(block)
+            return images
+        else:
+            raise ValueError("unexpected tool result type")
+
     def oa_chat(
         self,
     ) -> dict:  # OpenAI Chat Completions - tool results are separate messages
-        content = (
-            json.dumps(self.result) if isinstance(self.result, list) else self.result
-        )
-        return {"tool_call_id": self.tool_call_id, "content": content}
+        print("serializing toolresult with oa_chat...")
+        print("typeof self.result:", type(self.result))
+        if isinstance(self.result, str):
+            return {
+                "role": "tool",
+                "tool_call_id": self.tool_call_id,
+                "content": self.result,
+            }
+        elif isinstance(self.result, list):
+            # OpenAI only accepts strings! this is a painful limitation
+            image_idx = 0
+            text_result = ""
+            for block in self.result:
+                if isinstance(block, Text):
+                    text_result += block.text
+                    text_result += "\n\n---\n\n"
+                else:
+                    image_idx += 1
+                    text_result += f"[Image {image_idx} in following user message]"
+                    text_result += "\n\n---\n\n"
+
+            return {
+                "role": "tool",
+                "tool_call_id": self.tool_call_id,
+                "content": text_result,
+            }
+        else:
+            raise ValueError("result type not supported")
 
     def oa_resp(self) -> dict:  # OpenAI Responses
+        print("serializing toolresult with oa_chat...")
+        print("typeof self.result:", type(self.result))
         # if normal (not built-in just return the regular output
         if not self.built_in:
             result = (
@@ -169,13 +213,25 @@ class ToolResult:
             return result
 
     def anthropic(self) -> dict:  # Anthropic Messages
-        return {
-            "type": "tool_result",
-            "tool_use_id": self.tool_call_id,
-            "content": self.result,
-        }
+        if isinstance(self.result, str):
+            return {
+                "type": "tool_result",
+                "tool_use_id": self.tool_call_id,
+                "content": self.result,
+            }
+        elif isinstance(self.result, list):
+            # handle list of content blocks
+            return {
+                "type": "tool_result",
+                "tool_use_id": self.tool_call_id,
+                "content": [part.anthropic() for part in self.result],
+            }
+        else:
+            raise ValueError("unsupported self.result type")
 
     def gemini(self) -> dict:
+        if not isinstance(self.result, str):
+            raise ValueError("can't handle content blocks for gemini yet")
         return {
             "functionResponse": {
                 "name": self.tool_call_id,  # Gemini uses name field for ID
@@ -346,7 +402,7 @@ class Message:
 
     def add_image(
         self,
-        data: bytes | str | Path | io.BytesIO,
+        data: bytes | str | Path | io.BytesIO | Image,
         *,
         media_type: MediaType | None = None,
         detail: Literal["low", "high", "auto"] = "auto",
@@ -359,8 +415,10 @@ class Message:
         dimension equals max_size, but only if the longer dimension is currently
         larger than max_size.
         """
-        img = Image(data, media_type=media_type, detail=detail)
-
+        if not isinstance(data, Image):
+            img = Image(data, media_type=media_type, detail=detail)
+        else:
+            img = data
         # Resize if max_size is provided
         if max_size is not None:
             img.resize(max_size)
@@ -387,7 +445,9 @@ class Message:
         self.parts.append(ToolCall(id=id, name=name, arguments=arguments))
         return self
 
-    def add_tool_result(self, tool_call_id: str, result: str) -> "Message":
+    def add_tool_result(
+        self, tool_call_id: str, result: str | list[ToolResultPart]
+    ) -> "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
@@ -493,11 +553,12 @@ class Message:
             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,
-                }
+                return tool_result.oa_chat()
+                # {
+                #     "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)}"
@@ -597,7 +658,9 @@ class Conversation:
         self.messages.append(msg)
         return self
 
-    def add_tool_result(self, tool_call_id: str, result: str) -> "Conversation":
+    def add_tool_result(
+        self, tool_call_id: str, result: str | list[ToolResultPart]
+    ) -> "Conversation":
         """Add a tool result to the conversation.
 
         If the conversation ends with a tool message, append to it (for parallel tool calls).
@@ -617,11 +680,23 @@ class Conversation:
     def to_openai(self) -> list[dict]:
         result = []
         for m in self.messages:
-            if m.role == "tool" and len(m.tool_results) > 1:
+            if m.role == "tool":
                 # 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())
+
+                # if tool response included images, add those to next user message
+                user_msg = Message("user", [])
+                for i, tool_result in enumerate(m.tool_results):
+                    images = tool_result.get_images()
+                    if len(images) > 0:
+                        user_msg.add_text(
+                            f"[Images for Tool Call {tool_result.tool_call_id}]"
+                        )
+                        for img in images:
+                            user_msg.add_image(img)
+
             else:
                 result.append(m.oa_chat())
         return result
@@ -853,7 +928,9 @@ class Conversation:
                         {
                             "type": "tool_result",
                             "tool_call_id": p.tool_call_id,
-                            "result": p.result,
+                            "result": p.result
+                            if isinstance(p.result, str)
+                            else f"<Tool result ({len(p.result)} blocks)>",
                         }
                     )
                 elif isinstance(p, Thinking):
@@ -905,32 +982,3 @@ def prompts_to_conversations(prompts: Sequence[str | list[dict] | Conversation])
     return [  # type: ignore
         Conversation.user(p) if isinstance(p, str) else p for p in prompts
     ]
-
-
-###############################################################################
-# --------------------------------------------------------------------------- #
-# Basic usage examples                                                        #
-# --------------------------------------------------------------------------- #
-
-# 1️⃣  trivial single-turn (text only)  ---------------------------------------
-# conv = Conversation.user("Hi Claude, who won the 2018 World Cup?")
-# client.messages.create(model="claude-3-7-sonnet", **conv.to_anthropic())
-
-# # 2️⃣  system + vision + follow-up for OpenAI Chat Completions  ---------------
-# conv = (
-#     Conversation.system("You are a visual assistant.")
-#     .add(
-#         Message.with_image(
-#             "user",
-#             "What's in this photo?",
-#             Image("boardwalk.jpg", detail="low"),
-#         )
-#     )
-#     .add(Message.text("assistant", "Looks like a lakeside boardwalk."))
-#     .add(Message.text("user", "Great, write a haiku about it."))
-# )
-
-# openai.chat.completions.create(model="gpt-4o-mini", messages=conv.to_openai_chat())
-
-# # 3️⃣  Same conversation sent through new Responses API -----------------------
-# openai.responses.create(model="gpt-4o-mini", **conv.to_openai_responses())

lm_deluge/request_context.py

@@ -35,6 +35,7 @@ class RequestContext:
     cache: CachePattern | None = None
     use_responses_api: bool = False
     extra_headers: dict[str, str] | None = None
+    force_local_mcp: bool = False
 
     # Computed properties
     cache_key: str = field(init=False)
@@ -68,6 +69,7 @@ class RequestContext:
             "tools": self.tools,
             "cache": self.cache,
             "use_responses_api": self.use_responses_api,
+            "force_local_mcp": self.force_local_mcp,
         }
 
         # Update with any overrides

lm_deluge/tool.py

@@ -1,11 +1,15 @@
 import asyncio
 import inspect
-from typing import Any, Callable, Coroutine, Literal, get_type_hints
+from typing import Any, Callable, Coroutine, Literal, TypedDict, get_type_hints
+from concurrent.futures import ThreadPoolExecutor
 
 from fastmcp import Client  # pip install fastmcp >= 2.0
 from mcp.types import Tool as MCPTool
 from pydantic import BaseModel, Field, field_validator
 
+from lm_deluge.prompt import Text, ToolResultPart
+from lm_deluge.image import Image
+
 
 async def _load_all_mcp_tools(client: Client) -> list["Tool"]:
     metas: list[MCPTool] = await client.list_tools()
@@ -14,7 +18,18 @@ async def _load_all_mcp_tools(client: Client) -> list["Tool"]:
         async def _async_call(**kw):
             async with client:
                 # maybe should be call_tool_mcp if don't want to raise error
-                return await client.call_tool(name, kw)
+                content_blocks = await client.call_tool(name, kw)
+
+                # for now just concatenate them all into a result string
+                results = []
+                for block in content_blocks:
+                    if block.type == "text":
+                        results.append(Text(block.text))
+                    elif block.type == "image":
+                        data_url = f"data:{block.mimeType};base64,{block.data}"
+                        results.append(Image(data=data_url))
+
+                return results
 
         return _async_call
 
@@ -63,7 +78,7 @@ class Tool(BaseModel):
     def _is_async(self) -> bool:
         return inspect.iscoroutinefunction(self.run)
 
-    def call(self, **kwargs):
+    def call(self, **kwargs) -> str | list[ToolResultPart]:
         if self.run is None:
             raise ValueError("No run function provided")
 
@@ -71,17 +86,22 @@ class Tool(BaseModel):
             coro: Coroutine = self.run(**kwargs)  # type: ignore[arg-type]
             try:
                 loop = asyncio.get_running_loop()
+                assert loop
             except RuntimeError:
                 # no loop → safe to block
                 return asyncio.run(coro)
             else:
-                # already inside a loop → schedule
-                return loop.create_task(coro)
+                # Loop is running → execute coroutine in a worker thread
+                def _runner():
+                    return asyncio.run(coro)
+
+                with ThreadPoolExecutor(max_workers=1) as executor:
+                    return executor.submit(_runner).result()
         else:
             # plain function
             return self.run(**kwargs)
 
-    async def acall(self, **kwargs):
+    async def acall(self, **kwargs) -> str | list[ToolResultPart]:
         if self.run is None:
             raise ValueError("No run function provided")
 
@@ -218,12 +238,64 @@ class Tool(BaseModel):
             # Default to string for unknown types
             return {"type": "string"}
 
-    def _json_schema(self, include_additional_properties=False) -> dict[str, Any]:
+    def _json_schema(
+        self, include_additional_properties=False, remove_defaults=False
+    ) -> dict[str, Any]:
+        def _add_additional_properties_recursive(
+            schema: dict | list | Any, remove_defaults: bool = False
+        ) -> dict | list | Any:
+            """Recursively add additionalProperties: false to all object-type schemas."""
+            if isinstance(schema, dict):
+                # Copy the dictionary to avoid modifying the original
+                new_schema = schema.copy()
+
+                # make sure to label arrays and objects
+                if "type" not in new_schema:
+                    if "properties" in new_schema:
+                        new_schema["type"] = "object"
+                    elif "items" in new_schema:
+                        new_schema["type"] = "array"
+
+                # If this is an object type schema, set additionalProperties: false
+                if new_schema.get("type") == "object":
+                    new_schema["additionalProperties"] = False
+
+                # Remove default values if requested (for strict mode)
+                if remove_defaults and "default" in new_schema:
+                    del new_schema["default"]
+
+                # Recursively process all values in the dictionary
+                for key, value in new_schema.items():
+                    new_schema[key] = _add_additional_properties_recursive(
+                        value, remove_defaults
+                    )
+
+                return new_schema
+            elif isinstance(schema, list):
+                # Recursively process all items in the list
+                return [
+                    _add_additional_properties_recursive(item, remove_defaults)
+                    for item in schema
+                ]
+            else:
+                # Return primitive values as-is
+                return schema
+
+        # Start with the base schema structure
+        if include_additional_properties and self.parameters:
+            # Apply recursive additionalProperties processing to parameters
+            processed_parameters = _add_additional_properties_recursive(
+                self.parameters, remove_defaults
+            )
+        else:
+            processed_parameters = self.parameters
+
         res = {
             "type": "object",
-            "properties": self.parameters,
+            "properties": processed_parameters,
             "required": self.required,  # Use the tool's actual required list
         }
+
         if include_additional_properties:
             res["additionalProperties"] = False
 
@@ -236,8 +308,10 @@ class Tool(BaseModel):
         if self.built_in:
             return {"type": self.type, **self.built_in_args, **kwargs}
         if strict:
-            # For strict mode, all parameters must be required and additionalProperties must be false
-            schema = self._json_schema(include_additional_properties=True)
+            # For strict mode, remove defaults and make all parameters required
+            schema = self._json_schema(
+                include_additional_properties=True, remove_defaults=True
+            )
             schema["required"] = list(
                 (self.parameters or {}).keys()
             )  # All parameters required in strict mode
@@ -315,6 +389,14 @@ class Tool(BaseModel):
         raise ValueError(provider)
 
 
+class OpenAIMCPSpec(TypedDict):
+    type: str
+    server_label: str
+    server_url: str
+    headers: dict | None
+    require_approval: str
+
+
 class MCPServer(BaseModel):
     """
     Allow MCPServers to be passed directly, if provider supports it.
@@ -330,13 +412,18 @@ class MCPServer(BaseModel):
     # openai-specific
     headers: dict | None = None
 
+    # tools cache
+    _tools: list[Tool] | None = None
+
+    @classmethod
+    def from_openai(cls, spec: OpenAIMCPSpec):
+        return cls(
+            name=spec["server_label"],
+            url=spec["server_url"],
+            headers=spec.get("headers"),
+        )
+
     def for_openai_responses(self):
-        # return {
-        #     "type": "mcp",
-        #     "server_label": "deepwiki",
-        #     "server_url": "https://mcp.deepwiki.com/mcp",
-        #     "require_approval": "never",
-        # }
         res: dict[str, Any] = {
             "type": "mcp",
             "server_label": self.name,
@@ -349,16 +436,6 @@ class MCPServer(BaseModel):
         return res
 
     def for_anthropic(self):
-        # return {
-        #   "type": "url",
-        #   "url": "https://example-server.modelcontextprotocol.io/sse",
-        #   "name": "example-mcp",
-        #   "tool_configuration": {
-        #     "enabled": true,
-        #     "allowed_tools": ["example_tool_1", "example_tool_2"]
-        #   },
-        #   "authorization_token": "YOUR_TOKEN"
-        # }
         res: dict[str, Any] = {
             "type": "url",
             "url": self.url,
@@ -370,3 +447,15 @@ class MCPServer(BaseModel):
             res["tool_configuration"] = self.configuration
 
         return res
+
+    async def to_tools(self) -> list[Tool]:
+        """
+        Compatible with ALL providers.
+        Caches so we don't have to hit the server a ton of times.
+        """
+        if self._tools:
+            return self._tools
+        else:
+            tools: list[Tool] = await Tool.from_mcp(self.name, url=self.url)
+            self._tools = tools
+            return tools

{lm_deluge-0.0.21.dist-info → lm_deluge-0.0.23.dist-info}/METADATA

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

{lm_deluge-0.0.21.dist-info → lm_deluge-0.0.23.dist-info}/RECORD

@@ -1,30 +1,30 @@
 lm_deluge/__init__.py,sha256=mAztMuxINmh7dGbYnT8tsmw1eryQAvd0jpY8yHzd0EE,315
 lm_deluge/agent.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lm_deluge/batches.py,sha256=05t8UL1xCKjLRKtZLkfbexLqro6T_ufFVsaNIMk05Fw,17725
+lm_deluge/batches.py,sha256=OflXh9AHxb3qB5x5oo8cI5uhQihxj75Nvf7QDes3xV8,18630
 lm_deluge/cache.py,sha256=VB1kv8rM2t5XWPR60uhszFcxLDnVKOe1oA5hYjVDjIo,4375
-lm_deluge/client.py,sha256=H7rNqq9pOeyoqK2PyHbHUCIOygxXWJmRNj4WQA8qawE,25850
+lm_deluge/client.py,sha256=nAGMwdUPDVx-x23hZF6U5Yhug6Zf5FT27RHj_kj8nZk,26369
 lm_deluge/config.py,sha256=H1tQyJDNHGFuwxqQNL5Z-CjWAC0luHSBA3iY_pxmACM,932
 lm_deluge/embed.py,sha256=CO-TOlC5kOTAM8lcnicoG4u4K664vCBwHF1vHa-nAGg,13382
 lm_deluge/errors.py,sha256=oHjt7YnxWbh-eXMScIzov4NvpJMo0-2r5J6Wh5DQ1tk,209
 lm_deluge/file.py,sha256=zQH1STMjCG9pczO7Fk9Jw0_0Pj_8CogcdIxTe4J4AJw,5414
 lm_deluge/gemini_limits.py,sha256=V9mpS9JtXYz7AY6OuKyQp5TuIMRH1BVv9YrSNmGmHNA,1569
-lm_deluge/image.py,sha256=D8kMh2yu8sTuOchKpW9DE3XKbE6oUiFl9cRi6H1GpDc,7526
-lm_deluge/models.py,sha256=6ZCirxOpdcg_M24cKUABYbRpLK-r9dlkXxUS9aeh0UY,49657
-lm_deluge/prompt.py,sha256=T8o2hwv3RuxG7-fL5pCl0v14WVpmV09PdRzCZzLNszE,35265
-lm_deluge/request_context.py,sha256=l1DrPTtG80WtUhyDWblTiyT695K7Al9lWWDfdl6PMK0,2338
+lm_deluge/image.py,sha256=Qpa0k5yXfrpSaHzVUwW_TEn7yEgmwzYGL17Sa7-KhSA,7729
+lm_deluge/models.py,sha256=3vgI1BlfT4_Higev25QhhXJufQvsI6pd0yjF9YL0crA,49812
+lm_deluge/prompt.py,sha256=cfwzCAmT-1K0v7SfEMUrxpBkJGgf7IFlWfNLJrCcoBM,37025
+lm_deluge/request_context.py,sha256=0X-5m8BKn51rnnjzGDDXqbuSUEFGjdayirQjbvPcjMI,2425
 lm_deluge/rerank.py,sha256=-NBAJdHz9OB-SWWJnHzkFmeVO4wR6lFV7Vw-SxG7aVo,11457
-lm_deluge/tool.py,sha256=X6NDabz53BVe1pokaKCeTLCF1-AlMAxOn1_KWiCSb7c,12407
+lm_deluge/tool.py,sha256=_coOKB9nPNVZoseMRumRyQ8BMR7_d0IlstzMHNT69JY,15732
 lm_deluge/tracker.py,sha256=-EkFDAklh5mclIFR-5SthAwNL4p1yKS8LUN7rhpOVPQ,9266
 lm_deluge/usage.py,sha256=VMEKghePFIID5JFBObqYxFpgYxnbYm_dnHy7V1-_T6M,4866
 lm_deluge/api_requests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lm_deluge/api_requests/anthropic.py,sha256=kBvvZBjWsYrw2hV7-i_w3Hr0YlXzoNLBs0Eabw8YvWY,8045
-lm_deluge/api_requests/base.py,sha256=O3-Dsl_hr-xtLTekPLdrNnL5mTTfnfsN6Fcwq0-eKMg,5355
-lm_deluge/api_requests/bedrock.py,sha256=kZtKp6GqF73RpmLJKzEj4XTbllB8Kyq9-QydUuh2iu0,10977
+lm_deluge/api_requests/anthropic.py,sha256=Vi2iGQw6LGPW8d4X489Jg-dlEye529jf8i5YsM3bLYQ,8139
+lm_deluge/api_requests/base.py,sha256=EVHNFtlttKbN7Tt1MnLaO-NjvKHPSV5CqlRv-OnpVAE,5593
+lm_deluge/api_requests/bedrock.py,sha256=p6leW5stnvb406lwbmVFmfTGxdEI-t0GfaTExpol3qk,10900
 lm_deluge/api_requests/common.py,sha256=BZ3vRO5TB669_UsNKugkkuFSzoLHOYJIKt4nV4sf4vc,422
-lm_deluge/api_requests/gemini.py,sha256=N_94TpjpBLyekdrBjax2w0jPqYf70JycaRgZUNSsAAY,7531
-lm_deluge/api_requests/mistral.py,sha256=5EqYZgu9AfGrWs5-ucr8uJK_0cMEoUKKlEjBV3O6EPc,4561
-lm_deluge/api_requests/openai.py,sha256=fEIBchry-tLqkf0fhdFsS3CIjXbB_AV39Ig-PwAsT1I,21424
-lm_deluge/api_requests/response.py,sha256=JFSwHAs-yaJYkscOgTAyHkt-v8FDZ5mgER9NmueXTGk,5866
+lm_deluge/api_requests/gemini.py,sha256=UeA4gsIePsIu6IQQ7izR359LLQQTi0Qky_ykjH1XQf4,7461
+lm_deluge/api_requests/mistral.py,sha256=S_LpOfCGbCVEROH_od3P-tYeNYTKFMamMTL-c_wFCBI,4597
+lm_deluge/api_requests/openai.py,sha256=jb_pBGqSbqs7SvbA45Odu3JkwS3jsKn-p3hG8-qkYbc,21509
+lm_deluge/api_requests/response.py,sha256=FtkVYk_rDH93Kj9pqbB-l7a4dQHzVr6ivKL9khYKLbs,5966
 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
@@ -48,8 +48,8 @@ lm_deluge/util/logprobs.py,sha256=UkBZakOxWluaLqHrjARu7xnJ0uCHVfLGHJdnYlEcutk,11
 lm_deluge/util/spatial.py,sha256=BsF_UKhE-x0xBirc-bV1xSKZRTUhsOBdGqsMKme20C8,4099
 lm_deluge/util/validation.py,sha256=hz5dDb3ebvZrZhnaWxOxbNSVMI6nmaOODBkk0htAUhs,1575
 lm_deluge/util/xml.py,sha256=Ft4zajoYBJR3HHCt2oHwGfymGLdvp_gegVmJ-Wqk4Ck,10547
-lm_deluge-0.0.21.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.21.dist-info/METADATA,sha256=DNMP7Z4uanLqddXCRVnqXn_4eYmC8A15DuchzkO79n4,12978
-lm_deluge-0.0.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lm_deluge-0.0.21.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.21.dist-info/RECORD,,
+lm_deluge-0.0.23.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.23.dist-info/METADATA,sha256=AFWuOPqIKF8GE5qyw9uPjzpOTMy74i5ED1t3MqwOUcc,12978
+lm_deluge-0.0.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lm_deluge-0.0.23.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.23.dist-info/RECORD,,