lm-deluge 0.0.74__py3-none-any.whl → 0.0.76__py3-none-any.whl

lm_deluge/util/schema.py

@@ -0,0 +1,412 @@
+"""Schema transformation utilities for structured outputs.
+
+This module provides utilities for transforming Pydantic models and JSON schemas
+to be compatible with provider-specific structured output requirements (OpenAI, Anthropic).
+
+Key functions:
+- to_strict_json_schema: Convert Pydantic model to strict JSON schema
+- transform_schema_for_openai: Apply OpenAI-specific transformations
+- transform_schema_for_anthropic: Apply Anthropic-specific transformations
+"""
+
+from __future__ import annotations
+
+import copy
+import inspect
+from typing import Any, TypeGuard, TYPE_CHECKING, Type
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
+try:
+    import pydantic
+    from pydantic import BaseModel as _BaseModel
+except ImportError:
+    pydantic = None
+    _BaseModel = None  # type: ignore
+
+
+def is_pydantic_model(obj: Any) -> bool:
+    """Check if an object is a Pydantic model class."""
+    if pydantic is None or _BaseModel is None:
+        return False
+    return inspect.isclass(obj) and issubclass(obj, _BaseModel)
+
+
+def is_dict(obj: object) -> TypeGuard[dict[str, object]]:
+    """Type guard for dictionaries."""
+    return isinstance(obj, dict)
+
+
+def has_more_than_n_keys(obj: dict[str, object], n: int) -> bool:
+    """Check if a dictionary has more than n keys."""
+    i = 0
+    for _ in obj.keys():
+        i += 1
+        if i > n:
+            return True
+    return False
+
+
+def resolve_ref(*, root: dict[str, object], ref: str) -> object:
+    """Resolve a JSON Schema $ref pointer.
+
+    Args:
+        root: The root schema object
+        ref: The $ref string (e.g., "#/$defs/MyType")
+
+    Returns:
+        The resolved schema object
+
+    Raises:
+        ValueError: If the $ref format is invalid or cannot be resolved
+    """
+    if not ref.startswith("#/"):
+        raise ValueError(f"Unexpected $ref format {ref!r}; Does not start with #/")
+
+    path = ref[2:].split("/")
+    resolved = root
+    for key in path:
+        value = resolved[key]
+        if not is_dict(value):
+            raise ValueError(
+                f"Encountered non-dictionary entry while resolving {ref} - {resolved}"
+            )
+        resolved = value
+
+    return resolved
+
+
+def to_strict_json_schema(model: Type["BaseModel"]) -> dict[str, Any]:
+    """Convert a Pydantic model to a strict JSON schema.
+
+    This function extracts the JSON schema from a Pydantic model and ensures
+    it conforms to the strict mode requirements for structured outputs.
+
+    Args:
+        model: A Pydantic BaseModel class
+
+    Returns:
+        A JSON schema dict that conforms to strict mode requirements
+
+    Raises:
+        TypeError: If the model is not a Pydantic BaseModel
+        ImportError: If pydantic is not installed
+    """
+    if pydantic is None or _BaseModel is None:
+        raise ImportError(
+            "pydantic is required for Pydantic model support. "
+            "Install it with: pip install pydantic"
+        )
+
+    if not is_pydantic_model(model):
+        raise TypeError(
+            f"Expected a Pydantic BaseModel class, got {type(model).__name__}"
+        )
+
+    schema = model.model_json_schema()
+    return _ensure_strict_json_schema(schema, path=(), root=schema)
+
+
+def prepare_output_schema(
+    schema_obj: Type["BaseModel"] | dict[str, Any],
+) -> dict[str, Any]:
+    """Normalize a user-provided schema into strict JSON schema form.
+
+    Args:
+        schema_obj: Either a Pydantic BaseModel subclass or a JSON schema dict.
+
+    Returns:
+        A strict JSON schema suitable for provider-specific transformation.
+
+    Notes:
+        Dict schemas are deep-copied before normalization so the caller's
+        original object is left untouched.
+    """
+
+    if is_pydantic_model(schema_obj):
+        return to_strict_json_schema(schema_obj)  # type: ignore[arg-type]
+
+    if is_dict(schema_obj):
+        schema_copy = copy.deepcopy(schema_obj)
+        return _ensure_strict_json_schema(
+            schema_copy,
+            path=(),
+            root=schema_copy,
+        )
+
+    raise TypeError(
+        "output_schema must be a Pydantic BaseModel subclass or a JSON schema dict"
+    )
+
+
+def _ensure_strict_json_schema(
+    json_schema: object,
+    *,
+    path: tuple[str, ...],
+    root: dict[str, object],
+) -> dict[str, Any]:
+    """Recursively ensure a JSON schema conforms to strict mode requirements.
+
+    This function:
+    - Adds additionalProperties: false to all objects
+    - Makes all properties required
+    - Removes unsupported constraints and adds them to descriptions
+    - Expands $refs that are mixed with other properties
+    - Processes $defs, anyOf, allOf, etc.
+
+    Args:
+        json_schema: The schema to transform
+        path: Current path in the schema (for error messages)
+        root: The root schema (for resolving $refs)
+
+    Returns:
+        The transformed schema
+    """
+    if not is_dict(json_schema):
+        raise TypeError(f"Expected {json_schema} to be a dictionary; path={path}")
+
+    # Process $defs recursively
+    defs = json_schema.get("$defs")
+    if is_dict(defs):
+        for def_name, def_schema in defs.items():
+            _ensure_strict_json_schema(
+                def_schema, path=(*path, "$defs", def_name), root=root
+            )
+
+    # Process definitions recursively
+    definitions = json_schema.get("definitions")
+    if is_dict(definitions):
+        for definition_name, definition_schema in definitions.items():
+            _ensure_strict_json_schema(
+                definition_schema,
+                path=(*path, "definitions", definition_name),
+                root=root,
+            )
+
+    typ = json_schema.get("type")
+
+    # Object types - add additionalProperties: false and make all fields required
+    if typ == "object" and "additionalProperties" not in json_schema:
+        json_schema["additionalProperties"] = False
+
+    properties = json_schema.get("properties")
+    if is_dict(properties):
+        # Make all properties required
+        json_schema["required"] = list(properties.keys())
+
+        # Process each property recursively
+        json_schema["properties"] = {
+            key: _ensure_strict_json_schema(
+                prop_schema, path=(*path, "properties", key), root=root
+            )
+            for key, prop_schema in properties.items()
+        }
+
+    # Arrays - process items schema
+    items = json_schema.get("items")
+    if is_dict(items):
+        json_schema["items"] = _ensure_strict_json_schema(
+            items, path=(*path, "items"), root=root
+        )
+
+    # Unions - process each variant
+    any_of = json_schema.get("anyOf")
+    if isinstance(any_of, list):
+        json_schema["anyOf"] = [
+            _ensure_strict_json_schema(
+                variant, path=(*path, "anyOf", str(i)), root=root
+            )
+            for i, variant in enumerate(any_of)
+        ]
+
+    # Intersections - process each entry
+    all_of = json_schema.get("allOf")
+    if isinstance(all_of, list):
+        if len(all_of) == 1:
+            # Flatten single-element allOf
+            json_schema.update(
+                _ensure_strict_json_schema(
+                    all_of[0], path=(*path, "allOf", "0"), root=root
+                )
+            )
+            json_schema.pop("allOf")
+        else:
+            json_schema["allOf"] = [
+                _ensure_strict_json_schema(
+                    entry, path=(*path, "allOf", str(i)), root=root
+                )
+                for i, entry in enumerate(all_of)
+            ]
+
+    # Remove None defaults (redundant with nullable)
+    if "default" in json_schema and json_schema["default"] is None:
+        json_schema.pop("default")
+
+    # Expand $refs that are mixed with other properties
+    ref = json_schema.get("$ref")
+    if ref and has_more_than_n_keys(json_schema, 1):
+        if not isinstance(ref, str):
+            raise ValueError(f"Received non-string $ref - {ref}")
+
+        resolved = resolve_ref(root=root, ref=ref)
+        if not is_dict(resolved):
+            raise ValueError(
+                f"Expected `$ref: {ref}` to resolve to a dictionary but got {resolved}"
+            )
+
+        # Properties from json_schema take priority over $ref
+        json_schema.update({**resolved, **json_schema})
+        json_schema.pop("$ref")
+
+        # Re-process the expanded schema
+        return _ensure_strict_json_schema(json_schema, path=path, root=root)
+
+    return json_schema
+
+
+def _move_constraints_to_description(
+    json_schema: dict[str, Any],
+    constraint_keys: list[str],
+) -> dict[str, Any]:
+    """Move unsupported constraints to the description field.
+
+    This helps the model follow constraints even when they can't be enforced
+    by the grammar.
+
+    Args:
+        json_schema: The schema to modify
+        constraint_keys: List of constraint keys to move to description
+
+    Returns:
+        The modified schema
+    """
+    constraints_found = {}
+
+    for key in constraint_keys:
+        if key in json_schema:
+            constraints_found[key] = json_schema.pop(key)
+
+    if constraints_found:
+        description = json_schema.get("description", "")
+        constraint_str = ", ".join(
+            f"{key}: {value}" for key, value in constraints_found.items()
+        )
+
+        if description:
+            json_schema["description"] = f"{description}\n\n{{{constraint_str}}}"
+        else:
+            json_schema["description"] = f"{{{constraint_str}}}"
+
+    return json_schema
+
+
+def transform_schema_for_openai(schema: dict[str, Any]) -> dict[str, Any]:
+    """Return a deep copy of the schema for OpenAI requests.
+
+    OpenAI Structured Outputs currently support the standard constraints we
+    rely on (min/max length, numeric bounds, etc.), so we intentionally leave
+    the schema untouched apart from copying it to prevent downstream mutation.
+    """
+
+    return copy.deepcopy(schema)
+
+
+def _transform_schema_recursive_anthropic(
+    json_schema: dict[str, Any],
+    root: dict[str, Any],
+) -> dict[str, Any]:
+    """Recursively strip unsupported constraints for Anthropic."""
+    if not is_dict(json_schema):
+        return json_schema
+
+    # Process $defs
+    if "$defs" in json_schema and is_dict(json_schema["$defs"]):
+        for def_name, def_schema in json_schema["$defs"].items():
+            if is_dict(def_schema):
+                _transform_schema_recursive_anthropic(def_schema, root)
+
+    # Process definitions
+    if "definitions" in json_schema and is_dict(json_schema["definitions"]):
+        for def_name, def_schema in json_schema["definitions"].items():
+            if is_dict(def_schema):
+                _transform_schema_recursive_anthropic(def_schema, root)
+
+    typ = json_schema.get("type")
+
+    # Handle unsupported constraints based on type
+    if typ == "string":
+        _move_constraints_to_description(
+            json_schema,
+            ["minLength", "maxLength", "pattern"],
+        )
+    elif typ in ("number", "integer"):
+        _move_constraints_to_description(
+            json_schema,
+            [
+                "minimum",
+                "maximum",
+                "exclusiveMinimum",
+                "exclusiveMaximum",
+                "multipleOf",
+            ],
+        )
+    elif typ == "array":
+        _move_constraints_to_description(
+            json_schema,
+            [
+                "minItems",
+                "maxItems",
+            ],
+        )
+
+    # Recursively process nested schemas
+    if "properties" in json_schema and is_dict(json_schema["properties"]):
+        for prop_name, prop_schema in json_schema["properties"].items():
+            if is_dict(prop_schema):
+                _transform_schema_recursive_anthropic(prop_schema, root)
+
+    if "items" in json_schema and is_dict(json_schema["items"]):
+        _transform_schema_recursive_anthropic(json_schema["items"], root)
+
+    if "anyOf" in json_schema and isinstance(json_schema["anyOf"], list):
+        for variant in json_schema["anyOf"]:
+            if is_dict(variant):
+                _transform_schema_recursive_anthropic(variant, root)
+
+    if "allOf" in json_schema and isinstance(json_schema["allOf"], list):
+        for entry in json_schema["allOf"]:
+            if is_dict(entry):
+                _transform_schema_recursive_anthropic(entry, root)
+
+    return json_schema
+
+
+def transform_schema_for_anthropic(schema: dict[str, Any]) -> dict[str, Any]:
+    """Transform a JSON schema for Anthropic's structured output requirements."""
+
+    schema_copy = copy.deepcopy(schema)
+    return _transform_schema_recursive_anthropic(schema_copy, schema_copy)
+
+
+def get_json_schema(obj: Type["BaseModel"] | dict[str, Any]) -> dict[str, Any]:
+    """Get JSON schema from a Pydantic model or dict.
+
+    This is a convenience function that handles both Pydantic models
+    and raw dictionaries.
+
+    Args:
+        obj: Either a Pydantic BaseModel class or a dict
+
+    Returns:
+        The JSON schema dict
+    """
+    if is_pydantic_model(obj):
+        # Type narrowing: if is_pydantic_model returns True, obj must have model_json_schema
+        return obj.model_json_schema()  # type: ignore
+    elif is_dict(obj):
+        return obj  # type: ignore
+    else:
+        raise TypeError(
+            f"Expected Pydantic BaseModel or dict, got {type(obj).__name__}"
+        )

