better-ffmpeg-progress 3.2.5__tar.gz → 4.0.0__tar.gz

{better_ffmpeg_progress-3.2.5 → better_ffmpeg_progress-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: better-ffmpeg-progress
-Version: 3.2.5
+Version: 4.0.0
 Summary: Run FFmpeg & see percentage progress + ETA.
 Home-page: https://github.com/CrypticSignal/better-ffmpeg-progress
 Author: GitHub.com/CrypticSignal
@@ -53,13 +53,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 +95,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.5 → better_ffmpeg_progress-4.0.0}/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.0/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.0/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.0/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.0/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.0/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

better_ffmpeg_progress-4.0.0/better_ffmpeg_progress/terminate_process.py

@@ -0,0 +1,249 @@
+import os
+import psutil
+import subprocess
+from sys import exit
+from typing import Optional
+
+_TERMINATION_TIMEOUT = 2
+
+
+def _terminate_children_processes(parent_proc: psutil.Process):
+    """Helper to terminate child processes of the given parent process."""
+    try:
+        if not parent_proc.is_running():
+            return
+        children = parent_proc.children(recursive=True)
+    except (psutil.NoSuchProcess, psutil.ZombieProcess):
+        print(
+            f"Parent process {parent_proc.pid} not found or is a zombie while fetching children."
+        )
+        return
+    except psutil.AccessDenied:
+        print(
+            f"Access denied when trying to list children of {parent_proc.pid}. Skipping child termination."
+        )
+        return
+    except Exception as e:
+        print(
+            f"Error fetching children for process {parent_proc.pid}: {e}. Skipping child termination."
+        )
+        return
+
+    if not children:
+        return
+
+    print(
+        f"Attempting to terminate {len(children)} child process(es) of {parent_proc.pid}..."
+    )
+    for child in children:
+        try:
+            if child.is_running():
+                child.terminate()
+        except psutil.Error:
+            pass
+
+    _, alive = psutil.wait_procs(children, timeout=_TERMINATION_TIMEOUT)
+
+    if alive:
+        print(f"Force killing {len(alive)} remaining child process(es)...")
+        for child_to_kill in alive:
+            try:
+                if child_to_kill.is_running():
+                    child_to_kill.kill()
+            except psutil.Error:
+                pass
+
+
+def _terminate_parent_process_windows(proc: psutil.Process):
+    try:
+        # Same as .kill() on Windows
+        proc.terminate()
+        proc.wait(timeout=_TERMINATION_TIMEOUT)
+    except psutil.NoSuchProcess:
+        print(f"FFmpeg process {proc.pid} already exited.")
+    except psutil.TimeoutExpired:
+        print(
+            f"FFmpeg process {proc.pid} did not terminate within {_TERMINATION_TIMEOUT}s. Checking status..."
+        )
+        try:
+            # Check the status after the timeout
+            if proc.is_running():
+                print(
+                    f"FFmpeg process {proc.pid} still running after {_TERMINATION_TIMEOUT}s."
+                )
+            else:
+                print(
+                    f"FFmpeg process termination took longer than {_TERMINATION_TIMEOUT}s."
+                )
+        except psutil.NoSuchProcess:
+            print(
+                f"FFmpeg process not found after {_TERMINATION_TIMEOUT}s. It seems like it has terminated."
+            )
+        except psutil.Error as e:
+            print(
+                f"Error during status check for process {proc.pid} after timeout:\n{e}"
+            )
+    except psutil.AccessDenied:
+        print(f"Access denied when trying to terminate FFmpeg process {proc.pid}.")
+    except psutil.Error as e:
+        print(f"Unable to terminate FFmpeg process:\n{e}")
+
+
+def _terminate_parent_process_unix(proc: psutil.Process, original_pid: int):
+    """Helper to terminate the parent process and its group on Unix operating systems."""
+    from signal import SIGTERM, SIGKILL
+
+    terminated_by_pg = False
+    pgid_to_signal = 0
+    try:
+        pgid_to_signal = os.getpgid(original_pid)
+        print(f"Sending SIGTERM to process group {pgid_to_signal}...")
+        os.killpg(pgid_to_signal, SIGTERM)
+
+        try:
+            proc.wait(timeout=_TERMINATION_TIMEOUT)
+
+            if not proc.is_running():
+                terminated_by_pg = True
+        except psutil.TimeoutExpired:
+            print(
+                f"Process group {pgid_to_signal} did not exit after SIGTERM, sending SIGKILL..."
+            )
+            os.killpg(pgid_to_signal, SIGKILL)
+            try:
+                proc.wait(
+                    timeout=_TERMINATION_TIMEOUT
+                )  # Wait for SIGKILL on process group
+                if not proc.is_running():
+                    terminated_by_pg = True
+            except psutil.TimeoutExpired:
+                print(f"Process group {pgid_to_signal} still running after SIGKILL.")
+            # Process died after SIGKILL
+            except psutil.NoSuchProcess:
+                terminated_by_pg = True
+        # Process died after SIGTERM
+        except psutil.NoSuchProcess:
+            terminated_by_pg = True
+    # os.getpgid(original_pid) failed
+    except ProcessLookupError:
+        print(
+            f"ProcessLookupError for PID {original_pid} when trying to get PGID. Fallback to individual process."
+        )
+    # os.killpg failed
+    except OSError as e:
+        target_desc = (
+            f"process group {pgid_to_signal}"
+            if pgid_to_signal != 0
+            else f"process {original_pid}"
+        )
+        print(
+            f"Error sending signal to {target_desc}: {e}. Fallback to individual process."
+        )
+
+    if terminated_by_pg:
+        return
+
+    # Fallback: Terminate the main process directly if process group termination failed or was skipped
+    try:
+        if proc.is_running():
+            print(f"Attempting direct SIGTERM for main process {proc.pid}...")
+            try:
+                # Send SIGTERM
+                proc.terminate()
+                proc.wait(timeout=_TERMINATION_TIMEOUT)
+                # Successfully terminated with SIGTERM
+                if not proc.is_running():
+                    return
+            except psutil.TimeoutExpired:
+                print(
+                    f"SIGTERM for FFmpeg process (PID: {proc.pid}) timed out after {_TERMINATION_TIMEOUT}s."
+                )
+            except psutil.Error as e:
+                print(
+                    f"Error during SIGTERM for FFmpeg process (PID: {proc.pid}):\n{e}"
+                )
+                if not proc.is_running():
+                    return
+
+            # If SIGTERM failed/timed out and the process is still running, try SIGKILL:
+
+            # Check if process is still running
+            if proc.is_running():
+                print(
+                    f"FFmpeg process (PID: {proc.pid}) still running after direct SIGTERM, attempting SIGKILL..."
+                )
+                try:
+                    # Send SIGKILL
+                    proc.kill()
+                    print(f"SIGKILL sent to FFmpeg process (PID: {proc.pid}).")
+                except psutil.Error as e:
+                    print(
+                        f"Error during SIGKILL for FFmpeg process (PID: {proc.pid}):\n{e}"
+                    )
+        else:
+            print(f"It seems like FFmpeg process {proc.pid} is no longer running.")
+    except psutil.NoSuchProcess:
+        print(f"It seems like the FFmpeg process (PID: {proc.pid}) has terminated.")
+    except psutil.Error as e:
+        print(f"Unable to check the status of FFmpeg process (PID: {proc.pid}):\n{e}")
+
+
+def terminate_ffmpeg_process(process: Optional[subprocess.Popen]):
+    """
+    Terminates an FFmpeg process and its children.
+    'process' is the subprocess.Popen object for the FFmpeg process.
+    """
+    if not process or process.poll() is not None:
+        return
+
+    original_pid = process.pid
+
+    parent_ps_proc: Optional[psutil.Process] = None
+    try:
+        parent_ps_proc = psutil.Process(original_pid)
+    except (psutil.NoSuchProcess, psutil.ZombieProcess):
+        print(
+            f"FFmpeg process {original_pid} already gone or is a zombie when termination started."
+        )
+        return
+    except Exception as e:
+        print(f"Error accessing FFmpeg process {original_pid} with psutil: {e}")
+        if process.poll() is None:
+            try:
+                process.terminate()
+                process.wait(timeout=_TERMINATION_TIMEOUT)
+                if process.poll() is None:
+                    process.kill()
+                    process.wait(timeout=_TERMINATION_TIMEOUT)
+            except Exception as popen_term_err:
+                print(f"Error during fallback Popen termination: {popen_term_err}")
+        return
+
+    print("[better-ffmpeg-progress] Terminating the FFmpeg process...")
+
+    if parent_ps_proc:
+        _terminate_children_processes(parent_ps_proc)
+
+    try:
+        if parent_ps_proc and parent_ps_proc.is_running():
+            if os.name == "nt":
+                _terminate_parent_process_windows(parent_ps_proc)
+            else:
+                _terminate_parent_process_unix(parent_ps_proc, original_pid)
+        elif parent_ps_proc:
+            print(
+                f"Main FFmpeg process {parent_ps_proc.pid} exited, possibly during child termination or was already gone."
+            )
+    except psutil.NoSuchProcess:
+        print(
+            f"Main FFmpeg process {original_pid} became inaccessible during termination sequence."
+        )
+    except Exception as e:
+        print(
+            f"Unexpected error during main process termination for {original_pid}: {e}"
+        )
+
+    if process.poll() is None:
+        exit("It seems like the FFmpeg process has not terminated.")
+    else:
+        print(f"FFmpeg process (PID: {original_pid}) terminated.")

