talks-reducer 0.4.1__py3-none-any.whl → 0.5.1__py3-none-any.whl

talks_reducer/__about__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.4.1"
+__version__ = "0.5.1"

talks_reducer/cli.py

@@ -18,7 +18,7 @@ try:
 except Exception:  # pragma: no cover - fallback if metadata file missing
     _about_version = ""
 from .ffmpeg import FFmpegNotFoundError
-from .models import ProcessingOptions
+from .models import ProcessingOptions, default_temp_folder
 from .pipeline import speed_up_video
 from .progress import TqdmProgressReporter
 
@@ -55,7 +55,7 @@ def _build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--temp_folder",
         type=str,
-        default="TEMP",
+        default=str(default_temp_folder()),
         help="The file path of the temporary working folder.",
     )
     parser.add_argument(
@@ -63,7 +63,7 @@ def _build_parser() -> argparse.ArgumentParser:
         "--silent_threshold",
         type=float,
         dest="silent_threshold",
-        help="The volume amount that frames' audio needs to surpass to be considered sounded. Defaults to 0.03.",
+        help="The volume amount that frames' audio needs to surpass to be considered sounded. Defaults to 0.05.",
     )
     parser.add_argument(
         "-S",
@@ -143,6 +143,22 @@ def _launch_gui(argv: Sequence[str]) -> bool:
     return bool(gui_main(list(argv)))
 
 
+def _launch_server(argv: Sequence[str]) -> bool:
+    """Attempt to launch the Gradio web server with the provided arguments."""
+
+    try:
+        server_module = import_module(".server", __package__)
+    except ImportError:
+        return False
+
+    server_main = getattr(server_module, "main", None)
+    if server_main is None:
+        return False
+
+    server_main(list(argv))
+    return True
+
+
 def main(argv: Optional[Sequence[str]] = None) -> None:
     """Entry point for the command line interface.
 
@@ -154,6 +170,12 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
     else:
         argv_list = list(argv)
 
+    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)
+            sys.exit(1)
+        return
+
     if not argv_list:
         if _launch_gui(argv_list):
             return
@@ -200,7 +222,6 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
             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:

talks_reducer/ffmpeg.py

@@ -52,6 +52,9 @@ def find_ffmpeg() -> Optional[str]:
         "C:\\ProgramData\\chocolatey\\bin\\ffmpeg.exe",
         "C:\\Program Files\\ffmpeg\\bin\\ffmpeg.exe",
         "C:\\ffmpeg\\bin\\ffmpeg.exe",
+        "/usr/local/bin/ffmpeg",
+        "/opt/homebrew/bin/ffmpeg",
+        "/usr/bin/ffmpeg",
         "ffmpeg",
     ]
 
@@ -92,6 +95,9 @@ def find_ffprobe() -> Optional[str]:
         "C:\\ProgramData\\chocolatey\\bin\\ffprobe.exe",
         "C:\\Program Files\\ffmpeg\\bin\\ffprobe.exe",
         "C:\\ffmpeg\\bin\\ffprobe.exe",
+        "/usr/local/bin/ffprobe",
+        "/opt/homebrew/bin/ffprobe",
+        "/usr/bin/ffprobe",
         "ffprobe",
     ]
 
@@ -242,11 +248,29 @@ def run_timed_ffmpeg_command(
             if not line:
                 continue
 
-            sys.stderr.write(line)
-            sys.stderr.flush()
-
-            # Send FFmpeg output to reporter for GUI display
-            progress_reporter.log(line.strip())
+            # Filter out excessive progress output, only show important lines
+            if any(
+                keyword in line.lower()
+                for keyword in [
+                    "error",
+                    "warning",
+                    "encoded successfully",
+                    "frame=",
+                    "time=",
+                    "size=",
+                    "bitrate=",
+                    "speed=",
+                ]
+            ):
+                sys.stderr.write(line)
+                sys.stderr.flush()
+
+            # Send FFmpeg output to reporter for GUI display (filtered)
+            if any(
+                keyword in line.lower()
+                for keyword in ["error", "warning", "encoded successfully", "frame="]
+            ):
+                progress_reporter.log(line.strip())
 
             match = re.search(r"frame=\s*(\d+)", line)
             if match:
@@ -365,7 +389,11 @@ def build_video_commands(
             # Use a fast software encoder instead
             video_encoder_args = ["-c:v libx264", "-preset veryfast", "-crf 23"]
 
-    audio_parts = ["-c:a aac", f'"{output_file}"', "-loglevel info -stats -hide_banner"]
+    audio_parts = [
+        "-c:a aac",
+        f'"{output_file}"',
+        "-loglevel warning -stats -hide_banner",
+    ]
 
     full_command_parts = (
         global_parts + input_parts + output_parts + video_encoder_args + audio_parts

talks_reducer/gui.py

@@ -20,7 +20,7 @@ try:
     from .cli import gather_input_files
     from .cli import main as cli_main
     from .ffmpeg import FFmpegNotFoundError
-    from .models import ProcessingOptions
+    from .models import ProcessingOptions, default_temp_folder
     from .pipeline import speed_up_video
     from .progress import ProgressHandle, SignalProgressReporter
 except ImportError:  # pragma: no cover - handled at runtime
@@ -34,7 +34,7 @@ except ImportError:  # pragma: no cover - handled at runtime
     from talks_reducer.cli import gather_input_files
     from talks_reducer.cli import main as cli_main
     from talks_reducer.ffmpeg import FFmpegNotFoundError
-    from talks_reducer.models import ProcessingOptions
+    from talks_reducer.models import ProcessingOptions, default_temp_folder
     from talks_reducer.pipeline import speed_up_video
     from talks_reducer.progress import ProgressHandle, SignalProgressReporter
 
@@ -200,6 +200,7 @@ class _TkProgressReporter(SignalProgressReporter):
 
     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 = ""
@@ -256,7 +257,12 @@ class TalksReducerGUI:
         self._settings[key] = value
         self._save_settings()
 
-    def __init__(self) -> None:
+    def __init__(
+        self,
+        initial_inputs: Optional[Sequence[str]] = None,
+        *,
+        auto_run: bool = False,
+    ) -> None:
         self._config_path = self._determine_config_path()
         self._settings = self._load_settings()
 
@@ -284,8 +290,8 @@ class TalksReducerGUI:
 
         self._apply_window_icon()
 
-        self._full_size = (760, 680)
-        self._simple_size = (255, 330)
+        self._full_size = (1000, 800)
+        self._simple_size = (300, 270)
         self.root.geometry(f"{self._full_size[0]}x{self._full_size[1]}")
         self.style = self.ttk.Style(self.root)
 
@@ -298,6 +304,9 @@ class TalksReducerGUI:
         self._status_animation_job: Optional[str] = None
         self._status_animation_phase = 0
         self._video_duration_seconds: Optional[float] = None
+        self._encode_target_duration_seconds: Optional[float] = None
+        self._encode_total_frames: Optional[int] = None
+        self._encode_current_frame: Optional[int] = None
         self.progress_var = tk.IntVar(value=0)
         self._ffmpeg_process: Optional[subprocess.Popen] = None
         self._stop_requested = False
@@ -333,6 +342,9 @@ class TalksReducerGUI:
                 "Drag and drop requires the tkinterdnd2 package. Install it to enable the drop zone."
             )
 
+        if initial_inputs:
+            self._populate_initial_inputs(initial_inputs, auto_run=auto_run)
+
     # ------------------------------------------------------------------ UI --
     def _apply_window_icon(self) -> None:
         """Configure the application icon when the asset is available."""
@@ -423,7 +435,7 @@ class TalksReducerGUI:
 
         # Options frame
         options = self.ttk.Frame(main, padding=self.PADDING)
-        options.grid(row=2, column=0, pady=(16, 0), sticky="ew")
+        options.grid(row=2, column=0, pady=(0, 0), sticky="ew")
         options.columnconfigure(0, weight=1)
 
         checkbox_frame = self.ttk.Frame(options)
@@ -468,7 +480,7 @@ class TalksReducerGUI:
             self.advanced_frame, "Output file", self.output_var, row=0, browse=True
         )
 
-        self.temp_var = self.tk.StringVar(value="TEMP")
+        self.temp_var = self.tk.StringVar(value=str(default_temp_folder()))
         self._add_entry(
             self.advanced_frame, "Temp folder", self.temp_var, row=1, browse=True
         )
@@ -496,7 +508,7 @@ class TalksReducerGUI:
             self.advanced_frame, "Frame margin", self.frame_margin_var, row=5
         )
 
-        self.sample_rate_var = self.tk.StringVar()
+        self.sample_rate_var = self.tk.StringVar(value="48000")
         self._add_entry(self.advanced_frame, "Sample rate", self.sample_rate_var, row=6)
 
         self.ttk.Label(self.advanced_frame, text="Theme").grid(
@@ -862,6 +874,26 @@ class TalksReducerGUI:
         widget.drop_target_register(DND_FILES)  # type: ignore[arg-type]
         widget.dnd_bind("<<Drop>>", self._on_drop)  # type: ignore[attr-defined]
 
+    def _populate_initial_inputs(
+        self, inputs: Sequence[str], *, auto_run: bool = False
+    ) -> None:
+        """Seed the GUI with preselected inputs and optionally start processing."""
+
+        normalized: list[str] = []
+        for path in inputs:
+            if not path:
+                continue
+            resolved = os.fspath(Path(path))
+            if resolved not in self.input_files:
+                self.input_files.append(resolved)
+                self.input_list.insert(self.tk.END, resolved)
+                normalized.append(resolved)
+
+        if auto_run and normalized:
+            # Kick off processing once the event loop becomes idle so the
+            # interface has a chance to render before the work starts.
+            self.root.after_idle(self._start_run)
+
     # -------------------------------------------------------------- actions --
     def _ask_for_input_files(self) -> tuple[str, ...]:
         """Prompt the user to select input files for processing."""
@@ -1014,11 +1046,10 @@ class TalksReducerGUI:
                     self._append_log("Processing aborted by user.")
                     self._set_status("Aborted")
                 else:
-                    self._notify(
-                        lambda: self.messagebox.showerror(
-                            "Error", f"Processing failed: {exc}"
-                        )
-                    )
+                    error_msg = f"Processing failed: {exc}"
+                    self._append_log(error_msg)
+                    print(error_msg, file=sys.stderr)  # Also output to console
+                    self._notify(lambda: self.messagebox.showerror("Error", error_msg))
                     self._set_status("Error")
             finally:
                 self._notify(self._hide_stop_button)
@@ -1093,7 +1124,6 @@ class TalksReducerGUI:
             )
         if self.small_var.get():
             args["small"] = True
-
         return args
 
     def _parse_float(self, value: str, label: str) -> float:
@@ -1155,16 +1185,73 @@ class TalksReducerGUI:
             self._set_status("success", status_msg)
             self._set_progress(100)  # 100% on success
             self._video_duration_seconds = None  # Reset for next video
+            self._encode_target_duration_seconds = None
+            self._encode_total_frames = None
+            self._encode_current_frame = None
         elif normalized.startswith("extracting audio"):
             self._set_status("processing", "Extracting audio...")
             self._set_progress(0)  # 0% on start
             self._video_duration_seconds = None  # Reset for new processing
+            self._encode_target_duration_seconds = None
+            self._encode_total_frames = None
+            self._encode_current_frame = None
         elif normalized.startswith("starting processing") or normalized.startswith(
             "processing"
         ):
             self._set_status("processing", "Processing")
             self._set_progress(0)  # 0% on start
             self._video_duration_seconds = None  # Reset for new processing
+            self._encode_target_duration_seconds = None
+            self._encode_total_frames = None
+            self._encode_current_frame = None
+
+        frame_total_match = re.search(
+            r"Final encode target frames(?: \(fallback\))?:\s*(\d+)", message
+        )
+        if frame_total_match:
+            self._encode_total_frames = int(frame_total_match.group(1))
+            return
+
+        if "final encode target frames" in normalized and "unknown" in normalized:
+            self._encode_total_frames = None
+            return
+
+        frame_match = re.search(r"frame=\s*(\d+)", message)
+        if frame_match:
+            try:
+                current_frame = int(frame_match.group(1))
+            except ValueError:
+                current_frame = None
+
+            if current_frame is not None:
+                if self._encode_current_frame == current_frame:
+                    return
+
+                self._encode_current_frame = current_frame
+                if self._encode_total_frames and self._encode_total_frames > 0:
+                    percentage = min(
+                        100,
+                        int((current_frame / self._encode_total_frames) * 100),
+                    )
+                    self._set_progress(percentage)
+                else:
+                    self._set_status("processing", f"{current_frame} frames encoded")
+
+        # Parse encode target duration reported by the pipeline
+        encode_duration_match = re.search(
+            r"Final encode target duration(?: \(fallback\))?:\s*([\d.]+)s",
+            message,
+        )
+        if encode_duration_match:
+            try:
+                self._encode_target_duration_seconds = float(
+                    encode_duration_match.group(1)
+                )
+            except ValueError:
+                self._encode_target_duration_seconds = None
+
+        if "final encode target duration" in normalized and "unknown" in normalized:
+            self._encode_target_duration_seconds = None
 
         # Parse video duration from FFmpeg output
         duration_match = re.search(r"Duration:\s*(\d{2}):(\d{2}):(\d{2}\.\d+)", message)
@@ -1182,21 +1269,34 @@ class TalksReducerGUI:
             hours = int(time_match.group(1))
             minutes = int(time_match.group(2))
             seconds = int(time_match.group(3))
-            time_str = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+            current_seconds = hours * 3600 + minutes * 60 + seconds
+            time_str = self._format_progress_time(current_seconds)
             speed_str = speed_match.group(1)
 
-            # Calculate percentage if we have duration
-            if self._video_duration_seconds and self._video_duration_seconds > 0:
-                current_seconds = hours * 3600 + minutes * 60 + seconds
-                percentage = min(
-                    100, int((current_seconds / self._video_duration_seconds) * 100)
-                )
-                self._set_status(
-                    "processing", f"{time_str}, {speed_str}x ({percentage}%)"
-                )
-                self._set_progress(percentage)  # Update progress bar
+            total_seconds = (
+                self._encode_target_duration_seconds or self._video_duration_seconds
+            )
+            if total_seconds:
+                total_str = self._format_progress_time(total_seconds)
+                time_display = f"{time_str} / {total_str}"
             else:
-                self._set_status("processing", f"{time_str}, {speed_str}x")
+                time_display = time_str
+
+            status_msg = f"{time_display}, {speed_str}x"
+
+            if (
+                (
+                    not self._encode_total_frames
+                    or self._encode_total_frames <= 0
+                    or self._encode_current_frame is None
+                )
+                and total_seconds
+                and total_seconds > 0
+            ):
+                percentage = min(100, int((current_seconds / total_seconds) * 100))
+                self._set_progress(percentage)
+
+            self._set_status("processing", status_msg)
 
     def _apply_status_style(self, status: str) -> None:
         color = STATUS_COLORS.get(status.lower())
@@ -1208,7 +1308,7 @@ class TalksReducerGUI:
             status_lower = status.lower()
             if (
                 "extracting audio" in status_lower
-                or re.search(r"\d{2}:\d{2}:\d{2}.*\d+\.?\d*x", status)
+                or re.search(r"\d+:\d{2}(?: / \d+:\d{2})?.*\d+\.?\d*x", status)
                 or ("time:" in status_lower and "size:" in status_lower)
             ):
                 if "time:" in status_lower and "size:" in status_lower:
@@ -1261,6 +1361,23 @@ class TalksReducerGUI:
 
         self.root.after(0, apply)
 
+    def _format_progress_time(self, total_seconds: float) -> str:
+        """Format a duration in seconds as h:mm or m:ss for status display."""
+
+        try:
+            rounded_seconds = max(0, int(round(total_seconds)))
+        except (TypeError, ValueError):
+            return "0:00"
+
+        hours, remainder = divmod(rounded_seconds, 3600)
+        minutes, seconds = divmod(remainder, 60)
+
+        if hours > 0:
+            return f"{hours}:{minutes:02d}"
+
+        total_minutes = rounded_seconds // 60
+        return f"{total_minutes}:{seconds:02d}"
+
     def _calculate_gradient_color(self, percentage: int, darken: float = 1.0) -> str:
         """Calculate color gradient from red (0%) to green (100%).
 
@@ -1377,6 +1494,24 @@ def main(argv: Optional[Sequence[str]] = None) -> bool:
         argv = sys.argv[1:]
 
     if argv:
+        launch_gui = False
+        if sys.platform == "win32" and not any(arg.startswith("-") for arg in argv):
+            # Only attempt to launch the GUI automatically when the arguments
+            # look like file or directory paths. This matches the behaviour of
+            # file association launches on Windows while still allowing the CLI
+            # to be used explicitly with option flags.
+            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
 

talks_reducer/models.py

@@ -2,11 +2,36 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+import os
+import sys
+import tempfile
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Optional
 
 
+def default_temp_folder() -> Path:
+    """Return an OS-appropriate default temporary workspace directory."""
+
+    if sys.platform == "darwin":
+        base = Path.home() / "Library" / "Application Support" / "talks-reducer"
+    elif sys.platform == "win32":
+        appdata = os.environ.get("LOCALAPPDATA") or os.environ.get("APPDATA")
+        base = (
+            Path(appdata)
+            if appdata
+            else Path.home() / "AppData" / "Local" / "talks-reducer"
+        )
+    else:
+        xdg_runtime = os.environ.get("XDG_RUNTIME_DIR")
+        if xdg_runtime:
+            base = Path(xdg_runtime) / "talks-reducer"
+        else:
+            base = Path(tempfile.gettempdir()) / "talks-reducer"
+
+    return base / "temp"
+
+
 @dataclass(frozen=True)
 class ProcessingOptions:
     """Configuration values controlling how the talks reducer processes media.
@@ -18,13 +43,13 @@ class ProcessingOptions:
     input_file: Path
     output_file: Optional[Path] = None
     frame_rate: float = 30.0
-    sample_rate: int = 44100
-    silent_threshold: float = 0.03
+    sample_rate: int = 48000
+    silent_threshold: float = 0.05
     silent_speed: float = 4.0
     sounded_speed: float = 1.0
     frame_spreadage: int = 2
     audio_fade_envelope_size: int = 400
-    temp_folder: Path = Path("TEMP")
+    temp_folder: Path = field(default_factory=default_temp_folder)
     small: bool = False