talks-reducer 0.6.3__py3-none-any.whl → 0.7.0__py3-none-any.whl

talks_reducer/gui/theme.py

@@ -0,0 +1,269 @@
+"""Theme utilities shared by the Tkinter GUI."""
+
+from __future__ import annotations
+
+import subprocess
+from typing import Any, Callable, Mapping, Sequence
+
+STATUS_COLORS = {
+    "idle": "#9ca3af",
+    "waiting": "#9ca3af",
+    "processing": "#af8e0e",
+    "success": "#178941",
+    "error": "#ad4f4f",
+    "aborted": "#6d727a",
+}
+
+LIGHT_THEME = {
+    "background": "#f5f5f5",
+    "foreground": "#1f2933",
+    "accent": "#2563eb",
+    "surface": "#ffffff",
+    "border": "#cbd5e1",
+    "hover": "#efefef",
+    "hover_text": "#000000",
+    "selection_background": "#2563eb",
+    "selection_foreground": "#ffffff",
+}
+
+DARK_THEME = {
+    "background": "#1e1e28",
+    "foreground": "#f3f4f6",
+    "accent": "#60a5fa",
+    "surface": "#2b2b3c",
+    "border": "#4b5563",
+    "hover": "#333333",
+    "hover_text": "#ffffff",
+    "selection_background": "#333333",
+    "selection_foreground": "#f3f4f6",
+}
+
+
+RegistryReader = Callable[[str, str], int]
+DefaultsRunner = Callable[[Sequence[str]], subprocess.CompletedProcess[str]]
+
+
+def read_windows_theme_registry(key_path: str, value_name: str) -> int:
+    """Read *value_name* from the registry key at *key_path*."""
+
+    import winreg  # type: ignore
+
+    with winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path) as key:
+        value, _ = winreg.QueryValueEx(key, value_name)
+    return int(value)
+
+
+def run_defaults_command(args: Sequence[str]) -> subprocess.CompletedProcess[str]:
+    """Execute the macOS ``defaults`` command used to detect theme."""
+
+    return subprocess.run(args, capture_output=True, text=True, check=False)
+
+
+def detect_system_theme(
+    env: Mapping[str, str],
+    platform: str,
+    registry_reader: RegistryReader,
+    defaults_runner: DefaultsRunner,
+) -> str:
+    """Detect the system theme for the provided *platform* and environment."""
+
+    if platform.startswith("win"):
+        try:
+            value = registry_reader(
+                r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize",
+                "AppsUseLightTheme",
+            )
+            return "light" if int(value) else "dark"
+        except OSError:
+            return "light"
+
+    if platform == "darwin":
+        try:
+            result = defaults_runner(["defaults", "read", "-g", "AppleInterfaceStyle"])
+        except Exception:
+            return "light"
+        if result.returncode == 0 and result.stdout.strip().lower() == "dark":
+            return "dark"
+        return "light"
+
+    theme = env.get("GTK_THEME", "").lower()
+    if "dark" in theme:
+        return "dark"
+    return "light"
+
+
+def apply_theme(
+    style: Any,
+    palette: Mapping[str, str],
+    widgets: Mapping[str, Any],
+) -> Mapping[str, str]:
+    """Apply *palette* to *style* and update GUI *widgets*."""
+
+    root = widgets.get("root")
+    if root is not None:
+        root.configure(bg=palette["background"])
+
+    style.theme_use("clam")
+    style.configure(
+        ".", background=palette["background"], foreground=palette["foreground"]
+    )
+    style.configure("TFrame", background=palette["background"])
+    style.configure(
+        "TLabelframe",
+        background=palette["background"],
+        foreground=palette["foreground"],
+        borderwidth=0,
+        relief="flat",
+    )
+    style.configure(
+        "TLabelframe.Label",
+        background=palette["background"],
+        foreground=palette["foreground"],
+    )
+    style.configure(
+        "TLabel", background=palette["background"], foreground=palette["foreground"]
+    )
+    style.configure(
+        "TCheckbutton",
+        background=palette["background"],
+        foreground=palette["foreground"],
+    )
+    style.map(
+        "TCheckbutton",
+        background=[("active", palette.get("hover", palette["background"]))],
+    )
+    style.configure(
+        "TRadiobutton",
+        background=palette["background"],
+        foreground=palette["foreground"],
+    )
+    style.map(
+        "TRadiobutton",
+        background=[("active", palette.get("hover", palette["background"]))],
+    )
+    style.configure(
+        "Link.TButton",
+        background=palette["background"],
+        foreground=palette["accent"],
+        borderwidth=0,
+        relief="flat",
+        highlightthickness=0,
+        padding=2,
+        font=("TkDefaultFont", 8, "underline"),
+    )
+    style.map(
+        "Link.TButton",
+        background=[
+            ("active", palette.get("hover", palette["background"])),
+            ("disabled", palette["background"]),
+        ],
+        foreground=[
+            ("active", palette.get("accent", palette["foreground"])),
+            ("disabled", palette["foreground"]),
+        ],
+    )
+    style.configure(
+        "TButton",
+        background=palette["surface"],
+        foreground=palette["foreground"],
+        padding=4,
+        font=("TkDefaultFont", 8),
+    )
+    style.map(
+        "TButton",
+        background=[
+            ("active", palette.get("hover", palette["accent"])),
+            ("disabled", palette["surface"]),
+        ],
+        foreground=[
+            ("active", palette.get("hover_text", "#000000")),
+            ("disabled", palette["foreground"]),
+        ],
+    )
+    style.configure(
+        "TEntry",
+        fieldbackground=palette["surface"],
+        foreground=palette["foreground"],
+    )
+    style.configure(
+        "TCombobox",
+        fieldbackground=palette["surface"],
+        foreground=palette["foreground"],
+    )
+
+    style.configure(
+        "Idle.Horizontal.TProgressbar",
+        background=STATUS_COLORS["idle"],
+        troughcolor=palette["surface"],
+        borderwidth=0,
+        thickness=20,
+    )
+    style.configure(
+        "Processing.Horizontal.TProgressbar",
+        background=STATUS_COLORS["processing"],
+        troughcolor=palette["surface"],
+        borderwidth=0,
+        thickness=20,
+    )
+    style.configure(
+        "Success.Horizontal.TProgressbar",
+        background=STATUS_COLORS["success"],
+        troughcolor=palette["surface"],
+        borderwidth=0,
+        thickness=20,
+    )
+    style.configure(
+        "Error.Horizontal.TProgressbar",
+        background=STATUS_COLORS["error"],
+        troughcolor=palette["surface"],
+        borderwidth=0,
+        thickness=20,
+    )
+    style.configure(
+        "Aborted.Horizontal.TProgressbar",
+        background=STATUS_COLORS["aborted"],
+        troughcolor=palette["surface"],
+        borderwidth=0,
+        thickness=20,
+    )
+
+    drop_zone = widgets.get("drop_zone")
+    if drop_zone is not None:
+        drop_zone.configure(
+            bg=palette["surface"],
+            fg=palette["foreground"],
+            highlightthickness=0,
+        )
+
+    tk_module = widgets.get("tk")
+    slider_relief = getattr(tk_module, "FLAT", "flat") if tk_module else "flat"
+    sliders = widgets.get("sliders") or []
+    for slider in sliders:
+        slider.configure(
+            background=palette["border"],
+            troughcolor=palette["surface"],
+            activebackground=palette["border"],
+            sliderrelief=slider_relief,
+            bd=0,
+        )
+
+    log_text = widgets.get("log_text")
+    if log_text is not None:
+        log_text.configure(
+            bg=palette["surface"],
+            fg=palette["foreground"],
+            insertbackground=palette["foreground"],
+            highlightbackground=palette["border"],
+            highlightcolor=palette["border"],
+        )
+
+    status_label = widgets.get("status_label")
+    if status_label is not None:
+        status_label.configure(bg=palette["background"])
+
+    apply_status_style = widgets.get("apply_status_style")
+    status_state = widgets.get("status_state")
+    if callable(apply_status_style) and status_state is not None:
+        apply_status_style(status_state)
+
+    return palette

