dsh-plugin-image-workbench 0.0.0-stage → 1.1.5

package/vendor/chatgpt2api/source/services/log_service.py

@@ -0,0 +1,337 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import itertools
+import time
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+from fastapi import HTTPException
+from fastapi.concurrency import run_in_threadpool
+from fastapi.responses import JSONResponse, StreamingResponse
+
+from services.config import DATA_DIR
+from services.protocol.error_response import anthropic_error_response, openai_error_response
+from utils.helper import anthropic_sse_stream, sse_json_stream
+
+LOG_TYPE_CALL = "call"
+LOG_TYPE_ACCOUNT = "account"
+INTERNAL_RESPONSE_KEYS = {"_account_email", "_conversation_id"}
+
+
+class LogService:
+    def __init__(self, path: Path):
+        self.path = path
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+
+    @staticmethod
+    def _legacy_id(raw_line: str, line_number: int) -> str:
+        payload = f"{line_number}:{raw_line}".encode("utf-8", errors="ignore")
+        return hashlib.sha1(payload).hexdigest()[:24]
+
+    def _parse_line(self, raw_line: str, line_number: int) -> dict[str, Any] | None:
+        try:
+            item = json.loads(raw_line)
+        except Exception:
+            return None
+        if not isinstance(item, dict):
+            return None
+        parsed = dict(item)
+        parsed["id"] = str(parsed.get("id") or self._legacy_id(raw_line, line_number))
+        return parsed
+
+    @staticmethod
+    def _serialize_item(item: dict[str, Any]) -> str:
+        return json.dumps(item, ensure_ascii=False, separators=(",", ":"))
+
+    @staticmethod
+    def _matches_filters(item: dict[str, Any], *, type: str = "", start_date: str = "", end_date: str = "") -> bool:
+        t = str(item.get("time") or "")
+        day = t[:10]
+        if type and item.get("type") != type:
+            return False
+        if start_date and day < start_date:
+            return False
+        if end_date and day > end_date:
+            return False
+        return True
+
+    def add(self, type: str, summary: str = "", detail: dict[str, Any] | None = None, **data: Any) -> None:
+        item = {
+            "id": uuid4().hex,
+            "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "type": type,
+            "summary": summary,
+            "detail": detail or data,
+        }
+        with self.path.open("a", encoding="utf-8") as file:
+            file.write(self._serialize_item(item) + "\n")
+
+    def list(self, type: str = "", start_date: str = "", end_date: str = "", limit: int = 200) -> list[dict[str, Any]]:
+        if not self.path.exists():
+            return []
+        items: list[dict[str, Any]] = []
+        lines = self.path.read_text(encoding="utf-8").splitlines()
+        for line_number in range(len(lines) - 1, -1, -1):
+            item = self._parse_line(lines[line_number], line_number)
+            if item is None:
+                continue
+            if not self._matches_filters(item, type=type, start_date=start_date, end_date=end_date):
+                continue
+            items.append(item)
+            if len(items) >= limit:
+                break
+        return items
+
+    def delete(self, ids: list[str]) -> dict[str, int]:
+        target_ids = {str(item or "").strip() for item in ids if str(item or "").strip()}
+        if not self.path.exists() or not target_ids:
+            return {"removed": 0}
+        lines = self.path.read_text(encoding="utf-8").splitlines()
+        kept_lines: list[str] = []
+        removed = 0
+        for line_number, raw_line in enumerate(lines):
+            item = self._parse_line(raw_line, line_number)
+            if item is None:
+                kept_lines.append(raw_line)
+                continue
+            if str(item.get("id") or "") in target_ids:
+                removed += 1
+                continue
+            kept_lines.append(self._serialize_item(item))
+        content = "\n".join(kept_lines)
+        if content:
+            content += "\n"
+        self.path.write_text(content, encoding="utf-8")
+        return {"removed": removed}
+
+
+log_service = LogService(DATA_DIR / "logs.jsonl")
+
+
+def _collect_urls(value: object) -> list[str]:
+    urls: list[str] = []
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if key == "url" and isinstance(item, str):
+                urls.append(item)
+            elif key == "urls" and isinstance(item, list):
+                urls.extend(str(url) for url in item if isinstance(url, str))
+            else:
+                urls.extend(_collect_urls(item))
+    elif isinstance(value, list):
+        for item in value:
+            urls.extend(_collect_urls(item))
+    return urls
+
+
+def _collect_account_emails(value: object) -> list[str]:
+    emails: list[str] = []
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if key in {"_account_email", "account_email"} and isinstance(item, str) and item.strip():
+                emails.append(item.strip())
+            else:
+                emails.extend(_collect_account_emails(item))
+    elif isinstance(value, list):
+        for item in value:
+            emails.extend(_collect_account_emails(item))
+    return emails
+
+
+def _collect_conversation_ids(value: object) -> list[str]:
+    ids: list[str] = []
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if key == "_conversation_id" and isinstance(item, str) and item.strip():
+                ids.append(item.strip())
+            else:
+                ids.extend(_collect_conversation_ids(item))
+    elif isinstance(value, list):
+        for item in value:
+            ids.extend(_collect_conversation_ids(item))
+    return ids
+
+
+def _strip_internal_response_fields(value: object) -> object:
+    if isinstance(value, dict):
+        return {
+            key: _strip_internal_response_fields(item)
+            for key, item in value.items()
+            if key not in INTERNAL_RESPONSE_KEYS
+        }
+    if isinstance(value, list):
+        return [_strip_internal_response_fields(item) for item in value]
+    return value
+
+
+def _request_excerpt(text: object, limit: int = 1000) -> str:
+    value = str(text or "").strip()
+    if not value:
+        return ""
+    normalized = " ".join(value.split())
+    if len(normalized) <= limit:
+        return normalized
+    return normalized[: limit - 1].rstrip() + "…"
+
+
+def _image_error_response(exc: Exception) -> JSONResponse:
+    from services.protocol.conversation import public_image_error_message
+
+    message = public_image_error_message(str(exc))
+    if "no available image quota" in message.lower():
+        return openai_error_response(
+            {
+                "error": {
+                    "message": "no available image quota",
+                    "type": "insufficient_quota",
+                    "param": None,
+                    "code": "insufficient_quota",
+                }
+            },
+            429,
+        )
+    if hasattr(exc, "to_openai_error") and hasattr(exc, "status_code"):
+        return JSONResponse(status_code=int(exc.status_code), content=exc.to_openai_error())
+    return openai_error_response(message, 502)
+
+
+def _protocol_error_response(exc: Exception, status_code: int, sse: str) -> JSONResponse:
+    message = str(exc)
+    if sse == "anthropic":
+        return anthropic_error_response(message, status_code)
+    return openai_error_response(message, status_code)
+
+
+def _next_item(items):
+    try:
+        return True, next(items)
+    except StopIteration:
+        return False, None
+
+
+@dataclass
+class LoggedCall:
+    identity: dict[str, object]
+    endpoint: str
+    model: str
+    summary: str
+    started: float = field(default_factory=time.time)
+    request_text: str = ""
+    request_shape: dict[str, int] | None = None
+
+    async def run(self, handler, *args, sse: str = "openai"):
+        from services.protocol.conversation import ImageGenerationError
+
+        try:
+            result = await run_in_threadpool(handler, *args)
+        except ImageGenerationError as exc:
+            self.log("调用失败", status="failed", error=str(exc), account_email=getattr(exc, "account_email", ""),
+                     conversation_id=getattr(exc, "conversation_id", ""))
+            return _image_error_response(exc)
+        except HTTPException as exc:
+            self.log("调用失败", status="failed", error=str(exc.detail))
+            raise
+        except Exception as exc:
+            self.log("调用失败", status="failed", error=str(exc), account_email=getattr(exc, "account_email", ""))
+            if self.endpoint.startswith("/v1/images"):
+                return _image_error_response(exc)
+            return _protocol_error_response(exc, 502, sse)
+
+        if isinstance(result, dict):
+            self.log("调用完成", result)
+            response = dict(result)
+            response.pop("_account_email", None)
+            return response
+
+        sender = anthropic_sse_stream if sse == "anthropic" else sse_json_stream
+        try:
+            has_first, first = await run_in_threadpool(_next_item, result)
+        except ImageGenerationError as exc:
+            self.log("调用失败", status="failed", error=str(exc), account_email=getattr(exc, "account_email", ""),
+                     conversation_id=getattr(exc, "conversation_id", ""))
+            return _image_error_response(exc)
+        except HTTPException as exc:
+            self.log("调用失败", status="failed", error=str(exc.detail))
+            raise
+        except Exception as exc:
+            self.log("调用失败", status="failed", error=str(exc), account_email=getattr(exc, "account_email", ""))
+            if self.endpoint.startswith("/v1/images"):
+                return _image_error_response(exc)
+            return _protocol_error_response(exc, 502, sse)
+        if not has_first:
+            self.log("流式调用结束")
+            return StreamingResponse(sender(()), media_type="text/event-stream")
+        return StreamingResponse(sender(self.stream(itertools.chain([first], result))), media_type="text/event-stream")
+
+    def stream(self, items):
+        urls: list[str] = []
+        account_emails: list[str] = []
+        conversation_ids: list[str] = []
+        failed = False
+        try:
+            for item in items:
+                urls.extend(_collect_urls(item))
+                account_emails.extend(_collect_account_emails(item))
+                conversation_ids.extend(_collect_conversation_ids(item))
+                yield _strip_internal_response_fields(item)
+        except Exception as exc:
+            failed = True
+            self.log(
+                "流式调用失败",
+                status="failed",
+                error=str(exc),
+                urls=urls,
+                account_email=(account_emails[0] if account_emails else getattr(exc, "account_email", "")),
+                conversation_id=(conversation_ids[0] if conversation_ids else getattr(exc, "conversation_id", "")),
+            )
+            if self.endpoint.startswith("/v1/images") and not hasattr(exc, "to_openai_error"):
+                from services.protocol.conversation import ImageGenerationError, public_image_error_message
+
+                raise ImageGenerationError(public_image_error_message(str(exc))) from exc
+            raise
+        finally:
+            if not failed:
+                self.log("流式调用结束", urls=urls, account_email=account_emails[0] if account_emails else "",
+                         conversation_id=conversation_ids[0] if conversation_ids else "")
+
+    def log(self, suffix: str, result: object = None, status: str = "success", error: str = "",
+            urls: list[str] | None = None, account_email: str = "", conversation_id: str = "") -> None:
+        detail = {
+            "key_id": self.identity.get("id"),
+            "key_name": self.identity.get("name"),
+            "role": self.identity.get("role"),
+            "endpoint": self.endpoint,
+            "model": self.model,
+            "started_at": datetime.fromtimestamp(self.started).strftime("%Y-%m-%d %H:%M:%S"),
+            "ended_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "duration_ms": int((time.time() - self.started) * 1000),
+            "status": status,
+        }
+        request_excerpt = _request_excerpt(self.request_text)
+        if request_excerpt:
+            detail["request_text"] = request_excerpt
+        if self.request_shape:
+            detail["request_shape"] = self.request_shape
+        if error:
+            detail["error"] = error
+        email = str(account_email or "").strip()
+        if not email:
+            emails = _collect_account_emails(result)
+            email = emails[0] if emails else ""
+        if email:
+            detail["account_email"] = email
+        conv_id = str(conversation_id or "").strip()
+        if not conv_id:
+            conv_ids = _collect_conversation_ids(result)
+            conv_id = conv_ids[0] if conv_ids else ""
+        if conv_id:
+            detail["conversation_id"] = conv_id
+        collected_urls = [*(urls or []), *_collect_urls(result)]
+        if collected_urls and not self.endpoint.startswith("/v1/search"):
+            detail["urls"] = list(dict.fromkeys(collected_urls))
+        log_service.add(LOG_TYPE_CALL, f"{self.summary}{suffix}", detail)

