talks-reducer 0.7.1__py3-none-any.whl → 0.8.0__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

@@ -3,15 +3,15 @@
 from __future__ import annotations
 
 import sys
-from pathlib import Path
 from typing import TYPE_CHECKING, Callable
 
+from ..icons import find_icon_path
 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:
@@ -454,37 +454,24 @@ def reset_basic_defaults(gui: "TalksReducerGUI") -> None:
 def apply_window_icon(gui: "TalksReducerGUI") -> None:
     """Configure the application icon when the asset is available."""
 
-    base_path = Path(getattr(sys, "_MEIPASS", Path(__file__).resolve().parent.parent))
-
-    icon_candidates: list[tuple[Path, str]] = []
-    if sys.platform.startswith("win"):
-        icon_candidates.append(
-            (
-                base_path / "talks_reducer" / "resources" / "icons" / "icon.ico",
-                "ico",
-            )
-        )
-    icon_candidates.append(
-        (
-            base_path / "talks_reducer" / "resources" / "icons" / "icon.png",
-            "png",
-        )
+    icon_filenames = (
+        ("app.ico", "app.png")
+        if sys.platform.startswith("win")
+        else ("app.png", "app.ico")
     )
+    icon_path = find_icon_path(filenames=icon_filenames)
+    if icon_path is None:
+        return
 
-    for icon_path, icon_type in icon_candidates:
-        if not icon_path.is_file():
-            continue
-
-        try:
-            if icon_type == "ico" and sys.platform.startswith("win"):
-                # On Windows, iconbitmap works better without the 'default' parameter
-                gui.root.iconbitmap(str(icon_path))
-            else:
-                gui.root.iconphoto(False, gui.tk.PhotoImage(file=str(icon_path)))
-            return
-        except (gui.tk.TclError, Exception):
-            # Missing Tk image support or invalid icon format - try next candidate
-            continue
+    try:
+        if icon_path.suffix.lower() == ".ico" and sys.platform.startswith("win"):
+            # On Windows, iconbitmap works better without the 'default' parameter.
+            gui.root.iconbitmap(str(icon_path))
+        else:
+            gui.root.iconphoto(False, gui.tk.PhotoImage(file=str(icon_path)))
+    except (gui.tk.TclError, Exception):
+        # Missing Tk image support or invalid icon format - fail silently.
+        return
 
 
 def apply_window_size(gui: "TalksReducerGUI", *, simple: bool) -> 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

@@ -0,0 +1,123 @@
+"""Icon discovery helpers shared across Talks Reducer entry points."""
+
+from __future__ import annotations
+
+import logging
+import sys
+from contextlib import suppress
+from pathlib import Path
+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",
+)
+_ICON_PATH_SUFFIXES: Sequence[Path] = (
+    Path(""),
+    Path("_internal"),
+    Path("Contents") / "Resources",
+    Path("Resources"),
+)
+
+
+def _iter_base_roots(module_file: Optional[Path | str] = None) -> Iterator[Path]:
+    """Yield base directories where icon assets may live."""
+
+    module_path = Path(module_file or __file__).resolve()
+    package_root = module_path.parent
+    project_root = package_root.parent
+
+    seen: set[Path] = set()
+
+    def _yield(path: Optional[Path]) -> Iterator[Path]:
+        if path is None:
+            return iter(())
+        resolved = path.resolve()
+        if resolved in seen:
+            return iter(())
+        seen.add(resolved)
+        return iter((resolved,))
+
+    for root in (
+        package_root,
+        project_root,
+        Path.cwd(),
+    ):
+        yield from _yield(root)
+
+    frozen_root: Optional[Path] = None
+    frozen_value = getattr(sys, "_MEIPASS", None)
+    if frozen_value:
+        with suppress(Exception):
+            frozen_root = Path(str(frozen_value))
+    if frozen_root is not None:
+        yield from _yield(frozen_root)
+
+    with suppress(Exception):
+        executable_root = Path(sys.executable).resolve().parent
+        yield from _yield(executable_root)
+
+    with suppress(Exception):
+        launcher_root = Path(sys.argv[0]).resolve().parent
+        yield from _yield(launcher_root)
+
+
+def iter_icon_candidates(
+    *,
+    filenames: Sequence[str],
+    relative_paths: Sequence[Path] | None = None,
+    module_file: Optional[Path | str] = None,
+) -> Iterator[Path]:
+    """Yield possible icon paths ordered from most to least specific."""
+
+    if relative_paths is None:
+        relative_paths = _ICON_RELATIVE_PATHS
+
+    seen: set[Path] = set()
+    for base_root in _iter_base_roots(module_file=module_file):
+        for suffix in _ICON_PATH_SUFFIXES:
+            candidate_root = (base_root / suffix).resolve()
+            if candidate_root in seen:
+                continue
+            seen.add(candidate_root)
+            LOGGER.debug("Considering icon root: %s", candidate_root)
+
+            if not candidate_root.exists():
+                LOGGER.debug("Skipping missing icon root: %s", candidate_root)
+                continue
+
+            for relative in relative_paths:
+                candidate_base = (candidate_root / relative).resolve()
+                if not candidate_base.exists():
+                    LOGGER.debug("Skipping missing icon directory: %s", candidate_base)
+                    continue
+                for name in filenames:
+                    candidate = (candidate_base / name).resolve()
+                    LOGGER.debug("Checking icon candidate: %s", candidate)
+                    yield candidate
+
+
+def find_icon_path(
+    *,
+    filenames: Sequence[str],
+    relative_paths: Sequence[Path] | None = None,
+    module_file: Optional[Path | str] = None,
+) -> Optional[Path]:
+    """Return the first existing icon path matching *filenames* or ``None``."""
+
+    for candidate in iter_icon_candidates(
+        filenames=filenames,
+        relative_paths=relative_paths,
+        module_file=module_file,
+    ):
+        if candidate.is_file():
+            LOGGER.info("Found icon at %s", candidate)
+            return candidate
+    LOGGER.warning("Unable to locate Talks Reducer icon; checked %s", filenames)
+    return None
+
+
+__all__ = ["find_icon_path", "iter_icon_candidates"]