model-library 0.1.7__py3-none-any.whl → 0.1.8__py3-none-any.whl

model_library/retriers/token.py

@@ -0,0 +1,427 @@
+import asyncio
+import logging
+import time
+import uuid
+from asyncio.tasks import Task
+from math import ceil, floor
+from typing import Any, Callable, Coroutine
+
+from redis.asyncio import Redis
+
+from model_library.base.base import QueryResult, RateLimit
+from model_library.exceptions import exception_message
+from model_library.retriers.base import BaseRetrier
+from model_library.retriers.utils import jitter
+
+RETRY_WAIT_TIME: float = 20.0
+TOKEN_WAIT_TIME: float = 5.0
+
+MAX_PRIORITY: int = 1
+MIN_PRIORITY: int = 5
+
+MAX_RETRIES: int = 10
+
+redis_client: Redis
+LOCK_TIMEOUT: int = 10  # using 10 in case there is high compute load, don't want to error on lock releases
+
+
+def set_redis_client(client: Redis):
+    global redis_client
+    redis_client = client
+
+
+refill_tasks: dict[str, tuple[dict[str, int | Any], Task[None]]] = {}
+
+
+class TokenRetrier(BaseRetrier):
+    """
+    Token-based retry strategy
+    Predicts the number of tokens required for a query, sends resquests to respect the rate limit,
+    then adjusts the estimate based on actual usage.
+    """
+
+    @staticmethod
+    def get_token_key(client_registry_key: tuple[str, str]) -> str:
+        """Get the key which stores remaining tokens"""
+        return f"{client_registry_key[0]}:{client_registry_key[1]}:tokens"
+
+    @staticmethod
+    def get_priority_key(client_registry_key: tuple[str, str], priority: int) -> str:
+        """Get the key which stores the amount of tasks waiting for a given priority"""
+        return f"{client_registry_key[0]}:{client_registry_key[1]}:priority:{priority}"
+
+    @staticmethod
+    async def init_remaining_tokens(
+        client_registry_key: tuple[str, str],
+        limit: int,
+        limit_refresh_seconds: int,
+        logger: logging.Logger,
+        get_rate_limit_func: Callable[[], Coroutine[Any, Any, RateLimit | None]],
+    ) -> None:
+        """
+        Initialize remaining tokens in storage and start background refill process
+        """
+
+        async def _header_correction_loop(
+            key: str,
+            limit: int,
+            tokens_per_second: int,
+            get_rate_limit_func: Callable[[], Coroutine[Any, Any, RateLimit | None]],
+            version: str,
+        ) -> None:
+            """
+            Background loop that correct tokens based on provider headers
+            Every 5 seconds
+            """
+            interval = 5.0
+
+            assert redis_client
+            while True:
+                await asyncio.sleep(interval)
+                current_version = await redis_client.get("version:" + key)
+                if current_version != version:
+                    logger.debug(
+                        f"version changed ({current_version} != {version}), exiting _header_correction_loop for {key}"
+                    )
+                    return
+
+                rate_limit = await get_rate_limit_func()
+                if rate_limit is None:
+                    # kill the task as no headers are provided
+                    logger.debug(
+                        f"no rate limit headers, exiting _header_correction_loop for {key}"
+                    )
+                    return
+
+                tokens_remaining = rate_limit.token_remaining_total
+
+                async with redis_client.lock(key + ":lock", timeout=LOCK_TIMEOUT):
+                    current = int(await redis_client.get(key))
+
+                    # increment
+                    elapsed = time.time() - rate_limit.unix_timestamp
+                    adjusted = floor(tokens_remaining + (tokens_per_second * elapsed))
+
+                    # if the headers show a lower value, correct with that
+                    if adjusted < current:
+                        await redis_client.set(key, adjusted)
+                        logger.info(
+                            f"Corrected {key} from {current} to {adjusted} based on headers ({elapsed:.1f}s old)"
+                        )
+                    else:
+                        logger.debug(
+                            f"Not correcting {key} from {current} to {adjusted} based on headers ({elapsed:.1f}s old) (higher value)"
+                        )
+
+        async def _token_refill_loop(
+            key: str,
+            limit: int,
+            tokens_per_second: int,
+            version: str,
+        ) -> None:
+            """
+            Background loop that refills tokens
+            Every second
+            """
+            interval: float = 1.0
+
+            assert redis_client
+            while True:
+                await asyncio.sleep(interval)
+                current_version = await redis_client.get("version:" + key)
+                if current_version != version:
+                    logger.debug(
+                        f"version changed ({current_version} != {version}), exiting _token_refill_loop for {key}"
+                    )
+                    return
+
+                async with redis_client.lock(key + ":lock", timeout=LOCK_TIMEOUT):
+                    # increment
+                    current = await redis_client.incrby(key, tokens_per_second)
+                    logger.debug(
+                        f"[Token Refill] | {key} | Amount: {tokens_per_second} | Current: {current}"
+                    )
+                    # cap at limit
+                    if current > limit:
+                        logger.debug(f"[Token Cap] | {key} | Limit: {limit}")
+                        await redis_client.set(key, limit)
+
+        key = TokenRetrier.get_token_key(client_registry_key)
+
+        # limit_key is only used to check if the limit has changed
+        limit_key = f"{key}:limit"
+
+        async with redis_client.lock("init:" + key + ":lock", timeout=LOCK_TIMEOUT):
+            old_limit = int(await redis_client.get(limit_key) or 0)
+
+            # keep track of version so we can clean up old tasks
+            # even if the limit has not changed, reset background tasks just in case
+            version = str(uuid.uuid4())
+            await redis_client.set("version:" + key, version)
+
+            if old_limit != limit or not await redis_client.exists(key):
+                # if new limit if different, set it
+                await redis_client.set(key, limit)
+                await redis_client.set(limit_key, limit)
+
+            tokens_per_second = floor(limit / limit_refresh_seconds)
+
+            refill_task = asyncio.create_task(
+                _token_refill_loop(key, limit, tokens_per_second, version)
+            )
+            correction_task = asyncio.create_task(
+                _header_correction_loop(
+                    key, limit, tokens_per_second, get_rate_limit_func, version
+                )
+            )
+
+            refill_tasks["refill:" + key] = (
+                {
+                    "limit": limit,
+                    "limit_refresh_seconds": limit_refresh_seconds,
+                },
+                refill_task,
+            )
+            refill_tasks["correction:" + key] = (
+                {
+                    "limit": limit,
+                    "limit_refresh_seconds": limit_refresh_seconds,
+                    "get_rate_limit_func": get_rate_limit_func,
+                },
+                correction_task,
+            )
+
+    async def _get_remaining_tokens(self) -> int:
+        """Get remaining tokens"""
+        tokens = await redis_client.get(self.token_key)
+        return int(tokens)
+
+    async def _deduct_remaining_tokens(self) -> None:
+        """Deduct from remaining tokens"""
+        # NOTE: decrby is atomic
+        await redis_client.decrby(self.token_key, self.actual_estimate_total_tokens)
+
+    def __init__(
+        self,
+        logger: logging.Logger,
+        max_tries: int | None = MAX_RETRIES,
+        max_time: float | None = None,
+        retry_callback: Callable[[int, Exception | None, float, float], None]
+        | None = None,
+        *,
+        client_registry_key: tuple[str, str],
+        estimate_input_tokens: int,
+        estimate_output_tokens: int,
+        dynamic_estimate_instance_id: str | None = None,
+        retry_wait_time: float = RETRY_WAIT_TIME,
+        token_wait_time: float = TOKEN_WAIT_TIME,
+    ):
+        super().__init__(
+            strategy="token",
+            logger=logger,
+            max_tries=max_tries,
+            max_time=max_time,
+            retry_callback=retry_callback,
+        )
+
+        self.client_registry_key = client_registry_key
+
+        self.estimate_input_tokens = estimate_input_tokens
+        self.estimate_output_tokens = estimate_output_tokens
+        self.estimate_total_tokens = estimate_input_tokens + estimate_output_tokens
+        self.actual_estimate_total_tokens = (
+            self.estimate_total_tokens
+        )  # when multiplying base estimate_total_tokens by ratio
+
+        self.retry_wait_time = retry_wait_time
+        self.token_wait_time = token_wait_time
+
+        self.priority = MAX_PRIORITY
+
+        self.token_key = TokenRetrier.get_token_key(client_registry_key)
+        self._token_key_lock = self.token_key + ":lock"
+        self._init_key_lock = "init:" + self.token_key + ":lock"
+
+        self.dynamic_estimate_key = (
+            f"{self.token_key}:dynamic_estimate:{dynamic_estimate_instance_id}"
+            if dynamic_estimate_instance_id
+            else None
+        )
+
+    async def _calculate_wait_time(
+        self, attempt: int, exception: Exception | None = None
+    ) -> float:
+        """Wait time between retries"""
+        return jitter(self.retry_wait_time)
+
+    async def _on_retry(
+        self, exception: Exception | None, elapsed: float, wait_time: float
+    ) -> None:
+        """Log retry attempt and update priority/attempts only on actual exceptions"""
+
+        self.priority = min(MIN_PRIORITY, self.priority + 1)
+
+        logger_msg = (
+            f"[Token Retry] | Attempt: {self.attempts}/{self.max_tries} | Elapsed: {elapsed:.1f}s | "
+            f"Next wait: {wait_time:.1f}s | Priority: {self.priority} ({MAX_PRIORITY}-{MIN_PRIORITY}) | "
+            f"Exception: {exception_message(exception)}"
+        )
+
+        self.logger.warning(logger_msg)
+
+        if self.retry_callback:
+            self.retry_callback(self.attempts, exception, elapsed, wait_time)
+
+    async def _has_lower_priority_waiting(self) -> bool:
+        """
+        Check if there are lower priority requests waiting
+        """
+
+        # NOTE: no lock needed, stale counts are fine
+        for priority in range(MAX_PRIORITY, self.priority):
+            key = TokenRetrier.get_priority_key(self.client_registry_key, priority)
+            count = await redis_client.get(key)
+            self.logger.debug(f"priority: {priority}, count: {count}")
+            if count and int(count) > 0:
+                return True
+        return False
+
+    async def _pre_function(self) -> None:
+        """
+        Loop until sufficient tokens are available.
+        Acquires priority semaphore, checks for lower priority requests, deducts tokens from Redis.
+        Logs token waits but does not count as retry attempts.
+        """
+
+        priority_key = TokenRetrier.get_priority_key(
+            self.client_registry_key, self.priority
+        )
+
+        # let storage know we are waiting at this priority
+        await redis_client.incr(priority_key)
+        self.logger.debug(f"priority: {self.priority}, waiting: {priority_key}")
+
+        try:
+            while True:
+                wait_time = jitter(self.token_wait_time)
+
+                # if there is a task with lower priority waiting, go back to waiting
+                if await self._has_lower_priority_waiting():
+                    self.logger.debug(
+                        f"[Token Wait] Lower priority requests exist, waiting {wait_time:.1f}s | "
+                        f"Priority: {self.priority}"
+                    )
+                else:
+                    # dynamically adjust actual estimate tokens based on past requests
+                    if self.dynamic_estimate_key:
+                        # NOTE: ok to not lock, don't need precise ratio
+                        ratio = float(
+                            await redis_client.get(self.dynamic_estimate_key) or 1.0
+                        )
+                        self.actual_estimate_total_tokens = ceil(
+                            self.estimate_total_tokens * ratio
+                        )
+                        self.logger.debug(
+                            f"Adjusted actual estimate tokens to {self.actual_estimate_total_tokens} using ratio {ratio}"
+                        )
+
+                    # TODO: use luascript to avoid using locks
+
+                    # NOTE: `async with` releases lock in all situations
+                    async with redis_client.lock(
+                        self._token_key_lock, timeout=LOCK_TIMEOUT
+                    ):
+                        tokens_remaining = await self._get_remaining_tokens()
+
+                        # if we have enough tokens, deduct estimate tokens and make request
+                        if tokens_remaining >= self.actual_estimate_total_tokens:
+                            self.logger.debug(
+                                f"Enough tokens {self.actual_estimate_total_tokens}/{tokens_remaining}, deducting"
+                            )
+                            await self._deduct_remaining_tokens()
+                            return
+
+                    self.logger.warning(
+                        f"[Token Wait] Insufficient tokens, waiting {wait_time:.1f}s | "
+                        f"estimate_tokens: {self.actual_estimate_total_tokens}/{tokens_remaining} | "
+                        f"Priority: {self.priority}"
+                    )
+
+                # Zzz
+                self.logger.debug(f"Sleeping for {wait_time:.1f}s")
+                await asyncio.sleep(wait_time)
+        finally:
+            # let storage know we are done waiting at this priority
+            await redis_client.decr(priority_key)
+
+    async def _adjust_dynamic_estimate_ratio(self, actual_tokens: int) -> None:
+        if not self.dynamic_estimate_key:
+            return
+
+        observed_ratio = actual_tokens / self.estimate_total_tokens
+
+        alpha = 0.3
+
+        async with redis_client.lock(
+            self.dynamic_estimate_key + ":lock", timeout=LOCK_TIMEOUT
+        ):
+            current_ratio = float(
+                await redis_client.get(self.dynamic_estimate_key) or 1.0
+            )
+
+            new_ratio = (observed_ratio * alpha) + (current_ratio * (1 - alpha))
+
+            # NOTE: for now, will not cap the ratio as estimates will likely be very off
+            # the ratio between the tokenized estimate and the dynamic estimate should not be too far off
+            # new_ratio = max(0.01, min(100.0, new_ratio))
+
+            await redis_client.set(self.dynamic_estimate_key, new_ratio)
+
+            self.logger.info(
+                f"[Token Ratio] {self.token_key} | Observed: {observed_ratio:.5f} | "
+                f"Global Ratio: {current_ratio:.5f} -> {new_ratio:.5f}"
+            )
+
+    async def _post_function(self, result: tuple[QueryResult, float]) -> None:
+        """Adjust token estimate based on actual usage"""
+
+        metadata = result[0].metadata
+
+        countable_input_tokens = metadata.total_input_tokens - (
+            metadata.cache_read_tokens or 0
+        )
+        countable_output_tokens = metadata.total_output_tokens
+        actual_tokens = countable_input_tokens + countable_output_tokens
+
+        difference = self.actual_estimate_total_tokens - actual_tokens
+        self.logger.info(
+            f"Adjusting {self.token_key} by {difference}. Estimated {self.actual_estimate_total_tokens}, actual {actual_tokens}"
+        )
+
+        await self._adjust_dynamic_estimate_ratio(actual_tokens)
+
+        # NOTE: this can generate negative values, which represent `debt`
+        async with redis_client.lock(self._token_key_lock, timeout=LOCK_TIMEOUT):
+            await redis_client.incrby(self.token_key, difference)
+
+        result[0].metadata.extra["token_metadata"] = {
+            "estimated": self.estimate_total_tokens,
+            "estimated_with_dynamic_ratio": self.actual_estimate_total_tokens,
+            "actual": actual_tokens,
+            "difference": difference,
+            "ratio": actual_tokens / self.estimate_total_tokens,
+            "dynamic_ratio_used": self.actual_estimate_total_tokens
+            / self.estimate_total_tokens,
+        }
+
+    async def validate(self) -> None:
+        try:
+            assert redis_client
+        except Exception as e:
+            raise Exception(
+                f"redis client not set, run `TokenRetrier.set_redis_client`. Exception: {e}"
+            )
+        if not await redis_client.exists(self.token_key):
+            raise Exception(
+                "remaining_tokens not intialized, run `model.init_token_retry`"
+            )

