bilisum 1.13.2 → 1.13.3

package/runtime/packages/core/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["hatchling>=1.27.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "video-sum-core"
+version = "1.13.3"
+description = "Core domain logic for the local video summarizer."
+requires-python = ">=3.12"
+dependencies = [
+  "pydantic>=2.10,<3.0",
+  "yt-dlp>=2025.3.31",
+  "httpx>=0.28,<1.0",
+  "video-sum-infra",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/video_sum_core"]

package/runtime/packages/core/src/video_sum_core/__init__.py

@@ -0,0 +1 @@
+"""Core package for local video summarization."""

package/runtime/packages/core/src/video_sum_core/errors.py

@@ -0,0 +1,22 @@
+class VideoSumError(Exception):
+    """Base application error for core domain logic."""
+
+
+class LLMConfigurationError(VideoSumError):
+    """Raised when LLM settings are incomplete or invalid for the current request."""
+
+
+class LLMAuthenticationError(VideoSumError):
+    """Raised when the upstream LLM provider rejects the supplied credentials."""
+
+
+class TranscriptionConfigurationError(VideoSumError):
+    """Raised when transcription provider settings are incomplete or invalid."""
+
+
+class TranscriptionAuthenticationError(VideoSumError):
+    """Raised when the upstream transcription provider rejects the supplied credentials."""
+
+
+class UnsupportedInputError(VideoSumError):
+    """Raised when an input type is not supported by the current pipeline."""

package/runtime/packages/core/src/video_sum_core/markdown_exports.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from datetime import datetime
+import json
+import re
+from pathlib import Path
+
+from video_sum_core.utils import sanitize_filename
+
+
+def build_export_filename(title: str, export_time: datetime) -> str:
+    safe_title = re.sub(r"\s+", " ", sanitize_filename(str(title or "").strip())).strip(" .")
+    if not safe_title:
+        safe_title = "BiliSum Note"
+    return f"{safe_title} {export_time.date().isoformat()}.md"
+
+
+def build_task_markdown_export(
+    *,
+    title: str,
+    overview: str,
+    knowledge_note_markdown: str,
+    key_points: list[str],
+    timeline: list[dict[str, object]],
+    source_url: str,
+    platform: str,
+    video_id: str | None,
+    canonical_id: str | None,
+    task_id: str,
+    created_at: datetime,
+    exported_at: datetime,
+    tags: list[str],
+    target: str = "obsidian",
+    mindmap_path: str | None = None,
+) -> str:
+    normalized_title = str(title or "").strip() or "BiliSum 知识笔记"
+    body = _build_markdown_body(
+        title=normalized_title,
+        overview=overview,
+        knowledge_note_markdown=knowledge_note_markdown,
+        key_points=key_points,
+        timeline=timeline,
+        mindmap_path=mindmap_path,
+    )
+    if str(target or "obsidian").strip().lower() != "obsidian":
+        return body
+
+    frontmatter = _build_frontmatter(
+        {
+            "title": normalized_title,
+            "source_url": str(source_url or ""),
+            "platform": str(platform or ""),
+            "video_id": str(video_id or ""),
+            "canonical_id": str(canonical_id or ""),
+            "task_id": str(task_id or ""),
+            "created_at": created_at.isoformat(),
+            "exported_at": exported_at.isoformat(),
+            "tags": [str(tag).strip() for tag in tags if str(tag).strip()],
+        }
+    )
+    return f"{frontmatter}\n\n{body}".strip()
+
+
+def _build_frontmatter(payload: dict[str, object]) -> str:
+    lines = ["---"]
+    for key, value in payload.items():
+        if isinstance(value, list):
+            lines.append(f"{key}:")
+            for item in value:
+                lines.append(f"  - {json.dumps(str(item), ensure_ascii=False)}")
+            continue
+        lines.append(f"{key}: {json.dumps(str(value or ''), ensure_ascii=False)}")
+    lines.append("---")
+    return "\n".join(lines)
+
+
+def _build_markdown_body(
+    *,
+    title: str,
+    overview: str,
+    knowledge_note_markdown: str,
+    key_points: list[str],
+    timeline: list[dict[str, object]],
+    mindmap_path: str | None,
+) -> str:
+    sections = [
+        f"# {title}",
+        "## 核心概览",
+        str(overview or "").strip() or "暂无核心概览。",
+        "## 关键要点",
+        _format_key_points(key_points),
+        "## 章节时间线",
+        _format_timeline(timeline),
+        "## 知识笔记",
+        _normalize_embedded_note(knowledge_note_markdown, title),
+    ]
+    if str(mindmap_path or "").strip():
+        sections.extend(
+            [
+                "## 思维导图引用信息",
+                f"- 导图文件：`{Path(str(mindmap_path)).as_posix()}`",
+            ]
+        )
+    return "\n\n".join(section.strip() for section in sections if str(section).strip())
+
+
+def _format_key_points(key_points: list[str]) -> str:
+    items = [str(item).strip() for item in key_points if str(item).strip()]
+    if not items:
+        return "- 暂无关键要点。"
+    return "\n".join(f"- {item}" for item in items)
+
+
+def _format_timeline(timeline: list[dict[str, object]]) -> str:
+    items: list[str] = []
+    for entry in timeline:
+        title = str(entry.get("title") or "").strip() or "未命名章节"
+        summary = str(entry.get("summary") or "").strip()
+        start = _format_timestamp(entry.get("start"))
+        line = f"- `{start}` **{title}**"
+        if summary:
+            line = f"{line}: {summary}"
+        items.append(line)
+    if not items:
+        return "- 暂无章节时间线。"
+    return "\n".join(items)
+
+
+def _format_timestamp(value: object) -> str:
+    try:
+        total_seconds = max(0, int(float(value)))
+    except (TypeError, ValueError):
+        total_seconds = 0
+    hours, remainder = divmod(total_seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    if hours > 0:
+        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+    return f"{minutes:02d}:{seconds:02d}"
+
+
+def _normalize_embedded_note(markdown: str, title: str) -> str:
+    text = str(markdown or "").strip()
+    if not text:
+        return "暂无知识笔记正文。"
+
+    lines = text.splitlines()
+    if lines and lines[0].lstrip().startswith("#"):
+        heading_text = re.sub(r"^#+\s*", "", lines[0]).strip()
+        if heading_text == title or heading_text:
+            lines = lines[1:]
+            while lines and not lines[0].strip():
+                lines = lines[1:]
+    normalized = "\n".join(lines).strip()
+    return normalized or "暂无知识笔记正文。"

package/runtime/packages/core/src/video_sum_core/models/__init__.py

@@ -0,0 +1 @@
+"""Domain models for core package."""

package/runtime/packages/core/src/video_sum_core/models/tasks.py

@@ -0,0 +1,70 @@
+from datetime import datetime
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+
+class InputType(str, Enum):
+    URL = "url"
+    VIDEO_FILE = "video_file"
+    AUDIO_FILE = "audio_file"
+    TRANSCRIPT_TEXT = "transcript_text"
+
+
+class TaskStatus(str, Enum):
+    QUEUED = "queued"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class TaskOptions(BaseModel):
+    language: str = "zh"
+    summary_mode: str = "auto"
+    prefer_subtitles: bool = True
+    export_formats: list[str] = Field(default_factory=lambda: ["md", "json"])
+
+
+class TaskInput(BaseModel):
+    input_type: InputType
+    source: str
+    title: str | None = None
+    platform_hint: str | None = None
+    options: TaskOptions = Field(default_factory=TaskOptions)
+
+
+class TaskResult(BaseModel):
+    overview: str = ""
+    knowledge_note_markdown: str = ""
+    transcript_text: str = ""
+    segment_summaries: list[str] = Field(default_factory=list)
+    key_points: list[str] = Field(default_factory=list)
+    timeline: list[dict[str, object]] = Field(default_factory=list)
+    chapter_groups: list[dict[str, object]] = Field(default_factory=list)
+    artifacts: dict[str, str] = Field(default_factory=dict)
+    llm_prompt_tokens: int | None = None
+    llm_completion_tokens: int | None = None
+    llm_total_tokens: int | None = None
+    mindmap_status: str = "idle"
+    mindmap_error_message: str | None = None
+    mindmap_artifact_path: str | None = None
+    mindmap_updated_at: datetime | None = None
+
+
+class MindMapNode(BaseModel):
+    id: str
+    label: str
+    type: str
+    summary: str = ""
+    children: list["MindMapNode"] = Field(default_factory=list)
+    time_anchor: float | None = None
+    source_chapter_titles: list[str] = Field(default_factory=list)
+    source_chapter_starts: list[float] = Field(default_factory=list)
+
+
+class TaskMindMap(BaseModel):
+    version: int = 1
+    title: str
+    root: str
+    nodes: list[MindMapNode] = Field(default_factory=list)

package/runtime/packages/core/src/video_sum_core/pipeline/__init__.py

@@ -0,0 +1 @@
+"""Pipeline contracts and orchestration."""

package/runtime/packages/core/src/video_sum_core/pipeline/base.py

@@ -0,0 +1,46 @@
+from typing import Callable
+
+from pydantic import BaseModel, Field
+
+from video_sum_core.models.tasks import TaskInput, TaskResult
+
+
+class PipelineEvent(BaseModel):
+    stage: str
+    progress: int = 0
+    message: str
+    payload: dict[str, object] = Field(default_factory=dict)
+
+
+class PipelineContext(BaseModel):
+    task_id: str
+    task_input: TaskInput
+
+
+PipelineEventReporter = Callable[[PipelineEvent], None]
+
+
+class PipelineRunner:
+    """Minimal orchestration contract for future pipeline implementations."""
+
+    def preflight(
+        self,
+        context: PipelineContext,
+        on_event: PipelineEventReporter | None = None,
+    ) -> None:
+        return None
+
+    def run(
+        self,
+        context: PipelineContext,
+        on_event: PipelineEventReporter | None = None,
+    ) -> tuple[list[PipelineEvent], TaskResult]:
+        event = PipelineEvent(
+            stage="accepted",
+            progress=0,
+            message="Pipeline scaffold is ready. Processing implementation is pending.",
+        )
+        if on_event is not None:
+            on_event(event)
+        result = TaskResult()
+        return [event], result