S78 模型池配置落库

这个提交存在于:
YokiiroBW 2026-07-06 01:53:03 +08:00
父节点 cc340faf69
当前提交 b64accd0b0
共有 5 个文件被更改,包括 553 次插入 和 0 次删除

查看文件

@ -0,0 +1,62 @@
"""Model provider pool service."""
from __future__ import annotations
import re
from typing import Any
from database.repositories.model_provider_repository import ModelProviderRepository
class ModelProviderService:
def __init__(self, repository: ModelProviderRepository):
self.repository = repository
def upsert_provider(self, payload: dict[str, Any]) -> dict[str, Any]:
provider_id = _required_text(payload.get("provider_id"), "provider_id")
return self.repository.upsert_provider(
{
**payload,
"provider_id": provider_id,
"display_name": str(payload.get("display_name") or provider_id),
"provider_type": str(payload.get("provider_type") or "openai_compatible"),
"image_endpoint": str(payload.get("image_endpoint") or "/v1/images/generations"),
}
)
def upsert_route(self, payload: dict[str, Any]) -> dict[str, Any]:
route_name = _required_text(payload.get("route_name"), "route_name")
provider_id = _required_text(payload.get("provider_id"), "provider_id")
model_id = _required_text(payload.get("model_id"), "model_id")
return self.repository.upsert_route(
{
**payload,
"route_id": str(payload.get("route_id") or _route_id(route_name, provider_id, model_id)),
"route_name": route_name,
"provider_id": provider_id,
"model_id": model_id,
"modality": str(payload.get("modality") or "image_generation"),
}
)
def list_providers(self, *, enabled: bool | None = None) -> list[dict[str, Any]]:
return self.repository.list_providers(enabled=enabled)
def list_routes(self, *, enabled: bool | None = None) -> list[dict[str, Any]]:
return self.repository.list_routes(enabled=enabled)
def resolve_route(self, route_name: str, *, modality: str | None = None) -> dict[str, Any] | None:
return self.repository.resolve_route(route_name, modality=modality)
def _required_text(value: Any, field: str) -> str:
text = str(value or "").strip()
if not text:
raise ValueError(f"{field} is required")
return text
def _route_id(route_name: str, provider_id: str, model_id: str) -> str:
stem = "_".join([route_name, provider_id, model_id])
normalized = re.sub(r"[^A-Za-z0-9_]+", "_", stem).strip("_").lower()
return f"route_{normalized or 'model'}"

查看文件

@ -0,0 +1,37 @@
CREATE TABLE IF NOT EXISTS model_providers (
provider_id TEXT PRIMARY KEY,
display_name TEXT NOT NULL,
provider_type TEXT NOT NULL DEFAULT 'openai_compatible',
base_url TEXT NOT NULL,
image_endpoint TEXT NOT NULL DEFAULT '/v1/images/generations',
api_key_env_var TEXT,
api_key_secret_ref TEXT,
enabled INTEGER NOT NULL DEFAULT 1,
timeout_seconds INTEGER NOT NULL DEFAULT 180,
capabilities_json TEXT,
extra_headers_json TEXT,
metadata_json TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE IF NOT EXISTS model_routes (
route_id TEXT PRIMARY KEY,
route_name TEXT NOT NULL,
provider_id TEXT NOT NULL,
model_id TEXT NOT NULL,
modality TEXT NOT NULL DEFAULT 'image_generation',
priority INTEGER NOT NULL DEFAULT 100,
enabled INTEGER NOT NULL DEFAULT 1,
settings_json TEXT,
metadata_json TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY(provider_id) REFERENCES model_providers(provider_id)
);
CREATE INDEX IF NOT EXISTS idx_model_routes_provider
ON model_routes(provider_id);
CREATE INDEX IF NOT EXISTS idx_model_routes_name_enabled_priority
ON model_routes(route_name, enabled, priority);

查看文件

@ -114,6 +114,28 @@ TABLES: tuple[TableSpec, ...] = (
ColumnSpec("config_json", nullable=False, sensitive=True),
),
),
TableSpec(
"model_providers",
"provider_id",
(
ColumnSpec("provider_id", nullable=False),
ColumnSpec("display_name", nullable=False),
ColumnSpec("provider_type", nullable=False),
ColumnSpec("base_url", nullable=False),
ColumnSpec("api_key_secret_ref", sensitive=True),
),
),
TableSpec(
"model_routes",
"route_id",
(
ColumnSpec("route_id", nullable=False),
ColumnSpec("route_name", nullable=False),
ColumnSpec("provider_id", nullable=False),
ColumnSpec("model_id", nullable=False),
ColumnSpec("modality", nullable=False),
),
),
)

