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

talks_reducer/__about__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.7.1"
+__version__ = "0.8.0"

talks_reducer/cli.py

@@ -10,10 +10,9 @@ import sys
 import time
 from importlib import import_module
 from pathlib import Path
-from typing import Dict, List, Optional, Sequence, Tuple
+from typing import Callable, Dict, List, Optional, Sequence, Tuple
 
 from . import audio
-
 from .ffmpeg import FFmpegNotFoundError
 from .models import ProcessingOptions, default_temp_folder
 from .pipeline import speed_up_video
@@ -141,116 +140,215 @@ def _print_total_time(start_time: float) -> None:
     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.
+class CliApplication:
+    """Coordinator for CLI processing with dependency injection support."""
 
-    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.
-    """
+    def __init__(
+        self,
+        *,
+        gather_files: Callable[[List[str]], List[str]],
+        send_video: Optional[Callable[..., Tuple[Path, str, str]]],
+        speed_up: Callable[[ProcessingOptions, object], object],
+        reporter_factory: Callable[[], object],
+        remote_error_message: Optional[str] = None,
+    ) -> None:
+        self._gather_files = gather_files
+        self._send_video = send_video
+        self._speed_up = speed_up
+        self._reporter_factory = reporter_factory
+        self._remote_error_message = remote_error_message
 
-    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,
-        )
+    def run(self, parsed_args: argparse.Namespace) -> Tuple[int, List[str]]:
+        """Execute the CLI pipeline for *parsed_args*."""
 
-    remote_option_values: Dict[str, float] = {}
-    if parsed_args.silent_threshold is not None:
-        remote_option_values["silent_threshold"] = float(parsed_args.silent_threshold)
-    if parsed_args.silent_speed is not None:
-        remote_option_values["silent_speed"] = float(parsed_args.silent_speed)
-    if parsed_args.sounded_speed is not None:
-        remote_option_values["sounded_speed"] = float(parsed_args.sounded_speed)
-
-    unsupported_options = []
-    for name in (
-        "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,
-        )
+        start_time = time.time()
+        files = self._gather_files(parsed_args.input_file)
 
-    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),
-                **remote_option_values,
-                log_callback=_stream_server_log,
-                stream_updates=stream_updates,
-                progress_callback=_stream_progress if stream_updates else None,
+        args: Dict[str, object] = {
+            key: value for key, value in vars(parsed_args).items() if value is not 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"]
+
+        error_messages: List[str] = []
+        reporter_logs: List[str] = []
+
+        if getattr(parsed_args, "server_url", None):
+            remote_success, remote_errors, fallback_logs = self._process_via_server(
+                files, parsed_args, start_time
+            )
+            error_messages.extend(remote_errors)
+            reporter_logs.extend(fallback_logs)
+            if remote_success:
+                return 0, error_messages
+
+        reporter = self._reporter_factory()
+        for message in reporter_logs:
+            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)
+
+            option_kwargs: Dict[str, object] = {"input_file": Path(file)}
+
+            if "output_file" in local_options:
+                option_kwargs["output_file"] = Path(local_options["output_file"])
+            if "temp_folder" in local_options:
+                option_kwargs["temp_folder"] = Path(local_options["temp_folder"])
+            if "silent_threshold" in local_options:
+                option_kwargs["silent_threshold"] = float(
+                    local_options["silent_threshold"]
+                )
+            if "silent_speed" in local_options:
+                option_kwargs["silent_speed"] = float(local_options["silent_speed"])
+            if "sounded_speed" in local_options:
+                option_kwargs["sounded_speed"] = float(local_options["sounded_speed"])
+            if "frame_spreadage" in local_options:
+                option_kwargs["frame_spreadage"] = int(local_options["frame_spreadage"])
+            if "sample_rate" in local_options:
+                option_kwargs["sample_rate"] = int(local_options["sample_rate"])
+            if "small" in local_options:
+                option_kwargs["small"] = bool(local_options["small"])
+            options = ProcessingOptions(**option_kwargs)
+
+            try:
+                result = self._speed_up(options, reporter=reporter)
+            except FFmpegNotFoundError as exc:
+                message = str(exc)
+                return 1, [*error_messages, message]
+
+            reporter.log(f"Completed: {result.output_file}")
+            summary_parts: List[str] = []
+            time_ratio = getattr(result, "time_ratio", None)
+            size_ratio = getattr(result, "size_ratio", None)
+            if time_ratio is not None:
+                summary_parts.append(f"{time_ratio * 100:.0f}% time")
+            if size_ratio is not None:
+                summary_parts.append(f"{size_ratio * 100:.0f}% size")
+            if summary_parts:
+                reporter.log("Result: " + ", ".join(summary_parts))
+
+        _print_total_time(start_time)
+        return 0, error_messages
+
+    def _process_via_server(
+        self,
+        files: Sequence[str],
+        parsed_args: argparse.Namespace,
+        start_time: float,
+    ) -> Tuple[bool, List[str], List[str]]:
+        """Upload *files* to the configured server and download the results."""
+
+        if not self._send_video:
+            message = self._remote_error_message or "Server processing is unavailable."
+            fallback_notice = "Falling back to local processing pipeline."
+            return False, [message, fallback_notice], [message, fallback_notice]
+
+        server_url = parsed_args.server_url
+        if not server_url:
+            message = "Server URL was not provided."
+            fallback_notice = "Falling back to local processing pipeline."
+            return False, [message, fallback_notice], [message, fallback_notice]
+
+        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,
             )
-        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)
+        remote_option_values: Dict[str, float] = {}
+        if parsed_args.silent_threshold is not None:
+            remote_option_values["silent_threshold"] = float(
+                parsed_args.silent_threshold
+            )
+        if parsed_args.silent_speed is not None:
+            remote_option_values["silent_speed"] = float(parsed_args.silent_speed)
+        if parsed_args.sounded_speed is not None:
+            remote_option_values["sounded_speed"] = float(parsed_args.sounded_speed)
+
+        unsupported_options: List[str] = []
+        for name in ("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,
+            )
 
-    _print_total_time(start_time)
-    return True, None
+        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 = self._send_video(
+                    input_path=Path(file),
+                    output_path=output_override,
+                    server_url=server_url,
+                    small=bool(parsed_args.small),
+                    **remote_option_values,
+                    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
+                message = f"Failed to process {basename} via server: {exc}"
+                fallback_notice = "Falling back to local processing pipeline."
+                return False, [message, fallback_notice], [message, fallback_notice]
+
+            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, [], []
 
 
 def _launch_gui(argv: Sequence[str]) -> bool:
@@ -421,84 +519,30 @@ def main(argv: Optional[Sequence[str]] = None) -> 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)
-
-    args: Dict[str, object] = {
-        k: v for k, v in vars(parsed_args).items() if v is not 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
+    send_video = None
+    remote_error_message: Optional[str] = None
+    try:  # pragma: no cover - optional dependency guard
+        from . import service_client
+    except ImportError as exc:
+        remote_error_message = (
+            "Server mode requires the gradio_client dependency. " f"({exc})"
         )
-        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)
-
-        option_kwargs: Dict[str, object] = {"input_file": Path(file)}
-
-        if "output_file" in local_options:
-            option_kwargs["output_file"] = Path(local_options["output_file"])
-        if "temp_folder" in local_options:
-            option_kwargs["temp_folder"] = Path(local_options["temp_folder"])
-        if "silent_threshold" in local_options:
-            option_kwargs["silent_threshold"] = float(local_options["silent_threshold"])
-        if "silent_speed" in local_options:
-            option_kwargs["silent_speed"] = float(local_options["silent_speed"])
-        if "sounded_speed" in local_options:
-            option_kwargs["sounded_speed"] = float(local_options["sounded_speed"])
-        if "frame_spreadage" in local_options:
-            option_kwargs["frame_spreadage"] = int(local_options["frame_spreadage"])
-        if "sample_rate" in local_options:
-            option_kwargs["sample_rate"] = int(local_options["sample_rate"])
-        if "small" in local_options:
-            option_kwargs["small"] = bool(local_options["small"])
-        options = ProcessingOptions(**option_kwargs)
-
-        try:
-            result = speed_up_video(options, reporter=reporter)
-        except FFmpegNotFoundError as exc:
-            print(str(exc), file=sys.stderr)
-            sys.exit(1)
+    else:
+        send_video = service_client.send_video
+
+    application = CliApplication(
+        gather_files=gather_input_files,
+        send_video=send_video,
+        speed_up=speed_up_video,
+        reporter_factory=TqdmProgressReporter,
+        remote_error_message=remote_error_message,
+    )
 
-        reporter.log(f"Completed: {result.output_file}")
-        summary_parts = []
-        time_ratio = getattr(result, "time_ratio", None)
-        size_ratio = getattr(result, "size_ratio", None)
-        if time_ratio is not None:
-            summary_parts.append(f"{time_ratio * 100:.0f}% time")
-        if size_ratio is not None:
-            summary_parts.append(f"{size_ratio * 100:.0f}% size")
-        if summary_parts:
-            reporter.log("Result: " + ", ".join(summary_parts))
-
-    _print_total_time(start_time)
+    exit_code, error_messages = application.run(parsed_args)
+    for message in error_messages:
+        print(message, file=sys.stderr)
+    if exit_code:
+        sys.exit(exit_code)
 
 
 if __name__ == "__main__":

talks_reducer/discovery.py

@@ -7,7 +7,7 @@ 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
+from typing import Callable, Iterable, Iterator, List, Optional, Sequence, Set
 
 DEFAULT_PORT = 9005
 DEFAULT_TIMEOUT = 0.4
@@ -15,6 +15,10 @@ DEFAULT_TIMEOUT = 0.4
 _EXCLUDED_HOSTS = {"127.0.0.1", "localhost", "0.0.0.0"}
 
 
+AddressSource = Callable[[], Iterable[str]]
+ProbeHost = Callable[[str, int, float], Optional[str]]
+
+
 def _should_include_host(host: Optional[str]) -> bool:
     """Return ``True`` when *host* should be scanned for discovery."""
 
@@ -23,39 +27,85 @@ def _should_include_host(host: Optional[str]) -> bool:
     return host not in _EXCLUDED_HOSTS
 
 
-def _iter_local_ipv4_addresses() -> Iterator[str]:
-    """Yield IPv4 addresses that belong to the local machine."""
+def _create_udp_socket(family: int, type_: int) -> socket.socket:
+    """Return a UDP socket created with :func:`socket.socket`."""
 
-    seen: Set[str] = set()
+    return socket.socket(family, type_)
+
+
+def _iter_getaddrinfo_addresses(
+    *,
+    hostname_resolver: Callable[[], str] = socket.gethostname,
+    getaddrinfo: Callable[..., Sequence[Sequence[object]]] = socket.getaddrinfo,
+) -> Iterator[str]:
+    """Yield IPv4 addresses discovered via ``getaddrinfo``."""
 
     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
+        hostname = hostname_resolver()
+    except OSError:
+        return
+
+    try:
+        for info in getaddrinfo(hostname, None, family=socket.AF_INET):
+            try:
+                address = info[4][0]  # type: ignore[index]
+            except (IndexError, TypeError):
+                continue
+            if address:
+                yield str(address)
     except socket.gaierror:
-        pass
+        return
+
 
-    for probe in ("8.8.8.8", "1.1.1.1"):
+def _iter_probe_addresses(
+    probes: Iterable[str] = ("8.8.8.8", "1.1.1.1"),
+    *,
+    socket_factory: Callable[[int, int], socket.socket] = _create_udp_socket,
+) -> Iterator[str]:
+    """Yield IPv4 addresses by opening UDP sockets to well-known hosts."""
+
+    for probe in probes:
         try:
-            with closing(socket.socket(socket.AF_INET, socket.SOCK_DGRAM)) as sock:
+            with closing(socket_factory(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)
+                if address:
                     yield address
         except OSError:
             continue
 
 
-def _build_default_host_candidates(prefix_length: int = 24) -> List[str]:
+def _iter_local_ipv4_addresses(
+    *, address_sources: Optional[Iterable[AddressSource]] = None
+) -> Iterator[str]:
+    """Yield IPv4 addresses that belong to the local machine."""
+
+    seen: Set[str] = set()
+    sources: Iterable[AddressSource]
+    if address_sources is None:
+        sources = (_iter_getaddrinfo_addresses, _iter_probe_addresses)
+    else:
+        sources = address_sources
+
+    for source in sources:
+        for address in source():
+            if not address:
+                continue
+            if address not in seen:
+                seen.add(address)
+                yield address
+
+
+def _build_default_host_candidates(
+    prefix_length: int = 24,
+    *,
+    address_sources: Optional[Iterable[AddressSource]] = None,
+) -> List[str]:
     """Return a list of host candidates based on detected local networks."""
 
     hosts: Set[str] = set()
 
-    for address in _iter_local_ipv4_addresses():
+    for address in _iter_local_ipv4_addresses(address_sources=address_sources):
         if _should_include_host(address):
             hosts.add(address)
         try:
@@ -104,6 +154,8 @@ def discover_servers(
     timeout: float = DEFAULT_TIMEOUT,
     hosts: Optional[Iterable[str]] = None,
     progress_callback: Optional[ProgressCallback] = None,
+    address_sources: Optional[Iterable[AddressSource]] = None,
+    probe_host: Optional[ProbeHost] = None,
 ) -> List[str]:
     """Scan *hosts* for running Talks Reducer servers on *port*.
 
@@ -111,7 +163,9 @@ def discover_servers(
     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
+    candidate count whenever discovery advances. Supply *address_sources* to
+    override the IPv4 detection logic with custom iterables, and *probe_host*
+    to replace the HTTP-based reachability probe. The function returns a sorted
     list of unique base URLs.
     """
 
@@ -119,7 +173,9 @@ def discover_servers(
         candidates = sorted(
             {
                 host
-                for host in _build_default_host_candidates()
+                for host in _build_default_host_candidates(
+                    address_sources=address_sources
+                )
                 if _should_include_host(host)
             }
         )
@@ -132,11 +188,11 @@ def discover_servers(
     if progress_callback is not None:
         progress_callback(0, total)
 
+    probe_fn: ProbeHost = _probe_host if probe_host is None else probe_host
+
     with ThreadPoolExecutor(max_workers=32) as executor:
         scanned = 0
-        for url in executor.map(
-            lambda host: _probe_host(host, port, timeout), candidates
-        ):
+        for url in executor.map(lambda host: probe_fn(host, port, timeout), candidates):
             if url and url not in results:
                 results.append(url)
             scanned += 1