{lm_deluge-0.0.74.dist-info → lm_deluge-0.0.76.dist-info}/METADATA

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

{lm_deluge-0.0.74.dist-info → lm_deluge-0.0.76.dist-info}/RECORD

@@ -2,7 +2,7 @@ lm_deluge/__init__.py,sha256=zF5lAitfgJ8A28IXJ5BE9OUCqGOqSnGOWn3ZIlizNyY,822
 lm_deluge/batches.py,sha256=Km6QM5_7BlF2qEyo4WPlhkaZkpzrLqf50AaveHXQOoY,25127
 lm_deluge/cache.py,sha256=xO2AIYvP3tUpTMKQjwQQYfGRJSRi6e7sMlRhLjsS-u4,4873
 lm_deluge/cli.py,sha256=Ilww5gOw3J5v0NReq_Ra4hhxU4BCIJBl1oTGxJZKedc,12065
-lm_deluge/client.py,sha256=zR99e3apeH8A7kHnfaOnPoaa1jr3F-1Yzw6ZJL4zgjc,41874
+lm_deluge/client.py,sha256=RoxIeuM-LjaKl9fPXfs7rf2NyOuUNBLbTjVPkcIRfYA,44776
 lm_deluge/config.py,sha256=d7lS6i5-J23nM-UPjJ_gFcsmfgI8aPVwqw_IGGb1x3I,975
 lm_deluge/embed.py,sha256=CO-TOlC5kOTAM8lcnicoG4u4K664vCBwHF1vHa-nAGg,13382
 lm_deluge/errors.py,sha256=oHjt7YnxWbh-eXMScIzov4NvpJMo0-2r5J6Wh5DQ1tk,209
