better-ffmpeg-progress 5.1.0__tar.gz → 5.2.0__tar.gz

better_ffmpeg_progress-5.2.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.1
+Name: better-ffmpeg-progress
+Version: 5.2.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">
+[![PyPI downloads](https://img.shields.io/pypi/dm/better-ffmpeg-progress?label=PyPI\&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
+[![PyPI downloads](https://img.shields.io/pypi/dd/better-ffmpeg-progress?label=PyPI\&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
+![PyPI - Version](https://img.shields.io/pypi/v/better-ffmpeg-progress)
+[![GitHub](https://img.shields.io/github/license/crypticsignal/better-ffmpeg-progress?label=License\&color=blue)](LICENSE.txt)
+
+# 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 ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
+```
+Where:
+- `Processing abc.webm` is the description of the progresss bar.
+- `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}"
+    )
+```
+
+## 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.2.0/README.md

@@ -0,0 +1,108 @@
+<div align="center">
+[![PyPI downloads](https://img.shields.io/pypi/dm/better-ffmpeg-progress?label=PyPI\&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
+[![PyPI downloads](https://img.shields.io/pypi/dd/better-ffmpeg-progress?label=PyPI\&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
+![PyPI - Version](https://img.shields.io/pypi/v/better-ffmpeg-progress)
+[![GitHub](https://img.shields.io/github/license/crypticsignal/better-ffmpeg-progress?label=License\&color=blue)](LICENSE.txt)
+
+# 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 ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
+```
+Where:
+- `Processing abc.webm` is the description of the progresss bar.
+- `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}"
+    )
+```
+
+## 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.0 → better_ffmpeg_progress-5.2.0}/better_ffmpeg_progress/better_ffmpeg_progress.py

@@ -1,3 +1,4 @@
+import math
 import os
 from pathlib import Path
 import subprocess
@@ -27,18 +28,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 +58,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 +90,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 +118,30 @@ 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)
+
+        if duration_override is not None:
+            print(f"Using duration override: {self._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: {self._duration_secs:.2f} seconds")
 
         self._ffmpeg_command = [
             command[0],
@@ -114,14 +149,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 +191,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,
@@ -177,26 +214,19 @@ class FfmpegProcess:
         except Exception as e:
             raise FfmpegProcessError(f"Error starting FFmpeg process: {e}") from e
 
-        user_interrupted = False
         try:
             if self.use_tqdm:
                 use_tqdm(self, self._process)
             else:
                 use_rich(self, self._process)
         except KeyboardInterrupt:
-            user_interrupted = True
             self._terminate()
         finally:
-            if self._process:
-                if self._process.stdout:
-                    self._process.stdout.close()
-
-        if not user_interrupted and self._process and self._process.returncode != 0:
-            raise FfmpegProcessError(f"FFmpeg process failed. Return code: {self._process.returncode}")
+            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.0 → better_ffmpeg_progress-5.2.0}/better_ffmpeg_progress/progress_bars.py

@@ -19,9 +19,7 @@ if TYPE_CHECKING:
     from .better_ffmpeg_progress import FfmpegProcess
 
 
-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}"),
@@ -39,16 +37,14 @@ def use_rich(
     with progress_bar_instance as progress_bar:
         if duration_secs:
             task_id = progress_bar.add_task(
-                f"Processing '{input_filename}'",
+                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
-                )
+                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:
@@ -75,9 +71,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
@@ -100,9 +94,7 @@ 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
-            )
+            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()

{better_ffmpeg_progress-5.1.0 → better_ffmpeg_progress-5.2.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.")

{better_ffmpeg_progress-5.1.0 → better_ffmpeg_progress-5.2.0}/better_ffmpeg_progress/utils.py

@@ -42,16 +42,10 @@ def validate_ffmpeg_command(command: List[str]) -> None:
 
     input_file_idx = input_flag_pos + 1
     if input_file_idx >= len(command):
-        raise FfmpegCommandError(
-            f"No input file specified after '{_FFMPEG_INPUT_FLAG}'."
-        )
+        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()
-    ):
+    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."
         )
@@ -62,9 +56,7 @@ def validate_ffmpeg_command(command: List[str]) -> None:
             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}"
-            )
+            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}")
 

