better-ffmpeg-progress 5.4.2__tar.gz → 6.0.0__tar.gz

{better_ffmpeg_progress-5.4.2/better_ffmpeg_progress.egg-info → better_ffmpeg_progress-6.0.0}/PKG-INFO

@@ -1,21 +1,24 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: better-ffmpeg-progress
-Version: 5.4.2
+Version: 6.0.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
+Author-email: "GitHub.com/CrypticSignal" <theaudiophile@outlook.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/CrypticSignal/better-ffmpeg-progress
+Project-URL: Changelog, https://github.com/CrypticSignal/better-ffmpeg-progress/blob/main/CHANGELOG.md
 Keywords: ffmpeg,progress
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: psutil
-Requires-Dist: requests
 Requires-Dist: rich
 Requires-Dist: tqdm
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
 
 <div align="center">
 
@@ -65,9 +68,8 @@ command = [
 ]
 
 try:
+    # Pass use_tqdm=True to use tqdm instead of Rich.
     process = FfmpegProcess(command)
-    # Uncomment this line to use tqdm instead of Rich.
-    # process.use_tqdm = True
 
     process.run()
 except FfmpegProcessError as e:
@@ -137,14 +139,50 @@ An instance of `FfmpegProcess` accepts the following optional arguments:
 * `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`.
+* `use_tqdm` — Use tqdm instead of Rich for the progress bar. Default: `False`.
+* `overwrite` — What to do if the output file already exists: `True` overwrites it, `False` raises `FfmpegCommandError`, and `None` asks whether to overwrite it. Ignored if the command contains `-y` or `-n`. 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`:
+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 passing `use_tqdm=True`:
 ```python