@@ -10,21 +10,21 @@ lm_deluge/file.py,sha256=PTmlJQ-IaYcYUFun9V0bJ1NPVP84edJrR0hvCMWFylY,19697
 lm_deluge/image.py,sha256=5AMXmn2x47yXeYNfMSMAOWcnlrOxxOel-4L8QCJwU70,8928
 lm_deluge/mock_openai.py,sha256=-u4kxSzwoxDt_2fLh5LaiqETnu0Jg_VDL7TWAAYHGNw,21762
 lm_deluge/prompt.py,sha256=_6xkMuEKJEizRNbjQ5gbZesoE_vtwQe2wJHdm-E6vP0,64002
-lm_deluge/request_context.py,sha256=Eek8jebtURTFlVjVH8oQEq7Ory50rqeB1K85cUAMT_8,2663
+lm_deluge/request_context.py,sha256=eM_cCXZsrVb5FF3VQl6u1dZeZrWv00wW42Cr_Fjs5oA,2752
 lm_deluge/rerank.py,sha256=-NBAJdHz9OB-SWWJnHzkFmeVO4wR6lFV7Vw-SxG7aVo,11457
 lm_deluge/tool.py,sha256=ipgNy4OpfH3CA9OPQq5zfn1xO8H08GMvDynB8ZPQ5mA,30617
 lm_deluge/tracker.py,sha256=aeS9GUJpgOSQRVXAnGDvlMO8qYpSxpTNLYj2hrMg0m8,14757
 lm_deluge/usage.py,sha256=xz9tAw2hqaJvv9aAVhnQ6N1Arn7fS8Shb28VwCW26wI,5136
 lm_deluge/warnings.py,sha256=xXXYXEfaaSVr__16BKOEEWLdfZi1L-2ylzTrXTRyO18,1748
 lm_deluge/api_requests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lm_deluge/api_requests/anthropic.py,sha256=-jj2mdAjW28l-GhvcBeSfkgCkOPAx1cjr03KFUOBBag,10062
