talks-reducer 0.5.3__py3-none-any.whl → 0.6.0__py3-none-any.whl

talks_reducer/__about__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.5.3"
+__version__ = "0.6.0"

talks_reducer/cli.py

@@ -4,12 +4,14 @@ from __future__ import annotations
 
 import argparse
 import os
+import shutil
+import subprocess
 import sys
 import time
 from importlib import import_module
 from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
-from typing import Dict, List, Optional, Sequence
+from typing import Dict, List, Optional, Sequence, Tuple
 
 from . import audio
 
@@ -98,6 +100,23 @@ 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).",
+    )
+    parser.add_argument(
+        "--host",
+        dest="host",
+        default=None,
+        help="Shortcut for --url when targeting a Talks Reducer server on port 9005 (for example, localhost).",
+    )
+    parser.add_argument(
+        "--server-stream",
+        action="store_true",
+        help="Stream remote progress updates when using --url.",
+    )
     return parser
 
 
@@ -128,6 +147,122 @@ 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
+) -> Tuple[bool, Optional[str]]:
+    """Upload *files* to the configured server and download the results.
+
+    Returns a tuple of (success, error_message). When *success* is ``False``,
+    ``error_message`` contains the reason and the caller should fall back to the
+    local processing pipeline.
+    """
+
+    try:
+        from . import service_client
+    except ImportError as exc:  # pragma: no cover - optional dependency guard
+        return False, ("Server mode requires the gradio_client dependency. " f"({exc})")
+
+    server_url = parsed_args.server_url
+    if not server_url:
+        return False, "Server URL was not provided."
+
+    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}"
+        )
+        printed_log_header = False
+        progress_state: dict[str, tuple[Optional[int], Optional[int], str]] = {}
+        stream_updates = bool(getattr(parsed_args, "server_stream", False))
+
+        def _stream_server_log(line: str) -> None:
+            nonlocal printed_log_header
+            if not printed_log_header:
+                print("\nServer log:", flush=True)
+                printed_log_header = True
+            print(line, flush=True)
+
+        def _stream_progress(
+            desc: str, current: Optional[int], total: Optional[int], unit: str
+        ) -> None:
+            key = desc or "Processing"
+            state = (current, total, unit)
+            if progress_state.get(key) == state:
+                return
+            progress_state[key] = state
+
+            parts: list[str] = []
+            if current is not None and total and total > 0:
+                percent = (current / total) * 100
+                parts.append(f"{current}/{total}")
+                parts.append(f"{percent:.1f}%")
+            elif current is not None:
+                parts.append(str(current))
+            if unit:
+                parts.append(unit)
+            message = " ".join(parts).strip()
+            print(f"{key}: {message or 'update'}", flush=True)
+
+        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),
+                log_callback=_stream_server_log,
+                stream_updates=stream_updates,
+                progress_callback=_stream_progress if stream_updates else None,
+            )
+        except Exception as exc:  # pragma: no cover - network failure safeguard
+            return False, f"Failed to process {basename} via server: {exc}"
+
+        print(summary)
+        print(f"Saved processed video to {destination}")
+        if log_text.strip() and not printed_log_header:
+            print("\nServer log:\n" + log_text)
+
+    _print_total_time(start_time)
+    return True, None
+
+
 def _launch_gui(argv: Sequence[str]) -> bool:
     """Attempt to launch the GUI with the provided arguments."""
 
@@ -144,7 +279,7 @@ def _launch_gui(argv: Sequence[str]) -> bool:
 
 
 def _launch_server(argv: Sequence[str]) -> bool:
-    """Attempt to launch the Gradio web server with the provided arguments."""
+    """Attempt to launch the Gradio server with the provided arguments."""
 
     try:
         server_module = import_module(".server", __package__)
@@ -159,6 +294,103 @@ def _launch_server(argv: Sequence[str]) -> bool:
     return True
 
 
