lm-deluge 0.0.15__py3-none-any.whl → 0.0.16__py3-none-any.whl

lm_deluge/models.py

@@ -1,7 +1,11 @@
+from __future__ import annotations
+
 import random
 from dataclasses import dataclass, field
 
-registry = {
+from .request_context import RequestContext
+
+BUILTIN_MODELS = {
     # `7MMM.     ,MMF'         mm
     #   MMMb    dPMM           MM
     #   M YM   ,M MM  .gP"Ya mmMMmm  ,6"Yb.
@@ -243,7 +247,7 @@ registry = {
         "supports_json": True,
         "supports_logprobs": False,
         "supports_responses": True,
-        "api_spec": "openai-responses",
+        "api_spec": "openai",
         "input_cost": 2.0,
         "output_cost": 8.0,
         "requests_per_minute": 20,
@@ -1194,6 +1198,8 @@ class APIModel:
         if name not in registry:
             raise ValueError(f"Model {name} not found in registry")
         cfg = registry[name]
+        if isinstance(cfg, APIModel):
+            return cfg
         return cls(**cfg)
 
     def sample_region(self):
@@ -1206,3 +1212,34 @@ class APIModel:
         else:
             raise ValueError("no regions to sample")
         random.sample(regions, 1, counts=weights)[0]
+
+    def make_request(self, context: RequestContext):  # -> "APIRequestBase"
+        from .api_requests.common import CLASSES
+
+        api_spec = self.api_spec
+        if (
+            context.use_responses_api
+            and self.supports_responses
+            and api_spec == "openai"
+        ):
+            api_spec = "openai-responses"
+
+        request_class = CLASSES.get(api_spec, None)
+        if request_class is None:
+            raise ValueError(f"Unsupported API spec: {api_spec}")
+        return request_class(context=context)
+
+
+registry: dict[str, APIModel] = {}
+
+
+def register_model(**kwargs) -> APIModel:
+    """Register a model configuration and return the created APIModel."""
+    model = APIModel(**kwargs)
+    registry[model.id] = model
+    return model
+
+
+# Populate registry with builtin models
+for cfg in BUILTIN_MODELS.values():
+    register_model(**cfg)

lm_deluge/prompt.py

@@ -9,7 +9,6 @@ import xxhash
 
 from lm_deluge.file import File
 from lm_deluge.image import Image
-from lm_deluge.models import APIModel
 
 CachePattern = Literal[
     "tools_only",
@@ -57,6 +56,10 @@ class ToolCall:
     name: str  # function name
     arguments: dict  # parsed arguments
     type: str = field(init=False, default="tool_call")
+    # built-in tool handling
+    built_in: bool = False
+    built_in_type: str | None = None
+    extra_body: dict | None = None
 
     @property
     def fingerprint(self) -> str:
@@ -102,10 +105,13 @@ class ToolCall:
 @dataclass(slots=True)
 class ToolResult:
     tool_call_id: str  # references the ToolCall.id
-    result: (
-        str | dict | list[dict]
-    )  # tool execution result - can be string or list for images
+    # tool execution result - can be string or list for images
+    result: str | dict | list[dict]
     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
+    built_in: bool = False
+    built_in_type: str | None = None
 
     @property
     def fingerprint(self) -> str:
@@ -126,36 +132,42 @@ class ToolResult:
         return {"tool_call_id": self.tool_call_id, "content": content}
 
     def oa_resp(self) -> dict:  # OpenAI Responses
-        # Check if this is a computer use output (special case)
-        if isinstance(self.result, dict) and self.result.get("_computer_use_output"):
-            # This is a computer use output, emit it properly
-            output_data = self.result.copy()
-            output_data.pop("_computer_use_output")  # Remove marker
+        # if normal (not built-in just return the regular output
+        if not self.built_in:
+            result = (
+                json.dumps(self.result)
+                if isinstance(self.result, list)
+                else self.result
+            )
+            return {
+                "type": "function_result",
+                "call_id": self.tool_call_id,
+                "result": result,
+            }
 
+        # if it's a built-in, OpenAI expects special type for each
+        else:
+            assert isinstance(self.result, dict)
+            output_data = self.result.copy()
             result = {
-                "type": "computer_call_output",
+                "type": self.built_in_type,
                 "call_id": self.tool_call_id,
-                "output": output_data.get("output", {}),
             }
-
-            # Add acknowledged safety checks if present
-            if "acknowledged_safety_checks" in output_data:
-                result["acknowledged_safety_checks"] = output_data[
-                    "acknowledged_safety_checks"
-                ]
+            if self.built_in_type == "computer_call":
+                result["output"] = output_data.get("output", {})
+                if "acknowledged_safety_checks" in output_data:
+                    result["acknowledged_safety_checks"] = output_data[
+                        "acknowledged_safety_checks"
+                    ]
+            elif self.built_in_type == "image_generation_call":
+                raise NotImplementedError(
+                    "implement image generation call handling in tool result"
+                )
+            elif self.built_in_type == "web_search_call":
+                pass
 
             return result
 
-        # Regular function result
-        result = (
-            json.dumps(self.result) if isinstance(self.result, list) else self.result
-        )
-        return {
-            "type": "function_result",
-            "call_id": self.tool_call_id,
-            "result": result,
-        }
-
     def anthropic(self) -> dict:  # Anthropic Messages
         return {
             "type": "tool_result",
@@ -183,6 +195,8 @@ class ToolResult:
 class Thinking:
     content: str  # reasoning content (o1, Claude thinking, etc.)
     type: str = field(init=False, default="thinking")
+    # for openai - to keep conversation chain
+    raw_payload: dict | None = None
 
     @property
     def fingerprint(self) -> str:
@@ -779,6 +793,8 @@ class Conversation:
         return n + 6 * len(self.messages)
 
     def dry_run(self, model_name: str, max_new_tokens: int):
+        from lm_deluge.models import APIModel
+
         model_obj = APIModel.from_registry(model_name)
         if model_obj.api_spec == "openai":
             image_tokens = 85

lm_deluge/request_context.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from .config import SamplingParams
+from .prompt import CachePattern, Conversation
+from .tracker import StatusTracker
+
+
+@dataclass
+class RequestContext:
+    """
+    Encapsulates all the parameters needed for an API request.
+    This reduces parameter shuttling and makes the request lifecycle clearer.
+    """
+
+    # Core request parameters
+    task_id: int
+    model_name: str
+    prompt: Conversation
+    sampling_params: SamplingParams
+
+    # Request configuration
+    attempts_left: int = 5
+    request_timeout: int = 30
+
+    # Infrastructure
+    status_tracker: StatusTracker | None = None
+    results_arr: list[Any] | None = (
+        None  # list["APIRequestBase"] but avoiding circular import
+    )
+    callback: Callable | None = None
+
+    # Optional features
+    tools: list | None = None
+    cache: CachePattern | None = None
+    use_responses_api: bool = False
+
+    # Computed properties
+    cache_key: str = field(init=False)
+    num_tokens: int = field(init=False)
+
+    def __post_init__(self):
+        # Compute cache key from prompt fingerprint
+        self.cache_key = self.prompt.fingerprint
+
+        # Compute token count
+        self.num_tokens = self.prompt.count_tokens(self.sampling_params.max_new_tokens)
+
+    def maybe_callback(self, response, tracker):
+        if not self.callback:
+            return
+        self.callback(response, tracker)
+
+    def copy(self, **overrides):
+        """Create a copy of this RequestContext with optional field overrides."""
+        # Get all current field values
+        current_values = {
+            "task_id": self.task_id,
+            "model_name": self.model_name,
+            "prompt": self.prompt,
+            "sampling_params": self.sampling_params,
+            "attempts_left": self.attempts_left,
+            "request_timeout": self.request_timeout,
+            "status_tracker": self.status_tracker,
+            "results_arr": self.results_arr,
+            "callback": self.callback,
+            "tools": self.tools,
+            "cache": self.cache,
+            "use_responses_api": self.use_responses_api,
+        }
+
+        # Update with any overrides
+        current_values.update(overrides)
+
+        return RequestContext(**current_values)

lm_deluge/tool.py

@@ -1,6 +1,6 @@
-from typing import Any, Literal, Callable, Coroutine, get_type_hints
-import inspect
 import asyncio
+import inspect
+from typing import Any, Callable, Coroutine, Literal, get_type_hints
 
 from fastmcp import Client  # pip install fastmcp >= 2.0
 from mcp.types import Tool as MCPTool
@@ -40,11 +40,15 @@ class Tool(BaseModel):
 
     name: str
     description: str | None
-    parameters: dict[str, Any]
+    parameters: dict[str, Any] | None
     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
+    # for built-in tools that don't require schema
+    built_in: bool = False
+    type: str | None = None
+    built_in_args: dict[str, Any] = Field(default_factory=dict)
 
     @field_validator("name")
     @classmethod
@@ -196,7 +200,7 @@ class Tool(BaseModel):
         )
 
     @staticmethod
-    def _python_type_to_json_schema(python_type: type) -> dict[str, Any]:
+    def _python_type_to_json_schema(python_type) -> dict[str, Any]:
         """Convert Python type to JSON Schema type definition."""
         if python_type is int:
             return {"type": "integer"}
@@ -226,20 +230,16 @@ class Tool(BaseModel):
         return res
 
     # ---------- 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]:
+    def for_openai_completions(
+        self, *, strict: bool = True, **kwargs
+    ) -> dict[str, Any]:
+        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)
             schema["required"] = list(
-                self.parameters.keys()
+                (self.parameters or {}).keys()
             )  # All parameters required in strict mode
         else:
             # For non-strict mode, use the original required list
@@ -255,7 +255,25 @@ class Tool(BaseModel):
             },
         }
 
-    def for_anthropic(self) -> dict[str, Any]:
+    def for_openai_responses(self, **kwargs) -> dict[str, Any]:
+        if self.built_in:
+            return {"type": self.type, **self.built_in_args, **kwargs}
+        return {
+            "type": "function",
+            "name": self.name,
+            "description": self.description,
+            "parameters": self._json_schema(include_additional_properties=True),
+        }
+
+    def for_anthropic(self, **kwargs) -> dict[str, Any]:
+        # built-in tools have "name", "type", maybe metadata
+        if self.built_in:
+            return {
+                "name": self.name,
+                "type": self.type,
+                **self.built_in_args,
+                **kwargs,
+            }
         return {
             "name": self.name,
             "description": self.description,
@@ -272,6 +290,9 @@ class Tool(BaseModel):
             "parameters": self._json_schema(),
         }
 
+    def for_mistral(self) -> dict[str, Any]:
+        return self.for_openai_completions()
+
     def dump_for(
         self,
         provider: Literal[
@@ -288,3 +309,60 @@ class Tool(BaseModel):
         if provider == "google":
             return self.for_google()
         raise ValueError(provider)
+
+
+class MCPServer(BaseModel):
+    """
+    Allow MCPServers to be passed directly, if provider supports it.
+    Provider can directly call MCP instead of handling it client-side.
+    Should work with Anthropic MCP connector and OpenAI responses API.
+    """
+
+    name: str
+    url: str
+    # anthropic-specific
+    token: str | None = None
+    configuration: dict | None = None
+    # openai-specific
+    headers: dict | None = None
+
+    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,
+            "server_url": self.url,
+            "require_approval": "never",
+        }
+        if self.headers:
+            res["headers"] = self.headers
+
+        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,
+            "name": self.name,
+        }
+        if self.token:
+            res["authorization_token"] = self.token
+        if self.configuration:
+            res["tool_configuration"] = self.configuration
+
+        return res

lm_deluge/tracker.py

@@ -68,6 +68,7 @@ class StatusTracker:
         self.limiting_factor = factor
 
     def check_capacity(self, num_tokens: int, retry: bool = False):
+        self.update_capacity()  # always update before checking
         request_available = self.available_request_capacity >= 1
         tokens_available = self.available_token_capacity >= num_tokens
         concurrent_request_available = (

{lm_deluge-0.0.15.dist-info → lm_deluge-0.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.15
+Version: 0.0.16
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10
@@ -128,6 +128,30 @@ This just works. Images can be local images on disk, URLs, bytes, base64 data UR
 
 See a full multi-turn chat example in `examples/multiturn.md`.
 
+## Files
+
+For models that support file uploads (OpenAI, Anthropic, and Gemini), you can easily include PDF files and other documents:
+
+```python
+from lm_deluge import LLMClient, Conversation
+
+# Simple file upload
+client = LLMClient.basic("gpt-4.1-mini")
+conversation = Conversation.user(
+    "Please summarize this document", 
+    file="path/to/document.pdf"
+)
+resps = client.process_prompts_sync([conversation])
+
+# You can also create File objects for more control
+from lm_deluge import File
+file = File("path/to/report.pdf", filename="Q4_Report.pdf")
+conversation = Conversation.user("Analyze this financial report")
+conversation.messages[0].parts.append(file)
+```
+
+Files can be local paths, URLs, bytes, or base64 data URLs, just like images.
+
 ## Tool Use
 
 Define tools from Python functions and use them with any model:

{lm_deluge-0.0.15.dist-info → lm_deluge-0.0.16.dist-info}/RECORD

@@ -1,45 +1,48 @@
 lm_deluge/__init__.py,sha256=mAztMuxINmh7dGbYnT8tsmw1eryQAvd0jpY8yHzd0EE,315
 lm_deluge/agent.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lm_deluge/batches.py,sha256=dI5G9uvmoDU9hMohrkEhlIDyJPsmsVwZPwxx6qETxxk,17728
+lm_deluge/batches.py,sha256=05t8UL1xCKjLRKtZLkfbexLqro6T_ufFVsaNIMk05Fw,17725
 lm_deluge/cache.py,sha256=VB1kv8rM2t5XWPR60uhszFcxLDnVKOe1oA5hYjVDjIo,4375
-lm_deluge/client.py,sha256=kMHA3VlCRk_Ly1CiJ6rRz2GxttxhVuw6WEQtdMVrK-4,19806
+lm_deluge/client.py,sha256=Qn44_3x73PI0AxlmbGwO1MNz7fzjrkjB-RkhGf7k0Jo,22691
 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=hFbRajqEVQbkirAfOxsTPkeq-27Zl-so4AWBFeUbpBI,7161
-lm_deluge/models.py,sha256=Xad2Ya2U4nk0z6m0l8iba8EE34-mI2HbRqdXrM6Fqc0,48641
-lm_deluge/prompt.py,sha256=KOuJFwpRKuz2F5WLniZzjOTW05I--mzYyMglr-s47F8,34601
+lm_deluge/image.py,sha256=SIf6vh4pZ5ccrBvWc3zB_ncsWeFw2lKuIJfP3ovo6hk,7444
+lm_deluge/models.py,sha256=6ZCirxOpdcg_M24cKUABYbRpLK-r9dlkXxUS9aeh0UY,49657
+lm_deluge/prompt.py,sha256=SaLcUjfzgeIZRzb6fxLp6PTFLxpvcSlaazJq3__2Sqs,35248
+lm_deluge/request_context.py,sha256=SfPu9pl5NgDVLaWGQkSXdQZ7Mm-Vw4GSTlOu-PAOE3k,2290
 lm_deluge/rerank.py,sha256=-NBAJdHz9OB-SWWJnHzkFmeVO4wR6lFV7Vw-SxG7aVo,11457
-lm_deluge/tool.py,sha256=C2zwU9-7fldfYT0TZDoVVGGSC6dN_It9GSxnfkN6Z_w,9822
-lm_deluge/tracker.py,sha256=4QQ0-H01KQp8x8KccidBIJWA5zfSQyA0kgTynvSG0gk,9202
+lm_deluge/tool.py,sha256=-jeP6lYbJxwLhuiS7m84LAfgbwCjgyH-yuUCt031L58,12239
+lm_deluge/tracker.py,sha256=-EkFDAklh5mclIFR-5SthAwNL4p1yKS8LUN7rhpOVPQ,9266
 lm_deluge/usage.py,sha256=VMEKghePFIID5JFBObqYxFpgYxnbYm_dnHy7V1-_T6M,4866
-lm_deluge/api_requests/__init__.py,sha256=_aSpD6CJL9g6OpLPoChXiHjl4MH_OlGcKgfZaW8cgLM,71
-lm_deluge/api_requests/anthropic.py,sha256=itKPu1cqCYcrr4fkLarlvSYr6tqLEAGVLGXEG05QXWM,8345
-lm_deluge/api_requests/base.py,sha256=THgCceZ_z9YjA_E9WWME5f2tIRSOOI2OAQCAWVlV-Xg,12448
-lm_deluge/api_requests/bedrock.py,sha256=yh4-zMrjlQfmxoBbrc2WYJ8gEqVkTP_-tMR7-XbTAtQ,11753
+lm_deluge/api_requests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lm_deluge/api_requests/anthropic.py,sha256=nO4Gf59ZddZUURDqkiR3P3Mbr7De7sEcGL6fdYdbozU,7699
+lm_deluge/api_requests/base.py,sha256=wKB6a5nNwD-ST_nNRVUlA3l_O9HhccPcGA2fJut7kfw,4430
+lm_deluge/api_requests/bedrock.py,sha256=EDYzE7zeYscUeyIai-uHd-fDuPXZszWfSPn55XgUbCI,10846
 lm_deluge/api_requests/common.py,sha256=BZ3vRO5TB669_UsNKugkkuFSzoLHOYJIKt4nV4sf4vc,422
-lm_deluge/api_requests/gemini.py,sha256=8qWdHFsse3gYU2MiJRI_FAmM-Ez8YCGmHtHGI6_z-ww,8203
-lm_deluge/api_requests/mistral.py,sha256=PkuoKbOJAB6DOK_NvzbxpWPAktfvonf69QjC0tVCYuE,5366
-lm_deluge/api_requests/openai.py,sha256=HUn83Y_Roo3pCUTBnrQhL9skW_PJ4OvS5gr5rIg58dU,19366
-lm_deluge/api_requests/response.py,sha256=X6AHXv-4dWHLKkPv7J0MSesweunqxIqJED6UY6ypdzE,5770
+lm_deluge/api_requests/gemini.py,sha256=6brxdouJcsJSEb8OZxklrTaqbZ1M-gWulNkGJqAKWV8,7400
+lm_deluge/api_requests/mistral.py,sha256=diflr8NlsJGpSlY1F5Ay0GMZhBDdv9L2JV70UaHnOBs,4431
+lm_deluge/api_requests/openai.py,sha256=4MgEoEQ9n_vwsNOyM2tWaPIV3IN5x7UUCrXFlqeZYLk,20782
+lm_deluge/api_requests/response.py,sha256=JFSwHAs-yaJYkscOgTAyHkt-v8FDZ5mgER9NmueXTGk,5866
 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
 lm_deluge/api_requests/deprecated/mistral.py,sha256=pOfOZUM4U35I3Plch84SnAFpDAzouHcSNNMtgxRvjy4,4709
 lm_deluge/api_requests/deprecated/vertex.py,sha256=ygXz2RjdXErPCSBbiHLEWbf5_sSTIi31WoX0UaoYzRI,15275
-lm_deluge/computer_use/anthropic_tools.py,sha256=p1CgHw1htX0PTdDW9Tni9N1azVMCoyA_ei-fMT6HHis,2478
+lm_deluge/built_in_tools/anthropic.py,sha256=ZvO-8hBSQdD_RzWYF0APytr8grBnBovICA76yHYTFNA,4478
+lm_deluge/built_in_tools/openai.py,sha256=aLuJdXbANvXVIU38Vo2zsir7zlwWgX0d8oDPT7Ql64A,721
 lm_deluge/llm_tools/__init__.py,sha256=TbZTETq9i_9yYskFWQKOG4pGh5ZiyE_D-h3RArfhGp4,231
-lm_deluge/llm_tools/extract.py,sha256=-GtyqJUxKvB567tk_NnCMklazz18xZBCPlAjYHTVUWg,3649
+lm_deluge/llm_tools/extract.py,sha256=C3drVAMaoFx5jNE38Xi5cXxrqboyoZ9cE7nX5ylWbXw,4482
+lm_deluge/llm_tools/ocr.py,sha256=7fDlvs6uUOvbxMasvGGNJx5Fj6biM6z3lijKZaGN26k,23
 lm_deluge/llm_tools/score.py,sha256=9oGA3-k2U5buHQXkXaEI9M4Wb5yysNhTLsPbGeghAlQ,2580
 lm_deluge/llm_tools/translate.py,sha256=iXyYvQZ8bC44FWhBk4qpdqjKM1WFF7Shq-H2PxhPgg4,1452
 lm_deluge/util/json.py,sha256=_4Oar2Cmz2L1DK3EtPLPDxD6rsYHxjROmV8ZpmMjQ-4,5822
 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.15.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.15.dist-info/METADATA,sha256=Xahpew4j6u9EgJGJf6l_wvnKpq1c2I1hoQQh3RIhUes,11942
-lm_deluge-0.0.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lm_deluge-0.0.15.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.15.dist-info/RECORD,,
+lm_deluge-0.0.16.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.16.dist-info/METADATA,sha256=hfp55fuKt7dlheGj1uOcOoSMzSLmddXA85Gqe1U4KAM,12689
+lm_deluge-0.0.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lm_deluge-0.0.16.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.16.dist-info/RECORD,,