better-ffmpeg-progress 2.6.1__tar.gz → 3.1.0__tar.gz

better_ffmpeg_progress-3.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: better-ffmpeg-progress
+Version: 3.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: ffmpeg-python
+Requires-Dist: psutil
+Requires-Dist: rich
+
+<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.
+</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 (H:MM:SS) 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()`.
+
+Here's a simple example:
+```py
+from better_ffmpeg_progress import FfmpegProcess
+
+process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:v", "libx265", "output.mp4"])
+
+# return_code will be 0 if the process was successful
+return_code = process.run()
+
+if return_code == 0:
+    # Code to run if the process was successful
+    pass
+else:
+    # Code to run if the process was unsuccessful
+    pass
+```
+## 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.
+- `print_detected_duration` - Print the detected duration of the input file. Default: `True`
+- `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** argument:
+- `print_command` - Print the FFmpeg command being executed. Default: `False`

better_ffmpeg_progress-3.1.0/README.md

@@ -0,0 +1,61 @@
+<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.
+</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 (H:MM:SS) 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()`.
+
+Here's a simple example:
+```py
+from better_ffmpeg_progress import FfmpegProcess
+
+process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:v", "libx265", "output.mp4"])
+
+# return_code will be 0 if the process was successful
+return_code = process.run()
+
+if return_code == 0:
+    # Code to run if the process was successful
+    pass
+else:
+    # Code to run if the process was unsuccessful
+    pass
+```
+## 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.
+- `print_detected_duration` - Print the detected duration of the input file. Default: `True`
+- `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** argument:
+- `print_command` - Print the FFmpeg command being executed. Default: `False`

better_ffmpeg_progress-3.1.0/better_ffmpeg_progress/better_ffmpeg_progress.py

