File size: 3,684 Bytes
32030e4 | 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 | #!/usr/bin/env python3
"""Check an OpenAI-compatible endpoint before a run: served model names, context length, one reply.
Calling a Modal endpoint starts its GPU if it is asleep, so this costs a few minutes of GPU time.
It waits through a cold start, then prints each served model's ``id`` (pass it as ``--model``) and
``max_model_len`` (the prompt plus ``--max-tokens`` must fit inside it). ``--chat`` also sends one
short request with thinking off, to check that chat completions work. Keys are never printed.
python eval/check_endpoint.py --base-url https://<endpoint>/v1 --modal-proxy --env-file <.env>
"""
from __future__ import annotations
import argparse
import json
import sys
import time
import urllib.error
import urllib.request
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent))
from run_model import NO_THINKING, ChatClient, load_env_file, modal_proxy_auth # noqa: E402
def get_models(base_url: str, headers: dict, wait_minutes: float) -> tuple[list[dict], float]:
started = time.monotonic()
while True:
try:
request = urllib.request.Request(base_url.rstrip("/") + "/models", headers=headers)
with urllib.request.urlopen(request, timeout=120) as response:
return json.loads(response.read())["data"], time.monotonic() - started
except urllib.error.HTTPError as exc:
if exc.code in (401, 403):
raise SystemExit(f"HTTP {exc.code}: the endpoint refused the credentials")
reason = f"HTTP {exc.code}"
except (urllib.error.URLError, TimeoutError, ConnectionError) as exc:
reason = type(exc).__name__
if time.monotonic() - started > wait_minutes * 60:
raise SystemExit(f"no answer after {wait_minutes} min ({reason})")
print(f" waiting ({reason}); a cold start can take a few minutes", flush=True)
time.sleep(15)
def main(argv: list[str] | None = None) -> int:
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument("--base-url", required=True, help="ends in /v1")
ap.add_argument("--modal-proxy", action="store_true", help="authenticate with the Modal proxy token")
ap.add_argument("--api-key-env", default=None, help="or a variable holding a bearer key")
ap.add_argument("--env-file", default=None)
ap.add_argument("--wait-minutes", type=float, default=10)
ap.add_argument("--chat", action="store_true", help="also send one short request (thinking off)")
args = ap.parse_args(argv)
load_env_file(args.env_file)
key, extra = modal_proxy_auth() if args.modal_proxy else (None, {})
if args.api_key_env:
import os
key = os.environ.get(args.api_key_env) or sys.exit(f"{args.api_key_env} is not set")
headers = {**extra, **({"Authorization": f"Bearer {key}"} if key else {})}
models, seconds = get_models(args.base_url, headers, args.wait_minutes)
print(f"Answered after {seconds:.0f} s. Served models:")
for model in models:
print(f" --model {model['id']} max_model_len {model.get('max_model_len', 'not reported')}")
if args.chat and models:
chat = ChatClient(args.base_url, models[0]["id"], key, temperature=None, max_tokens=16,
extra_body=NO_THINKING, headers=extra, retries=3)
started = time.monotonic()
text, usage = chat([{"role": "user", "content": "Reply with the single word OK."}])
print(f"Chat reply in {time.monotonic() - started:.1f} s: {text.strip()[:40]!r} (usage {usage})")
return 0
if __name__ == "__main__":
raise SystemExit(main())
|