better_ffmpeg_progress-5.2.0/better_ffmpeg_progress.egg-info/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.1
+Name: better-ffmpeg-progress
+Version: 5.2.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">
+[![PyPI downloads](https://img.shields.io/pypi/dm/better-ffmpeg-progress?label=PyPI\&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
+[![PyPI downloads](https://img.shields.io/pypi/dd/better-ffmpeg-progress?label=PyPI\&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
+![PyPI - Version](https://img.shields.io/pypi/v/better-ffmpeg-progress)
+[![GitHub](https://img.shields.io/github/license/crypticsignal/better-ffmpeg-progress?label=License\&color=blue)](LICENSE.txt)
+
+# 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 ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
+```
+Where:
+- `Processing abc.webm` is the description of the progresss bar.
+- `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}"
+    )
+```
+
+## 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.0 → better_ffmpeg_progress-5.2.0}/setup.py

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

better_ffmpeg_progress-5.1.0/PKG-INFO

@@ -1,94 +0,0 @@
-Metadata-Version: 2.1
-Name: better-ffmpeg-progress
-Version: 5.1.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">
-
-[![PyPI downloads](https://img.shields.io/pypi/dm/better-ffmpeg-progress?label=PyPI&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
-[![PyPI downloads](https://img.shields.io/pypi/dd/better-ffmpeg-progress?label=PyPI&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
-![PyPI - Version](https://img.shields.io/pypi/v/better-ffmpeg-progress)
-[![GitHub](https://img.shields.io/github/license/crypticsignal/better-ffmpeg-progress?label=License&color=blue)](LICENSE.txt)
-
-# Better FFmpeg Progress
-Runs an FFmpeg command and shows a progress bar with percentage progress, time elapsed and ETA.
-
-The [Rich](https://github.com/Textualize/rich) library is used for the progress bar by default, [tqdm](https://github.com/tqdm/tqdm) will be used if you pass `use_tqdm=True` to the `run` method.
-</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 ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
-```
-Where:
-- `Processing abc.webm` is the description of the progresss bar.
-- `23%` is the percentage progress.
-- `0:00:04` is the time elapsed.
-- `00:15` is the estimated time until the FFmpeg process completes.
-
-As you can see, the output of Better FFmpeg Progress is much more useful.
-
-## Installation
-```
-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()`.
-
-Example:
-```py
-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 the line below if you want to use tqdm instead of rich for the progress bar
-    # process.use_tqdm = True
-
-    process.run()
-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:
-
-- `ffmpeg_log_level` - Desired FFmpeg log level. Default: `"verbose"`
-- `ffmpeg_log_file` - The filepath to save the FFmpeg log to. Default: `<input filename>_log.txt`
-- `print_detected_duration` - Print the detected duration of the input file. Default: `False`
-- `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`

better_ffmpeg_progress-5.1.0/README.md

@@ -1,75 +0,0 @@
-<div align="center">
-
-[![PyPI downloads](https://img.shields.io/pypi/dm/better-ffmpeg-progress?label=PyPI&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
-[![PyPI downloads](https://img.shields.io/pypi/dd/better-ffmpeg-progress?label=PyPI&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
-![PyPI - Version](https://img.shields.io/pypi/v/better-ffmpeg-progress)
-[![GitHub](https://img.shields.io/github/license/crypticsignal/better-ffmpeg-progress?label=License&color=blue)](LICENSE.txt)
-
-# Better FFmpeg Progress
-Runs an FFmpeg command and shows a progress bar with percentage progress, time elapsed and ETA.
-
-The [Rich](https://github.com/Textualize/rich) library is used for the progress bar by default, [tqdm](https://github.com/tqdm/tqdm) will be used if you pass `use_tqdm=True` to the `run` method.
-</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 ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
-```
-Where:
-- `Processing abc.webm` is the description of the progresss bar.
-- `23%` is the percentage progress.
-- `0:00:04` is the time elapsed.
-- `00:15` is the estimated time until the FFmpeg process completes.
-
-As you can see, the output of Better FFmpeg Progress is much more useful.
-
-## Installation
-```
-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()`.
-
-Example:
-```py
-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 the line below if you want to use tqdm instead of rich for the progress bar
-    # process.use_tqdm = True
-
-    process.run()
-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:
-
-- `ffmpeg_log_level` - Desired FFmpeg log level. Default: `"verbose"`
-- `ffmpeg_log_file` - The filepath to save the FFmpeg log to. Default: `<input filename>_log.txt`
-- `print_detected_duration` - Print the detected duration of the input file. Default: `False`
-- `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`

better_ffmpeg_progress-5.1.0/better_ffmpeg_progress.egg-info/PKG-INFO

@@ -1,94 +0,0 @@
-Metadata-Version: 2.1
-Name: better-ffmpeg-progress
-Version: 5.1.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">
-
-[![PyPI downloads](https://img.shields.io/pypi/dm/better-ffmpeg-progress?label=PyPI&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
-[![PyPI downloads](https://img.shields.io/pypi/dd/better-ffmpeg-progress?label=PyPI&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
-![PyPI - Version](https://img.shields.io/pypi/v/better-ffmpeg-progress)
-[![GitHub](https://img.shields.io/github/license/crypticsignal/better-ffmpeg-progress?label=License&color=blue)](LICENSE.txt)
-
-# Better FFmpeg Progress
-Runs an FFmpeg command and shows a progress bar with percentage progress, time elapsed and ETA.
-
-The [Rich](https://github.com/Textualize/rich) library is used for the progress bar by default, [tqdm](https://github.com/tqdm/tqdm) will be used if you pass `use_tqdm=True` to the `run` method.
-</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 ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
-```
-Where:
-- `Processing abc.webm` is the description of the progresss bar.
-- `23%` is the percentage progress.
-- `0:00:04` is the time elapsed.
-- `00:15` is the estimated time until the FFmpeg process completes.
-
-As you can see, the output of Better FFmpeg Progress is much more useful.
-
-## Installation
-```
-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()`.
-
-Example:
-```py
-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 the line below if you want to use tqdm instead of rich for the progress bar
-    # process.use_tqdm = True
-
-    process.run()
-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:
-
-- `ffmpeg_log_level` - Desired FFmpeg log level. Default: `"verbose"`
-- `ffmpeg_log_file` - The filepath to save the FFmpeg log to. Default: `<input filename>_log.txt`
-- `print_detected_duration` - Print the detected duration of the input file. Default: `False`
-- `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`