talks_reducer/models.py

@@ -29,7 +29,7 @@ def default_temp_folder() -> Path:
         else:
             base = Path(tempfile.gettempdir()) / "talks-reducer"
 
-    return base / "temp"
+    return base / "talks-reducer-temp"
 
 
 @dataclass(frozen=True)

talks_reducer/pipeline.py

@@ -23,103 +23,39 @@ from .ffmpeg import (
 )
 from .models import ProcessingOptions, ProcessingResult
 from .progress import NullProgressReporter, ProgressReporter
+from talks_reducer.version_utils import resolve_version
 
 
-def _input_to_output_filename(filename: Path, small: bool = False) -> Path:
-    dot_index = filename.name.rfind(".")
-    suffix_parts = []
-
-    if small:
-        suffix_parts.append("_small")
-
-    if not suffix_parts:
-        suffix_parts.append("")  # Default case
-
-    suffix = "_speedup" + "".join(suffix_parts)
-    new_name = (
-        filename.name[:dot_index] + suffix + filename.name[dot_index:]
-        if dot_index != -1
-        else filename.name + suffix
-    )
-    return filename.with_name(new_name)
-
-
-def _create_path(path: Path) -> None:
-    try:
-        path.mkdir(parents=True, exist_ok=True)
-    except OSError as exc:  # pragma: no cover - defensive logging
-        raise AssertionError(
-            "Creation of the directory failed. (The TEMP folder may already exist. Delete or rename it, and try again.)"
-        ) from exc
-
-
-def _delete_path(path: Path) -> None:
-    import time
-    from shutil import rmtree
-
-    try:
-        rmtree(path, ignore_errors=False)
-        for i in range(5):
-            if not path.exists():
-                return
-            time.sleep(0.01 * i)
-    except OSError as exc:  # pragma: no cover - defensive logging
-        print(f"Deletion of the directory {path} failed")
-        print(exc)
-
-
-def _extract_video_metadata(input_file: Path, frame_rate: float) -> Dict[str, float]:
-    from .ffmpeg import get_ffprobe_path
-
-    ffprobe_path = get_ffprobe_path()
-    command = [
-        ffprobe_path,
-        "-i",
-        os.fspath(input_file),
-        "-hide_banner",
-        "-loglevel",
-        "error",
-        "-select_streams",
-        "v",
-        "-show_entries",
-        "format=duration:stream=avg_frame_rate,nb_frames",
-    ]
-    process = subprocess.Popen(
-        command,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        bufsize=1,
-        universal_newlines=True,
-    )
-    stdout, _ = process.communicate()
+class ProcessingAborted(RuntimeError):
+    """Raised when processing is cancelled by the caller."""
 
