test: add comprehensive Python integration test suite

Add Python test code for testing all API formats:
- OpenAI Chat API, Anthropic Messages API, OpenAI Responses API
- Streaming and non-streaming modes
- Function calling / tool use
- Vision Language Model (VLM) support
- Rate limiting tests
- Request deduplication (ReqId) tests
- Client abort handling tests

The unified test suite (test_unified_suite.py) contains 52 tests
covering API formats, streaming, function calling, VLM, and error handling.

Run with: cd python_test_code && uv run test_unified_suite.py

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: pescn

.gitignore

@@ -24,5 +24,7 @@ backend/docs/
 
 .turbo
 
-# Python test code (local testing only)
-python_test_code/
+# Python test code - local artifacts
+python_test_code/.venv/
+python_test_code/.ruff_cache/
+python_test_code/test_report_*.txt

python_test_code/.python-version

@@ -0,0 +1 @@
+3.12

python_test_code/README.md

@@ -0,0 +1,35 @@
+import anthropic
+import os
+
+client = anthropic.Anthropic(
+    api_key="sk-d493c33eabaa3b71486d5de4194fa4ab",
+    base_url="http://localhost:3000",
+)
+message = client.messages.create(
+    model="deepseek-v3-2",
+    max_tokens=1024,
+    # 流式输出
+    stream=True,
+    messages=[
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "你是谁？"
+                }
+            ]
+        }
+    ]
+)
+print("=== 思考过程 ===")
+first_text = True
+for chunk in message:
+    if chunk.type == "content_block_delta":
+        if hasattr(chunk.delta, 'thinking'):
+            print(chunk.delta.thinking, end="", flush=True)
+        elif hasattr(chunk.delta, 'text'):
+            if first_text:
+                print("\n\n=== 回答 ===")
+                first_text = False
+            print(chunk.delta.text, end="", flush=True)

