lm-deluge 0.0.40__py3-none-any.whl → 0.0.42__py3-none-any.whl

lm_deluge/api_requests/bedrock.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import os
+import warnings
 
 from aiohttp import ClientResponse
 
@@ -135,27 +136,110 @@ async def _build_anthropic_bedrock_request(
     return request_json, base_headers, auth, url, region
 
 
+async def _build_openai_bedrock_request(
+    model: APIModel,
+    context: RequestContext,
+):
+    prompt = context.prompt
+    tools = context.tools
+    sampling_params = context.sampling_params
+
+    # Handle AWS auth
+    access_key = os.getenv("AWS_ACCESS_KEY_ID")
+    secret_key = os.getenv("AWS_SECRET_ACCESS_KEY")
+    session_token = os.getenv("AWS_SESSION_TOKEN")
+
+    if not access_key or not secret_key:
+        raise ValueError(
+            "AWS credentials not found. Please set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables."
+        )
+
+    # Determine region - GPT-OSS is available in us-west-2
+    region = "us-west-2"
+
+    # Construct the endpoint URL for OpenAI-compatible endpoint
+    service = "bedrock"
+    url = f"https://bedrock-runtime.{region}.amazonaws.com/openai/v1/chat/completions"
+
+    # Prepare headers
+    auth = AWS4Auth(
+        access_key,
+        secret_key,
+        region,
+        service,
+        session_token=session_token,
+    )
+
+    # Setup basic headers (AWS4Auth will add the Authorization header)
+    base_headers = {
+        "Content-Type": "application/json",
+    }
+
+    # Prepare request body in OpenAI format
+    request_json = {
+        "model": model.name,
+        "messages": prompt.to_openai(),
+        "temperature": sampling_params.temperature,
+        "top_p": sampling_params.top_p,
+        "max_completion_tokens": sampling_params.max_new_tokens,
+    }
+
+    # Note: GPT-OSS on Bedrock doesn't support response_format parameter
+    # Even though the model supports JSON, we can't use the response_format parameter
+    if sampling_params.json_mode and model.supports_json:
+        warnings.warn(
+            f"JSON mode requested for {model.name} but response_format parameter not supported on Bedrock"
+        )
+
+    if tools:
+        request_tools = []
+        for tool in tools:
+            if isinstance(tool, Tool):
+                request_tools.append(tool.dump_for("openai-completions"))
+            elif isinstance(tool, MCPServer):
+                as_tools = await tool.to_tools()
+                request_tools.extend(
+                    [t.dump_for("openai-completions") for t in as_tools]
+                )
+        request_json["tools"] = request_tools
+
+    return request_json, base_headers, auth, url, region
+
+
 class BedrockRequest(APIRequestBase):
     def __init__(self, context: RequestContext):
         super().__init__(context=context)
 
         self.model = APIModel.from_registry(self.context.model_name)
         self.region = None  # Will be set during build_request
+        self.is_openai_model = self.model.name.startswith("openai.")
 
     async def build_request(self):
-        self.url = f"{self.model.api_base}/messages"
-
-        # Lock images as bytes if caching is enabled
-        if self.context.cache is not None:
-            self.context.prompt.lock_images_as_bytes()
-
-        (
-            self.request_json,
-            base_headers,
-            self.auth,
-            self.url,
-            self.region,
-        ) = await _build_anthropic_bedrock_request(self.model, self.context)
+        if self.is_openai_model:
+            # Use OpenAI-compatible endpoint
+            (
+                self.request_json,
+                base_headers,
+                self.auth,
+                self.url,
+                self.region,
+            ) = await _build_openai_bedrock_request(self.model, self.context)
+        else:
+            # Use Anthropic-style endpoint
+            self.url = f"{self.model.api_base}/messages"
+
+            # Lock images as bytes if caching is enabled
+            if self.context.cache is not None:
+                self.context.prompt.lock_images_as_bytes()
+
+            (
+                self.request_json,
+                base_headers,
+                self.auth,
+                self.url,
+                self.region,
+            ) = await _build_anthropic_bedrock_request(self.model, self.context)
+
         self.request_header = self.merge_headers(
             base_headers, exclude_patterns=["anthropic", "openai", "gemini", "mistral"]
         )
@@ -232,34 +316,64 @@ class BedrockRequest(APIRequestBase):
         thinking = None
         content = None
         usage = None
+        finish_reason = None
         status_code = http_response.status
         mimetype = http_response.headers.get("Content-Type", None)
+        data = None
         assert self.context.status_tracker
 
         if status_code >= 200 and status_code < 300:
             try:
                 data = await http_response.json()
-                response_content = data["content"]
-
-                # Parse response into Message with parts
-                parts = []
-                for item in response_content:
-                    if item["type"] == "text":
-                        parts.append(Text(item["text"]))
-                    elif item["type"] == "thinking":
-                        thinking = item["thinking"]
-                        parts.append(Thinking(item["thinking"]))
-                    elif item["type"] == "tool_use":
-                        parts.append(
-                            ToolCall(
-                                id=item["id"],
-                                name=item["name"],
-                                arguments=item["input"],
+
+                if self.is_openai_model:
+                    # Handle OpenAI-style response
+                    parts = []
+                    message = data["choices"][0]["message"]
+                    finish_reason = data["choices"][0]["finish_reason"]
+
+                    # Add text content if present
+                    if message.get("content"):
+                        parts.append(Text(message["content"]))
+
+                    # Add tool calls if present
+                    if "tool_calls" in message:
+                        for tool_call in message["tool_calls"]:
+                            parts.append(
+                                ToolCall(
+                                    id=tool_call["id"],
+                                    name=tool_call["function"]["name"],
+                                    arguments=json.loads(
+                                        tool_call["function"]["arguments"]
+                                    ),
+                                )
+                            )
+
+                    content = Message("assistant", parts)
+                    usage = Usage.from_openai_usage(data["usage"])
+                else:
+                    # Handle Anthropic-style response
+                    response_content = data["content"]
+
+                    # Parse response into Message with parts
+                    parts = []
+                    for item in response_content:
+                        if item["type"] == "text":
+                            parts.append(Text(item["text"]))
+                        elif item["type"] == "thinking":
+                            thinking = item["thinking"]
+                            parts.append(Thinking(item["thinking"]))
+                        elif item["type"] == "tool_use":
+                            parts.append(
+                                ToolCall(
+                                    id=item["id"],
+                                    name=item["name"],
+                                    arguments=item["input"],
+                                )
                             )
-                        )
 
-                content = Message("assistant", parts)
-                usage = Usage.from_anthropic_usage(data["usage"])
+                    content = Message("assistant", parts)
+                    usage = Usage.from_anthropic_usage(data["usage"])
             except Exception as e:
                 is_error = True
                 error_message = (
@@ -275,6 +389,7 @@ class BedrockRequest(APIRequestBase):
             error_message = text
 
         # Handle special kinds of errors
+        retry_with_different_model = status_code in [529, 429, 400, 401, 403, 413]
         if is_error and error_message is not None:
             if (
                 "rate limit" in error_message.lower()
@@ -286,6 +401,7 @@ class BedrockRequest(APIRequestBase):
             if "context length" in error_message or "too long" in error_message:
                 error_message += " (Context length exceeded, set retries to 0.)"
                 self.context.attempts_left = 0
+            retry_with_different_model = True
 
         return APIResponse(
             id=self.context.task_id,
@@ -299,4 +415,7 @@ class BedrockRequest(APIRequestBase):
             region=self.region,
             sampling_params=self.context.sampling_params,
             usage=usage,
+            raw_response=data,
+            finish_reason=finish_reason,
+            retry_with_different_model=retry_with_different_model,
         )

lm_deluge/api_requests/openai.py

@@ -113,6 +113,9 @@ class OpenAIRequest(APIRequestBase):
         finish_reason = None
         assert self.context.status_tracker
 
+        if status_code == 500:
+            print("Internal Server Error: ", (await http_response.text()))
+
         if status_code >= 200 and status_code < 300:
             try:
                 data = await http_response.json()
@@ -305,6 +308,9 @@ class OpenAIResponsesRequest(APIRequestBase):
         data = None
         assert self.context.status_tracker
 
+        if status_code == 500:
+            print("Internal Server Error: ", http_response.text())
+
         if status_code >= 200 and status_code < 300:
             try:
                 data = await http_response.json()
@@ -428,10 +434,12 @@ class OpenAIResponsesRequest(APIRequestBase):
                     error_message = f"Error parsing {self.model.name} responses API response: {str(e)}"
 
         elif mimetype and "json" in mimetype.lower():
+            print("is_error True, json response")
             is_error = True
             data = await http_response.json()
             error_message = json.dumps(data)
         else:
+            print("is_error True, non-json response")
             is_error = True
             text = await http_response.text()
             error_message = text

lm_deluge/batches.py

@@ -1,21 +1,22 @@
-import os
+import asyncio
 import json
+import os
+import tempfile
 import time
-import asyncio
+from typing import Literal, Sequence
+
 import aiohttp
-import tempfile
-from lm_deluge.prompt import CachePattern, Conversation, prompts_to_conversations
-from lm_deluge.config import SamplingParams
-from lm_deluge.models import APIModel
-from typing import Sequence, Literal
-from lm_deluge.api_requests.openai import _build_oa_chat_request
-from lm_deluge.api_requests.anthropic import _build_anthropic_request
 from rich.console import Console
 from rich.live import Live
 from rich.spinner import Spinner
 from rich.table import Table
 from rich.text import Text
-from lm_deluge.models import registry
+
+from lm_deluge.api_requests.anthropic import _build_anthropic_request
+from lm_deluge.api_requests.openai import _build_oa_chat_request
+from lm_deluge.config import SamplingParams
+from lm_deluge.models import APIModel, registry
+from lm_deluge.prompt import CachePattern, Conversation, prompts_to_conversations
 from lm_deluge.request_context import RequestContext
 
 
@@ -162,6 +163,91 @@ async def _submit_anthropic_batch(file_path: str, headers: dict, model: str):
         return batch_id
 
 
+async def create_batch_files_oa(
+    model: str,
+    sampling_params: SamplingParams,
+    prompts: Sequence[str | list[dict] | Conversation],
+    batch_size: int = 50_000,
+    destination: str | None = None,  # if none provided, temp files
+):
+    MAX_BATCH_SIZE_BYTES = 200 * 1024 * 1024  # 200MB
+    MAX_BATCH_SIZE_ITEMS = batch_size
+
+    prompts = prompts_to_conversations(prompts)
+    if any(p is None for p in prompts):
+        raise ValueError("All prompts must be valid.")
+
+    model_obj = APIModel.from_registry(model)
+
+    current_batch = []
+    current_batch_size = 0
+    file_paths = []
+
+    for idx, prompt in enumerate(prompts):
+        assert isinstance(prompt, Conversation)
+        context = RequestContext(
+            task_id=idx,
+            model_name=model,
+            prompt=prompt,
+            sampling_params=sampling_params,
+        )
+        request = {
+            "custom_id": str(idx),
+            "method": "POST",
+            "url": "/v1/chat/completions",
+            "body": await _build_oa_chat_request(model_obj, context),
+        }
+
+        # Calculate size of this request
+        request_json = json.dumps(request) + "\n"
+        request_size = len(request_json.encode("utf-8"))
+
+        # Check if adding this request would exceed limits
+        would_exceed_size = current_batch_size + request_size > MAX_BATCH_SIZE_BYTES
+        would_exceed_items = len(current_batch) >= MAX_BATCH_SIZE_ITEMS
+
+        if current_batch and (would_exceed_size or would_exceed_items):
+            # Submit current batch
+            def write_batch_file():
+                with tempfile.NamedTemporaryFile(
+                    mode="w+", suffix=".jsonl", delete=False
+                ) as f:
+                    for batch_request in current_batch:
+                        json.dump(batch_request, f)
+                        f.write("\n")
+                    print("wrote", len(current_batch), "items")
+                    return f.name
+
+            file_path = await asyncio.to_thread(write_batch_file)
+            file_paths.append(file_path)
+            # Start new batch
+            current_batch = []
+            current_batch_size = 0
+            # current_batch_start_idx = idx
+
+        # Add request to current batch
+        current_batch.append(request)
+        current_batch_size += request_size
+
+    # Submit final batch if it has items
+    if current_batch:
+
+        def write_final_batch_file():
+            with tempfile.NamedTemporaryFile(
+                mode="w+", suffix=".jsonl", delete=False
+            ) as f:
+                for batch_request in current_batch:
+                    json.dump(batch_request, f)
+                    f.write("\n")
+                print("wrote", len(current_batch), "items")
+                return f.name
+
+        file_path = await asyncio.to_thread(write_final_batch_file)
+        file_paths.append(file_path)
+
+    return file_paths
+
+
 async def submit_batches_oa(
     model: str,
     sampling_params: SamplingParams,

lm_deluge/client.py

@@ -294,7 +294,7 @@ class _LLMClient(BaseModel):
 
             # Print error message for debugging
             error_msg = (
-                f"Error task {context.task_id}. Model: {response.model_internal}"
+                f"😔 Error task {context.task_id}. Model: {response.model_internal}"
             )
             if response.status_code:
                 error_msg += f" Code: {response.status_code},"
@@ -356,16 +356,16 @@ class _LLMClient(BaseModel):
         prompts = prompts_to_conversations(prompts)
         ids = list(range(len(prompts)))
         results: list[APIResponse | None] = [None for _ in range(len(prompts))]
-
-        # Create StatusTracker
-        tracker = StatusTracker(
-            max_requests_per_minute=self.max_requests_per_minute,
-            max_tokens_per_minute=self.max_tokens_per_minute,
-            max_concurrent_requests=self.max_concurrent_requests,
-            progress_style=self.progress,
-            use_progress_bar=show_progress,
-        )
-        tracker.init_progress_bar(total=len(prompts), disable=not show_progress)
+        # Use existing tracker if client has been opened; otherwise open/close automatically
+        tracker: StatusTracker
+        tracker_preopened = self._tracker is not None
+        if tracker_preopened:
+            tracker = self._tracker  # type: ignore[assignment]
+            tracker.add_to_total(len(prompts))
+        else:
+            self.open(total=len(prompts), show_progress=show_progress)
+            tracker = self._tracker  # type: ignore[assignment]
+        assert tracker is not None
 
         # Create retry queue for failed requests
         retry_queue: asyncio.Queue[RequestContext] = asyncio.Queue()
@@ -458,7 +458,8 @@ class _LLMClient(BaseModel):
             # Sleep - original logic
             await asyncio.sleep(seconds_to_sleep_each_loop + tracker.seconds_to_pause)
 
-        tracker.log_final_status()
+        if not tracker_preopened:
+            self.close()
 
         if return_completions_only:
             return [r.completion if r is not None else None for r in results]
@@ -473,6 +474,7 @@ class _LLMClient(BaseModel):
         show_progress=True,
         tools: list[Tool | dict | MCPServer] | None = None,
         cache: CachePattern | None = None,
+        use_responses_api: bool = False,
     ):
         return asyncio.run(
             self.process_prompts_async(
@@ -481,6 +483,7 @@ class _LLMClient(BaseModel):
                 show_progress=show_progress,
                 tools=tools,
                 cache=cache,
+                use_responses_api=use_responses_api,
             )
         )
 

lm_deluge/models/bedrock.py

@@ -96,4 +96,33 @@ BEDROCK_MODELS = {
         "tokens_per_minute": 400_000,
         "reasoning_model": True,
     },
+    # GPT-OSS on AWS Bedrock
+    "gpt-oss-120b-bedrock": {
+        "id": "gpt-oss-120b-bedrock",
+        "name": "openai.gpt-oss-120b-1:0",
+        "regions": ["us-west-2"],
+        "api_base": "",
+        "api_key_env_var": "",
+        "api_spec": "bedrock",
+        "input_cost": 0.0,
+        "output_cost": 0.0,
+        "supports_json": False,
+        "supports_logprobs": False,
+        "supports_responses": False,
+        "reasoning_model": False,
+    },
+    "gpt-oss-20b-bedrock": {
+        "id": "gpt-oss-20b-bedrock",
+        "name": "openai.gpt-oss-20b-1:0",
+        "regions": ["us-west-2"],
+        "api_base": "",
+        "api_key_env_var": "",
+        "api_spec": "bedrock",
+        "input_cost": 0.0,
+        "output_cost": 0.0,
+        "supports_json": False,
+        "supports_logprobs": False,
+        "supports_responses": False,
+        "reasoning_model": False,
+    },
 }

lm_deluge/tracker.py

@@ -14,7 +14,7 @@ from rich.progress import (
     TextColumn,
 )
 from rich.text import Text
-from tqdm import tqdm
+from tqdm.auto import tqdm
 
 SECONDS_TO_PAUSE_AFTER_RATE_LIMIT_ERROR = 5
 

{lm_deluge-0.0.40.dist-info → lm_deluge-0.0.42.dist-info}/METADATA

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

{lm_deluge-0.0.40.dist-info → lm_deluge-0.0.42.dist-info}/RECORD

@@ -1,9 +1,9 @@
 lm_deluge/__init__.py,sha256=mAztMuxINmh7dGbYnT8tsmw1eryQAvd0jpY8yHzd0EE,315
 lm_deluge/agent.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lm_deluge/batches.py,sha256=vJXVnuuGkIQnXoDPODPERrvdG9X1Ov1jnXExnPe6ZAc,21772
+lm_deluge/batches.py,sha256=rQocJLyIs3Ko_nRdAE9jT__5cKWYxiIRAH_Lw3L0E1k,24653
 lm_deluge/cache.py,sha256=VB1kv8rM2t5XWPR60uhszFcxLDnVKOe1oA5hYjVDjIo,4375
 lm_deluge/cli.py,sha256=Ilww5gOw3J5v0NReq_Ra4hhxU4BCIJBl1oTGxJZKedc,12065
-lm_deluge/client.py,sha256=ddLk9p4nHMQdDKTV2klPJ9D5Xoj89WepWMHcFFo0we0,34102
+lm_deluge/client.py,sha256=WeVdwS6_tnSEqnZRpokWL7cBXLkG1B9SXD9hF2uYKls,34292
 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
@@ -14,16 +14,16 @@ lm_deluge/prompt.py,sha256=quG4dzK2yMiRqPiF67USY5Gl2TqT3rwYkZDJTfwZFHw,37183
 lm_deluge/request_context.py,sha256=o33LSEwnK6YPhZeulUoSE_VrdKCXiCQa0tjjixK2K6M,2540
 lm_deluge/rerank.py,sha256=-NBAJdHz9OB-SWWJnHzkFmeVO4wR6lFV7Vw-SxG7aVo,11457
 lm_deluge/tool.py,sha256=_coOKB9nPNVZoseMRumRyQ8BMR7_d0IlstzMHNT69JY,15732
-lm_deluge/tracker.py,sha256=5ehC-mcLWXpI-OBm6B9W8R4wUegA9OqkRc1PxyotvnY,11526
+lm_deluge/tracker.py,sha256=EHFPsS94NmsON2u97rSE70q1t6pwCsixUmGV-kIphMs,11531
 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=J5BzYV7aYNoL6FPArB6usyS267z1BguZTRY5JLMd0So,8159
 lm_deluge/api_requests/base.py,sha256=EVHNFtlttKbN7Tt1MnLaO-NjvKHPSV5CqlRv-OnpVAE,5593
-lm_deluge/api_requests/bedrock.py,sha256=FZMhF590JzJtAYDugbDtG93RhPt5efWZ0Wn4V8U8Dgw,11031
+lm_deluge/api_requests/bedrock.py,sha256=GmVxXz3ERAeQ7e52Nlztt81O4H9eJOQeOnS6b65vjm4,15453
 lm_deluge/api_requests/common.py,sha256=BZ3vRO5TB669_UsNKugkkuFSzoLHOYJIKt4nV4sf4vc,422
 lm_deluge/api_requests/gemini.py,sha256=COHqPWmeaq9fpg0YwOZqQTUbijKnXNF4cvMLnW9kLl8,7857
 lm_deluge/api_requests/mistral.py,sha256=S_LpOfCGbCVEROH_od3P-tYeNYTKFMamMTL-c_wFCBI,4597
-lm_deluge/api_requests/openai.py,sha256=FL_UCELdkaf_GZIBPViLdNcUwPMwqvEKj9mMcH72Nmc,22346
+lm_deluge/api_requests/openai.py,sha256=queIeUwQnXUZpa7ebCkSACNCGY3LXnz9_St-AnWcCJU,22656
 lm_deluge/api_requests/response.py,sha256=Zc9kxBqB4JJIFR6OhXW-BS3ulK5JygE75JNBEpKgn5Q,5989
 lm_deluge/api_requests/deprecated/bedrock.py,sha256=WrcIShCoO8JCUSlFOCHxg6KQCNTZfw3TpYTvSpYk4mA,11320
 lm_deluge/api_requests/deprecated/cohere.py,sha256=KgDScD6_bWhAzOY5BHZQKSA3kurt4KGENqC4wLsGmcU,5142
@@ -45,7 +45,7 @@ lm_deluge/llm_tools/score.py,sha256=9oGA3-k2U5buHQXkXaEI9M4Wb5yysNhTLsPbGeghAlQ,
 lm_deluge/llm_tools/translate.py,sha256=iXyYvQZ8bC44FWhBk4qpdqjKM1WFF7Shq-H2PxhPgg4,1452
 lm_deluge/models/__init__.py,sha256=Dh2CuTZeCAddIIXwWJXOjM10B0CpKqjTdMXWYuBP0s8,4289
 lm_deluge/models/anthropic.py,sha256=3pW7fyBY9Xh1m1RtfncU9amWTtKnjGZD0STjpu8iUSQ,5700
-lm_deluge/models/bedrock.py,sha256=jpb_n-Wh3G3VAKZn7U1t5r5IQ2oTDXwrjGIP013l2cI,4534
+lm_deluge/models/bedrock.py,sha256=PIaXvho2agCm1hSSAEy8zHCITjApXT2eUOGDKW425tE,5424
 lm_deluge/models/cerebras.py,sha256=u2FMXJF6xMr0euDRKLKMo_NVTOcvSrrEpehbHr8sSeE,2050
 lm_deluge/models/cohere.py,sha256=M_7cVA9QD4qe1X4sZXCpKEkKrKz2jibaspiTnzsZ1GU,3998
 lm_deluge/models/deepseek.py,sha256=6_jDEprNNYis5I5MDQNloRes9h1P6pMYHXxOd2UZMgg,941
@@ -64,8 +64,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.40.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.40.dist-info/METADATA,sha256=QMWHzRuDQohIf6ZWjWpajRmQhAh2aJqEqAnXgVZ613s,13443
-lm_deluge-0.0.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lm_deluge-0.0.40.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.40.dist-info/RECORD,,
+lm_deluge-0.0.42.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.42.dist-info/METADATA,sha256=yfYfPalVaruEKv25EO2hCIDKUzKbM-EJgaY2i3x1_I8,13443
+lm_deluge-0.0.42.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lm_deluge-0.0.42.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.42.dist-info/RECORD,,