videoconverter-worker 1.0.2__tar.gz → 1.0.4__tar.gz

{videoconverter_worker-1.0.2 → videoconverter_worker-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: videoconverter-worker
-Version: 1.0.2
+Version: 1.0.4
 Summary: VideoConverter Python Worker：从 queue 目录读取任务并执行切分/去字幕/合成
 License: MIT
 Keywords: videoconverter,ffmpeg,worker,video

{videoconverter_worker-1.0.2 → videoconverter_worker-1.0.4}/ffmpeg_runner.py

@@ -285,13 +285,15 @@ def split_video_to_chunks(
         })
         logger.info("切分完成: %s (%.1f - %.1f秒)", chunk_id, ch_start, ch_end)
 
+    _now = __import__("datetime").datetime.utcnow()
     metadata = {
         "videoId": video_id,
         "originalPath": video_path,
         "chunkSize": chunk_size_sec,
         "totalChunks": total_chunks,
         "chunks": chunks,
-        "createdAt": __import__("datetime").datetime.utcnow().isoformat() + "Z",
+        "createdAt": _now.isoformat() + "Z",
+        "splitStartedAt": _now.isoformat() + "Z",
     }
     meta_path = chunk_dir / "metadata.json"
     with open(meta_path, "w", encoding="utf-8") as f:
