| """Danbooru API 的共享客户端:限速、退避、以及「抓不到就报错」。 |
| |
| 两个同步脚本原本各写了一套重试,各自带着不同的 bug:update_wiki 把 429 当成普通 |
| 错误按 2**attempt 干等,update_danbooru 重试三次之后直接 break —— 那一页 200 条 |
| 投稿就永远不在存档里了,而且不打印任何东西。存档缺一页在成品里看不出来,只能靠 |
| 下次全量刷新撞上。合并到这里,顺便让缺页变成硬错误。 |
| """ |
|
|
| import random |
| import threading |
| import time |
| from typing import Any |
|
|
| import requests |
|
|
| |
| HEADERS = { |
| "User-Agent": "danbooru-metadata/1.0 (https://github.com/Jannchie/danbooru_metadata)", |
| } |
|
|
| |
| |
| DEFAULT_RATE = 5.0 |
| MIN_RATE = 0.5 |
| MAX_RETRIES = 6 |
|
|
|
|
| class RateLimiter: |
| """跨线程共享的发牌器,撞到 429 会自动降速。 |
| |
| 限速是按账号算的,不是按连接:16 个 worker 各自限速等于超发 16 倍。所以间隔必须 |
| 在一个共享的锁里推进,而不是每个线程各睡各的。 |
| |
| 降速用 AIMD(撞墙就减半,顺利就慢慢加回来),因为 Danbooru 的实际配额随时段和 |
| 认证状态变化,写死一个数字迟早会错。让它自己收敛到当下能跑的速度。 |
| """ |
|
|
| def __init__(self, rate: float = DEFAULT_RATE) -> None: |
| self._ceiling = 1.0 / rate |
| self._interval = 1.0 / rate |
| self._lock = threading.Lock() |
| self._next = 0.0 |
|
|
| def acquire(self) -> None: |
| with self._lock: |
| now = time.monotonic() |
| wait = self._next - now |
| self._next = max(now, self._next) + self._interval |
| if wait > 0: |
| time.sleep(wait) |
|
|
| def penalise(self, pause: float) -> None: |
| """撞到 429:所有 worker 一起停 pause 秒,并把稳态速率减半。 |
| |
| 惩罚必须是全局的。只让倒霉的那个线程睡觉,其余 15 个会立刻把配额再耗光, |
| 于是每个线程轮流挨罚,总速率一点没降。 |
| """ |
| with self._lock: |
| self._interval = min(self._interval * 2, 1.0 / MIN_RATE) |
| self._next = max(self._next, time.monotonic() + pause) |
|
|
| def reward(self) -> None: |
| """连续成功时把间隔慢慢收回上限,免得一次偶发 429 让后面几小时都慢一半。""" |
| with self._lock: |
| if self._interval > self._ceiling: |
| self._interval = max(self._ceiling, self._interval * 0.99) |
|
|
| @property |
| def rate(self) -> float: |
| return 1.0 / self._interval |
|
|
|
|
| MAX_BACKOFF = 60.0 |
|
|
|
|
| def backoff(attempt: int) -> float: |
| """指数退避 + 抖动,封顶 MAX_BACKOFF。 |
| |
| 抖动是必须的:多个 worker 同时挨 429 会算出同一个延迟,不打散就会在同一毫秒 |
| 一起重试,复现刚才那次超发。 |
| |
| 先抖动再封顶。反过来写(先 min 再乘抖动)会让上限变成 1.5 倍 —— 封顶 60 秒的 |
| 退避实际能睡 90 秒。 |
| """ |
| return min(2**attempt * (0.5 + random.random()), MAX_BACKOFF) |
|
|
|
|
| def retry_after(response: requests.Response, attempt: int) -> float: |
| """服务端说等多久就等多久,没说才自己猜。""" |
| header = response.headers.get("Retry-After") |
| if header: |
| try: |
| return float(header) |
| except ValueError: |
| |
| pass |
| return backoff(attempt) |
|
|
|
|
| def get_json( |
| session: requests.Session, |
| url: str, |
| params: dict[str, Any] | None = None, |
| limiter: RateLimiter | None = None, |
| timeout: int = 60, |
| ) -> list[dict[str, Any]]: |
| """取回一页 JSON 列表,失败到底就抛异常 —— 绝不返回空列表冒充「这页没有数据」。 |
| |
| 空列表是同步循环的终止信号。一次失败的请求返回 [] 会让调用方以为抓完了,于是 |
| 静默地少存几百万条。 |
| """ |
| last_error = "" |
| for attempt in range(MAX_RETRIES): |
| if limiter: |
| limiter.acquire() |
| try: |
| response = session.get(url, params=params, headers=HEADERS, timeout=timeout) |
| if response.status_code == 200: |
| payload = response.json() |
| if isinstance(payload, list): |
| if limiter: |
| limiter.reward() |
| return payload |
| |
| last_error = f"unexpected payload: {str(payload)[:200]}" |
| elif response.status_code == 429: |
| pause = retry_after(response, attempt) |
| if limiter: |
| limiter.penalise(pause) |
| last_error = f"429, backing off {pause:.1f}s (now {limiter.rate:.1f} req/s)" |
| else: |
| time.sleep(pause) |
| last_error = f"429, waited {pause:.1f}s" |
| continue |
| elif 400 <= response.status_code < 500: |
| |
| raise RuntimeError(f"{url} returned {response.status_code}: {response.text[:200]}") |
| else: |
| last_error = f"status {response.status_code}" |
| except requests.RequestException as exc: |
| last_error = str(exc) |
| if attempt < MAX_RETRIES - 1: |
| time.sleep(backoff(attempt)) |
| raise RuntimeError(f"{url} failed after {MAX_RETRIES} attempts: {last_error}") |
|
|