查看文件

@ -0,0 +1,354 @@
"""Repository for persisted model providers and model routes."""
from __future__ import annotations
import json
from typing import Any
from database.db_helper import Database
class ModelProviderRepository:
def __init__(self, database: Database):
self.database = database
@property
def placeholder(self) -> str:
return self.database._placeholder
def upsert_provider(self, payload: dict[str, Any]) -> dict[str, Any]:
provider_id = str(payload["provider_id"]).strip()
existing = self.get_provider(provider_id)
if existing:
return self.update_provider(provider_id, payload) or existing
placeholder = self.placeholder
conn = self.database.connect()
try:
conn.execute(
f"""
INSERT INTO model_providers (
provider_id, display_name, provider_type, base_url, image_endpoint,
api_key_env_var, api_key_secret_ref, enabled, timeout_seconds,
capabilities_json, extra_headers_json, metadata_json
) VALUES (
{placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder},
{placeholder}, {placeholder}, {placeholder}, {placeholder},
{placeholder}, {placeholder}, {placeholder}
)
""",
(
provider_id,
str(payload.get("display_name") or provider_id),
str(payload.get("provider_type") or "openai_compatible"),
str(payload.get("base_url") or ""),
str(payload.get("image_endpoint") or "/v1/images/generations"),
_optional_text(payload.get("api_key_env_var")),
_optional_text(payload.get("api_key_secret_ref")),
_bool_int(payload.get("enabled", True)),
_int_or_default(payload.get("timeout_seconds"), 180),
_json_or_none(payload.get("capabilities") or {}),
_json_or_none(payload.get("extra_headers") or {}),
_json_or_none(payload.get("metadata") or {}),
),
)
conn.commit()
finally:
conn.close()
return self.get_provider(provider_id) or dict(payload)
def update_provider(self, provider_id: str, payload: dict[str, Any]) -> dict[str, Any] | None:
column_map = {
"display_name": ("display_name", str),
"provider_type": ("provider_type", str),
"base_url": ("base_url", str),
"image_endpoint": ("image_endpoint", str),
"api_key_env_var": ("api_key_env_var", _optional_text),
"api_key_secret_ref": ("api_key_secret_ref", _optional_text),
"enabled": ("enabled", _bool_int),
"timeout_seconds": ("timeout_seconds", lambda value: _int_or_default(value, 180)),
"capabilities": ("capabilities_json", lambda value: _json_or_none(value or {})),
"extra_headers": ("extra_headers_json", lambda value: _json_or_none(value or {})),
"metadata": ("metadata_json", lambda value: _json_or_none(value or {})),
}
assignments: list[str] = []
params: list[Any] = []
placeholder = self.placeholder
for key, (column, normalizer) in column_map.items():
if key not in payload:
continue
assignments.append(f"{column} = {placeholder}")
params.append(normalizer(payload[key]))
if not assignments:
return self.get_provider(provider_id)
assignments.append("updated_at = CURRENT_TIMESTAMP")
params.append(provider_id)
conn = self.database.connect()
try:
conn.execute(
f"""
UPDATE model_providers
SET {", ".join(assignments)}
WHERE provider_id = {placeholder}
""",
tuple(params),
)
conn.commit()
finally:
conn.close()
return self.get_provider(provider_id)
def get_provider(self, provider_id: str) -> dict[str, Any] | None:
placeholder = self.placeholder
conn = self.database.connect()
try:
row = conn.execute(
f"SELECT * FROM model_providers WHERE provider_id = {placeholder}",
(provider_id,),
).fetchone()
finally:
conn.close()
return _row_to_provider(row) if row else None
def list_providers(self, *, enabled: bool | None = None) -> list[dict[str, Any]]:
params: list[Any] = []
where = ""
if enabled is not None:
where = f"WHERE enabled = {self.placeholder}"
params.append(_bool_int(enabled))
conn = self.database.connect()
try:
rows = conn.execute(
f"""
SELECT *
FROM model_providers
{where}
ORDER BY provider_id ASC
""",
tuple(params),
).fetchall()
finally:
conn.close()
return [_row_to_provider(row) for row in rows]
def upsert_route(self, payload: dict[str, Any]) -> dict[str, Any]:
route_id = str(payload["route_id"]).strip()
existing = self.get_route(route_id)
if existing:
return self.update_route(route_id, payload) or existing
placeholder = self.placeholder
conn = self.database.connect()
try:
conn.execute(
f"""
INSERT INTO model_routes (
route_id, route_name, provider_id, model_id, modality,
priority, enabled, settings_json, metadata_json
) VALUES (
{placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder},
{placeholder}, {placeholder}, {placeholder}, {placeholder}
)
""",
(
route_id,
str(payload["route_name"]).strip(),
str(payload["provider_id"]).strip(),
str(payload["model_id"]).strip(),
str(payload.get("modality") or "image_generation"),
_int_or_default(payload.get("priority"), 100),
_bool_int(payload.get("enabled", True)),
_json_or_none(payload.get("settings") or {}),
_json_or_none(payload.get("metadata") or {}),
),
)
conn.commit()
finally:
conn.close()
return self.get_route(route_id) or dict(payload)
def update_route(self, route_id: str, payload: dict[str, Any]) -> dict[str, Any] | None:
column_map = {
"route_name": ("route_name", str),
"provider_id": ("provider_id", str),
"model_id": ("model_id", str),
"modality": ("modality", str),
"priority": ("priority", lambda value: _int_or_default(value, 100)),
"enabled": ("enabled", _bool_int),
"settings": ("settings_json", lambda value: _json_or_none(value or {})),
"metadata": ("metadata_json", lambda value: _json_or_none(value or {})),
}
assignments: list[str] = []
params: list[Any] = []
placeholder = self.placeholder
for key, (column, normalizer) in column_map.items():
if key not in payload:
continue
assignments.append(f"{column} = {placeholder}")
params.append(normalizer(payload[key]))
if not assignments:
return self.get_route(route_id)
assignments.append("updated_at = CURRENT_TIMESTAMP")
params.append(route_id)
conn = self.database.connect()
try:
conn.execute(
f"""
UPDATE model_routes
SET {", ".join(assignments)}
WHERE route_id = {placeholder}
""",
tuple(params),
)
conn.commit()
finally:
conn.close()
return self.get_route(route_id)
def get_route(self, route_id: str) -> dict[str, Any] | None:
placeholder = self.placeholder
conn = self.database.connect()
try:
row = conn.execute(
f"SELECT * FROM model_routes WHERE route_id = {placeholder}",
(route_id,),
).fetchone()
finally:
conn.close()
return _row_to_route(row) if row else None
def list_routes(self, *, enabled: bool | None = None) -> list[dict[str, Any]]:
params: list[Any] = []
where = ""
if enabled is not None:
where = f"WHERE enabled = {self.placeholder}"
params.append(_bool_int(enabled))
conn = self.database.connect()
try:
rows = conn.execute(
f"""
SELECT *
FROM model_routes
{where}
ORDER BY route_name ASC, priority ASC, route_id ASC
""",
tuple(params),
).fetchall()
finally:
conn.close()
return [_row_to_route(row) for row in rows]
def resolve_route(self, route_name: str, *, modality: str | None = None) -> dict[str, Any] | None:
params: list[Any] = [route_name]
modality_clause = ""
if modality:
modality_clause = f"AND route.modality = {self.placeholder}"
params.append(modality)
conn = self.database.connect()
try:
row = conn.execute(
f"""
SELECT
route.*,
provider.display_name AS provider_display_name,
provider.provider_type,
provider.base_url,
provider.image_endpoint,
provider.api_key_env_var,
provider.api_key_secret_ref,
provider.timeout_seconds,
provider.capabilities_json AS provider_capabilities_json,
provider.extra_headers_json AS provider_extra_headers_json
FROM model_routes route
JOIN model_providers provider ON provider.provider_id = route.provider_id
WHERE route.route_name = {self.placeholder}
AND route.enabled = 1
AND provider.enabled = 1
{modality_clause}
ORDER BY route.priority ASC, route.route_id ASC
""",
tuple(params),
).fetchone()
finally:
conn.close()
return _row_to_resolved_route(row) if row else None
def _row_to_provider(row) -> dict[str, Any]:
return {
"provider_id": row["provider_id"],
"display_name": row["display_name"],
"provider_type": row["provider_type"],
"base_url": row["base_url"],
"image_endpoint": row["image_endpoint"],
"api_key_env_var": row["api_key_env_var"],
"api_key_secret_ref": row["api_key_secret_ref"],
"enabled": bool(row["enabled"]),
"timeout_seconds": int(row["timeout_seconds"]),
"capabilities": _json_loads(row["capabilities_json"]),
"extra_headers": _json_loads(row["extra_headers_json"]),
"metadata": _json_loads(row["metadata_json"]),
"created_at": str(row["created_at"]),
"updated_at": str(row["updated_at"]),
}
def _row_to_route(row) -> dict[str, Any]:
return {
"route_id": row["route_id"],
"route_name": row["route_name"],
"provider_id": row["provider_id"],
"model_id": row["model_id"],
"modality": row["modality"],
"priority": int(row["priority"]),
"enabled": bool(row["enabled"]),
"settings": _json_loads(row["settings_json"]),
"metadata": _json_loads(row["metadata_json"]),
"created_at": str(row["created_at"]),
"updated_at": str(row["updated_at"]),
}
def _row_to_resolved_route(row) -> dict[str, Any]:
route = _row_to_route(row)
route["provider"] = {
"provider_id": row["provider_id"],
"display_name": row["provider_display_name"],
"provider_type": row["provider_type"],
"base_url": row["base_url"],
"image_endpoint": row["image_endpoint"],
"api_key_env_var": row["api_key_env_var"],
"api_key_secret_ref": row["api_key_secret_ref"],
"timeout_seconds": int(row["timeout_seconds"]),
"capabilities": _json_loads(row["provider_capabilities_json"]),
"extra_headers": _json_loads(row["provider_extra_headers_json"]),
}
return route
def _json_or_none(value: Any | None) -> str | None:
if value is None:
return None
return json.dumps(value, ensure_ascii=False, sort_keys=True)
def _json_loads(value: str | None) -> dict[str, Any]:
if not value:
return {}
return json.loads(value)
def _optional_text(value: Any) -> str | None:
text = str(value or "").strip()
return text or None
def _bool_int(value: Any) -> int:
if isinstance(value, str):
return 1 if value.strip().lower() in {"1", "true", "yes", "on"} else 0
return 1 if bool(value) else 0
def _int_or_default(value: Any, default: int) -> int:
try:
return int(value)
except (TypeError, ValueError):
return default