python_test_code/main.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+Background monitor for multi-key rate limit test.
+Polls API key usage 5 times per second and logs to file.
+"""
+import asyncio
+import json
+import time
+import sys
+from dataclasses import dataclass, asdict
+from datetime import datetime
+
+import httpx
+
+BASE_URL = "http://localhost:3000/api"
+ADMIN_SECRET = "admin"
+OUTPUT_FILE = "/tmp/rate_limit_monitor.jsonl"
+POLL_INTERVAL = 0.2  # 5 times per second
+
+
+@dataclass
+class UsageSnapshot:
+    timestamp: float
+    datetime_str: str
+    api_key_id: int
+    api_key_short: str
+    rpm_current: int
+    rpm_limit: int
+    rpm_remaining: int
+    tpm_current: int
+    tpm_limit: int
+    tpm_remaining: int
+
+
+async def get_all_api_keys(client: httpx.AsyncClient) -> list[dict]:
+    """Get all API keys"""
+    try:
+        resp = await client.get(
+            f"{BASE_URL}/admin/apiKey",
+            headers={"Authorization": f"Bearer {ADMIN_SECRET}"},
+            timeout=5.0
+        )
+        if resp.status_code == 200:
+            return resp.json()
+    except Exception as e:
+        print(f"[Monitor] Error getting API keys: {e}", file=sys.stderr)
+    return []
+
+
+async def get_usage(client: httpx.AsyncClient, key_info: dict) -> UsageSnapshot | None:
+    """Get usage for a single API key"""
+    try:
+        resp = await client.get(
+            f"{BASE_URL}/admin/apiKey/{key_info['key']}/usage",
+            headers={"Authorization": f"Bearer {ADMIN_SECRET}"},
+            timeout=5.0
+        )
+        if resp.status_code == 200:
+            data = resp.json()
+            now = time.time()
+            return UsageSnapshot(
+                timestamp=now,
+                datetime_str=datetime.fromtimestamp(now).strftime("%H:%M:%S.%f")[:-3],
+                api_key_id=key_info["id"],
+                api_key_short=key_info["key"][:15] + "...",
+                rpm_current=data.get("usage", {}).get("rpm", {}).get("current", 0),
+                rpm_limit=data.get("limits", {}).get("rpm", 0),
+                rpm_remaining=data.get("usage", {}).get("rpm", {}).get("remaining", 0),
+                tpm_current=data.get("usage", {}).get("tpm", {}).get("current", 0),
+                tpm_limit=data.get("limits", {}).get("tpm", 0),
+                tpm_remaining=data.get("usage", {}).get("tpm", {}).get("remaining", 0),
+            )
+    except Exception as e:
+        pass  # Silent fail for monitoring
+    return None
+
+
+async def monitor_loop(stop_file: str = "/tmp/stop_monitor"):
+    """Main monitoring loop"""
+    print(f"[Monitor] Starting rate limit monitor")
+    print(f"[Monitor] Output file: {OUTPUT_FILE}")
+    print(f"[Monitor] Poll interval: {POLL_INTERVAL}s (5x per second)")
+    print(f"[Monitor] Stop by creating file: {stop_file}")
+    print()
+
+    # Clear output file
+    with open(OUTPUT_FILE, "w") as f:
+        f.write("")
+
+    snapshot_count = 0
+    last_keys_check = 0
+    api_keys: list[dict] = []
+
+    async with httpx.AsyncClient() as client:
+        while True:
+            # Check stop condition
+            import os
+            if os.path.exists(stop_file):
+                print(f"\n[Monitor] Stop file detected, exiting...")
+                try:
+                    os.remove(stop_file)
+                except:
+                    pass
+                break
+
+            # Refresh API keys list every 2 seconds
+            now = time.time()
+            if now - last_keys_check > 2:
+                api_keys = await get_all_api_keys(client)
+                last_keys_check = now
+                if api_keys:
+                    # Filter to recent test keys (created in last 10 minutes)
+                    # This is a simple heuristic based on comment pattern
+                    test_keys = [k for k in api_keys if k.get("comment", "").startswith("test-multikey-")]
+                    if test_keys:
+                        api_keys = test_keys
+                        print(f"[Monitor] Tracking {len(api_keys)} test API keys: {[k['id'] for k in api_keys]}")
+
+            if not api_keys:
+                await asyncio.sleep(POLL_INTERVAL)
+                continue
+
+            # Get usage for all keys concurrently
+            tasks = [get_usage(client, k) for k in api_keys]
+            snapshots = await asyncio.gather(*tasks, return_exceptions=True)
+
+            # Write snapshots to file
+            with open(OUTPUT_FILE, "a") as f:
+                for snapshot in snapshots:
+                    if isinstance(snapshot, UsageSnapshot):
+                        f.write(json.dumps(asdict(snapshot)) + "\n")
+                        snapshot_count += 1
+
+                        # Print summary every 10 snapshots
+                        if snapshot_count % 10 == 0:
+                            print(f"[Monitor] {snapshot.datetime_str} Key-{snapshot.api_key_id}: "
+                                  f"RPM {snapshot.rpm_current}/{snapshot.rpm_limit} "
+                                  f"(rem={snapshot.rpm_remaining}), "
+                                  f"TPM {snapshot.tpm_current}/{snapshot.tpm_limit}")
+
+            await asyncio.sleep(POLL_INTERVAL)
+
+    print(f"\n[Monitor] Total snapshots collected: {snapshot_count}")
+    print(f"[Monitor] Output saved to: {OUTPUT_FILE}")
+
+
+async def main():
+    # Remove stop file if exists
+    import os
+    stop_file = "/tmp/stop_monitor"
+    if os.path.exists(stop_file):
+        os.remove(stop_file)
+
+    try:
+        await monitor_loop(stop_file)
+    except KeyboardInterrupt:
+        print("\n[Monitor] Interrupted by user")
+    except Exception as e:
+        print(f"\n[Monitor] Error: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

python_test_code/monitor_multi_key.py

@@ -0,0 +1,94 @@
+"""
+Rate Limit Monitor
+Polls the rate limit usage API every 200ms and displays real-time status
+"""
+import time
+import httpx
+
+# Configuration
+BASE_URL = "http://localhost:3000"
+ADMIN_SECRET = "admin"
+API_KEY = "sk-d493c33eabaa3b71486d5de4194fa4ab"
+POLL_INTERVAL = 0.2  # 200ms
+
+
+def get_usage():
+    """Fetch current rate limit usage"""
+    try:
+        response = httpx.get(
+            f"{BASE_URL}/api/admin/apiKey/{API_KEY}/usage",
+            headers={"Authorization": f"Bearer {ADMIN_SECRET}"},
+            timeout=5.0
+        )
+        if response.status_code == 200:
+            return response.json()
+        return None
+    except Exception as e:
+        return None
+
+
+def format_bar(current: int, limit: int, width: int = 30) -> str:
+    """Create a visual progress bar"""
+    ratio = min(1.0, current / limit) if limit > 0 else 0
+    filled = int(width * ratio)
+    bar = "█" * filled + "░" * (width - filled)
+
+    if current > limit:
+        return f"\033[93m{bar}\033[0m"  # Yellow for over limit
+    elif current > limit * 0.8:
+        return f"\033[91m{bar}\033[0m"  # Red for near limit
+    else:
+        return f"\033[92m{bar}\033[0m"  # Green for normal
+
+
+def monitor():
+    """Main monitoring loop"""
+    print("=" * 70)
+    print("Rate Limit Monitor - Press Ctrl+C to stop")
+    print("=" * 70)
+    print(f"Monitoring API Key: {API_KEY[:20]}...")
+    print(f"Poll interval: {POLL_INTERVAL * 1000:.0f}ms")
+    print()
+
+    start_time = time.time()
+    max_rpm = 0
+    max_tpm = 0
+
+    try:
+        while True:
+            usage = get_usage()
+            elapsed = time.time() - start_time
+
+            if usage:
+                rpm_current = usage["usage"]["rpm"]["current"]
+                rpm_limit = usage["limits"]["rpm"]
+                tpm_current = usage["usage"]["tpm"]["current"]
+                tpm_limit = usage["limits"]["tpm"]
+
+                max_rpm = max(max_rpm, rpm_current)
+                max_tpm = max(max_tpm, tpm_current)
+
+                # Clear line and print status
+                rpm_bar = format_bar(rpm_current, rpm_limit)
+                tpm_bar = format_bar(tpm_current, tpm_limit)
+
+                print(f"\r[{elapsed:6.1f}s] RPM: {rpm_bar} {rpm_current:4d}/{rpm_limit:4d} | "
+                      f"TPM: {tpm_bar} {tpm_current:6d}/{tpm_limit:6d}", end="", flush=True)
+            else:
+                print(f"\r[{elapsed:6.1f}s] Waiting for API...", end="", flush=True)
+
+            time.sleep(POLL_INTERVAL)
+
+    except KeyboardInterrupt:
+        print("\n")
+        print("=" * 70)
+        print("Monitor Summary")
+        print("=" * 70)
+        print(f"Duration:    {time.time() - start_time:.1f}s")
+        print(f"Max RPM:     {max_rpm}")
+        print(f"Max TPM:     {max_tpm}")
+        print("=" * 70)
+
+
+if __name__ == "__main__":
+    monitor()

python_test_code/monitor_rate_limit.py

@@ -0,0 +1,11 @@
+[project]
+name = "python-test-code"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "anthropic>=0.75.0",
+    "openai>=2.15.0",
+    "httpx>=0.27.0",
+]