-    match_frame_rate = re.search(r"frame_rate=(\d*)/(\d*)", str(stdout))
-    if match_frame_rate is not None:
-        frame_rate = float(match_frame_rate.group(1)) / float(match_frame_rate.group(2))
 
-    match_duration = re.search(r"duration=([\d.]*)", str(stdout))
-    original_duration = float(match_duration.group(1)) if match_duration else 0.0
+def _stop_requested(reporter: ProgressReporter | None) -> bool:
+    """Return ``True`` when *reporter* indicates that processing should stop."""
 
-    match_frames = re.search(r"nb_frames=(\d+)", str(stdout))
-    frame_count = int(match_frames.group(1)) if match_frames else 0
+    if reporter is None:
+        return False
 
-    return {
-        "frame_rate": frame_rate,
-        "duration": original_duration,
-        "frame_count": frame_count,
-    }
+    flag = getattr(reporter, "stop_requested", None)
+    if callable(flag):
+        try:
+            flag = flag()
+        except Exception:  # pragma: no cover - defensive
+            flag = False
+    return bool(flag)
 
 
-def _ensure_two_dimensional(audio_data: np.ndarray) -> np.ndarray:
-    if audio_data.ndim == 1:
-        return audio_data[:, np.newaxis]
-    return audio_data
+def _raise_if_stopped(
+    reporter: ProgressReporter | None, *, temp_path: Path | None = None
+) -> None:
+    """Abort processing when the user has requested a stop."""
 
+    if not _stop_requested(reporter):
+        return
 
