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

lm_deluge/image.py

@@ -1,20 +1,23 @@
-import os
-from contextlib import contextmanager
-import io
-import requests
-from PIL import Image as PILImage  # type: ignore
 import base64
+import io
 import mimetypes
+import os
+from contextlib import contextmanager
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Literal
 
+import requests
+from PIL import Image as PILImage  # type: ignore
+
+MediaType = Literal["image/jpeg", "image/png", "image/gif", "image/webp"]
+
 
 @dataclass(slots=True)
 class Image:
     # raw bytes, pathlike, http url, or base64 data url
     data: bytes | io.BytesIO | Path | str
-    media_type: str | None = None  # inferred if None
+    media_type: MediaType | None = None  # inferred if None
     detail: Literal["low", "high", "auto"] = "auto"
     type: str = field(init=False, default="image")
     _fingerprint_cache: str | None = field(init=False, default=None)

lm_deluge/llm_tools/classify.py

@@ -0,0 +1 @@
+# NOT IMPLEMENTED!!!

lm_deluge/llm_tools/locate.py

@@ -0,0 +1,162 @@
+# # utilities for locating things in images
+# from dataclasses import dataclass
+# from typing import Literal
+
+# from lm_deluge.util.json import load_json
+# from lm_deluge.util.spatial import Box2D, Point
+
+
+# @dataclass
+# class LocatePrompt:
+#     description: str
+#     task: Literal["click", "detect"] = "click"
+#     orientation: Literal["xy", "yx"] = "xy"
+#     origin: Literal["top-left", "bottom-left"] = "top-left"
+#     coords: Literal["absolute", "relative-1", "relative-1k"] = "absolute"
+#     height: int | None = None
+#     width: int | None = None
+#     output_type: Literal["point", "points", "box", "boxes"] = "point"
+#     output_fmt: Literal["json", "xml"] = "xml"
+
+#     def to_string(self) -> str:
+#         """Compose the full prompt string based on the current configuration."""
+#         parts: list[str] = []
+
+#         if self.task == "click":
+#             parts.append(
+#                 "Given an instruction, determine where to click in the image to complete it. "
+#             )
+#             parts.append(f"\n\nINSTRUCTION: {self.description}\n\n")
+#         else:
+#             if self.output_type.endswith("s"):
+#                 parts.append(
+#                     "Given a description of an object to locate, find ALL instances of that object in the image."
+#                 )
+#             else:
+#                 parts.append(
+#                     "Given a description of an object to locate, find that object in the image."
+#                 )
+#             parts.append(f"\n\nDESCRIPTION: {self.description}\n\n")
+
+#         if self.output_type == "point":
+#             point_type = "(x, y)" if self.orientation == "xy" else "(y, x)"
+#             parts.append(f"Your response should be a single {point_type} point")
+#             if self.output_fmt == "xml":
+#                 parts.append("enclosed in <point></point> tags.")
+#             else:
+#                 parts.append('formatted as JSON, like {"point": [0, 1]}.')
+
+#         elif self.output_type == "points":
+#             point_type = "(x, y)" if self.orientation == "xy" else "(y, x)"
+#             parts.append(f"Your response should be a series of {point_type} points,")
+#             if self.output_fmt == "xml":
+#                 parts.append("each one enclosed in <point></point> tags.")
+#             else:
+#                 parts.append(
+#                     'formatted as a JSON array, like [{"point": [0, 1]}, {"point": [1, 0]}].'
+#                 )
+
+#         elif self.output_type == "box":
+#             box_type = (
+#                 "(x0, y0, x1, y1)" if self.orientation == "xy" else "(y0, x0, y1, x1)"
+#             )
+#             parts.append(f"Your response should be a {box_type} bounding box,")
+
+#             if self.output_fmt == "xml":
+#                 parts.append("enclosed in <box></box> tags.")
+#             else:
+#                 parts.append('formatted as JSON, like {"box_2d": [0, 0, 1, 1]}')
+
+#         elif self.output_type == "boxes":
+#             box_type = (
+#                 "(x0, y0, x1, y1)" if self.orientation == "xy" else "(y0, x0, y1, x1)"
+#             )
+#             parts.append(
+#                 f"Your response should be a series of {box_type} bounding boxes,"
+#             )
+#             if self.output_fmt == "xml":
+#                 parts.append("each one enclosed in <box></box> tags.")
+#             else:
+#                 parts.append(
+#                     'formatted as a JSON array, like [{"box_2d": [0, 0, 1, 1]}, {"box_2d": [0.5, 0.5, 1, 1]}].'
+#                 )
+
+#         if self.coords == "absolute":
+#             parts.append(
+#                 "The returned coordinates should be absolute pixel coordinates in the image. "
+#                 f"The image has a height of {self.height} pixels and a width of {self.width} pixels. "
+#             )
+#             if self.origin == "top-left":
+#                 parts.append("The origin (0, 0) is at the top-left of the image.")
+#             else:
+#                 parts.append("The origin (0, 0) is at the bottom-left of the image.")
+#         elif self.coords == "relative-1":
+#             parts.append(
+#                 "The returned coordinates should be relative coordinates where x are between 0 and 1. "
+#             )
+#             if self.origin == "top-left":
+#                 parts.append(
+#                     "The origin (0, 0) is at the top-left of the image, and (1, 1) is at the bottom-right."
+#                 )
+#             else:
+#                 parts.append(
+#                     "The origin (0, 0) is at the bottom-left of the image, and (1, 1) is at the top-right."
+#                 )
+#         elif self.coords == "relative-1k":
+#             parts.append(
+#                 "The returned coordinates should be relative coordinates where x are between 0 and 1000. "
+#             )
+#             if self.origin == "top-left":
+#                 parts.append(
+#                     "The origin (0, 0) is at the top-left of the image, and (1000, 1000) is at the bottom-right."
+#                 )
+#             else:
+#                 parts.append(
+#                     "The origin (0, 0) is at the bottom-left of the image, and (1000, 1000) is at the top-right."
+#                 )
+
+#         parts.append(
+#             "Return JUST the structured output, no prelude or commentary needed."
+#         )
+
+#         result = ""
+#         for part in parts:
+#             if part.startswith("\n") or result.endswith("\n"):
+#                 result += part
+#             else:
+#                 result += " " + part
+
+#         return result.strip()
+
+#     def parse_output(self, output: str) -> Point | Box2D | list[Point] | list[Box2D]:
+#         if self.output_fmt == "json":
+#             loaded = load_json(output)
+#             if self.output_type == "point":
+#                 assert isinstance(loaded, dict)
+#                 if self.orientation == "xy":
+#                     x, y = loaded["point"]
+#                 else:
+#                     y, x = loaded["point"]
+
+#                     return Point(x=)
+
+#         else:
+#             pass
+
+#         return []
+
+
+# def locate_point():
+#     pass
+
+
+# def locate_points():
+#     pass
+
+
+# def locate_box():
+#     pass
+
+
+# def locate_boxes():
+#     pass

