File size: 5,801 Bytes
7018a90 | 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 | """Danbooru API 的共享客户端:限速、退避、以及「抓不到就报错」。
两个同步脚本原本各写了一套重试,各自带着不同的 bug:update_wiki 把 429 当成普通
错误按 2**attempt 干等,update_danbooru 重试三次之后直接 break —— 那一页 200 条
投稿就永远不在存档里了,而且不打印任何东西。存档缺一页在成品里看不出来,只能靠
下次全量刷新撞上。合并到这里,顺便让缺页变成硬错误。
"""
import random
import threading
import time
from typing import Any
import requests
# Danbooru 拒绝默认的 python-requests User-Agent(返回 403),必须带描述性 UA
HEADERS = {
"User-Agent": "danbooru-metadata/1.0 (https://github.com/Jannchie/danbooru_metadata)",
}
# Danbooru 文档写的上限是 10 req/s。贴着上限跑意味着任何抖动都会撞 429,所以起步
# 定在 5 —— 慢一倍,但不会陷入「429 -> 退避 -> 再撞」的循环,实测反而更快。
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:
# Retry-After 也允许是 HTTP 日期。解析它不值得,退避猜一个就够了。
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
# Danbooru 用 200 + {"success": false} 回报某些错误,不能当成数据。
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:
# 认证/参数错误重试无意义,而且会把 429 之外的问题拖成几分钟的假死。
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}")
|