bilisum 1.13.2 → 1.13.3

package/runtime/apps/service/src/video_sum_service/routers/__init__.py

@@ -0,0 +1 @@
+"""FastAPI route groups for the service."""

package/runtime/apps/service/src/video_sum_service/routers/knowledge.py

@@ -0,0 +1,272 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from queue import Empty, Queue
+from threading import BoundedSemaphore, Event, Thread
+
+from fastapi import APIRouter, HTTPException, Query, Request
+from fastapi.responses import StreamingResponse
+
+from video_sum_service.context import settings_manager
+from video_sum_service.runtime_support import detect_environment
+from video_sum_service.knowledge import KnowledgeIndexService, RagService, TagService
+from video_sum_service.knowledge.local_llm import knowledge_llm_available
+from video_sum_service.repository import SqliteTaskRepository
+from video_sum_service.schemas import (
+    KnowledgeAskRequest,
+    KnowledgeAskResponse,
+    KnowledgeAutoTagRequest,
+    KnowledgeAutoTagResponse,
+    KnowledgeNetworkResponse,
+    KnowledgeRebuildResponse,
+    KnowledgeSearchRequest,
+    KnowledgeSearchResponse,
+    KnowledgeStatsResponse,
+    KnowledgeTagCreateRequest,
+    TagListResponse,
+    VideoTagListResponse,
+)
+
+router = APIRouter(prefix="/api/v1/knowledge")
+_QUEUE_TIMEOUT = object()
+_ASK_STREAM_SEMAPHORE = BoundedSemaphore(2)
+
+
+def _get_queue_item(event_queue: Queue[object], timeout: float) -> object:
+    try:
+        return event_queue.get(timeout=timeout)
+    except Empty:
+        return _QUEUE_TIMEOUT
+
+
+def _knowledge_settings_signature(settings) -> tuple[object, ...]:
+    return (
+        bool(getattr(settings, "knowledge_enabled", False)),
+        str(getattr(settings, "runtime_channel", "base") or "base"),
+        str(getattr(settings, "knowledge_index_auto_rebuild", "disabled") or "disabled"),
+        bool(settings.llm_enabled),
+        str(settings.llm_base_url or ""),
+        str(settings.llm_model or ""),
+        str(settings.llm_api_key or ""),
+        str(getattr(settings, "knowledge_llm_mode", "same_as_main") or "same_as_main"),
+        bool(getattr(settings, "knowledge_llm_enabled", False)),
+        str(getattr(settings, "knowledge_llm_base_url", "") or ""),
+        str(getattr(settings, "knowledge_llm_model", "") or ""),
+        str(getattr(settings, "knowledge_llm_api_key", "") or ""),
+    )
+
+
+def _get_services(request: Request) -> tuple[TagService, KnowledgeIndexService, RagService]:
+    task_store: SqliteTaskRepository = request.app.state.task_repository
+    settings = settings_manager.current
+    settings_signature = _knowledge_settings_signature(settings)
+    tag_service = getattr(request.app.state, "knowledge_tag_service", None)
+    index_service = getattr(request.app.state, "knowledge_index_service", None)
+    rag_service = getattr(request.app.state, "knowledge_rag_service", None)
+    cached_signature = getattr(request.app.state, "knowledge_settings_signature", None)
+
+    if tag_service is None or index_service is None or rag_service is None or cached_signature != settings_signature:
+        tag_service = TagService(task_store, settings)
+        index_service = KnowledgeIndexService(task_store, settings)
+        rag_service = RagService(task_store, index_service, tag_service, settings)
+        request.app.state.knowledge_tag_service = tag_service
+        request.app.state.knowledge_index_service = index_service
+        request.app.state.knowledge_rag_service = rag_service
+        request.app.state.knowledge_settings_signature = settings_signature
+
+    return tag_service, index_service, rag_service
+
+
+def _knowledge_runtime_ready() -> bool:
+    environment = detect_environment(settings_manager.current.runtime_channel)
+    return bool(environment.get("knowledgeDependenciesReady"))
+
+
+def _knowledge_enabled() -> bool:
+    return bool(getattr(settings_manager.current, "knowledge_enabled", False))
+
+
+def _index_video_if_ready(index_service: KnowledgeIndexService, video_id: str) -> None:
+    if _knowledge_enabled() and _knowledge_runtime_ready():
+        index_service.index_video(video_id)
+
+
+def _require_knowledge_enabled() -> None:
+    if not _knowledge_enabled():
+        raise HTTPException(
+            status_code=400,
+            detail="知识库当前未启用。请先在设置中的知识库板块开启知识库。",
+        )
+
+
+def _require_knowledge_runtime() -> None:
+    _require_knowledge_enabled()
+    if not _knowledge_runtime_ready():
+        raise HTTPException(
+            status_code=424,
+            detail="知识库依赖未安装。请先到设置中的知识库或运行时板块安装知识库依赖。",
+        )
+
+
+@router.get("/tags", response_model=TagListResponse | VideoTagListResponse)
+def get_tags(request: Request, video_id: str | None = None) -> TagListResponse | VideoTagListResponse:
+    tag_service, _index_service, _rag_service = _get_services(request)
+    if video_id:
+        return VideoTagListResponse(video_id=video_id, items=tag_service.get_tags_for_video(video_id))
+    return TagListResponse(items=tag_service.get_all_tags())
+
+
+@router.post("/tags", response_model=VideoTagListResponse)
+def create_tag(body: KnowledgeTagCreateRequest, request: Request) -> VideoTagListResponse:
+    tag_service, index_service, _rag_service = _get_services(request)
+    created = tag_service.add_tag(body.video_id, body.tag)
+    if not created:
+        raise HTTPException(status_code=404, detail="Video not found.")
+    _index_video_if_ready(index_service, body.video_id)
+    return VideoTagListResponse(video_id=body.video_id, items=tag_service.get_tags_for_video(body.video_id))
+
+
+@router.delete("/tags/{video_id}/{tag}", response_model=VideoTagListResponse)
+def delete_tag(video_id: str, tag: str, request: Request) -> VideoTagListResponse:
+    tag_service, index_service, _rag_service = _get_services(request)
+    removed = tag_service.remove_tag(video_id, tag)
+    if not removed:
+        raise HTTPException(status_code=404, detail="Tag not found.")
+    _index_video_if_ready(index_service, video_id)
+    return VideoTagListResponse(video_id=video_id, items=tag_service.get_tags_for_video(video_id))
+
+
+@router.post("/auto-tag", response_model=KnowledgeAutoTagResponse)
+def auto_tag(body: KnowledgeAutoTagRequest, request: Request) -> KnowledgeAutoTagResponse:
+    tag_service, index_service, _rag_service = _get_services(request)
+    response = tag_service.batch_auto_tag(body.video_ids)
+    for item in response.items:
+        _index_video_if_ready(index_service, item.video_id)
+    return response
+
+
+@router.get("/network", response_model=KnowledgeNetworkResponse)
+def get_network(
+    request: Request,
+    selected_tag: list[str] | None = Query(default=None),
+    max_tags: int = 12,
+    max_videos: int = 8,
+) -> KnowledgeNetworkResponse:
+    tag_service, _index_service, _rag_service = _get_services(request)
+    selected_values = selected_tag if isinstance(selected_tag, list) else None
+    return tag_service.get_network_data(selected_values, max_tags=max_tags, max_videos=max_videos)
+
+
+@router.post("/search", response_model=KnowledgeSearchResponse)
+def search_knowledge(body: KnowledgeSearchRequest, request: Request) -> KnowledgeSearchResponse:
+    _require_knowledge_runtime()
+    _tag_service, index_service, _rag_service = _get_services(request)
+    filters = body.filters.tags if body.filters is not None else []
+    results = index_service.search(body.query, limit=body.limit, tag_filter=filters)
+    return KnowledgeSearchResponse(query=body.query, results=results, total=len(results))
+
+
+@router.post("/ask", response_model=KnowledgeAskResponse)
+def ask_knowledge(body: KnowledgeAskRequest, request: Request) -> KnowledgeAskResponse:
+    _require_knowledge_runtime()
+    _tag_service, _index_service, rag_service = _get_services(request)
+    return rag_service.ask(
+        body.query,
+        context_limit=body.context_limit,
+        history=getattr(body, "history", []),
+    )
+
+
+@router.post("/ask/stream")
+async def ask_knowledge_stream(body: KnowledgeAskRequest, request: Request) -> StreamingResponse:
+    _require_knowledge_runtime()
+    _tag_service, _index_service, rag_service = _get_services(request)
+
+    async def event_generator():
+        event_queue: Queue[object] = Queue()
+        cancel_event = Event()
+
+        def produce_events() -> None:
+            acquired = _ASK_STREAM_SEMAPHORE.acquire(blocking=False)
+            if not acquired:
+                event_queue.put(
+                    HTTPException(
+                        status_code=429,
+                        detail="知识库问答任务较多，请等待当前回答结束后再试。",
+                    )
+                )
+                event_queue.put(None)
+                return
+            try:
+                for event in rag_service.ask_stream(
+                    body.query,
+                    context_limit=body.context_limit,
+                    history=getattr(body, "history", []),
+                    should_cancel=cancel_event.is_set,
+                ):
+                    if cancel_event.is_set():
+                        return
+                    event_queue.put(event)
+            except Exception as exc:  # pragma: no cover - surfaced to the SSE client below
+                event_queue.put(exc)
+            finally:
+                _ASK_STREAM_SEMAPHORE.release()
+                event_queue.put(None)
+
+        worker = Thread(target=produce_events, daemon=True, name="knowledge-ask-stream")
+        worker.start()
+
+        try:
+            while True:
+                if await request.is_disconnected():
+                    cancel_event.set()
+                    return
+                item = await asyncio.to_thread(_get_queue_item, event_queue, 1.5)
+                if item is _QUEUE_TIMEOUT:
+                    yield ": keep-alive\n\n"
+                    continue
+                if item is None:
+                    return
+                if isinstance(item, HTTPException):
+                    raise item
+                if isinstance(item, Exception):
+                    raise item
+                event_name, payload = item
+                yield f"event: {event_name}\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n"
+        except HTTPException as exc:
+            yield (
+                "event: error\n"
+                f"data: {json.dumps({'message': str(exc.detail), 'status_code': exc.status_code}, ensure_ascii=False)}\n\n"
+            )
+        except Exception as exc:  # pragma: no cover - defensive fallback
+            yield f"event: error\ndata: {json.dumps({'message': f'知识库问答失败：{exc}'}, ensure_ascii=False)}\n\n"
+        finally:
+            cancel_event.set()
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no"},
+    )
+
+
+@router.get("/stats", response_model=KnowledgeStatsResponse)
+def get_knowledge_stats(request: Request) -> KnowledgeStatsResponse:
+    tag_service, index_service, _rag_service = _get_services(request)
+    task_store: SqliteTaskRepository = request.app.state.task_repository
+    settings = settings_manager.current
+    return KnowledgeStatsResponse(
+        video_count=len(task_store.list_video_assets()),
+        indexed_chunk_count=task_store.get_knowledge_chunk_count(),
+        tag_count=len(tag_service.get_all_tags()),
+        untagged_video_count=len(task_store.list_untagged_video_ids()),
+        knowledge_llm_available=bool(settings.knowledge_enabled and knowledge_llm_available(settings)),
+    )
+
+
+@router.post("/rebuild-index", response_model=KnowledgeRebuildResponse)
+def rebuild_index(request: Request) -> KnowledgeRebuildResponse:
+    _require_knowledge_runtime()
+    _tag_service, index_service, _rag_service = _get_services(request)
+    return KnowledgeRebuildResponse(indexed_videos=index_service.rebuild_index(force=True))