lm_deluge/prompt.py

@@ -8,7 +8,7 @@ import tiktoken
 import xxhash
 
 from lm_deluge.file import File
-from lm_deluge.image import Image
+from lm_deluge.image import Image, MediaType
 
 CachePattern = Literal[
     "tools_only",
@@ -348,7 +348,7 @@ class Message:
         self,
         data: bytes | str | Path | io.BytesIO,
         *,
-        media_type: str | None = None,
+        media_type: MediaType | None = None,
         detail: Literal["low", "high", "auto"] = "auto",
         max_size: int | None = None,
     ) -> "Message":

lm_deluge/request_context.py

@@ -34,6 +34,7 @@ class RequestContext:
     tools: list | None = None
     cache: CachePattern | None = None
     use_responses_api: bool = False
+    extra_headers: dict[str, str] | None = None
 
     # Computed properties
     cache_key: str = field(init=False)

lm_deluge/tool.py

@@ -255,6 +255,10 @@ class Tool(BaseModel):
             },
         }
 
+    def for_openai(self, strict: bool = True, **kwargs):
+        """just an alias for the above"""
+        return self.for_openai_completions(strict=strict, **kwargs)
+
     def for_openai_responses(self, **kwargs) -> dict[str, Any]:
         if self.built_in:
             return {"type": self.type, **self.built_in_args, **kwargs}

lm_deluge/util/spatial.py

