better-ffmpeg-progress 3.2.0__tar.gz → 3.2.2__tar.gz

{better_ffmpeg_progress-3.2.0 → better_ffmpeg_progress-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: better-ffmpeg-progress
-Version: 3.2.0
+Version: 3.2.2
 Summary: Run FFmpeg & see percentage progress + ETA.
 Home-page: https://github.com/CrypticSignal/better-ffmpeg-progress
 Author: GitHub.com/CrypticSignal

{better_ffmpeg_progress-3.2.0 → better_ffmpeg_progress-3.2.2}/better_ffmpeg_progress/better_ffmpeg_progress.py

@@ -2,10 +2,9 @@ from enum import Enum
 import os
 from pathlib import Path
 import psutil
-from queue import Empty, Queue
+from queue import Queue
 import shutil
 import subprocess
-from threading import Thread
 from typing import List, Optional, Union
 
 from ffmpeg import probe
@@ -34,26 +33,6 @@ class FfmpegLogLevel(Enum):
 
 
 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"):
@@ -113,14 +92,11 @@ class FfmpegProcess:
         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")
+                print(f"Detected duration: {self._duration_secs} seconds")
         except Exception:
             self._duration_secs = None
 
@@ -131,26 +107,13 @@ class FfmpegProcess:
             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 _use_rich(self, process, stdout_queue, stderr_queue) -> int:
+    def _use_rich(self, process) -> int:
         with Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
@@ -161,46 +124,39 @@ class FfmpegProcess:
             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
+            if task_id is not None:
+                while process.poll() is None:
+                    stdout = process.stdout.readline()
 
-            # 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}"),
-                BarColumn(),
-                TaskProgressColumn(),
-            )
+                    if not stdout.startswith("out_time_ms"):
+                        continue
+
+                    try:
+                        value = int(stdout.split("=")[1]) / 1_000_000
+                    except ValueError:
+                        continue
+                    else:
+                        if value <= self._duration_secs:
+                            progress_bar.update(task_id, completed=value)
+
+                if process.returncode == 0:
+                    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}",
+                    )
 
             if process.returncode != 0:
                 progress_bar.update(
@@ -209,19 +165,14 @@ class FfmpegProcess:
                 )
                 return 1
 
-            progress_bar.update(
-                task_id,
-                description=f"✓ Processed {self._input_filepath.name}",
-            )
-
             return 0
 
-    def _use_tqdm(self, process, stdout_queue, stderr_queue) -> int:
-        pbar = None
+    def _use_tqdm(self, process) -> int:
+        progress_bar = None
         width, _ = os.get_terminal_size()
 
         if self._duration_secs:
-            pbar = tqdm(
+            progress_bar = tqdm(
                 total=self._duration_secs,
                 desc=f"Processing {self._input_filepath.name}",
                 ncols=80,
@@ -229,34 +180,27 @@ class FfmpegProcess:
                 bar_format="{desc} {bar} {percentage:.1f}% {elapsed} {remaining}",
             )
 
-        while process.poll() is None:
-            # stdout
-            if pbar 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:
-                                pbar.n = value
-                                pbar.refresh()
-                        except ValueError:
-                            pass
-                except Empty:
-                    pass
-            # stderr
-            if not stderr_queue.empty():
+        if progress_bar is not None:
+            while process.poll() is None:
+                stdout = process.stdout.readline()
+
+                if not stdout.startswith("out_time_ms"):
+                    continue
+
                 try:
-                    self._process_stderr(stderr_queue.get_nowait())
-                except Empty:
-                    pass
+                    value = int(stdout.split("=")[1]) / 1_000_000
+                except ValueError:
+                    continue
+                else:
+                    if value <= self._duration_secs:
+                        progress_bar.n = value
+                        progress_bar.refresh()
 
-        # Process remaining stderr
-        while not stderr_queue.empty():
-            try:
-                self._process_stderr(stderr_queue.get_nowait())
-            except Empty:
-                break
+            if process.returncode == 0:
+                progress_bar.n = self._duration_secs
+                progress_bar.set_description(f"✓ Processed {self._input_filepath.name}")
+
+            progress_bar.close()
 
         if process.returncode != 0:
             print(
@@ -264,13 +208,13 @@ class FfmpegProcess:
             )
             return 1
 
-        pbar.set_description(f"✓ Processed {self._input_filepath.name}")
-        if pbar:
-            pbar.close()
-
         return 0
 
-    def run(self, print_command: bool = False, use_tqdm: bool = False) -> int:
+    def run(
+        self,
+        print_command: bool = False,
+        use_tqdm: bool = False,
+    ) -> int:
         if hasattr(self, "return_code") and self.return_code != 0:
             return 1
 
@@ -299,38 +243,26 @@ class FfmpegProcess:
             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,
-            )
+            with open(self._ffmpeg_log_file, "w") as f:
+                process = subprocess.Popen(
+                    self._ffmpeg_command,
+                    shell=isinstance(self._ffmpeg_command, str),
+                    stdout=subprocess.PIPE,
+                    stderr=f,
+                    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)
+                return self._use_tqdm(process)
             else:
-                return self._use_rich(process, stdout_queue, stderr_queue)
+                return self._use_rich(process)
         except KeyboardInterrupt:
             try:
                 psutil.Process(process.pid).terminate()

{better_ffmpeg_progress-3.2.0 → better_ffmpeg_progress-3.2.2}/better_ffmpeg_progress.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: better-ffmpeg-progress
-Version: 3.2.0
+Version: 3.2.2
 Summary: Run FFmpeg & see percentage progress + ETA.
 Home-page: https://github.com/CrypticSignal/better-ffmpeg-progress
 Author: GitHub.com/CrypticSignal

{better_ffmpeg_progress-3.2.0 → better_ffmpeg_progress-3.2.2}/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.0",
+    version="3.2.2",
     author="GitHub.com/CrypticSignal",
     author_email="theaudiophile@outlook.com",
     description="Run FFmpeg & see percentage progress + ETA.",