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

talks_reducer/gui/discovery.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, List
 from ..discovery import discover_servers as core_discover_servers
 
 if TYPE_CHECKING:  # pragma: no cover - imported for type checking only
-    from . import TalksReducerGUI
+    from .app import TalksReducerGUI
 
 
 def start_discovery(gui: "TalksReducerGUI") -> None:

talks_reducer/gui/layout.py

@@ -11,7 +11,7 @@ from ..models import default_temp_folder
 if TYPE_CHECKING:  # pragma: no cover - imported for type checking only
     import tkinter as tk
 
-    from . import TalksReducerGUI
+    from .app import TalksReducerGUI
 
 
 def build_layout(gui: "TalksReducerGUI") -> None:

talks_reducer/gui/progress.py

@@ -0,0 +1,80 @@
+"""Progress helpers that bridge the pipeline with the Tkinter GUI."""
+
+from __future__ import annotations
+
+from typing import Callable, Optional
+
+from ..progress import ProgressHandle, SignalProgressReporter
+
+
+class _GuiProgressHandle(ProgressHandle):
+    """Simple progress handle that records totals but only logs milestones."""
+
+    def __init__(self, log_callback: Callable[[str], None], desc: str) -> None:
+        self._log_callback = log_callback
+        self._desc = desc
+        self._current = 0
+        self._total: Optional[int] = None
+        if desc:
+            self._log_callback(f"{desc} started")
+
+    @property
+    def current(self) -> int:
+        return self._current
+
+    def ensure_total(self, total: int) -> None:
+        if self._total is None or total > self._total:
+            self._total = total
+
+    def advance(self, amount: int) -> None:
+        if amount > 0:
+            self._current += amount
+
+    def finish(self) -> None:
+        if self._total is not None:
+            self._current = self._total
+        if self._desc:
+            self._log_callback(f"{self._desc} completed")
+
+    def __enter__(self) -> "_GuiProgressHandle":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> bool:
+        if exc_type is None:
+            self.finish()
+        return False
+
+
+class _TkProgressReporter(SignalProgressReporter):
+    """Progress reporter that forwards updates to the GUI thread."""
+
+    def __init__(
+        self,
+        log_callback: Callable[[str], None],
+        process_callback: Optional[Callable] = None,
+        *,
+        stop_callback: Optional[Callable[[], bool]] = None,
+    ) -> None:
+        self._log_callback = log_callback
+        self.process_callback = process_callback
+        self._stop_callback = stop_callback
+
+    def log(self, message: str) -> None:
+        self._log_callback(message)
+        print(message, flush=True)
+
+    def task(
+        self, *, desc: str = "", total: Optional[int] = None, unit: str = ""
+    ) -> _GuiProgressHandle:
+        del total, unit
+        return _GuiProgressHandle(self._log_callback, desc)
+
+    def stop_requested(self) -> bool:
+        """Return ``True`` when the GUI has asked to cancel processing."""
+
+        if self._stop_callback is None:
+            return False
+        return bool(self._stop_callback())
+
+
+__all__ = ["_GuiProgressHandle", "_TkProgressReporter"]

talks_reducer/gui/remote.py

@@ -14,7 +14,7 @@ from typing import TYPE_CHECKING, Callable, Dict, List, Optional
 from ..pipeline import ProcessingAborted
 
 if TYPE_CHECKING:  # pragma: no cover - imported for type checking only
-    from . import TalksReducerGUI
+    from .app import TalksReducerGUI
 
 
 def normalize_server_url(server_url: str) -> str:
@@ -219,6 +219,12 @@ def check_remote_server_for_gui(
     )
 
 
