mkv2cast 1.2.7.post4__py3-none-any.whl

mkv2cast/ui/simple_rich.py

@@ -0,0 +1,243 @@
+"""
+Simple Rich-based progress UI for mkv2cast (sequential mode).
+
+Provides a beautiful progress bar for single-file encoding.
+
+Respects:
+- NO_COLOR environment variable
+- MKV2CAST_SCRIPT_MODE environment variable
+- sys.stdout.isatty() for automatic detection
+"""
+
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+from rich.console import Console
+from rich.live import Live
+from rich.progress import (
+    BarColumn,
+    Progress,
+    SpinnerColumn,
+    TaskID,
+    TextColumn,
+    TimeElapsedColumn,
+    TimeRemainingColumn,
+)
+from rich.table import Table
+
+from mkv2cast.i18n import _
+from mkv2cast.ui.legacy_ui import fmt_hms
+
+
+def _should_use_color() -> bool:
+    """Check if color output should be used."""
+    # Check NO_COLOR environment variable (https://no-color.org/)
+    if os.getenv("NO_COLOR"):
+        return False
+    # Check script mode
+    if os.getenv("MKV2CAST_SCRIPT_MODE"):
+        return False
+    # Check if stdout is a TTY
+    try:
+        if not sys.stdout.isatty():
+            return False
+    except Exception:
+        return False
+    return True
+
+
+class SimpleRichUI:
+    """Simple Rich-based UI for sequential file processing."""
+
+    def __init__(self, progress_enabled: bool = True):
+        # Respect NO_COLOR and TTY detection
+        use_color = _should_use_color()
+        self.console = Console(
+            force_terminal=use_color if use_color else None,
+            no_color=not use_color,
+        )
+        self.enabled = progress_enabled and use_color
+
+        # Stats
+        self.ok = 0
+        self.skipped = 0
+        self.failed = 0
+        self.processed = 0
+
+        # Current progress
+        self.progress: Optional[Progress] = None
+        self.current_task: Optional[TaskID] = None
+        self.live: Optional[Live] = None
+
+    def log(self, msg: str, style: str = "") -> None:
+        """Print a log message."""
+        if style:
+            self.console.print(msg, style=style)
+        else:
+            self.console.print(msg)
+
+    def log_file_start(self, inp: Path, output: Path) -> None:
+        """Log start of file processing."""
+        self.console.print()
+        self.console.print(f"[bold blue]▶[/bold blue] [cyan]{inp.name}[/cyan]")
+        self.console.print(f"  [dim]→ {output.name}[/dim]")
+
+    def log_skip(self, reason: str) -> None:
+        """Log a skip."""
+        self.console.print(f"  [yellow]⊘ {_('SKIP')}[/yellow]: {reason}")
+        self.skipped += 1
+        self.processed += 1
+
+    def log_error(self, error: str) -> None:
+        """Log an error."""
+        self.console.print(f"  [red]✗ {_('FAILED')}[/red]: {error}")
+        self.failed += 1
+        self.processed += 1
+
+    def log_success(self, elapsed: float, output_size: int = 0) -> None:
+        """Log success."""
+        size_str = ""
+        if output_size > 0:
+            size_mb = output_size / (1024 * 1024)
+            size_str = f" ({size_mb:.1f} MB)"
+        self.console.print(f"  [green]✓ {_('OK')}[/green] {_('in')} {fmt_hms(elapsed)}{size_str}")
+        self.ok += 1
+        self.processed += 1
+
+    def log_compatible(self) -> None:
+        """Log file is already compatible."""
+        self.console.print(f"  [green]✓[/green] [dim]{_('Already compatible')}[/dim]")
+        self.skipped += 1
+        self.processed += 1
+
+    def run_ffmpeg_with_progress(
+        self, cmd: List[str], stage: str, dur_ms: int = 0, file_idx: int = 1, total_files: int = 1
+    ) -> Tuple[int, str]:
+        """
+        Run ffmpeg command while showing progress.
+
+        Returns (return_code, error_message).
+        """
+        if not self.enabled:
+            # Fallback to simple execution
+            result = subprocess.run(cmd, capture_output=True, timeout=86400)
+            stderr = result.stderr.decode("utf-8", errors="replace") if result.stderr else ""
+            return result.returncode, stderr
+
+        # Create progress bar
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[bold blue]{task.description}[/bold blue]"),
+            BarColumn(bar_width=40),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            TextColumn("•"),
+            TextColumn("[cyan]{task.fields[speed]}[/cyan]"),
+            TextColumn("•"),
+            TimeElapsedColumn(),
+            TextColumn("→"),
+            TimeRemainingColumn(),
+            console=self.console,
+            transient=True,
+        )
+
+        task_desc = f"[{file_idx}/{total_files}] {stage}"
+        task_id = progress.add_task(task_desc, total=100, speed="0.0x")
+
+        # Start ffmpeg process
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=False,
+        )
+
+        # Read stderr for progress updates
+        stderr_buffer = []
+        last_pct = 0
+
+        with progress:
+            while True:
+                # Read one line from stderr
+                if process.stderr is None:
+                    break
+                line = process.stderr.readline()
+                if not line:
+                    break
+
+                line_str = line.decode("utf-8", errors="replace")
+                stderr_buffer.append(line_str)
+
+                # Parse ffmpeg progress
+                # Example: frame=  123 fps=45 q=28.0 size=    1234kB time=00:00:05.12 bitrate=1234.5kbits/s speed=1.23x
+                pct, speed = self._parse_ffmpeg_progress(line_str, dur_ms)
+
+                if pct > last_pct:
+                    last_pct = pct
+                    progress.update(task_id, completed=pct)
+
+                if speed:
+                    progress.update(task_id, speed=speed)
+
+        # Wait for process to complete
+        process.wait()
+
+        stderr_text = "".join(stderr_buffer)
+        return process.returncode, stderr_text
+
+    def _parse_ffmpeg_progress(self, line: str, dur_ms: int) -> Tuple[int, str]:
+        """Parse ffmpeg progress line. Returns (percentage, speed)."""
+        pct = 0
+        speed = ""
+
+        # Parse time
+        m = re.search(r"time=\s*(\d+):(\d+):(\d+)\.(\d+)", line)
+        if m and dur_ms > 0:
+            h, mi, s, cs = int(m.group(1)), int(m.group(2)), int(m.group(3)), int(m.group(4))
+            current_ms = (h * 3600 + mi * 60 + s) * 1000 + cs * 10
+            pct = min(100, int(current_ms * 100 / dur_ms))
+
+        # Parse speed
+        m = re.search(r"speed=\s*([0-9.]+)x", line)
+        if m:
+            speed = f"{float(m.group(1)):.1f}x"
+
+        return pct, speed
+
+    def print_summary(self, total_time: float) -> None:
+        """Print final summary."""
+        self.console.print()
+
+        # Create summary table
+        table = Table(title=_("Summary"), box=None, show_header=False)
+        table.add_column("Metric", style="bold")
+        table.add_column("Value", justify="right")
+
+        table.add_row(f"✓ {_('Converted')}", f"[green]{self.ok}[/green]")
+        table.add_row(f"⊘ {_('Skipped')}", f"[yellow]{self.skipped}[/yellow]")
+        table.add_row(f"✗ {_('Failed')}", f"[red]{self.failed}[/red]")
+        table.add_row(f"⏱ {_('Total time')}", fmt_hms(total_time))
+
+        self.console.print(table)
+
+    def inc_ok(self) -> None:
+        """Increment success counter."""
+        self.ok += 1
+        self.processed += 1
+
+    def inc_skipped(self) -> None:
+        """Increment skipped counter."""
+        self.skipped += 1
+        self.processed += 1
+
+    def inc_failed(self) -> None:
+        """Increment failed counter."""
+        self.failed += 1
+        self.processed += 1
+
+    def get_stats(self):
+        """Get current stats."""
+        return (self.ok, self.skipped, self.failed, self.processed)

