Spaces:
Sleeping
Sleeping
| """Detect rate-limit / transient API errors for key rotation and backoff.""" | |
| from __future__ import annotations | |
| import random | |
| import time | |
| from typing import Callable, TypeVar | |
| T = TypeVar("T") | |
| def is_rate_limit_error(exc: BaseException) -> bool: | |
| """True for HTTP 429, OpenAI-style rate limits, and common Zep wording.""" | |
| try: | |
| code = getattr(exc, "status_code", None) | |
| if code is None and hasattr(exc, "response"): | |
| code = getattr(exc.response, "status_code", None) | |
| if code == 429: | |
| return True | |
| except Exception: | |
| pass | |
| name = type(exc).__name__.lower() | |
| if "ratelimit" in name or "rate_limit" in name: | |
| return True | |
| msg = str(exc).lower() | |
| if "429" in msg: | |
| return True | |
| if "rate limit" in msg or "too many requests" in msg: | |
| return True | |
| if "quota" in msg and ("exceed" in msg or "exceeded" in msg): | |
| return True | |
| return False | |
| def is_transient_server_error(exc: BaseException) -> bool: | |
| try: | |
| code = getattr(exc, "status_code", None) | |
| if code is None and hasattr(exc, "response"): | |
| code = getattr(exc.response, "status_code", None) | |
| if code in (500, 502, 503, 504): | |
| return True | |
| except Exception: | |
| pass | |
| return False | |
| def sleep_backoff(attempt: float, cap: float = 60.0) -> None: | |
| """Exponential backoff with jitter (seconds).""" | |
| base = min(cap, (2**min(attempt, 6)) + random.uniform(0, 1.5)) | |
| time.sleep(base) | |
| def run_with_key_rotation( | |
| keys: list[str], | |
| fn_per_key: Callable[[str], T], | |
| *, | |
| per_key_attempts: int = 3, | |
| op_name: str = "api", | |
| ) -> T: | |
| """ | |
| For each key, retry fn_per_key(key) with backoff on rate limits / 5xx. | |
| Then try the next key. Re-raises the last error if nothing succeeds. | |
| """ | |
| from ..utils.logger import get_logger | |
| log = get_logger("mirofish.api_retry") | |
| keys = [k.strip() for k in keys if k and str(k).strip()] | |
| if not keys: | |
| raise ValueError("No API keys configured") | |
| last: BaseException | None = None | |
| for ki, key in enumerate(keys): | |
| for attempt in range(per_key_attempts): | |
| try: | |
| return fn_per_key(key) | |
| except Exception as e: | |
| last = e | |
| retryable = is_rate_limit_error(e) or is_transient_server_error(e) | |
| if not retryable: | |
| raise | |
| log.warning( | |
| "%s retryable error (key %s/%s, attempt %s/%s): %s", | |
| op_name, | |
| ki + 1, | |
| len(keys), | |
| attempt + 1, | |
| per_key_attempts, | |
| e, | |
| ) | |
| if attempt < per_key_attempts - 1: | |
| sleep_backoff(float(attempt)) | |
| continue | |
| if ki < len(keys) - 1: | |
| log.warning("%s: switching to next API key after %s attempts", op_name, per_key_attempts) | |
| break | |
| raise | |
| if last: | |
| raise last | |
| raise RuntimeError(f"{op_name}: failed without exception") | |