bilisum 1.13.2 → 1.13.3

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

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+
+
+logger = logging.getLogger("video_sum_core.transcribe_subprocess")
+
+
+def configure_logging() -> None:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s %(name)s | %(message)s",
+    )
+
+
+def write_progress(progress_path: Path, payload: dict[str, object]) -> None:
+    with progress_path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
+        handle.flush()
+
+
+def configure_runtime_library_dirs() -> None:
+    raw_paths = os.environ.get("VIDEO_SUM_DLL_PATHS", "")
+    if not raw_paths:
+        return
+    dll_paths: list[str] = []
+    for entry in raw_paths.split(os.pathsep):
+        path = entry.strip()
+        if path and path not in dll_paths and Path(path).exists():
+            dll_paths.append(path)
+
+    if not dll_paths:
+        return
+
+    os.environ["PATH"] = os.pathsep.join([*dll_paths, os.environ.get("PATH", "")])
+    add_dll_directory = getattr(os, "add_dll_directory", None)
+    if add_dll_directory is None:
+        return
+    for path in dll_paths:
+        try:
+            add_dll_directory(path)
+        except OSError:
+            logger.debug("skip dll directory path=%s", path, exc_info=True)
+
+
+def transcribe(
+    audio_path: Path,
+    model_name: str,
+    device: str,
+    compute_type: str,
+    progress_path: Path,
+    output_path: Path,
+    duration: float | None,
+) -> None:
+    configure_runtime_library_dirs()
+    from faster_whisper import WhisperModel
+
+    logger.info(
+        "child transcription start audio=%s model=%s device=%s compute_type=%s",
+        audio_path,
+        model_name,
+        device,
+        compute_type,
+    )
+    model = WhisperModel(model_name, device=device, compute_type=compute_type)
+    raw_segments, _info = model.transcribe(str(audio_path), language="zh", vad_filter=True)
+
+    segments: list[dict[str, object]] = []
+    transcript_lines: list[str] = []
+    last_reported_progress = 58
+
+    for segment in raw_segments:
+        item = {
+            "start": round(segment.start, 3),
+            "end": round(segment.end, 3),
+            "text": segment.text.strip(),
+        }
+        segments.append(item)
+        transcript_lines.append(f"[{format_timestamp(item['start'])}] {item['text']}")
+
+        if duration and duration > 0:
+            progress = min(82, 58 + int((float(segment.end) / float(duration)) * 24))
+        else:
+            progress = min(82, 58 + min(24, len(segments)))
+
+        if progress > last_reported_progress:
+            last_reported_progress = progress
+            write_progress(
+                progress_path,
+                {
+                    "stage": "transcribing",
+                    "progress": progress,
+                    "message": f"正在转写，已识别 {len(segments)} 段",
+                    "payload": {
+                        "segment_count": len(segments),
+                        "current_time": round(float(segment.end), 3),
+                    },
+                },
+            )
+
+    transcript = "\n".join(transcript_lines)
+    if not transcript.strip():
+        raise RuntimeError("Transcription produced empty output.")
+
+    write_progress(
+        progress_path,
+        {
+            "stage": "transcribing",
+            "progress": 84,
+            "message": f"转写完成，共识别 {len(segments)} 段",
+            "payload": {"segment_count": len(segments)},
+        },
+    )
+    output_path.write_text(
+        json.dumps({"transcript": transcript, "segments": segments}, ensure_ascii=False),
+        encoding="utf-8",
+    )
+    logger.info(
+        "child transcription finish audio=%s segments=%d transcript_chars=%d",
+        audio_path,
+        len(segments),
+        len(transcript),
+    )
+
+
+def format_timestamp(seconds: float) -> str:
+    total = max(0, int(seconds))
+    hours = total // 3600
+    minutes = (total % 3600) // 60
+    secs = total % 60
+    if hours:
+        return f"{hours:02d}:{minutes:02d}:{secs:02d}"
+    return f"{minutes:02d}:{secs:02d}"
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run faster-whisper transcription in an isolated subprocess.")
+    parser.add_argument("--audio-path", required=True)
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--device", required=True)
+    parser.add_argument("--compute-type", required=True)
+    parser.add_argument("--progress-path", required=True)
+    parser.add_argument("--output-path", required=True)
+    parser.add_argument("--duration", type=float)
+    return parser.parse_args()
+
+
+def main() -> int:
+    configure_logging()
+    args = parse_args()
+    try:
+        transcribe(
+            audio_path=Path(args.audio_path),
+            model_name=args.model,
+            device=args.device,
+            compute_type=args.compute_type,
+            progress_path=Path(args.progress_path),
+            output_path=Path(args.output_path),
+            duration=args.duration,
+        )
+    except Exception:
+        logger.exception("child transcription failed")
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.parse import parse_qs, urlencode, urlparse
+
+
+@dataclass(frozen=True, slots=True)
+class NormalizedVideoUrl:
+    normalized_url: str
+    canonical_id: str
+    platform: str = "unknown"
+    page_number: int | None = None
+
+    def __iter__(self):
+        # Backward-compatible tuple unpacking for existing call sites.
+        yield self.normalized_url
+        yield self.canonical_id
+
+
+def normalize_video_url(value: str) -> NormalizedVideoUrl:
+    raw = (value or "").strip()
+    if not raw:
+        return NormalizedVideoUrl(normalized_url="", canonical_id="")
+
+    match = re.search(r"(BV[0-9A-Za-z]+)", raw, flags=re.IGNORECASE)
+    if match:
+        bvid = match.group(1)
+        normalized_url = f"https://www.bilibili.com/video/{bvid}"
+        page = extract_bilibili_page(raw)
+        if page is not None:
+            normalized_url = f"{normalized_url}?{urlencode({'p': page})}"
+        return NormalizedVideoUrl(
+            normalized_url=normalized_url,
+            canonical_id=bvid,
+            platform="bilibili",
+            page_number=page,
+        )
+
+    youtube_id = extract_youtube_video_id(raw)
+    if youtube_id:
+        return NormalizedVideoUrl(
+            normalized_url=f"https://www.youtube.com/watch?v={youtube_id}",
+            canonical_id=youtube_id,
+            platform="youtube",
+        )
+
+    return NormalizedVideoUrl(normalized_url=raw, canonical_id="")
+
+
+def extract_bilibili_page(value: str) -> int | None:
+    raw = (value or "").strip()
+    if not raw:
+        return None
+
+    if not re.search(r"(BV[0-9A-Za-z]+|bilibili\.com|b23\.tv)", raw, flags=re.IGNORECASE):
+        return None
+
+    try:
+        parsed = urlparse(raw)
+        query = parse_qs(parsed.query)
+        page_value = query.get("p", [None])[0]
+    except ValueError:
+        page_value = None
+
+    if page_value is None:
+        match = re.search(r"[?&]p=(\d+)", raw, flags=re.IGNORECASE)
+        page_value = match.group(1) if match else None
+
+    if page_value is None:
+        return None
+
+    try:
+        page = int(str(page_value))
+    except (TypeError, ValueError):
+        return None
+    return page if page > 0 else None
+
+
+def extract_youtube_video_id(value: str) -> str | None:
+    raw = (value or "").strip()
+    if not raw:
+        return None
+
+    try:
+        parsed = urlparse(raw)
+    except ValueError:
+        parsed = None
+
+    if parsed is not None:
+        host = parsed.netloc.lower()
+        path = parsed.path or ""
+
+        if host.endswith("youtu.be"):
+            candidate = path.strip("/").split("/", 1)[0]
+            return candidate or None
+
+        if "youtube.com" in host:
+            if path == "/watch":
+                candidate = parse_qs(parsed.query).get("v", [None])[0]
+                return str(candidate).strip() or None
+            if path.startswith("/shorts/"):
+                candidate = path.split("/", 3)[2] if len(path.split("/")) > 2 else ""
+                return candidate.strip() or None
+
+    return None
+
+
+def sanitize_filename(value: str) -> str:
+    sanitized = re.sub(r"[\\/:*?\"<>|]+", "_", value).strip()
+    return sanitized[:120] or "video_summary"
+
+
+def ensure_directory(path: Path) -> Path:
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def format_timestamp(seconds: float) -> str:
+    total = max(0, int(seconds))
+    hours = total // 3600
+    minutes = (total % 3600) // 60
+    remaining = total % 60
+    if hours:
+        return f"{hours:02d}:{minutes:02d}:{remaining:02d}"
+    return f"{minutes:02d}:{remaining:02d}"

