better-ffmpeg-progress 3.2.1__tar.gz → 3.2.3__tar.gz

{better_ffmpeg_progress-3.2.1 → better_ffmpeg_progress-3.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: better-ffmpeg-progress
-Version: 3.2.1
+Version: 3.2.3
 Summary: Run FFmpeg & see percentage progress + ETA.
 Home-page: https://github.com/CrypticSignal/better-ffmpeg-progress
 Author: GitHub.com/CrypticSignal
@@ -12,7 +12,6 @@ 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
 Requires-Dist: tqdm

better_ffmpeg_progress-3.2.3/better_ffmpeg_progress/better_ffmpeg_progress.py

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

{better_ffmpeg_progress-3.2.1 → better_ffmpeg_progress-3.2.3}/better_ffmpeg_progress.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: better-ffmpeg-progress
-Version: 3.2.1
+Version: 3.2.3
 Summary: Run FFmpeg & see percentage progress + ETA.
 Home-page: https://github.com/CrypticSignal/better-ffmpeg-progress
 Author: GitHub.com/CrypticSignal
@@ -12,7 +12,6 @@ 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
 Requires-Dist: tqdm

{better_ffmpeg_progress-3.2.1 → better_ffmpeg_progress-3.2.3}/better_ffmpeg_progress.egg-info/requires.txt

@@ -1,4 +1,3 @@
-ffmpeg-python
 psutil
 rich
 tqdm

{better_ffmpeg_progress-3.2.1 → better_ffmpeg_progress-3.2.3}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as f:
 
 setuptools.setup(
     name="better-ffmpeg-progress",
-    version="3.2.1",
+    version="3.2.3",
     author="GitHub.com/CrypticSignal",
     author_email="theaudiophile@outlook.com",
     description="Run FFmpeg & see percentage progress + ETA.",
@@ -13,7 +13,7 @@ setuptools.setup(
     long_description_content_type="text/markdown",
     url="https://github.com/CrypticSignal/better-ffmpeg-progress",
     packages=["better_ffmpeg_progress"],
-    install_requires=["ffmpeg-python", "psutil", "rich", "tqdm"],
+    install_requires=["psutil", "rich", "tqdm"],
     python_requires=">=3.7",
     keywords=["ffmpeg", "progress"],
     classifiers=[

better_ffmpeg_progress-3.2.1/better_ffmpeg_progress/better_ffmpeg_progress.py

@@ -1,328 +0,0 @@
-from enum import Enum
-import os
-from pathlib import Path
-import psutil
-from queue import Queue
-import shutil
-import subprocess
-from threading import Thread
-from time import sleep
-from typing import List, Optional, Union
-
-from ffmpeg import probe
-from rich.progress import (
-    Progress,
-    TextColumn,
-    BarColumn,
-    TaskProgressColumn,
-    TimeRemainingColumn,
-    TimeElapsedColumn,
-    SpinnerColumn,
-)
-from tqdm import tqdm
-
-
-class FfmpegLogLevel(Enum):
-    QUIET = "quiet"
-    PANIC = "panic"
-    FATAL = "fatal"
-    ERROR = "error"
-    WARNING = "warning"
-    INFO = "info"
-    VERBOSE = "verbose"
-    DEBUG = "debug"
-    TRACE = "trace"
-
-
-class FfmpegProcess:
-    @staticmethod
-    def _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} seconds")
-        except Exception:
-            self._duration_secs = None
-
-        self._ffmpeg_command = [
-            command[0],
-            "-hide_banner",
-            "-loglevel",
-            self._ffmpeg_log_level,
-            "-progress",
-            "pipe: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 _use_rich(self, process, stdout_queue, stderr_queue) -> int:
-        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:
-                # FFmpeg only updates encoding progress/statistics every 0.5 seconds
-                sleep(0.5)
-                # stdout
-                if task_id is not None and not stdout_queue.empty():
-                    line = stdout_queue.get()
-                    try:
-                        value = int(line.split("=")[1]) / 1_000_000
-                        if value <= self._duration_secs:
-                            progress_bar.update(task_id, completed=value)
-                    except ValueError:
-                        pass
-                # stderr
-                if not stderr_queue.empty():
-                    self._process_stderr(stderr_queue.get())
-
-            if process.returncode == 0 and task_id is not None:
-                progress_bar.update(task_id, completed=self._duration_secs)
-                progress_bar.columns = (
-                    TextColumn("[progress.description]{task.description}"),
-                    BarColumn(),
-                    TaskProgressColumn(),
-                )
-                progress_bar.update(
-                    task_id,
-                    description=f"✓ Processed {self._input_filepath.name}",
-                )
-
-            # Process remaining stderr
-            while not stderr_queue.empty():
-                self._process_stderr(stderr_queue.get())
-
-            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
-
-            return 0
-
-    def _use_tqdm(self, process, stdout_queue, stderr_queue) -> int:
-        pbar = None
-        width, _ = os.get_terminal_size()
-
-        if self._duration_secs:
-            pbar = tqdm(
-                total=self._duration_secs,
-                desc=f"Processing {self._input_filepath.name}",
-                ncols=80,
-                dynamic_ncols=True if width < 80 else False,
-                bar_format="{desc} {bar} {percentage:.1f}% {elapsed} {remaining}",
-            )
-
-        while process.poll() is None:
-            # FFmpeg only updates encoding progress/statistics every 0.5 seconds
-            sleep(0.5)
-            # stdout
-            if pbar and not stdout_queue.empty():
-                line = stdout_queue.get()
-                try:
-                    value = int(line.split("=")[1]) / 1_000_000
-                    if value <= self._duration_secs:
-                        pbar.n = value
-                        pbar.refresh()
-                except ValueError:
-                    pass
-            # stderr
-            if not stderr_queue.empty():
-                self._process_stderr(stderr_queue.get())
-
-        if process.returncode == 0 and pbar:
-            pbar.n = self._duration_secs
-            pbar.set_description(f"✓ Processed {self._input_filepath.name}")
-
-        if pbar:
-            pbar.close()
-
-        # Process remaining stderr
-        while not stderr_queue.empty():
-            self._process_stderr(stderr_queue.get())
-
-        if process.returncode != 0:
-            print(
-                f"The FFmpeg process did not complete successfully. Check out {self._ffmpeg_log_file} for details."
-            )
-            return 1
-
-        return 0
-
-    def run(
-        self,
-        print_command: bool = False,
-        use_tqdm: bool = False,
-    ) -> int:
-        if hasattr(self, "return_code") and self.return_code != 0:
-            return 1
-
-        if 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:
-            if use_tqdm:
-                return self._use_tqdm(process, stdout_queue, stderr_queue)
-            else:
-                return self._use_rich(process, stdout_queue, stderr_queue)
-        except KeyboardInterrupt:
-            try:
-                psutil.Process(process.pid).terminate()
-            except psutil.NoSuchProcess:
-                pass
-            return 1