285 lines
10 KiB
Python
285 lines
10 KiB
Python
#!/usr/bin/env python3
|
||
"""独立模型连通性检测脚本（中文日志输出）。"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import json
|
||
import os
|
||
import ssl
|
||
import sys
|
||
import time
|
||
import urllib.error
|
||
import urllib.request
|
||
from datetime import datetime
|
||
from pathlib import Path
|
||
|
||
REPO_ROOT = Path(__file__).resolve().parents[1]
|
||
BACKEND_DIR = REPO_ROOT / "backend"
|
||
if str(BACKEND_DIR) not in sys.path:
|
||
sys.path.insert(0, str(BACKEND_DIR))
|
||
|
||
from app.services.model.model_config import get_provider_defaults, get_tier_defaults
|
||
|
||
|
||
def load_env_file(env_path: Path) -> None:
|
||
if not env_path.exists():
|
||
return
|
||
for raw_line in env_path.read_text(encoding="utf-8").splitlines():
|
||
line = raw_line.strip()
|
||
if not line or line.startswith("#") or "=" not in line:
|
||
continue
|
||
key, value = line.split("=", 1)
|
||
key = key.strip()
|
||
value = value.strip()
|
||
if len(value) >= 2 and ((value[0] == value[-1] == '"') or (value[0] == value[-1] == "'")):
|
||
value = value[1:-1]
|
||
os.environ.setdefault(key, value)
|
||
|
||
|
||
def provider_runtime(provider: str, provider_defaults: dict[str, dict[str, str]]) -> dict[str, str]:
|
||
aliases = {"zhipu": "glm", "chatglm": "glm", "deep-seek": "deepseek", "local": "ollama"}
|
||
p = aliases.get(provider.strip().lower(), provider.strip().lower())
|
||
defaults = dict(provider_defaults.get(p) or {})
|
||
api_env = str(defaults.get("api_env") or "").strip()
|
||
api_key = str(os.getenv(api_env, "")).strip() if api_env else ""
|
||
if p == "glm":
|
||
api_key = str(os.getenv("DASHSCOPE_API_KEY", api_key)).strip()
|
||
base_url = str(defaults.get("base_url") or "").strip()
|
||
if p == "ollama" and not base_url:
|
||
base_url = str(os.getenv("OLLAMA_BASE_URL", os.getenv("OLLAMA_HOST", "http://127.0.0.1:11434"))).strip()
|
||
return {"provider": p, "provider_name": str(defaults.get("name") or p).strip(), "base_url": base_url, "api_key": api_key}
|
||
|
||
|
||
def extract_json_detail(text: str) -> dict[str, str]:
|
||
detail = {
|
||
"content": "",
|
||
"reasoning_content": "",
|
||
"error_message": "",
|
||
"body_preview": text[:180].replace("\n", " "),
|
||
}
|
||
try:
|
||
data = json.loads(text)
|
||
except Exception:
|
||
return detail
|
||
|
||
if isinstance(data, dict):
|
||
choices = data.get("choices") or []
|
||
if isinstance(choices, list) and choices:
|
||
first = choices[0] if isinstance(choices[0], dict) else {}
|
||
msg = first.get("message") if isinstance(first, dict) else {}
|
||
if isinstance(msg, dict):
|
||
detail["content"] = str(msg.get("content") or "").strip()
|
||
detail["reasoning_content"] = str(msg.get("reasoning_content") or "").strip()
|
||
|
||
if not detail["error_message"]:
|
||
err = data.get("error")
|
||
if isinstance(err, dict):
|
||
detail["error_message"] = str(err.get("message") or "").strip()
|
||
elif err:
|
||
detail["error_message"] = str(err).strip()
|
||
|
||
if not detail["error_message"]:
|
||
if data.get("message"):
|
||
detail["error_message"] = str(data.get("message")).strip()
|
||
elif data.get("reason"):
|
||
detail["error_message"] = str(data.get("reason")).strip()
|
||
return detail
|
||
|
||
|
||
def probe_model(
|
||
level: str,
|
||
provider: str,
|
||
model: str,
|
||
timeout: float,
|
||
insecure: bool,
|
||
provider_defaults: dict[str, dict[str, str]],
|
||
) -> dict[str, object]:
|
||
runtime = provider_runtime(provider, provider_defaults)
|
||
base_url = runtime["base_url"].rstrip("/")
|
||
api_key = runtime["api_key"]
|
||
started = time.perf_counter()
|
||
|
||
if not base_url:
|
||
elapsed = time.perf_counter() - started
|
||
return {
|
||
"level": level,
|
||
"provider": provider,
|
||
"model": model,
|
||
"ok": False,
|
||
"elapsed": elapsed,
|
||
"reason": f"provider={provider} 缺少 base_url 配置",
|
||
"http_status": 0,
|
||
}
|
||
|
||
url = f"{base_url}/chat/completions"
|
||
payload = {
|
||
"model": model,
|
||
"messages": [
|
||
{"role": "system", "content": "你是连通性检测助手，只回复OK。"},
|
||
{"role": "user", "content": "ping"},
|
||
],
|
||
"temperature": 0,
|
||
"max_tokens": 16,
|
||
}
|
||
req = urllib.request.Request(
|
||
url=url,
|
||
data=json.dumps(payload).encode("utf-8"),
|
||
headers={"Content-Type": "application/json"},
|
||
method="POST",
|
||
)
|
||
if api_key:
|
||
req.add_header("Authorization", f"Bearer {api_key}")
|
||
|
||
status_code = 0
|
||
body = ""
|
||
error_text = ""
|
||
ssl_context = ssl._create_unverified_context() if insecure else None
|
||
try:
|
||
with urllib.request.urlopen(req, timeout=timeout, context=ssl_context) as resp:
|
||
status_code = int(resp.getcode() or 0)
|
||
body = resp.read().decode("utf-8", errors="replace")
|
||
except urllib.error.HTTPError as exc:
|
||
status_code = int(exc.code or 0)
|
||
body = exc.read().decode("utf-8", errors="replace")
|
||
error_text = str(exc)
|
||
except Exception as exc: # pragma: no cover
|
||
error_text = str(exc)
|
||
|
||
elapsed = time.perf_counter() - started
|
||
detail = extract_json_detail(body)
|
||
content = detail["content"]
|
||
reasoning = detail["reasoning_content"]
|
||
has_text = bool(content)
|
||
has_reasoning = bool(reasoning)
|
||
http_ok = 200 <= status_code < 300
|
||
|
||
if http_ok and (has_text or has_reasoning):
|
||
note = "文本返回" if has_text else "仅推理内容"
|
||
return {
|
||
"level": level,
|
||
"provider": provider,
|
||
"model": model,
|
||
"ok": True,
|
||
"elapsed": elapsed,
|
||
"reason": note,
|
||
"http_status": status_code,
|
||
}
|
||
|
||
reason_parts: list[str] = []
|
||
if status_code:
|
||
reason_parts.append(f"HTTP {status_code}")
|
||
if detail["error_message"]:
|
||
reason_parts.append(str(detail["error_message"]))
|
||
elif error_text:
|
||
reason_parts.append(error_text)
|
||
elif http_ok:
|
||
reason_parts.append("响应为空（content/reasoning_content 均为空）")
|
||
else:
|
||
reason_parts.append(detail["body_preview"] or "请求失败")
|
||
|
||
return {
|
||
"level": level,
|
||
"provider": provider,
|
||
"model": model,
|
||
"ok": False,
|
||
"elapsed": elapsed,
|
||
"reason": " | ".join(reason_parts),
|
||
"http_status": status_code,
|
||
}
|
||
|
||
|
||
def render_result_line(item: dict[str, object]) -> str:
|
||
status_text = "✓ 正常" if bool(item["ok"]) else "✗ 失败"
|
||
elapsed_text = f"{float(item['elapsed']):.2f}s"
|
||
return (
|
||
f"[{item['level']}] {item['model']} ({item.get('provider_name') or item['provider']}) "
|
||
f"{status_text} ({elapsed_text})"
|
||
)
|
||
|
||
|
||
def main() -> int:
|
||
parser = argparse.ArgumentParser(description="PMFlow 模型连通性独立检测")
|
||
parser.add_argument(
|
||
"--env-file",
|
||
default=str(Path(__file__).resolve().parents[1] / ".env"),
|
||
help="环境变量文件路径（默认根目录 .env）",
|
||
)
|
||
parser.add_argument(
|
||
"--timeout",
|
||
type=float,
|
||
default=float(os.getenv("PMFLOW_MODEL_PROBE_TIMEOUT", "20")),
|
||
help="单次请求超时时间（秒）",
|
||
)
|
||
parser.add_argument(
|
||
"--insecure",
|
||
action="store_true",
|
||
default=str(os.getenv("PMFLOW_MODEL_PROBE_INSECURE", "1")).strip().lower() in {"1", "true", "yes"},
|
||
help="关闭 TLS 证书校验（默认开启，可用 PMFLOW_MODEL_PROBE_INSECURE=0 关闭）",
|
||
)
|
||
parser.add_argument(
|
||
"--strict-tls",
|
||
action="store_true",
|
||
default=False,
|
||
help="强制开启 TLS 证书校验（优先级高于 --insecure）",
|
||
)
|
||
args = parser.parse_args()
|
||
|
||
load_env_file(Path(args.env_file))
|
||
|
||
insecure = bool(args.insecure and not args.strict_tls)
|
||
|
||
provider_defaults = get_provider_defaults(refresh=True)
|
||
tier_defaults = get_tier_defaults(refresh=True)
|
||
low_tier = dict(tier_defaults.get("low") or {})
|
||
high_tier = dict(tier_defaults.get("high") or {})
|
||
|
||
low_provider = str(low_tier.get("provider") or "glm").strip() or "glm"
|
||
low_model = str(low_tier.get("model") or provider_defaults.get(low_provider, {}).get("model") or "qwen-plus").strip() or "qwen-plus"
|
||
high_provider = str(high_tier.get("provider") or "openai").strip() or "openai"
|
||
high_model = str(high_tier.get("model") or provider_defaults.get(high_provider, {}).get("model") or "GLM-5").strip() or "GLM-5"
|
||
|
||
targets: list[tuple[str, str, str]] = [("LOW", low_provider, low_model), ("HIGH", high_provider, high_model)]
|
||
deduped: list[tuple[str, str, str]] = []
|
||
seen: set[tuple[str, str]] = set()
|
||
for level, provider, model in targets:
|
||
key = (provider.lower(), model)
|
||
if key in seen:
|
||
continue
|
||
seen.add(key)
|
||
deduped.append((level, provider, model))
|
||
|
||
started_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||
print("┌────────────────────────────────────────┐")
|
||
print("│ PMFlow 模型连通性独立检测 │")
|
||
print(f"│ 启动时间: {started_at} │")
|
||
print(f"│ TLS校验: {'关闭' if insecure else '开启'} │")
|
||
print("├────────────────────────────────────────┤")
|
||
|
||
results: list[dict[str, object]] = []
|
||
for level, provider, model in deduped:
|
||
result = probe_model(
|
||
level=level,
|
||
provider=provider,
|
||
model=model,
|
||
timeout=args.timeout,
|
||
insecure=insecure,
|
||
provider_defaults=provider_defaults,
|
||
)
|
||
results.append(result)
|
||
print(f"│ {render_result_line(result)}")
|
||
print(f"│ 说明: {result['reason']}")
|
||
|
||
print("└────────────────────────────────────────┘")
|
||
|
||
failed = [item for item in results if not bool(item["ok"])]
|
||
if failed:
|
||
print(f"[结果] 检测完成：{len(failed)} 个模型异常。")
|
||
return 1
|
||
print("[结果] 检测完成：全部模型连通正常。")
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main())
|