better_ffmpeg_progress-4.0.0/better_ffmpeg_progress/utils.py

@@ -0,0 +1,151 @@
+import shutil
+import subprocess
+from pathlib import Path
+from typing import List, Optional
+import requests  # Added for URL validation
+
+from .exceptions import FfmpegCommandError
+
+_FFMPEG_INPUT_FLAG = "-i"
+_OUT_TIME_US_PREFIX = b"out_time_us="
+_MULTIPLIER = 1e-6
+
+
+def validate_ffmpeg_command(command: List[str]) -> None:
+    """
+    Validates the FFmpeg command.
+    Raises FfmpegCommandError if validation fails.
+    """
+    if not command:
+        raise FfmpegCommandError("FFmpeg command list cannot be empty.")
+
+    ffmpeg_executable = command[0]
+    if not shutil.which(ffmpeg_executable):
+        err_msg = (
+            f"'{ffmpeg_executable}' not found. "
+            "Ensure it's in your system's PATH or provide the full path of the FFmpeg executable."
+        )
+
+        raise FfmpegCommandError(err_msg)
+
+    if _FFMPEG_INPUT_FLAG not in command:
+        raise FfmpegCommandError(
+            f"FFmpeg command must include the input flag '{_FFMPEG_INPUT_FLAG}'."
+        )
+
+    try:
+        input_flag_pos = command.index(_FFMPEG_INPUT_FLAG)
+    except ValueError:
+        raise FfmpegCommandError(
+            f"Internal error: Input flag '{_FFMPEG_INPUT_FLAG}' not found after check."
+        )
+
+    input_file_idx = input_flag_pos + 1
+    if input_file_idx >= len(command):
+        raise FfmpegCommandError(
+            f"No input file specified after '{_FFMPEG_INPUT_FLAG}'."
+        )
+
+    input_file = command[input_file_idx]
+    if (
+        input_file.startswith("-")
+        and len(input_file) == 2
+        and not input_file[1:].isdigit()
+    ):
+        raise FfmpegCommandError(
+            f"Input file path '{input_file}' looks like an option flag. Please check your command."
+        )
+
+    # Validate input file/URL
+    if input_file.startswith("http://") or input_file.startswith("https://"):
+        try:
+            response = requests.head(input_file, timeout=5, allow_redirects=True)
+            response.raise_for_status()
+        except requests.exceptions.RequestException as e:
+            raise FfmpegCommandError(
+                f"Input URL not accessible: {input_file}. Error: {e}"
+            )
+    elif not Path(input_file).exists():
+        raise FfmpegCommandError(f"Input file not found: {input_file}")
+
+    if len(command) <= input_file_idx + 1:
+        raise FfmpegCommandError(
+            "No output file specified. The command seems to end after the input file path."
+        )
+
+    output_file_path_str = command[-1]
+    if output_file_path_str == input_file:
+        raise FfmpegCommandError(
+            "Output file path cannot be the same as the input file path in this command structure."
+        )
+
+
+def get_media_duration(input_file: str) -> Optional[float]:
+    """
+    Retrieves the duration of a media file or URL using ffprobe.
+    Returns duration in seconds, or None if it cannot be determined.
+    Accepts input_file as a string to correctly handle URLs.
+    """
+    if not shutil.which("ffprobe"):
+        print("Warning: ffprobe not found in PATH. Cannot determine media duration.")
+        return None
+    try:
+        output = subprocess.check_output(
+            [
+                "ffprobe",
+                "-v",
+                "error",
+                "-show_entries",
+                "format=duration",
+                "-of",
+                "default=noprint_wrappers=1:nokey=1",
+                "-i",
+                input_file,
+            ],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+        return float(output)
+    except (subprocess.CalledProcessError, ValueError, FileNotFoundError):
+        print(f"Warning: Could not determine duration for '{input_file}'.")
+        return None
+
+
+def check_shell_needed_for_command(command: List[str]) -> bool:
+    """
+    Checks if any part of the command contains shell operators,
+    indicating that shell=True might be needed for subprocess.Popen.
+    This is a basic check and might not cover all edge cases.
+    """
+    shell_operators = {"|", ">", "<", ">>", "&&", "||"}  # Basic set
+    return any(op in item for item in command for op in shell_operators)
+
+
+def parse_ffmpeg_progress_line(
+    line: bytes, total_duration_secs: Optional[float]
+) -> Optional[float]:
+    """
+    Parses a progress line from FFmpeg's stdout.
+    Example line: b"out_time_us=12345678"
+    Returns the current progress time in seconds, or None if parsing fails or line is not a progress line.
+    Caps progress at total_duration_secs if provided.
+    Assumes `line` has already been stripped of leading/trailing whitespace.
+    """
+    if line.startswith(_OUT_TIME_US_PREFIX):
+        try:
+            # Get the value after out_time_us=
+            value_str = line[len(_OUT_TIME_US_PREFIX) :]
+
+            if not value_str:
+                return None
+
+            current_time_us = int(value_str)
+            current_time_secs = current_time_us * _MULTIPLIER
+
+            if total_duration_secs is not None:
+                return min(current_time_secs, total_duration_secs)
+            return current_time_secs
+        except (ValueError, IndexError):
+            return None
+
+    return None

{better_ffmpeg_progress-3.2.5 → better_ffmpeg_progress-4.0.0}/better_ffmpeg_progress.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: better-ffmpeg-progress
-Version: 3.2.5
+Version: 4.0.0
 Summary: Run FFmpeg & see percentage progress + ETA.
 Home-page: https://github.com/CrypticSignal/better-ffmpeg-progress
 Author: GitHub.com/CrypticSignal
@@ -53,13 +53,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 +95,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.5 → better_ffmpeg_progress-4.0.0}/better_ffmpeg_progress.egg-info/SOURCES.txt