mkv2cast/watcher.py

@@ -0,0 +1,293 @@
+"""
+Watch mode for mkv2cast.
+
+Monitors directories for new MKV files and automatically converts them.
+Uses watchdog library if available, falls back to polling otherwise.
+"""
+
+import os
+import time
+from pathlib import Path
+from threading import Event, Thread
+from typing import TYPE_CHECKING, Any, Callable, Optional, Set
+
+from mkv2cast.config import Config
+from mkv2cast.integrity import check_file_stable
+
+# Try to import watchdog for efficient file system monitoring
+if TYPE_CHECKING:
+    from watchdog.events import FileCreatedEvent, FileMovedEvent, FileSystemEventHandler
+    from watchdog.observers import Observer
+
+try:
+    from watchdog.events import FileCreatedEvent, FileMovedEvent, FileSystemEventHandler
+    from watchdog.observers import Observer
+
+    WATCHDOG_AVAILABLE = True
+except ImportError:
+    WATCHDOG_AVAILABLE = False
+    # Type stubs for mypy
+    Observer = None  # type: ignore
+    FileSystemEventHandler = None  # type: ignore
+    FileCreatedEvent = None  # type: ignore
+    FileMovedEvent = None  # type: ignore
+
+
+class MKVFileHandler:
+    """Handler for new MKV files."""
+
+    def __init__(
+        self,
+        convert_callback: Callable[[Path], None],
+        cfg: Config,
+        stable_wait: int = 5,
+    ):
+        """
+        Initialize the handler.
+
+        Args:
+            convert_callback: Function to call when a new MKV file is detected.
+            cfg: Configuration instance.
+            stable_wait: Seconds to wait for file to stabilize.
+        """
+        self.convert_callback = convert_callback
+        self.cfg = cfg
+        self.stable_wait = stable_wait
+        self.processing: Set[Path] = set()
+        self._lock = __import__("threading").Lock()
+
+    def handle_file(self, filepath: Path) -> None:
+        """Handle a new or moved file."""
+        # Only process MKV files
+        if not filepath.suffix.lower() == ".mkv":
+            return
+
+        # Skip our output files
+        name = filepath.name
+        if ".tmp." in name or self.cfg.suffix in name:
+            return
+        if ".h264." in name or ".aac." in name or ".remux." in name:
+            return
+
+        # Check if already processing
+        with self._lock:
+            if filepath in self.processing:
+                return
+            self.processing.add(filepath)
+
+        try:
+            # Wait for file to be stable (not being written)
+            if not check_file_stable(filepath, wait_seconds=self.stable_wait):
+                return
+
+            # Convert the file
+            self.convert_callback(filepath)
+
+        finally:
+            with self._lock:
+                self.processing.discard(filepath)
+
+
+if WATCHDOG_AVAILABLE:
+
+    class WatchdogHandler(FileSystemEventHandler):
+        """Watchdog event handler for MKV files."""
+
+        def __init__(self, mkv_handler: MKVFileHandler):
+            super().__init__()
+            self.mkv_handler = mkv_handler
+
+        def on_created(self, event: "FileCreatedEvent") -> None:  # type: ignore[override]
+            if not event.is_directory:
+                # Run in thread to not block the observer
+                src_path = str(event.src_path) if isinstance(event.src_path, bytes) else event.src_path
+                Thread(
+                    target=self.mkv_handler.handle_file,
+                    args=(Path(src_path),),
+                    daemon=True,
+                ).start()
+
+        def on_moved(self, event: "FileMovedEvent") -> None:  # type: ignore[override]
+            if not event.is_directory:
+                # Handle files moved into watched directory
+                dest_path = str(event.dest_path) if isinstance(event.dest_path, bytes) else event.dest_path
+                Thread(
+                    target=self.mkv_handler.handle_file,
+                    args=(Path(dest_path),),
+                    daemon=True,
+                ).start()
+
+
+class DirectoryWatcher:
+    """
+    Watch a directory for new MKV files.
+
+    Uses watchdog if available, otherwise falls back to polling.
+    """
+
+    def __init__(
+        self,
+        watch_path: Path,
+        convert_callback: Callable[[Path], None],
+        cfg: Config,
+        interval: float = 5.0,
+        recursive: bool = True,
+    ):
+        """
+        Initialize the watcher.
+
+        Args:
+            watch_path: Directory to watch.
+            convert_callback: Function to call for each new MKV file.
+            cfg: Configuration instance.
+            interval: Polling interval in seconds (for fallback mode).
+            recursive: Watch subdirectories.
+        """
+        self.watch_path = watch_path
+        self.convert_callback = convert_callback
+        self.cfg = cfg
+        self.interval = interval
+        self.recursive = recursive
+        self.stop_event = Event()
+        self._observer: Optional[Any] = None
+        self._poll_thread: Optional[Thread] = None
+
+        self.mkv_handler = MKVFileHandler(
+            convert_callback=convert_callback,
+            cfg=cfg,
+            stable_wait=cfg.stable_wait,
+        )
+
+    def start(self) -> None:
+        """Start watching the directory."""
+        if WATCHDOG_AVAILABLE:
+            self._start_watchdog()
+        else:
+            self._start_polling()
+
+    def _start_watchdog(self) -> None:
+        """Start watching using watchdog."""
+        if not WATCHDOG_AVAILABLE:
+            return
+        handler = WatchdogHandler(self.mkv_handler)
+        observer = Observer()
+        observer.schedule(handler, str(self.watch_path), recursive=self.recursive)
+        observer.start()
+        self._observer = observer
+
+    def _start_polling(self) -> None:
+        """Start watching using polling (fallback)."""
+        self._known_files: Set[Path] = set()
+
+        # Initial scan
+        self._scan_directory()
+
+        # Start polling thread
+        poll_thread = Thread(target=self._polling_loop, daemon=True)
+        poll_thread.start()
+        self._poll_thread = poll_thread
+
+    def _scan_directory(self) -> Set[Path]:
+        """Scan directory for MKV files."""
+        found = set()
+        try:
+            if self.recursive:
+                for root, _dirs, files in os.walk(self.watch_path):
+                    for f in files:
+                        if f.lower().endswith(".mkv"):
+                            found.add(Path(root) / f)
+            else:
+                for item in self.watch_path.iterdir():
+                    if item.is_file() and item.suffix.lower() == ".mkv":
+                        found.add(item)
+        except OSError:
+            pass
+        return found
+
+    def _polling_loop(self) -> None:
+        """Polling loop for fallback mode."""
+        while not self.stop_event.is_set():
+            time.sleep(self.interval)
+
+            current_files = self._scan_directory()
+            new_files = current_files - self._known_files
+
+            for filepath in new_files:
+                Thread(
+                    target=self.mkv_handler.handle_file,
+                    args=(filepath,),
+                    daemon=True,
+                ).start()
+
+            self._known_files = current_files
+
+    def stop(self) -> None:
+        """Stop watching."""
+        self.stop_event.set()
+
+        if self._observer is not None:
+            # Observer has stop() and join() methods
+            self._observer.stop()  # type: ignore[attr-defined]
+            self._observer.join(timeout=5)  # type: ignore[attr-defined]
+
+        if self._poll_thread is not None:
+            self._poll_thread.join(timeout=5)
+
+    def wait(self) -> None:
+        """Wait until stopped (blocks)."""
+        try:
+            while not self.stop_event.is_set():
+                time.sleep(0.5)
+        except KeyboardInterrupt:
+            pass
+
+
+def watch_directory(
+    path: Path,
+    convert_callback: Callable[[Path], None],
+    cfg: Config,
+    interval: float = 5.0,
+    print_fn: Optional[Callable[[str], None]] = None,
+) -> None:
+    """
+    Watch a directory for new MKV files and convert them.
+
+    This function blocks until interrupted (Ctrl+C).
+
+    Args:
+        path: Directory to watch.
+        convert_callback: Function to call for each new MKV file.
+        cfg: Configuration instance.
+        interval: Polling interval in seconds.
+        print_fn: Optional function to print status messages.
+    """
+    if print_fn is None:
+        print_fn = print
+
+    if not path.is_dir():
+        print_fn(f"Error: {path} is not a directory")
+        return
+
+    mode = "watchdog" if WATCHDOG_AVAILABLE else "polling"
+    recursive = "recursive" if cfg.recursive else "non-recursive"
+
+    print_fn(f"Watching {path} ({mode}, {recursive})")
+    print_fn("Press Ctrl+C to stop")
+    print_fn("")
+
+    watcher = DirectoryWatcher(
+        watch_path=path,
+        convert_callback=convert_callback,
+        cfg=cfg,
+        interval=interval,
+        recursive=cfg.recursive,
+    )
+
+    try:
+        watcher.start()
+        watcher.wait()
+    except KeyboardInterrupt:
+        print_fn("\nStopping watcher...")
+    finally:
+        watcher.stop()
+        print_fn("Watcher stopped.")