-process = FfmpegProcess(command)
-process.use_tqdm = True
+process = FfmpegProcess(command, use_tqdm=True)
 process.run()
 ```
+## Limitations
+- Progress is calculated from the duration of the first input (the first `-i`).
+- The last argument of the command is treated as the output file, e.g. when checking whether it already exists. With multiple outputs, only the last one is checked.
+
+## Development
+Install the package in editable mode with the test dependencies, then run the tests (FFmpeg and FFprobe must be installed):
+```bash
+pip install -e ".[test]"
+```
+```bash
+pytest
+```
+`test.py` is a standalone example that encodes a test pattern and shows the progress bar.
+
+## Publishing
+Update `__version__` in `better_ffmpeg_progress/__init__.py` and add an entry to `CHANGELOG.md`.
+
+One-time setup:
+```bash
+pip install --upgrade build twine pkginfo
+```
+
+Then, for each release:
+```bash
+rm -rf dist
+```
+```bash
+python -m build
+```
+```bash
+twine check dist/*
+```
+```bash
+twine upload dist/*
+```

better_ffmpeg_progress-5.4.2/PKG-INFO → better_ffmpeg_progress-6.0.0/README.md

@@ -1,22 +1,3 @@
-Metadata-Version: 2.1
-Name: better-ffmpeg-progress
-Version: 5.4.2
-Summary: Run FFmpeg & see percentage progress + ETA.
-Home-page: https://github.com/CrypticSignal/better-ffmpeg-progress
-Author: GitHub.com/CrypticSignal
-Author-email: theaudiophile@outlook.com
-Keywords: ffmpeg,progress
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: psutil
-Requires-Dist: requests
-Requires-Dist: rich
-Requires-Dist: tqdm
-
 <div align="center">
 
 # Better FFmpeg Progress
@@ -65,9 +46,8 @@ command = [
 ]
 
 try:
+    # Pass use_tqdm=True to use tqdm instead of Rich.
     process = FfmpegProcess(command)
-    # Uncomment this line to use tqdm instead of Rich.
-    # process.use_tqdm = True
 
     process.run()
 except FfmpegProcessError as e:
@@ -137,14 +117,50 @@ An instance of `FfmpegProcess` accepts the following optional arguments:
 * `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`.
+* `use_tqdm` — Use tqdm instead of Rich for the progress bar. Default: `False`.
+* `overwrite` — What to do if the output file already exists: `True` overwrites it, `False` raises `FfmpegCommandError`, and `None` asks whether to overwrite it. Ignored if the command contains `-y` or `-n`. 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`:
+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 passing `use_tqdm=True`:
 ```python
-process = FfmpegProcess(command)
-process.use_tqdm = True
+process = FfmpegProcess(command, use_tqdm=True)
 process.run()
 ```
+## Limitations
+- Progress is calculated from the duration of the first input (the first `-i`).
+- The last argument of the command is treated as the output file, e.g. when checking whether it already exists. With multiple outputs, only the last one is checked.
+
+## Development
+Install the package in editable mode with the test dependencies, then run the tests (FFmpeg and FFprobe must be installed):
+```bash
+pip install -e ".[test]"
+```
+```bash
+pytest
+```
+`test.py` is a standalone example that encodes a test pattern and shows the progress bar.
+
+## Publishing
+Update `__version__` in `better_ffmpeg_progress/__init__.py` and add an entry to `CHANGELOG.md`.
+
+One-time setup:
+```bash
+pip install --upgrade build twine pkginfo
+```
+
+Then, for each release:
+```bash
+rm -rf dist
+```
+```bash
+python -m build
+```
+```bash
+twine check dist/*
+```
+```bash
+twine upload dist/*
+```

{better_ffmpeg_progress-5.4.2 → better_ffmpeg_progress-6.0.0}/better_ffmpeg_progress/__init__.py

@@ -1,3 +1,5 @@
+__version__ = "6.0.0"
+
 from .better_ffmpeg_progress import FfmpegProcess
 from .enums import FfmpegLogLevel
 from .exceptions import (
@@ -8,6 +10,7 @@ from .exceptions import (
 )
 
 __all__ = [
+    "__version__",
     "FfmpegProcess",
     "FfmpegLogLevel",
     "FfmpegProcessError",

{better_ffmpeg_progress-5.4.2 → better_ffmpeg_progress-6.0.0}/better_ffmpeg_progress/better_ffmpeg_progress.py

@@ -4,8 +4,7 @@ import re
 import shlex
 from pathlib import Path
 import subprocess
-from sys import exit
-from typing import List, Optional, Union
+from typing import IO, Any, List, Optional, Union
 
 from .enums import FfmpegLogLevel
 from .exceptions import (
@@ -19,11 +18,19 @@ from .utils import (
     get_media_duration,
     get_expected_output_duration,
     is_lavfi_input,
+    is_local_file_input,
+    is_stdin_input,
 )
 from .terminate_process import terminate_ffmpeg_process
 from .progress_bars import use_rich, use_tqdm
 
 _FFMPEG_OVERWRITE_FLAG = "-y"
+_FFMPEG_NO_OVERWRITE_FLAG = "-n"
+
+
+def _safe_filename(name: str) -> str:
+    """Replaces characters that are not valid in filenames on every OS."""
+    return re.sub(r"[^\w.,-]", "_", name)
 
 
 class FfmpegProcess:
@@ -59,9 +66,11 @@ class FfmpegProcess:
         self,
         command: List[str],
         ffmpeg_log_level: Optional[Union[FfmpegLogLevel, str]] = None,
-        ffmpeg_log_file: Optional[Union[str, os.PathLike]] = None,
+        ffmpeg_log_file: Optional[Union[str, os.PathLike, IO[Any]]] = None,
         print_detected_duration: bool = False,
         duration_override: Optional[float] = None,
+        overwrite: Optional[bool] = None,
+        use_tqdm: bool = False,
     ):
         """
         Create an FFmpeg process with progress reporting.
@@ -72,12 +81,19 @@ class FfmpegProcess:
             ffmpeg_log_level:
                 FFmpeg log level enum or case-insensitive string.
             ffmpeg_log_file:
-                File path or file-like object used for FFmpeg stderr.
+                File path or file object (with a file descriptor, e.g. one returned by open())
+                to which FFmpeg's stderr is written.
             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.
+            overwrite:
+                What to do if the output file already exists. True overwrites it, False raises
+                FfmpegCommandError, and None (the default) asks the user. Ignored if the command
+                contains -y or -n.
+            use_tqdm:
+                Use tqdm instead of Rich for the progress bar.
         """
         validate_ffmpeg_command(command)
 
@@ -118,10 +134,17 @@ class FfmpegProcess:
                 # A filtergraph such as "testsrc2=size=1920x1080" can contain characters that
                 # are not valid in filenames (e.g. ":" on Windows), so name the log after the
                 # source instead.
-                source_name = re.sub(r"[^\w.,-]", "_", input_file_path_str.split("=", 1)[0])
+                source_name = _safe_filename(input_file_path_str.split("=", 1)[0])
                 self._ffmpeg_log_file = Path(f"lavfi_{source_name}_ffmpeg_log.txt")
-            else:
+            elif input_file_path_str == "-":
+                self._ffmpeg_log_file = Path("stdin_ffmpeg_log.txt")
+            elif is_local_file_input(command, input_file_index):
                 self._ffmpeg_log_file = Path(f"{self._input_filepath.name}_ffmpeg_log.txt")
+            else:
+                # URLs and other protocols (e.g. "pipe:0") can contain characters that are not
+                # valid in filenames, such as ":" or "?".
+                name = self._input_filepath.name or input_file_path_str
+                self._ffmpeg_log_file = Path(f"{_safe_filename(name)}_ffmpeg_log.txt")
         elif isinstance(ffmpeg_log_file, (str, os.PathLike)):
             self._ffmpeg_log_file = Path(ffmpeg_log_file)
         else:
@@ -142,6 +165,9 @@ class FfmpegProcess:
                 raise ValueError("duration_override must be a finite number greater than 0")
 
             self._duration_secs = duration_value
+        elif is_stdin_input(input_file_path_str):
+            # Running FFprobe on standard input would consume data that is meant for FFmpeg.
+            self._duration_secs = None
         else:
             self._duration_secs = get_media_duration(input_file_path_str)
 
@@ -178,13 +204,29 @@ class FfmpegProcess:
         ]
         self._ffmpeg_command.extend(command[1:])
 
-        is_overwrite_in_user_command = any(arg == _FFMPEG_OVERWRITE_FLAG for arg in command[1:])
+        if overwrite is not None and not isinstance(overwrite, bool):
+            raise TypeError("overwrite must be True, False or None")
 
-        if self._output_filepath.exists() and not is_overwrite_in_user_command:
-            self._handle_overwrite_prompt()
+        user_args = command[1:]
+        if _FFMPEG_OVERWRITE_FLAG not in user_args and self._output_filepath.exists():
+            if _FFMPEG_NO_OVERWRITE_FLAG in user_args or overwrite is False:
+                raise FfmpegCommandError(
+                    f"Output file {self._output_filepath} already exists and overwriting is "
+                    "disabled."
+                )
+            elif overwrite:
+                self._ffmpeg_command.insert(1, _FFMPEG_OVERWRITE_FLAG)
+            elif is_stdin_input(input_file_path_str):
+                # Prompting would read from standard input, which carries FFmpeg's input.
+                raise FfmpegCommandError(
+                    f"Output file {self._output_filepath} already exists. Pass overwrite=True "
+                    "or add -y to the command to overwrite it."
+                )
+            else:
+                self._handle_overwrite_prompt()
 
         self._process: Optional[subprocess.Popen] = None
-        self.use_tqdm: bool = False
+        self.use_tqdm: bool = use_tqdm
 
     def run(
         self,
@@ -193,12 +235,15 @@ class FfmpegProcess:
         if print_command:
             print(f"Executing: {shlex.join(self._ffmpeg_command)}")
 
-        try:
-            creationflags = 0
-            # Windows
-            if os.name == "nt":
-                creationflags = subprocess.CREATE_NEW_PROCESS_GROUP
+        # Run FFmpeg in its own process group, so that terminating the group on
+        # KeyboardInterrupt does not also terminate this Python process.
+        popen_kwargs = {}
+        if os.name == "nt":
+            popen_kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+        else:
+            popen_kwargs["start_new_session"] = True
 
+        try:
             if isinstance(self._ffmpeg_log_file, Path):
                 with open(
                     self._ffmpeg_log_file,
@@ -209,14 +254,14 @@ class FfmpegProcess:
                         self._ffmpeg_command,
                         stdout=subprocess.PIPE,
                         stderr=f,
-                        creationflags=creationflags,
+                        **popen_kwargs,
                     )
             else:
                 self._process = subprocess.Popen(
                     self._ffmpeg_command,
                     stdout=subprocess.PIPE,
                     stderr=self._ffmpeg_log_file,
-                    creationflags=creationflags,
+                    **popen_kwargs,
                 )
         except Exception as e:
             raise FfmpegProcessError(f"Error starting FFmpeg process: {e}") from e
@@ -226,14 +271,11 @@ class FfmpegProcess:
                 use_tqdm(self, self._process)
             else:
                 use_rich(self, self._process)
-        except KeyboardInterrupt:
-            self._terminate()
+        except KeyboardInterrupt as e:
+            terminate_ffmpeg_process(self._process)
+            raise FfmpegProcessInterruptedError(
+                "[KeyboardInterrupt] FFmpeg process cancelled."
+            ) from e
         finally:
             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.4.2 → better_ffmpeg_progress-6.0.0}/better_ffmpeg_progress/progress_bars.py

@@ -13,6 +13,7 @@ from rich.progress import (
 from tqdm import tqdm
 
 from .utils import (
+    build_failure_message,
     estimate_final_size_mb,
     parse_ffmpeg_progress_line,
     parse_ffmpeg_total_size_line,
@@ -44,6 +45,16 @@ def _with_size(text: str, current_size_mb: float, estimated_size_mb: Optional[fl
     return f"{text} {size}" if size else text
 
 
+def _drain(process: subprocess.Popen) -> None:
+    """
+    Reads FFmpeg's progress output until it ends. FFmpeg writes it to a pipe, so it must be read
+    even when it is not displayed: once the pipe's buffer is full, FFmpeg blocks and never exits.
+    """
+    if process.stdout is not None:
+        for _ in process.stdout:
+            pass
+
+
 def use_rich(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen) -> None:
     task_id = None
     progress_bar_instance = Progress(
@@ -94,6 +105,7 @@ def use_rich(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
                     )
         else:
             print(f"Processing '{input_filename}'...")
+            _drain(process)
 
         process.wait()
 
@@ -115,7 +127,7 @@ def use_rich(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
             if task_id is not None:
                 progress_bar.update(task_id)
 
-            raise FfmpegProcessError(f"FFmpeg process failed. Check '{log_file}' for details.")
+            raise FfmpegProcessError(build_failure_message(log_file))
 
 
 def use_tqdm(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen) -> None:
@@ -161,6 +173,7 @@ def use_tqdm(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
                 progress_bar.set_postfix_str(_format_size(current_size_mb, estimated_size_mb))
     else:
         print(f"Processing '{input_filename}'...")
+        _drain(process)
 
     process.wait()
 
@@ -176,4 +189,4 @@ def use_tqdm(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
         if progress_bar:
             progress_bar.close()
 
-        raise FfmpegProcessError(f"FFmpeg process failed. Check '{log_file}' for details.")
+        raise FfmpegProcessError(build_failure_message(log_file))

{better_ffmpeg_progress-5.4.2 → better_ffmpeg_progress-6.0.0}/better_ffmpeg_progress/terminate_process.py

@@ -1,11 +1,16 @@
+import logging
 import os
-import psutil
 import subprocess
-from sys import exit
+
+import psutil
 from typing import Optional
 
+from .exceptions import FfmpegProcessError
+
 _TERMINATION_TIMEOUT = 2
 
+logger = logging.getLogger(__name__)
+
 
 def _terminate_children_processes(parent_proc: psutil.Process):
     """Helper to terminate child processes of the given parent process."""
@@ -14,17 +19,17 @@ def _terminate_children_processes(parent_proc: psutil.Process):
             return
         children = parent_proc.children(recursive=True)
     except (psutil.NoSuchProcess, psutil.ZombieProcess):
-        print(
+        logger.info(
             f"Parent process {parent_proc.pid} not found or is a zombie while fetching children."
         )
         return
     except psutil.AccessDenied:
-        print(
+        logger.warning(
             f"Access denied when trying to list children of {parent_proc.pid}. Skipping child termination."
         )
         return
     except Exception as e:
-        print(
+        logger.warning(
             f"Error fetching children for process {parent_proc.pid}: {e}. Skipping child termination."
         )
         return
@@ -32,7 +37,9 @@ 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}...")
+    logger.info(
+        f"Attempting to terminate {len(children)} child process(es) of {parent_proc.pid}..."
+    )
     for child in children:
         try:
             if child.is_running():
@@ -43,7 +50,7 @@ def _terminate_children_processes(parent_proc: psutil.Process):
     _, alive = psutil.wait_procs(children, timeout=_TERMINATION_TIMEOUT)
 
     if alive:
-        print(f"Force killing {len(alive)} remaining child process(es)...")
+        logger.warning(f"Force killing {len(alive)} remaining child process(es)...")
         for child_to_kill in alive:
             try:
                 if child_to_kill.is_running():
@@ -58,27 +65,31 @@ def _terminate_parent_process_windows(proc: psutil.Process):
         proc.terminate()
         proc.wait(timeout=_TERMINATION_TIMEOUT)
     except psutil.NoSuchProcess:
-        print(f"FFmpeg process {proc.pid} already exited.")
+        logger.info(f"FFmpeg process {proc.pid} already exited.")
     except psutil.TimeoutExpired:
-        print(
+        logger.warning(
             f"FFmpeg process {proc.pid} did not terminate within {_TERMINATION_TIMEOUT}s. Checking status..."
         )
         try:
             # Check the status after the timeout
             if proc.is_running():
-                print(f"FFmpeg process {proc.pid} still running after {_TERMINATION_TIMEOUT}s.")
+                logger.warning(
+                    f"FFmpeg process {proc.pid} still running after {_TERMINATION_TIMEOUT}s."
+                )
             else:
-                print(f"FFmpeg process termination took longer than {_TERMINATION_TIMEOUT}s.")
+                logger.info(
+                    f"FFmpeg process termination took longer than {_TERMINATION_TIMEOUT}s."
+                )
         except psutil.NoSuchProcess:
-            print(
+            logger.info(
                 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}")
+            logger.warning(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}.")
+        logger.warning(f"Access denied when trying to terminate FFmpeg process {proc.pid}.")
     except psutil.Error as e:
-        print(f"Unable to terminate FFmpeg process:\n{e}")
+        logger.warning(f"Unable to terminate FFmpeg process:\n{e}")
 
 
 def _terminate_parent_process_unix(proc: psutil.Process, original_pid: int):
@@ -89,7 +100,7 @@ def _terminate_parent_process_unix(proc: psutil.Process, original_pid: int):
     pgid_to_signal = 0
     try:
         pgid_to_signal = os.getpgid(original_pid)
-        print(f"Sending SIGTERM to process group {pgid_to_signal}...")
+        logger.info(f"Sending SIGTERM to process group {pgid_to_signal}...")
         os.killpg(pgid_to_signal, SIGTERM)
 
         try:
@@ -98,14 +109,16 @@ 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...")
+            logger.warning(
+                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
                 if not proc.is_running():
                     terminated_by_pg = True
             except psutil.TimeoutExpired:
-                print(f"Process group {pgid_to_signal} still running after SIGKILL.")
+                logger.warning(f"Process group {pgid_to_signal} still running after SIGKILL.")
             # Process died after SIGKILL
             except psutil.NoSuchProcess:
                 terminated_by_pg = True
@@ -114,7 +127,7 @@ def _terminate_parent_process_unix(proc: psutil.Process, original_pid: int):
             terminated_by_pg = True
     # os.getpgid(original_pid) failed
     except ProcessLookupError:
-        print(
+        logger.warning(
             f"ProcessLookupError for PID {original_pid} when trying to get PGID. Fallback to individual process."
         )
     # os.killpg failed
@@ -122,7 +135,9 @@ def _terminate_parent_process_unix(proc: psutil.Process, original_pid: int):
         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.")
+        logger.warning(
+            f"Error sending signal to {target_desc}: {e}. Fallback to individual process."
+        )
 
     if terminated_by_pg:
         return
@@ -130,7 +145,7 @@ def _terminate_parent_process_unix(proc: psutil.Process, original_pid: int):
     # Fallback: Terminate the main process directly if process group termination failed or was skipped
     try:
         if proc.is_running():
-            print(f"Attempting direct SIGTERM for main process {proc.pid}...")
+            logger.info(f"Attempting direct SIGTERM for main process {proc.pid}...")
             try:
                 # Send SIGTERM
                 proc.terminate()
@@ -139,11 +154,11 @@ def _terminate_parent_process_unix(proc: psutil.Process, original_pid: int):
                 if not proc.is_running():
                     return
             except psutil.TimeoutExpired:
-                print(
+                logger.warning(
                     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}")
+                logger.warning(f"Error during SIGTERM for FFmpeg process (PID: {proc.pid}):\n{e}")
                 if not proc.is_running():
                     return
 
@@ -151,21 +166,23 @@ def _terminate_parent_process_unix(proc: psutil.Process, original_pid: int):
 
             # Check if process is still running
             if proc.is_running():
-                print(
+                logger.warning(
                     f"FFmpeg process (PID: {proc.pid}) still running after direct SIGTERM, attempting SIGKILL..."
                 )
                 try:
                     # Send SIGKILL
                     proc.kill()
-                    print(f"SIGKILL sent to FFmpeg process (PID: {proc.pid}).")
+                    logger.info(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}")
+                    logger.warning(
+                        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.")
+            logger.info(f"It seems like FFmpeg process {proc.pid} is no longer running.")
     except psutil.NoSuchProcess:
-        print(f"It seems like the FFmpeg process (PID: {proc.pid}) has terminated.")
+        logger.info(f"It seems like the FFmpeg process (PID: {proc.pid}) has terminated.")
     except psutil.Error as e:
-        print(f"Unable to check the status of FFmpeg process (PID: {proc.pid}):\n{e}")
+        logger.warning(f"Unable to check the status of FFmpeg process (PID: {proc.pid}):\n{e}")
 
 
 def terminate_ffmpeg_process(process: Optional[subprocess.Popen]):
@@ -184,12 +201,12 @@ def terminate_ffmpeg_process(process: Optional[subprocess.Popen]):
     try:
         parent_ps_proc = psutil.Process(original_pid)
     except (psutil.NoSuchProcess, psutil.ZombieProcess):
-        print(
+        logger.info(
             f"FFmpeg process {original_pid} already gone or is a zombie when termination started."
         )
         return
     except Exception as e:
-        print(f"Error accessing FFmpeg process {original_pid} with psutil: {e}")
+        logger.warning(f"Error accessing FFmpeg process {original_pid} with psutil: {e}")
         if process.poll() is None:
             try:
                 process.terminate()
@@ -198,7 +215,7 @@ def terminate_ffmpeg_process(process: Optional[subprocess.Popen]):
                     process.kill()
                     process.wait(timeout=_TERMINATION_TIMEOUT)
             except Exception as popen_term_err:
-                print(f"Error during fallback Popen termination: {popen_term_err}")
+                logger.warning(f"Error during fallback Popen termination: {popen_term_err}")
         return
 
     if parent_ps_proc:
@@ -211,17 +228,17 @@ def terminate_ffmpeg_process(process: Optional[subprocess.Popen]):
             else:
                 _terminate_parent_process_unix(parent_ps_proc, original_pid)
         elif parent_ps_proc:
-            print(
+            logger.info(
                 f"Main FFmpeg process {parent_ps_proc.pid} exited, possibly during child termination or was already gone."
             )
     except psutil.NoSuchProcess:
-        print(
+        logger.info(
             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}")
+        logger.warning(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.")
+        raise FfmpegProcessError(f"FFmpeg process (PID: {original_pid}) could not be terminated.")
     else:
-        print(f"FFmpeg process (PID: {original_pid}) terminated.")
+        logger.info(f"FFmpeg process (PID: {original_pid}) terminated.")

{better_ffmpeg_progress-5.4.2 → better_ffmpeg_progress-6.0.0}/better_ffmpeg_progress/utils.py

@@ -2,9 +2,9 @@ import os
 import re
 import shutil
 import subprocess
+from collections import deque
 from pathlib import Path
 from typing import Dict, List, Optional
-import requests  # Added for URL validation
 
 from .exceptions import FfmpegCommandError
 
@@ -15,12 +15,56 @@ _BYTES_PER_MB = 1024 * 1024
 _MULTIPLIER = 1e-6
 
 
+# A protocol prefix such as "pipe:", "rtsp://" or "concat:". At least two characters are required
+# before the colon, so that a Windows drive letter (e.g. "C:\\video.mp4") is not matched.
+_PROTOCOL_RE = re.compile(r"^[a-zA-Z][a-zA-Z0-9+.-]+:")
+# A printf-style pattern used for image sequences, e.g. "img%03d.png".
+_SEQUENCE_PATTERN_RE = re.compile(r"%0?\d*d")
+
+
+def get_input_format(command: List[str], input_flag_pos: int) -> Optional[str]:
+    """
+    Returns the value of the "-f" option given for the first input (e.g. "lavfi" for
+    "-f lavfi -i testsrc2"), or None if no input format is specified.
+    """
+    input_format = None
+    args = command[1:input_flag_pos]
+    for i, arg in enumerate(args[:-1]):
+        if arg == "-f":
+            input_format = args[i + 1]
+    return input_format
+
+
 def is_lavfi_input(command: List[str], input_flag_pos: int) -> bool:
     """
-    Returns True if the input at input_flag_pos is preceded by "-f lavfi", meaning it is a
-    filtergraph (e.g. "testsrc2=duration=30") generated by FFmpeg rather than a file or URL.
+    Returns True if the first input's format is "lavfi", meaning it is a filtergraph
+    (e.g. "testsrc2=duration=30") generated by FFmpeg rather than a file or URL.
     """
-    return command[max(input_flag_pos - 2, 0) : input_flag_pos] == ["-f", "lavfi"]
+    return get_input_format(command, input_flag_pos) == "lavfi"
+
+
+def is_stdin_input(input_file: str) -> bool:
+    """Returns True if the input is read from standard input or a file descriptor."""
+    return input_file == "-" or input_file.startswith("pipe:")
+
+
+def is_protocol_input(input_file: str) -> bool:
+    """Returns True if the input uses a protocol, e.g. "https://...", "rtsp://..." or "pipe:0"."""
+    return bool(_PROTOCOL_RE.match(input_file))
+
+
+def is_local_file_input(command: List[str], input_flag_pos: int) -> bool:
+    """
+    Returns True if the first input is expected to be a path to an existing local file.
+    Inputs read from standard input, inputs with a protocol (e.g. a URL), and inputs with an
+    explicit format (e.g. "-f lavfi", "-f v4l2" or "-f concat") are not.
+    """
+    input_file = command[input_flag_pos + 1]
+    return not (
+        is_stdin_input(input_file)
+        or is_protocol_input(input_file)
+        or get_input_format(command, input_flag_pos) is not None
+    )
 
 
 def validate_ffmpeg_command(command: List[str]) -> None:
@@ -45,12 +89,7 @@ def validate_ffmpeg_command(command: List[str]) -> None:
             f"FFmpeg command must include the input flag '{_FFMPEG_INPUT_FLAG}'."
         )
 
-    try:
-        input_flag_pos = command.index(_FFMPEG_INPUT_FLAG)
-    except ValueError:
-        raise FfmpegCommandError(
-            f"Internal error: Input flag '{_FFMPEG_INPUT_FLAG}' not found after check."
-        )
+    input_flag_pos = command.index(_FFMPEG_INPUT_FLAG)
 
     input_file_idx = input_flag_pos + 1
     if input_file_idx >= len(command):
@@ -62,16 +101,13 @@ def validate_ffmpeg_command(command: List[str]) -> None:
             f"Input file path '{input_file}' looks like an option flag. Please check your command."
         )
 
-    # Validate input file/URL. lavfi inputs are generated by FFmpeg, so there is nothing to check.
-    if is_lavfi_input(command, input_flag_pos):
-        pass
-    elif input_file.startswith("http://") or input_file.startswith("https://"):
-        try:
-            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}")
-    elif not Path(input_file).exists():
+    # Validate the input. Only local file paths can be checked: inputs such as standard input,
+    # network streams, devices and lavfi filtergraphs are left for FFmpeg to validate.
+    if (
+        is_local_file_input(command, input_flag_pos)
+        and not Path(input_file).exists()
+        and not _SEQUENCE_PATTERN_RE.search(input_file)
+    ):
         raise FfmpegCommandError(f"Input file not found: {input_file}")
 
     if len(command) <= input_file_idx + 1:
@@ -80,7 +116,7 @@ def validate_ffmpeg_command(command: List[str]) -> None:
         )
 
     output_file_path_str = command[-1]
-    if output_file_path_str == input_file:
+    if output_file_path_str == input_file and is_local_file_input(command, input_flag_pos):
         raise FfmpegCommandError(
             "Output file path cannot be the same as the input file path in this command structure."
         )
@@ -282,3 +318,23 @@ def estimate_final_size_mb(
     if current_time_secs < min_secs or current_size_mb <= 0:
         return None
     return current_size_mb / current_time_secs * total_duration_secs
+
+
+def build_failure_message(log_file: object, max_lines: int = 5) -> str:
+    """
+    Returns the error message for a failed FFmpeg process, including the last lines of the
+    FFmpeg log when it was written to a file path.
+    """
+    message = f"FFmpeg process failed. Check '{log_file}' for details."
+    if not isinstance(log_file, Path):
+        return message
+
+    try:
+        with open(log_file, encoding="utf-8", errors="replace") as f:
+            tail = [line.rstrip() for line in deque(f, maxlen=max_lines) if line.strip()]
+    except OSError:
+        return message
+
+    if not tail:
+        return message
+    return message + " Last lines of the log:\n" + "\n".join(tail)

better_ffmpeg_progress-5.4.2/README.md → better_ffmpeg_progress-6.0.0/better_ffmpeg_progress.egg-info/PKG-INFO

@@ -1,3 +1,25 @@
+Metadata-Version: 2.4
+Name: better-ffmpeg-progress
+Version: 6.0.0
+Summary: Run FFmpeg & see percentage progress + ETA.
+Author-email: "GitHub.com/CrypticSignal" <theaudiophile@outlook.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/CrypticSignal/better-ffmpeg-progress
+Project-URL: Changelog, https://github.com/CrypticSignal/better-ffmpeg-progress/blob/main/CHANGELOG.md
+Keywords: ffmpeg,progress
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil
+Requires-Dist: rich
+Requires-Dist: tqdm
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
 <div align="center">
 
 # Better FFmpeg Progress
@@ -46,9 +68,8 @@ command = [
 ]
 
 try:
+    # Pass use_tqdm=True to use tqdm instead of Rich.
     process = FfmpegProcess(command)
-    # Uncomment this line to use tqdm instead of Rich.
-    # process.use_tqdm = True
 
     process.run()
 except FfmpegProcessError as e:
@@ -118,14 +139,50 @@ An instance of `FfmpegProcess` accepts the following optional arguments:
 * `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`.
+* `use_tqdm` — Use tqdm instead of Rich for the progress bar. Default: `False`.
+* `overwrite` — What to do if the output file already exists: `True` overwrites it, `False` raises `FfmpegCommandError`, and `None` asks whether to overwrite it. Ignored if the command contains `-y` or `-n`. 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`:
+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 passing `use_tqdm=True`:
 ```python
-process = FfmpegProcess(command)
-process.use_tqdm = True
+process = FfmpegProcess(command, use_tqdm=True)
 process.run()
-```
+```
+## Limitations
+- Progress is calculated from the duration of the first input (the first `-i`).
+- The last argument of the command is treated as the output file, e.g. when checking whether it already exists. With multiple outputs, only the last one is checked.
+
+## Development
+Install the package in editable mode with the test dependencies, then run the tests (FFmpeg and FFprobe must be installed):
+```bash
+pip install -e ".[test]"
+```
+```bash
+pytest
+```
+`test.py` is a standalone example that encodes a test pattern and shows the progress bar.
+
+## Publishing
+Update `__version__` in `better_ffmpeg_progress/__init__.py` and add an entry to `CHANGELOG.md`.
+
+One-time setup:
+```bash
+pip install --upgrade build twine pkginfo
+```
+
+Then, for each release:
+```bash
+rm -rf dist
+```
+```bash
+python -m build
+```
+```bash
+twine check dist/*
+```
+```bash
+twine upload dist/*
+```

{better_ffmpeg_progress-5.4.2 → better_ffmpeg_progress-6.0.0}/better_ffmpeg_progress.egg-info/SOURCES.txt

@@ -1,15 +1,18 @@
 LICENSE
 README.md
-setup.py
+pyproject.toml
 better_ffmpeg_progress/__init__.py
 better_ffmpeg_progress/better_ffmpeg_progress.py
 better_ffmpeg_progress/enums.py
 better_ffmpeg_progress/exceptions.py
 better_ffmpeg_progress/progress_bars.py
+better_ffmpeg_progress/py.typed
 better_ffmpeg_progress/terminate_process.py
 better_ffmpeg_progress/utils.py
 better_ffmpeg_progress.egg-info/PKG-INFO
 better_ffmpeg_progress.egg-info/SOURCES.txt
 better_ffmpeg_progress.egg-info/dependency_links.txt
 better_ffmpeg_progress.egg-info/requires.txt
-better_ffmpeg_progress.egg-info/top_level.txt
+better_ffmpeg_progress.egg-info/top_level.txt
+tests/test_ffmpeg_process.py
+tests/test_utils.py

{better_ffmpeg_progress-5.4.2 → better_ffmpeg_progress-6.0.0}/better_ffmpeg_progress.egg-info/requires.txt

@@ -1,4 +1,6 @@
 psutil
-requests
 rich
 tqdm
+
+[test]
+pytest

better_ffmpeg_progress-6.0.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "better-ffmpeg-progress"
+dynamic = ["version"]
+description = "Run FFmpeg & see percentage progress + ETA."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "GitHub.com/CrypticSignal", email = "theaudiophile@outlook.com" }]
+requires-python = ">=3.9"
+dependencies = ["psutil", "rich", "tqdm"]
+keywords = ["ffmpeg", "progress"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://github.com/CrypticSignal/better-ffmpeg-progress"
+Changelog = "https://github.com/CrypticSignal/better-ffmpeg-progress/blob/main/CHANGELOG.md"
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[tool.setuptools]
+packages = ["better_ffmpeg_progress"]
+
+[tool.setuptools.dynamic]
+version = { attr = "better_ffmpeg_progress.__version__" }
+
+[tool.setuptools.package-data]
+better_ffmpeg_progress = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

better_ffmpeg_progress-6.0.0/tests/test_ffmpeg_process.py

@@ -0,0 +1,152 @@
+import os
+import shutil
+import sys
+from pathlib import Path
+
+import pytest
+
+from better_ffmpeg_progress import (
+    FfmpegCommandError,
+    FfmpegProcess,
+    FfmpegProcessError,
+)
+
+pytestmark = pytest.mark.skipif(
+    shutil.which("ffmpeg") is None or shutil.which("ffprobe") is None,
+    reason="FFmpeg and FFprobe are required",
+)
+
+
+@pytest.fixture
+def input_file(tmp_path: Path) -> Path:
+    path = tmp_path / "input.mkv"
+    FfmpegProcess(
+        [
+            "ffmpeg",
+            "-f",
+            "lavfi",
+            "-i",
+            "testsrc2=duration=2:size=64x64:rate=10",
+            "-c:v",
+            "ffv1",
+            str(path),
+        ],
+        ffmpeg_log_file=os.devnull,
+        duration_override=2,
+    ).run()
+    return path
+
+
+@pytest.mark.parametrize("use_tqdm", [False, True])
+def test_run_succeeds(input_file: Path, tmp_path: Path, use_tqdm: bool):
+    output_file = tmp_path / "output.mkv"
+    log_file = tmp_path / "log.txt"
+    process = FfmpegProcess(
+        ["ffmpeg", "-i", str(input_file), "-c:v", "ffv1", str(output_file)],
+        ffmpeg_log_file=log_file,
+        use_tqdm=use_tqdm,
+    )
+    assert process._duration_secs == pytest.approx(2, abs=0.2)
+    process.run()
+    assert output_file.stat().st_size > 0
+    assert log_file.exists()
+
+
+def test_run_without_duration_does_not_hang(tmp_path: Path):
+    # Without a duration, the progress output must still be read, or FFmpeg blocks once the
+    # pipe's buffer is full. -stats_period makes FFmpeg write enough output to fill it.
+    process = FfmpegProcess(
+        [
+            "ffmpeg",
+            "-stats_period",
+            "0.001",
+            "-f",
+            "lavfi",
+            "-i",
+            "testsrc2=duration=20:size=32x32:rate=1000",
+            "-f",
+            "null",
+            "-",
+        ],
+        ffmpeg_log_file=tmp_path / "log.txt",
+    )
+    assert process._duration_secs is None
+    process.run()
+
+
+def test_failure_includes_log_tail(input_file: Path, tmp_path: Path):
+    process = FfmpegProcess(
+        ["ffmpeg", "-i", str(input_file), "-c:v", "no_such_encoder", str(tmp_path / "o.mkv")],
+        ffmpeg_log_file=tmp_path / "log.txt",
+    )
+    with pytest.raises(FfmpegProcessError, match="no_such_encoder"):
+        process.run()
+
+
+def test_missing_input_file(tmp_path: Path):
+    with pytest.raises(FfmpegCommandError, match="Input file not found"):
+        FfmpegProcess(["ffmpeg", "-i", str(tmp_path / "missing.mp4"), "out.mp4"])
+
+
+@pytest.mark.parametrize(
+    "input_args",
+    [
+        ["-i", "-"],
+        ["-i", "pipe:0"],
+        ["-f", "lavfi", "-i", "testsrc2"],
+        ["-i", "rtsp://127.0.0.1:1/stream"],
+    ],
+)
+def test_non_file_inputs_are_accepted(input_args, monkeypatch, tmp_path: Path):
+    monkeypatch.chdir(tmp_path)
+    process = FfmpegProcess(["ffmpeg"] + input_args + ["-f", "null", "-"], duration_override=1)
+    assert ":" not in process._ffmpeg_log_file.name
+
+
+def test_image_sequence_input_is_accepted(tmp_path: Path):
+    FfmpegProcess(
+        ["ffmpeg", "-i", str(tmp_path / "img%03d.png"), "-f", "null", "-"],
+        ffmpeg_log_file=os.devnull,
+        duration_override=1,
+    )
+
+
+def test_overwrite(input_file: Path, tmp_path: Path):
+    output_file = tmp_path / "output.mkv"
+    output_file.touch()
+    command = ["ffmpeg", "-i", str(input_file), str(output_file)]
+
+    with pytest.raises(FfmpegCommandError, match="already exists"):
+        FfmpegProcess(command, overwrite=False)
+
+    with pytest.raises(FfmpegCommandError, match="already exists"):
+        FfmpegProcess(command[:-1] + ["-n", str(output_file)])
+
+    process = FfmpegProcess(command, overwrite=True)
+    assert "-y" in process._ffmpeg_command
+
+    # -y in the command takes priority over overwrite=False.
+    FfmpegProcess(command[:-1] + ["-y", str(output_file)], overwrite=False)
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="Uses POSIX signals")
+def test_keyboard_interrupt_raises_and_does_not_kill_python(tmp_path: Path):
+    import signal
+    import threading
+
+    from better_ffmpeg_progress import FfmpegProcessInterruptedError
+
+    process = FfmpegProcess(
+        ["ffmpeg", "-re", "-f", "lavfi", "-i", "testsrc2=duration=30", "-f", "null", "-"],
+        ffmpeg_log_file=tmp_path / "log.txt",
+        duration_override=30,
+    )
+    timer = threading.Timer(1, lambda: os.kill(os.getpid(), signal.SIGINT))
+    timer.start()
+    try:
+        with pytest.raises(FfmpegProcessInterruptedError):
+            process.run()
+    finally:
+        timer.cancel()
+    assert process._process is not None
+    assert process._process.poll() is not None

better_ffmpeg_progress-6.0.0/tests/test_utils.py

@@ -0,0 +1,119 @@
+from pathlib import Path
+
+import pytest
+
+from better_ffmpeg_progress.utils import (
+    build_failure_message,
+    estimate_final_size_mb,
+    get_expected_output_duration,
+    get_input_format,
+    is_lavfi_input,
+    is_local_file_input,
+    parse_ffmpeg_progress_line,
+    parse_ffmpeg_time,
+    parse_ffmpeg_total_size_line,
+    truncate_filename,
+)
+
+
+@pytest.mark.parametrize(
+    "value, expected",
+    [
+        ("90", 90.0),
+        ("1.5", 1.5),
+        (".5", 0.5),
+        ("500ms", 0.5),
+        ("250000us", 0.25),
+        ("2s", 2.0),
+        ("01:30", 90.0),
+        ("00:01:30.5", 90.5),
+        ("-5", -5.0),
+        ("-00:00:10", -10.0),
+        (" 10 ", 10.0),
+        ("abc", None),
+        ("1:2:3:4", None),
+    ],
+)
+def test_parse_ffmpeg_time(value, expected):
+    assert parse_ffmpeg_time(value) == expected
+
+
+@pytest.mark.parametrize(
+    "args, expected",
+    [
+        ([], 100.0),
+        (["-ss", "10", "-i", "in.mp4", "out.mp4"], 90.0),
+        (["-i", "in.mp4", "-ss", "10", "out.mp4"], 90.0),
+        (["-i", "in.mp4", "-t", "30", "out.mp4"], 30.0),
+        (["-i", "in.mp4", "-to", "40", "out.mp4"], 40.0),
+        (["-ss", "10", "-to", "40", "-i", "in.mp4", "out.mp4"], 30.0),
+        (["-ss", "10", "-t", "20", "-to", "80", "-i", "in.mp4", "out.mp4"], 20.0),
+        (["-sseof", "-15", "-i", "in.mp4", "out.mp4"], 15.0),
+        (["-ss", "10", "-i", "in.mp4", "-t", "200", "out.mp4"], 90.0),
+        (["-ss", "10", "-copyts", "-i", "in.mp4", "out.mp4"], 100.0),
+        # A trim that leaves nothing falls back to the input duration.
+        (["-ss", "200", "-i", "in.mp4", "out.mp4"], 100.0),
+    ],
+)
+def test_get_expected_output_duration(args, expected):
+    command = ["ffmpeg"] + (args or ["-i", "in.mp4", "out.mp4"])
+    assert get_expected_output_duration(command, 100.0) == pytest.approx(expected)
+
+
+def test_parse_ffmpeg_progress_line():
+    assert parse_ffmpeg_progress_line(b"out_time_us=1500000", None) == pytest.approx(1.5)
+    assert parse_ffmpeg_progress_line(b"out_time_us=1500000", 1.0) == 1.0
+    assert parse_ffmpeg_progress_line(b"out_time_us=N/A", 10.0) is None
+    assert parse_ffmpeg_progress_line(b"out_time_us=", 10.0) is None
+    assert parse_ffmpeg_progress_line(b"frame=10", 10.0) is None
+
+
+def test_parse_ffmpeg_total_size_line():
+    assert parse_ffmpeg_total_size_line(b"total_size=1048576") == 1.0
+    assert parse_ffmpeg_total_size_line(b"total_size=N/A") is None
+    assert parse_ffmpeg_total_size_line(b"out_time_us=1") is None
+
+
+def test_truncate_filename():
+    assert truncate_filename("short.mp4", 60) == "short.mp4"
+    truncated = truncate_filename("a" * 100 + ".mp4", 20)
+    assert truncated == "a" * 13 + "....mp4"
+    assert len(truncated) == 20
+    assert len(truncate_filename("a" * 10 + "." + "b" * 30, 20)) == 20
+
+
+def test_estimate_final_size_mb():
+    assert estimate_final_size_mb(10.0, 0.5, 100.0) is None
+    assert estimate_final_size_mb(0.0, 50.0, 100.0) is None
+    assert estimate_final_size_mb(10.0, 50.0, 100.0) == pytest.approx(20.0)
+
+
+@pytest.mark.parametrize(
+    "args, expected_format, expected_local",
+    [
+        (["-i", "in.mp4"], None, True),
+        (["-i", "C:\\videos\\in.mp4"], None, True),
+        (["-f", "lavfi", "-i", "testsrc2"], "lavfi", False),
+        (["-f", "image2", "-pattern_type", "glob", "-i", "*.png"], "image2", False),
+        (["-i", "-"], None, False),
+        (["-i", "pipe:0"], None, False),
+        (["-i", "https://example.com/in.mp4"], None, False),
+        (["-i", "rtsp://example.com/stream"], None, False),
+    ],
+)
+def test_input_classification(args, expected_format, expected_local):
+    command = ["ffmpeg"] + args + ["out.mp4"]
+    input_flag_pos = command.index("-i")
+    assert get_input_format(command, input_flag_pos) == expected_format
+    assert is_lavfi_input(command, input_flag_pos) == (expected_format == "lavfi")
+    assert is_local_file_input(command, input_flag_pos) == expected_local
+
+
+def test_build_failure_message(tmp_path: Path):
+    log_file = tmp_path / "log.txt"
+    log_file.write_text("".join(f"line {i}\n" for i in range(10)), encoding="utf-8")
+    message = build_failure_message(log_file, max_lines=3)
+    assert message.endswith("line 7\nline 8\nline 9")
+
+    assert build_failure_message(tmp_path / "missing.txt").endswith("for details.")
+    assert build_failure_message(object()).endswith("for details.")

better_ffmpeg_progress-5.4.2/setup.py

@@ -1,24 +0,0 @@
-import setuptools
-
-with open("README.md", "r", encoding="utf-8") as f:
-    long_description = f.read()
-
-setuptools.setup(
-    name="better-ffmpeg-progress",
-    version="5.4.2",
-    author="GitHub.com/CrypticSignal",
-    author_email="theaudiophile@outlook.com",
-    description="Run FFmpeg & see percentage progress + ETA.",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/CrypticSignal/better-ffmpeg-progress",
-    packages=["better_ffmpeg_progress"],
-    install_requires=["psutil", "requests", "rich", "tqdm"],
-    python_requires=">=3.7",
-    keywords=["ffmpeg", "progress"],
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-    ],
-)