@@ -0,0 +1,277 @@
+from enum import Enum
+import os
+from pathlib import Path
+import psutil
+from queue import Empty, Queue
+import shutil
+import subprocess
+from threading import Thread
+from typing import List, Optional, Union
+
+from ffmpeg import probe
+from rich.progress import (
+    Progress,
+    TextColumn,
+    BarColumn,
+    TaskProgressColumn,
+    TimeRemainingColumn,
+    TimeElapsedColumn,
+    SpinnerColumn,
+)
+
+
+class FfmpegLogLevel(Enum):
+    QUIET = "quiet"
+    PANIC = "panic"
+    FATAL = "fatal"
+    ERROR = "error"
+    WARNING = "warning"
+    INFO = "info"
+    VERBOSE = "verbose"
+    DEBUG = "debug"
+    TRACE = "trace"
+
+
+class FfmpegProcess:
+    TIME_MS_PREFIX = "out_time_ms="
+
+    @staticmethod
+    def _read_pipe(pipe: subprocess.PIPE, queue: Queue, stdout: bool = False) -> None:
+        """Read from pipe and put lines into queue."""
+        try:
+            with pipe:
+                for line in iter(pipe.readline, ""):
+                    line = line.strip()
+                    if line:
+                        if stdout:
+                            if line.startswith("out_time_ms="):
+                                queue.put(line)
+                        else:
+                            queue.put(line)
+        except (IOError, ValueError) as e:
+            print(f"Error reading pipe: {e}")
+        finally:
+            pipe.close()
+
+    @classmethod
+    def _validate_command(cls, 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 __init__(
+        self,
+        command: List[str],
+        ffmpeg_log_level: Optional[FfmpegLogLevel] = 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
+            if ffmpeg_log_file
+            else f"{self._input_filepath.name}_log.txt"
+        )
+        self._print_detected_duration = print_detected_duration
+        self._print_stderr_new_line = print_stderr_new_line
+
+        with open(self._ffmpeg_log_file, "w"):
+            pass
+
+        try:
+            probe_data = probe(self._input_filepath)
+            self._duration_secs = float(probe_data["format"]["duration"])
+            if self._print_detected_duration:
+                print(f"Detected duration: {self._duration_secs:.2f} seconds")
+        except Exception:
+            self._duration_secs = None
+
+        self._ffmpeg_command = [
+            command[0],
+            "-hide_banner",
+            "-loglevel",
+            self._ffmpeg_log_level,
+            "-progress",
+            "pipe:1",
+            "-stats_period",
+            "0.1",
+            "-nostats",
+            *command[1:],
+        ]
+
+        self.return_code = 0
+
+    def _process_stderr(self, stderr: str) -> None:
+        if self._duration_secs is None:
+            print(stderr, end="\n" if self._print_stderr_new_line else "\r", flush=True)
+
+        try:
+            with open(self._ffmpeg_log_file, "a", encoding="utf-8") as f:
+                f.write(f"{stderr}\n")
+        except IOError as e:
+            print(f"Error writing to log file: {e}")
+            self.return_code = 1
+
+    def run(self, print_command: bool = False) -> int:
+        if hasattr(self, "return_code") and self.return_code != 0:
+            return 1
+
+        if self._output_filepath.exists() and "-y" not in self._ffmpeg_command:
+            if (
+                input(
+                    f"{self._output_filepath} already exists. Overwrite? [Y/N]: "
+                ).lower()
+                != "y"
+            ):
+                print(
+                    "FFmpeg process cancelled. Output file exists and overwrite declined."
+                )
+                return 1
+            self._ffmpeg_command.insert(1, "-y")
+
+        if print_command:
+            print(f"Executing: {' '.join(self._ffmpeg_command)}")
+
+        def _contains_shell_operators(command: List[str]) -> bool:
+            shell_operators = {"|", ">", "<", ">>", "&&", "||"}
+            return any(op in command for op in shell_operators)
+
+        # If command contains shell operators, turn the list into a string.
+        if _contains_shell_operators(self._ffmpeg_command):
+            self._ffmpeg_command = " ".join(self._ffmpeg_command)
+
+        try:
+            process = subprocess.Popen(
+                self._ffmpeg_command,
+                shell=isinstance(self._ffmpeg_command, str),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                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
+
+        stdout_queue, stderr_queue = Queue(), Queue()
+        # Start stdout and stderr pipe readers
+        Thread(
+            target=self._read_pipe,
+            args=(process.stdout, stdout_queue, True),
+            daemon=True,
+        ).start()
+        Thread(
+            target=self._read_pipe,
+            args=(process.stderr, stderr_queue, False),
+            daemon=True,
+        ).start()
+
+        try:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                TaskProgressColumn(),
+                TimeElapsedColumn(),
+                TimeRemainingColumn(compact=True),
+                refresh_per_second=10,
+            ) as progress_bar:
+                task_id = None
+                if self._duration_secs:
+                    task_id = progress_bar.add_task(
+                        f"Processing {self._input_filepath.name}",
+                        total=self._duration_secs,
+                    )
+
+                while process.poll() is None:
+                    # stdout
+                    if task_id is not None and not stdout_queue.empty():
+                        try:
+                            line = stdout_queue.get_nowait()
+                            if line.startswith(self.TIME_MS_PREFIX):
+                                try:
+                                    value = int(line.split("=")[1]) / 1_000_000
+                                    if value <= self._duration_secs:
+                                        progress_bar.update(task_id, completed=value)
+                                except ValueError:
+                                    pass
+                        except Empty:
+                            pass
+
+                    # stderr
+                    if not stderr_queue.empty():
+                        try:
+                            self._process_stderr(stderr_queue.get_nowait())
+                        except Empty:
+                            pass
+
+                # Process remaining stderr
+                while not stderr_queue.empty():
+                    try:
+                        self._process_stderr(stderr_queue.get_nowait())
+                    except Empty:
+                        break
+
+                progress_bar.columns = (
+                    TextColumn("[progress.description]{task.description}"),
+                )
+
+                if process.returncode != 0:
+                    progress_bar.update(
+                        task_id,
+                        description=f"The FFmpeg process did not complete successfully. Check out {self._ffmpeg_log_file} for details.",
+                    )
+                    return 1
+
+                progress_bar.update(
+                    task_id,
+                    description=f"✓ Processed {self._input_filepath.name}",
+                )
+
+        except KeyboardInterrupt:
+            try:
+                psutil.Process(process.pid).terminate()
+            except psutil.NoSuchProcess:
+                pass
+            return 1
+
+        return 0 if process.returncode == 0 else 1

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

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: better-ffmpeg-progress
+Version: 3.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: ffmpeg-python
+Requires-Dist: psutil
+Requires-Dist: rich
+
+<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.
+</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 (H:MM:SS) 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()`.
+
+Here's a simple example:
+```py
+from better_ffmpeg_progress import FfmpegProcess
+
+process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:v", "libx265", "output.mp4"])
+
+# return_code will be 0 if the process was successful
+return_code = process.run()
+
+if return_code == 0:
+    # Code to run if the process was successful
+    pass
+else:
+    # Code to run if the process was unsuccessful
+    pass
+```
+## 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.
+- `print_detected_duration` - Print the detected duration of the input file. Default: `True`
+- `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** argument:
+- `print_command` - Print the FFmpeg command being executed. Default: `False`

{better_ffmpeg_progress-2.6.1 → better_ffmpeg_progress-3.1.0}/setup.py

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

better_ffmpeg_progress-2.6.1/PKG-INFO

@@ -1,113 +0,0 @@
-Metadata-Version: 2.1
-Name: better-ffmpeg-progress
-Version: 2.6.1
-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: ffmpeg-python
-Requires-Dist: psutil
-Requires-Dist: rich
-
-<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.
-</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 (H:MM:SS) 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()`.
-
-Simple Example:
-```py
-from better_ffmpeg_progress import FfmpegProcess
-# Pass a list of FFmpeg arguments, like you would if using subprocess.run()
-process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:a", "libmp3lame", "output.mp3"])
-# Use the run method to run the FFmpeg command.
-process.run()
-```
-
-Advanced Example:
-```py
-from better_ffmpeg_progress import FfmpegProcess
-
-def handle_progress_info(percentage, speed, eta, estimated_filesize):
-    print(f"Estimated Output Filesize: {estimated_filesize / 1_000_000} MB")
-
-def handle_success():
-  # Code to run if the FFmpeg process completes successfully.
-  pass
-
-def handle_error():
-  # Code to run if the FFmpeg process encounters an error.
-  pass
-
-# Pass a list of FFmpeg arguments, like you would if using subprocess.run() or subprocess.Popen()
-process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:a", "libmp3lame", "output.mp3"])
-
-# Use the run method to run the FFmpeg command.
-process.run(
-    progress_bar_description="Converting file...",
-    progress_handler=handle_progress_info,
-    log_file="ffmpeg_log.txt",
-    success_handler=handle_success,
-    error_handler=handle_error,
-)
-```
-
-## Optional Arguments
-An instance of the `FfmpegProcess` class takes the following **optional** arguments:
-
-- `ffmpeg_loglevel`: Desired FFmpeg log level. Default: `"verbose"`
-- `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
-- `print_detected_duration`: Print the detected duration of the input file. Default: True
-
-The `run` method takes the following **optional** arguments:
-- `print_command` - Print the FFmpeg command being executed. Default: `False`
-- `progress_bar_description` - An optional string to set a custom description for the progress bar. The default description is `Processing <file>`. This can be an empty string if you don't want the progress bar to have a description.
-- `progress_handler`
-  - You can create a function if you would like to do something with the following values:
-    - Percentage progress. [float]
-    - Speed, e.g. `22.3x` which means that 22.3 seconds of the input are processed every second. [string]
-    - ETA in seconds. [float]
-    - Estimated output filesize in bytes. [float]
-      - _Note: This is not accurate. Please take the value with a grain of salt._
-
-    The values will be `None` if unknown. The function will receive the current values of these metrics as arguments, every 0.1s.
-
-- `log_file` -  The filepath to save the FFmpeg log to.
-- `success_handler` - A function to run if the FFmpeg process completes successfully.
-- `error_handler` - A function to run if the FFmpeg process encounters an error.

better_ffmpeg_progress-2.6.1/README.md

@@ -1,95 +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.
-</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 (H:MM:SS) 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()`.
-
-Simple Example:
-```py
-from better_ffmpeg_progress import FfmpegProcess
-# Pass a list of FFmpeg arguments, like you would if using subprocess.run()
-process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:a", "libmp3lame", "output.mp3"])
-# Use the run method to run the FFmpeg command.
-process.run()
-```
-
-Advanced Example:
-```py
-from better_ffmpeg_progress import FfmpegProcess
-
-def handle_progress_info(percentage, speed, eta, estimated_filesize):
-    print(f"Estimated Output Filesize: {estimated_filesize / 1_000_000} MB")
-
-def handle_success():
-  # Code to run if the FFmpeg process completes successfully.
-  pass
-
-def handle_error():
-  # Code to run if the FFmpeg process encounters an error.
-  pass
-
-# Pass a list of FFmpeg arguments, like you would if using subprocess.run() or subprocess.Popen()
-process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:a", "libmp3lame", "output.mp3"])
-
-# Use the run method to run the FFmpeg command.
-process.run(
-    progress_bar_description="Converting file...",
-    progress_handler=handle_progress_info,
-    log_file="ffmpeg_log.txt",
-    success_handler=handle_success,
-    error_handler=handle_error,
-)
-```
-
-## Optional Arguments
-An instance of the `FfmpegProcess` class takes the following **optional** arguments:
-
-- `ffmpeg_loglevel`: Desired FFmpeg log level. Default: `"verbose"`
-- `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
-- `print_detected_duration`: Print the detected duration of the input file. Default: True
-
-The `run` method takes the following **optional** arguments:
-- `print_command` - Print the FFmpeg command being executed. Default: `False`
-- `progress_bar_description` - An optional string to set a custom description for the progress bar. The default description is `Processing <file>`. This can be an empty string if you don't want the progress bar to have a description.
-- `progress_handler`
-  - You can create a function if you would like to do something with the following values:
-    - Percentage progress. [float]
-    - Speed, e.g. `22.3x` which means that 22.3 seconds of the input are processed every second. [string]
-    - ETA in seconds. [float]
-    - Estimated output filesize in bytes. [float]
-      - _Note: This is not accurate. Please take the value with a grain of salt._
-
-    The values will be `None` if unknown. The function will receive the current values of these metrics as arguments, every 0.1s.
-
-- `log_file` -  The filepath to save the FFmpeg log to.
-- `success_handler` - A function to run if the FFmpeg process completes successfully.
-- `error_handler` - A function to run if the FFmpeg process encounters an error.

better_ffmpeg_progress-2.6.1/better_ffmpeg_progress/better_ffmpeg_progress.py

@@ -1,436 +0,0 @@
-from dataclasses import dataclass
-import os
-from pathlib import Path
-from queue import Empty, Queue
-import subprocess
-import sys
-from threading import Thread
-from typing import Callable, List, Optional, Union
-
-from .utils import print_with_prefix
-
-from ffmpeg import probe
-import psutil
-from rich.progress import (
-    Progress,
-    TextColumn,
-    BarColumn,
-    TaskProgressColumn,
-    TimeRemainingColumn,
-    TimeElapsedColumn,
-    SpinnerColumn,
-)
-
-
-@dataclass
-class Metrics:
-    """Data class to store FFmpeg progress information."""
-
-    percentage: float = 0.0
-    seconds_processed: float = 0
-    speed: float = None
-    eta: Optional[float] = None
-    estimated_size: Optional[int] = None
-
-
-class FfmpegProcess:
-    """
-    Args:
-        command: A list of arguments to pass to FFmpeg.
-        ffmpeg_loglevel: Desired FFmpeg log level. Default: "verbose"
-        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
-        print_detected_duration: Print the detected duration of the input file. Default: True
-
-    Raises:
-        FileNotFoundError: If FFmpeg cannot find the input filepath or filename.
-        ValueError: If the list of arguments does not include "-i"
-    """
-
-    WANTED_METRICS = frozenset({"out_time_ms", "total_size", "speed"})
-
-    def __init__(
-        self,
-        command: List[str],
-        ffmpeg_loglevel: str = "verbose",
-        print_detected_duration: bool = False,
-        print_stderr_new_line: bool = False,
-    ):
-        if "-i" not in command:
-            raise ValueError("FFmpeg command must include '-i'")
-
-        # -progress pipe:1 sends progress metrics to stdout
-        # -stats_period sets the period at which encoding progress/statistics are updated
-        extra_ffmpeg_options = [
-            "-hide_banner",
-            "-loglevel",
-            ffmpeg_loglevel,
-            "-progress",
-            "pipe:1",
-            "-stats_period",
-            "0.1",
-        ]
-
-        command[1:1] = extra_ffmpeg_options
-
-        self._ffmpeg_command = command
-        self._output_filepath = Path(command[-1])
-        self._print_detected_duration = print_detected_duration
-        self._print_stderr_new_line = print_stderr_new_line
-        self._metrics = Metrics()
-        self._duration_secs: Optional[float]
-        self._current_size: int = 0
-        self._ffmpeg_log_file: Optional[Path] = None
-        self._error_messages: list[str] = []
-        self._get_input_file_duration()
-
-    def _get_input_file_duration(self) -> None:
-        """Use ffprobe to get the duration of the input file"""
-        index_of_filepath = self._ffmpeg_command.index("-i") + 1
-        self._input_filepath = Path(self._ffmpeg_command[index_of_filepath])
-
-        try:
-            self._duration_secs = float(
-                probe(self._input_filepath)["format"]["duration"]
-            )
-
-            if self._print_detected_duration:
-                print_with_prefix(
-                    "[Better FFmpeg Progress] ",
-                    f"The duration of {self._input_filepath.name} has been detected as {self._duration_secs} seconds",
-                )
-
-            # -nostats ensures that progress information is not sent to stderr as this info is not needed in the log file, e.g.
-            # frame= 1381 fps=254 q=18.0 size=   46592KiB time=00:00:46.07 bitrate=8283.1kbits/s speed=8.47x
-            self._ffmpeg_command.extend(["-nostats"])
-        except Exception:
-            print_with_prefix(
-                "[Better FFmpeg Progress] ",
-                f"Could not detect the duration of '{self._input_filepath.name}'. Percentage progress, ETA and estimated filesize will be unavailable.\n",
-            )
-            self._duration_secs = None
-
-    def _should_overwrite(self) -> bool:
-        if self._output_filepath.exists() and "-y" not in self._ffmpeg_command:
-            choice = input(
-                f"{self._output_filepath} already exists. Overwrite? [Y/N]: "
-            ).lower()
-
-            if choice != "y":
-                print_with_prefix(
-                    "[Better FFmpeg Progress] ",
-                    "FFmpeg process cancelled. Output file exists and overwrite declined.",
-                )
-                return False
-
-            self._ffmpeg_command.insert(1, "-y")
-
-        return True
-
-    def _update_metrics(
-        self, line: str, metric: str, value: str, progress_handler: Optional[Callable]
-    ) -> None:
-        """Update progress information based on FFmpeg output."""
-        if metric == "total_size":
-            self._current_size = int(value)
-
-        elif metric == "out_time_ms":
-            self._metrics.seconds_processed = int(value) / 1_000_000
-
-            if self._duration_secs:
-                self._metrics.percentage = (
-                    self._metrics.seconds_processed / self._duration_secs
-                ) * 100
-                if self._current_size and self._metrics.percentage > 0:
-                    self._metrics.estimated_size = int(
-                        self._current_size * (100 / self._metrics.percentage)
-                    )
-
-        elif metric == "speed":
-            speed_float = float(value.rstrip("x"))
-            if speed_float > 0:
-                self._metrics.speed = float(speed_float)
-                if self._duration_secs:
-                    seconds_remaining = (
-                        self._duration_secs - self._metrics.seconds_processed
-                    )
-                    self._metrics.eta = seconds_remaining / self._metrics.speed
-
-        if line == "progress=end":
-            self._metrics.percentage = 100
-            self._metrics.eta = 0
-
-        if progress_handler:
-            progress_handler(
-                self._metrics.percentage,
-                self._metrics.speed,
-                self._metrics.eta,
-                self._metrics.estimated_size,
-            )
-
-    @staticmethod
-    def _handle_pipe(pipe, queue: Queue) -> None:
-        """Read from the pipe and put the lines into the queue."""
-        try:
-            for line in pipe:
-                queue.put(line.strip())
-        finally:
-            pipe.close()
-
-    def _contains_shell_operators(self, command: List[str]) -> bool:
-        """Check if the command contains shell operators."""
-        shell_operators = {"|", ">", "<", ">>", "&&", "||"}
-        return any(op in command for op in shell_operators)
-
-    def _start_process(
-        self,
-        progress_bar: Optional[Progress],
-        task_id: Optional[int],
-        progress_handler: Optional[Callable],
-    ) -> int:
-        creationflags = subprocess.CREATE_NEW_PROCESS_GROUP if os.name == "nt" else 0
-
-        # If command contains shell operators, turn the list into a string.
-        if self._contains_shell_operators(self._ffmpeg_command):
-            final_command = " ".join(self._ffmpeg_command)
-        else:
-            final_command = self._ffmpeg_command
-
-        self._write_to_log_file(
-            f"This file contains the log for the following command:\n{final_command if isinstance(final_command, str) else ' '.join(final_command)}\n",
-        )
-
-        process = subprocess.Popen(
-            final_command,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            shell=isinstance(final_command, str),
-            creationflags=creationflags,
-        )
-
-        stdout_queue, stderr_queue = Queue(), Queue()
-        Thread(
-            target=self._handle_pipe, args=(process.stdout, stdout_queue), daemon=True
-        ).start()
-        Thread(
-            target=self._handle_pipe, args=(process.stderr, stderr_queue), daemon=True
-        ).start()
-
-        error_words = [
-            "error",
-            "failed",
-            "invalid",
-            "trailing",
-            "unable",
-            "unknown",
-            "no such file",
-            "permission denied",
-            "not found",
-            "unrecognized",
-            "undefined",
-            "unsupported",
-            "does not exist",
-            "missing",
-            "not available",
-            "cannot",
-            "could not",
-            "bad",
-            "wrong",
-            "forbidden",
-        ]
-
-        try:
-            while process.poll() is None:
-                if self._duration_secs is not None:
-                    try:
-                        stdout = stdout_queue.get_nowait()
-
-                        if stdout:
-                            metric, value = stdout.split("=")
-                            if (
-                                metric in self.WANTED_METRICS
-                                and value
-                                and "N/A" not in value
-                            ):
-                                self._update_metrics(
-                                    stdout, metric, value, progress_handler
-                                )
-                                if (
-                                    metric == "out_time_ms"
-                                    and progress_bar
-                                    and task_id is not None
-                                ):
-                                    progress_bar.update(
-                                        task_id,
-                                        completed=self._metrics.seconds_processed,
-                                        speed=self._metrics.speed,
-                                    )
-                    except Empty:
-                        pass
-
-                try:
-                    stderr = stderr_queue.get_nowait()
-
-                    if stderr:
-                        self._write_to_log_file(stderr)
-
-                        if any(keyword in stderr.lower() for keyword in error_words):
-                            self._error_messages.append(stderr)
-
-                        if self._duration_secs is None:
-                            print(
-                                stderr,
-                                end="\n" if self._print_stderr_new_line else "\r",
-                                flush=True,
-                            )
-                except Empty:
-                    pass
-
-        except KeyboardInterrupt:
-            self._kill_process_and_children(process.pid)
-            self._write_to_log_file("\n[KeyboardInterrupt] FFmpeg process killed.")
-            sys.exit("\n[KeyboardInterrupt] FFmpeg process killed.")
-
-        # After the process ends, drain any remaining stderr
-        while True:
-            try:
-                stderr = stderr_queue.get_nowait()
-                if stderr:
-                    self._write_to_log_file(stderr)
-
-                    if any(keyword in stderr.lower() for keyword in error_words):
-                        self._error_messages.append(stderr)
-
-                    if self._duration_secs is None:
-                        print(
-                            stderr,
-                            end="\n" if self._print_stderr_new_line else "\r",
-                            flush=True,
-                        )
-            except Empty:
-                break
-
-        return process.returncode
-
-    def run(
-        self,
-        log_file: Optional[Union[str, Path]] = "ffmpeg_log.txt",
-        print_command=False,
-        progress_bar_description: str = None,
-        progress_handler: Optional[Callable] = None,
-        success_handler: Optional[Callable] = None,
-        error_handler: Optional[Callable] = None,
-    ) -> None:
-        """
-        Args:
-            log_file: Optional filepath to write FFmpeg output to
-            print_command: Print the FFmpeg command being executed. Default: False
-            progress_bar_description: Optional string to set a custom description for the progress bar
-            progress_handler: Optional function which receives progress metrics
-            success_handler: Optional function to handle successful completion of the FFmpeg process
-            error_handler: Optional function for FFmpeg process error handling
-        """
-        if not self._should_overwrite():
-            return
-
-        self._ffmpeg_log_file = Path(log_file)
-
-        with open(self._ffmpeg_log_file, "w"):
-            pass
-
-        if print_command:
-            print(f"Executing: {' '.join(self._ffmpeg_command)}")
-
-        if self._duration_secs and not progress_handler:
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                BarColumn(),
-                TaskProgressColumn(),
-                TimeElapsedColumn(),
-                TimeRemainingColumn(compact=True),
-                refresh_per_second=10,
-            ) as progress_bar:
-                task_id = progress_bar.add_task(
-                    progress_bar_description
-                    if progress_bar_description is not None
-                    else f"Processing {self._input_filepath.name}",
-                    total=self._duration_secs,
-                )
-
-                return_code = self._start_process(
-                    progress_bar,
-                    task_id,
-                    None,
-                )
-
-                if return_code == 0:
-                    progress_bar.columns = (
-                        TextColumn("[progress.description]{task.description}"),
-                    )
-                    progress_bar.update(
-                        task_id,
-                        description=f"✓ Processed 100% of {self._input_filepath.name}",
-                    )
-
-        else:
-            return_code = self._start_process(
-                None,
-                None,
-                progress_handler,
-            )
-
-            if return_code == 0:
-                print_with_prefix(
-                    "\n" if self._duration_secs is None else "",
-                    "FFmpeg process completed.",
-                )
-
-        self._handle_process_ended(return_code, error_handler, success_handler)
-
-    def _handle_process_ended(
-        self,
-        return_code: int,
-        error_handler: Optional[Callable],
-        success_handler: Optional[Callable],
-    ) -> None:
-        """Handle the completion of the FFmpeg process."""
-        if return_code != 0:
-            if error_handler:
-                error_handler()
-                sys.exit(
-                    "\nThe FFmpeg process encounted an error. Custom error handler executed."
-                )
-
-            print_with_prefix(
-                "[Better FFmpeg Progress] ",
-                f"FFmpeg process failed with return code {return_code}.\nError(s):",
-            )
-            print_with_prefix(
-                "[Better FFmpeg Progress] ", "\n".join(self._error_messages)
-            )
-            print_with_prefix(
-                "[Better FFmpeg Progress] ",
-                f"Check out '{self._ffmpeg_log_file}' for more details.",
-            )
-            sys.exit(1)
-
-        if success_handler:
-            success_handler()
-
-    def _kill_process_and_children(self, proc_pid: int) -> None:
-        """Kill the FFmpeg process and its children."""
-        try:
-            process = psutil.Process(proc_pid)
-            for child in process.children(recursive=True):
-                child.terminate()
-            # Terminate the main process
-            process.terminate()
-        except psutil.NoSuchProcess:
-            pass
-
-    def _write_to_log_file(self, message: str, mode: str = "a") -> None:
-        if self._ffmpeg_log_file:
-            with open(self._ffmpeg_log_file, mode) as f:
-                f.write(f"{message}\n")
-                f.flush()  # Ensure the message is written immediately

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