查看文件

@ -0,0 +1,78 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.services.model_provider_service import ModelProviderService
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.models import table_spec
from database.repositories.model_provider_repository import ModelProviderRepository
class ModelProviderServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(Path(self.tmp.name) / "imagestudio.db")))
)
self.database.initialize()
self.service = ModelProviderService(ModelProviderRepository(self.database))
def tearDown(self):
self.tmp.cleanup()
def test_provider_and_route_are_persisted_and_resolved(self):
provider = self.service.upsert_provider(
{
"provider_id": "site_b",
"display_name": "B Site",
"base_url": "https://botcf.com",
"image_endpoint": "/v1/images/generations",
"api_key_env_var": "IMAGESTUDIO_SITE_B_KEY",
"timeout_seconds": 180,
"capabilities": {"image_generation": True},
}
)
route = self.service.upsert_route(
{
"route_name": "image_high",
"provider_id": "site_b",
"model_id": "image2",
"priority": 10,
"settings": {"size": "1024x1024"},
}
)
resolved = self.service.resolve_route("image_high", modality="image_generation")
self.assertEqual(provider["provider_id"], "site_b")
self.assertEqual(route["route_id"], "route_image_high_site_b_image2")
self.assertIsNotNone(resolved)
self.assertEqual(resolved["model_id"], "image2")
self.assertEqual(resolved["provider"]["base_url"], "https://botcf.com")
self.assertEqual(resolved["provider"]["api_key_env_var"], "IMAGESTUDIO_SITE_B_KEY")
def test_route_resolution_prefers_lower_priority_enabled_provider(self):
self.service.upsert_provider({"provider_id": "slow", "base_url": "https://slow.example"})
self.service.upsert_provider({"provider_id": "fast", "base_url": "https://fast.example"})
self.service.upsert_route(
{"route_name": "image_low", "provider_id": "slow", "model_id": "slow-model", "priority": 50}
)
self.service.upsert_route(
{"route_name": "image_low", "provider_id": "fast", "model_id": "fast-model", "priority": 5}
)
resolved = self.service.resolve_route("image_low")
self.assertEqual(resolved["provider_id"], "fast")
self.assertEqual(resolved["model_id"], "fast-model")
def test_model_tables_are_registered_as_metadata(self):
self.assertEqual(table_spec("model_providers").primary_key, "provider_id")
self.assertEqual(table_spec("model_routes").primary_key, "route_id")
self.assertEqual(table_spec("model_providers").sensitive_columns(), ["api_key_secret_ref"])
if __name__ == "__main__":
unittest.main()