lm-deluge 0.0.56__py3-none-any.whl → 0.0.58__py3-none-any.whl

lm_deluge/tool.py

@@ -1,7 +1,17 @@
 import asyncio
 import inspect
 from concurrent.futures import ThreadPoolExecutor
-from typing import Any, Callable, Coroutine, Literal, TypedDict, get_type_hints
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Literal,
+    Type,
+    TypedDict,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 
 from fastmcp import Client  # pip install fastmcp >= 2.0
 from mcp.types import Tool as MCPTool
@@ -11,6 +21,196 @@ from lm_deluge.image import Image
 from lm_deluge.prompt import Text, ToolResultPart
 
 
+def _python_type_to_json_schema_enhanced(python_type: Any) -> dict[str, Any]:
+    """
+    Convert Python type annotations to JSON Schema.
+    Handles: primitives, Optional, Literal, list[T], dict[str, T], Union.
+    """
+    # Get origin and args for generic types
+    origin = get_origin(python_type)
+    args = get_args(python_type)
+
+    # Handle Optional[T] or T | None
+    if origin is type(None) or python_type is type(None):
+        return {"type": "null"}
+
+    # Handle Union types (including Optional)
+    if origin is Literal:
+        # Literal["a", "b"] -> enum
+        return {"type": "string", "enum": list(args)}
+
+    # Handle list[T]
+    if origin is list:
+        if args:
+            items_schema = _python_type_to_json_schema_enhanced(args[0])
+            return {"type": "array", "items": items_schema}
+        return {"type": "array"}
+
+    # Handle dict[str, T]
+    if origin is dict:
+        if len(args) >= 2:
+            # For dict[str, T], we can set additionalProperties
+            value_schema = _python_type_to_json_schema_enhanced(args[1])
+            return {"type": "object", "additionalProperties": value_schema}
+        return {"type": "object"}
+
+    # Handle basic types
+    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"}
+
+
+class ToolParams:
+    """
+    Helper class for constructing tool parameters more easily.
+
+    Usage:
+        # Simple constructor with Python types
+        params = ToolParams({"city": str, "age": int})
+
+        # With extras (description, enum, etc)
+        params = ToolParams({
+            "operation": (str, {"enum": ["add", "sub"], "description": "Math operation"}),
+            "value": (int, {"description": "The value"})
+        })
+
+        # From Pydantic model
+        params = ToolParams.from_pydantic(MyModel)
+
+        # From TypedDict
+        params = ToolParams.from_typed_dict(MyTypedDict)
+
+        # From existing JSON Schema
+        params = ToolParams.from_json_schema(schema_dict, required=["field1"])
+    """
+
+    def __init__(self, spec: dict[str, Any]):
+        """
+        Create ToolParams from a dict mapping parameter names to types or (type, extras) tuples.
+
+        Args:
+            spec: Dict where values can be:
+                - A Python type (str, int, list[str], etc.)
+                - A tuple of (type, extras_dict) for additional JSON Schema properties
+                - An already-formed JSON Schema dict (passed through as-is)
+        """
+        self.parameters: dict[str, Any] = {}
+        self.required: list[str] = []
+
+        for param_name, param_spec in spec.items():
+            # If it's a tuple, extract (type, extras)
+            if isinstance(param_spec, tuple):
+                param_type, extras = param_spec
+                schema = _python_type_to_json_schema_enhanced(param_type)
+                schema.update(extras)
+                self.parameters[param_name] = schema
+                # Mark as required unless explicitly marked as optional
+                if extras.get("optional") is not True:
+                    self.required.append(param_name)
+            # If it's already a dict with "type" key, use as-is
+            elif isinstance(param_spec, dict) and "type" in param_spec:
+                self.parameters[param_name] = param_spec
+                # Assume required unless marked optional
+                if param_spec.get("optional") is not True:
+                    self.required.append(param_name)
+            # Otherwise treat as a Python type
+            else:
+                self.parameters[param_name] = _python_type_to_json_schema_enhanced(
+                    param_spec
+                )
+                self.required.append(param_name)
+
+    @classmethod
+    def from_pydantic(cls, model: Type[BaseModel]) -> "ToolParams":
+        """
+        Create ToolParams from a Pydantic model.
+
+        Args:
+            model: A Pydantic BaseModel class
+        """
+        # Get the JSON schema from Pydantic
+        schema = model.model_json_schema()
+        properties = schema.get("properties", {})
+        required = schema.get("required", [])
+
+        return cls.from_json_schema(properties, required)
+
+    @classmethod
+    def from_typed_dict(cls, typed_dict: Type) -> "ToolParams":
+        """
+        Create ToolParams from a TypedDict.
+
+        Args:
+            typed_dict: A TypedDict class
+        """
+        hints = get_type_hints(typed_dict)
+
+        # TypedDict doesn't have a built-in way to mark optional fields,
+        # but we can check for Optional in the type hints
+        params = {}
+        required = []
+
+        for field_name, field_type in hints.items():
+            # Check if it's Optional (Union with None)
+            origin = get_origin(field_type)
+            # args = get_args(field_type)
+
+            is_optional = False
+            actual_type = field_type
+
+            # Check for Union types (including Optional[T] which is Union[T, None])
+            if origin is type(None):
+                is_optional = True
+                actual_type = type(None)
+
+            # For now, treat all TypedDict fields as required unless they're explicitly Optional
+            schema = _python_type_to_json_schema_enhanced(actual_type)
+            params[field_name] = schema
+
+            if not is_optional:
+                required.append(field_name)
+
+        instance = cls.__new__(cls)
+        instance.parameters = params
+        instance.required = required
+        return instance
+
+    @classmethod
+    def from_json_schema(
+        cls, properties: dict[str, Any], required: list[str] | None = None
+    ) -> "ToolParams":
+        """
+        Create ToolParams from an existing JSON Schema properties dict.
+
+        Args:
+            properties: The "properties" section of a JSON Schema
+            required: List of required field names
+        """
+        instance = cls.__new__(cls)
+        instance.parameters = properties
+        instance.required = required or []
+        return instance
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Convert to a dict with 'parameters' and 'required' keys.
+        Useful for unpacking into Tool constructor.
+        """
+        return {"parameters": self.parameters, "required": self.required}
+
+
 async def _load_all_mcp_tools(client: Client) -> list["Tool"]:
     metas: list[MCPTool] = await client.list_tools()
 
@@ -79,6 +279,24 @@ class Tool(BaseModel):
             )
         return v
 
+    @field_validator("parameters", mode="before")
+    @classmethod
+    def validate_parameters(cls, v: Any) -> dict[str, Any] | None:
+        """Accept ToolParams objects and convert to dict for backwards compatibility."""
+        if isinstance(v, ToolParams):
+            return v.parameters
+        return v
+
+    def model_post_init(self, __context: Any) -> None:
+        """
+        After validation, if parameters came from ToolParams, also update required list.
+        This is called by Pydantic after __init__.
+        """
+        # This is a bit tricky - we need to capture the required list from ToolParams
+        # Since Pydantic has already converted it in the validator, we can't access it here
+        # Instead, we'll handle this differently in the convenience constructors
+        pass
+
     def _is_async(self) -> bool:
         return inspect.iscoroutinefunction(self.run)
 
@@ -143,7 +361,7 @@ class Tool(BaseModel):
             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)
+            json_type = _python_type_to_json_schema_enhanced(param_type)
 
             parameters[param_name] = json_type
 
@@ -209,6 +427,119 @@ class Tool(BaseModel):
                 return t
         raise ValueError(f"Tool '{tool_name}' not found on that server")
 
+    @classmethod
+    def from_params(
+        cls,
+        name: str,
+        params: ToolParams,
+        *,
+        description: str | None = None,
+        run: Callable | None = None,
+        **kwargs,
+    ) -> "Tool":
+        """
+        Create a Tool from a ToolParams object.
+
+        Args:
+            name: Tool name
+            params: ToolParams object defining the parameter schema
+            description: Optional description
+            run: Optional callable to execute the tool
+            **kwargs: Additional Tool arguments
+
+        Example:
+            params = ToolParams({"city": str, "age": int})
+            tool = Tool.from_params("get_user", params, run=my_function)
+        """
+        return cls(
+            name=name,
+            description=description,
+            parameters=params.parameters,
+            required=params.required,
+            run=run,
+            **kwargs,
+        )
+
+    @classmethod
+    def from_pydantic(
+        cls,
+        name: str,
+        model: Type[BaseModel],
+        *,
+        description: str | None = None,
+        run: Callable | None = None,
+        **kwargs,
+    ) -> "Tool":
+        """
+        Create a Tool from a Pydantic model.
+
+        Args:
+            name: Tool name
+            model: Pydantic BaseModel class
+            description: Optional description (defaults to model docstring)
+            run: Optional callable to execute the tool
+            **kwargs: Additional Tool arguments
+
+        Example:
+            class UserQuery(BaseModel):
+                city: str
+                age: int
+
+            tool = Tool.from_pydantic("get_user", UserQuery, run=my_function)
+        """
+        params = ToolParams.from_pydantic(model)
+
+        # Use model docstring as default description if not provided
+        if description is None and model.__doc__:
+            description = model.__doc__.strip()
+
+        return cls(
+            name=name,
+            description=description,
+            parameters=params.parameters,
+            required=params.required,
+            run=run,
+            **kwargs,
+        )
+
+    @classmethod
+    def from_typed_dict(
+        cls,
+        name: str,
+        typed_dict: Type,
+        *,
+        description: str | None = None,
+        run: Callable | None = None,
+        **kwargs,
+    ) -> "Tool":
+        """
+        Create a Tool from a TypedDict.
+
+        Args:
+            name: Tool name
+            typed_dict: TypedDict class
+            description: Optional description
+            run: Optional callable to execute the tool
+            **kwargs: Additional Tool arguments
+
+        Example:
+            class UserQuery(TypedDict):
+                city: str
+                age: int
+
+            tool = Tool.from_typed_dict("get_user", UserQuery, run=my_function)
+        """
+        params = ToolParams.from_typed_dict(typed_dict)
+
+        return cls(
+            name=name,
+            description=description,
+            parameters=params.parameters,
+            required=params.required,
+            run=run,
+            **kwargs,
+        )
+
     @staticmethod
     def _tool_from_meta(meta: dict[str, Any], runner) -> "Tool":
         props = meta["inputSchema"].get("properties", {})
@@ -225,22 +556,11 @@ class Tool(BaseModel):
 
     @staticmethod
     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"}
-        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"}
+        """
+        Convert Python type to JSON Schema type definition.
+        Now delegates to enhanced version for better type support.
+        """
+        return _python_type_to_json_schema_enhanced(python_type)
 
     def _json_schema(
         self, include_additional_properties=False, remove_defaults=False

lm_deluge/tracker.py

@@ -171,20 +171,24 @@ class StatusTracker:
             )
 
         # Display cumulative usage stats if available
-        if self.total_cost > 0 or self.total_input_tokens > 0 or self.total_output_tokens > 0:
+        if (
+            self.total_cost > 0
+            or self.total_input_tokens > 0
+            or self.total_output_tokens > 0
+        ):
             usage_parts = []
             if self.total_cost > 0:
-                usage_parts.append(f"Cost: ${self.total_cost:.4f}")
+                usage_parts.append(f"💰 Cost: ${self.total_cost:.4f}")
             if self.total_input_tokens > 0 or self.total_output_tokens > 0:
                 usage_parts.append(
-                    f"Tokens: {self.total_input_tokens:,} in / {self.total_output_tokens:,} out"
+                    f"🔡 Tokens: {self.total_input_tokens:,} in / {self.total_output_tokens:,} out"
                 )
             if self.total_cache_read_tokens > 0:
                 usage_parts.append(f"Cache: {self.total_cache_read_tokens:,} read")
             if self.total_cache_write_tokens > 0:
                 usage_parts.append(f"{self.total_cache_write_tokens:,} write")
 
-            print(" | ".join(usage_parts))
+            print("  ", " • ".join(usage_parts))
 
     @property
     def pbar(self) -> tqdm | None:
@@ -288,7 +292,9 @@ class StatusTracker:
                     usage_text = f"   [gold3]Usage:[/gold3] {' • '.join(usage_parts)}"
 
                 if usage_text:
-                    display = Group(self._rich_progress, in_progress, capacity_text, usage_text)
+                    display = Group(
+                        self._rich_progress, in_progress, capacity_text, usage_text
+                    )
                 else:
                     display = Group(self._rich_progress, in_progress, capacity_text)
                 live.update(display)

{lm_deluge-0.0.56.dist-info → lm_deluge-0.0.58.dist-info}/METADATA

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

{lm_deluge-0.0.56.dist-info → lm_deluge-0.0.58.dist-info}/RECORD

@@ -1,23 +1,21 @@
-lm_deluge/__init__.py,sha256=D01sxqvAuW1QPYQfdSOlBFVhf7QUr78fGgCNPvKXbAc,346
-lm_deluge/agent.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lm_deluge/__init__.py,sha256=LKKIcqQoQyDpTck6fnB7iAs75BnfNNa3Bj5Nz7KU4Hk,376
 lm_deluge/batches.py,sha256=rQocJLyIs3Ko_nRdAE9jT__5cKWYxiIRAH_Lw3L0E1k,24653
 lm_deluge/cache.py,sha256=xO2AIYvP3tUpTMKQjwQQYfGRJSRi6e7sMlRhLjsS-u4,4873
 lm_deluge/cli.py,sha256=Ilww5gOw3J5v0NReq_Ra4hhxU4BCIJBl1oTGxJZKedc,12065
-lm_deluge/client.py,sha256=3V33qNbtinl5FoPDB2LxH-OLsJDWMG2bLGhQyNh_yIE,32609
+lm_deluge/client.py,sha256=1ZxQAWkmtz-zhW4E8rfU2V4BfzvqGsKhvqz_CB63-lc,32894
 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=FGomcG8s2go_55Z2CChflHgmU-UqgFftgFY8c7f_G70,5631
-lm_deluge/gemini_limits.py,sha256=V9mpS9JtXYz7AY6OuKyQp5TuIMRH1BVv9YrSNmGmHNA,1569
 lm_deluge/image.py,sha256=5AMXmn2x47yXeYNfMSMAOWcnlrOxxOel-4L8QCJwU70,8928
-lm_deluge/prompt.py,sha256=2-6bALg_hOfExh9vHeKPFA6E_O8rHe6p9eIdvCulERs,59654
+lm_deluge/prompt.py,sha256=RgZBcCiAtThqjILkPa4X530sR53SUK03U-6TWWk07tc,59607
 lm_deluge/request_context.py,sha256=o33LSEwnK6YPhZeulUoSE_VrdKCXiCQa0tjjixK2K6M,2540
 lm_deluge/rerank.py,sha256=-NBAJdHz9OB-SWWJnHzkFmeVO4wR6lFV7Vw-SxG7aVo,11457
-lm_deluge/tool.py,sha256=3weKo09E_srEKwHlz2WMVhk2BuDr5pJpi1UP0-qlcmo,16210
-lm_deluge/tracker.py,sha256=IIKReE1sNqzmhvHbokIAjKPwdOMG83jTAFanXAZCk04,14645
+lm_deluge/tool.py,sha256=eZpzgkSIlGD7KdZQwzLF-UdyRJpRnNNXpceGJrNhRrE,26421
+lm_deluge/tracker.py,sha256=aeS9GUJpgOSQRVXAnGDvlMO8qYpSxpTNLYj2hrMg0m8,14757
 lm_deluge/usage.py,sha256=xz9tAw2hqaJvv9aAVhnQ6N1Arn7fS8Shb28VwCW26wI,5136
 lm_deluge/api_requests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lm_deluge/api_requests/anthropic.py,sha256=Iy-AMo1o7xliwWhamFIUc601PZ0YWLhwAgszgfws42I,8467
+lm_deluge/api_requests/anthropic.py,sha256=7tTb_NMPodDHrCzakrLd9LyXuLqeTQyAGU-FvMoV3gI,8437
 lm_deluge/api_requests/base.py,sha256=1et-5SdRqfnvXZT3b9fBEx0vvbCwbVunHBWtQr7Wurg,5878
 lm_deluge/api_requests/bedrock.py,sha256=GmVxXz3ERAeQ7e52Nlztt81O4H9eJOQeOnS6b65vjm4,15453
 lm_deluge/api_requests/common.py,sha256=BZ3vRO5TB669_UsNKugkkuFSzoLHOYJIKt4nV4sf4vc,422
@@ -43,21 +41,21 @@ lm_deluge/llm_tools/locate.py,sha256=lYNbKTmy9dTvj0lEQkOQ7yrxyqsgYzjD0C_byJKI_4w
 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/models/__init__.py,sha256=qlpGDoTC89dKOFW3KxLUMiHCg_OzpRYHyrCt0OiSW7c,4525
-lm_deluge/models/anthropic.py,sha256=qAsykXPDz0dK8o4h9vP1QtO-3am3VDzhsYBl4YhEsds,6734
-lm_deluge/models/bedrock.py,sha256=PIaXvho2agCm1hSSAEy8zHCITjApXT2eUOGDKW425tE,5424
+lm_deluge/models/__init__.py,sha256=7HNEnpxpEguZYjcudY_9oJ79hOOLo0oNUvG-kwkEpv4,4539
+lm_deluge/models/anthropic.py,sha256=5j75sB40yZzT1wwKC7Dh0f2Y2cXnp8yxHuXW63PCuns,6285
+lm_deluge/models/bedrock.py,sha256=g1PbfceSRH2lWST3ja0mUlF3oTq4e4T-si6RMe7qXgg,4888
 lm_deluge/models/cerebras.py,sha256=u2FMXJF6xMr0euDRKLKMo_NVTOcvSrrEpehbHr8sSeE,2050
-lm_deluge/models/cohere.py,sha256=M_7cVA9QD4qe1X4sZXCpKEkKrKz2jibaspiTnzsZ1GU,3998
+lm_deluge/models/cohere.py,sha256=iXjYtM6jy_YL73Op8OfNsrMNopwae9y-Sw-4vF9cEBw,3406
 lm_deluge/models/deepseek.py,sha256=6_jDEprNNYis5I5MDQNloRes9h1P6pMYHXxOd2UZMgg,941
 lm_deluge/models/fireworks.py,sha256=yvt2Ggzye4aUqCqY74ta67Vu7FrQaLFjdFtN4P7D-dc,638
-lm_deluge/models/google.py,sha256=_spZkMBuUkWTHhb_Z7_Nq75l_3QF7aUtlk-Wyh6pWEI,6117
-lm_deluge/models/grok.py,sha256=aInkUSclXE47Lm4PKiP3OebAP9V-GOZwK-Eiis4zVow,1199
-lm_deluge/models/groq.py,sha256=djBs9N8LpzE0BQSb4KiY6F06B4f8csn-fB_5wfQTpNU,2548
-lm_deluge/models/meta.py,sha256=m6HPR82TJONYTTWkQw5EKmITMxoWzrfYOuNgFnGaRX8,2195
+lm_deluge/models/google.py,sha256=Hr2MolQoaeY85pKCGO7k7OH_1nQJdrwMgrJbfz5bI8w,5387
+lm_deluge/models/grok.py,sha256=TDzr8yfTaHbdJhwMA-Du6L-efaKFJhjTQViuVElCCHI,2566
+lm_deluge/models/groq.py,sha256=Mi5WE1xOBGoZlymD0UN6kzhH_NOmfJYU4N2l-TO0Z8Q,2552
+lm_deluge/models/meta.py,sha256=BBgnscL1gMcIdPbRqrlDl_q9YAYGSrkw9JkAIabXtLs,1883
 lm_deluge/models/mistral.py,sha256=x67o5gckBGmPcIGdVbS26XZAYFKBYM4tsxEAahGp8bk,4323
-lm_deluge/models/openai.py,sha256=vp-VcTi21N7M-Lvohx4RFkvqCl-L-UwwWH0A8GwYoX8,11452
-lm_deluge/models/openrouter.py,sha256=aAgBT5_TZQtUPQyNn-Bob6NGyrlFOclnxIb0F53pgvA,23
-lm_deluge/models/together.py,sha256=RCZoYAb8OVxdH9uwXnv47TDTGzC30P-FZoDbiBE23_g,4957
+lm_deluge/models/openai.py,sha256=HC_oNLmKkmShkcfeUgyhesACtXGg__I2WiIIDrN-X84,10176
+lm_deluge/models/openrouter.py,sha256=O-Po4tmHjAqFIVU96TUL0QnK01R4e2yDN7Z4sYJ-CuE,2120
+lm_deluge/models/together.py,sha256=AjKhPsazqBgqyLwHkNQW07COM1n_oSrYQRp2BFVvn9o,4381
 lm_deluge/presets/cerebras.py,sha256=MDkqj15qQRrj8wxSCDNNe_Cs7h1WN1UjV6lTmSY1olQ,479
 lm_deluge/presets/meta.py,sha256=QrreLAVgYS6VIC_NQth1vgGAYuxY38jFQQZSe6ot7C8,364
 lm_deluge/util/harmony.py,sha256=XBfJck6q-5HbOqMhEjdfy1i17i0QtpHG8ruXV4EsHl0,2731
@@ -66,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.56.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.56.dist-info/METADATA,sha256=-eDXjRnhBK1u3StotPfhovz7nXS5Cgitz0K3ETSf4ZA,13443
-lm_deluge-0.0.56.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lm_deluge-0.0.56.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.56.dist-info/RECORD,,
+lm_deluge-0.0.58.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.58.dist-info/METADATA,sha256=jyhXeGVPAMMYBGm3omp6MKZfQGlRX-ow_9fI58ZZNGg,13443
+lm_deluge-0.0.58.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lm_deluge-0.0.58.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.58.dist-info/RECORD,,

lm_deluge/gemini_limits.py

@@ -1,65 +0,0 @@
-gemini_flash_limits = {
-    "asia-east1": 2000,
-    "asia-east2": 200,
-    "asia-northeast1": 200,
-    "asia-northeast3": 200,
-    "asia-south1": 200,
-    "asia-southeast1": 3_000,
-    "australia-southeast1": 200,
-    "europe-central2": 200,
-    "europe-north1": 200,
-    "europe-southwest1": 200,
-    "europe-west1": 10_000,
-    "europe-west2": 200,
-    "europe-west3": 200,
-    "europe-west4": 200,
-    "europe-west6": 200,
-    "europe-west8": 200,
-    "europe-west9": 200,
-    # 'me-central1': 200,
-    "me-central2": 200,
-    "me-west1": 200,
-    "northamerica-northeast1": 200,
-    "southamerica-east1": 200,
-    "us-central1": 5_000,
-    "us-east1": 3_000,
-    "us-east4": 200,
-    # 'us-east5': 200,
-    "us-south1": 3_000,
-    "us-west1": 5_000,
-    "us-west4": 200,
-}
-
-# total: 7_520
-gemini_1_5_pro_limits = {
-    "asia-east1": 500,
-    "asia-east2": 500,
-    "asia-northeast1": 500,
-    # "asia-northeast2": 500,
-    "asia-northeast3": 500,
-    "asia-south1": 500,
-    "asia-southeast1": 500,
-    "australia-southeast1": 60,
-    "europe-central2": 500,
-    "europe-north1": 60,
-    "europe-southwest1": 60,
-    "europe-west1": 500,
-    "europe-west2": 60,
-    "europe-west3": 60,
-    "europe-west4": 60,
-    "europe-west6": 60,
-    "europe-west8": 60,
-    "europe-west9": 60,
-    "me-central1": 60,
-    "me-central2": 60,
-    "me-west1": 60,
-    "northamerica-northeast1": 60,
-    "southamerica-east1": 500,
-    "us-central1": 500,
-    "us-east1": 500,
-    "us-east4": 60,
-    # "us-east5": 60,
-    "us-south1": 60,
-    "us-west1": 500,
-    "us-west4": 60,
-}