-def _prepare_output_audio(output_audio_data: np.ndarray) -> np.ndarray:
-    if output_audio_data.ndim == 2 and output_audio_data.shape[1] == 1:
-        return output_audio_data[:, 0]
-    return output_audio_data
+    if temp_path is not None and temp_path.exists():
+        _delete_path(temp_path)
+    raise ProcessingAborted("Processing aborted by user request.")
 
 
 def speed_up_video(
@@ -152,10 +88,14 @@ def speed_up_video(
     original_duration = metadata["duration"]
     frame_count = metadata.get("frame_count", 0)
 
+    app_version = resolve_version()
+    if app_version and app_version != "unknown":
+        reporter.log(f"talks-reducer v{app_version}")
+
     reporter.log(
         (
-            "Source metadata — duration: {duration:.2f}s, frame rate: {fps:.3f} fps,"
-            " reported frames: {frames}"
+            "Source metadata: duration: {duration:.2f}s, frame rate: {fps:.3f} fps,"
+            " frames: {frames}"
         ).format(
             duration=original_duration,
             fps=frame_rate,
@@ -186,6 +126,7 @@ def speed_up_video(
         ffmpeg_path=ffmpeg_path,
     )
 
+    _raise_if_stopped(reporter, temp_path=temp_path)
     reporter.log("Extracting audio...")
     process_callback = getattr(reporter, "process_callback", None)
     estimated_total_frames = frame_count
@@ -211,12 +152,13 @@ def speed_up_video(
     audio_sample_count = audio_data.shape[0]
     max_audio_volume = audio_utils.get_max_volume(audio_data)
 
-    reporter.log("\nInformation:")
-    reporter.log(f"- Max Audio Volume: {max_audio_volume}")
+    reporter.log(f"Max Audio Volume: {max_audio_volume}")
 
     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)
+
     has_loud_audio = chunk_utils.detect_loud_frames(
         audio_data,
         audio_frame_count,
@@ -227,7 +169,9 @@ def speed_up_video(
 
     chunks, _ = chunk_utils.build_chunks(has_loud_audio, options.frame_spreadage)
 
-    reporter.log(f"Generated {len(chunks)} chunks")
+    reporter.log(f"Processing {len(chunks)} chunks...")
+
+    _raise_if_stopped(reporter, temp_path=temp_path)
 
     new_speeds = [options.silent_speed, options.sounded_speed]
     output_audio_data, updated_chunks = audio_utils.process_audio_chunks(
@@ -248,6 +192,8 @@ def speed_up_video(
         _prepare_output_audio(output_audio_data),
     )
 
+    _raise_if_stopped(reporter, temp_path=temp_path)
+
     expression = chunk_utils.get_tree_expression(updated_chunks)
     filter_graph_path = temp_path / "filterGraph.txt"
     with open(filter_graph_path, "w", encoding="utf-8") as filter_graph_file:
@@ -285,6 +231,8 @@ def speed_up_video(
         _delete_path(temp_path)
         raise FileNotFoundError("Filter graph file was not generated")
 
+    _raise_if_stopped(reporter, temp_path=temp_path)
+
     try:
         final_total_frames = updated_chunks[-1][3] if updated_chunks else 0
         if final_total_frames > 0:
@@ -315,6 +263,8 @@ def speed_up_video(
         )
     except subprocess.CalledProcessError as exc:
         if fallback_command_str and use_cuda_encoder:
+            _raise_if_stopped(reporter, temp_path=temp_path)
+
             reporter.log("CUDA encoding failed, retrying with CPU encoder...")
             if final_total_frames > 0:
                 reporter.log(
@@ -364,3 +314,103 @@ def speed_up_video(
         time_ratio=time_ratio,
         size_ratio=size_ratio,
     )
+
+
+def _input_to_output_filename(filename: Path, small: bool = False) -> Path:
+    dot_index = filename.name.rfind(".")
+    suffix_parts = []
+
+    if small:
+        suffix_parts.append("_small")
+
+    if not suffix_parts:
+        suffix_parts.append("")  # Default case
+
+    suffix = "_speedup" + "".join(suffix_parts)
+    new_name = (
+        filename.name[:dot_index] + suffix + filename.name[dot_index:]
+        if dot_index != -1
+        else filename.name + suffix
+    )
+    return filename.with_name(new_name)
+
+
+def _create_path(path: Path) -> None:
+    try:
+        path.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:  # pragma: no cover - defensive logging
+        raise AssertionError(
+            "Creation of the directory failed. (The TEMP folder may already exist. Delete or rename it, and try again.)"
+        ) from exc
+
+
+def _delete_path(path: Path) -> None:
+    import time
+    from shutil import rmtree
+
+    if not path.exists():
+        return
+
+    try:
+        rmtree(path, ignore_errors=False)
+        for i in range(5):
+            if not path.exists():
+                return
+            time.sleep(0.01 * i)
+    except OSError as exc:  # pragma: no cover - defensive logging
+        print(f"Deletion of the directory {path} failed")
+        print(exc)
+
+
+def _extract_video_metadata(input_file: Path, frame_rate: float) -> Dict[str, float]:
+    from .ffmpeg import get_ffprobe_path
+
+    ffprobe_path = get_ffprobe_path()
+    command = [
+        ffprobe_path,
+        "-i",
+        os.fspath(input_file),
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-select_streams",
+        "v",
+        "-show_entries",
+        "format=duration:stream=avg_frame_rate,nb_frames",
+    ]
+    process = subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        bufsize=1,
+        universal_newlines=True,
+    )
+    stdout, _ = process.communicate()
+
+    match_frame_rate = re.search(r"frame_rate=(\d*)/(\d*)", str(stdout))
+    if match_frame_rate is not None:
+        frame_rate = float(match_frame_rate.group(1)) / float(match_frame_rate.group(2))
+
+    match_duration = re.search(r"duration=([\d.]*)", str(stdout))
+    original_duration = float(match_duration.group(1)) if match_duration else 0.0
+
+    match_frames = re.search(r"nb_frames=(\d+)", str(stdout))
+    frame_count = int(match_frames.group(1)) if match_frames else 0
+
+    return {
+        "frame_rate": frame_rate,
+        "duration": original_duration,
+        "frame_count": frame_count,
+    }
+
+
+def _ensure_two_dimensional(audio_data: np.ndarray) -> np.ndarray:
+    if audio_data.ndim == 1:
+        return audio_data[:, np.newaxis]
+    return audio_data
+
+
+def _prepare_output_audio(output_audio_data: np.ndarray) -> np.ndarray:
+    if output_audio_data.ndim == 2 and output_audio_data.shape[1] == 1:
+        return output_audio_data[:, 0]
+    return output_audio_data

talks_reducer/server.py

@@ -11,7 +11,7 @@ from contextlib import AbstractContextManager, suppress
 from pathlib import Path
 from queue import SimpleQueue
 from threading import Thread
-from typing import Callable, Iterator, Optional, Sequence
+from typing import Callable, Iterator, Optional, Sequence, cast
 
 import gradio as gr
 
@@ -248,6 +248,9 @@ def _format_summary(result: ProcessingResult) -> str:
 def process_video(
     file_path: Optional[str],
     small_video: bool,
+    silent_threshold: Optional[float] = None,
+    sounded_speed: Optional[float] = None,
+    silent_speed: Optional[float] = None,
     progress: Optional[gr.Progress] = gr.Progress(track_tqdm=False),
 ) -> Iterator[tuple[Optional[str], str, str, Optional[str]]]:
     """Run the Talks Reducer pipeline for a single uploaded file."""
@@ -267,7 +270,7 @@ def process_video(
     if progress is not None:
 
         def _callback(current: int, total: int, desc: str) -> None:
-            progress(current, total=total, desc=desc)
+            events.put(("progress", (current, total, desc)))
 
         progress_callback = _callback
 
@@ -281,11 +284,20 @@ def process_video(
         log_callback=_log_callback,
     )
 
+    option_kwargs: dict[str, float] = {}
+    if silent_threshold is not None:
+        option_kwargs["silent_threshold"] = float(silent_threshold)
+    if sounded_speed is not None:
+        option_kwargs["sounded_speed"] = float(sounded_speed)
+    if silent_speed is not None:
+        option_kwargs["silent_speed"] = float(silent_speed)
+
     options = ProcessingOptions(
         input_file=input_path,
         output_file=output_file,
         temp_folder=temp_folder,
         small=small_video,
+        **option_kwargs,
     )
 
     def _worker() -> None:
@@ -323,6 +335,11 @@ def process_video(
                     gr.update(),
                     gr.update(),
                 )
+        elif kind == "progress":
+            if progress is not None:
+                current, total, desc = cast(tuple[int, int, str], payload)
+                percent = current / total if total > 0 else 0
+                progress(percent, total=total, desc=desc)
         elif kind == "result":
             final_result = payload  # type: ignore[assignment]
         elif kind == "error":
@@ -371,14 +388,39 @@ def build_interface() -> gr.Blocks:
             """.strip()
         )
 
-        with gr.Row():
+        with gr.Column():
             file_input = gr.File(
                 label="Video file",
                 file_types=["video"],
                 type="filepath",
             )
+
+        with gr.Row():
             small_checkbox = gr.Checkbox(label="Small video", value=True)
 
+        with gr.Column():
+            silent_speed_input = gr.Slider(
+                minimum=1.0,
+                maximum=10.0,
+                value=4.0,
+                step=0.1,
+                label="Silent speed",
+            )
+            sounded_speed_input = gr.Slider(
+                minimum=0.5,
+                maximum=3.0,
+                value=1.0,
+                step=0.05,
+                label="Sounded speed",
+            )
+            silent_threshold_input = gr.Slider(
+                minimum=0.0,
+                maximum=1.0,
+                value=0.05,
+                step=0.01,
+                label="Silent threshold",
+            )
+
         video_output = gr.Video(label="Processed video")
         summary_output = gr.Markdown()
         download_output = gr.File(label="Download processed file", interactive=False)
@@ -386,7 +428,13 @@ def build_interface() -> gr.Blocks:
 
         file_input.upload(
             process_video,
-            inputs=[file_input, small_checkbox],
+            inputs=[
+                file_input,
+                small_checkbox,
+                silent_threshold_input,
+                sounded_speed_input,
+                silent_speed_input,
+            ],
             outputs=[video_output, log_output, summary_output, download_output],
             queue=True,
             api_name="process_video",