398 行
15 KiB
Python
398 行
15 KiB
Python
"""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 resolve_provider_model(
|
|
self,
|
|
provider_id: str,
|
|
model_id: str,
|
|
*,
|
|
modality: str | None = None,
|
|
) -> dict[str, Any] | None:
|
|
"""Resolve an enabled route from the provider/model identity used by discovery UIs."""
|
|
|
|
params: list[Any] = [provider_id, model_id]
|
|
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.provider_id = {self.placeholder}
|
|
AND route.model_id = {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
|