+def _load_service_client() -> object:
+    """Return the Talks Reducer service client module."""
+
+    return importlib.import_module("talks_reducer.service_client")
+
+
 def process_files_via_server(
     gui: "TalksReducerGUI",
     files: List[str],
@@ -228,6 +234,8 @@ def process_files_via_server(
     open_after_convert: bool,
     default_remote_destination: Callable[[Path, bool], Path],
     parse_summary: Callable[[str], tuple[Optional[float], Optional[float]]],
+    load_service_client: Callable[[], object] = _load_service_client,
+    check_server: Callable[..., bool] = check_remote_server_for_gui,
 ) -> bool:
     """Send *files* to the configured server for processing."""
 
@@ -236,7 +244,7 @@ def process_files_via_server(
             raise ProcessingAborted("Remote processing cancelled by user.")
 
     try:
-        service_module = importlib.import_module("talks_reducer.service_client")
+        service_module = load_service_client()
     except ModuleNotFoundError as exc:
         gui._append_log(f"Server client unavailable: {exc}")
         gui._schedule_on_ui_thread(
@@ -253,7 +261,7 @@ def process_files_via_server(
         lambda: gui._set_status("waiting", f"Waiting server {host_label}...")
     )
 
-    available = check_remote_server_for_gui(
+    available = check_server(
         gui,
         server_url,
         success_status="waiting",

talks_reducer/gui/startup.py

@@ -0,0 +1,202 @@
+"""Startup utilities for launching the Talks Reducer GUI."""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional, Sequence, Tuple
+
+from ..cli import main as cli_main
+from .app import TalksReducerGUI
+
+
+def _check_tkinter_available() -> Tuple[bool, str]:
+    """Check if tkinter can create windows without importing it globally."""
+
+    # Test in a subprocess to avoid crashing the main process
+    test_code = """
+import json
+
+def run_check():
+    try:
+        import tkinter as tk  # noqa: F401 - imported for side effect
+    except Exception as exc:  # pragma: no cover - runs in subprocess
+        return {
+            "status": "import_error",
+            "error": f"{exc.__class__.__name__}: {exc}",
+        }
+
+    try:
+        import tkinter as tk
+
+        root = tk.Tk()
+        root.destroy()
+    except Exception as exc:  # pragma: no cover - runs in subprocess
+        return {
+            "status": "init_error",
+            "error": f"{exc.__class__.__name__}: {exc}",
+        }
+
+    return {"status": "ok"}
+
+
+if __name__ == "__main__":
+    print(json.dumps(run_check()))
+"""
+
+    try:
+        result = subprocess.run(
+            [sys.executable, "-c", test_code], capture_output=True, text=True, timeout=5
+        )
+
+        output = result.stdout.strip() or result.stderr.strip()
+
+        if not output:
+            return False, "Window creation failed"
+
+        try:
+            payload = json.loads(output)
+        except json.JSONDecodeError:
+            return False, output
+
+        status = payload.get("status")
+
+        if status == "ok":
+            return True, ""
+
+        if status == "import_error":
+            return (
+                False,
+                f"tkinter is not installed ({payload.get('error', 'unknown error')})",
+            )
+
+        if status == "init_error":
+            return (
+                False,
+                f"tkinter could not open a window ({payload.get('error', 'unknown error')})",
+            )
+
+        return False, output
+    except Exception as e:  # pragma: no cover - defensive fallback
+        return False, f"Error testing tkinter: {e}"
+
+
+def main(argv: Optional[Sequence[str]] = None) -> bool:
+    """Launch the GUI when run without arguments, otherwise defer to the CLI."""
+
+    if argv is None:
+        argv = sys.argv[1:]
+
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument(
+        "--server",
+        action="store_true",
+        help="Launch the Talks Reducer server tray instead of the desktop GUI.",
+    )
+    parser.add_argument(
+        "--no-tray",
+        action="store_true",
+        help="Deprecated: the GUI no longer starts the server tray automatically.",
+    )
+
+    parsed_args, remaining = parser.parse_known_args(argv)
+    if parsed_args.server:
+        package_name = __package__ or "talks_reducer"
+        module_name = f"{package_name}.server_tray"
+        try:
+            tray_module = importlib.import_module(module_name)
+        except ModuleNotFoundError as exc:
+            if exc.name != module_name:
+                raise
+            root_package = package_name.split(".")[0] or "talks_reducer"
+            tray_module = importlib.import_module(f"{root_package}.server_tray")
+        tray_main = getattr(tray_module, "main")
+        tray_main(remaining)
+        return False
+    if parsed_args.no_tray:
+        sys.stderr.write(
+            "Warning: --no-tray is deprecated; the GUI no longer starts the server tray automatically.\n"
+        )
+    argv = remaining
+
+    if argv:
+        launch_gui = False
+        if sys.platform == "win32" and not any(arg.startswith("-") for arg in argv):
+            if any(Path(arg).exists() for arg in argv if arg):
+                launch_gui = True
+
+        if launch_gui:
+            try:
+                app = TalksReducerGUI(argv, auto_run=True)
+                app.run()
+                return True
+            except Exception:
+                # Fall back to the CLI if the GUI cannot be started.
+                pass
+
+        cli_main(argv)
+        return False
+
+    is_frozen = getattr(sys, "frozen", False)
+
+    if not is_frozen:
+        tkinter_available, error_msg = _check_tkinter_available()
+
+        if not tkinter_available:
+            try:
+                print("Talks Reducer GUI")
+                print("=" * 50)
+                print("X GUI not available on this system")
+                print(f"Error: {error_msg}")
+                print()
+                print("! Alternative: Use the command-line interface")
+                print()
+                print("The CLI provides all the same functionality:")
+                print("  python3 -m talks_reducer <input_file> [options]")
+                print()
+                print("Examples:")
+                print("  python3 -m talks_reducer video.mp4")
+                print("  python3 -m talks_reducer video.mp4 --small")
+                print("  python3 -m talks_reducer video.mp4 -o output.mp4")
+                print()
+                print("Run 'python3 -m talks_reducer --help' for all options.")
+                print()
+                print("Troubleshooting tips:")
+                if sys.platform == "darwin":
+                    print(
+                        "  - On macOS, install Python from python.org or ensure "
+                        "Homebrew's python-tk package is present."
+                    )
+                elif sys.platform.startswith("linux"):
+                    print(
+                        "  - On Linux, install the Tk bindings for Python (for example, "
+                        "python3-tk)."
+                    )
+                else:
+                    print("  - Ensure your Python installation includes Tk support.")
+                print("  - You can always fall back to the CLI workflow below.")
+                print()
+                print("The CLI interface works perfectly and is recommended.")
+            except UnicodeEncodeError:
+                sys.stderr.write("GUI not available. Use CLI mode instead.\n")
+            return False
+
+    try:
+        app = TalksReducerGUI()
+        app.run()
+        return True
+    except Exception as e:
+        import traceback
+
+        sys.stderr.write(f"Error starting GUI: {e}\n")
+        sys.stderr.write(traceback.format_exc())
+        sys.stderr.write("\nPlease use the CLI mode instead:\n")
+        sys.stderr.write("  python3 -m talks_reducer <input_file> [options]\n")
+        sys.exit(1)
+
+
+__all__ = ["_check_tkinter_available", "main"]

talks_reducer/icons.py

@@ -11,6 +11,7 @@ from typing import Iterator, Optional, Sequence
 LOGGER = logging.getLogger(__name__)
 
 _ICON_RELATIVE_PATHS: Sequence[Path] = (
+    Path("resources") / "icons",
     Path("talks_reducer") / "resources" / "icons",
     Path("docs") / "assets",
 )
@@ -43,6 +44,7 @@ def _iter_base_roots(module_file: Optional[Path | str] = None) -> Iterator[Path]
     for root in (
         package_root,
         project_root,
+        Path.cwd(),
     ):
         yield from _yield(root)
 

talks_reducer/pipeline.py

@@ -6,12 +6,15 @@ import math
 import os
 import re
 import subprocess
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict
+from typing import Callable, Dict
 
 import numpy as np
 from scipy.io import wavfile
 
+from talks_reducer.version_utils import resolve_version
+
 from . import audio as audio_utils
 from . import chunks as chunk_utils
 from .ffmpeg import (
@@ -23,13 +26,33 @@ from .ffmpeg import (
 )
 from .models import ProcessingOptions, ProcessingResult
 from .progress import NullProgressReporter, ProgressReporter
-from talks_reducer.version_utils import resolve_version
 
 
 class ProcessingAborted(RuntimeError):
     """Raised when processing is cancelled by the caller."""
 
 
+@dataclass
+class PipelineDependencies:
+    """Bundle of external dependencies used by :func:`speed_up_video`."""
+
+    get_ffmpeg_path: Callable[[], str] = get_ffmpeg_path
+    check_cuda_available: Callable[[str], bool] = check_cuda_available
+    build_extract_audio_command: Callable[..., str] = build_extract_audio_command
+    build_video_commands: Callable[..., tuple[str, str | None, bool]] = (
+        build_video_commands
+    )
+    run_timed_ffmpeg_command: Callable[..., None] = run_timed_ffmpeg_command
+    create_path: Callable[[Path], None] | None = None
+    delete_path: Callable[[Path], None] | None = None
+
+    def __post_init__(self) -> None:
+        if self.create_path is None:
+            self.create_path = _create_path
+        if self.delete_path is None:
+            self.delete_path = _delete_path
+
+
 def _stop_requested(reporter: ProgressReporter | None) -> bool:
     """Return ``True`` when *reporter* indicates that processing should stop."""
 
@@ -46,7 +69,10 @@ def _stop_requested(reporter: ProgressReporter | None) -> bool:
 
 
 def _raise_if_stopped(
-    reporter: ProgressReporter | None, *, temp_path: Path | None = None
+    reporter: ProgressReporter | None,
+    *,
+    temp_path: Path | None = None,
+    dependencies: PipelineDependencies | None = None,
 ) -> None:
     """Abort processing when the user has requested a stop."""
 
@@ -54,34 +80,40 @@ def _raise_if_stopped(
         return
 
     if temp_path is not None and temp_path.exists():
-        _delete_path(temp_path)
+        if dependencies is not None:
+            dependencies.delete_path(temp_path)
+        else:
+            _delete_path(temp_path)
     raise ProcessingAborted("Processing aborted by user request.")
 
 
 def speed_up_video(
-    options: ProcessingOptions, reporter: ProgressReporter | None = None
+    options: ProcessingOptions,
+    reporter: ProgressReporter | None = None,
+    dependencies: PipelineDependencies | None = None,
 ) -> ProcessingResult:
     """Speed up a video by shortening silent sections while keeping sounded sections intact."""
 
     reporter = reporter or NullProgressReporter()
+    dependencies = dependencies or PipelineDependencies()
 
     input_path = Path(options.input_file)
     if not input_path.exists():
         raise FileNotFoundError(f"Input file not found: {input_path}")
 
-    ffmpeg_path = get_ffmpeg_path()
+    ffmpeg_path = dependencies.get_ffmpeg_path()
 
     output_path = options.output_file or _input_to_output_filename(
         input_path, options.small
     )
     output_path = Path(output_path)
 
-    cuda_available = check_cuda_available(ffmpeg_path)
+    cuda_available = dependencies.check_cuda_available(ffmpeg_path)
 
     temp_path = Path(options.temp_folder)
     if temp_path.exists():
-        _delete_path(temp_path)
-    _create_path(temp_path)
+        dependencies.delete_path(temp_path)
+    dependencies.create_path(temp_path)
 
     metadata = _extract_video_metadata(input_path, options.frame_rate)
     frame_rate = metadata["frame_rate"]
@@ -117,7 +149,7 @@ def speed_up_video(
 
     extraction_sample_rate = options.sample_rate
 
-    extract_command = build_extract_audio_command(
+    extract_command = dependencies.build_extract_audio_command(
         os.fspath(input_path),
         os.fspath(audio_wav),
         extraction_sample_rate,
@@ -126,7 +158,7 @@ def speed_up_video(
         ffmpeg_path=ffmpeg_path,
     )
 
-    _raise_if_stopped(reporter, temp_path=temp_path)
+    _raise_if_stopped(reporter, temp_path=temp_path, dependencies=dependencies)
     reporter.log("Extracting audio...")
     process_callback = getattr(reporter, "process_callback", None)
     estimated_total_frames = frame_count
@@ -138,7 +170,7 @@ def speed_up_video(
     else:
         reporter.log("Extract audio target frames: unknown")
 
-    run_timed_ffmpeg_command(
+    dependencies.run_timed_ffmpeg_command(
         extract_command,
         reporter=reporter,
         total=estimated_total_frames if estimated_total_frames > 0 else None,
@@ -157,7 +189,7 @@ def speed_up_video(
     samples_per_frame = wav_sample_rate / frame_rate
     audio_frame_count = int(math.ceil(audio_sample_count / samples_per_frame))
 
-    _raise_if_stopped(reporter, temp_path=temp_path)
+    _raise_if_stopped(reporter, temp_path=temp_path, dependencies=dependencies)
 
     has_loud_audio = chunk_utils.detect_loud_frames(
         audio_data,
@@ -171,7 +203,7 @@ def speed_up_video(
 
     reporter.log(f"Processing {len(chunks)} chunks...")
 
-    _raise_if_stopped(reporter, temp_path=temp_path)
+    _raise_if_stopped(reporter, temp_path=temp_path, dependencies=dependencies)
 
     new_speeds = [options.silent_speed, options.sounded_speed]
     output_audio_data, updated_chunks = audio_utils.process_audio_chunks(
@@ -192,7 +224,7 @@ def speed_up_video(
         _prepare_output_audio(output_audio_data),
     )
 
-    _raise_if_stopped(reporter, temp_path=temp_path)
+    _raise_if_stopped(reporter, temp_path=temp_path, dependencies=dependencies)
 
     expression = chunk_utils.get_tree_expression(updated_chunks)
     filter_graph_path = temp_path / "filterGraph.txt"
@@ -205,14 +237,16 @@ def speed_up_video(
         filter_parts.append(f"setpts={escaped_expression}")
         filter_graph_file.write(",".join(filter_parts))
 
-    command_str, fallback_command_str, use_cuda_encoder = build_video_commands(
-        os.fspath(input_path),
-        os.fspath(audio_new_path),
-        os.fspath(filter_graph_path),
-        os.fspath(output_path),
-        ffmpeg_path=ffmpeg_path,
-        cuda_available=cuda_available,
-        small=options.small,
+    command_str, fallback_command_str, use_cuda_encoder = (
+        dependencies.build_video_commands(
+            os.fspath(input_path),
+            os.fspath(audio_new_path),
+            os.fspath(filter_graph_path),
+            os.fspath(output_path),
+            ffmpeg_path=ffmpeg_path,
+            cuda_available=cuda_available,
+            small=options.small,
+        )
     )
 
     output_dir = output_path.parent.resolve()
@@ -224,14 +258,14 @@ def speed_up_video(
     reporter.log(command_str)
 
     if not audio_new_path.exists():
-        _delete_path(temp_path)
+        dependencies.delete_path(temp_path)
         raise FileNotFoundError("Audio intermediate file was not generated")
 
     if not filter_graph_path.exists():
-        _delete_path(temp_path)
+        dependencies.delete_path(temp_path)
         raise FileNotFoundError("Filter graph file was not generated")
 
-    _raise_if_stopped(reporter, temp_path=temp_path)
+    _raise_if_stopped(reporter, temp_path=temp_path, dependencies=dependencies)
 
     try:
         final_total_frames = updated_chunks[-1][3] if updated_chunks else 0
@@ -253,7 +287,7 @@ def speed_up_video(
 
         total_frames_arg = final_total_frames if final_total_frames > 0 else None
 
-        run_timed_ffmpeg_command(
+        dependencies.run_timed_ffmpeg_command(
             command_str,
             reporter=reporter,
             total=total_frames_arg,
@@ -261,9 +295,9 @@ def speed_up_video(
             desc="Generating final:",
             process_callback=process_callback,
         )
-    except subprocess.CalledProcessError as exc:
+    except subprocess.CalledProcessError:
         if fallback_command_str and use_cuda_encoder:
-            _raise_if_stopped(reporter, temp_path=temp_path)
+            _raise_if_stopped(reporter, temp_path=temp_path, dependencies=dependencies)
 
             reporter.log("CUDA encoding failed, retrying with CPU encoder...")
             if final_total_frames > 0:
@@ -281,7 +315,7 @@ def speed_up_video(
                         fps=frame_rate,
                     )
                 )
-            run_timed_ffmpeg_command(
+            dependencies.run_timed_ffmpeg_command(
                 fallback_command_str,
                 reporter=reporter,
                 total=total_frames_arg,
@@ -292,7 +326,7 @@ def speed_up_video(
         else:
             raise
     finally:
-        _delete_path(temp_path)
+        dependencies.delete_path(temp_path)
 
     output_metadata = _extract_video_metadata(output_path, frame_rate)
     output_duration = output_metadata.get("duration", 0.0)