model_library/retriers/utils.py

@@ -0,0 +1,11 @@
+import random
+
+
+def jitter(wait: float) -> float:
+    """
+    Increase or decrease the wait time by up to 20%.
+    """
+    jitter_fraction = 0.2
+    min_wait = wait * (1 - jitter_fraction)
+    max_wait = wait * (1 + jitter_fraction)
+    return random.uniform(min_wait, max_wait)

model_library/settings.py

@@ -22,7 +22,7 @@ class ModelLibrarySettings:
         except AttributeError:
             return default
 
-    def __getattr__(self, name: str) -> str | Any:
+    def __getattr__(self, name: str) -> str:
         # load key from override
         if name in self._key_overrides:
             return self._key_overrides[name]

model_library/utils.py

@@ -2,6 +2,7 @@ import logging
 from collections.abc import Mapping, Sequence
 
 import httpx
+from anthropic import AsyncAnthropic
 from openai import AsyncOpenAI
 from pydantic.main import BaseModel
 
@@ -62,6 +63,18 @@ def create_openai_client_with_defaults(
     )
 
 
+def create_anthropic_client_with_defaults(
+    api_key: str, base_url: str | None = None, default_headers: dict[str, str] = {}
+) -> AsyncAnthropic:
+    return AsyncAnthropic(
+        base_url=base_url,
+        api_key=api_key,
+        default_headers=default_headers,
+        http_client=default_httpx_client(),
+        max_retries=3,
+    )
+
+
 def get_context_window_for_model(model_name: str, default: int = 128_000) -> int:
     """
     Get the context window for a model by looking up its configuration from the registry.

{model_library-0.1.7.dist-info → model_library-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-library
-Version: 0.1.7
+Version: 0.1.8
 Summary: Model Library for vals.ai 
 Author-email: "Vals AI, Inc." <contact@vals.ai>
 License: MIT
@@ -23,6 +23,7 @@ Requires-Dist: ai21<5.0,>=4.3.0
 Requires-Dist: boto3<2.0,>=1.38.27
 Requires-Dist: google-genai[aiohttp]>=1.51.0
 Requires-Dist: google-cloud-storage>=1.26.0
+Requires-Dist: pytest-xdist>=3.8.0
 Dynamic: license-file
 
 # Model Library

model_library-0.1.8.dist-info/RECORD

@@ -0,0 +1,70 @@
+model_library/__init__.py,sha256=AKc_15aklOf-LbcS9z1Xer_moRWNpG6Dh3kqvSQ0nOI,714
+model_library/exceptions.py,sha256=8d1BKI9wdzmF8hKH3lncwjvoQW7cT5b-rZ4GwqPndOY,6899
+model_library/file_utils.py,sha256=FAZRRtDT8c4Rjfoj64Te3knEHggXAAfRRuS8WLCsSe8,3682
+model_library/logging.py,sha256=rZrrVQlEmyZzvKx6nIOR8bKHl49wQIIW5c36Zqcigm4,888
+model_library/model_utils.py,sha256=l8oCltGeimMGtnne_3Q1EguVtzCj61UMsLsma-1czwg,753
+model_library/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+model_library/register_models.py,sha256=-CtFggD296wqO2nd6yC5GIWBoi0YD0kDyG8bwxBa1ec,13696
+model_library/registry_utils.py,sha256=Qcu5du88RlcHo_mpZqOumLDie019sKQ_qX55XcjYWNc,9530
+model_library/settings.py,sha256=6xD9RADiiLWDk3xafYeCV9_4ZwxA2vYzpul-VP3qQlQ,867
+model_library/utils.py,sha256=uBLM9vfh2YG0pYsNSYCgmOc1GbE7zW9ykhBSlYJ3q0c,3302
+model_library/base/__init__.py,sha256=TtxCXGUtkEqWZNMMofLPuC4orN7Ja2hemtbtHitt_UA,266
+model_library/base/base.py,sha256=mB1oanWnXNk_C5M70LcwXQ1EvPdjFpcENq_Me2VvQJk,20588
+model_library/base/batch.py,sha256=-jd6L0ECc5pkj73zoX2ZYcv_9iQdqxEi1kEilwaXWSA,2895
+model_library/base/delegate_only.py,sha256=LYmci02i3ShQuF_3N0gJsUySVvFB__PEAgTQQryp0nA,4764
+model_library/base/input.py,sha256=JrnvBZ_xLcEmaMjnOfUS6GFV0QWtCGpJq0RQQL2YBG8,1934
+model_library/base/output.py,sha256=z8x3-0a3seRBuNwRDWgzdXjKS5bSASuR01qoRTmDoWI,8796
+model_library/base/utils.py,sha256=AjVeC41vg8vbGGL0fQmSGtnnTuZ589Xl7ljv0N1Jzd0,3330
+model_library/config/README.md,sha256=i8_wHnlI6uHIqWN9fYBkDCglZM2p5ZMVD3SLlxiwUVk,4274
+model_library/config/ai21labs_models.yaml,sha256=ZWHhk1cep2GQIYHqkTS_0152mF3oZg2tSzMPmvfMRSI,2478
+model_library/config/alibaba_models.yaml,sha256=KTNt9YJrAmgVKiQp3yeloiqaHg7PyobSK_97_p5kjbE,1826
+model_library/config/all_models.json,sha256=5L_V2DQsJTESTfluxfqUo6FJOr55EaF8z5dSSCaevWU,537531
+model_library/config/amazon_models.yaml,sha256=HgLmhpfedHCQtkPEviEJCBbAb-dNQPOnVtf4UnwrDds,7654
+model_library/config/anthropic_models.yaml,sha256=bTc_3Oqn4wCdq-dcWcEfmXrPVZjcR8-V6pTao7sGa_E,10475
+model_library/config/cohere_models.yaml,sha256=ZfWrS1K45Hxd5nT_gpP5YGAovJcBIlLNIdaRyE3V-7o,5022
+model_library/config/deepseek_models.yaml,sha256=4CCrf-4UPBgFCrS6CQa3vzNiaYlD4B6dFJFK_kIYBWY,1156
+model_library/config/dummy_model.yaml,sha256=lImYJBtBVJk_jgnLbkuSyOshQphVlYCMkw-UiJIBYhY,877
+model_library/config/fireworks_models.yaml,sha256=bAlXvjkdt-CnRp66WbfDv2qTrF5UHceRd2pvrsBERMk,6324
+model_library/config/google_models.yaml,sha256=Rg127nsBbHpk62X7WBq2ckdHo0bwYM0NVjF7T2h_1c0,16494
+model_library/config/inception_models.yaml,sha256=YCqfQlkH_pTdHIKee5dP_aRFXw_fTIEQCpUvX2bwO0M,560
+model_library/config/kimi_models.yaml,sha256=336jcbMhcKDHFNxzRIYxFTV7v2W_93y2sY-IkiYtkuo,1340
+model_library/config/minimax_models.yaml,sha256=gWTuTcl1-zyCF6KRuU6DSre2Cw5gXC-TeKV2Qp4StnQ,1263
+model_library/config/mistral_models.yaml,sha256=mYKYSzJl24lUiA_erSkom7nCBxAoeJ57Mi3090q1ArM,5162
+model_library/config/openai_models.yaml,sha256=pKsYFF4TnuWnAJVby6Bw6JFJhr6rbkt75N4VIg40iO4,25061
+model_library/config/perplexity_models.yaml,sha256=WUDqhLvnB0kQhCCwPv19FYLHozet3m33Spdo6bGff3Q,2336
+model_library/config/together_models.yaml,sha256=BeqRJonYzPvWwoLfkyH0RMRKBYUrCSEQhg_25Nvx97M,23867
+model_library/config/xai_models.yaml,sha256=2KRNNQy3kV-4xxSfhj7Uhp9TZF-S5qPlM8Ef-04zv8Y,7985
+model_library/config/zai_models.yaml,sha256=-96aPrxpwWcEQD7vNZjDhTMi8lWYWl56AHYt-mwEkgM,2418
+model_library/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+model_library/providers/ai21labs.py,sha256=xXqgk-bAC6WTZ7rvN9eHoE_IUukaU_qF3eLw-TX8gTY,6356
+model_library/providers/alibaba.py,sha256=0oMgs09BmRknuY5E66OL987xjtIrLHMh2jzSce8UiCY,3226
+model_library/providers/amazon.py,sha256=VvC0-DoZWXx-obMMkw9YLQOwwcMNYnCSIGrMGkun7tI,15589
+model_library/providers/anthropic.py,sha256=SQuGxg_XH4g1nPDkrejYdW5pDRArm__IBUixYKlfWI8,25022
+model_library/providers/azure.py,sha256=mEwoGz8ajwI6MW464spPoa36uFsPWaG_4WtwQZWkxuE,1784
+model_library/providers/cohere.py,sha256=9ZGNekBlvubVw8o-emxdIhre_00iq5saENCVaD74Jqc,944
+model_library/providers/deepseek.py,sha256=S7Ud80vKVJMCkovaLEtZEPr1jI_yfOq-R0Ln-jWwqdo,1040
+model_library/providers/fireworks.py,sha256=y5Si_nRrvDKJnQtsoIFPFUO6s6Y6PBij8NVz6in5H9I,2146
+model_library/providers/inception.py,sha256=_UHWd8b3_YbR5tHXOGwPkz5YHEBXVaYM8bP0i-yfZJE,985
+model_library/providers/kimi.py,sha256=r1K0mbaNY_OUTERLttoItcjWMb9wTu7ghEIP0kXblG0,1362
+model_library/providers/minimax.py,sha256=VTLzELrya4q_q5pdkmOA61kALbMu6ZkNxMdkuIZSDY8,1361
+model_library/providers/mistral.py,sha256=SkIHBkeDZuLfNYkvcm7holk63zNIIGJ8KmoXjQi399o,10299
+model_library/providers/openai.py,sha256=tDWozNzs8jcbtjQWEoMzYQq0qZObqOb_iK5AD-MVT3k,37618
+model_library/providers/openrouter.py,sha256=FRKyeUyCSSQFCvoKvVbKzYJ_SL60jEU-Y6wWDyvevYc,962
+model_library/providers/perplexity.py,sha256=GT7nfu42ATbG7Eu_J8nrIwJMr_BpFpLOaQVOQG4gtRk,961
+model_library/providers/together.py,sha256=M1xAsbBd-41a3yHj2MDrysrIav9pp7eqGYUo16a4L8s,1911
+model_library/providers/vals.py,sha256=lQXaQ6494r0Ujv2B9epLfVNdWk1nkMOZt1LKgAYsXhc,10084
+model_library/providers/xai.py,sha256=WzAV1WnUrx9UenLGkP77JslKDFVz1T0g25PfCYzMOlw,10687
+model_library/providers/zai.py,sha256=C-0Q41vEhsb6PIbFIW4kXGSx1-mTuB-czB7Vq1_KBqk,1924
+model_library/providers/google/__init__.py,sha256=ypuLVL_QJEQ7C3S47FhC9y4wyawYOdGikAViJmACI0U,115
+model_library/providers/google/batch.py,sha256=kqe9ponDe9Tkrh_-4kWd5-47wYf4V_XSKXZnrFOzAHc,10187
+model_library/providers/google/google.py,sha256=9sEBUmLqKy1M62kwc_1ViaTDoW6j5rGA3z9kgCn9ATY,18418
+model_library/retriers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+model_library/retriers/backoff.py,sha256=vmpzLje51yfvSgAEST_yNrL87_J_0pmI-jwnRek5Ie0,2296
+model_library/retriers/base.py,sha256=zmiGZq4yvJx7aE0FD8rqZuJxZavhKTXLjt58z5TKJNw,6832
+model_library/retriers/token.py,sha256=ypHzuJjEORsv931sjEI1lejRO8Ju_ljSrCGV4pgaa34,16794
+model_library/retriers/utils.py,sha256=fhtQ64aT8mZcwZ8aTXnLRU4HVIf8JQ3CfmArvxZPWvQ,279
+model_library-0.1.8.dist-info/licenses/LICENSE,sha256=x6mf4o7U_wHaaqcfxoU-0R6uYJLbqL_TNuoULP3asaA,1070
+model_library-0.1.8.dist-info/METADATA,sha256=PlDQKGnuuNlRnlD5MiEUmc5egBmkFSjAGpJbup6sSAs,7024
+model_library-0.1.8.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+model_library-0.1.8.dist-info/top_level.txt,sha256=HtQYxA_7RP8UT35I6VcUw20L6edI0Zf2t5Ys1uDGVjs,14
+model_library-0.1.8.dist-info/RECORD,,

{model_library-0.1.7.dist-info → model_library-0.1.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

model_library-0.1.7.dist-info/RECORD

@@ -1,64 +0,0 @@
-model_library/__init__.py,sha256=AKc_15aklOf-LbcS9z1Xer_moRWNpG6Dh3kqvSQ0nOI,714
-model_library/exceptions.py,sha256=4TJ1aDkpPV-gv3gLIO7pi5ORRBG2hPXSBAvOXS6I_Wg,9027
-model_library/file_utils.py,sha256=FAZRRtDT8c4Rjfoj64Te3knEHggXAAfRRuS8WLCsSe8,3682
-model_library/logging.py,sha256=rZrrVQlEmyZzvKx6nIOR8bKHl49wQIIW5c36Zqcigm4,888
-model_library/model_utils.py,sha256=l8oCltGeimMGtnne_3Q1EguVtzCj61UMsLsma-1czwg,753
-model_library/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-model_library/register_models.py,sha256=-CtFggD296wqO2nd6yC5GIWBoi0YD0kDyG8bwxBa1ec,13696
-model_library/registry_utils.py,sha256=BVauHcP02Et2maLxowNBbdpGd32cnLz1_zSjDLVJjp0,8843
-model_library/settings.py,sha256=QyeUqzWBpexFi014L_mZkoXP49no3SAQNJRObATXrL8,873
-model_library/utils.py,sha256=dcww26Ph0PSihEzSN4gZ48XXxN3Bt5oWveVYX6UACyI,2922
-model_library/base/__init__.py,sha256=TtxCXGUtkEqWZNMMofLPuC4orN7Ja2hemtbtHitt_UA,266
-model_library/base/base.py,sha256=nrdPS92-vFkDVJJvNVOQ8e6U1zCyZxOtFg18ZgM4o0s,17467
-model_library/base/batch.py,sha256=-jd6L0ECc5pkj73zoX2ZYcv_9iQdqxEi1kEilwaXWSA,2895
-model_library/base/delegate_only.py,sha256=5v2twEuQl1jF34M8iFcaZQlk0_uBLew4B46TkHUEssw,2441
-model_library/base/input.py,sha256=JrnvBZ_xLcEmaMjnOfUS6GFV0QWtCGpJq0RQQL2YBG8,1934
-model_library/base/output.py,sha256=jwd3rfRFUcqm8q-O5H684ToNZPvcD_obtf6ugmhzUus,7613
-model_library/base/utils.py,sha256=eiMTiFFXHTb44Nnz3fjxf9YQzJpdfNI7tprSi9COPu0,2268
-model_library/config/README.md,sha256=i8_wHnlI6uHIqWN9fYBkDCglZM2p5ZMVD3SLlxiwUVk,4274
-model_library/config/ai21labs_models.yaml,sha256=ZWHhk1cep2GQIYHqkTS_0152mF3oZg2tSzMPmvfMRSI,2478
-model_library/config/alibaba_models.yaml,sha256=-RLWOwh3ZaCQqjaZ-4Zw0BJNVE6JVHJ8Ggm9gQJZ6QI,2082
-model_library/config/all_models.json,sha256=U-XQrbaWWhjmkawg0Bd9NTxoDN-DT0WPhmDLF6OALR4,533621
-model_library/config/amazon_models.yaml,sha256=HgLmhpfedHCQtkPEviEJCBbAb-dNQPOnVtf4UnwrDds,7654
-model_library/config/anthropic_models.yaml,sha256=bTc_3Oqn4wCdq-dcWcEfmXrPVZjcR8-V6pTao7sGa_E,10475
-model_library/config/cohere_models.yaml,sha256=ZfWrS1K45Hxd5nT_gpP5YGAovJcBIlLNIdaRyE3V-7o,5022
-model_library/config/deepseek_models.yaml,sha256=4CCrf-4UPBgFCrS6CQa3vzNiaYlD4B6dFJFK_kIYBWY,1156
-model_library/config/dummy_model.yaml,sha256=lImYJBtBVJk_jgnLbkuSyOshQphVlYCMkw-UiJIBYhY,877
-model_library/config/fireworks_models.yaml,sha256=bAlXvjkdt-CnRp66WbfDv2qTrF5UHceRd2pvrsBERMk,6324
-model_library/config/google_models.yaml,sha256=Rg127nsBbHpk62X7WBq2ckdHo0bwYM0NVjF7T2h_1c0,16494
-model_library/config/inception_models.yaml,sha256=YCqfQlkH_pTdHIKee5dP_aRFXw_fTIEQCpUvX2bwO0M,560
-model_library/config/kimi_models.yaml,sha256=AAqse_BCE-lrHkJHIWJVqMtttnZQCa-5Qy5qiLUJjYs,755
-model_library/config/minimax_models.yaml,sha256=gWTuTcl1-zyCF6KRuU6DSre2Cw5gXC-TeKV2Qp4StnQ,1263
-model_library/config/mistral_models.yaml,sha256=mYKYSzJl24lUiA_erSkom7nCBxAoeJ57Mi3090q1ArM,5162
-model_library/config/openai_models.yaml,sha256=1lKsTQwsxMMJqXtEoYs3liy6NcaK4p8NN7b-GSFnl8k,25261
-model_library/config/perplexity_models.yaml,sha256=WUDqhLvnB0kQhCCwPv19FYLHozet3m33Spdo6bGff3Q,2336
-model_library/config/together_models.yaml,sha256=BeqRJonYzPvWwoLfkyH0RMRKBYUrCSEQhg_25Nvx97M,23867
-model_library/config/xai_models.yaml,sha256=2KRNNQy3kV-4xxSfhj7Uhp9TZF-S5qPlM8Ef-04zv8Y,7985
-model_library/config/zai_models.yaml,sha256=lcYMh2FCrLWkKqdCnarRlwDoL3SbutRBNAiMPBUYQiw,1894
-model_library/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-model_library/providers/ai21labs.py,sha256=NXoEu0NFwxLVJIN751tEuKLFYk4ECSDnWMik35pL5Y4,6277
-model_library/providers/alibaba.py,sha256=k6LZErV_l9oTFTdKTwyw1SXD509Rl3AqFbN8umCryEE,2941
-model_library/providers/amazon.py,sha256=F8anL4pmeadA0P9luUZSSnEcke90WH7mCa3afJ2akgM,14156
-model_library/providers/anthropic.py,sha256=xbSZx6R54UhNQij-vwFKPCIQJoTzxLblJMIxdqGcsqs,23094
-model_library/providers/azure.py,sha256=brQNCED-zHvYjL5K5hdjFBNso6hJZg0HTHNnAgJPPG0,1408
-model_library/providers/cohere.py,sha256=lCBm1PP1l_UOa1pKFMIZM3C0wCv3QWB6UP0-jvjkFa4,1066
-model_library/providers/deepseek.py,sha256=7T4lxDiV5wmWUK7TAKwr332_T6uyXNCOiirZOCCETL0,1159
-model_library/providers/fireworks.py,sha256=w-5mOF5oNzqx_0ijCoTm1lSn2ZHwhp6fURKhV3LEqIc,2309
-model_library/providers/inception.py,sha256=Nrky53iujIM9spAWoNRtoJg2inFiL0li6E75vT3b6V8,1107
-model_library/providers/kimi.py,sha256=zzvcKpZLsM1xPebpLeMxNKTt_FRiLN1rFWrIly7wfXA,1092
-model_library/providers/minimax.py,sha256=ckVyoXdtVxGT3aU-AknBQCa7_mOckNMfOXSgwbrJNIY,1610
-model_library/providers/mistral.py,sha256=kmp74jEETMnB8fQ5VNfNVkksIrPMGJwJeXJDnTVwKa8,10117
-model_library/providers/openai.py,sha256=gMykcN5eHFHqCrK9y5twc18h7XSMI68mB9YGYnpt93A,34522
-model_library/providers/perplexity.py,sha256=eIzzkaZ4ZMlRKFVI9bnwyo91iJkh7aEmJ-0_4OKeAWc,1083
-model_library/providers/together.py,sha256=7Y4QLnX8c_fyXUud-W_C1gidmROQainTgODBwbvFyXQ,2033
-model_library/providers/vals.py,sha256=dbaL8toYTssm8qVlrgqzqwCeeTV9h-xfA37uBuoWtfg,9894
-model_library/providers/xai.py,sha256=eA3CsiOWIF_vKxNZC95INUKOazz54R6vpVrGM8VR1tY,10719
-model_library/providers/zai.py,sha256=O_GM6KlJ0fM2wYoxO9xrCWfnpYH7IpoKEzjiD4jB8Kc,1050
-model_library/providers/google/__init__.py,sha256=ypuLVL_QJEQ7C3S47FhC9y4wyawYOdGikAViJmACI0U,115
-model_library/providers/google/batch.py,sha256=ycK2arf00lhZQNgyM5Yd01LAScul6rvVv--dUcRWWSA,9977
-model_library/providers/google/google.py,sha256=txQaet1HobyjYd3dp9Mgonx3x5ln3LMuW10Qsyum3B4,17809
-model_library-0.1.7.dist-info/licenses/LICENSE,sha256=x6mf4o7U_wHaaqcfxoU-0R6uYJLbqL_TNuoULP3asaA,1070
-model_library-0.1.7.dist-info/METADATA,sha256=436seE0dN2884VkHzGHyp36aARqBxqKMKRccmKYG3_E,6989
-model_library-0.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-model_library-0.1.7.dist-info/top_level.txt,sha256=HtQYxA_7RP8UT35I6VcUw20L6edI0Zf2t5Ys1uDGVjs,14
-model_library-0.1.7.dist-info/RECORD,,