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

lm_deluge/api_requests/mistral.py

@@ -34,6 +34,7 @@ class MistralRequest(APIRequestBase):
         debug: bool = False,
         all_model_names: list[str] | None = None,
         all_sampling_params: list[SamplingParams] | None = None,
+        tools: list | None = None,
     ):
         super().__init__(
             task_id=task_id,

lm_deluge/client.py

@@ -9,7 +9,7 @@ from typing import Sequence, overload, Literal, Any
 from tqdm.auto import tqdm
 
 from lm_deluge.prompt import Conversation
-from lm_deluge.tool import ToolSpec
+from lm_deluge.tool import Tool
 
 from .tracker import StatusTracker
 from .sampling_params import SamplingParams
@@ -231,7 +231,7 @@ class LLMClient:
         show_progress: bool = ...,
         dry_run: Literal[True],
         verbose: bool = ...,
-        tools: list[ToolSpec] | None = ...,
+        tools: list[Tool] | None = ...,
     ) -> dict[str, int]: ...
 
     @overload
@@ -243,7 +243,7 @@ class LLMClient:
         show_progress: bool = ...,
         dry_run: bool = ...,
         verbose: bool = ...,
-        tools: list[ToolSpec] | None = ...,
+        tools: list[Tool] | None = ...,
     ) -> list[str | None]: ...
 
     @overload
@@ -255,7 +255,7 @@ class LLMClient:
         show_progress: bool = ...,
         dry_run: bool = ...,
         verbose: bool = ...,
-        tools: list[ToolSpec] | None = ...,
+        tools: list[Tool] | None = ...,
     ) -> list[APIResponse | None]: ...
 
     async def process_prompts_async(
@@ -266,7 +266,7 @@ class LLMClient:
         show_progress: bool = True,
         dry_run: bool = False,
         verbose: bool = False,
-        tools: list[ToolSpec] | None = None,
+        tools: list[Tool] | None = None,
     ) -> list[APIResponse | None] | list[str | None] | dict[str, int]:
         # if prompts are not Conversations, convert them.
         # can only handle strings for now
@@ -372,7 +372,7 @@ class LLMClient:
         show_progress=True,
         dry_run: bool = False,
         verbose: bool = False,
