better-ffmpeg-progress 5.1.1__tar.gz → 5.3.0__tar.gz

better_ffmpeg_progress-5.3.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.1
+Name: better-ffmpeg-progress
+Version: 5.3.0
+Summary: Run FFmpeg & see percentage progress + ETA.
+Home-page: https://github.com/CrypticSignal/better-ffmpeg-progress
+Author: GitHub.com/CrypticSignal
+Author-email: theaudiophile@outlook.com
+Keywords: ffmpeg,progress
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil
+Requires-Dist: requests
+Requires-Dist: rich
+Requires-Dist: tqdm
+
+<div align="center">
+
+# Better FFmpeg Progress
+Runs an FFmpeg command and shows a progress bar with percentage progress, elapsed time and ETA.
+</div>
+
+FFmpeg outputs something like:
+```
+frame=  692 fps= 58 q=28.0 size=    5376KiB time=00:00:28.77 bitrate=1530.3kbits/s speed=2.43x
+```
+Better FFmpeg Progress outputs something like:
+```
+⠏ Processing abc.webm (5.50 MB / ~23.91 MB) ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
+```
+Where:
+- `Processing abc.webm` is the description of the progresss bar. Filenames longer than 60 characters are truncated.
+- `(5.50 MB / ~23.91 MB)` is the current output size and the estimated final output size.
+- `23%` is the percentage progress.
+- `0:00:04` is the time elapsed.
+- `00:15` is the estimated time until the FFmpeg process completes.
+
+## Installation
+```bash
+pip install better-ffmpeg-progress --upgrade
+```
+
+## Usage
+Create an instance of the `FfmpegProcess` class and supply a list of arguments like you would when using `subprocess.run()` or `subprocess.Popen()`. Example:
+
+```python
+from better_ffmpeg_progress import FfmpegProcess, FfmpegProcessError
+
+command = [
+    "ffmpeg",
+    "-i",
+    "https://media.xiph.org/video/derf/y4m/ducks_take_off_1080p50.y4m",
+    "-map",
+    "0:V",
+    "-c:V",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-f",
+    "null",
+    "-",
+]
+
+try:
+    process = FfmpegProcess(command)
+    # Uncomment this line to use tqdm instead of Rich.
+    # process.use_tqdm = True
+
+    process.run()
+except FfmpegProcessError as e:
+    print(
+        "An error occurred when running Better FFmpeg Progress:\n"
+        f"{e}"
+    )
+```
+
+## Trimming
+If your command trims the input with `-ss`, `-sseof`, `-t` or `-to` (as input or output options), the expected duration of the output is calculated automatically, so the progress bar and ETA reflect the trimmed output rather than the whole input file. This adjustment is skipped when `-copyts` is used.
+
+## Duration Override
+By default, Better FFmpeg Progress detects the duration of the input file and uses it to calculate percentage progress and ETA.
+
+For partial, damaged, streamed or synthetic inputs, FFmpeg may be unable to detect the duration correctly. In these cases, you can provide the duration manually using `duration_override`.
+
+The value should be the duration of the input file, in seconds:
+
+```python
+from better_ffmpeg_progress import FfmpegProcess
+
+command = [
+    "ffmpeg",
+    "-i",
+    "partial-input.flv",
+    "-c",
+    "copy",
+    "recovered-output.mkv",
+]
+
+process = FfmpegProcess(
+    command,
+    duration_override=1222.64,
+    print_detected_duration=True,
+)
+
+process.run()
+```
+
+## Optional Arguments
+An instance of `FfmpegProcess` accepts the following optional arguments:
+* `ffmpeg_log_level` — Set a value for FFmpeg's `-loglevel` option. Default: `"verbose"`.
+* `ffmpeg_log_file` — Filepath or file-like object to which FFmpeg stderr will be written. Default: `<input filename>_ffmpeg_log.txt`.
+* `print_detected_duration` — Print the detected duration. Default: `False`.
+* `duration_override` — Specify input file duration in seconds to use for progress calculation, instead of trying to detect this automatically with FFprobe. Default: `None`.
+
+The `run` method accepts the following optional argument:
+* `print_command` — Print the FFmpeg command being executed. Default: `False`.
+
+## Using tqdm
+By default, the [Rich](https://github.com/Textualize/rich) library is used to display a progress bar. [tqdm](https://github.com/tqdm/tqdm) can be used instead by setting `process.use_tqdm = True`:
+```python
+process = FfmpegProcess(command)
+process.use_tqdm = True
+process.run()
+```

better_ffmpeg_progress-5.3.0/README.md

@@ -0,0 +1,108 @@
+<div align="center">
+
+# Better FFmpeg Progress
+Runs an FFmpeg command and shows a progress bar with percentage progress, elapsed time and ETA.
+</div>
+
+FFmpeg outputs something like:
+```
+frame=  692 fps= 58 q=28.0 size=    5376KiB time=00:00:28.77 bitrate=1530.3kbits/s speed=2.43x
+```
+Better FFmpeg Progress outputs something like:
+```
+⠏ Processing abc.webm (5.50 MB / ~23.91 MB) ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
+```
+Where:
+- `Processing abc.webm` is the description of the progresss bar. Filenames longer than 60 characters are truncated.
+- `(5.50 MB / ~23.91 MB)` is the current output size and the estimated final output size.
+- `23%` is the percentage progress.
+- `0:00:04` is the time elapsed.
+- `00:15` is the estimated time until the FFmpeg process completes.
+
+## Installation
+```bash
+pip install better-ffmpeg-progress --upgrade
+```
+
+## Usage
+Create an instance of the `FfmpegProcess` class and supply a list of arguments like you would when using `subprocess.run()` or `subprocess.Popen()`. Example:
+
+```python
+from better_ffmpeg_progress import FfmpegProcess, FfmpegProcessError
+
+command = [
+    "ffmpeg",
+    "-i",
+    "https://media.xiph.org/video/derf/y4m/ducks_take_off_1080p50.y4m",
+    "-map",
+    "0:V",
+    "-c:V",
+    "libx264",
+    "-preset",
+    "ultrafast",
+    "-f",
+    "null",
+    "-",
+]
+
+try:
+    process = FfmpegProcess(command)
+    # Uncomment this line to use tqdm instead of Rich.
+    # process.use_tqdm = True
+
+    process.run()
+except FfmpegProcessError as e:
+    print(
+        "An error occurred when running Better FFmpeg Progress:\n"
+        f"{e}"
+    )
+```
+
+## Trimming
+If your command trims the input with `-ss`, `-sseof`, `-t` or `-to` (as input or output options), the expected duration of the output is calculated automatically, so the progress bar and ETA reflect the trimmed output rather than the whole input file. This adjustment is skipped when `-copyts` is used.
+
+## Duration Override
+By default, Better FFmpeg Progress detects the duration of the input file and uses it to calculate percentage progress and ETA.
+
+For partial, damaged, streamed or synthetic inputs, FFmpeg may be unable to detect the duration correctly. In these cases, you can provide the duration manually using `duration_override`.
+
+The value should be the duration of the input file, in seconds:
+
+```python
+from better_ffmpeg_progress import FfmpegProcess
+
+command = [
+    "ffmpeg",
+    "-i",
+    "partial-input.flv",
+    "-c",
+    "copy",
+    "recovered-output.mkv",
+]
+
+process = FfmpegProcess(
+    command,
+    duration_override=1222.64,
+    print_detected_duration=True,
+)
+
+process.run()
+```
+
+## Optional Arguments
+An instance of `FfmpegProcess` accepts the following optional arguments:
+* `ffmpeg_log_level` — Set a value for FFmpeg's `-loglevel` option. Default: `"verbose"`.
+* `ffmpeg_log_file` — Filepath or file-like object to which FFmpeg stderr will be written. Default: `<input filename>_ffmpeg_log.txt`.
+* `print_detected_duration` — Print the detected duration. Default: `False`.
+* `duration_override` — Specify input file duration in seconds to use for progress calculation, instead of trying to detect this automatically with FFprobe. Default: `None`.
+
+The `run` method accepts the following optional argument:
+* `print_command` — Print the FFmpeg command being executed. Default: `False`.
+
+## Using tqdm
+By default, the [Rich](https://github.com/Textualize/rich) library is used to display a progress bar. [tqdm](https://github.com/tqdm/tqdm) can be used instead by setting `process.use_tqdm = True`:
+```python
+process = FfmpegProcess(command)
+process.use_tqdm = True
+process.run()
+```

{better_ffmpeg_progress-5.1.1 → better_ffmpeg_progress-5.3.0}/better_ffmpeg_progress/better_ffmpeg_progress.py

@@ -1,3 +1,4 @@
+import math
 import os
 from pathlib import Path
 import subprocess
@@ -14,6 +15,7 @@ from .exceptions import (
 from .utils import (
     validate_ffmpeg_command,
     get_media_duration,
+    get_expected_output_duration,
     check_shell_needed_for_command,
 )
 from .terminate_process import terminate_ffmpeg_process
@@ -27,18 +29,16 @@ class FfmpegProcess:
         """
         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.
+        Raises FfmpegProcessUserCancelledError or
+        FfmpegProcessInterruptedError if not proceeding.
         """
         try:
             answer = (
-                input(
-                    f"Output file {self._output_filepath} already exists. Overwrite? [y/N]: "
-                )
+                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(
@@ -59,8 +59,24 @@ class FfmpegProcess:
         ffmpeg_log_level: Optional[Union[FfmpegLogLevel, str]] = None,
         ffmpeg_log_file: Optional[Union[str, os.PathLike]] = None,
         print_detected_duration: bool = False,
+        duration_override: Optional[float] = None,
     ):
-        # Raises FfmpegCommandError if the command is invalid
+        """
+        Create an FFmpeg process with progress reporting.
+
+        Args:
+            command:
+                FFmpeg command as a list of arguments.
+            ffmpeg_log_level:
+                FFmpeg log level enum or case-insensitive string.
+            ffmpeg_log_file:
+                File path or file-like object used for FFmpeg stderr.
+            print_detected_duration:
+                Print the duration used for progress calculation.
+            duration_override:
+                Specify input file duration in seconds to use for progress calculation, instead of trying to detect this automatically with FFprobe. This is useful for partial, damaged, streamed, or
+                synthetic inputs whose duration cannot be detected correctly.
+        """
         validate_ffmpeg_command(command)
 
         ffmpeg_log_level_val: str
@@ -75,20 +91,24 @@ class FfmpegProcess:
             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)."
+                    f"Invalid ffmpeg_log_level string: "
+                    f"'{ffmpeg_log_level}'. Must be one of "
+                    f"{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__}"
+                "ffmpeg_log_level must be an FfmpegLogLevel enum instance, "
+                f"a string, or None, not "
+                f"{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
+
+        # Assumes last argument is output.
         self._output_filepath = Path(command[-1])
 
         if ffmpeg_log_file is None:
@@ -99,14 +119,44 @@ class FfmpegProcess:
             self._ffmpeg_log_file = ffmpeg_log_file
 
         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."
-            )
+        if duration_override is not None:
+            if isinstance(duration_override, bool):
+                raise TypeError("duration_override must be a number of seconds, not bool")
+
+            try:
+                duration_value = float(duration_override)
+            except (TypeError, ValueError) as e:
+                raise TypeError("duration_override must be a number of seconds or None") from e
+
+            if not math.isfinite(duration_value) or duration_value <= 0:
+                raise ValueError("duration_override must be a finite number greater than 0")
+
+            self._duration_secs = duration_value
+        else:
+            self._duration_secs = get_media_duration(input_file_path_str)
+
+        input_duration_secs = self._duration_secs
+
+        # Account for trimming (-ss, -sseof, -t, -to) so the progress bar reflects the
+        # duration of the output rather than the whole input.
+        if self._duration_secs is not None:
+            self._duration_secs = get_expected_output_duration(command, self._duration_secs)
+
+        if duration_override is not None:
+            print(f"Using duration override: {input_duration_secs:.2f} seconds")
+        elif self._print_detected_duration:
+            if self._duration_secs is None:
+                print("Could not detect duration. Progress bar may not show time remaining.")
+            else:
+                print(f"Detected duration: {input_duration_secs:.2f} seconds")
+
+        if (
+            self._duration_secs is not None
+            and self._duration_secs != input_duration_secs
+            and (duration_override is not None or self._print_detected_duration)
+        ):
+            print(f"Expected output duration after trimming: {self._duration_secs:.2f} seconds")
 
         self._ffmpeg_command = [
             command[0],
@@ -114,14 +164,12 @@ class FfmpegProcess:
             "-loglevel",
             self._ffmpeg_log_level_val,
             "-progress",
-            "pipe:1",  # stdout
+            "pipe:1",
             "-nostats",
         ]
         self._ffmpeg_command.extend(command[1:])
 
-        is_overwrite_in_user_command = any(
-            arg == _FFMPEG_OVERWRITE_FLAG for arg in 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()
@@ -158,7 +206,11 @@ class FfmpegProcess:
                 creationflags = subprocess.CREATE_NEW_PROCESS_GROUP
 
             if isinstance(self._ffmpeg_log_file, Path):
-                with open(self._ffmpeg_log_file, "w", encoding="utf-8") as f:
+                with open(
+                    self._ffmpeg_log_file,
+                    "w",
+                    encoding="utf-8",
+                ) as f:
                     self._process = subprocess.Popen(
                         current_ffmpeg_command,
                         shell=self._shell_needed,
@@ -185,13 +237,11 @@ class FfmpegProcess:
         except KeyboardInterrupt:
             self._terminate()
         finally:
-            if self._process:
-                if self._process.stdout:
-                    self._process.stdout.close()
+            if self._process and self._process.stdout:
+                self._process.stdout.close()
 
     def _terminate(self):
         if self._process:
             terminate_ffmpeg_process(self._process)
         else:
             exit()
-

{better_ffmpeg_progress-5.1.1 → better_ffmpeg_progress-5.3.0}/better_ffmpeg_progress/progress_bars.py

@@ -1,6 +1,6 @@
 import os
 import subprocess
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from rich.progress import (
     Progress,
@@ -12,16 +12,26 @@ from rich.progress import (
 )
 from tqdm import tqdm
 
-from .utils import parse_ffmpeg_progress_line
+from .utils import (
+    estimate_final_size_mb,
+    parse_ffmpeg_progress_line,
+    parse_ffmpeg_total_size_line,
+    truncate_filename,
+)
 from .exceptions import FfmpegProcessError
 
 if TYPE_CHECKING:
     from .better_ffmpeg_progress import FfmpegProcess
 
+_MAX_FILENAME_LENGTH = 60
+
+
+def _format_size(current_size_mb: float, estimated_size_mb: Optional[float]) -> str:
+    estimate = f"~{estimated_size_mb:.2f} MB" if estimated_size_mb is not None else "~? MB"
+    return f"({current_size_mb:.2f} MB / {estimate})"
+
 
-def use_rich(
-    ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
-) -> None:
+def use_rich(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen) -> None:
     task_id = None
     progress_bar_instance = Progress(
         TextColumn("[progress.description]{task.description}"),
@@ -33,11 +43,14 @@ def use_rich(
     )
 
     duration_secs = ffmpeg_process_instance._duration_secs
-    input_filename = ffmpeg_process_instance._input_filepath.name
+    input_filename = truncate_filename(
+        ffmpeg_process_instance._input_filepath.name, _MAX_FILENAME_LENGTH
+    )
     log_file = ffmpeg_process_instance._ffmpeg_log_file
 
     with progress_bar_instance as progress_bar:
         if duration_secs:
+            current_size_mb = 0.0
             task_id = progress_bar.add_task(
                 f"Processing {input_filename}",
                 total=duration_secs,
@@ -46,11 +59,25 @@ def use_rich(
 
             for line_bytes in process.stdout:
                 stripped_line_bytes = line_bytes.strip()
-                progress_val_secs = parse_ffmpeg_progress_line(
-                    stripped_line_bytes, duration_secs
-                )
+
+                size_mb = parse_ffmpeg_total_size_line(stripped_line_bytes)
+                if size_mb is not None:
+                    current_size_mb = size_mb
+                    continue
+
+                # FFmpeg writes total_size before out_time_us in each progress block,
+                # so updating here refreshes the bar once per block with the latest size.
+                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)
+                    estimated_size_mb = estimate_final_size_mb(
+                        current_size_mb, progress_val_secs, duration_secs
+                    )
+                    update_progress(
+                        task_id,
+                        completed=progress_val_secs,
+                        description=f"Processing {input_filename} "
+                        f"{_format_size(current_size_mb, estimated_size_mb)}",
+                    )
         else:
             print(f"Processing '{input_filename}'...")
 
@@ -66,7 +93,7 @@ def use_rich(
                 )
                 update_progress(
                     task_id,
-                    description=f"✓ Processed '{input_filename}'",
+                    description=f"✓ Processed '{input_filename}' ({current_size_mb:.2f} MB)",
                 )
         else:
             if task_id is not None:
@@ -75,9 +102,7 @@ def use_rich(
             raise FfmpegProcessError(f"FFmpeg process failed. Check '{log_file}' for details.")
 
 
-def use_tqdm(
-    ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
-) -> None:
+def use_tqdm(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen) -> None:
     progress_bar = None
     try:
         width = os.get_terminal_size().columns
@@ -85,9 +110,13 @@ def use_tqdm(
         width = 80
 
     duration_secs = ffmpeg_process_instance._duration_secs
-    input_filename = ffmpeg_process_instance._input_filepath.name
+    input_filename = truncate_filename(
+        ffmpeg_process_instance._input_filepath.name, _MAX_FILENAME_LENGTH
+    )
     log_file = ffmpeg_process_instance._ffmpeg_log_file
 
+    current_size_mb = 0.0
+
     if duration_secs:
         progress_bar = tqdm(
             mininterval=0.5,
@@ -100,12 +129,20 @@ def use_tqdm(
 
         for line_bytes in process.stdout:
             stripped_line_bytes = line_bytes.strip()
-            progress_val_secs = parse_ffmpeg_progress_line(
-                stripped_line_bytes, duration_secs
-            )
+
+            size_mb = parse_ffmpeg_total_size_line(stripped_line_bytes)
+            if size_mb is not None:
+                current_size_mb = size_mb
+                continue
+
+            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:
+                estimated_size_mb = estimate_final_size_mb(
+                    current_size_mb, progress_val_secs, duration_secs
+                )
                 progress_bar.n = progress_val_secs
-                progress_bar.refresh()
+                # set_postfix_str refreshes the bar by default
+                progress_bar.set_postfix_str(_format_size(current_size_mb, estimated_size_mb))
     else:
         print(f"Processing '{input_filename}'...")
 
@@ -115,6 +152,7 @@ def use_tqdm(
         if progress_bar:
             progress_bar.n = duration_secs
             progress_bar.set_description(f"✓ Processed '{input_filename}'")
+            progress_bar.set_postfix_str(f"{current_size_mb:.2f} MB")
             progress_bar.close()
         else:
             print(f"✓ Processed '{input_filename}'")

{better_ffmpeg_progress-5.1.1 → better_ffmpeg_progress-5.3.0}/better_ffmpeg_progress/terminate_process.py

@@ -32,9 +32,7 @@ def _terminate_children_processes(parent_proc: psutil.Process):
     if not children:
         return
 
-    print(
-        f"Attempting to terminate {len(children)} child process(es) of {parent_proc.pid}..."
-    )
+    print(f"Attempting to terminate {len(children)} child process(es) of {parent_proc.pid}...")
     for child in children:
         try:
             if child.is_running():
@@ -68,21 +66,15 @@ def _terminate_parent_process_windows(proc: psutil.Process):
         try:
             # Check the status after the timeout
             if proc.is_running():
-                print(
-                    f"FFmpeg process {proc.pid} still running after {_TERMINATION_TIMEOUT}s."
-                )
+                print(f"FFmpeg process {proc.pid} still running after {_TERMINATION_TIMEOUT}s.")
             else:
-                print(
-                    f"FFmpeg process termination took longer than {_TERMINATION_TIMEOUT}s."
-                )
+                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}"
-            )
+            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:
@@ -106,14 +98,10 @@ def _terminate_parent_process_unix(proc: psutil.Process, original_pid: int):
             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..."
-            )
+            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
+                proc.wait(timeout=_TERMINATION_TIMEOUT)  # Wait for SIGKILL on process group
                 if not proc.is_running():
                     terminated_by_pg = True
             except psutil.TimeoutExpired:
@@ -132,13 +120,9 @@ def _terminate_parent_process_unix(proc: psutil.Process, original_pid: int):
     # 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."
+            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
@@ -159,9 +143,7 @@ def _terminate_parent_process_unix(proc: psutil.Process, original_pid: int):
                     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}"
-                )
+                print(f"Error during SIGTERM for FFmpeg process (PID: {proc.pid}):\n{e}")
                 if not proc.is_running():
                     return
 
@@ -177,9 +159,7 @@ def _terminate_parent_process_unix(proc: psutil.Process, original_pid: int):
                     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}"
-                    )
+                    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:
@@ -239,9 +219,7 @@ def terminate_ffmpeg_process(process: Optional[subprocess.Popen]):
             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}"
-        )
+        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.")