+lm_deluge/api_requests/anthropic.py,sha256=OvkciXTHyrG1cFyC1vv6nYyCFTqtMgt1r15Q-pbHiUQ,10411
 lm_deluge/api_requests/base.py,sha256=mXEM85mcU_5LD-ugELpCl28tv-tpHKcaxerTIVLQZVo,10436
-lm_deluge/api_requests/bedrock.py,sha256=flC777E3sZZZ4qUWleO1vF0b3NVXuR8I7ayV4isosKc,15635
+lm_deluge/api_requests/bedrock.py,sha256=mY1xTvgfCLyqLlfFFmu_baKgkVq1Df1_MJXeN_G1jWQ,15597
 lm_deluge/api_requests/chat_reasoning.py,sha256=sJvstvKFqsSBUjYcwxzGt2_FH4cEp3Z6gKcBPyPjGwk,236
 lm_deluge/api_requests/common.py,sha256=BZ3vRO5TB669_UsNKugkkuFSzoLHOYJIKt4nV4sf4vc,422
 lm_deluge/api_requests/gemini.py,sha256=4uD7fQl0yWyAvYkPNi3oO1InBnvYfo5_QR6k-va-2GI,7838
 lm_deluge/api_requests/mistral.py,sha256=8JZP2CDf1XZfaPcTk0WS4q-VfYYj58ptpoH8LD3MQG4,4528
