astrbot_plugin_imagestudio/database/repositories/model_provider_repository.py

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