package/runtime/apps/service/src/video_sum_service/routers/system.py

@@ -0,0 +1,280 @@
+import os
+import re
+import threading
+
+import httpx
+from fastapi import APIRouter, HTTPException, Request
+
+from video_sum_core.models.tasks import TaskStatus
+from video_sum_infra.runtime import (
+    activate_runtime_pythonpath,
+    bootstrap_managed_runtime,
+    log_dir,
+    prepend_runtime_path,
+    service_log_path,
+)
+
+from video_sum_service.context import app_info, logger, settings_manager
+from video_sum_service.integrations import (
+    extract_http_error_detail,
+    probe_asr_connection,
+    probe_llm_connection,
+    read_log_tail,
+)
+from video_sum_service.runtime_support import (
+    build_worker,
+    clear_environment_probe_cache,
+    detect_environment,
+    inspect_runtime_channels,
+    install_cuda_support,
+    install_knowledge_dependencies,
+    install_local_asr,
+    replace_task_worker,
+    serialize_settings,
+    sync_all_runtime_channels,
+    sync_runtime_channel,
+)
+from video_sum_service.settings_manager import SettingsUpdatePayload
+
+router = APIRouter(prefix="/api/v1")
+LATEST_RELEASE_URL = "https://api.github.com/repos/lycohana/BiliSum/releases/latest"
+
+
+def _clear_knowledge_service_cache(app_state) -> None:
+    for key in (
+        "knowledge_tag_service",
+        "knowledge_index_service",
+        "knowledge_rag_service",
+        "knowledge_settings_signature",
+    ):
+        if hasattr(app_state, key):
+            delattr(app_state, key)
+
+
+def _normalize_version(value: str | None) -> str:
+    return str(value or "").strip().removeprefix("v").removeprefix("V")
+
+
+def _version_key(value: str | None) -> tuple[int | str, ...]:
+    normalized = _normalize_version(value)
+    if not normalized:
+        return (0,)
+
+    parts: list[int | str] = []
+    for chunk in re.split(r"[.\-+_]", normalized):
+        if not chunk:
+            continue
+        parts.append(int(chunk) if chunk.isdigit() else chunk.lower())
+    return tuple(parts) or (0,)
+
+
+@router.get("/system/info")
+def system_info(runtime_channel: str | None = None, refresh: bool = False) -> dict[str, object]:
+    current_settings = settings_manager.current
+    active_channel = runtime_channel or current_settings.runtime_channel
+    if refresh:
+        clear_environment_probe_cache(active_channel)
+    environment = detect_environment(active_channel)
+    runtime_settings = current_settings.with_resolved_runtime(
+        cuda_available=bool(environment.get("cudaAvailable"))
+    )
+    return {
+        "application": {"name": app_info.name, "version": app_info.version},
+        "service": {
+            "host": current_settings.host,
+            "port": current_settings.port,
+            "data_dir": str(current_settings.data_dir),
+            "cache_dir": str(current_settings.cache_dir),
+            "tasks_dir": str(current_settings.tasks_dir),
+            "database_url": current_settings.database_url,
+            "log_dir": str(log_dir()),
+            "log_file": str(service_log_path()),
+        },
+        "runtime": {
+            "runtime_channel": active_channel,
+            "whisper_model": runtime_settings.whisper_model,
+            "whisper_device": runtime_settings.whisper_device,
+            "whisper_compute_type": runtime_settings.whisper_compute_type,
+            "llm_enabled": current_settings.llm_enabled,
+            "llm_model": current_settings.llm_model,
+        },
+        "taskModel": {"statuses": [status.value for status in TaskStatus]},
+        "environment": environment,
+    }
+
+
+@router.get("/settings")
+def get_settings() -> dict[str, object]:
+    return serialize_settings(settings_manager.current)
+
+
+@router.get("/app/update")
+def get_app_update() -> dict[str, object]:
+    current_version = app_info.version
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "User-Agent": f"{app_info.name}/{current_version}",
+    }
+
+    try:
+        with httpx.Client(timeout=20, follow_redirects=True, headers=headers) as client:
+            response = client.get(LATEST_RELEASE_URL)
+    except httpx.HTTPError as exc:
+        raise HTTPException(status_code=502, detail=f"获取最新版本信息失败：{exc}") from exc
+
+    if response.status_code >= 400:
+        detail = extract_http_error_detail(response)
+        raise HTTPException(status_code=response.status_code, detail=f"获取最新版本信息失败：{detail}")
+
+    try:
+        payload = response.json()
+    except ValueError as exc:
+        raise HTTPException(status_code=502, detail="获取最新版本信息失败：响应格式无效。") from exc
+
+    latest_version = _normalize_version(payload.get("tag_name") or payload.get("name") or current_version)
+    if not latest_version:
+        raise HTTPException(status_code=502, detail="获取最新版本信息失败：缺少版本号。")
+
+    current_key = _version_key(current_version)
+    latest_key = _version_key(latest_version)
+    is_newer_available = latest_key > current_key
+
+    return {
+        "status": "available" if is_newer_available else "not-available",
+        "version": latest_version if is_newer_available else _normalize_version(current_version),
+        "releaseDate": payload.get("published_at") or payload.get("created_at") or "",
+        "releaseNotes": str(payload.get("body") or "").strip() or None,
+        "downloadProgress": 0,
+        "errorMessage": None,
+    }
+
+
+@router.put("/settings")
+def update_settings(payload: SettingsUpdatePayload, request: Request) -> dict[str, object]:
+    previous_settings = settings_manager.current
+    current_settings = settings_manager.save(payload)
+    bootstrap_managed_runtime(current_settings.runtime_channel)
+    prepend_runtime_path(current_settings.runtime_channel)
+    activate_runtime_pythonpath(current_settings.runtime_channel)
+    current_settings.data_dir.mkdir(parents=True, exist_ok=True)
+    current_settings.cache_dir.mkdir(parents=True, exist_ok=True)
+    current_settings.tasks_dir.mkdir(parents=True, exist_ok=True)
+    runtime_channel_changed = previous_settings.runtime_channel != current_settings.runtime_channel
+    if runtime_channel_changed:
+        clear_environment_probe_cache(previous_settings.runtime_channel)
+        clear_environment_probe_cache(current_settings.runtime_channel)
+        _clear_knowledge_service_cache(request.app.state)
+    environment = detect_environment(current_settings.runtime_channel)
+    replace_task_worker(
+        request.app.state,
+        build_worker(
+            request.app.state.task_repository,
+            current_settings,
+            environment_info=environment,
+        ),
+    )
+    return {
+        "saved": True,
+        "settings": serialize_settings(current_settings, environment_info=environment),
+        "message": "设置已保存。涉及服务监听地址的修改将在下次启动后生效。",
+    }
+
+
+@router.post("/llm/test")
+def post_llm_test(payload: SettingsUpdatePayload | None = None) -> dict[str, object]:
+    return probe_llm_connection(payload)
+
+
+@router.post("/asr/test")
+def post_asr_test(payload: SettingsUpdatePayload | None = None) -> dict[str, object]:
+    return probe_asr_connection(payload)
+
+
+@router.get("/environment")
+def get_environment(runtime_channel: str | None = None, refresh: bool = False) -> dict[str, object]:
+    active_channel = runtime_channel or settings_manager.current.runtime_channel
+    if refresh:
+        clear_environment_probe_cache(active_channel)
+    return detect_environment(active_channel)
+
+
+@router.get("/runtime/status")
+def get_runtime_status() -> dict[str, object]:
+    return inspect_runtime_channels()
+
+
+@router.post("/runtime/sync")
+def post_runtime_sync(request: Request, payload: dict[str, object] | None = None) -> dict[str, object]:
+    requested_channel = str((payload or {}).get("runtime_channel") or (payload or {}).get("runtimeChannel") or "").strip()
+    try:
+        result = sync_runtime_channel(requested_channel) if requested_channel else sync_all_runtime_channels()
+        _clear_knowledge_service_cache(request.app.state)
+
+        current_settings = settings_manager.current
+        environment = detect_environment(current_settings.runtime_channel)
+        replace_task_worker(
+            request.app.state,
+            build_worker(
+                request.app.state.task_repository,
+                current_settings,
+                environment_info=environment,
+            ),
+        )
+        return {
+            **result,
+            "environment": environment,
+            "runtimeStatus": inspect_runtime_channels(),
+        }
+    except HTTPException:
+        raise
+    except Exception as exc:
+        logger.exception("runtime sync failed requested_channel=%s error=%s", requested_channel or "all", exc)
+        raise HTTPException(status_code=500, detail=f"运行时同步失败：{exc}") from exc
+
+
+@router.get("/system/logs")
+def get_system_logs(lines: int = 200) -> dict[str, object]:
+    line_count = max(20, min(int(lines), 1000))
+    return {
+        "path": str(service_log_path()),
+        "lines": line_count,
+        "content": read_log_tail(line_count),
+    }
+
+
+@router.post("/system/shutdown")
+def shutdown_service(request: Request) -> dict[str, object]:
+    def shutdown() -> None:
+        task_worker = getattr(request.app.state, "task_worker", None)
+        if task_worker is not None:
+            task_worker.shutdown(wait=False)
+        os._exit(0)
+
+    threading.Timer(0.5, shutdown).start()
+    return {"shuttingDown": True, "message": "服务正在关闭。"}
+
+
+@router.post("/cuda/install")
+def post_cuda_install(payload: dict[str, object], request: Request) -> dict[str, object]:
+    requested_variant = payload.get("cuda_variant", payload.get("cudaVariant", "cu128"))
+    result, worker = install_cuda_support(str(requested_variant), request.app.state.task_repository)
+    _clear_knowledge_service_cache(request.app.state)
+    replace_task_worker(request.app.state, worker)
+    return result
+
+
+@router.post("/asr/local/install")
+def post_local_asr_install(request: Request, payload: dict[str, object] | None = None) -> dict[str, object]:
+    reinstall = bool((payload or {}).get("reinstall"))
+    result, worker = install_local_asr(reinstall=reinstall, repository=request.app.state.task_repository)
+    replace_task_worker(request.app.state, worker)
+    return result
+
+
+@router.post("/knowledge/install")
+def post_knowledge_install(request: Request, payload: dict[str, object] | None = None) -> dict[str, object]:
+    reinstall = bool((payload or {}).get("reinstall"))
+    result, worker = install_knowledge_dependencies(reinstall=reinstall, repository=request.app.state.task_repository)
+    _clear_knowledge_service_cache(request.app.state)
+    replace_task_worker(request.app.state, worker)
+    return result