-lm_deluge/api_requests/openai.py,sha256=bS8Kvv3BJgeYoEltJgVmEk7sm5OZL6OCjDnCw3nvIgU,28283
+lm_deluge/api_requests/openai.py,sha256=E0oakhcb2T5Swfn6ATMjRZKuLyRrx4Zj5SREo1JILfc,28841
 lm_deluge/api_requests/response.py,sha256=vG194gAH5p7ulpNy4qy5Pryfb1p3ZV21-YGoj__ru3E,7436
 lm_deluge/api_requests/deprecated/bedrock.py,sha256=WrcIShCoO8JCUSlFOCHxg6KQCNTZfw3TpYTvSpYk4mA,11320
 lm_deluge/api_requests/deprecated/cohere.py,sha256=KgDScD6_bWhAzOY5BHZQKSA3kurt4KGENqC4wLsGmcU,5142
@@ -37,12 +37,15 @@ lm_deluge/built_in_tools/anthropic/__init__.py,sha256=Dxm8MJTUwMhyXT_78uIdRe8dJs
 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/__init__.py,sha256=fMBsM6cGNxmv0YHZHZ79DGrfn3XYmiucvfgtxS47Ii8,433
 lm_deluge/llm_tools/classify.py,sha256=OdMwV5u4XoPlVhjOHX0sng5KPBIKFJmQeOE2fmnPgLU,21
 lm_deluge/llm_tools/extract.py,sha256=p61JW8yv5gQxPp4P8Hkm90ERgfD_Ek5IABzjIIlX-M0,4631
+lm_deluge/llm_tools/filesystem.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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/subagents.py,sha256=srJ7On7YR0Y8WuNvf5TJl_7IUfEtG3zlxZeLgmn_-NI,8484
+lm_deluge/llm_tools/todos.py,sha256=doKJZWLZlh4J_k6HkdwonWHfZTZaxEI9_XHAoNFnfQo,14906
 lm_deluge/llm_tools/translate.py,sha256=iXyYvQZ8bC44FWhBk4qpdqjKM1WFF7Shq-H2PxhPgg4,1452
 lm_deluge/models/__init__.py,sha256=54H24K_eADbfdEH9aNORrNEXvDLZCQ4TEekeLiWljSE,4619
 lm_deluge/models/anthropic.py,sha256=sFkS-g0OWgRnVoFMKxWkSUt0qy2LVrcO5KtbYAG26iY,6283
@@ -66,11 +69,12 @@ lm_deluge/presets/meta.py,sha256=QrreLAVgYS6VIC_NQth1vgGAYuxY38jFQQZSe6ot7C8,364
 lm_deluge/util/harmony.py,sha256=XBfJck6q-5HbOqMhEjdfy1i17i0QtpHG8ruXV4EsHl0,2731
 lm_deluge/util/json.py,sha256=_4Oar2Cmz2L1DK3EtPLPDxD6rsYHxjROmV8ZpmMjQ-4,5822
 lm_deluge/util/logprobs.py,sha256=UkBZakOxWluaLqHrjARu7xnJ0uCHVfLGHJdnYlEcutk,11768
+lm_deluge/util/schema.py,sha256=q6uwhA4s1lM2dHT1Kwc46E7OY1VecMOtTEI0PTFn6tA,13206
 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.74.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.74.dist-info/METADATA,sha256=6eIB7IwAxqRTxfOeXCl9JDmyCM9KSCuuS2EfdhLfTm8,13514
-lm_deluge-0.0.74.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lm_deluge-0.0.74.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.74.dist-info/RECORD,,
+lm_deluge-0.0.76.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.76.dist-info/METADATA,sha256=JEc89Sw-9vDaMHZAPBpBJAyk11WAnGNZMs0JBQU3GZ0,13514
+lm_deluge-0.0.76.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lm_deluge-0.0.76.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.76.dist-info/RECORD,,