-        tools: list[ToolSpec] | None = None,
+        tools: list[Tool] | None = None,
     ):
         return asyncio.run(
             self.process_prompts_async(
@@ -569,7 +569,7 @@ async def process_api_prompts_async(
     progress_bar: tqdm | None = None,
     use_qps: bool = False,
     verbose: bool = False,
-    tools: list[ToolSpec] | None = None,
+    tools: list[Tool] | None = None,
 ):
     """Processes API requests in parallel, throttling to stay under rate limits."""
     # change ids to integer list

lm_deluge/models.py

@@ -445,30 +445,6 @@ registry = {
         "requests_per_minute": 4_000,
         "tokens_per_minute": 400_000,
     },
-    "claude-3-haiku": {
-        "id": "claude-3-haiku",
-        "name": "claude-3-haiku-20240307",
-        "api_base": "https://api.anthropic.com/v1",
-        "api_key_env_var": "ANTHROPIC_API_KEY",
-        "supports_json": False,
-        "api_spec": "anthropic",
-        "input_cost": 0.25,
-        "output_cost": 1.25,
-        "requests_per_minute": 10_000,
-        "tokens_per_minute": 4_000_000,  # supposed to be this but they fucked up
-    },
-    "claude-3.5-haiku": {
-        "id": "claude-3.5-haiku",
-        "name": "claude-3-5-haiku-20241022",
-        "api_base": "https://api.anthropic.com/v1",
-        "api_key_env_var": "ANTHROPIC_API_KEY",
-        "supports_json": False,
-        "api_spec": "anthropic",
-        "input_cost": 1.00,
-        "output_cost": 5.00,
-        "requests_per_minute": 20_000,
-        "tokens_per_minute": 4_000_000,  # supposed to be this but they fucked up
-    },
     "claude-3.7-sonnet": {
         "id": "claude-3.7-sonnet",
         "name": "claude-3-7-sonnet-20250219",
@@ -518,6 +494,42 @@ registry = {
         "requests_per_minute": 4_000,
         "tokens_per_minute": 400_000,
     },
+    "claude-3-sonnet": {
+        "id": "claude-3-sonnet",
+        "name": "claude-3-sonnet-20240229",
+        "api_base": "https://api.anthropic.com/v1",
+        "api_key_env_var": "ANTHROPIC_API_KEY",
+        "supports_json": False,
+        "api_spec": "anthropic",
+        "input_cost": 15.0,
+        "output_cost": 75.0,
+        "requests_per_minute": 4_000,
+        "tokens_per_minute": 400_000,
+    },
+    "claude-3.5-haiku": {
+        "id": "claude-3.5-haiku",
+        "name": "claude-3-5-haiku-20241022",
+        "api_base": "https://api.anthropic.com/v1",
+        "api_key_env_var": "ANTHROPIC_API_KEY",
+        "supports_json": False,
+        "api_spec": "anthropic",
+        "input_cost": 1.00,
+        "output_cost": 5.00,
+        "requests_per_minute": 20_000,
+        "tokens_per_minute": 4_000_000,  # supposed to be this but they fucked up
+    },
+    "claude-3-haiku": {
+        "id": "claude-3-haiku",
+        "name": "claude-3-haiku-20240307",
+        "api_base": "https://api.anthropic.com/v1",
+        "api_key_env_var": "ANTHROPIC_API_KEY",
+        "supports_json": False,
+        "api_spec": "anthropic",
+        "input_cost": 0.25,
+        "output_cost": 1.25,
+        "requests_per_minute": 10_000,
+        "tokens_per_minute": 4_000_000,  # supposed to be this but they fucked up
+    },
     #  █████   █████                     █████
     # ░░███   ░░███                     ░░███
     #  ░███    ░███   ██████  ████████  ███████    ██████  █████ █████
@@ -664,7 +676,7 @@ registry = {
         "output_cost": 15.0,
         "requests_per_minute": 4_000,
         "tokens_per_minute": 400_000,
-        "reasoning_model": True,
+        "reasoning_model": False,
     },
     "claude-3.6-sonnet-bedrock": {
         "id": "claude-3.6-sonnet-bedrock",
@@ -677,10 +689,10 @@ registry = {
         "output_cost": 15.0,
         "requests_per_minute": 4_000,
         "tokens_per_minute": 400_000,
-        "reasoning_model": True,
+        "reasoning_model": False,
     },
-    "claude-sonnet-3.7-bedrock": {
-        "id": "claude-sonnet-3.7-bedrock",
+    "claude-3.7-sonnet-bedrock": {
+        "id": "claude-3.7-sonnet-bedrock",
         "name": "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
         "regions": ["us-east-1", "us-west-2", "eu-west-1"],
         "api_base": "",
@@ -692,8 +704,8 @@ registry = {
         "tokens_per_minute": 400_000,
         "reasoning_model": True,
     },
-    "claude-sonnet-4-bedrock": {
-        "id": "claude-sonnet-4-bedrock",
+    "claude-4-sonnet-bedrock": {
+        "id": "claude-4-sonnet-bedrock",
         "name": "us.anthropic.claude-sonnet-4-20250514-v1:0",
         "regions": ["us-east-1", "us-west-2", "us-east-2"],
         "api_base": "",
@@ -703,10 +715,10 @@ registry = {
         "output_cost": 15.0,
         "requests_per_minute": 4_000,
         "tokens_per_minute": 400_000,
-        "reasoning_model": False,
+        "reasoning_model": True,
     },
-    "claude-opus-4-bedrock": {
-        "id": "claude-opus-4-bedrock",
+    "claude-4-opus-bedrock": {
+        "id": "claude-4-opus-bedrock",
         "name": "us.anthropic.claude-opus-4-20250514-v1:0",
         "regions": ["us-east-1", "us-west-2", "us-east-2"],
         "api_base": "",

lm_deluge/tool.py

@@ -1,31 +1,214 @@
-from typing import Any, Literal, Callable
+from typing import Any, Literal, Callable, Coroutine, get_type_hints
+import inspect
+import asyncio
+
+from fastmcp import Client  # pip install fastmcp >= 2.0
+from mcp.types import Tool as MCPTool
 from pydantic import BaseModel, Field
 
 
-class ToolSpec(BaseModel):
+async def _load_all_mcp_tools(client: Client) -> list["Tool"]:
+    metas: list[MCPTool] = await client.list_tools()
+
+    def make_runner(name: str):
+        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)
+
+        return _async_call
+
+    tools: list[Tool] = []
+    for m in metas:
+        tools.append(
+            Tool(
+                name=m.name,
+                description=m.description,
+                parameters=m.inputSchema.get("properties", {}),
+                required=m.inputSchema.get("required", []),
+                additionalProperties=m.inputSchema.get("additionalProperties"),
+                run=make_runner(m.name),
+            )
+        )
+    return tools
+
+
+class Tool(BaseModel):
     """
     Provider‑agnostic tool definition with no extra nesting.
     """
 
     name: str
-    description: str
+    description: str | None
     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 _is_async(self) -> bool:
+        return inspect.iscoroutinefunction(self.run)
+
     def call(self, **kwargs):
         if self.run is None:
             raise ValueError("No run function provided")
-        return self.run(**kwargs)
+
+        if self._is_async():
+            coro: Coroutine = self.run(**kwargs)  # type: ignore[arg-type]
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                # no loop → safe to block
+                return asyncio.run(coro)
+            else:
+                # already inside a loop → schedule
+                return loop.create_task(coro)
+        else:
+            # plain function
+            return self.run(**kwargs)
+
+    async def acall(self, **kwargs):
+        if self.run is None:
+            raise ValueError("No run function provided")
+
+        if self._is_async():
+            return await self.run(**kwargs)  # type: ignore[func-returns-value]
+        else:
+            loop = asyncio.get_running_loop()
+            assert self.run is not None, "can't run None"
+            return await loop.run_in_executor(None, lambda: self.run(**kwargs))  # type: ignore
+
+    @classmethod
+    def from_function(cls, func: Callable) -> "Tool":
+        """Create a Tool from a function using introspection."""
+        # Get function name
+        name = func.__name__
+
+        # Get docstring for description
+        description = func.__doc__ or f"Call the {name} function"
+        description = description.strip()
+
+        # Get function signature and type hints
+        sig = inspect.signature(func)
+        type_hints = get_type_hints(func)
+
+        # Build parameters and required list
+        parameters = {}
+        required = []
+
+        for param_name, param in sig.parameters.items():
+            # Skip *args and **kwargs
+            if param.kind in (param.VAR_POSITIONAL, param.VAR_KEYWORD):
+                continue
+
+            # Get type hint
+            param_type = type_hints.get(param_name, str)
+
+            # Convert Python types to JSON Schema types
+            json_type = cls._python_type_to_json_schema(param_type)
+
+            parameters[param_name] = json_type
+
+            # Add to required if no default value
+            if param.default is param.empty:
+                required.append(param_name)
+
+        return cls(
+            name=name,
+            description=description,
+            parameters=parameters,
+            required=required,
+            run=func,
+        )
+
+    @classmethod
+    async def from_mcp_config(
+        cls,
+        config: dict[str, Any],
+        *,
+        timeout: float | None = None,
+    ) -> list["Tool"]:
+        """
+        config: full Claude-Desktop-style dict *or* just its "mcpServers" block
+        Returns {server_key: [Tool, …], …}
+        """
+        # allow caller to pass either the whole desktop file or just the sub-dict
+        servers_block = config.get("mcpServers", config)
+
+        # FastMCP understands the whole config dict directly
+        client = Client({"mcpServers": servers_block}, timeout=timeout)
+        async with client:
+            all_tools = await _load_all_mcp_tools(client)
+
+        # bucket by prefix that FastMCP added (serverkey_toolname)
+        return all_tools
+
+    @classmethod
+    async def from_mcp(
+        cls,
+        server_name: str,
+        *,
+        tool_name: str | None = None,
+        timeout: float | None = None,
+        **server_spec,  # url="…"  OR  command="…" args=[…]
+    ) -> Any:  # Tool | list[Tool]
+        """
+        Thin wrapper for one server.  Example uses:
+
+            Tool.from_mcp(url="https://weather.example.com/mcp")
+            Tool.from_mcp(command="python", args=["./assistant.py"], tool_name="answer_question")
+        """
+        # ensure at least one of command or url is defined
+        if not (server_spec.get("url") or server_spec.get("command")):
+            raise ValueError("most provide url or command")
+        # build a one-server desktop-style dict
+        cfg = {server_name: server_spec}
+        tools = await cls.from_mcp_config(cfg, timeout=timeout)
+        if tool_name is None:
+            return tools
+        for t in tools:
+            if t.name.endswith(f"{tool_name}"):  # prefixed by FastMCP
+                return t
+        raise ValueError(f"Tool '{tool_name}' not found on that server")
+
+    @staticmethod
+    def _tool_from_meta(meta: dict[str, Any], runner) -> "Tool":
+        props = meta["inputSchema"].get("properties", {})
+        req = meta["inputSchema"].get("required", [])
+        addl = meta["inputSchema"].get("additionalProperties")
+        return Tool(
+            name=meta["name"],
+            description=meta.get("description", ""),
+            parameters=props,
+            required=req,
+            additionalProperties=addl,
+            run=runner,
+        )
+
+    @staticmethod
+    def _python_type_to_json_schema(python_type: type) -> dict[str, Any]:
+        """Convert Python type to JSON Schema type definition."""
+        if python_type is int:
+            return {"type": "integer"}
+        elif python_type is float:
+            return {"type": "number"}
+        elif python_type is str:
+            return {"type": "string"}
+        elif python_type is bool:
+            return {"type": "boolean"}
+        elif python_type is list:
+            return {"type": "array"}
+        elif python_type is dict:
+            return {"type": "object"}
+        else:
+            # Default to string for unknown types
+            return {"type": "string"}
 
     def _json_schema(self, include_additional_properties=False) -> dict[str, Any]:
         res = {
             "type": "object",
             "properties": self.parameters,
-            # for openai all must be required
-            "required": list(self.parameters.keys()),
+            "required": self.required,  # Use the tool's actual required list
         }
         if include_additional_properties:
             res["additionalProperties"] = False
@@ -42,12 +225,22 @@ class ToolSpec(BaseModel):
         }
 
     def for_openai_completions(self, *, strict: bool = True) -> dict[str, Any]:
+        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()
+            )  # All parameters required in strict mode
+        else:
+            # For non-strict mode, use the original required list
+            schema = self._json_schema(include_additional_properties=True)
+
         return {
             "type": "function",
             "function": {
                 "name": self.name,
                 "description": self.description,
-                "parameters": self._json_schema(include_additional_properties=True),
+                "parameters": schema,
                 "strict": strict,
             },
         }

{lm_deluge-0.0.9.dist-info → lm_deluge-0.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.9
+Version: 0.0.11
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10
@@ -21,6 +21,7 @@ Requires-Dist: bs4
 Requires-Dist: lxml
 Requires-Dist: pdf2image
 Requires-Dist: pillow
+Requires-Dist: fastmcp>=2.4
 Requires-Dist: fasttext-wheel
 Requires-Dist: fasttext-langdetect
 Dynamic: license-file
@@ -32,6 +33,8 @@ Dynamic: license-file
 - **Unified client** – Send prompts to all relevant models with a single client.
 - **Massive concurrency with throttling** – Set `max_tokens_per_minute` and `max_requests_per_minute` and let it fly. The client will process as many requests as possible while respecting rate limits and retrying failures.
 - **Spray across models/providers** – Configure a client with multiple models from any provider(s), and sampling weights. The client samples a model for each request.
+- **Tool Use** – Unified API for defining tools for all providers, and creating tools automatically from python functions.
+- **MCP Support** – Instantiate a `Tool` from a local or remote MCP server so that any LLM can use it, whether or not that provider natively supports MCP.
 - **Caching** – Save completions in a local or distributed cache to avoid repeated LLM calls to process the same input.
 - **Convenient message constructor** – No more looking up how to build an Anthropic messages list with images. Our `Conversation` and `Message` classes work great with our client or with the `openai` and `anthropic` packages.
 - **Sync and async APIs** – Use the client from sync or async code.
@@ -66,7 +69,7 @@ To distribute your requests across models, just provide a list of more than one
 from lm_deluge import LLMClient
 
 client = LLMClient.basic(
-    ["gpt-4o-mini", "claude-haiku-anthropic"],
+    ["gpt-4o-mini", "claude-3-haiku"],
     max_requests_per_minute=10_000
 )
 resps = client.process_prompts_sync(
@@ -120,6 +123,34 @@ resps = client.process_prompts_sync([prompt])
 
 This just works. Images can be local images on disk, URLs, bytes, base64 data URLs... go wild. You can use `Conversation.to_openai` or `Conversation.to_anthropic` to format your messages for the OpenAI or Anthropic clients directly.
 
+## Basic Tool Use
+
+Define tools from Python functions and use them with any model:
+
+```python
+from lm_deluge import LLMClient, Tool
+
+def get_weather(city: str) -> str:
+    return f"The weather in {city} is sunny and 72°F"
+
+tool = Tool.from_function(get_weather)
+client = LLMClient.basic("claude-3-haiku")
+resp = client.process_prompts_sync(["What's the weather in Paris?"], tools=[tool])
+```
+
+## MCP Integration
+
+Connect to MCP servers to extend your models with external tools:
+
+```python
+from lm_deluge import LLMClient, Tool
+
+# Connect to a local MCP server
+mcp_tool = Tool.from_mcp("filesystem", command="npx -y @modelcontextprotocol/server-filesystem", args=["/path/to/directory"])
+client = LLMClient.basic("gpt-4o-mini", tools=[mcp_tool])
+resp = client.process_prompts_sync(["List the files in the current directory"])
+```
+
 ## Caching
 
 `lm_deluge.cache` includes LevelDB, SQLite and custom dictionary based caches.  Pass an instance via `LLMClient(..., cache=my_cache)` and previously seen prompts will not be re‑sent across different `process_prompts_[...]` calls.

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

@@ -1,22 +1,22 @@
 lm_deluge/__init__.py,sha256=rndOr4Rcfnpttz-onWU3vVEm-MM0WDFgz6KexKPAx0k,222
 lm_deluge/cache.py,sha256=VB1kv8rM2t5XWPR60uhszFcxLDnVKOe1oA5hYjVDjIo,4375
-lm_deluge/client.py,sha256=rk0YAUvC5kF3OuxnmYlkT8I6NjAmEJ6TUfryQbRkmXw,28960
+lm_deluge/client.py,sha256=lGD4rqT7qHkTKddjRvKK_1bh7s8GNIzXzQ52GCZhfCg,28932
 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=qdUsHC1kz82ZwduUU_rBcvJP4j2JXCL3Q2RtbHWc1H8,44998
+lm_deluge/models.py,sha256=oYrt0x0iVfTwoHjP-l1WWennzEDGwnZczj6ds6a6-xc,45406
 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=zXletfGtpgBCXuqietZn-eaOItbIyOROskTbaSjfwEk,2701
+lm_deluge/tool.py,sha256=5nFbHchv12C1jkL8nkEh6v9WfxpC0O6rALP25z60WsI,9476
 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=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/mistral.py,sha256=lU9AOyb46uTzRjKw6Sd5iojEbBIMF432fRex7q6Xtwk,5423
 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
@@ -31,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.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,,
+lm_deluge-0.0.11.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.11.dist-info/METADATA,sha256=jdPdmbo_F8ecKTAHtPTg2GeyCOFmmsJ6T4-4RUleU24,9210
+lm_deluge-0.0.11.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+lm_deluge-0.0.11.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.11.dist-info/RECORD,,