@@ -0,0 +1,139 @@
+from dataclasses import dataclass
+from functools import partial
+
+from PIL import Image, ImageDraw
+
+
+@dataclass
+class Point:
+    def __init__(self, x: float, y: float, description: str | None = None):
+        self.x = x
+        self.y = y
+        self.description = description
+
+    def __getitem__(self, index):
+        if index == 0:
+            return self.x
+        elif index == 1:
+            return self.y
+        elif index == "x":
+            return self.x
+        elif index == "y":
+            return self.y
+        else:
+            raise IndexError("Index out of range")
+
+    def __iter__(self):
+        yield self.x
+        yield self.y
+
+    def __str__(self):
+        return f"Point(x={self.x}, y={self.y})"
+
+    def __repr__(self):
+        return f"Point(x={self.x}, y={self.y})"
+
+    @classmethod
+    def from_tuple(cls, point: tuple, description: str | None = None):
+        return cls(point[0], point[1], description)
+
+    @classmethod
+    def from_dict(cls, point: dict, description: str | None = None):
+        return cls(point["x"], point["y"], description)
+
+
+@dataclass
+class Box2D:
+    def __init__(
+        self,
+        xmin: float,
+        ymin: float,
+        xmax: float,
+        ymax: float,
+        description: str | None = None,
+    ):
+        self.xmin = xmin
+        self.ymin = ymin
+        self.xmax = xmax
+        self.ymax = ymax
+        self.description = description
+
+    def __repr__(self):
+        return f"Box2D(xmin={self.xmin}, ymin={self.ymin}, xmax={self.xmax}, ymax={self.ymax})"
+
+    def __str__(self):
+        return f"Box2D(xmin={self.xmin}, ymin={self.ymin}, xmax={self.xmax}, ymax={self.ymax})"
+
+    @classmethod
+    def from_list(cls, box: list):
+        return cls(box[1], box[0], box[3], box[2])
+
+    def center(self):
+        return Point((self.xmin + self.xmax) / 2, (self.ymin + self.ymax) / 2)
+
+
+def scale(
+    obj: Point | Box2D | tuple | dict,
+    src_width: int,
+    src_height: int,
+    dst_width: int,
+    dst_height: int,
+    return_integers: bool = True,
+):
+    if isinstance(obj, tuple):
+        if len(obj) == 2:
+            obj = Point(obj[0], obj[1])
+        elif len(obj) == 4:
+            obj = Box2D(obj[0], obj[1], obj[2], obj[3])
+        else:
+            raise ValueError("Invalid tuple length")
+    elif isinstance(obj, dict):
+        if "x" in obj and "y" in obj:
+            obj = Point(obj["x"], obj["y"])
+        elif "xmin" in obj and "ymin" in obj and "xmax" in obj and "ymax" in obj:
+            obj = Box2D(obj["xmin"], obj["ymin"], obj["xmax"], obj["ymax"])
+        else:
+            raise ValueError("Invalid dictionary keys")
+    scale_x = dst_width / src_width
+    scale_y = dst_height / src_height
+
+    if isinstance(obj, Point):
+        x = obj.x * scale_x
+        y = obj.y * scale_y
+        if return_integers:
+            return Point(int(x), int(y), obj.description)
+        return Point(x, y)
+    elif isinstance(obj, Box2D):
+        xmin = obj.xmin * scale_x
+        ymin = obj.ymin * scale_y
+        xmax = obj.xmax * scale_x
+        ymax = obj.ymax * scale_y
+        if return_integers:
+            return Box2D(int(xmin), int(ymin), int(xmax), int(ymax), obj.description)
+        return Box2D(xmin, ymin, xmax, ymax, obj.description)
+    else:
+        raise TypeError("Unsupported type")
+
+
+normalize_point = partial(scale, dst_width=1, dst_height=1, return_integers=False)
+denormalize_point = partial(scale, src_width=1, src_height=1, return_integers=False)
+normalize_point_1k = partial(
+    scale, dst_width=1000, dst_height=1000, return_integers=True
+)
+denormalize_point_1k = partial(
+    scale, src_width=1000, src_height=1000, return_integers=False
+)
+
+
+def draw_box(image: Image.Image | str, box: Box2D):
+    if isinstance(image, str):
+        image = Image.open(image)
+    draw = ImageDraw.Draw(image)
+    draw.rectangle((box.xmin, box.ymin, box.xmax, box.ymax), outline="red", width=2)
+    return image
+
+
+def draw_point(image: Image.Image, point: Point):
+    draw = ImageDraw.Draw(image)
+    draw.ellipse((point[0] - 2, point[1] - 2, point[0] + 2, point[1] + 2), fill="red")
+    return image

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.16
+Version: 0.0.18
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10
@@ -211,6 +211,16 @@ for tool_call in resps[0].tool_calls:
     # this is dumb sorry will make it better
     tool_to_call = [x for x in tools if x.name == tool_call.name][0]
     tool_to_call.call(**tool_call.arguments) # in async code, use .acall()
