Repository navigation
Expand file tree
/
Copy pathprogress.py
More file actions
114 lines (91 loc) · 2.97 KB
/
Copy pathprogress.py
File metadata and controls
114 lines (91 loc) · 2.97 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
"""Parsing for FFmpeg's machine-readable progress protocol."""
from __future__ import annotations
from dataclasses import dataclass
from datetime import timedelta
@dataclass(frozen=True, slots=True)
class Progress:
"""One complete progress record emitted by FFmpeg."""
frame: int | None
fps: float | None
output_time: timedelta | None
total_size: int | None
speed: float | None
percent: float | None
state: str
raw: tuple[tuple[str, str], ...]
class ProgressParser:
"""Collect protocol lines until FFmpeg completes a record."""
def __init__(self, expected_duration: float | None = None) -> None:
self._expected_duration = expected_duration
self._values: dict[str, str] = {}
def feed_line(self, line: str) -> Progress | None:
"""Consume one line and return a completed progress record."""
text = line.strip()
if not text or "=" not in text:
return None
key, value = text.split("=", 1)
self._values[key] = value
if key != "progress":
return None
values = self._values
self._values = {}
return _build_progress(values, self._expected_duration)
def _build_progress(
values: dict[str, str], expected_duration: float | None
) -> Progress:
output_time = _output_time(values)
percent = None
if (
output_time is not None
and expected_duration is not None
and expected_duration > 0
):
percent = min(
100.0,
max(0.0, output_time.total_seconds() / expected_duration * 100),
)
return Progress(
frame=_integer(values.get("frame")),
fps=_number(values.get("fps")),
output_time=output_time,
total_size=_integer(values.get("total_size")),
speed=_speed(values.get("speed")),
percent=percent,
state=values["progress"],
raw=tuple(values.items()),
)
def _output_time(values: dict[str, str]) -> timedelta | None:
microseconds = _integer(values.get("out_time_us"))
if microseconds is not None:
return timedelta(microseconds=microseconds)
text = values.get("out_time")
if text is None:
return None
pieces = text.split(":")
if len(pieces) != 3:
return None
try:
hours = int(pieces[0])
minutes = int(pieces[1])
seconds = float(pieces[2])
except ValueError:
return None
return timedelta(hours=hours, minutes=minutes, seconds=seconds)
def _integer(value: str | None) -> int | None:
if value is None or value == "N/A":
return None
try:
return int(value)
except ValueError:
return None
def _number(value: str | None) -> float | None:
if value is None or value == "N/A":
return None
try:
return float(value)
except ValueError:
return None
def _speed(value: str | None) -> float | None:
if value is None:
return None
return _number(value.removesuffix("x"))