talks-reducer 0.5.2__tar.gz → 0.5.5__tar.gz

{talks_reducer-0.5.2/talks_reducer.egg-info → talks_reducer-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: talks-reducer
-Version: 0.5.2
+Version: 0.5.5
 Summary: CLI for speeding up long-form talks by removing silence
 Author: Talks Reducer Maintainers
 License-Expression: MIT
@@ -70,6 +70,14 @@ Example CLI usage:
 talks-reducer --small input.mp4
 ```
 
+Need to offload work to a remote Talks Reducer server? Pass `--url` with the
+server address and the CLI will upload the input, wait for processing to finish,
+and download the rendered video:
+
+```sh
+talks-reducer --url http://localhost:9005 demo.mp4
+```
+
 ### Speech detection
 
 Talks Reducer now relies on its built-in volume thresholding to detect speech. Adjust `--silent_threshold` if you need to fine-tune when segments count as silence. Dropping the optional Silero VAD integration keeps the install lightweight and avoids pulling in PyTorch.
@@ -91,6 +99,10 @@ Want the server to live in your system tray instead of a terminal window? Use:
 talks-reducer server-tray
 ```
 
+Bundled Windows builds include the same behaviour: run
+`talks-reducer.exe --server` to launch the tray-managed server directly from the
+desktop shortcut without opening the GUI first.
+
 Pass `--debug` to print verbose logs about the tray icon lifecycle, and
 `--tray-mode pystray-detached` to try pystray's alternate detached runner. If
 the icon backend refuses to appear, fall back to `--tray-mode headless` to keep
@@ -111,6 +123,12 @@ This opens a local web page featuring a drag-and-drop upload zone, a **Small vid
 progress indicator, and automatic previews of the processed output. Once the job completes you can inspect the resulting compression
 ratio and download the rendered video directly from the page.
 
+The desktop GUI mirrors this behaviour. Open **Advanced** settings to provide a
+server URL and click **Discover** to scan your local network for Talks Reducer
+instances listening on port `9005`. Leaving the field blank keeps processing
+local; selecting a discovered server delegates rendering to that machine while
+the GUI downloads the finished files automatically.
+
 ### Uploading and retrieving a processed video
 
 1. Open the printed `http://localhost:<port>` address (the default port is `9005`).

{talks_reducer-0.5.2 → talks_reducer-0.5.5}/README.md

@@ -42,6 +42,14 @@ Example CLI usage:
 talks-reducer --small input.mp4
 ```
 
+Need to offload work to a remote Talks Reducer server? Pass `--url` with the
+server address and the CLI will upload the input, wait for processing to finish,
+and download the rendered video:
+
+```sh
+talks-reducer --url http://localhost:9005 demo.mp4
+```
+
 ### Speech detection
 
 Talks Reducer now relies on its built-in volume thresholding to detect speech. Adjust `--silent_threshold` if you need to fine-tune when segments count as silence. Dropping the optional Silero VAD integration keeps the install lightweight and avoids pulling in PyTorch.
@@ -63,6 +71,10 @@ Want the server to live in your system tray instead of a terminal window? Use:
 talks-reducer server-tray
 ```
 
+Bundled Windows builds include the same behaviour: run
+`talks-reducer.exe --server` to launch the tray-managed server directly from the
+desktop shortcut without opening the GUI first.
+
 Pass `--debug` to print verbose logs about the tray icon lifecycle, and
 `--tray-mode pystray-detached` to try pystray's alternate detached runner. If
 the icon backend refuses to appear, fall back to `--tray-mode headless` to keep
@@ -83,6 +95,12 @@ This opens a local web page featuring a drag-and-drop upload zone, a **Small vid
 progress indicator, and automatic previews of the processed output. Once the job completes you can inspect the resulting compression
 ratio and download the rendered video directly from the page.
 
+The desktop GUI mirrors this behaviour. Open **Advanced** settings to provide a
+server URL and click **Discover** to scan your local network for Talks Reducer
+instances listening on port `9005`. Leaving the field blank keeps processing
+local; selecting a discovered server delegates rendering to that machine while
+the GUI downloads the finished files automatically.
+
 ### Uploading and retrieving a processed video
 
 1. Open the printed `http://localhost:<port>` address (the default port is `9005`).

{talks_reducer-0.5.2 → talks_reducer-0.5.5}/talks_reducer/__about__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.5.2"
+__version__ = "0.5.5"

{talks_reducer-0.5.2 → talks_reducer-0.5.5}/talks_reducer/cli.py

@@ -98,6 +98,12 @@ def _build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Apply small file optimizations: resize video to 720p, audio to 128k bitrate, best compression (uses CUDA if available).",
     )
