better-ffmpeg-progress 3.2.6__tar.gz → 4.0.1__tar.gz

{better_ffmpeg_progress-3.2.6 → better_ffmpeg_progress-4.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: better-ffmpeg-progress
-Version: 3.2.6
+Version: 4.0.1
 Summary: Run FFmpeg & see percentage progress + ETA.
 Home-page: https://github.com/CrypticSignal/better-ffmpeg-progress
 Author: GitHub.com/CrypticSignal
@@ -13,6 +13,7 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: psutil
+Requires-Dist: requests
 Requires-Dist: rich
 Requires-Dist: tqdm
 
@@ -53,13 +54,37 @@ pip install better-ffmpeg-progress --upgrade
 ## Usage
 Create an instance of the `FfmpegProcess` class and supply a list of arguments like you would to `subprocess.run()` or `subprocess.Popen()`.
 
-Here's a simple example:
+Example:
 ```py
-from better_ffmpeg_progress import FfmpegProcess
+from better_ffmpeg_progress import FfmpegProcess, FfmpegProcessError
 
-process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:v", "libx265", "output.mp4"])
-# return_code will be 0 if the process completed successfully, otherwise it will be 1
-return_code = process.run()
+command = [
+    "ffmpeg",
+    "-i",
+    "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-c:a",
+    "copy",
+    "-f",
+    "null",
+    "-",
+]
+
+try:
+    process = FfmpegProcess(command)
+    # Uncomment the line below if you want to use tqdm instead of rich for the progress bar
+    # process.use_tqdm = True
+
+    # Run the FFmpeg command and show a progress bar
+    process.run()
+    # The FFmpeg process failed if the return code is not 0
+    if process.return_code != 0:
+        pass
+except FfmpegProcessError as e:
+    print(f"An error occurred when running the better-ffmpeg-process package:\n{e}")
 ```
 ## Optional Arguments
 An instance of the `FfmpegProcess` class takes the following **optional** arguments:
@@ -71,4 +96,3 @@ An instance of the `FfmpegProcess` class takes the following **optional** argume
 
 The `run` method takes the following **optional** arguments:
 - `print_command` - Print the FFmpeg command being executed. Default: `False`
-- `use_tqdm` - Use [tqdm](https://github.com/tqdm/tqdm) instead of [Rich](https://github.com/Textualize/rich) for the progress bar. Default: `False`

{better_ffmpeg_progress-3.2.6 → better_ffmpeg_progress-4.0.1}/README.md

@@ -35,13 +35,37 @@ pip install better-ffmpeg-progress --upgrade
 ## Usage
 Create an instance of the `FfmpegProcess` class and supply a list of arguments like you would to `subprocess.run()` or `subprocess.Popen()`.
 
-Here's a simple example:
+Example:
 ```py
-from better_ffmpeg_progress import FfmpegProcess
+from better_ffmpeg_progress import FfmpegProcess, FfmpegProcessError
 
-process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:v", "libx265", "output.mp4"])
-# return_code will be 0 if the process completed successfully, otherwise it will be 1
-return_code = process.run()
+command = [
+    "ffmpeg",
+    "-i",
+    "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-c:a",
+    "copy",
+    "-f",
+    "null",
+    "-",
+]
+
+try:
+    process = FfmpegProcess(command)
+    # Uncomment the line below if you want to use tqdm instead of rich for the progress bar
+    # process.use_tqdm = True
+
+    # Run the FFmpeg command and show a progress bar
+    process.run()
+    # The FFmpeg process failed if the return code is not 0
+    if process.return_code != 0:
+        pass
+except FfmpegProcessError as e:
+    print(f"An error occurred when running the better-ffmpeg-process package:\n{e}")
 ```
 ## Optional Arguments
 An instance of the `FfmpegProcess` class takes the following **optional** arguments:
@@ -52,5 +76,4 @@ An instance of the `FfmpegProcess` class takes the following **optional** argume
 - `print_stderr_new_line` - If better progress information cannot be shown, print FFmpeg stderr in a new line instead of replacing the current line in the terminal. Default: `False`
 
 The `run` method takes the following **optional** arguments:
-- `print_command` - Print the FFmpeg command being executed. Default: `False`
-- `use_tqdm` - Use [tqdm](https://github.com/tqdm/tqdm) instead of [Rich](https://github.com/Textualize/rich) for the progress bar. Default: `False`
+- `print_command` - Print the FFmpeg command being executed. Default: `False`

better_ffmpeg_progress-4.0.1/better_ffmpeg_progress/__init__.py

@@ -0,0 +1,17 @@
+from .better_ffmpeg_progress import FfmpegProcess
+from .enums import FfmpegLogLevel
+from .exceptions import (
+    FfmpegProcessError,
+    FfmpegCommandError,
+    FfmpegProcessUserCancelledError,
+    FfmpegProcessInterruptedError,
+)
+
+__all__ = [
+    "FfmpegProcess",
+    "FfmpegLogLevel",
+    "FfmpegProcessError",
+    "FfmpegCommandError",
+    "FfmpegProcessUserCancelledError",
+    "FfmpegProcessInterruptedError",
+]

better_ffmpeg_progress-4.0.1/better_ffmpeg_progress/better_ffmpeg_progress.py

@@ -0,0 +1,200 @@
+import os
+from pathlib import Path
+import subprocess
+from sys import exit
+from typing import List, Optional, Union
+
+from .enums import FfmpegLogLevel
+from .exceptions import (
+    FfmpegProcessError,
+    FfmpegCommandError,
+    FfmpegProcessUserCancelledError,
+    FfmpegProcessInterruptedError,
+)
+from .utils import (
+    validate_ffmpeg_command,
+    get_media_duration,
+    check_shell_needed_for_command,
+)
+from .terminate_process import terminate_ffmpeg_process
+from .progress_bars import use_rich, use_tqdm
+
+_FFMPEG_OVERWRITE_FLAG = "-y"
+
+
+class FfmpegProcess:
+    def _handle_overwrite_prompt(self) -> None:
+        """
+        Handles the logic for overwriting an existing output file.
+        Modifies self._ffmpeg_command to include -y if overwrite is confirmed.
+        Raises FfmpegProcessUserCancelledError or FfmpegProcessInterruptedError if not proceeding.
+        """
+        try:
+            answer = (
+                input(
+                    f"Output file {self._output_filepath} already exists. Overwrite? [y/N]: "
+                )
+                .strip()
+                .lower()
+            )
+            if answer == "y":
+                # Insert -y
+                self._ffmpeg_command.insert(1, _FFMPEG_OVERWRITE_FLAG)
+            else:
+                raise FfmpegProcessUserCancelledError(
+                    "FFmpeg process cancelled. Output file exists and overwrite declined."
+                )
+        except KeyboardInterrupt as e:
+            raise FfmpegProcessInterruptedError(
+                "[KeyboardInterrupt] FFmpeg process cancelled during overwrite prompt."
+            ) from e
+        except EOFError as e:
+            raise FfmpegProcessInterruptedError(
+                "Input error (EOF) during overwrite prompt. FFmpeg process cancelled."
+            ) from e
+
+    def __init__(
+        self,
+        command: List[str],
+        ffmpeg_log_level: Optional[Union[FfmpegLogLevel, str]] = None,
+        ffmpeg_log_file: Optional[Union[str, Path]] = None,
+        print_detected_duration: bool = False,
+    ):
+        # Raises FfmpegCommandError if the command is invalid
+        validate_ffmpeg_command(command)
+
+        ffmpeg_log_level_val: str
+
+        if ffmpeg_log_level is None:
+            ffmpeg_log_level_val = FfmpegLogLevel.VERBOSE.value
+        elif isinstance(ffmpeg_log_level, FfmpegLogLevel):
+            ffmpeg_log_level_val = ffmpeg_log_level.value
+        elif isinstance(ffmpeg_log_level, str):
+            try:
+                ffmpeg_log_level_val = FfmpegLogLevel(ffmpeg_log_level.lower()).value
+            except ValueError:
+                valid_levels = [e.value for e in FfmpegLogLevel]
+                raise FfmpegCommandError(
+                    f"Invalid ffmpeg_log_level string: '{ffmpeg_log_level}'. "
+                    f"Must be one of {valid_levels} (case-insensitive)."
+                )
+        else:
+            raise TypeError(
+                f"ffmpeg_log_level must be an FfmpegLogLevel enum instance, a string, or None, "
+                f"not {type(ffmpeg_log_level).__name__}"
+            )
+        self._ffmpeg_log_level_val = ffmpeg_log_level_val
+
+        input_file_index = command.index("-i")
+        input_file_path_str = command[input_file_index + 1]
+        self._input_filepath = Path(input_file_path_str)
+        # Assumes last argument is output
+        self._output_filepath = Path(command[-1])
+
+        self._ffmpeg_log_file = Path(
+            ffmpeg_log_file or f"{self._input_filepath.name}_ffmpeg_log.txt"
+        )
+        self._print_detected_duration = print_detected_duration
+        self._duration_secs = get_media_duration(input_file_path_str)
+
+        if self._print_detected_duration and self._duration_secs is not None:
+            print(f"Detected duration: {self._duration_secs:.2f} seconds")
+        elif self._print_detected_duration and self._duration_secs is None:
+            print(
+                "Could not detect duration. Progress bar may not show time remaining."
+            )
+
+        self._ffmpeg_command = [
+            command[0],
+            "-hide_banner",
+            "-loglevel",
+            self._ffmpeg_log_level_val,
+            "-progress",
+            "pipe:1",  # stdout
+            "-nostats",
+        ]
+        self._ffmpeg_command.extend(command[1:])
+
+        is_overwrite_in_user_command = any(
+            arg == _FFMPEG_OVERWRITE_FLAG for arg in command[1:]
+        )
+
+        if self._output_filepath.exists() and not is_overwrite_in_user_command:
+            self._handle_overwrite_prompt()
+
+        self._process: Optional[subprocess.Popen] = None
+        self._return_code: Optional[int] = None
+        self.use_tqdm: bool = False
+
+    def run(
+        self,
+        print_command: bool = False,
+    ) -> int:
+        if print_command:
+            cmd_str = (
+                " ".join(self._ffmpeg_command)
+                if isinstance(self._ffmpeg_command, list)
+                else self._ffmpeg_command
+            )
+            print(f"Executing: {cmd_str}")
+
+        self._shell_needed = check_shell_needed_for_command(
+            self._ffmpeg_command
+            if isinstance(self._ffmpeg_command, list)
+            else [self._ffmpeg_command]
+        )
+
+        current_ffmpeg_command = self._ffmpeg_command
+        if self._shell_needed and isinstance(current_ffmpeg_command, list):
+            current_ffmpeg_command = " ".join(current_ffmpeg_command)
+
+        self._return_code = 1
+
+        try:
+            with open(self._ffmpeg_log_file, "w", encoding="utf-8") as f:
+                creationflags = 0
+
+                if os.name == "nt":
+                    creationflags = subprocess.CREATE_NEW_PROCESS_GROUP
+
+                self._process = subprocess.Popen(
+                    current_ffmpeg_command,
+                    shell=self._shell_needed,
+                    stdout=subprocess.PIPE,
+                    stderr=f,
+                    creationflags=creationflags,
+                )
+        except Exception as e:
+            # self._return_code remains None as the process didn't start
+            raise FfmpegProcessError(f"Error starting FFmpeg process: {e}") from e
+
+        try:
+            if self.use_tqdm:
+                self._return_code = use_tqdm(self, self._process)
+            else:
+                self._return_code = use_rich(self, self._process)
+        except KeyboardInterrupt:
+            self._terminate()
+            self._return_code = 1
+        finally:
+            if self._process:
+                self._return_code = self._process.returncode
+
+                if self._process.stdout:
+                    self._process.stdout.close()
+
+        return self._return_code
+
+    def _terminate(self):
+        if self._process:
+            terminate_ffmpeg_process(self._process)
+        else:
+            exit()
+
+    @property
+    def return_code(self) -> Optional[int]:
+        """
+        The return code of the FFmpeg process.
+        None if the process has not started or failed to start.
+        """
+        return self._return_code

better_ffmpeg_progress-4.0.1/better_ffmpeg_progress/enums.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class FfmpegLogLevel(Enum):
+    QUIET = "quiet"
+    PANIC = "panic"
+    FATAL = "fatal"
+    ERROR = "error"
+    WARNING = "warning"
+    INFO = "info"
+    VERBOSE = "verbose"
+    DEBUG = "debug"
+    TRACE = "trace"

better_ffmpeg_progress-4.0.1/better_ffmpeg_progress/exceptions.py

@@ -0,0 +1,14 @@
+class FfmpegProcessError(Exception):
+    pass
+
+
+class FfmpegCommandError(FfmpegProcessError):
+    pass
+
+
+class FfmpegProcessUserCancelledError(FfmpegProcessError):
+    pass
+
+
+class FfmpegProcessInterruptedError(FfmpegProcessError):
+    pass

better_ffmpeg_progress-4.0.1/better_ffmpeg_progress/progress_bars.py

@@ -0,0 +1,130 @@
+import os
+import subprocess
+from typing import TYPE_CHECKING
+
+from rich.progress import (
+    Progress,
+    TextColumn,
+    BarColumn,
+    TaskProgressColumn,
+    TimeRemainingColumn,
+    TimeElapsedColumn,
+)
+from tqdm import tqdm
+
+from .utils import parse_ffmpeg_progress_line
+
+if TYPE_CHECKING:
+    from .better_ffmpeg_progress import FfmpegProcess
+
+
+def use_rich(
+    ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
+) -> int:
+    task_id = None
+    progress_bar_instance = Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        TimeElapsedColumn(),
+        TimeRemainingColumn(compact=True),
+        refresh_per_second=2,
+    )
+
+    duration_secs = ffmpeg_process_instance._duration_secs
+    input_filename = ffmpeg_process_instance._input_filepath.name
+    log_file = ffmpeg_process_instance._ffmpeg_log_file
+
+    with progress_bar_instance as progress_bar:
+        if duration_secs:
+            task_id = progress_bar.add_task(
+                f"Processing {input_filename}",
+                total=duration_secs,
+            )
+            update_progress = progress_bar.update
+
+            for line_bytes in process.stdout:
+                stripped_line_bytes = line_bytes.strip()
+                progress_val_secs = parse_ffmpeg_progress_line(
+                    stripped_line_bytes, duration_secs
+                )
+                if progress_val_secs is not None and task_id is not None:
+                    update_progress(task_id, completed=progress_val_secs)
+        else:
+            print(f"Processing {input_filename}...")
+
+        process.wait()
+
+        if task_id is not None:
+            if process.returncode == 0:
+                update_progress(task_id, completed=duration_secs)
+                progress_bar.columns = (
+                    TextColumn("[progress.description]{task.description}"),
+                    BarColumn(),
+                    TaskProgressColumn(),
+                )
+                update_progress(
+                    task_id,
+                    description=f"✓ Processed {input_filename}",
+                )
+            else:
+                progress_bar.update(
+                    task_id,
+                    description=f"FFmpeg process failed. Check {log_file} for details.",
+                )
+
+        if process.returncode != 0 and task_id is None:
+            print(f"FFmpeg process failed. Check {log_file} for details.")
+
+        return 1 if process.returncode != 0 else 0
+
+
+def use_tqdm(
+    ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
+) -> int:
+    progress_bar = None
+    try:
+        width = os.get_terminal_size().columns
+    except OSError:
+        width = 80
+
+    duration_secs = ffmpeg_process_instance._duration_secs
+    input_filename = ffmpeg_process_instance._input_filepath.name
+    log_file = ffmpeg_process_instance._ffmpeg_log_file
+
+    if duration_secs:
+        progress_bar = tqdm(
+            mininterval=0.5,
+            total=duration_secs,
+            desc=f"Processing {input_filename}",
+            ncols=80,
+            dynamic_ncols=True if width < 80 else False,
+            bar_format="{desc} {bar} {percentage:.1f}% [{elapsed}<{remaining}, {rate_fmt}{postfix}]",
+        )
+
+        for line_bytes in process.stdout:
+            stripped_line_bytes = line_bytes.strip()
+            progress_val_secs = parse_ffmpeg_progress_line(
+                stripped_line_bytes, duration_secs
+            )
+            if progress_val_secs is not None and progress_bar is not None:
+                progress_bar.n = progress_val_secs
+                progress_bar.refresh()
+    else:
+        print(f"Processing {input_filename}...")
+
+    process.wait()
+
+    if process.returncode == 0:
+        if progress_bar:
+            progress_bar.n = duration_secs
+            progress_bar.set_description(f"✓ Processed {input_filename}")
+            progress_bar.close()
+        else:
+            print(f"✓ Processed {input_filename}")
+    else:
+        if progress_bar:
+            progress_bar.close()
+        print(f"FFmpeg process failed. Check {log_file} for details.")
+
+    return 1 if process.returncode != 0 else 0