api-key-manager 2.1.0__py3-none-any.whl

key_manager/providers/tencent_hunyuan.py

@@ -0,0 +1,122 @@
+import asyncio
+import time
+from .base import ProviderBase, CheckResult, TestResult
+
+
+class TencentHunyuanProvider(ProviderBase):
+    """腾讯混元 provider - OpenAI compatible endpoint."""
+    name = "tencent-hunyuan"
+    base_url = "https://api.hunyuan.cloud.tencent.com/v1"
+    check_endpoint = "/models"
+    check_model = "hunyuan-turbos-latest"
+
+    def build_headers(self, key: str) -> dict:
+        return {"Authorization": f"Bearer {key}"}
+
+    async def get_models(self, client, key: str) -> list[str]:
+        headers = self.build_headers(key)
+        try:
+            resp = await client.get(f"{self.get_base_url()}{self.check_endpoint}", headers=headers)
+            if resp.status_code == 200:
+                data = resp.json()
+                if "data" in data:
+                    return [m["id"] for m in data["data"] if "id" in m]
+            return []
+        except Exception:
+            return []
+
+    async def check(self, client, key: str) -> CheckResult:
+        headers = self.build_headers(key)
+        headers["Content-Type"] = "application/json"
+        start = time.monotonic()
+        try:
+            resp = await client.post(
+                f"{self.get_base_url()}/chat/completions",
+                headers=headers,
+                json={"model": "hunyuan-turbos-latest", "messages": [{"role": "user", "content": "hi"}], "max_tokens": 5}
+            )
+            latency = (time.monotonic() - start) * 1000
+            if resp.status_code == 200:
+                return CheckResult(True, 200, latency, None)
+            elif resp.status_code in (401, 403):
+                return CheckResult(False, resp.status_code, latency, "invalid key or forbidden")
+            elif resp.status_code == 429:
+                return CheckResult(False, 429, latency, "rate limited")
+            else:
+                try:
+                    data = resp.json()
+                    error_msg = data.get("error", {}).get("message", f"status {resp.status_code}")
+                except:
+                    error_msg = f"status {resp.status_code}"
+                return CheckResult(False, resp.status_code, latency, error_msg)
+        except Exception as e:
+            return CheckResult(False, None, (time.monotonic() - start) * 1000, str(e))
+
+    async def test_token_limit(self, client, key: str, token_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in token_steps:
+            try:
+                resp = await client.post(
+                    f"{self.get_base_url()}/chat/completions",
+                    headers=headers,
+                    json={"model": "hunyuan-turbos-latest", "messages": [{"role": "user", "content": "hi"}], "max_tokens": step}
+                )
+                if resp.status_code == 200:
+                    last_success = step
+                elif resp.status_code in (400, 413):
+                    break
+                elif resp.status_code == 429:
+                    await asyncio.sleep(1)
+                    continue
+                else:
+                    break
+            except Exception:
+                break
+        return TestResult(max_tokens=last_success)
+
+
+    async def check_real(self, client, key: str) -> CheckResult:
+        return await self.check(client, key)
+    async def test_concurrency(self, client, key: str, concurrency_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in concurrency_steps:
+            tasks = [self._probe(client, headers) for _ in range(step)]
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            rate_limited = sum(1 for r in results if not isinstance(r, Exception) and not r)
+            if rate_limited / step >= 0.3:
+                break
+            last_success = step
+        return TestResult(max_concurrency=last_success)
+
+    async def _probe(self, client, headers) -> bool:
+        try:
+            resp = await client.get(f"{self.get_base_url()}{self.check_endpoint}", headers=headers)
+            return resp.status_code == 200
+        except Exception:
+            return False
+
+    async def test_concurrency_for_model(self, client, key: str, model: str, concurrency_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        headers["Content-Type"] = "application/json"
+        last_success = None
+        for step in concurrency_steps:
+            tasks = [self._probe_model(client, headers, model) for _ in range(step)]
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            rate_limited = sum(1 for r in results if not isinstance(r, Exception) and not r)
+            if rate_limited / step >= 0.3:
+                break
+            last_success = step
+        return TestResult(max_concurrency=last_success)
+
+    async def _probe_model(self, client, headers, model: str) -> bool:
+        try:
+            resp = await client.post(
+                f"{self.get_base_url()}/chat/completions",
+                headers=headers,
+                json={"model": model, "messages": [{"role": "user", "content": "hi"}], "max_tokens": 1}
+            )
+            return resp.status_code == 200
+        except Exception:
+            return False

key_manager/providers/together.py

@@ -0,0 +1,134 @@
+import asyncio
+import time
+from .base import ProviderBase, CheckResult, TestResult, BalanceResult
+
+
+class TogetherProvider(ProviderBase):
+    name = "together"
+    base_url = "https://api.together.xyz"
+    check_endpoint = "/v1/models"
+
+    def build_headers(self, key: str) -> dict:
+        return {"Authorization": f"Bearer {key}"}
+
+    async def get_models(self, client, key: str) -> list[str]:
+        headers = self.build_headers(key)
+        try:
+            resp = await client.get(
+                f"{self.get_base_url()}{self.check_endpoint}",
+                headers=headers
+            )
+            if resp.status_code == 200:
+                data = resp.json()
+                if "data" in data:
+                    return [m["id"] for m in data["data"] if "id" in m]
+            return []
+        except Exception:
+            return []
+
+    async def check(self, client, key: str) -> CheckResult:
+        """Real usage test - try to make a minimal chat completion request."""
+        headers = self.build_headers(key)
+        headers["Content-Type"] = "application/json"
+        start = time.monotonic()
+        try:
+            resp = await client.post(
+                f"{self.get_base_url()}/v1/chat/completions",
+                headers=headers,
+                json={
+                    "model": "mistralai/Mixtral-8x7B-v0.1",
+                    "messages": [{"role": "user", "content": "hi"}],
+                    "max_tokens": 5
+                }
+            )
+            latency = (time.monotonic() - start) * 1000
+
+            if resp.status_code == 200:
+                return CheckResult(True, 200, latency, None)
+            elif resp.status_code in (401, 403):
+                return CheckResult(False, resp.status_code, latency, "invalid key or forbidden")
+            elif resp.status_code == 429:
+                return CheckResult(False, 429, latency, "rate limited")
+            else:
+                try:
+                    data = resp.json()
+                    error_msg = data.get("error", {}).get("message", f"status {resp.status_code}")
+                except:
+                    error_msg = f"status {resp.status_code}"
+                return CheckResult(False, resp.status_code, latency, error_msg)
+        except Exception as e:
+            return CheckResult(False, None, (time.monotonic() - start) * 1000, str(e))
+
+    async def test_token_limit(self, client, key: str, token_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in token_steps:
+            try:
+                resp = await client.post(
+                    f"{self.get_base_url()}/v1/chat/completions",
+                    headers=headers,
+                    json={
+                        "model": "mistralai/Mixtral-8x7B-v0.1",
+                        "messages": [{"role": "user", "content": "hi"}],
+                        "max_tokens": step
+                    }
+                )
+                if resp.status_code == 200:
+                    last_success = step
+                elif resp.status_code in (400, 413):
+                    break
+                elif resp.status_code == 429:
+                    await asyncio.sleep(1)
+                    continue
+                else:
+                    break
+            except Exception:
+                break
+        return TestResult(max_tokens=last_success)
+
+
+    async def check_real(self, client, key: str) -> CheckResult:
+        return await self.check(client, key)
+    async def test_concurrency(self, client, key: str, concurrency_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in concurrency_steps:
+            tasks = [self._probe(client, headers) for _ in range(step)]
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            rate_limited = sum(1 for r in results if not isinstance(r, Exception) and not r)
+            if rate_limited / step >= 0.3:
+                break
+            last_success = step
+        return TestResult(max_concurrency=last_success)
+
+    async def _probe(self, client, headers) -> bool:
+        try:
+            resp = await client.get(f"{self.get_base_url()}{self.check_endpoint}", headers=headers)
+            return resp.status_code == 200
+        except Exception:
+            return False
+
+    async def get_balance(self, client, key: str) -> BalanceResult:
+        """Get organization info via Together API."""
+        headers = self.build_headers(key)
+        try:
+            resp = await client.get(
+                f"{self.get_base_url()}/v1/organizations/me",
+                headers=headers
+            )
+            if resp.status_code == 200:
+                data = resp.json()
+                # Together API returns org info, not direct balance
+                # Try to extract any balance-related fields
+                return BalanceResult(
+                    supported=True,
+                    balance=None,
+                    currency="USD",
+                    raw=data,
+                )
+            elif resp.status_code in (401, 403):
+                return BalanceResult(supported=True, error="invalid key or forbidden")
+            else:
+                return BalanceResult(supported=True, error=f"status {resp.status_code}")
+        except Exception as e:
+            return BalanceResult(supported=True, error=str(e))

key_manager/providers/yi.py

@@ -0,0 +1,97 @@
+import asyncio
+import time
+from .base import ProviderBase, CheckResult, TestResult
+
+
+class YiProvider(ProviderBase):
+    name = "yi"
+    base_url = "https://api.lingyiwanwu.com/v1"
+    check_endpoint = "/models"
+    check_model = "yi-lightning"
+
+    def build_headers(self, key: str) -> dict:
+        return {"Authorization": f"Bearer {key}"}
+
+    async def get_models(self, client, key: str) -> list[str]:
+        headers = self.build_headers(key)
+        try:
+            resp = await client.get(f"{self.get_base_url()}/models", headers=headers)
+            if resp.status_code == 200:
+                data = resp.json()
+                if "data" in data:
+                    return [m["id"] for m in data["data"] if "id" in m]
+            return []
+        except Exception:
+            return []
+
+    async def check(self, client, key: str) -> CheckResult:
+        headers = self.build_headers(key)
+        headers["Content-Type"] = "application/json"
+        start = time.monotonic()
+        try:
+            resp = await client.post(
+                f"{self.get_base_url()}/chat/completions",
+                headers=headers,
+                json={"model": "yi-lightning", "messages": [{"role": "user", "content": "hi"}], "max_tokens": 5}
+            )
+            latency = (time.monotonic() - start) * 1000
+            if resp.status_code == 200:
+                return CheckResult(True, 200, latency, None)
+            elif resp.status_code in (401, 403):
+                return CheckResult(False, resp.status_code, latency, "invalid key or forbidden")
+            elif resp.status_code == 429:
+                return CheckResult(False, 429, latency, "rate limited")
+            else:
+                try:
+                    data = resp.json()
+                    error_msg = data.get("error", {}).get("message", f"status {resp.status_code}")
+                except:
+                    error_msg = f"status {resp.status_code}"
+                return CheckResult(False, resp.status_code, latency, error_msg)
+        except Exception as e:
+            return CheckResult(False, None, (time.monotonic() - start) * 1000, str(e))
+
+    async def test_token_limit(self, client, key: str, token_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in token_steps:
+            try:
+                resp = await client.post(
+                    f"{self.get_base_url()}/chat/completions",
+                    headers=headers,
+                    json={"model": "yi-lightning", "messages": [{"role": "user", "content": "hi"}], "max_tokens": step}
+                )
+                if resp.status_code == 200:
+                    last_success = step
+                elif resp.status_code in (400, 413):
+                    break
+                elif resp.status_code == 429:
+                    await asyncio.sleep(1)
+                    continue
+                else:
+                    break
+            except Exception:
+                break
+        return TestResult(max_tokens=last_success)
+
+
+    async def check_real(self, client, key: str) -> CheckResult:
+        return await self.check(client, key)
+    async def test_concurrency(self, client, key: str, concurrency_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in concurrency_steps:
+            tasks = [self._probe(client, headers) for _ in range(step)]
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            rate_limited = sum(1 for r in results if not isinstance(r, Exception) and not r)
+            if rate_limited / step >= 0.3:
+                break
+            last_success = step
+        return TestResult(max_concurrency=last_success)
+
+    async def _probe(self, client, headers) -> bool:
+        try:
+            resp = await client.get(f"{self.get_base_url()}{self.check_endpoint}", headers=headers)
+            return resp.status_code == 200
+        except Exception:
+            return False

key_manager/providers/zai.py

@@ -0,0 +1,109 @@
+import asyncio
+import time
+from .base import ProviderBase, CheckResult, TestResult
+
+
+class ZAIProvider(ProviderBase):
+    name = "zai"
+    base_url = "https://api.z.ai/api/paas/v4"
+    check_endpoint = "/models"
+
+    def build_headers(self, key: str) -> dict:
+        return {"Authorization": f"Bearer {key}"}
+
+    async def get_models(self, client, key: str) -> list[str]:
+        headers = self.build_headers(key)
+        try:
+            resp = await client.get(
+                f"{self.get_base_url()}{self.check_endpoint}",
+                headers=headers
+            )
+            if resp.status_code == 200:
+                data = resp.json()
+                if "data" in data:
+                    return [m["id"] for m in data["data"] if "id" in m]
+            return []
+        except Exception:
+            return []
+
+    async def check(self, client, key: str) -> CheckResult:
+        """Real usage test - try to make a minimal chat completion request."""
+        headers = self.build_headers(key)
+        headers["Content-Type"] = "application/json"
+        start = time.monotonic()
+        try:
+            resp = await client.post(
+                f"{self.get_base_url()}/chat/completions",
+                headers=headers,
+                json={
+                    "model": "glm-4-flash",
+                    "messages": [{"role": "user", "content": "hi"}],
+                    "max_tokens": 5
+                }
+            )
+            latency = (time.monotonic() - start) * 1000
+
+            if resp.status_code == 200:
+                return CheckResult(True, 200, latency, None)
+            elif resp.status_code in (401, 403):
+                return CheckResult(False, resp.status_code, latency, "invalid key or forbidden")
+            elif resp.status_code == 429:
+                return CheckResult(False, 429, latency, "rate limited")
+            else:
+                try:
+                    data = resp.json()
+                    error_msg = data.get("error", {}).get("message", f"status {resp.status_code}")
+                except:
+                    error_msg = f"status {resp.status_code}"
+                return CheckResult(False, resp.status_code, latency, error_msg)
+        except Exception as e:
+            return CheckResult(False, None, (time.monotonic() - start) * 1000, str(e))
+
+    async def test_token_limit(self, client, key: str, token_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in token_steps:
+            try:
+                resp = await client.post(
+                    f"{self.get_base_url()}/chat/completions",
+                    headers=headers,
+                    json={
+                        "model": "glm-4-flash",
+                        "messages": [{"role": "user", "content": "hi"}],
+                        "max_tokens": step
+                    }
+                )
+                if resp.status_code == 200:
+                    last_success = step
+                elif resp.status_code in (400, 413):
+                    break
+                elif resp.status_code == 429:
+                    await asyncio.sleep(1)
+                    continue
+                else:
+                    break
+            except Exception:
+                break
+        return TestResult(max_tokens=last_success)
+
+
+    async def check_real(self, client, key: str) -> CheckResult:
+        return await self.check(client, key)
+    async def test_concurrency(self, client, key: str, concurrency_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in concurrency_steps:
+            tasks = [self._probe(client, headers) for _ in range(step)]
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            rate_limited = sum(1 for r in results if not isinstance(r, Exception) and not r)
+            if rate_limited / step >= 0.3:
+                break
+            last_success = step
+        return TestResult(max_concurrency=last_success)
+
+    async def _probe(self, client, headers) -> bool:
+        try:
+            resp = await client.get(f"{self.get_base_url()}{self.check_endpoint}", headers=headers)
+            return resp.status_code == 200
+        except Exception:
+            return False

key_manager/providers/zhipu.py

@@ -0,0 +1,127 @@
+import asyncio
+import time
+from .base import ProviderBase, CheckResult, TestResult, BalanceResult
+
+
+class ZhipuProvider(ProviderBase):
+    name = "zhipu"
+    base_url = "https://open.bigmodel.cn/api/paas/v4"
+    check_endpoint = "/models"
+    check_model = "glm-4-flash"
+
+    def build_headers(self, key: str) -> dict:
+        return {"Authorization": f"Bearer {key}"}
+
+    async def get_models(self, client, key: str) -> list[str]:
+        headers = self.build_headers(key)
+        try:
+            resp = await client.get(f"{self.get_base_url()}/models", headers=headers)
+            if resp.status_code == 200:
+                data = resp.json()
+                if "data" in data:
+                    return [m["id"] for m in data["data"] if "id" in m]
+            return []
+        except Exception:
+            return []
+
+    async def check(self, client, key: str) -> CheckResult:
+        headers = self.build_headers(key)
+        headers["Content-Type"] = "application/json"
+        start = time.monotonic()
+        try:
+            resp = await client.post(
+                f"{self.get_base_url()}/chat/completions",
+                headers=headers,
+                json={"model": "glm-4-flash", "messages": [{"role": "user", "content": "hi"}], "max_tokens": 5}
+            )
+            latency = (time.monotonic() - start) * 1000
+            if resp.status_code == 200:
+                return CheckResult(True, 200, latency, None)
+            elif resp.status_code in (401, 403):
+                return CheckResult(False, resp.status_code, latency, "invalid key or forbidden")
+            elif resp.status_code == 429:
+                return CheckResult(False, 429, latency, "rate limited")
+            else:
+                try:
+                    data = resp.json()
+                    error_msg = data.get("error", {}).get("message", f"status {resp.status_code}")
+                except:
+                    error_msg = f"status {resp.status_code}"
+                return CheckResult(False, resp.status_code, latency, error_msg)
+        except Exception as e:
+            return CheckResult(False, None, (time.monotonic() - start) * 1000, str(e))
+
+    async def test_token_limit(self, client, key: str, token_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in token_steps:
+            try:
+                resp = await client.post(
+                    f"{self.get_base_url()}/chat/completions",
+                    headers=headers,
+                    json={"model": "glm-4-flash", "messages": [{"role": "user", "content": "hi"}], "max_tokens": step}
+                )
+                if resp.status_code == 200:
+                    last_success = step
+                elif resp.status_code in (400, 413):
+                    break
+                elif resp.status_code == 429:
+                    await asyncio.sleep(1)
+                    continue
+                else:
+                    break
+            except Exception:
+                break
+        return TestResult(max_tokens=last_success)
+
+
+    async def check_real(self, client, key: str) -> CheckResult:
+        return await self.check(client, key)
+    async def test_concurrency(self, client, key: str, concurrency_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in concurrency_steps:
+            tasks = [self._probe(client, headers) for _ in range(step)]
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            rate_limited = sum(1 for r in results if not isinstance(r, Exception) and not r)
+            if rate_limited / step >= 0.3:
+                break
+            last_success = step
+        return TestResult(max_concurrency=last_success)
+
+    async def _probe(self, client, headers) -> bool:
+        try:
+            resp = await client.get(f"{self.get_base_url()}{self.check_endpoint}", headers=headers)
+            return resp.status_code == 200
+        except Exception:
+            return False
+
+    async def get_balance(self, client, key: str) -> BalanceResult:
+        """Get quota/usage info via Zhipu monitoring API."""
+        headers = self.build_headers(key)
+        try:
+            resp = await client.get(
+                f"https://open.bigmodel.cn/api/monitor/usage/quota/limit",
+                headers=headers
+            )
+            if resp.status_code == 200:
+                data = resp.json()
+                if data.get("success"):
+                    limits = data.get("data", {}).get("limits", [])
+                    # Extract percentage used from limits
+                    for limit in limits:
+                        if limit.get("type") == "TOKENS_LIMIT":
+                            percentage = limit.get("percentage", 0)
+                            return BalanceResult(
+                                supported=True,
+                                balance=float(100 - percentage),  # remaining percentage
+                                currency="%",
+                                raw=data,
+                            )
+                return BalanceResult(supported=True, balance=None, raw=data)
+            elif resp.status_code in (401, 403):
+                return BalanceResult(supported=True, error="invalid key or forbidden")
+            else:
+                return BalanceResult(supported=True, error=f"status {resp.status_code}")
+        except Exception as e:
+            return BalanceResult(supported=True, error=str(e))