+    parser.add_argument(
+        "--url",
+        dest="server_url",
+        default=None,
+        help="Process videos via a Talks Reducer server at the provided base URL (for example, http://localhost:9005).",
+    )
     return parser
 
 
@@ -128,6 +134,86 @@ def gather_input_files(paths: List[str]) -> List[str]:
     return files
 
 
+def _print_total_time(start_time: float) -> None:
+    """Print the elapsed processing time since *start_time*."""
+
+    end_time = time.time()
+    total_time = end_time - start_time
+    hours, remainder = divmod(total_time, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    print(f"\nTime: {int(hours)}h {int(minutes)}m {seconds:.2f}s")
+
+
+def _process_via_server(
+    files: Sequence[str], parsed_args: argparse.Namespace, *, start_time: float
+) -> None:
+    """Upload *files* to the configured server and download the results."""
+
+    try:
+        from . import service_client
+    except ImportError as exc:  # pragma: no cover - optional dependency guard
+        print(
+            "Server mode requires the gradio_client dependency." f" ({exc})",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    server_url = parsed_args.server_url
+    if not server_url:
+        return
+
+    output_override: Optional[Path] = None
+    if parsed_args.output_file and len(files) == 1:
+        output_override = Path(parsed_args.output_file).expanduser()
+    elif parsed_args.output_file and len(files) > 1:
+        print(
+            "Warning: --output is ignored when processing multiple files via the server.",
+            file=sys.stderr,
+        )
+
+    unsupported_options = []
+    for name in (
+        "silent_threshold",
+        "silent_speed",
+        "sounded_speed",
+        "frame_spreadage",
+        "sample_rate",
+        "temp_folder",
+    ):
+        if getattr(parsed_args, name) is not None:
+            unsupported_options.append(f"--{name.replace('_', '-')}")
+
+    if unsupported_options:
+        print(
+            "Warning: the following options are ignored when using --url: "
+            + ", ".join(sorted(unsupported_options)),
+            file=sys.stderr,
+        )
+
+    for index, file in enumerate(files, start=1):
+        basename = os.path.basename(file)
+        print(
+            f"Processing file {index}/{len(files)} '{basename}' via server {server_url}"
+        )
+        try:
+            destination, summary, log_text = service_client.send_video(
+                input_path=Path(file),
+                output_path=output_override,
+                server_url=server_url,
+                small=bool(parsed_args.small),
+            )
+        except Exception as exc:  # pragma: no cover - network failure safeguard
+            print(f"Failed to process {basename}: {exc}", file=sys.stderr)
+            sys.exit(1)
+
+        print(summary)
+        print(f"Saved processed video to {destination}")
+        if log_text.strip():
+            print("\nServer log:\n" + log_text)
+
+    _print_total_time(start_time)
+
+
 def _launch_gui(argv: Sequence[str]) -> bool:
     """Attempt to launch the GUI with the provided arguments."""
 
@@ -198,6 +284,10 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
     if len(files) > 1 and "output_file" in args:
         del args["output_file"]
 
+    if parsed_args.server_url:
+        _process_via_server(files, parsed_args, start_time=start_time)
+        return
+
     reporter = TqdmProgressReporter()
 
     for index, file in enumerate(files):
@@ -241,11 +331,7 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
         if summary_parts:
             reporter.log("Result: " + ", ".join(summary_parts))
 
-    end_time = time.time()
-    total_time = end_time - start_time
-    hours, remainder = divmod(total_time, 3600)
-    minutes, seconds = divmod(remainder, 60)
-    print(f"\nTime: {int(hours)}h {int(minutes)}m {seconds:.2f}s")
+    _print_total_time(start_time)
 
 
 if __name__ == "__main__":

talks_reducer-0.5.5/talks_reducer/discovery.py

@@ -0,0 +1,119 @@
+"""Utilities for discovering Talks Reducer servers on the local network."""
+
+from __future__ import annotations
+
+import ipaddress
+import socket
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import closing
+from http.client import HTTPConnection
+from typing import Iterable, Iterator, List, Optional, Set
+
+DEFAULT_PORT = 9005
+DEFAULT_TIMEOUT = 0.4
+
+
+def _iter_local_ipv4_addresses() -> Iterator[str]:
+    """Yield IPv4 addresses that belong to the local machine."""
+
+    seen: Set[str] = set()
+
+    try:
+        hostname = socket.gethostname()
+        for info in socket.getaddrinfo(hostname, None, family=socket.AF_INET):
+            address = info[4][0]
+            if address and address not in seen:
+                seen.add(address)
+                yield address
+    except socket.gaierror:
+        pass
+
+    for probe in ("8.8.8.8", "1.1.1.1"):
+        try:
+            with closing(socket.socket(socket.AF_INET, socket.SOCK_DGRAM)) as sock:
+                sock.connect((probe, 80))
+                address = sock.getsockname()[0]
+                if address and address not in seen:
+                    seen.add(address)
+                    yield address
+        except OSError:
+            continue
+
+
+def _build_default_host_candidates(prefix_length: int = 24) -> List[str]:
+    """Return a list of host candidates based on detected local networks."""
+
+    hosts: Set[str] = {"127.0.0.1", "localhost"}
+
+    for address in _iter_local_ipv4_addresses():
+        hosts.add(address)
+        try:
+            network = ipaddress.ip_network(f"{address}/{prefix_length}", strict=False)
+        except ValueError:
+            continue
+        for host in network.hosts():
+            hosts.add(str(host))
+
+    return sorted(hosts)
+
+
+def _probe_host(host: str, port: int, timeout: float) -> Optional[str]:
+    """Return the URL if *host* responds on *port* within *timeout* seconds."""
+
+    connection: Optional[HTTPConnection] = None
+    try:
+        connection = HTTPConnection(host, port, timeout=timeout)
+        connection.request(
+            "GET", "/", headers={"User-Agent": "talks-reducer-discovery"}
+        )
+        response = connection.getresponse()
+        # Drain the response to avoid ResourceWarning in some Python versions.
+        response.read()
+        if 200 <= response.status < 500:
+            return f"http://{host}:{port}/"
+    except OSError:
+        return None
+    finally:
+        if connection is not None:
+            try:
+                connection.close()
+            except Exception:
+                pass
+    return None
+
+
+def discover_servers(
+    *,
+    port: int = DEFAULT_PORT,
+    timeout: float = DEFAULT_TIMEOUT,
+    hosts: Optional[Iterable[str]] = None,
+) -> List[str]:
+    """Scan *hosts* for running Talks Reducer servers on *port*.
+
+    When *hosts* is omitted, the local /24 networks derived from available IPv4
+    addresses are scanned. ``localhost`` and ``127.0.0.1`` are always included.
+    The function returns a sorted list of unique base URLs.
+    """
+
+    if hosts is None:
+        candidates = _build_default_host_candidates()
+    else:
+        candidates = sorted(set(hosts))
+        if "127.0.0.1" not in candidates:
+            candidates.append("127.0.0.1")
+        if "localhost" not in candidates:
+            candidates.append("localhost")
+
+    results: List[str] = []
+
+    with ThreadPoolExecutor(max_workers=32) as executor:
+        for url in executor.map(
+            lambda host: _probe_host(host, port, timeout), candidates
+        ):
+            if url and url not in results:
+                results.append(url)
+
+    return results
+
+
+__all__ = ["discover_servers"]

{talks_reducer-0.5.2 → talks_reducer-0.5.5}/talks_reducer/gui.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import argparse
+import importlib
 import json
 import os
 import re
@@ -20,6 +21,7 @@ if TYPE_CHECKING:
 try:
     from .cli import gather_input_files
     from .cli import main as cli_main
+    from .discovery import discover_servers
     from .ffmpeg import FFmpegNotFoundError
     from .models import ProcessingOptions, default_temp_folder
     from .pipeline import speed_up_video
@@ -34,6 +36,7 @@ except ImportError:  # pragma: no cover - handled at runtime
 
     from talks_reducer.cli import gather_input_files
     from talks_reducer.cli import main as cli_main
+    from talks_reducer.discovery import discover_servers
     from talks_reducer.ffmpeg import FFmpegNotFoundError
     from talks_reducer.models import ProcessingOptions, default_temp_folder
     from talks_reducer.pipeline import speed_up_video
@@ -356,6 +359,11 @@ class TalksReducerGUI:
         self.open_after_convert_var.trace_add(
             "write", self._on_open_after_convert_change
         )
+        self.server_url_var = tk.StringVar(
+            value=str(self._get_setting("server_url", ""))
+        )
+        self.server_url_var.trace_add("write", self._on_server_url_change)
+        self._discovery_thread: Optional[threading.Thread] = None
 
         self._build_layout()
         self._apply_simple_mode(initial=True)
@@ -538,11 +546,23 @@ class TalksReducerGUI:
         self.sample_rate_var = self.tk.StringVar(value="48000")
         self._add_entry(self.advanced_frame, "Sample rate", self.sample_rate_var, row=6)
 
+        self.ttk.Label(self.advanced_frame, text="Server URL").grid(
+            row=7, column=0, sticky="w", pady=4
+        )
+        self.server_url_entry = self.ttk.Entry(
+            self.advanced_frame, textvariable=self.server_url_var
+        )
+        self.server_url_entry.grid(row=7, column=1, sticky="ew", pady=4)
+        self.server_discover_button = self.ttk.Button(
+            self.advanced_frame, text="Discover", command=self._start_discovery
+        )
+        self.server_discover_button.grid(row=7, column=2, padx=(8, 0))
+
         self.ttk.Label(self.advanced_frame, text="Theme").grid(
-            row=7, column=0, sticky="w", pady=(8, 0)
+            row=8, column=0, sticky="w", pady=(8, 0)
         )
         theme_choice = self.ttk.Frame(self.advanced_frame)
-        theme_choice.grid(row=7, column=1, columnspan=2, sticky="w", pady=(8, 0))
+        theme_choice.grid(row=8, column=1, columnspan=2, sticky="w", pady=(8, 0))
         for value, label in ("os", "OS"), ("light", "Light"), ("dark", "Dark"):
             self.ttk.Radiobutton(
                 theme_choice,
@@ -644,6 +664,110 @@ class TalksReducerGUI:
             )
             button.grid(row=row, column=2, padx=(8, 0))
 
+    def _start_discovery(self) -> None:
+        """Search the local network for running Talks Reducer servers."""
+
+        if self._discovery_thread and self._discovery_thread.is_alive():
+            return
+
+        self.server_discover_button.configure(
+            state=self.tk.DISABLED, text="Discovering…"
+        )
+        self._append_log("Discovering Talks Reducer servers on port 9005…")
+
+        def worker() -> None:
+            try:
+                urls = discover_servers()
+            except Exception as exc:  # pragma: no cover - network failure safeguard
+                self._notify(lambda: self._on_discovery_failed(exc))
+                return
+            self._notify(lambda: self._on_discovery_complete(urls))
+
+        self._discovery_thread = threading.Thread(target=worker, daemon=True)
+        self._discovery_thread.start()
+
+    def _on_discovery_failed(self, exc: Exception) -> None:
+        self.server_discover_button.configure(state=self.tk.NORMAL, text="Discover")
+        message = f"Discovery failed: {exc}"
+        self._append_log(message)
+        self.messagebox.showerror("Discovery failed", message)
+
+    def _on_discovery_complete(self, urls: List[str]) -> None:
+        self.server_discover_button.configure(state=self.tk.NORMAL, text="Discover")
+        if not urls:
+            self._append_log("No Talks Reducer servers were found.")
+            self.messagebox.showinfo(
+                "No servers found",
+                "No Talks Reducer servers responded on port 9005.",
+            )
+            return
+
+        self._append_log(
+            f"Discovered {len(urls)} server{'s' if len(urls) != 1 else ''}."
+        )
+
+        if len(urls) == 1:
+            self.server_url_var.set(urls[0])
+            return
+
+        self._show_discovery_results(urls)
+
+    def _show_discovery_results(self, urls: List[str]) -> None:
+        dialog = self.tk.Toplevel(self.root)
+        dialog.title("Select server")
+        dialog.transient(self.root)
+        dialog.grab_set()
+
+        self.ttk.Label(dialog, text="Select a Talks Reducer server:").grid(
+            row=0, column=0, columnspan=2, sticky="w", padx=self.PADDING, pady=(12, 4)
+        )
+
+        listbox = self.tk.Listbox(
+            dialog,
+            height=min(10, len(urls)),
+            selectmode=self.tk.SINGLE,
+        )
+        listbox.grid(
+            row=1,
+            column=0,
+            columnspan=2,
+            padx=self.PADDING,
+            sticky="nsew",
+        )
+        dialog.columnconfigure(0, weight=1)
+        dialog.columnconfigure(1, weight=1)
+        dialog.rowconfigure(1, weight=1)
+
+        for url in urls:
+            listbox.insert(self.tk.END, url)
+        listbox.select_set(0)
+
+        def choose(_: object | None = None) -> None:
+            selection = listbox.curselection()
+            if not selection:
+                return
+            index = selection[0]
+            self.server_url_var.set(urls[index])
+            dialog.grab_release()
+            dialog.destroy()
+
+        def cancel() -> None:
+            dialog.grab_release()
+            dialog.destroy()
+
+        listbox.bind("<Double-Button-1>", choose)
+        listbox.bind("<Return>", choose)
+
+        button_frame = self.ttk.Frame(dialog)
+        button_frame.grid(row=2, column=0, columnspan=2, pady=(8, 12))
+        self.ttk.Button(button_frame, text="Use server", command=choose).pack(
+            side=self.tk.LEFT, padx=(0, 8)
+        )
+        self.ttk.Button(button_frame, text="Cancel", command=cancel).pack(
+            side=self.tk.LEFT
+        )
+        dialog.protocol("WM_DELETE_WINDOW", cancel)
+
     def _toggle_simple_mode(self) -> None:
         self._update_setting("simple_mode", self.simple_mode_var.get())
         self._apply_simple_mode()
@@ -726,6 +850,10 @@ class TalksReducerGUI:
             "open_after_convert", bool(self.open_after_convert_var.get())
         )
 
+    def _on_server_url_change(self, *_: object) -> None:
+        value = self.server_url_var.get().strip()
+        self._update_setting("server_url", value)
+
     def _apply_theme(self) -> None:
         preference = self.theme_var.get().lower()
         if preference not in {"light", "dark"}:
@@ -1017,14 +1145,12 @@ class TalksReducerGUI:
         self._append_log("Starting processing…")
         self._stop_requested = False
         open_after_convert = bool(self.open_after_convert_var.get())
+        server_url = self.server_url_var.get().strip()
 
         def worker() -> None:
             def set_process(proc: subprocess.Popen) -> None:
                 self._ffmpeg_process = proc
 
-            reporter = _TkProgressReporter(
-                self._append_log, process_callback=set_process
-            )
             try:
                 files = gather_input_files(self.input_files)
                 if not files:
@@ -1036,6 +1162,20 @@ class TalksReducerGUI:
                     self._set_status("Idle")
                     return
 
+                if server_url:
+                    success = self._process_files_via_server(
+                        files,
+                        args,
+                        server_url,
+                        open_after_convert=open_after_convert,
+                    )
+                    if success:
+                        self._notify(self._hide_stop_button)
+                    return
+
+                reporter = _TkProgressReporter(
+                    self._append_log, process_callback=set_process
+                )
                 for index, file in enumerate(files, start=1):
                     self._append_log(
                         f"Processing {index}/{len(files)}: {os.path.basename(file)}"
@@ -1085,7 +1225,10 @@ class TalksReducerGUI:
         self._processing_thread.start()
 
         # Show Stop button when processing starts
-        self.stop_button.grid()
+        if server_url:
+            self.stop_button.grid_remove()
+        else:
+            self.stop_button.grid()
 
     def _stop_processing(self) -> None:
         """Stop the currently running processing by terminating FFmpeg."""
@@ -1153,6 +1296,80 @@ class TalksReducerGUI:
             args["small"] = True
         return args
 
+    def _process_files_via_server(
+        self,
+        files: List[str],
+        args: dict[str, object],
+        server_url: str,
+        *,
+        open_after_convert: bool,
+    ) -> bool:
+        """Send *files* to the configured server for processing."""
+
+        try:
+            service_module = importlib.import_module("talks_reducer.service_client")
+        except ModuleNotFoundError as exc:
+            self._append_log(f"Server client unavailable: {exc}")
+            self._notify(
+                lambda: self.messagebox.showerror(
+                    "Server unavailable",
+                    "Remote processing requires the gradio_client package.",
+                )
+            )
+            self._notify(lambda: self._set_status("Error"))
+            return False
+
+        output_override = args.get("output_file") if len(files) == 1 else None
+        ignored = [key for key in args if key not in {"output_file", "small"}]
+        if ignored:
+            ignored_options = ", ".join(sorted(ignored))
+            self._append_log(
+                f"Server mode ignores the following options: {ignored_options}"
+            )
+
+        for index, file in enumerate(files, start=1):
+            basename = os.path.basename(file)
+            self._append_log(
+                f"Uploading {index}/{len(files)}: {basename} to {server_url}"
+            )
+            try:
+                destination, summary, log_text = service_module.send_video(
+                    input_path=Path(file),
+                    output_path=output_override,
+                    server_url=server_url,
+                    small=bool(args.get("small", False)),
+                )
+            except Exception as exc:  # pragma: no cover - network safeguard
+                error_msg = f"Processing failed: {exc}"
+                self._append_log(error_msg)
+                self._notify(lambda: self._set_status("Error"))
+                self._notify(
+                    lambda: self.messagebox.showerror(
+                        "Server error",
+                        f"Failed to process {basename}: {exc}",
+                    )
+                )
+                return False
+
+            self._last_output = Path(destination)
+            self._last_time_ratio = None
+            self._last_size_ratio = None
+            for line in summary.splitlines():
+                self._append_log(line)
+            if log_text.strip():
+                self._append_log("Server log:")
+                for line in log_text.splitlines():
+                    self._append_log(line)
+            if open_after_convert:
+                self._notify(
+                    lambda path=self._last_output: self._open_in_file_manager(path)
+                )
+
+        self._append_log("All jobs finished successfully.")
+        self._notify(lambda: self.open_button.configure(state=self.tk.NORMAL))
+        self._notify(self._clear_input_files)
+        return True
+
     def _parse_float(self, value: str, label: str) -> float:
         try:
             return float(value)
@@ -1526,9 +1743,20 @@ def main(argv: Optional[Sequence[str]] = None) -> bool:
         action="store_true",
         help="Do not start the Talks Reducer server tray alongside the GUI.",
     )
+    parser.add_argument(
+        "--server",
+        action="store_true",
+        help="Launch the Talks Reducer server tray instead of the desktop GUI.",
+    )
 
     parsed_args, remaining = parser.parse_known_args(argv)
     no_tray = parsed_args.no_tray
+    if parsed_args.server:
+        package_name = __package__ or "talks_reducer"
+        tray_module = importlib.import_module(f"{package_name}.server_tray")
+        tray_main = getattr(tray_module, "main")
+        tray_main(remaining)
+        return False
     argv = remaining
 
     if argv:

{talks_reducer-0.5.2 → talks_reducer-0.5.5}/talks_reducer/server.py

@@ -309,7 +309,7 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
 
     parser = argparse.ArgumentParser(description="Launch the Talks Reducer web UI.")
     parser.add_argument(
-        "--host", dest="host", default=None, help="Custom host to bind."
+        "--host", dest="host", default="0.0.0.0", help="Custom host to bind."
     )
     parser.add_argument(
         "--port",

{talks_reducer-0.5.2 → talks_reducer-0.5.5}/talks_reducer/server_tray.py

@@ -35,7 +35,7 @@ def _guess_local_url(host: Optional[str], port: int) -> str:
     """Return the URL the server is most likely reachable at locally."""
 
     if host in (None, "", "0.0.0.0", "::"):
-        hostname = "127.0.0.1"
+        hostname = "0.0.0.0"
     else:
         hostname = host
     return f"http://{hostname}:{port}/"

{talks_reducer-0.5.2 → talks_reducer-0.5.5/talks_reducer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: talks-reducer
-Version: 0.5.2
+Version: 0.5.5
 Summary: CLI for speeding up long-form talks by removing silence
 Author: Talks Reducer Maintainers
 License-Expression: MIT
@@ -70,6 +70,14 @@ Example CLI usage:
 talks-reducer --small input.mp4
 ```
 
+Need to offload work to a remote Talks Reducer server? Pass `--url` with the
+server address and the CLI will upload the input, wait for processing to finish,
+and download the rendered video:
+
+```sh
+talks-reducer --url http://localhost:9005 demo.mp4
+```
+
 ### Speech detection
 
 Talks Reducer now relies on its built-in volume thresholding to detect speech. Adjust `--silent_threshold` if you need to fine-tune when segments count as silence. Dropping the optional Silero VAD integration keeps the install lightweight and avoids pulling in PyTorch.
@@ -91,6 +99,10 @@ Want the server to live in your system tray instead of a terminal window? Use:
 talks-reducer server-tray
 ```
 
+Bundled Windows builds include the same behaviour: run
+`talks-reducer.exe --server` to launch the tray-managed server directly from the
+desktop shortcut without opening the GUI first.
+
 Pass `--debug` to print verbose logs about the tray icon lifecycle, and
 `--tray-mode pystray-detached` to try pystray's alternate detached runner. If
 the icon backend refuses to appear, fall back to `--tray-mode headless` to keep
@@ -111,6 +123,12 @@ This opens a local web page featuring a drag-and-drop upload zone, a **Small vid
 progress indicator, and automatic previews of the processed output. Once the job completes you can inspect the resulting compression
 ratio and download the rendered video directly from the page.
 
+The desktop GUI mirrors this behaviour. Open **Advanced** settings to provide a
+server URL and click **Discover** to scan your local network for Talks Reducer
+instances listening on port `9005`. Leaving the field blank keeps processing
+local; selecting a discovered server delegates rendering to that machine while
+the GUI downloads the finished files automatically.
+
 ### Uploading and retrieving a processed video
 
 1. Open the printed `http://localhost:<port>` address (the default port is `9005`).

{talks_reducer-0.5.2 → talks_reducer-0.5.5}/talks_reducer.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ talks_reducer/__main__.py
 talks_reducer/audio.py
 talks_reducer/chunks.py
 talks_reducer/cli.py
+talks_reducer/discovery.py
 talks_reducer/ffmpeg.py
 talks_reducer/gui.py
 talks_reducer/models.py
@@ -23,6 +24,7 @@ talks_reducer.egg-info/requires.txt
 talks_reducer.egg-info/top_level.txt
 tests/test_audio.py
 tests/test_cli.py
+tests/test_discovery.py
 tests/test_pipeline_service.py
 tests/test_server.py
 tests/test_service_client.py

{talks_reducer-0.5.2 → talks_reducer-0.5.5}/tests/test_cli.py

@@ -44,6 +44,7 @@ def test_main_runs_cli_with_arguments(monkeypatch: pytest.MonkeyPatch) -> None:
         frame_spreadage=None,
         sample_rate=None,
         small=False,
+        server_url=None,
     )
 
     parser_mock = mock.Mock()
@@ -103,3 +104,47 @@ def test_main_exits_when_server_unavailable(monkeypatch: pytest.MonkeyPatch) ->
 
     with pytest.raises(SystemExit):
         cli.main(["server"])
+
+
+def test_main_uses_remote_server_when_url_provided(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """The CLI should delegate to the remote server client when --url is set."""
+
+    parsed_args = SimpleNamespace(
+        input_file=["input.mp4"],
+        output_file=None,
+        temp_folder=None,
+        silent_threshold=None,
+        silent_speed=None,
+        sounded_speed=None,
+        frame_spreadage=None,
+        sample_rate=None,
+        small=True,
+        server_url="http://localhost:9005/",
+    )
+
+    parser_mock = mock.Mock()
+    parser_mock.parse_args.return_value = parsed_args
+
+    def fake_gather_input_files(_paths: list[str]) -> list[str]:
+        return ["/tmp/input.mp4"]
+
+    calls: list[SimpleNamespace] = []
+
+    def fake_send_video(**kwargs):
+        calls.append(SimpleNamespace(**kwargs))
+        return Path("/tmp/result.mp4"), "Summary", "Log"
+
+    monkeypatch.setattr(cli, "_build_parser", lambda: parser_mock)
+    monkeypatch.setattr(cli, "gather_input_files", fake_gather_input_files)
+    monkeypatch.setattr(cli, "_launch_gui", lambda argv: False)
+    import talks_reducer.service_client as service_client_module
+
+    monkeypatch.setattr(service_client_module, "send_video", fake_send_video)
+
+    cli.main(["input.mp4", "--url", "http://localhost:9005/"])
+
+    assert len(calls) == 1
+    assert calls[0].input_path == Path("/tmp/input.mp4")
+    assert calls[0].small is True

talks_reducer-0.5.5/tests/test_discovery.py

@@ -0,0 +1,52 @@
+"""Tests for the network discovery helper utilities."""
+
+from __future__ import annotations
+
+import http.server
+import threading
+from contextlib import contextmanager
+
+from talks_reducer import discovery
+
+
+@contextmanager
+def _http_server() -> tuple[str, int]:
+    """Start a lightweight HTTP server for discovery tests."""
+
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self) -> None:  # pragma: no cover - exercised via discovery
+            self.send_response(200)
+            self.end_headers()
+            self.wfile.write(b"OK")
+
+        def log_message(self, *args, **kwargs):  # type: ignore[override]
+            return
+
+    server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    host, port = server.server_address
+
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+
+    try:
+        yield host, port
+    finally:
+        server.shutdown()
+        thread.join(timeout=2)
+
+
+def test_discover_servers_detects_running_instance() -> None:
+    """The discovery helper should report a reachable local server."""
+
+    with _http_server() as (host, port):
+        results = discovery.discover_servers(port=port, hosts=[host])
+
+    expected_url = f"http://{host}:{port}/"
+    assert expected_url in results
+
+
+def test_discover_servers_handles_missing_hosts() -> None:
+    """Scanning an unreachable host should return an empty result list."""
+
+    results = discovery.discover_servers(port=65500, hosts=["192.0.2.123"])
+    assert results == []