@@ -3,6 +3,10 @@ README.md
 setup.py
 better_ffmpeg_progress/__init__.py
 better_ffmpeg_progress/better_ffmpeg_progress.py
+better_ffmpeg_progress/enums.py
+better_ffmpeg_progress/exceptions.py
+better_ffmpeg_progress/progress_bars.py
+better_ffmpeg_progress/terminate_process.py
 better_ffmpeg_progress/utils.py
 better_ffmpeg_progress.egg-info/PKG-INFO
 better_ffmpeg_progress.egg-info/SOURCES.txt

{better_ffmpeg_progress-3.2.5 → better_ffmpeg_progress-4.0.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as f:
 
 setuptools.setup(
     name="better-ffmpeg-progress",
-    version="3.2.5",
+    version="4.0.0",
     author="GitHub.com/CrypticSignal",
     author_email="theaudiophile@outlook.com",
     description="Run FFmpeg & see percentage progress + ETA.",

better_ffmpeg_progress-3.2.5/better_ffmpeg_progress/__init__.py

@@ -1 +0,0 @@
-from .better_ffmpeg_progress import FfmpegProcess

better_ffmpeg_progress-3.2.5/better_ffmpeg_progress/better_ffmpeg_progress.py

@@ -1,351 +0,0 @@
-from enum import Enum
-import os
-from pathlib import Path
-import psutil
-import shutil
-import subprocess
-from typing import List, Optional, Union
-
-from rich.progress import (
-    Progress,
-    TextColumn,
-    BarColumn,
-    TaskProgressColumn,
-    TimeRemainingColumn,
-    TimeElapsedColumn,
-)
-from tqdm import tqdm
-
-OUT_TIME_PREFIX = b"out_time_"
-# Convert microseconds to seconds
-MULTIPLIER = 1e-6
-
-
-class FfmpegLogLevel(Enum):
-    QUIET = "quiet"
-    PANIC = "panic"
-    FATAL = "fatal"
-    ERROR = "error"
-    WARNING = "warning"
-    INFO = "info"
-    VERBOSE = "verbose"
-    DEBUG = "debug"
-    TRACE = "trace"
-
-
-class FfmpegProcess:
-    @staticmethod
-    def _validate_command(command: List[str]) -> bool:
-        if not shutil.which("ffmpeg"):
-            print("Error: FFmpeg executable not found in PATH")
-            return False
-
-        if "-i" not in command:
-            print("Error: FFmpeg command must include '-i'")
-            return False
-
-        input_idx = command.index("-i") + 1
-        if input_idx >= len(command):
-            print("Error: No input file specified after -i")
-            return False
-
-        input_file = Path(command[input_idx])
-        if not input_file.exists():
-            print(f"Error: Input file not found: {input_file}")
-            return False
-
-        if input_idx + 1 >= len(command):
-            print("Error: No output file specified")
-            return False
-
-        return True
-
-    def _should_overwrite(self):
-        if self._output_filepath.exists() and "-y" not in self._ffmpeg_command:
-            try:
-                if (
-                    input(
-                        f"{self._output_filepath} already exists. Overwrite? [Y/N]: "
-                    ).lower()
-                    != "y"
-                ):
-                    print(
-                        "FFmpeg process cancelled. Output file exists and overwrite declined."
-                    )
-                    return False
-            except EOFError:
-                print("Input error. FFmpeg process cancelled.")
-                return False
-            except KeyboardInterrupt:
-                print("[KeyboardInterrupt] FFmpeg process cancelled.")
-                return False
-
-            self._ffmpeg_command.insert(1, "-y")
-            return True
-
-    @staticmethod
-    def _get_duration(filepath: Path) -> Optional[float]:
-        try:
-            output = subprocess.check_output(
-                [
-                    "ffprobe",
-                    "-v",
-                    "error",
-                    "-show_entries",
-                    "format=duration",
-                    "-of",
-                    "default=noprint_wrappers=1:nokey=1",
-                    "-i",
-                    str(filepath),
-                ],
-                text=True,
-            )
-            return float(output)
-        except (subprocess.CalledProcessError, ValueError, FileNotFoundError):
-            return None
-
-    @staticmethod
-    def _check_shell_needed(command):
-        shell_operators = {"|", ">", "<", ">>", "&&", "||"}
-        return any(op in item for item in command for op in shell_operators)
-
-    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,
-        print_stderr_new_line: bool = False,
-    ):
-        if not self._validate_command(command):
-            self._return_code = 1
-            return
-
-        if ffmpeg_log_level and ffmpeg_log_level not in FfmpegLogLevel:
-            print(
-                f"ffmpeg_log_level must be a lowercase variant of: {list(FfmpegLogLevel.__members__)}"
-            )
-            self._return_code = 1
-            return
-
-        input_idx = command.index("-i") + 1
-        self._input_filepath = Path(command[input_idx])
-        self._output_filepath = Path(command[-1])
-        self._ffmpeg_log_level = (
-            ffmpeg_log_level if ffmpeg_log_level else FfmpegLogLevel.VERBOSE.value
-        )
-        self._ffmpeg_log_file = Path(
-            ffmpeg_log_file or f"{self._input_filepath.name}_log.txt"
-        )
-        self._print_detected_duration = print_detected_duration
-        self._print_stderr_new_line = print_stderr_new_line
-        self._duration_secs = self._get_duration(self._input_filepath)
-
-        if self._print_detected_duration and self._duration_secs is not None:
-            print(f"Detected duration: {self._duration_secs} seconds")
-
-        self._ffmpeg_command = [
-            command[0],
-            "-hide_banner",
-            "-loglevel",
-            self._ffmpeg_log_level,
-            "-progress",
-            "pipe:1",
-            "-nostats",
-        ]
-        self._ffmpeg_command.extend(command[1:])
-
-        if not self._should_overwrite():
-            self._return_code = 1
-            return
-
-    def _use_rich(self, process) -> int:
-        task_id = None
-
-        with Progress(
-            TextColumn("[progress.description]{task.description}"),
-            BarColumn(),
-            TaskProgressColumn(),
-            TimeElapsedColumn(),
-            TimeRemainingColumn(compact=True),
-            refresh_per_second=2,
-        ) as progress_bar:
-            if self._duration_secs:
-                task_id = progress_bar.add_task(
-                    f"Processing {self._input_filepath.name}",
-                    total=self._duration_secs,
-                )
-
-                update_progress = progress_bar.update
-                duration = self._duration_secs
-
-                for line in process.stdout:
-                    if line[:9] == OUT_TIME_PREFIX:
-                        value = line[12:-1]
-                        # Check if the first byte is a digit
-                        try:
-                            if 48 <= value[0] <= 57:
-                                value_int = int(value) * MULTIPLIER
-                                if value_int <= duration:
-                                    update_progress(task_id, completed=value_int)
-                        except (IndexError, ValueError):
-                            pass
-
-            process.wait()
-
-            if process.returncode == 0 and task_id is not None:
-                update_progress(task_id, completed=duration)
-                progress_bar.columns = (
-                    TextColumn("[progress.description]{task.description}"),
-                    BarColumn(),
-                    TaskProgressColumn(),
-                )
-                update_progress(
-                    task_id,
-                    description=f"✓ Processed {self._input_filepath.name}",
-                )
-
-            if process.returncode != 0:
-                if task_id is not None:
-                    progress_bar.update(
-                        task_id,
-                        description=f"FFmpeg process failed. Check out {self._ffmpeg_log_file} for details.",
-                    )
-                return 1
-
-            return 0
-
-    def _use_tqdm(self, process) -> int:
-        progress_bar = None
-
-        try:
-            width = os.get_terminal_size().columns
-        except OSError:
-            width = 80
-
-        if self._duration_secs:
-            progress_bar = tqdm(
-                mininterval=0.5,
-                total=self._duration_secs,
-                desc=f"Processing {self._input_filepath.name}",
-                ncols=80,
-                dynamic_ncols=True if width < 80 else False,
-                bar_format="{desc} {bar} {percentage:.1f}% {elapsed} {remaining}",
-            )
-
-            duration = self._duration_secs
-
-            for line in process.stdout:
-                if line[:9] == OUT_TIME_PREFIX:
-                    value = line[12:-1]
-                    try:
-                        # Check if the first byte is a digit
-                        if 48 <= value[0] <= 57:
-                            value_int = int(value) * MULTIPLIER
-                            if value_int <= duration:
-                                progress_bar.n = value_int
-                                progress_bar.refresh()
-                    except (IndexError, ValueError):
-                        pass
-
-        process.wait()
-
-        if process.returncode == 0 and progress_bar is not None:
-            progress_bar.n = duration
-            progress_bar.set_description(f"✓ Processed {self._input_filepath.name}")
-            progress_bar.close()
-
-        if process.returncode != 0:
-            print(
-                f"FFmpeg process failed. Check out {self._ffmpeg_log_file} for details."
-            )
-            return 1
-
-        return 0
-
-    def run(
-        self,
-        print_command: bool = False,
-        use_tqdm: bool = False,
-    ) -> int:
-        if hasattr(self, "_return_code") and self._return_code != 0:
-            return 1
-
-        if print_command:
-            print(f"Executing: {' '.join(self._ffmpeg_command)}")
-
-        self._shell_needed = self._check_shell_needed(self._ffmpeg_command)
-
-        if self._shell_needed:
-            self._ffmpeg_command = " ".join(self._ffmpeg_command)
-
-        try:
-            with open(self._ffmpeg_log_file, "w") as f:
-                self._process = subprocess.Popen(
-                    self._ffmpeg_command,
-                    shell=self._shell_needed,
-                    stdout=subprocess.PIPE,
-                    stderr=f,
-                    creationflags=subprocess.CREATE_NEW_PROCESS_GROUP
-                    if os.name == "nt"
-                    else 0,
-                )
-        except Exception as e:
-            print(f"Error starting FFmpeg process: {e}")
-            return 1
-
-        try:
-            return (
-                self._use_tqdm(self._process)
-                if use_tqdm
-                else self._use_rich(self._process)
-            )
-        except KeyboardInterrupt:
-            print("\n[KeyboardInterrupt] Terminating FFmpeg process...")
-            self._terminate()
-            print("Done!")
-            return 1
-        finally:
-            if self._process and self._process.poll() is None:
-                self._terminate()
-
-    def _terminate(self):
-        if not self._process or self._process.poll() is not None:
-            return
-
-        try:
-            proc = psutil.Process(self._process.pid)
-            children = proc.children(recursive=True)
-
-            # Windows. Use CTRL_BREAK_EVENT to terminate entire process group
-            if os.name == "nt":
-                if self._shell_needed:
-                    # If running under a shell, terminate shell first
-                    proc.terminate()
-                else:
-                    from signal import CTRL_BREAK_EVENT
-
-                    # Send CTRL_BREAK_EVENT to entire process group
-                    os.kill(self._process.pid, CTRL_BREAK_EVENT)
-            # Unix
-            else:
-                for child in children:
-                    try:
-                        child.terminate()
-                    except psutil.NoSuchProcess:
-                        pass
-                proc.terminate()
-
-            # Wait up to 1 second for processes to exit gracefully
-            gone, still_alive = psutil.wait_procs(children + [proc], timeout=1)
-
-            # Force kill any remaining processes
-            for p in still_alive:
-                try:
-                    p.kill()
-                except psutil.NoSuchProcess:
-                    pass
-
-        except (psutil.NoSuchProcess, ProcessLookupError, KeyboardInterrupt):
-            # As a last resort, force kill the main process
-            self._process.kill()

better_ffmpeg_progress-3.2.5/better_ffmpeg_progress/utils.py

@@ -1,10 +0,0 @@
-import os
-
-
-def line():
-    width, _ = os.get_terminal_size()
-    print("-" * width)
-
-
-def print_with_prefix(prefix, message):
-    print(f"{prefix}{message}")