package/runtime/packages/infra/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["hatchling>=1.27.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "video-sum-infra"
+version = "1.13.3"
+description = "Infrastructure layer for the local video summarizer."
+requires-python = ">=3.12"
+dependencies = [
+  "pydantic>=2.10,<3.0",
+  "pydantic-settings>=2.7,<3.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/video_sum_infra"]

package/runtime/packages/infra/src/video_sum_infra/__init__.py

@@ -0,0 +1 @@
+"""Infrastructure package for local video summarizer."""

package/runtime/packages/infra/src/video_sum_infra/app.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from importlib import metadata
+from pathlib import Path
+import sys
+
+
+@dataclass(slots=True)
+class AppInfo:
+    name: str
+    version: str
+
+    @classmethod
+    def load(cls) -> "AppInfo":
+        return cls(name="BiliSum", version=_resolve_version())
+
+
+def _resolve_version() -> str:
+    version_file = Path(__file__).resolve().parents[4] / "VERSION"
+
+    # In local development, prefer the workspace VERSION file so the UI reflects
+    # the checked-out repo version immediately without reinstalling packages.
+    if version_file.exists() and not _is_running_from_installed_dist():
+        return version_file.read_text(encoding="utf-8").strip()
+
+    for distribution_name in ("video-sum-service", "video-sum-infra"):
+        try:
+            return metadata.version(distribution_name)
+        except metadata.PackageNotFoundError:
+            continue
+
+    if version_file.exists():
+        return version_file.read_text(encoding="utf-8").strip()
+    return "0.0.0"
+
+
+def _is_running_from_installed_dist() -> bool:
+    base_prefix = Path(getattr(sys, "base_prefix", sys.prefix)).resolve()
+    current_file = Path(__file__).resolve()
+    return base_prefix in current_file.parents