File size: 6,175 Bytes
5fed0fc |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 |
"""API key pool management for solution generation."""
import os
import threading
import time
from typing import Dict, List, Optional, Tuple
PROVIDER_ENV_KEY_MAP: Dict[str, List[str]] = {
"openai": ["OPENAI_API_KEY"],
"google": ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
"anthropic": ["ANTHROPIC_API_KEY"],
"xai": ["XAI_API_KEY", "GROK_API_KEY"],
"deepseek": ["DEEPSEEK_API_KEY"],
"openrouter": ["OPENROUTER_API_KEY"],
}
class APIKeyPool:
"""Thread-safe pool of API keys with backoff handling."""
def __init__(self, keys: List[str], *, name: str):
self.name = name
self._states = [
{
"key": key,
"failures": 0,
"disabled": False,
"backoff_until": 0.0,
}
for key in keys
]
self._lock = threading.Lock()
self._index = 0
def acquire(self) -> Tuple[Optional[str], Optional[int]]:
"""Acquire an available API key from the pool."""
with self._lock:
if not self._states:
return None, None
now = time.time()
for _ in range(len(self._states)):
idx = self._index % len(self._states)
self._index += 1
state = self._states[idx]
if state["disabled"]:
continue
if state["backoff_until"] > now:
continue
return state["key"], idx
return None, None
def report_success(self, idx: Optional[int]) -> None:
"""Report successful API call for a key."""
if idx is None:
return
with self._lock:
if 0 <= idx < len(self._states):
state = self._states[idx]
state["failures"] = 0
state["backoff_until"] = 0.0
def report_failure(self, idx: Optional[int], error: Optional[str]) -> None:
"""Report failed API call for a key."""
if idx is None:
return
with self._lock:
if not (0 <= idx < len(self._states)):
return
state = self._states[idx]
state["failures"] += 1
reason = (error or "").lower()
fatal_markers = ("invalid", "unauthorized", "forbidden", "permission", "auth")
if any(marker in reason for marker in fatal_markers):
if not state["disabled"]:
print(f"Disabling API key for {self.name}: appears invalid/unauthorized")
state["disabled"] = True
state["backoff_until"] = float("inf")
return
delay: int = min(600, 60 * state["failures"])
state["backoff_until"] = max(state["backoff_until"], time.time() + delay)
print(
f"Backing off {delay:.0f}s for {self.name} key due to failure (count={state['failures']})."
)
def size(self) -> int:
"""Return the number of keys in the pool."""
with self._lock:
return len(self._states)
def _matches_env_base(key_name: str, base: str) -> bool:
"""Check if an environment variable name matches a base name pattern."""
if key_name == base:
return True
if key_name.startswith(base):
suffix = key_name[len(base):]
if not suffix:
return True
if suffix.isdigit():
return True
if suffix.startswith(('_', '-')):
return True
return False
def _collect_provider_keys(provider: str, base_names: List[str]) -> List[str]:
"""Collect all API keys for a provider from environment variables."""
keys: List[str] = []
seen: set[str] = set()
for env_name, value in os.environ.items():
if not value:
continue
for base in base_names:
if _matches_env_base(env_name, base):
key_value = value.strip()
if key_value and key_value not in seen:
seen.add(key_value)
keys.append(key_value)
return keys
def build_key_pools(primary_openai_key: Optional[str] = None) -> Dict[str, APIKeyPool]:
"""Build API key pools for all providers."""
pools: Dict[str, APIKeyPool] = {}
for provider, bases in PROVIDER_ENV_KEY_MAP.items():
keys = _collect_provider_keys(provider, bases)
if provider == "openai" and primary_openai_key:
key = primary_openai_key.strip()
if key and key not in keys:
keys.insert(0, key)
if keys:
pools[provider] = APIKeyPool(keys, name=provider)
return pools
def get_fallback_api_key(provider: str, default_key: Optional[str] = None) -> Optional[str]:
"""Get a fallback API key for a provider without using the pool."""
candidate_keys: List[Optional[str]] = []
if provider == "openai":
candidate_keys.extend([
default_key,
os.getenv("OPENAI_API_KEY"),
os.getenv("OPENAI_API_KEY2"),
os.getenv("OPENAI_API_KEY_2"),
])
elif provider == "openrouter":
candidate_keys.extend([
os.getenv("OPENROUTER_API_KEY"),
os.getenv("OPENROUTER_API_KEY2"),
os.getenv("OPENROUTER_KEY"),
])
elif provider == "google":
candidate_keys.extend([
os.getenv("GOOGLE_API_KEY"),
os.getenv("GOOGLE_API_KEY2"),
os.getenv("GEMINI_API_KEY"),
os.getenv("GEMINI_API_KEY2"),
])
elif provider == "anthropic":
candidate_keys.extend([
os.getenv("ANTHROPIC_API_KEY"),
os.getenv("ANTHROPIC_API_KEY2"),
])
elif provider == "xai":
candidate_keys.extend([
os.getenv("XAI_API_KEY"),
os.getenv("XAI_API_KEY2"),
os.getenv("GROK_API_KEY"),
os.getenv("GROK_API_KEY2"),
])
elif provider == "deepseek":
candidate_keys.extend([
os.getenv("DEEPSEEK_API_KEY"),
os.getenv("DEEPSEEK_API_KEY2"),
])
return next((k for k in candidate_keys if k), None)
|