@@ -301,20 +303,33 @@ def split_video_to_chunks(
 
 
 def merge_chunks(metadata: dict, start_time: float, end_time: float, output_path: str) -> bool:
-    """合并已处理的 chunk（按 startTime 排序，concat + 可选 trim）。"""
+    """合并已处理的 chunk（按 startTime 排序，concat + 可选 trim）。processedPath 支持相对路径（相对 output_dir/video_id）或绝对路径。"""
     chunks = metadata.get("chunks") or []
     processed = [c for c in chunks if c.get("status") == "processed" and c.get("processedPath")]
-    processed = [c for c in processed if Path(c["processedPath"]).exists()]
+    out_path = Path(output_path)
+    video_id = metadata.get("videoId") or ""
+    chunk_dir = out_path.parent / video_id if video_id else out_path.parent
+
+    def resolve_path(c: dict) -> Path:
+        raw = c["processedPath"]
+        p = Path(raw)
+        if p.is_absolute():
+            return p.resolve()
+        return (chunk_dir / raw).resolve()
+
+    processed = [c for c in processed if resolve_path(c).exists()]
     if not processed:
         raise ValueError("没有可用的已处理小块")
     processed.sort(key=lambda c: c["startTime"])
 
     with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
         for c in processed:
-            f.write(f"file '{Path(c['processedPath']).resolve()}'\n")
+            p = resolve_path(c)
+            # FFmpeg concat 列表：路径中单引号须转义为 '\''
+            path_str = str(p).replace("'", "'\\''")
+            f.write(f"file '{path_str}'\n")
         list_path = f.name
     try:
-        out_path = Path(output_path)
         tmp_concat = out_path.parent / f"chunk_merge_{os.getpid()}.mp4"
         tmp_trim = out_path.parent / f"chunk_trim_{os.getpid()}.mp4"
         try:

{videoconverter_worker-1.0.2 → videoconverter_worker-1.0.4}/metadata.py

@@ -54,13 +54,15 @@ def update_chunk_processed(metadata_path: str, chunk_id: str, processed_path: st
 
     def _do_update():
         data = load_metadata(metadata_path)
+        # 存相对路径（相对 metadata 所在目录），便于移动 output 目录后仍可合并
+        rel_path = processed_path_obj.name
         for chunk in data.get("chunks") or []:
             if chunk.get("chunkId") == chunk_id:
-                chunk["processedPath"] = processed_path
+                chunk["processedPath"] = rel_path
                 chunk["status"] = "processed"
                 chunk["processedAt"] = __import__("datetime").datetime.utcnow().isoformat() + "Z"
                 save_metadata(metadata_path, data)
-                logger.info("已更新 metadata 中 chunk %s 为已处理: %s", chunk_id, processed_path)
+                logger.info("已更新 metadata 中 chunk %s 为已处理: %s", chunk_id, rel_path)
                 return
         logger.warning("未在 metadata 中找到 chunk: %s", chunk_id)
 
@@ -71,5 +73,9 @@ def update_chunk_processed(metadata_path: str, chunk_id: str, processed_path: st
                 _do_update()
             finally:
                 fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+        try:
+            lock_path.unlink(missing_ok=True)
+        except OSError:
+            pass
     else:
         _do_update()

{videoconverter_worker-1.0.2 → videoconverter_worker-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "videoconverter-worker"
-version = "1.0.2"
+version = "1.0.4"
 description = "VideoConverter Python Worker：从 queue 目录读取任务并执行切分/去字幕/合成"
 readme = "README.txt"
 requires-python = ">=3.8"

{videoconverter_worker-1.0.2 → videoconverter_worker-1.0.4}/videoconverter_worker.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: videoconverter-worker
-Version: 1.0.2
+Version: 1.0.4
 Summary: VideoConverter Python Worker：从 queue 目录读取任务并执行切分/去字幕/合成
 License: MIT
 Keywords: videoconverter,ffmpeg,worker,video

{videoconverter_worker-1.0.2 → videoconverter_worker-1.0.4}/worker.py

@@ -8,6 +8,7 @@ Python Worker：从 queue 目录读取任务并执行切分/去字幕/合成，
 import argparse
 import logging
 import sys
+import threading
 import time
 from pathlib import Path
 
@@ -30,6 +31,19 @@ logging.basicConfig(
 logger = logging.getLogger("worker")
 
 
+def _desub_spinner(stop_event: threading.Event) -> None:
+    """去字幕阶段同一行跑马灯，避免用户以为死机。"""
+    i = 0
+    while not stop_event.wait(0.25):
+        dots = "." * ((i % 3) + 1)
+        try:
+            sys.stderr.write("\r  [INFO] worker: 去字幕中 " + dots + "   ")
+            sys.stderr.flush()
+        except (OSError, UnicodeEncodeError):
+            break
+        i += 1
+
+
 def process_split_task(store: QueueStore, task: dict) -> None:
     task_id = task["task_id"]
     input_file = task["input_file"]
@@ -146,6 +160,51 @@ def check_and_create_merge_task(store: QueueStore, video_id: str, output_dir: st
         logger.info("自动创建合成任务: videoId=%s, 已处理 %d/%d 块", video_id, len(processed), total)
 
 
+def _format_duration(sec: float) -> str:
+    """不足1分钟用秒，超过60秒用分钟，超过60分钟用小时。"""
+    if sec < 60:
+        return f"{sec:.1f}秒" if sec != int(sec) else f"{int(sec)}秒"
+    if sec < 3600:
+        m = int(sec // 60)
+        s = int(round(sec % 60))
+        return f"{m}分{s}秒" if s else f"{m}分"
+    h = int(sec // 3600)
+    m = int((sec % 3600) // 60)
+    s = int(round(sec % 60))
+    if m and s:
+        return f"{h}小时{m}分{s}秒"
+    if m:
+        return f"{h}小时{m}分"
+    if s:
+        return f"{h}小时{s}秒"
+    return f"{h}小时"
+
+
+def _log_split_to_merge_duration(data: dict, task_id: str, store: QueueStore) -> None:
+    """若 metadata 含 splitStartedAt，则计算并输出从切分到合成结束的总时长与产能预估。"""
+    s = data.get("splitStartedAt") or ""
+    if not s:
+        return
+    try:
+        from datetime import datetime, timezone
+        ts = datetime.fromisoformat(s.replace("Z", "+00:00"))
+        if ts.tzinfo is None:
+            ts = ts.replace(tzinfo=timezone.utc)
+        duration_sec = (datetime.now(timezone.utc) - ts).total_seconds()
+        if duration_sec < 0:
+            return
+        msg = f"从切分到合成结束总时长: {_format_duration(duration_sec)}"
+        processed = get_processed_chunks(data)
+        if processed and duration_sec > 0:
+            src_duration_sec = processed[-1]["endTime"] - processed[0]["startTime"]
+            capacity = (src_duration_sec / 3600.0) / (duration_sec / 3600.0)
+            msg += f"，产能预估: 约 {capacity:.2f} 原视频小时/小时"
+        logger.info("videoId=%s %s", data.get("videoId", ""), msg)
+        store.add_log(task_id, "INFO", msg)
+    except Exception:
+        pass
+
+
 def process_merge_task(store: QueueStore, task: dict) -> None:
     task_id = task["task_id"]
     video_id = task.get("video_id")
@@ -174,6 +233,8 @@ def process_merge_task(store: QueueStore, task: dict) -> None:
         merge_chunks(data, start_time, end_time, str(output_file))
         store.complete_task(task_id)
         store.add_log(task_id, "INFO", f"合成完成: {output_file.name}")
+        # 从切分到合成结束总时长（若 metadata 含 splitStartedAt）
+        _log_split_to_merge_duration(data, task_id, store)
     except Exception as e:
         store.fail_task(task_id, str(e))
         store.add_log(task_id, "WARN", str(e))
@@ -286,31 +347,44 @@ def run_simple_compose(
     }
 
     logger.info("简易模式: 切分 %s (%.0f - %.0f秒), 字幕高度(裁底)=%d", input_path.name, start_sec, end_sec, crop_bottom)
+    t0 = time.time()
     metadata, video_id = split_video_to_chunks(input_file, output_dir, 120.0, start_sec, end_sec)
     chunk_list = [c for c in (metadata.get("chunks") or []) if c.get("originalPath")]
     logger.info("切分完成: %d 块，开始去字幕", len(chunk_list))
 
-    for ch in chunk_list:
-        rel = ch.get("originalPath", "")
-        if not rel:
-            continue
-        chunk_path = Path(output_dir) / rel
-        if not chunk_path.exists():
-            continue
-        chunk_id = ch.get("chunkId", "")
-        out_dir_v = Path(output_dir) / video_id
-        out_dir_v.mkdir(parents=True, exist_ok=True)
-        output_file = out_dir_v / (Path(chunk_path).stem + "_desub.mp4")
-        cfg = dict(config)
-        cfg["inputPath"] = str(chunk_path)
-        cfg["outputPath"] = str(output_file)
-        cfg["startTime"] = 0
-        cfg["endTime"] = 0
-        cfg["forceKeyframeAtStart"] = True
-        run_desubtitle(cfg, str(chunk_path), str(output_file))
-        meta_path = Path(output_dir) / video_id / "metadata.json"
-        if meta_path.exists():
-            update_chunk_processed(str(meta_path), chunk_id, str(output_file))
+    stop_spinner = threading.Event()
+    spinner = threading.Thread(target=_desub_spinner, args=(stop_spinner,), daemon=True)
+    spinner.start()
+    try:
+        for ch in chunk_list:
+            rel = ch.get("originalPath", "")
+            if not rel:
+                continue
+            chunk_path = Path(output_dir) / rel
+            if not chunk_path.exists():
+                continue
+            chunk_id = ch.get("chunkId", "")
+            out_dir_v = Path(output_dir) / video_id
+            out_dir_v.mkdir(parents=True, exist_ok=True)
+            output_file = out_dir_v / (Path(chunk_path).stem + "_desub.mp4")
+            cfg = dict(config)
+            cfg["inputPath"] = str(chunk_path)
+            cfg["outputPath"] = str(output_file)
+            cfg["startTime"] = 0
+            cfg["endTime"] = 0
+            cfg["forceKeyframeAtStart"] = True
+            run_desubtitle(cfg, str(chunk_path), str(output_file))
+            meta_path = Path(output_dir) / video_id / "metadata.json"
+            if meta_path.exists():
+                update_chunk_processed(str(meta_path), chunk_id, str(output_file))
+    finally:
+        stop_spinner.set()
+        spinner.join(timeout=1.0)
+        try:
+            sys.stderr.write("\n")
+            sys.stderr.flush()
+        except (OSError, UnicodeEncodeError):
+            pass
 
     data = load_metadata(str(Path(output_dir) / video_id / "metadata.json"))
     processed = get_processed_chunks(data)
@@ -320,7 +394,13 @@ def run_simple_compose(
     end_t = processed[-1]["endTime"]
     out_file = Path(output_dir) / f"{video_id}_merged.mp4"
     merge_chunks(data, start_t, end_t, str(out_file))
-    logger.info("简易模式完成: %s", out_file)
+    elapsed = time.time() - t0
+    src_duration_sec = end_sec - start_sec
+    capacity = (src_duration_sec / 3600.0) / (elapsed / 3600.0) if elapsed > 0 else 0
+    logger.info(
+        "简易模式完成: %s，从切分到合成结束总时长: %s，产能预估: 约 %.2f 原视频小时/小时",
+        out_file, _format_duration(elapsed), capacity,
+    )
     return str(out_file)