package/vendor/chatgpt2api/source/services/model_service.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from threading import RLock
+from typing import Any
+
+from services.account_service import AccountService, account_service
+from services.openai_backend_api import OpenAIBackendAPI
+from utils.log import logger
+
+
+@dataclass(frozen=True)
+class ModelRoute:
+    account_types: frozenset[str]
+    allow_anonymous: bool = False
+
+
+class ModelUnavailableError(RuntimeError):
+    pass
+
+
+class ModelCatalogService:
+    """Caches the model catalogs advertised to each active account type."""
+
+    def __init__(
+        self,
+        accounts: AccountService,
+        *,
+        backend_factory: Callable[..., Any] = OpenAIBackendAPI,
+        cache_ttl_seconds: float = 300,
+        clock: Callable[[], float] = time.monotonic,
+    ) -> None:
+        self._accounts = accounts
+        self._backend_factory = backend_factory
+        self._cache_ttl_seconds = max(1.0, float(cache_ttl_seconds))
+        self._clock = clock
+        self._lock = RLock()
+        self._expires_at = 0.0
+        self._account_signature: tuple[tuple[str, int], ...] = ()
+        self._anonymous_models: dict[str, dict[str, Any]] = {}
+        self._models_by_account_type: dict[str, dict[str, dict[str, Any]]] = {}
+
+    @staticmethod
+    def _model_map(result: object) -> dict[str, dict[str, Any]]:
+        if not isinstance(result, dict) or not isinstance(result.get("data"), list):
+            raise TypeError("upstream model response has no data list")
+        models: dict[str, dict[str, Any]] = {}
+        for item in result["data"]:
+            if not isinstance(item, dict):
+                continue
+            model_id = str(item.get("id") or "").strip()
+            if model_id and model_id not in models:
+                models[model_id] = dict(item)
+        return models
+
+    def _active_accounts_by_type(self) -> dict[str, list[str]]:
+        groups: dict[str, list[str]] = {}
+        for account in self._accounts.list_accounts():
+            if not isinstance(account, dict) or account.get("status") in {"禁用", "异常"}:
+                continue
+            access_token = str(account.get("access_token") or "").strip()
+            account_type = self._accounts._normalize_account_type(account.get("type"))
+            if access_token and account_type:
+                groups.setdefault(account_type, []).append(access_token)
+        return groups
+
+    @staticmethod
+    def _signature(groups: dict[str, list[str]]) -> tuple[tuple[str, int], ...]:
+        return tuple(
+            (account_type, len(tokens))
+            for account_type, tokens in sorted(groups.items())
+        )
+
+    def _fetch_models(self, access_token: str = "") -> dict[str, dict[str, Any]]:
+        backend = self._backend_factory(access_token=access_token)
+        try:
+            return self._model_map(backend.list_models())
+        finally:
+            backend.close()
+
+    def _fetch_account_type_models(
+        self,
+        account_type: str,
+        access_tokens: list[str],
+    ) -> dict[str, dict[str, Any]] | None:
+        attempted_tokens: set[str] = set()
+        last_error: Exception | None = None
+        for access_token in access_tokens:
+            try:
+                resolved_token = self._accounts.refresh_access_token(
+                    access_token,
+                    event="list_models",
+                ) or access_token
+                if resolved_token in attempted_tokens:
+                    continue
+                attempted_tokens.add(resolved_token)
+                return self._fetch_models(resolved_token)
+            except Exception as exc:  # noqa: BLE001 - try the next account for any upstream failure
+                last_error = exc
+        if last_error is not None:
+            logger.warning({
+                "event": "model_catalog_account_type_failed",
+                "account_type": account_type,
+                "error_type": type(last_error).__name__,
+            })
+        return None
+
+    def _refresh(self, groups: dict[str, list[str]], signature: tuple[tuple[str, int], ...]) -> None:
+        models_by_account_type: dict[str, dict[str, dict[str, Any]]] = {}
+        with ThreadPoolExecutor(max_workers=min(4, len(groups) + 1)) as executor:
+            anonymous_future = executor.submit(self._fetch_models)
+            account_futures = {
+                account_type: executor.submit(
+                    self._fetch_account_type_models,
+                    account_type,
+                    access_tokens,
+                )
+                for account_type, access_tokens in groups.items()
+            }
+            try:
+                anonymous_models = anonymous_future.result()
+            except Exception as exc:  # noqa: BLE001 - retain cached models on upstream failure
+                logger.warning({
+                    "event": "model_catalog_anonymous_failed",
+                    "error_type": type(exc).__name__,
+                })
+                anonymous_models = self._anonymous_models
+
+            for account_type, future in account_futures.items():
+                models = future.result()
+                if models is not None:
+                    models_by_account_type[account_type] = models
+                elif account_type in self._models_by_account_type:
+                    models_by_account_type[account_type] = self._models_by_account_type[account_type]
+
+        self._anonymous_models = anonymous_models
+        self._models_by_account_type = models_by_account_type
+        self._account_signature = signature
+        self._expires_at = self._clock() + self._cache_ttl_seconds
+
+    def _ensure_catalog(self) -> None:
+        groups = self._active_accounts_by_type()
+        signature = self._signature(groups)
+        with self._lock:
+            if signature == self._account_signature and self._clock() < self._expires_at:
+                return
+            self._refresh(groups, signature)
+
+    def list_models(self) -> dict[str, Any]:
+        self._ensure_catalog()
+        with self._lock:
+            union: dict[str, dict[str, Any]] = {
+                model_id: dict(item)
+                for model_id, item in self._anonymous_models.items()
+            }
+            for account_type in sorted(self._models_by_account_type):
+                for model_id, item in self._models_by_account_type[account_type].items():
+                    union.setdefault(model_id, dict(item))
+        return {
+            "object": "list",
+            "data": [union[model_id] for model_id in sorted(union)],
+        }
+
+    def route_for_model(self, model: str) -> ModelRoute:
+        model = str(model or "").strip()
+        self._ensure_catalog()
+        with self._lock:
+            account_types = frozenset(
+                account_type
+                for account_type, models in self._models_by_account_type.items()
+                if model in models
+            )
+            return ModelRoute(
+                account_types=account_types,
+                allow_anonymous=model in self._anonymous_models,
+            )
+
+
+model_catalog_service = ModelCatalogService(account_service)