talks-reducer 0.7.2__py3-none-any.whl → 0.8.0__py3-none-any.whl

talks_reducer/server.py

@@ -9,6 +9,7 @@ import socket
 import sys
 import tempfile
 from contextlib import AbstractContextManager, suppress
+from dataclasses import dataclass
 from pathlib import Path
 from queue import SimpleQueue
 from threading import Thread
@@ -244,6 +245,98 @@ def _format_summary(result: ProcessingResult) -> str:
     return "\n".join(lines)
 
 
+PipelineEvent = tuple[str, object]
+
+
+def _default_reporter_factory(
+    progress_callback: Optional[Callable[[int, int, str], None]],
+    log_callback: Callable[[str], None],
+) -> SignalProgressReporter:
+    """Construct a :class:`GradioProgressReporter` with the given callbacks."""
+
+    return GradioProgressReporter(
+        progress_callback=progress_callback,
+        log_callback=log_callback,
+    )
+
+
+def run_pipeline_job(
+    options: ProcessingOptions,
+    *,
+    speed_up: Callable[[ProcessingOptions, SignalProgressReporter], ProcessingResult],
+    reporter_factory: Callable[
+        [Optional[Callable[[int, int, str], None]], Callable[[str], None]],
+        SignalProgressReporter,
+    ],
+    events: SimpleQueue[PipelineEvent],
+    enable_progress: bool = True,
+    start_in_thread: bool = True,
+) -> Iterator[PipelineEvent]:
+    """Execute the processing pipeline and yield emitted events."""
+
+    def _emit(kind: str, payload: object) -> None:
+        events.put((kind, payload))
+
+    progress_callback: Optional[Callable[[int, int, str], None]] = None
+    if enable_progress:
+        progress_callback = lambda current, total, desc: _emit(
+            "progress", (current, total, desc)
+        )
+
+    reporter = reporter_factory(
+        progress_callback, lambda message: _emit("log", message)
+    )
+
+    def _worker() -> None:
+        try:
+            result = speed_up(options, reporter=reporter)
+        except FFmpegNotFoundError as exc:  # pragma: no cover - depends on runtime env
+            _emit("error", gr.Error(str(exc)))
+        except FileNotFoundError as exc:
+            _emit("error", gr.Error(str(exc)))
+        except Exception as exc:  # pragma: no cover - defensive fallback
+            reporter.log(f"Error: {exc}")
+            _emit("error", gr.Error(f"Failed to process the video: {exc}"))
+        else:
+            reporter.log("Processing complete.")
+            _emit("result", result)
+        finally:
+            _emit("done", None)
+
+    thread: Optional[Thread] = None
+    if start_in_thread:
+        thread = Thread(target=_worker, daemon=True)
+        thread.start()
+    else:
+        _worker()
+
+    try:
+        while True:
+            kind, payload = events.get()
+            if kind == "done":
+                break
+            yield (kind, payload)
+    finally:
+        if thread is not None:
+            thread.join()
+
+
+@dataclass
+class ProcessVideoDependencies:
+    """Container for dependencies used by :func:`process_video`."""
+
+    speed_up: Callable[
+        [ProcessingOptions, SignalProgressReporter], ProcessingResult
+    ] = speed_up_video
+    reporter_factory: Callable[
+        [Optional[Callable[[int, int, str], None]], Callable[[str], None]],
+        SignalProgressReporter,
+    ] = _default_reporter_factory
+    queue_factory: Callable[[], SimpleQueue[PipelineEvent]] = SimpleQueue
+    run_pipeline_job_func: Callable[..., Iterator[PipelineEvent]] = run_pipeline_job
+    start_in_thread: bool = True
+
+
 def process_video(
     file_path: Optional[str],
     small_video: bool,
@@ -251,6 +344,8 @@ def process_video(
     sounded_speed: Optional[float] = None,
     silent_speed: Optional[float] = None,
     progress: Optional[gr.Progress] = gr.Progress(track_tqdm=False),
+    *,
+    dependencies: Optional[ProcessVideoDependencies] = None,
 ) -> Iterator[tuple[Optional[str], str, str, Optional[str]]]:
     """Run the Talks Reducer pipeline for a single uploaded file."""
 
@@ -265,23 +360,8 @@ def process_video(
     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:
-            events.put(("progress", (current, total, desc)))
-
-        progress_callback = _callback
-
-    events: "SimpleQueue[tuple[str, object]]" = SimpleQueue()
-
-    def _log_callback(message: str) -> None:
-        events.put(("log", message))
-
-    reporter = GradioProgressReporter(
-        progress_callback=progress_callback,
-        log_callback=_log_callback,
-    )
+    deps = dependencies or ProcessVideoDependencies()
+    events = deps.queue_factory()
 
     option_kwargs: dict[str, float] = {}
     if silent_threshold is not None:
@@ -299,31 +379,20 @@ def process_video(
         **option_kwargs,
     )
 
-    def _worker() -> None:
-        try:
-            result = speed_up_video(options, reporter=reporter)
-        except FFmpegNotFoundError as exc:  # pragma: no cover - depends on runtime env
-            events.put(("error", gr.Error(str(exc))))
-        except FileNotFoundError as exc:
-            events.put(("error", gr.Error(str(exc))))
-        except Exception as exc:  # pragma: no cover - defensive fallback
-            reporter.log(f"Error: {exc}")
-            events.put(("error", gr.Error(f"Failed to process the video: {exc}")))
-        else:
-            reporter.log("Processing complete.")
-            events.put(("result", result))
-        finally:
-            events.put(("done", None))
-
-    worker = Thread(target=_worker, daemon=True)
-    worker.start()
+    event_stream = deps.run_pipeline_job_func(
+        options,
+        speed_up=deps.speed_up,
+        reporter_factory=deps.reporter_factory,
+        events=events,
+        enable_progress=progress is not None,
+        start_in_thread=deps.start_in_thread,
+    )
 
     collected_logs: list[str] = []
     final_result: Optional[ProcessingResult] = None
     error: Optional[gr.Error] = None
 
-    while True:
-        kind, payload = events.get()
+    for kind, payload in event_stream:
         if kind == "log":
             text = str(payload).strip()
             if text:
@@ -343,10 +412,6 @@ def process_video(
             final_result = payload  # type: ignore[assignment]
         elif kind == "error":
             error = payload  # type: ignore[assignment]
-        elif kind == "done":
-            break
-
-    worker.join()
 
     if error is not None:
         raise error

talks_reducer/server_tray.py

@@ -12,7 +12,7 @@ import time
 import webbrowser
 from contextlib import suppress
 from pathlib import Path
-from typing import Any, Iterator, Optional, Sequence
+from typing import Any, Callable, Iterator, Optional, Sequence
 from urllib.parse import urlsplit, urlunsplit
 
 from PIL import Image
@@ -49,9 +49,27 @@ def _guess_local_url(host: Optional[str], port: int) -> str:
     return f"http://{hostname}:{port}/"
 
 
-def _normalize_local_url(url: str, host: Optional[str], port: int) -> str:
+def _coerce_url(value: Optional[Any]) -> Optional[str]:
+    """Convert an arbitrary URL-like object to a trimmed string if possible."""
+
+    if not value:
+        return None
+
+    try:
+        text = str(value)
+    except Exception:  # pragma: no cover - defensive fallback
+        return None
+
+    stripped = text.strip()
+    return stripped or None
+
+
+def _normalize_local_url(url: Optional[str], host: Optional[str], port: int) -> str:
     """Rewrite *url* when a wildcard host should map to the loopback address."""
 
+    if not url:
+        return _guess_local_url(host, port)
+
     if host not in (None, "", "0.0.0.0"):
         return url
 
@@ -131,6 +149,15 @@ def _load_icon() -> Image.Image:
     return _generate_fallback_icon()
 
 
+class _HeadlessTrayBackend:
+    """Placeholder backend used when the tray icon is disabled."""
+
+    def __getattr__(self, name: str) -> Any:
+        raise RuntimeError(
+            "System tray backend is unavailable when running in headless mode."
+        )
+
+
 class _ServerTrayApplication:
     """Coordinate the Gradio server lifecycle and the system tray icon."""
 
@@ -142,21 +169,28 @@ class _ServerTrayApplication:
         share: bool,
         open_browser: bool,
         tray_mode: str,
+        tray_backend: Any,
+        build_interface: Callable[[], Any],
+        open_browser_callback: Callable[[str], Any],
     ) -> None:
         self._host = host
         self._port = port
         self._share = share
         self._open_browser_on_start = open_browser
         self._tray_mode = tray_mode
+        self._tray_backend = tray_backend
+        self._build_interface = build_interface
+        self._open_browser = open_browser_callback
 
         self._stop_event = threading.Event()
+        self._server_ready_event = threading.Event()
         self._ready_event = threading.Event()
         self._gui_lock = threading.Lock()
 
         self._server_handle: Optional[Any] = None
         self._local_url: Optional[str] = None
         self._share_url: Optional[str] = None
-        self._icon: Optional[pystray.Icon] = None
+        self._icon: Optional[Any] = None
         self._gui_process: Optional[subprocess.Popen[Any]] = None
         self._startup_error: Optional[BaseException] = None
 
@@ -171,7 +205,7 @@ class _ServerTrayApplication:
             self._port,
             self._share,
         )
-        demo = build_interface()
+        demo = self._build_interface()
         server = demo.launch(
             server_name=self._host,
             server_port=self._port,
@@ -183,15 +217,15 @@ class _ServerTrayApplication:
 
         self._server_handle = server
         fallback_url = _guess_local_url(self._host, self._port)
-        local_url = getattr(server, "local_url", fallback_url)
+        local_url = _coerce_url(getattr(server, "local_url", fallback_url))
         self._local_url = _normalize_local_url(local_url, self._host, self._port)
-        self._share_url = getattr(server, "share_url", None)
-        self._ready_event.set()
+        self._share_url = _coerce_url(getattr(server, "share_url", None))
+        self._server_ready_event.set()
         LOGGER.info("Server ready at %s", self._local_url)
 
         # Keep checking for a share URL while the server is running.
         while not self._stop_event.is_set():
-            share_url = getattr(server, "share_url", None)
+            share_url = _coerce_url(getattr(server, "share_url", None))
             if share_url:
                 self._share_url = share_url
                 LOGGER.info("Share URL available: %s", share_url)
@@ -206,12 +240,12 @@ class _ServerTrayApplication:
 
     def _handle_open_webui(
         self,
-        _icon: Optional[pystray.Icon] = None,
-        _item: Optional[pystray.MenuItem] = None,
+        _icon: Optional[Any] = None,
+        _item: Optional[Any] = None,
     ) -> None:
         url = self._resolve_url()
         if url:
-            webbrowser.open(url)
+            self._open_browser(url)
             LOGGER.info("Opened browser to %s", url)
         else:
             LOGGER.warning("Server URL not yet available; please try again.")
@@ -242,8 +276,8 @@ class _ServerTrayApplication:
 
     def _launch_gui(
         self,
-        _icon: Optional[pystray.Icon] = None,
-        _item: Optional[pystray.MenuItem] = None,
+        _icon: Optional[Any] = None,
+        _item: Optional[Any] = None,
     ) -> None:
         """Launch the Talks Reducer GUI in a background subprocess."""
 
@@ -274,21 +308,27 @@ class _ServerTrayApplication:
 
     def _handle_quit(
         self,
-        icon: Optional[pystray.Icon] = None,
-        _item: Optional[pystray.MenuItem] = None,
+        icon: Optional[Any] = None,
+        _item: Optional[Any] = None,
     ) -> None:
         self.stop()
         if icon is not None:
-            icon.stop()
+            stop_method = getattr(icon, "stop", None)
+            if callable(stop_method):
+                with suppress(Exception):
+                    stop_method()
 
     # Public API -------------------------------------------------------
 
-    def _await_server_start(self, icon: Optional[pystray.Icon]) -> None:
+    def _await_server_start(self, icon: Optional[Any]) -> None:
         """Wait for the server to signal readiness or trigger shutdown on failure."""
 
-        if self._ready_event.wait(timeout=30):
-            if self._open_browser_on_start and not self._stop_event.is_set():
-                self._handle_open_webui()
+        if self._server_ready_event.wait(timeout=30):
+            try:
+                if self._open_browser_on_start and not self._stop_event.is_set():
+                    self._handle_open_webui()
+            finally:
+                self._ready_event.set()
             return
 
         if self._stop_event.is_set():
@@ -301,8 +341,10 @@ class _ServerTrayApplication:
         LOGGER.error("%s", error)
 
         if icon is not None:
-            with suppress(Exception):
-                icon.notify("Talks Reducer server failed to start.")
+            notify = getattr(icon, "notify", None)
+            if callable(notify):
+                with suppress(Exception):
+                    notify("Talks Reducer server failed to start.")
 
         self.stop()
 
@@ -334,17 +376,17 @@ class _ServerTrayApplication:
             f" v{APP_VERSION}" if APP_VERSION and APP_VERSION != "unknown" else ""
         )
         version_label = f"Talks Reducer{version_suffix}"
-        menu = pystray.Menu(
-            pystray.MenuItem(version_label, None, enabled=False),
-            pystray.MenuItem(
+        menu = self._tray_backend.Menu(
+            self._tray_backend.MenuItem(version_label, None, enabled=False),
+            self._tray_backend.MenuItem(
                 "Open GUI",
                 self._launch_gui,
                 default=True,
             ),
-            pystray.MenuItem("Open WebUI", self._handle_open_webui),
-            pystray.MenuItem("Quit", self._handle_quit),
+            self._tray_backend.MenuItem("Open WebUI", self._handle_open_webui),
+            self._tray_backend.MenuItem("Quit", self._handle_quit),
         )
-        self._icon = pystray.Icon(
+        self._icon = self._tray_backend.Icon(
             "talks-reducer",
             icon_image,
             f"{version_label} Server",
@@ -380,12 +422,17 @@ class _ServerTrayApplication:
         """Stop the tray icon and shut down the Gradio server."""
 
         self._stop_event.set()
+        self._server_ready_event.set()
+        self._ready_event.set()
 
         if self._icon is not None:
             with suppress(Exception):
-                self._icon.visible = False
-            with suppress(Exception):
-                self._icon.stop()
+                if hasattr(self._icon, "visible"):
+                    self._icon.visible = False
+            stop_method = getattr(self._icon, "stop", None)
+            if callable(stop_method):
+                with suppress(Exception):
+                    stop_method()
 
         self._stop_gui()
 
@@ -419,6 +466,42 @@ class _ServerTrayApplication:
             self._gui_process = None
 
 
+def create_tray_app(
+    *,
+    host: Optional[str],
+    port: int,
+    share: bool,
+    open_browser: bool,
+    tray_mode: str,
+) -> _ServerTrayApplication:
+    """Build a :class:`_ServerTrayApplication` wired to production dependencies."""
+
+    if tray_mode != "headless" and (
+        pystray is None or PYSTRAY_IMPORT_ERROR is not None
+    ):
+        raise RuntimeError(
+            "System tray mode requires the 'pystray' dependency. Install it with "
+            "`pip install pystray` or `pip install talks-reducer[dev]` and try again."
+        ) from PYSTRAY_IMPORT_ERROR
+
+    tray_backend: Any
+    if pystray is None:
+        tray_backend = _HeadlessTrayBackend()
+    else:
+        tray_backend = pystray
+
+    return _ServerTrayApplication(
+        host=host,
+        port=port,
+        share=share,
+        open_browser=open_browser,
+        tray_mode=tray_mode,
+        tray_backend=tray_backend,
+        build_interface=build_interface,
+        open_browser_callback=webbrowser.open,
+    )
+
+
 def main(argv: Optional[Sequence[str]] = None) -> None:
     """Launch the Gradio server with a companion system tray icon."""
 
@@ -477,13 +560,7 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
         datefmt="%H:%M:%S",
     )
 
-    if args.tray_mode != "headless" and PYSTRAY_IMPORT_ERROR is not None:
-        raise RuntimeError(
-            "System tray mode requires the 'pystray' dependency. Install it with "
-            "`pip install pystray` or `pip install talks-reducer[dev]` and try again."
-        ) from PYSTRAY_IMPORT_ERROR
-
-    app = _ServerTrayApplication(
+    app = create_tray_app(
         host=args.host,
         port=args.port,
         share=args.share,
@@ -499,7 +576,7 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
         app.stop()
 
 
-__all__ = ["main"]
+__all__ = ["create_tray_app", "main"]
 
 
 if __name__ == "__main__":  # pragma: no cover - convenience entry point

talks_reducer/service_client.py

@@ -8,7 +8,7 @@ import shutil
 import time
 from contextlib import suppress
 from pathlib import Path
-from typing import Callable, Optional, Sequence, Tuple
+from typing import Any, AsyncIterator, Callable, Optional, Sequence, Tuple
 
 from gradio_client import Client
 from gradio_client import file as gradio_file
@@ -20,6 +20,55 @@ except ImportError:  # pragma: no cover - allow running as script
     from talks_reducer.pipeline import ProcessingAborted
 
 
+class StreamingJob:
+    """Adapter that provides a consistent interface for streaming jobs."""
+
+    def __init__(self, job: Any) -> None:
+        self._job = job
+
+    @property
+    def raw(self) -> Any:
+        """Return the wrapped job instance."""
+
+        return self._job
+
+    @property
+    def supports_streaming(self) -> bool:
+        """Return ``True`` when the remote job can stream async updates."""
+
+        communicator = getattr(self._job, "communicator", None)
+        return communicator is not None
+
+    async def async_iter_updates(self) -> AsyncIterator[Any]:
+        """Yield updates from the wrapped job asynchronously."""
+
+        async for update in self._job:  # type: ignore[async-for]
+            yield update
+
+    def status(self) -> Any:
+        """Return the latest status update from the job when available."""
+
+        status_method = getattr(self._job, "status", None)
+        if callable(status_method):
+            return status_method()
+        raise AttributeError("Wrapped job does not expose a status() method")
+
+    def outputs(self) -> Any:
+        """Return cached outputs from the job when available."""
+
+        outputs_method = getattr(self._job, "outputs", None)
+        if callable(outputs_method):
+            return outputs_method()
+        raise AttributeError("Wrapped job does not expose an outputs() method")
+
+    def cancel(self) -> None:
+        """Cancel the remote job when supported."""
+
+        cancel_method = getattr(self._job, "cancel", None)
+        if callable(cancel_method):
+            cancel_method()
+
+
 def send_video(
     input_path: Path,
     output_path: Optional[Path],
@@ -35,6 +84,10 @@ def send_video(
     progress_callback: Optional[
         Callable[[str, Optional[int], Optional[int], str], None]
     ] = None,
+    client_factory: Optional[Callable[[str], Client]] = None,
+    job_factory: Optional[
+        Callable[[Client, Tuple[Any, ...], dict[str, Any]], Any]
+    ] = None,
 ) -> Tuple[Path, str, str]:
     """Upload *input_path* to the Gradio server and download the processed video.
 
@@ -45,15 +98,23 @@ def send_video(
     if not input_path.exists():
         raise FileNotFoundError(f"Input file does not exist: {input_path}")
 
-    client = Client(server_url)
-    job = client.submit(
+    client_builder = client_factory or Client
+    client = client_builder(server_url)
+    submit_args: Tuple[Any, ...] = (
         gradio_file(str(input_path)),
         bool(small),
         silent_threshold,
         sounded_speed,
         silent_speed,
-        api_name="/process_video",
     )
+    submit_kwargs: dict[str, Any] = {"api_name": "/process_video"}
+
+    if job_factory is not None:
+        job = job_factory(client, submit_args, submit_kwargs)
+    else:
+        job = client.submit(*submit_args, **submit_kwargs)
+
+    streaming_job = StreamingJob(job)
 
     cancelled = False
 
@@ -62,7 +123,7 @@ def send_video(
         if should_cancel and should_cancel():
             if not cancelled:
                 with suppress(Exception):
-                    job.cancel()
+                    streaming_job.cancel()
                 cancelled = True
             raise ProcessingAborted("Remote processing cancelled by user.")
 
@@ -85,7 +146,7 @@ def send_video(
         if should_cancel is not None:
             stream_kwargs["cancel_callback"] = _cancel_if_requested
         consumed_stream = _stream_job_updates(
-            job,
+            streaming_job,
             _emit_new_lines,
             **stream_kwargs,
         )
@@ -190,7 +251,7 @@ def _emit_progress_update(
 
 
 async def _pump_job_updates(
-    job,
+    job: StreamingJob,
     emit_log: Callable[[str], None],
     progress_callback: Optional[
         Callable[[str, Optional[int], Optional[int], str], None]
@@ -199,7 +260,7 @@ async def _pump_job_updates(
 ) -> None:
     """Consume asynchronous updates from *job* and emit logs and progress."""
 
-    async for update in job:  # type: ignore[async-for]
+    async for update in job.async_iter_updates():
         if cancel_callback:
             cancel_callback()
         update_type = getattr(update, "type", "status")
@@ -242,15 +303,18 @@ def _poll_job_updates(
 ) -> None:
     """Poll *job* for outputs and status updates when async streaming is unavailable."""
 
+    streaming_job = job if isinstance(job, StreamingJob) else StreamingJob(job)
+    raw_job = streaming_job.raw
+
     while True:
         if cancel_callback:
             cancel_callback()
-        if job.done():
+        if hasattr(raw_job, "done") and raw_job.done():
             break
 
         status: Optional[StatusUpdate] = None
         with suppress(Exception):
-            status = job.status()  # type: ignore[assignment]
+            status = streaming_job.status()  # type: ignore[assignment]
 
         if status is not None:
             if progress_callback:
@@ -268,7 +332,7 @@ def _poll_job_updates(
 
         outputs = []
         with suppress(Exception):
-            outputs = job.outputs()
+            outputs = streaming_job.outputs()
         if outputs:
             latest = outputs[-1]
             if isinstance(latest, (list, tuple)) and len(latest) == 4:
@@ -280,7 +344,7 @@ def _poll_job_updates(
 
 
 def _stream_job_updates(
-    job,
+    job: StreamingJob,
     emit_log: Callable[[str], None],
     *,
     progress_callback: Optional[
@@ -294,8 +358,7 @@ def _stream_job_updates(
     generator-based fallback should be used.
     """
 
-    communicator = getattr(job, "communicator", None)
-    if communicator is None:
+    if not job.supports_streaming:
         return False
 
     try:

{talks_reducer-0.7.2.dist-info → talks_reducer-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: talks-reducer
-Version: 0.7.2
+Version: 0.8.0
 Summary: CLI for speeding up long-form talks by removing silence
 Author: Talks Reducer Maintainers
 License-Expression: MIT
@@ -26,7 +26,7 @@ Requires-Dist: bump-my-version>=0.5.0; extra == "dev"
 Requires-Dist: pyinstaller>=6.4.0; extra == "dev"
 Dynamic: license-file
 
-# Talks Reducer 
+# Talks Reducer [![Coverage Status](https://coveralls.io/repos/github/popstas/talks-reducer/badge.svg?branch=master)](https://coveralls.io/github/popstas/talks-reducer?branch=master)
 
 Talks Reducer shortens long-form presentations by removing silent gaps and optionally re-encoding them to smaller files. The
 project was renamed from **jumpcutter** to emphasize its focus on conference talks and screencasts.