+def _find_server_tray_binary() -> Optional[Path]:
+    """Return the best available path to the server tray executable."""
+
+    binary_name = "talks-reducer-server-tray"
+    candidates: List[Path] = []
+
+    which_path = shutil.which(binary_name)
+    if which_path:
+        candidates.append(Path(which_path))
+
+    try:
+        launcher_dir = Path(sys.argv[0]).resolve().parent
+    except Exception:
+        launcher_dir = None
+
+    potential_names = [binary_name]
+    if sys.platform == "win32":
+        potential_names = [f"{binary_name}.exe", binary_name]
+
+    if launcher_dir is not None:
+        for name in potential_names:
+            candidates.append(launcher_dir / name)
+
+    for candidate in candidates:
+        if candidate and candidate.exists() and os.access(candidate, os.X_OK):
+            return candidate
+
+    return None
+
+
+def _should_hide_subprocess_console() -> bool:
+    """Return ``True` ` when a detached Windows launch should hide the console."""
+
+    if sys.platform != "win32":
+        return False
+
+    try:
+        import ctypes
+    except Exception:  # pragma: no cover - optional runtime dependency
+        return False
+
+    try:
+        get_console_window = ctypes.windll.kernel32.GetConsoleWindow  # type: ignore[attr-defined]
+    except Exception:  # pragma: no cover - platform specific guard
+        return False
+
+    try:
+        handle = get_console_window()
+    except Exception:  # pragma: no cover - defensive fallback
+        return False
+
+    return handle == 0
+
+
+def _launch_server_tray_binary(argv: Sequence[str]) -> bool:
+    """Launch the packaged server tray executable when available."""
+
+    command = _find_server_tray_binary()
+    if command is None:
+        return False
+
+    tray_args = [str(command), *list(argv)]
+
+    run_kwargs: Dict[str, object] = {"check": False}
+
+    if sys.platform == "win32":
+        no_window_flag = getattr(subprocess, "CREATE_NO_WINDOW", 0)
+        if no_window_flag and _should_hide_subprocess_console():
+            run_kwargs["creationflags"] = no_window_flag
+
+    try:
+        result = subprocess.run(tray_args, **run_kwargs)
+    except OSError:
+        return False
+
+    return result.returncode == 0
+
+
+def _launch_server_tray(argv: Sequence[str]) -> bool:
+    """Attempt to launch the server tray helper with the provided arguments."""
+
+    if _launch_server_tray_binary(argv):
+        return True
+
+    try:
+        tray_module = import_module(".server_tray", __package__)
+    except ImportError:
+        return False
+
+    tray_main = getattr(tray_module, "main", None)
+    if tray_main is None:
+        return False
+
+    tray_main(list(argv))
+    return True
+
+
 def main(argv: Optional[Sequence[str]] = None) -> None:
     """Entry point for the command line interface.
 
@@ -170,6 +402,14 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
     else:
         argv_list = list(argv)
 
+    if "--server" in argv_list:
+        index = argv_list.index("--server")
+        tray_args = argv_list[index + 1 :]
+        if not _launch_server_tray(tray_args):
+            print("Server tray mode is unavailable.", file=sys.stderr)
+            sys.exit(1)
+        return
+
     if argv_list and argv_list[0] in {"server", "serve"}:
         if not _launch_server(argv_list[1:]):
             print("Gradio server mode is unavailable.", file=sys.stderr)
@@ -186,6 +426,11 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
 
     parser = _build_parser()
     parsed_args = parser.parse_args(argv_list)
+
+    host_value = getattr(parsed_args, "host", None)
+    if host_value:
+        parsed_args.server_url = f"http://{host_value}:9005"
+
     start_time = time.time()
 
     files = gather_input_files(parsed_args.input_file)
@@ -195,11 +440,33 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
     }
     del args["input_file"]
 
+    if "host" in args:
+        del args["host"]
+
     if len(files) > 1 and "output_file" in args:
         del args["output_file"]
 
+    fallback_messages: List[str] = []
+    if parsed_args.server_url:
+        server_success, error_message = _process_via_server(
+            files, parsed_args, start_time=start_time
+        )
+        if server_success:
+            return
+
+        fallback_reason = error_message or "Server processing is unavailable."
+        print(fallback_reason, file=sys.stderr)
+        fallback_messages.append(fallback_reason)
+
+        fallback_notice = "Falling back to local processing pipeline."
+        print(fallback_notice, file=sys.stderr)
+        fallback_messages.append(fallback_notice)
+
     reporter = TqdmProgressReporter()
 
+    for message in fallback_messages:
+        reporter.log(message)
+
     for index, file in enumerate(files):
         print(f"Processing file {index + 1}/{len(files)} '{os.path.basename(file)}'")
         local_options = dict(args)
@@ -241,11 +508,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/discovery.py

@@ -0,0 +1,149 @@
+"""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 Callable, Iterable, Iterator, List, Optional, Set
+
+DEFAULT_PORT = 9005
+DEFAULT_TIMEOUT = 0.4
+
+_EXCLUDED_HOSTS = {"127.0.0.1", "localhost", "0.0.0.0"}
+
+
+def _should_include_host(host: Optional[str]) -> bool:
+    """Return ``True`` when *host* should be scanned for discovery."""
+
+    if not host:
+        return False
+    return host not in _EXCLUDED_HOSTS
+
+
+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] = set()
+
+    for address in _iter_local_ipv4_addresses():
+        if _should_include_host(address):
+            hosts.add(address)
+        try:
+            network = ipaddress.ip_network(f"{address}/{prefix_length}", strict=False)
+        except ValueError:
+            continue
+        for host in network.hosts():
+            host_str = str(host)
+            if _should_include_host(host_str):
+                hosts.add(host_str)
+
+    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
+
+
+ProgressCallback = Callable[[int, int], None]
+
+
+def discover_servers(
+    *,
+    port: int = DEFAULT_PORT,
+    timeout: float = DEFAULT_TIMEOUT,
+    hosts: Optional[Iterable[str]] = None,
+    progress_callback: Optional[ProgressCallback] = 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. ``127.0.0.1``, ``localhost``, and ``0.0.0.0`` are
+    excluded to avoid duplicating local endpoints. The optional
+    *progress_callback* receives the number of scanned hosts and the total
+    candidate count whenever discovery advances. The function returns a sorted
+    list of unique base URLs.
+    """
+
+    if hosts is None:
+        candidates = sorted(
+            {
+                host
+                for host in _build_default_host_candidates()
+                if _should_include_host(host)
+            }
+        )
+    else:
+        candidates = sorted({host for host in hosts if _should_include_host(host)})
+
+    results: List[str] = []
+    total = len(candidates)
+
+    if progress_callback is not None:
+        progress_callback(0, total)
+
+    with ThreadPoolExecutor(max_workers=32) as executor:
+        scanned = 0
+        for url in executor.map(
+            lambda host: _probe_host(host, port, timeout), candidates
+        ):
+            if url and url not in results:
+                results.append(url)
+            scanned += 1
+            if progress_callback is not None:
+                progress_callback(scanned, total)
+
+    return results
+
+
+__all__ = ["discover_servers"]