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

{better_ffmpeg_progress-5.2.0 → better_ffmpeg_progress-5.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: better-ffmpeg-progress
-Version: 5.2.0
+Version: 5.3.0
 Summary: Run FFmpeg & see percentage progress + ETA.
 Home-page: https://github.com/CrypticSignal/better-ffmpeg-progress
 Author: GitHub.com/CrypticSignal
@@ -18,10 +18,6 @@ Requires-Dist: rich
 Requires-Dist: tqdm
 
 <div align="center">
-[![PyPI downloads](https://img.shields.io/pypi/dm/better-ffmpeg-progress?label=PyPI\&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
-[![PyPI downloads](https://img.shields.io/pypi/dd/better-ffmpeg-progress?label=PyPI\&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
-![PyPI - Version](https://img.shields.io/pypi/v/better-ffmpeg-progress)
-[![GitHub](https://img.shields.io/github/license/crypticsignal/better-ffmpeg-progress?label=License\&color=blue)](LICENSE.txt)
 
 # Better FFmpeg Progress
 Runs an FFmpeg command and shows a progress bar with percentage progress, elapsed time and ETA.
@@ -33,10 +29,11 @@ frame=  692 fps= 58 q=28.0 size=    5376KiB time=00:00:28.77 bitrate=1530.3kbits
 ```
 Better FFmpeg Progress outputs something like:
 ```
-⠏ Processing abc.webm ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
+⠏ Processing abc.webm (5.50 MB / ~23.91 MB) ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
 ```
 Where:
-- `Processing abc.webm` is the description of the progresss bar.
+- `Processing abc.webm` is the description of the progresss bar. Filenames longer than 60 characters are truncated.
+- `(5.50 MB / ~23.91 MB)` is the current output size and the estimated final output size.
 - `23%` is the percentage progress.
 - `0:00:04` is the time elapsed.
 - `00:15` is the estimated time until the FFmpeg process completes.
@@ -80,6 +77,9 @@ except FfmpegProcessError as e:
     )
 ```
 
+## Trimming
+If your command trims the input with `-ss`, `-sseof`, `-t` or `-to` (as input or output options), the expected duration of the output is calculated automatically, so the progress bar and ETA reflect the trimmed output rather than the whole input file. This adjustment is skipped when `-copyts` is used.
+
 ## Duration Override
 By default, Better FFmpeg Progress detects the duration of the input file and uses it to calculate percentage progress and ETA.
 

{better_ffmpeg_progress-5.2.0 → better_ffmpeg_progress-5.3.0}/README.md

@@ -1,8 +1,4 @@
 <div align="center">
-[![PyPI downloads](https://img.shields.io/pypi/dm/better-ffmpeg-progress?label=PyPI\&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
-[![PyPI downloads](https://img.shields.io/pypi/dd/better-ffmpeg-progress?label=PyPI\&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
-![PyPI - Version](https://img.shields.io/pypi/v/better-ffmpeg-progress)
-[![GitHub](https://img.shields.io/github/license/crypticsignal/better-ffmpeg-progress?label=License\&color=blue)](LICENSE.txt)
 
 # Better FFmpeg Progress
 Runs an FFmpeg command and shows a progress bar with percentage progress, elapsed time and ETA.
@@ -14,10 +10,11 @@ frame=  692 fps= 58 q=28.0 size=    5376KiB time=00:00:28.77 bitrate=1530.3kbits
 ```
 Better FFmpeg Progress outputs something like:
 ```
-⠏ Processing abc.webm ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
+⠏ Processing abc.webm (5.50 MB / ~23.91 MB) ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
 ```
 Where:
-- `Processing abc.webm` is the description of the progresss bar.
+- `Processing abc.webm` is the description of the progresss bar. Filenames longer than 60 characters are truncated.
+- `(5.50 MB / ~23.91 MB)` is the current output size and the estimated final output size.
 - `23%` is the percentage progress.
 - `0:00:04` is the time elapsed.
 - `00:15` is the estimated time until the FFmpeg process completes.
@@ -61,6 +58,9 @@ except FfmpegProcessError as e:
     )
 ```
 
+## Trimming
+If your command trims the input with `-ss`, `-sseof`, `-t` or `-to` (as input or output options), the expected duration of the output is calculated automatically, so the progress bar and ETA reflect the trimmed output rather than the whole input file. This adjustment is skipped when `-copyts` is used.
+
 ## Duration Override
 By default, Better FFmpeg Progress detects the duration of the input file and uses it to calculate percentage progress and ETA.
 

{better_ffmpeg_progress-5.2.0 → better_ffmpeg_progress-5.3.0}/better_ffmpeg_progress/better_ffmpeg_progress.py

@@ -15,6 +15,7 @@ from .exceptions import (
 from .utils import (
     validate_ffmpeg_command,
     get_media_duration,
+    get_expected_output_duration,
     check_shell_needed_for_command,
 )
 from .terminate_process import terminate_ffmpeg_process
@@ -135,13 +136,27 @@ class FfmpegProcess:
         else:
             self._duration_secs = get_media_duration(input_file_path_str)
 
+        input_duration_secs = self._duration_secs
+
+        # Account for trimming (-ss, -sseof, -t, -to) so the progress bar reflects the
+        # duration of the output rather than the whole input.
+        if self._duration_secs is not None:
+            self._duration_secs = get_expected_output_duration(command, self._duration_secs)
+
         if duration_override is not None:
-            print(f"Using duration override: {self._duration_secs:.2f} seconds")
+            print(f"Using duration override: {input_duration_secs:.2f} seconds")
         elif self._print_detected_duration:
             if self._duration_secs is None:
                 print("Could not detect duration. Progress bar may not show time remaining.")
             else:
-                print(f"Detected duration: {self._duration_secs:.2f} seconds")
+                print(f"Detected duration: {input_duration_secs:.2f} seconds")
+
+        if (
+            self._duration_secs is not None
+            and self._duration_secs != input_duration_secs
+            and (duration_override is not None or self._print_detected_duration)
+        ):
+            print(f"Expected output duration after trimming: {self._duration_secs:.2f} seconds")
 
         self._ffmpeg_command = [
             command[0],

{better_ffmpeg_progress-5.2.0 → better_ffmpeg_progress-5.3.0}/better_ffmpeg_progress/progress_bars.py

@@ -1,6 +1,6 @@
 import os
 import subprocess
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from rich.progress import (
     Progress,
@@ -12,12 +12,24 @@ from rich.progress import (
 )
 from tqdm import tqdm
 
-from .utils import parse_ffmpeg_progress_line
+from .utils import (
+    estimate_final_size_mb,
+    parse_ffmpeg_progress_line,
+    parse_ffmpeg_total_size_line,
+    truncate_filename,
+)
 from .exceptions import FfmpegProcessError
 
 if TYPE_CHECKING:
     from .better_ffmpeg_progress import FfmpegProcess
 
+_MAX_FILENAME_LENGTH = 60
+
+
+def _format_size(current_size_mb: float, estimated_size_mb: Optional[float]) -> str:
+    estimate = f"~{estimated_size_mb:.2f} MB" if estimated_size_mb is not None else "~? MB"
+    return f"({current_size_mb:.2f} MB / {estimate})"
+
 
 def use_rich(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen) -> None:
     task_id = None
@@ -31,11 +43,14 @@ def use_rich(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
     )
 
     duration_secs = ffmpeg_process_instance._duration_secs
-    input_filename = ffmpeg_process_instance._input_filepath.name
+    input_filename = truncate_filename(
+        ffmpeg_process_instance._input_filepath.name, _MAX_FILENAME_LENGTH
+    )
     log_file = ffmpeg_process_instance._ffmpeg_log_file
 
     with progress_bar_instance as progress_bar:
         if duration_secs:
+            current_size_mb = 0.0
             task_id = progress_bar.add_task(
                 f"Processing {input_filename}",
                 total=duration_secs,
@@ -44,9 +59,25 @@ def use_rich(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
 
             for line_bytes in process.stdout:
                 stripped_line_bytes = line_bytes.strip()
+
+                size_mb = parse_ffmpeg_total_size_line(stripped_line_bytes)
+                if size_mb is not None:
+                    current_size_mb = size_mb
+                    continue
+
+                # FFmpeg writes total_size before out_time_us in each progress block,
+                # so updating here refreshes the bar once per block with the latest size.
                 progress_val_secs = parse_ffmpeg_progress_line(stripped_line_bytes, duration_secs)
                 if progress_val_secs is not None and task_id is not None:
-                    update_progress(task_id, completed=progress_val_secs)
+                    estimated_size_mb = estimate_final_size_mb(
+                        current_size_mb, progress_val_secs, duration_secs
+                    )
+                    update_progress(
+                        task_id,
+                        completed=progress_val_secs,
+                        description=f"Processing {input_filename} "
+                        f"{_format_size(current_size_mb, estimated_size_mb)}",
+                    )
         else:
             print(f"Processing '{input_filename}'...")
 
@@ -62,7 +93,7 @@ def use_rich(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
                 )
                 update_progress(
                     task_id,
-                    description=f"✓ Processed '{input_filename}'",
+                    description=f"✓ Processed '{input_filename}' ({current_size_mb:.2f} MB)",
                 )
         else:
             if task_id is not None:
@@ -79,9 +110,13 @@ def use_tqdm(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
         width = 80
 
     duration_secs = ffmpeg_process_instance._duration_secs
-    input_filename = ffmpeg_process_instance._input_filepath.name
+    input_filename = truncate_filename(
+        ffmpeg_process_instance._input_filepath.name, _MAX_FILENAME_LENGTH
+    )
     log_file = ffmpeg_process_instance._ffmpeg_log_file
 
+    current_size_mb = 0.0
+
     if duration_secs:
         progress_bar = tqdm(
             mininterval=0.5,
@@ -94,10 +129,20 @@ def use_tqdm(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
 
         for line_bytes in process.stdout:
             stripped_line_bytes = line_bytes.strip()
+
+            size_mb = parse_ffmpeg_total_size_line(stripped_line_bytes)
+            if size_mb is not None:
+                current_size_mb = size_mb
+                continue
+
             progress_val_secs = parse_ffmpeg_progress_line(stripped_line_bytes, duration_secs)
             if progress_val_secs is not None and progress_bar is not None:
+                estimated_size_mb = estimate_final_size_mb(
+                    current_size_mb, progress_val_secs, duration_secs
+                )
                 progress_bar.n = progress_val_secs
-                progress_bar.refresh()
+                # set_postfix_str refreshes the bar by default
+                progress_bar.set_postfix_str(_format_size(current_size_mb, estimated_size_mb))
     else:
         print(f"Processing '{input_filename}'...")
 
@@ -107,6 +152,7 @@ def use_tqdm(ffmpeg_process_instance: "FfmpegProcess", process: subprocess.Popen
         if progress_bar:
             progress_bar.n = duration_secs
             progress_bar.set_description(f"✓ Processed '{input_filename}'")
+            progress_bar.set_postfix_str(f"{current_size_mb:.2f} MB")
             progress_bar.close()
         else:
             print(f"✓ Processed '{input_filename}'")

better_ffmpeg_progress-5.3.0/better_ffmpeg_progress/utils.py

@@ -0,0 +1,284 @@
+import os
+import re
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Dict, List, Optional
+import requests  # Added for URL validation
+
+from .exceptions import FfmpegCommandError
+
+_FFMPEG_INPUT_FLAG = "-i"
+_OUT_TIME_US_PREFIX = b"out_time_us="
+_TOTAL_SIZE_PREFIX = b"total_size="
+_BYTES_PER_MB = 1024 * 1024
+_MULTIPLIER = 1e-6
+
+
+def validate_ffmpeg_command(command: List[str]) -> None:
+    """
+    Validates the FFmpeg command.
+    Raises FfmpegCommandError if validation fails.
+    """
+    if not command:
+        raise FfmpegCommandError("FFmpeg command list cannot be empty.")
+
+    ffmpeg_executable = command[0]
+    if not shutil.which(ffmpeg_executable):
+        err_msg = (
+            f"'{ffmpeg_executable}' not found. "
+            "Ensure it's in your system's PATH or provide the full path of the FFmpeg executable."
+        )
+
+        raise FfmpegCommandError(err_msg)
+
+    if _FFMPEG_INPUT_FLAG not in command:
+        raise FfmpegCommandError(
+            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_file_idx = input_flag_pos + 1
+    if input_file_idx >= len(command):
+        raise FfmpegCommandError(f"No input file specified after '{_FFMPEG_INPUT_FLAG}'.")
+
+    input_file = command[input_file_idx]
+    if input_file.startswith("-") and len(input_file) == 2 and not input_file[1:].isdigit():
+        raise FfmpegCommandError(
+            f"Input file path '{input_file}' looks like an option flag. Please check your command."
+        )
+
+    # Validate input file/URL
+    if 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():
+        raise FfmpegCommandError(f"Input file not found: {input_file}")
+
+    if len(command) <= input_file_idx + 1:
+        raise FfmpegCommandError(
+            "No output file specified. The command seems to end after the input file path."
+        )
+
+    output_file_path_str = command[-1]
+    if output_file_path_str == input_file:
+        raise FfmpegCommandError(
+            "Output file path cannot be the same as the input file path in this command structure."
+        )
+
+
+def get_media_duration(input_file: str) -> Optional[float]:
+    """
+    Retrieves the duration of a media file or URL using ffprobe.
+    Returns duration in seconds, or None if it cannot be determined.
+    Accepts input_file as a string to correctly handle URLs.
+    """
+    if not shutil.which("ffprobe"):
+        print("Warning: ffprobe not found in PATH. Cannot determine media duration.")
+        return None
+    try:
+        output = subprocess.check_output(
+            [
+                "ffprobe",
+                "-v",
+                "error",
+                "-show_entries",
+                "format=duration",
+                "-of",
+                "default=noprint_wrappers=1:nokey=1",
+                "-i",
+                input_file,
+            ],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+        return float(output)
+    except (subprocess.CalledProcessError, ValueError, FileNotFoundError):
+        print(f"Warning: Could not determine duration for '{input_file}'.")
+        return None
+
+
+def check_shell_needed_for_command(command: List[str]) -> bool:
+    """
+    Checks if any part of the command contains shell operators,
+    indicating that shell=True might be needed for subprocess.Popen.
+    This is a basic check and might not cover all edge cases.
+    """
+    shell_operators = {"|", ">", "<", ">>", "&&", "||"}  # Basic set
+    return any(op in item for item in command for op in shell_operators)
+
+
+def parse_ffmpeg_progress_line(
+    line: bytes, total_duration_secs: Optional[float]
+) -> Optional[float]:
+    """
+    Parses a progress line from FFmpeg's stdout.
+    Example line: b"out_time_us=12345678"
+    Returns the current progress time in seconds, or None if parsing fails or line is not a progress line.
+    Caps progress at total_duration_secs if provided.
+    Assumes `line` has already been stripped of leading/trailing whitespace.
+    """
+    if line.startswith(_OUT_TIME_US_PREFIX):
+        try:
+            # Get the value after out_time_us=
+            value_str = line[len(_OUT_TIME_US_PREFIX) :]
+
+            if not value_str:
+                return None
+
+            current_time_us = int(value_str)
+            current_time_secs = current_time_us * _MULTIPLIER
+
+            if total_duration_secs is not None:
+                return min(current_time_secs, total_duration_secs)
+            return current_time_secs
+        except (ValueError, IndexError):
+            return None
+
+    return None
+
+
+# Matches FFmpeg's time duration syntax: [-][HH:]MM:SS[.m...] or [-]S+[.m...][s|ms|us]
+_SEXAGESIMAL_RE = re.compile(r"^(-)?(?:(\d+):)?(\d+):(\d+(?:\.\d*)?)$")
+_SECONDS_RE = re.compile(r"^(-)?(\d+(?:\.\d*)?|\.\d+)(s|ms|us)?$")
+_TRIM_OPTIONS = ("-ss", "-sseof", "-t", "-to")
+
+
+def parse_ffmpeg_time(value: str) -> Optional[float]:
+    """
+    Parses a time duration in FFmpeg's syntax (e.g. "90", "1.5", "500ms", "01:30", "00:01:30.5").
+    Returns the value in seconds, or None if it cannot be parsed.
+    """
+    value = value.strip()
+
+    match = _SEXAGESIMAL_RE.match(value)
+    if match:
+        sign, hours, minutes, seconds = match.groups()
+        total = int(hours or 0) * 3600 + int(minutes) * 60 + float(seconds)
+        return -total if sign else total
+
+    match = _SECONDS_RE.match(value)
+    if match:
+        sign, number, unit = match.groups()
+        total = float(number) / {None: 1, "s": 1, "ms": 1e3, "us": 1e6}[unit]
+        return -total if sign else total
+
+    return None
+
+
+def _collect_trim_options(args: List[str]) -> Dict[str, float]:
+    """Returns the last value of each trim option found in args (FFmpeg uses the last occurrence)."""
+    options: Dict[str, float] = {}
+    for i, arg in enumerate(args[:-1]):
+        if arg in _TRIM_OPTIONS:
+            parsed = parse_ffmpeg_time(args[i + 1])
+            if parsed is not None:
+                options[arg] = parsed
+    return options
+
+
+def _apply_trim(duration: float, options: Dict[str, float]) -> float:
+    """
+    Applies -ss/-sseof/-t/-to to a duration, mirroring FFmpeg's logic:
+    -t takes priority over -to, and -to is relative to -ss (recording_time = to - ss).
+    """
+    start = options.get("-ss", 0.0)
+
+    if "-sseof" in options and "-ss" not in options:
+        # -sseof is negative, relative to the end of the input
+        remaining = min(duration, abs(options["-sseof"]))
+    else:
+        remaining = duration - max(start, 0.0)
+
+    if "-t" in options:
+        remaining = min(remaining, options["-t"])
+    elif "-to" in options:
+        remaining = min(remaining, options["-to"] - max(start, 0.0))
+
+    return max(remaining, 0.0)
+
+
+def get_expected_output_duration(command: List[str], input_duration: float) -> float:
+    """
+    Estimates the duration of the output by taking the trim options of the command into account.
+
+    Options before the first "-i" are input options for the first input, and options between the
+    last input path and the output path are output options. Input trimming is applied first
+    (seeking with an input -ss resets timestamps to 0), then output trimming.
+
+    If -copyts is used, timestamps are not reset, so no adjustment is made.
+    """
+    if "-copyts" in command:
+        return input_duration
+
+    first_input_idx = command.index(_FFMPEG_INPUT_FLAG)
+    last_input_idx = len(command) - 1 - command[::-1].index(_FFMPEG_INPUT_FLAG)
+
+    input_options = _collect_trim_options(command[1:first_input_idx])
+    output_options = _collect_trim_options(command[last_input_idx + 2 : -1])
+
+    duration = _apply_trim(input_duration, input_options)
+    duration = _apply_trim(duration, output_options)
+
+    # Never return 0, which would disable the progress bar.
+    return duration if duration > 0 else input_duration
+
+
+def parse_ffmpeg_total_size_line(line: bytes) -> Optional[float]:
+    """
+    Parses a total_size line from FFmpeg's stdout.
+    Example line: b"total_size=12345678"
+    Returns the current output size in MB, or None if parsing fails or line is not a total_size line.
+    Assumes `line` has already been stripped of leading/trailing whitespace.
+    """
+    if line.startswith(_TOTAL_SIZE_PREFIX):
+        try:
+            value_str = line[len(_TOTAL_SIZE_PREFIX) :]
+
+            if not value_str:
+                return None
+
+            return int(value_str) / _BYTES_PER_MB
+        except ValueError:
+            return None
+
+    return None
+
+
+def truncate_filename(filename: str, max_length: int = 60) -> str:
+    """
+    Truncates a filename to at most max_length characters, preserving the file extension.
+    """
+    if len(filename) <= max_length:
+        return filename
+
+    stem, ext = os.path.splitext(filename)
+    ellipsis = "..."
+    allowed_stem_len = max_length - len(ext) - len(ellipsis)
+
+    if allowed_stem_len < 1:
+        return filename[: max_length - len(ellipsis)] + ellipsis
+
+    return f"{stem[:allowed_stem_len]}{ellipsis}{ext}"
+
+
+def estimate_final_size_mb(
+    current_size_mb: float, current_time_secs: float, total_duration_secs: float
+) -> Optional[float]:
+    """
+    Estimates the final output size in MB by extrapolating the current size over the total duration.
+    Returns None until enough of the input has been processed for the estimate to be meaningful.
+    """
+    min_secs = max(1.0, total_duration_secs * 0.01)
+    if current_time_secs < min_secs or current_size_mb <= 0:
+        return None
+    return current_size_mb / current_time_secs * total_duration_secs

{better_ffmpeg_progress-5.2.0 → better_ffmpeg_progress-5.3.0}/better_ffmpeg_progress.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: better-ffmpeg-progress
-Version: 5.2.0
+Version: 5.3.0
 Summary: Run FFmpeg & see percentage progress + ETA.
 Home-page: https://github.com/CrypticSignal/better-ffmpeg-progress
 Author: GitHub.com/CrypticSignal
@@ -18,10 +18,6 @@ Requires-Dist: rich
 Requires-Dist: tqdm
 
 <div align="center">
-[![PyPI downloads](https://img.shields.io/pypi/dm/better-ffmpeg-progress?label=PyPI\&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
-[![PyPI downloads](https://img.shields.io/pypi/dd/better-ffmpeg-progress?label=PyPI\&color=blue)](https://pypistats.org/packages/better-ffmpeg-progress)
-![PyPI - Version](https://img.shields.io/pypi/v/better-ffmpeg-progress)
-[![GitHub](https://img.shields.io/github/license/crypticsignal/better-ffmpeg-progress?label=License\&color=blue)](LICENSE.txt)
 
 # Better FFmpeg Progress
 Runs an FFmpeg command and shows a progress bar with percentage progress, elapsed time and ETA.
@@ -33,10 +29,11 @@ frame=  692 fps= 58 q=28.0 size=    5376KiB time=00:00:28.77 bitrate=1530.3kbits
 ```
 Better FFmpeg Progress outputs something like:
 ```
-⠏ Processing abc.webm ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
+⠏ Processing abc.webm (5.50 MB / ~23.91 MB) ━━━━━━━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  23% 0:00:04 00:15
 ```
 Where:
-- `Processing abc.webm` is the description of the progresss bar.
+- `Processing abc.webm` is the description of the progresss bar. Filenames longer than 60 characters are truncated.
+- `(5.50 MB / ~23.91 MB)` is the current output size and the estimated final output size.
 - `23%` is the percentage progress.
 - `0:00:04` is the time elapsed.
 - `00:15` is the estimated time until the FFmpeg process completes.
@@ -80,6 +77,9 @@ except FfmpegProcessError as e:
     )
 ```
 
+## Trimming
+If your command trims the input with `-ss`, `-sseof`, `-t` or `-to` (as input or output options), the expected duration of the output is calculated automatically, so the progress bar and ETA reflect the trimmed output rather than the whole input file. This adjustment is skipped when `-copyts` is used.
+
 ## Duration Override
 By default, Better FFmpeg Progress detects the duration of the input file and uses it to calculate percentage progress and ETA.
 

{better_ffmpeg_progress-5.2.0 → better_ffmpeg_progress-5.3.0}/setup.py

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

better_ffmpeg_progress-5.2.0/better_ffmpeg_progress/utils.py

@@ -1,143 +0,0 @@
-import shutil
-import subprocess
-from pathlib import Path
-from typing import List, Optional
-import requests  # Added for URL validation
-
-from .exceptions import FfmpegCommandError
-
-_FFMPEG_INPUT_FLAG = "-i"
-_OUT_TIME_US_PREFIX = b"out_time_us="
-_MULTIPLIER = 1e-6
-
-
-def validate_ffmpeg_command(command: List[str]) -> None:
-    """
-    Validates the FFmpeg command.
-    Raises FfmpegCommandError if validation fails.
-    """
-    if not command:
-        raise FfmpegCommandError("FFmpeg command list cannot be empty.")
-
-    ffmpeg_executable = command[0]
-    if not shutil.which(ffmpeg_executable):
-        err_msg = (
-            f"'{ffmpeg_executable}' not found. "
-            "Ensure it's in your system's PATH or provide the full path of the FFmpeg executable."
-        )
-
-        raise FfmpegCommandError(err_msg)
-
-    if _FFMPEG_INPUT_FLAG not in command:
-        raise FfmpegCommandError(
-            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_file_idx = input_flag_pos + 1
-    if input_file_idx >= len(command):
-        raise FfmpegCommandError(f"No input file specified after '{_FFMPEG_INPUT_FLAG}'.")
-
-    input_file = command[input_file_idx]
-    if input_file.startswith("-") and len(input_file) == 2 and not input_file[1:].isdigit():
-        raise FfmpegCommandError(
-            f"Input file path '{input_file}' looks like an option flag. Please check your command."
-        )
-
-    # Validate input file/URL
-    if 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():
-        raise FfmpegCommandError(f"Input file not found: {input_file}")
-
-    if len(command) <= input_file_idx + 1:
-        raise FfmpegCommandError(
-            "No output file specified. The command seems to end after the input file path."
-        )
-
-    output_file_path_str = command[-1]
-    if output_file_path_str == input_file:
-        raise FfmpegCommandError(
-            "Output file path cannot be the same as the input file path in this command structure."
-        )
-
-
-def get_media_duration(input_file: str) -> Optional[float]:
-    """
-    Retrieves the duration of a media file or URL using ffprobe.
-    Returns duration in seconds, or None if it cannot be determined.
-    Accepts input_file as a string to correctly handle URLs.
-    """
-    if not shutil.which("ffprobe"):
-        print("Warning: ffprobe not found in PATH. Cannot determine media duration.")
-        return None
-    try:
-        output = subprocess.check_output(
-            [
-                "ffprobe",
-                "-v",
-                "error",
-                "-show_entries",
-                "format=duration",
-                "-of",
-                "default=noprint_wrappers=1:nokey=1",
-                "-i",
-                input_file,
-            ],
-            text=True,
-            stderr=subprocess.DEVNULL,
-        )
-        return float(output)
-    except (subprocess.CalledProcessError, ValueError, FileNotFoundError):
-        print(f"Warning: Could not determine duration for '{input_file}'.")
-        return None
-
-
-def check_shell_needed_for_command(command: List[str]) -> bool:
-    """
-    Checks if any part of the command contains shell operators,
-    indicating that shell=True might be needed for subprocess.Popen.
-    This is a basic check and might not cover all edge cases.
-    """
-    shell_operators = {"|", ">", "<", ">>", "&&", "||"}  # Basic set
-    return any(op in item for item in command for op in shell_operators)
-
-
-def parse_ffmpeg_progress_line(
-    line: bytes, total_duration_secs: Optional[float]
-) -> Optional[float]:
-    """
-    Parses a progress line from FFmpeg's stdout.
-    Example line: b"out_time_us=12345678"
-    Returns the current progress time in seconds, or None if parsing fails or line is not a progress line.
-    Caps progress at total_duration_secs if provided.
-    Assumes `line` has already been stripped of leading/trailing whitespace.
-    """
-    if line.startswith(_OUT_TIME_US_PREFIX):
-        try:
-            # Get the value after out_time_us=
-            value_str = line[len(_OUT_TIME_US_PREFIX) :]
-
-            if not value_str:
-                return None
-
-            current_time_us = int(value_str)
-            current_time_secs = current_time_us * _MULTIPLIER
-
-            if total_duration_secs is not None:
-                return min(current_time_secs, total_duration_secs)
-            return current_time_secs
-        except (ValueError, IndexError):
-            return None
-
-    return None