+
+# or use the built-in agent loop to handle this automatically
+import asyncio
+
+async def main():
+    conv = Conversation.user("List the files in the current directory")
+    conv, resp = await client.run_agent_loop(conv, tools=tools)
+    print(resp.content.completion)
+
+asyncio.run(main())
 ```
 
 ### Prompt Caching (Anthropic)

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

@@ -2,47 +2,54 @@ 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/cache.py,sha256=VB1kv8rM2t5XWPR60uhszFcxLDnVKOe1oA5hYjVDjIo,4375
-lm_deluge/client.py,sha256=Qn44_3x73PI0AxlmbGwO1MNz7fzjrkjB-RkhGf7k0Jo,22691
+lm_deluge/client.py,sha256=KFkI8uzHxwIvDS1PV4KjykHUMQ48wo6h-Yn4IJKUDbg,25682
 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=SIf6vh4pZ5ccrBvWc3zB_ncsWeFw2lKuIJfP3ovo6hk,7444
+lm_deluge/image.py,sha256=D8kMh2yu8sTuOchKpW9DE3XKbE6oUiFl9cRi6H1GpDc,7526
 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/prompt.py,sha256=T8o2hwv3RuxG7-fL5pCl0v14WVpmV09PdRzCZzLNszE,35265
+lm_deluge/request_context.py,sha256=l1DrPTtG80WtUhyDWblTiyT695K7Al9lWWDfdl6PMK0,2338
 lm_deluge/rerank.py,sha256=-NBAJdHz9OB-SWWJnHzkFmeVO4wR6lFV7Vw-SxG7aVo,11457
-lm_deluge/tool.py,sha256=-jeP6lYbJxwLhuiS7m84LAfgbwCjgyH-yuUCt031L58,12239
+lm_deluge/tool.py,sha256=X6NDabz53BVe1pokaKCeTLCF1-AlMAxOn1_KWiCSb7c,12407
 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=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/anthropic.py,sha256=pgDJLS98R59ZBLUGZxEPuuagEKS3UgjPgvr3LPvsndA,7815
+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/common.py,sha256=BZ3vRO5TB669_UsNKugkkuFSzoLHOYJIKt4nV4sf4vc,422
-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/gemini.py,sha256=N_94TpjpBLyekdrBjax2w0jPqYf70JycaRgZUNSsAAY,7531
+lm_deluge/api_requests/mistral.py,sha256=5EqYZgu9AfGrWs5-ucr8uJK_0cMEoUKKlEjBV3O6EPc,4561
+lm_deluge/api_requests/openai.py,sha256=vunVsUKW-YwMQ_p7DlVBBUMldjxQUaMinpzl0TyIXm4,21228
 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/built_in_tools/anthropic.py,sha256=ZvO-8hBSQdD_RzWYF0APytr8grBnBovICA76yHYTFNA,4478
+lm_deluge/built_in_tools/base.py,sha256=FLYdKVAqlffA6WOu4j8wQVRd0iHMsyBW_T3vfl--aXo,276
 lm_deluge/built_in_tools/openai.py,sha256=aLuJdXbANvXVIU38Vo2zsir7zlwWgX0d8oDPT7Ql64A,721
+lm_deluge/built_in_tools/anthropic/__init__.py,sha256=Dxm8MJTUwMhyXT_78uIdRe8dJsLHZcHThJ9UEurTw18,4526
+lm_deluge/built_in_tools/anthropic/bash.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lm_deluge/built_in_tools/anthropic/computer_use.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lm_deluge/built_in_tools/anthropic/editor.py,sha256=DyC_DrHVTm1khU9QDL39vBuhu4tO5mS5H7xMRIT0Ng4,23327
 lm_deluge/llm_tools/__init__.py,sha256=TbZTETq9i_9yYskFWQKOG4pGh5ZiyE_D-h3RArfhGp4,231
+lm_deluge/llm_tools/classify.py,sha256=OdMwV5u4XoPlVhjOHX0sng5KPBIKFJmQeOE2fmnPgLU,21
 lm_deluge/llm_tools/extract.py,sha256=C3drVAMaoFx5jNE38Xi5cXxrqboyoZ9cE7nX5ylWbXw,4482
+lm_deluge/llm_tools/locate.py,sha256=lYNbKTmy9dTvj0lEQkOQ7yrxyqsgYzjD0C_byJKI_4w,6271
 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/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.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,,
+lm_deluge-0.0.18.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.18.dist-info/METADATA,sha256=ipVPBfU_QURIDLXW3V-dwTFw_5luECxLTs3_bxku1oc,12978
+lm_deluge-0.0.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lm_deluge-0.0.18.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.18.dist-info/RECORD,,