talks-reducer 0.4.1__py3-none-any.whl → 0.5.1__py3-none-any.whl

talks_reducer/pipeline.py

@@ -27,7 +27,15 @@ from .progress import NullProgressReporter, ProgressReporter
 
 def _input_to_output_filename(filename: Path, small: bool = False) -> Path:
     dot_index = filename.name.rfind(".")
-    suffix = "_speedup_small" if small else "_speedup"
+    suffix_parts = []
+
+    if small:
+        suffix_parts.append("_small")
+
+    if not suffix_parts:
+        suffix_parts.append("")  # Default case
+
+    suffix = "_speedup" + "".join(suffix_parts)
     new_name = (
         filename.name[:dot_index] + suffix + filename.name[dot_index:]
         if dot_index != -1
@@ -38,7 +46,7 @@ def _input_to_output_filename(filename: Path, small: bool = False) -> Path:
 
 def _create_path(path: Path) -> None:
     try:
-        path.mkdir()
+        path.mkdir(parents=True, exist_ok=True)
     except OSError as exc:  # pragma: no cover - defensive logging
         raise AssertionError(
             "Creation of the directory failed. (The TEMP folder may already exist. Delete or rename it, and try again.)"
@@ -74,7 +82,7 @@ def _extract_video_metadata(input_file: Path, frame_rate: float) -> Dict[str, fl
         "-select_streams",
         "v",
         "-show_entries",
-        "format=duration:stream=avg_frame_rate",
+        "format=duration:stream=avg_frame_rate,nb_frames",
     ]
     process = subprocess.Popen(
         command,
@@ -92,7 +100,14 @@ def _extract_video_metadata(input_file: Path, frame_rate: float) -> Dict[str, fl
     match_duration = re.search(r"duration=([\d.]*)", str(stdout))
     original_duration = float(match_duration.group(1)) if match_duration else 0.0
 
-    return {"frame_rate": frame_rate, "duration": original_duration}
+    match_frames = re.search(r"nb_frames=(\d+)", str(stdout))
+    frame_count = int(match_frames.group(1)) if match_frames else 0
+
+    return {
+        "frame_rate": frame_rate,
+        "duration": original_duration,
+        "frame_count": frame_count,
+    }
 
 
 def _ensure_two_dimensional(audio_data: np.ndarray) -> np.ndarray:
@@ -135,6 +150,18 @@ def speed_up_video(
     metadata = _extract_video_metadata(input_path, options.frame_rate)
     frame_rate = metadata["frame_rate"]
     original_duration = metadata["duration"]
+    frame_count = metadata.get("frame_count", 0)
+
+    reporter.log(
+        (
+            "Source metadata — duration: {duration:.2f}s, frame rate: {fps:.3f} fps,"
+            " reported frames: {frames}"
+        ).format(
+            duration=original_duration,
+            fps=frame_rate,
+            frames=frame_count if frame_count > 0 else "unknown",
+        )
+    )
 
     reporter.log("Processing on: {}".format("GPU (CUDA)" if cuda_available else "CPU"))
     if options.small:
@@ -148,10 +175,12 @@ def speed_up_video(
     audio_bitrate = "128k" if options.small else "160k"
     audio_wav = temp_path / "audio.wav"
 
+    extraction_sample_rate = options.sample_rate
+
     extract_command = build_extract_audio_command(
         os.fspath(input_path),
         os.fspath(audio_wav),
-        options.sample_rate,
+        extraction_sample_rate,
         audio_bitrate,
         hwaccel,
         ffmpeg_path=ffmpeg_path,
@@ -159,10 +188,19 @@ def speed_up_video(
 
     reporter.log("Extracting audio...")
     process_callback = getattr(reporter, "process_callback", None)
+    estimated_total_frames = frame_count
+    if estimated_total_frames <= 0 and original_duration > 0 and frame_rate > 0:
+        estimated_total_frames = int(math.ceil(original_duration * frame_rate))
+
+    if estimated_total_frames > 0:
+        reporter.log(f"Extract audio target frames: {estimated_total_frames}")
+    else:
+        reporter.log("Extract audio target frames: unknown")
+
     run_timed_ffmpeg_command(
         extract_command,
         reporter=reporter,
-        total=int(original_duration * frame_rate),
+        total=estimated_total_frames if estimated_total_frames > 0 else None,
         unit="frames",
         desc="Extracting audio:",
         process_callback=process_callback,
@@ -202,9 +240,11 @@ def speed_up_video(
     )
 
     audio_new_path = temp_path / "audioNew.wav"
+    # Use the sample rate that was actually used for processing
+    output_sample_rate = extraction_sample_rate
     wavfile.write(
         os.fspath(audio_new_path),
-        options.sample_rate,
+        output_sample_rate,
         _prepare_output_audio(output_audio_data),
     )
 
@@ -246,10 +286,29 @@ def speed_up_video(
         raise FileNotFoundError("Filter graph file was not generated")
 
     try:
+        final_total_frames = updated_chunks[-1][3] if updated_chunks else 0
+        if final_total_frames > 0:
+            reporter.log(f"Final encode target frames: {final_total_frames}")
+            if frame_rate > 0:
+                final_duration_seconds = final_total_frames / frame_rate
+                reporter.log(
+                    (
+                        "Final encode target duration: {duration:.2f}s at {fps:.3f} fps"
+                    ).format(duration=final_duration_seconds, fps=frame_rate)
+                )
+            else:
+                reporter.log(
+                    "Final encode target duration: unknown (missing frame rate)"
+                )
+        else:
+            reporter.log("Final encode target frames: unknown")
+
+        total_frames_arg = final_total_frames if final_total_frames > 0 else None
+
         run_timed_ffmpeg_command(
             command_str,
             reporter=reporter,
-            total=updated_chunks[-1][3],
+            total=total_frames_arg,
             unit="frames",
             desc="Generating final:",
             process_callback=process_callback,
@@ -257,10 +316,25 @@ def speed_up_video(
     except subprocess.CalledProcessError as exc:
         if fallback_command_str and use_cuda_encoder:
             reporter.log("CUDA encoding failed, retrying with CPU encoder...")
+            if final_total_frames > 0:
+                reporter.log(
+                    f"Final encode target frames (fallback): {final_total_frames}"
+                )
+            else:
+                reporter.log("Final encode target frames (fallback): unknown")
+            if final_total_frames > 0 and frame_rate > 0:
+                reporter.log(
+                    (
+                        "Final encode target duration (fallback): {duration:.2f}s at {fps:.3f} fps"
+                    ).format(
+                        duration=final_total_frames / frame_rate,
+                        fps=frame_rate,
+                    )
+                )
             run_timed_ffmpeg_command(
                 fallback_command_str,
                 reporter=reporter,
-                total=updated_chunks[-1][3],
+                total=total_frames_arg,
                 unit="frames",
                 desc="Generating final (fallback):",
                 process_callback=process_callback,

talks_reducer/server.py

@@ -0,0 +1,354 @@
+"""Gradio-powered simple server for running Talks Reducer in a browser."""
+
+from __future__ import annotations
+
+import argparse
+import atexit
+import shutil
+import tempfile
+from contextlib import AbstractContextManager, suppress
+from pathlib import Path
+from typing import Callable, Optional, Sequence
+
+import gradio as gr
+
+from talks_reducer.ffmpeg import FFmpegNotFoundError
+from talks_reducer.models import ProcessingOptions, ProcessingResult
+from talks_reducer.pipeline import speed_up_video
+from talks_reducer.progress import ProgressHandle, SignalProgressReporter
+
+
+class _GradioProgressHandle(AbstractContextManager[ProgressHandle]):
+    """Translate pipeline progress updates into Gradio progress callbacks."""
+
+    def __init__(
+        self,
+        reporter: "GradioProgressReporter",
+        *,
+        desc: str,
+        total: Optional[int],
+        unit: str,
+    ) -> None:
+        self._reporter = reporter
+        self._desc = desc.strip() or "Processing"
+        self._unit = unit
+        self._total = total
+        self._current = 0
+        self._reporter._start_task(self._desc, self._total)
+
+    @property
+    def current(self) -> int:
+        """Return the number of processed units reported so far."""
+
+        return self._current
+
+    def ensure_total(self, total: int) -> None:
+        """Update the total units when FFmpeg discovers a larger frame count."""
+
+        if total > 0 and (self._total is None or total > self._total):
+            self._total = total
+            self._reporter._update_progress(self._current, self._total, self._desc)
+
+    def advance(self, amount: int) -> None:
+        """Advance the current progress and notify the UI."""
+
+        if amount <= 0:
+            return
+        self._current += amount
+        self._reporter._update_progress(self._current, self._total, self._desc)
+
+    def finish(self) -> None:
+        """Fill the progress bar when FFmpeg completes."""
+
+        if self._total is not None:
+            self._current = self._total
+        else:
+            # Without a known total, treat the final frame count as the total so the
+            # progress bar reaches 100%.
+            inferred_total = self._current if self._current > 0 else 1
+            self._reporter._update_progress(self._current, inferred_total, self._desc)
+            return
+        self._reporter._update_progress(self._current, self._total, self._desc)
+
+    def __enter__(self) -> "_GradioProgressHandle":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> bool:
+        if exc_type is None:
+            self.finish()
+        return False
+
+
+class GradioProgressReporter(SignalProgressReporter):
+    """Progress reporter that forwards updates to Gradio's progress widget."""
+
+    def __init__(
+        self,
+        progress_callback: Optional[Callable[[int, int, str], None]] = None,
+        *,
+        max_log_lines: int = 500,
+    ) -> None:
+        super().__init__()
+        self._progress_callback = progress_callback
+        self._max_log_lines = max_log_lines
+        self._active_desc = "Processing"
+        self.logs: list[str] = []
+
+    def log(self, message: str) -> None:
+        """Collect log messages for display in the web interface."""
+
+        text = message.strip()
+        if not text:
+            return
+        self.logs.append(text)
+        if len(self.logs) > self._max_log_lines:
+            self.logs = self.logs[-self._max_log_lines :]
+
+    def task(
+        self,
+        *,
+        desc: str = "",
+        total: Optional[int] = None,
+        unit: str = "",
+    ) -> AbstractContextManager[ProgressHandle]:
+        """Create a context manager bridging pipeline progress to Gradio."""
+
+        return _GradioProgressHandle(self, desc=desc, total=total, unit=unit)
+
+    # Internal helpers -------------------------------------------------
+
+    def _start_task(self, desc: str, total: Optional[int]) -> None:
+        self._active_desc = desc or "Processing"
+        self._update_progress(0, total, self._active_desc)
+
+    def _update_progress(
+        self, current: int, total: Optional[int], desc: Optional[str]
+    ) -> None:
+        if self._progress_callback is None:
+            return
+        if total is None or total <= 0:
+            total_value = max(1, int(current) + 1 if current >= 0 else 1)
+            bounded_current = max(0, int(current))
+        else:
+            total_value = max(int(total), 1, int(current))
+            bounded_current = max(0, min(int(current), int(total_value)))
+        display_desc = desc or self._active_desc
+        self._progress_callback(bounded_current, total_value, display_desc)
+
+
+_WORKSPACES: list[Path] = []
+
+
+def _allocate_workspace() -> Path:
+    """Create and remember a workspace directory for a single request."""
+
+    path = Path(tempfile.mkdtemp(prefix="talks_reducer_web_"))
+    _WORKSPACES.append(path)
+    return path
+
+
+def _cleanup_workspaces() -> None:
+    """Remove any workspaces that remain when the process exits."""
+
+    for workspace in _WORKSPACES:
+        if workspace.exists():
+            with suppress(Exception):
+                shutil.rmtree(workspace)
+    _WORKSPACES.clear()
+
+
+def _build_output_path(input_path: Path, workspace: Path, small: bool) -> Path:
+    """Mirror the CLI output naming scheme inside the workspace directory."""
+
+    suffix = input_path.suffix or ".mp4"
+    stem = input_path.stem
+    marker = "_speedup_small" if small else "_speedup"
+    return workspace / f"{stem}{marker}{suffix}"
+
+
+def _format_duration(seconds: float) -> str:
+    """Return a compact human-readable duration string."""
+
+    if seconds <= 0:
+        return "0s"
+    total_seconds = int(round(seconds))
+    hours, remainder = divmod(total_seconds, 3600)
+    minutes, secs = divmod(remainder, 60)
+    parts: list[str] = []
+    if hours:
+        parts.append(f"{hours}h")
+    if minutes or hours:
+        parts.append(f"{minutes}m")
+    parts.append(f"{secs}s")
+    return " ".join(parts)
+
+
+def _format_summary(result: ProcessingResult) -> str:
+    """Produce a Markdown summary of the processing result."""
+
+    lines = [
+        f"**Input:** `{result.input_file.name}`",
+        f"**Output:** `{result.output_file.name}`",
+    ]
+
+    duration_line = (
+        f"**Duration:** {_format_duration(result.output_duration)}"
+        f" ({_format_duration(result.original_duration)} original)"
+    )
+    if result.time_ratio is not None:
+        duration_line += f" — {result.time_ratio * 100:.1f}% of the original"
+    lines.append(duration_line)
+
+    if result.size_ratio is not None:
+        size_percent = result.size_ratio * 100
+        lines.append(f"**Size:** {size_percent:.1f}% of the original file")
+
+    lines.append(f"**Chunks merged:** {result.chunk_count}")
+    lines.append(f"**Encoder:** {'CUDA' if result.used_cuda else 'CPU'}")
+
+    return "\n".join(lines)
+
+
+def process_video(
+    file_path: Optional[str],
+    small_video: bool,
+    progress: Optional[gr.Progress] = gr.Progress(track_tqdm=False),
+) -> tuple[Optional[str], str, str, Optional[str]]:
+    """Run the Talks Reducer pipeline for a single uploaded file."""
+
+    if not file_path:
+        raise gr.Error("Please upload a video file to begin processing.")
+
+    input_path = Path(file_path)
+    if not input_path.exists():
+        raise gr.Error("The uploaded file is no longer available on the server.")
+
+    workspace = _allocate_workspace()
+    temp_folder = workspace / "temp"
+    output_file = _build_output_path(input_path, workspace, small_video)
+
+    progress_callback: Optional[Callable[[int, int, str], None]] = None
+    if progress is not None:
+
+        def _callback(current: int, total: int, desc: str) -> None:
+            progress(current, total=total, desc=desc)
+
+        progress_callback = _callback
+
+    reporter = GradioProgressReporter(progress_callback=progress_callback)
+
+    options = ProcessingOptions(
+        input_file=input_path,
+        output_file=output_file,
+        temp_folder=temp_folder,
+        small=small_video,
+    )
+
+    try:
+        result = speed_up_video(options, reporter=reporter)
+    except FFmpegNotFoundError as exc:  # pragma: no cover - depends on runtime env
+        raise gr.Error(str(exc)) from exc
+    except FileNotFoundError as exc:
+        raise gr.Error(str(exc)) from exc
+    except Exception as exc:  # pragma: no cover - defensive fallback
+        reporter.log(f"Error: {exc}")
+        raise gr.Error(f"Failed to process the video: {exc}") from exc
+
+    reporter.log("Processing complete.")
+    log_text = "\n".join(reporter.logs)
+    summary = _format_summary(result)
+
+    return (
+        str(result.output_file),
+        log_text,
+        summary,
+        str(result.output_file),
+    )
+
+
+def build_interface() -> gr.Blocks:
+    """Construct the Gradio Blocks application for the simple web UI."""
+
+    with gr.Blocks(title="Talks Reducer Web UI") as demo:
+        gr.Markdown(
+            """
+            ## Talks Reducer — Simple Server
+            Drop a video into the zone below or click to browse. Toggle **Small video** to
+            apply the 720p/128k preset before processing starts.
+            """.strip()
+        )
+
+        with gr.Row():
+            file_input = gr.File(
+                label="Video file",
+                file_types=["video"],
+                type="filepath",
+            )
+            small_checkbox = gr.Checkbox(label="Small video", value=False)
+
+        video_output = gr.Video(label="Processed video")
+        summary_output = gr.Markdown()
+        download_output = gr.File(label="Download processed file", interactive=False)
+        log_output = gr.Textbox(label="Log", lines=12, interactive=False)
+
+        file_input.upload(
+            process_video,
+            inputs=[file_input, small_checkbox],
+            outputs=[video_output, log_output, summary_output, download_output],
+            queue=True,
+            api_name="process_video",
+        )
+
+    demo.queue(default_concurrency_limit=1)
+    return demo
+
+
+def main(argv: Optional[Sequence[str]] = None) -> None:
+    """Launch the Gradio server from the command line."""
+
+    parser = argparse.ArgumentParser(description="Launch the Talks Reducer web UI.")
+    parser.add_argument(
+        "--host", dest="host", default=None, help="Custom host to bind."
+    )
+    parser.add_argument(
+        "--port",
+        dest="port",
+        type=int,
+        default=9005,
+        help="Port number for the web server (default: 9005).",
+    )
+    parser.add_argument(
+        "--share",
+        action="store_true",
+        help="Create a temporary public Gradio link.",
+    )
+    parser.add_argument(
+        "--no-browser",
+        action="store_true",
+        help="Do not automatically open the browser window.",
+    )
+
+    args = parser.parse_args(argv)
+
+    demo = build_interface()
+    demo.launch(
+        server_name=args.host,
+        server_port=args.port,
+        share=args.share,
+        inbrowser=not args.no_browser,
+    )
+
+
+atexit.register(_cleanup_workspaces)
+
+
+__all__ = [
+    "GradioProgressReporter",
+    "build_interface",
+    "main",
+    "process_video",
+]
+
+
+if __name__ == "__main__":  # pragma: no cover - convenience entry point
+    main()

talks_reducer/service_client.py

@@ -0,0 +1,102 @@
+"""Command-line helper for sending videos to the Talks Reducer server."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+from pathlib import Path
+from typing import Optional, Sequence, Tuple
+
+from gradio_client import Client
+from gradio_client import file as gradio_file
+
+
+def send_video(
+    input_path: Path,
+    output_path: Optional[Path],
+    server_url: str,
+    small: bool = False,
+) -> Tuple[Path, str, str]:
+    """Upload *input_path* to the Gradio server and download the processed video."""
+
+    if not input_path.exists():
+        raise FileNotFoundError(f"Input file does not exist: {input_path}")
+
+    client = Client(server_url)
+    prediction = client.predict(
+        gradio_file(str(input_path)),
+        bool(small),
+        api_name="/process_video",
+    )
+
+    try:
+        _, log_text, summary, download_path = prediction
+    except (TypeError, ValueError) as exc:  # pragma: no cover - defensive
+        raise RuntimeError("Unexpected response from server") from exc
+
+    if not download_path:
+        raise RuntimeError("Server did not return a processed file")
+
+    download_source = Path(str(download_path))
+    if output_path is None:
+        destination = Path.cwd() / download_source.name
+    else:
+        destination = output_path
+        if destination.is_dir():
+            destination = destination / download_source.name
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    if download_source.resolve() != destination.resolve():
+        shutil.copy2(download_source, destination)
+
+    return destination, summary, log_text
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Send a video to a running talks-reducer server and download the result.",
+    )
+    parser.add_argument("input", type=Path, help="Path to the video file to upload.")
+    parser.add_argument(
+        "--server",
+        default="http://127.0.0.1:9005/",
+        help="Base URL for the talks-reducer server (default: http://127.0.0.1:9005/).",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=None,
+        help="Where to store the processed video. Defaults to the working directory.",
+    )
+    parser.add_argument(
+        "--small",
+        action="store_true",
+        help="Toggle the 'Small video' preset before processing.",
+    )
+    parser.add_argument(
+        "--print-log",
+        action="store_true",
+        help="Print the server log after processing completes.",
+    )
+    return parser
+
+
+def main(argv: Optional[Sequence[str]] = None) -> None:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    destination, summary, log_text = send_video(
+        input_path=args.input.expanduser(),
+        output_path=args.output.expanduser() if args.output else None,
+        server_url=args.server,
+        small=args.small,
+    )
+
+    print(summary)
+    print(f"Saved processed video to {destination}")
+    if args.print_log:
+        print("\nServer log:\n" + log_text)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()