Frontier-CS / research /scripts /gen_api_keys.py
andylizf's picture
Upload folder using huggingface_hub
5fed0fc verified
Raw
History Blame Contribute Delete
6.18 kB
"""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)