@@ -1,113 +0,0 @@
-Metadata-Version: 2.1
-Name: better-ffmpeg-progress
-Version: 2.6.1
-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: ffmpeg-python
-Requires-Dist: psutil
-Requires-Dist: rich
-
-<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.
-</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 (H:MM:SS) 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()`.
-
-Simple Example:
-```py
-from better_ffmpeg_progress import FfmpegProcess
-# Pass a list of FFmpeg arguments, like you would if using subprocess.run()
-process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:a", "libmp3lame", "output.mp3"])
-# Use the run method to run the FFmpeg command.
-process.run()
-```
-
-Advanced Example:
-```py
-from better_ffmpeg_progress import FfmpegProcess
-
-def handle_progress_info(percentage, speed, eta, estimated_filesize):
-    print(f"Estimated Output Filesize: {estimated_filesize / 1_000_000} MB")
-
-def handle_success():
-  # Code to run if the FFmpeg process completes successfully.
-  pass
-
-def handle_error():
-  # Code to run if the FFmpeg process encounters an error.
-  pass
-
-# Pass a list of FFmpeg arguments, like you would if using subprocess.run() or subprocess.Popen()
-process = FfmpegProcess(["ffmpeg", "-i", "input.mp4", "-c:a", "libmp3lame", "output.mp3"])
-
-# Use the run method to run the FFmpeg command.
-process.run(
-    progress_bar_description="Converting file...",
-    progress_handler=handle_progress_info,
-    log_file="ffmpeg_log.txt",
-    success_handler=handle_success,
-    error_handler=handle_error,
-)
-```
-
-## Optional Arguments
-An instance of the `FfmpegProcess` class takes the following **optional** arguments:
-
-- `ffmpeg_loglevel`: Desired FFmpeg log level. Default: `"verbose"`
-- `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
-- `print_detected_duration`: Print the detected duration of the input file. Default: True
-
-The `run` method takes the following **optional** arguments:
-- `print_command` - Print the FFmpeg command being executed. Default: `False`
-- `progress_bar_description` - An optional string to set a custom description for the progress bar. The default description is `Processing <file>`. This can be an empty string if you don't want the progress bar to have a description.
-- `progress_handler`
-  - You can create a function if you would like to do something with the following values:
-    - Percentage progress. [float]
-    - Speed, e.g. `22.3x` which means that 22.3 seconds of the input are processed every second. [string]
-    - ETA in seconds. [float]
-    - Estimated output filesize in bytes. [float]
-      - _Note: This is not accurate. Please take the value with a grain of salt._
-
-    The values will be `None` if unknown. The function will receive the current values of these metrics as arguments, every 0.1s.
-
-- `log_file` -  The filepath to save the FFmpeg log to.
-- `success_handler` - A function to run if the FFmpeg process completes successfully.
-- `error_handler` - A function to run if the FFmpeg process encounters an error.