auto-editor 26.3.3__py3-none-any.whl → 27.1.0__py3-none-any.whl

auto_editor/__init__.py

@@ -1 +1 @@
-__version__ = "26.3.3"
+__version__ = "27.1.0"

auto_editor/__main__.py

@@ -75,7 +75,9 @@ class Args:
 
     # Audio Rendering
     audio_codec: str = "auto"
+    audio_layout: str | None = None
     audio_bitrate: str = "auto"
+    mix_audio_streams: bool = False
     keep_tracks_separate: bool = False
     audio_normalize: str = "#f"
 
@@ -335,16 +337,26 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         metavar="ENCODER",
         help="Set audio codec for output media",
     )
+    parser.add_argument(
+        "--audio-layout",
+        "-channel-layout",
+        "-layout",
+        metavar="LAYOUT",
+        help="Set the audio layout for the output media/timeline",
+    )
     parser.add_argument(
         "--audio-bitrate",
         "-b:a",
         metavar="BITRATE",
         help="Set the number of bits per second for audio",
     )
+    parser.add_argument(
+        "--mix-audio-streams", flag=True, help="Mix all audio streams together into one"
+    )
     parser.add_argument(
         "--keep-tracks-separate",
         flag=True,
-        help="Don't mix all audio tracks into one when exporting",
+        help="Don't mix all audio streams into one when exporting (default)",
     )
     parser.add_argument(
         "--audio-normalize",
@@ -448,15 +460,15 @@ def main() -> None:
     if args.debug and not args.input:
         buf = StringIO()
         buf.write(f"OS: {plat.system()} {plat.release()} {plat.machine().lower()}\n")
-        buf.write(f"Python: {plat.python_version()}\nPyAV: ")
+        buf.write(f"Python: {plat.python_version()}\nAV: ")
         try:
-            import av
+            import bv
         except (ModuleNotFoundError, ImportError):
             buf.write("not found")
         else:
             try:
-                buf.write(f"{av.__version__} ")
-                license = av._core.library_meta["libavcodec"]["license"]
+                buf.write(f"{bv.__version__} ")
+                license = bv._core.library_meta["libavcodec"]["license"]
                 buf.write(f"({license})")
             except AttributeError:
                 buf.write("error")

auto_editor/analyze.py

@@ -9,10 +9,10 @@ from math import ceil
 from tempfile import gettempdir
 from typing import TYPE_CHECKING
 
-import av
+import bv
 import numpy as np
-from av.audio.fifo import AudioFifo
-from av.subtitles.subtitle import AssSubtitle
+from bv.audio.fifo import AudioFifo
+from bv.subtitles.subtitle import AssSubtitle
 
 from auto_editor import __version__
 
@@ -72,7 +72,7 @@ def mut_remove_large(
             active = False
 
 
-def iter_audio(audio_stream: av.AudioStream, tb: Fraction) -> Iterator[np.float32]:
+def iter_audio(audio_stream: bv.AudioStream, tb: Fraction) -> Iterator[np.float32]:
     fifo = AudioFifo()
     sr = audio_stream.rate
 
@@ -80,10 +80,10 @@ def iter_audio(audio_stream: av.AudioStream, tb: Fraction) -> Iterator[np.float3
     accumulated_error = Fraction(0)
 
     # Resample so that audio data is between [-1, 1]
-    resampler = av.AudioResampler(av.AudioFormat("flt"), audio_stream.layout, sr)
+    resampler = bv.AudioResampler(bv.AudioFormat("flt"), audio_stream.layout, sr)
 
     container = audio_stream.container
-    assert isinstance(container, av.container.InputContainer)
+    assert isinstance(container, bv.container.InputContainer)
 
     for frame in container.decode(audio_stream):
         frame.pts = None  # Skip time checks
@@ -103,7 +103,7 @@ def iter_audio(audio_stream: av.AudioStream, tb: Fraction) -> Iterator[np.float3
 
 
 def iter_motion(
-    video: av.VideoStream, tb: Fraction, blur: int, width: int
+    video: bv.VideoStream, tb: Fraction, blur: int, width: int
 ) -> Iterator[np.float32]:
     video.thread_type = "AUTO"
 
@@ -113,7 +113,7 @@ def iter_motion(
     index = 0
     prev_index = -1
 
-    graph = av.filter.Graph()
+    graph = bv.filter.Graph()
     graph.link_nodes(
         graph.add_buffer(template=video),
         graph.add("scale", f"{width}:-1"),
@@ -123,7 +123,7 @@ def iter_motion(
     ).configure()
 
     container = video.container
-    assert isinstance(container, av.container.InputContainer)
+    assert isinstance(container, bv.container.InputContainer)
 
     for unframe in container.decode(video):
         if unframe.pts is None:
@@ -154,7 +154,7 @@ def iter_motion(
 
 @dataclass(slots=True)
 class Levels:
-    container: av.container.InputContainer
+    container: bv.container.InputContainer
     name: str
     mod_time: int
     tb: Fraction
@@ -258,7 +258,7 @@ class Levels:
         if audio.duration is not None and audio.time_base is not None:
             inaccurate_dur = int(audio.duration * audio.time_base * self.tb)
         elif container.duration is not None:
-            inaccurate_dur = int(container.duration / av.time_base * self.tb)
+            inaccurate_dur = int(container.duration / bv.time_base * self.tb)
         else:
             inaccurate_dur = 1024
 
@@ -343,15 +343,9 @@ class Levels:
         for packet in container.demux(subtitle_stream):
             if packet.pts is None or packet.duration is None:
                 continue
-            for subset in packet.decode():
-                # See definition of `AVSubtitle`
-                # in: https://ffmpeg.org/doxygen/trunk/avcodec_8h_source.html
-                start = float(packet.pts * subtitle_stream.time_base)
-                dur = float(packet.duration * subtitle_stream.time_base)
-
-                end = round((start + dur) * self.tb)
-                sub_length = max(sub_length, end)
+            sub_length = max(sub_length, packet.pts + packet.duration)
 
+        sub_length = round(sub_length * subtitle_stream.time_base * self.tb)
         result = np.zeros((sub_length), dtype=np.bool_)
         del sub_length
 
@@ -363,25 +357,25 @@ class Levels:
                 continue
             if early_exit:
                 break
-            for subset in packet.decode():
-                if max_count is not None and count >= max_count:
-                    early_exit = True
-                    break
 
-                start = float(packet.pts * subtitle_stream.time_base)
-                dur = float(packet.duration * subtitle_stream.time_base)
+            if max_count is not None and count >= max_count:
+                early_exit = True
+                break
+
+            start = float(packet.pts * subtitle_stream.time_base)
+            dur = float(packet.duration * subtitle_stream.time_base)
 
-                san_start = round(start * self.tb)
-                san_end = round((start + dur) * self.tb)
+            san_start = round(start * self.tb)
+            san_end = round((start + dur) * self.tb)
 
-                for sub in subset:
-                    if not isinstance(sub, AssSubtitle):
-                        continue
+            for sub in packet.decode():
+                if not isinstance(sub, AssSubtitle):
+                    continue
 
-                    line = sub.dialogue.decode(errors="ignore")
-                    if line and re.search(re_pattern, line):
-                        result[san_start:san_end] = 1
-                        count += 1
+                line = sub.dialogue.decode(errors="ignore")
+                if line and re.search(re_pattern, line):
+                    result[san_start:san_end] = 1
+                    count += 1
 
         container.seek(0)
         return result
@@ -391,8 +385,8 @@ def initLevels(
     src: FileInfo, tb: Fraction, bar: Bar, no_cache: bool, log: Log
 ) -> Levels:
     try:
-        container = av.open(src.path)
-    except av.FFmpegError as e:
+        container = bv.open(src.path)
+    except bv.FFmpegError as e:
         log.error(e)
 
     mod_time = int(src.path.stat().st_mtime)

auto_editor/cmds/desc.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import sys
 from dataclasses import dataclass, field
 
-from auto_editor.ffwrapper import initFileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.utils.log import Log
 from auto_editor.vanparse import ArgumentParser
 
@@ -22,7 +22,7 @@ def desc_options(parser: ArgumentParser) -> ArgumentParser:
 def main(sys_args: list[str] = sys.argv[1:]) -> None:
     args = desc_options(ArgumentParser("desc")).parse_args(DescArgs, sys_args)
     for path in args.input:
-        src = initFileInfo(path, Log())
+        src = FileInfo.init(path, Log())
         if src.description is not None:
             sys.stdout.write(f"\n{src.description}\n\n")
         else:

auto_editor/cmds/info.py

@@ -5,8 +5,8 @@ import sys
 from dataclasses import dataclass, field
 from typing import Any, Literal, TypedDict
 
-from auto_editor.ffwrapper import initFileInfo
-from auto_editor.lang.json import dump
+from auto_editor.ffwrapper import FileInfo
+from auto_editor.json import dump
 from auto_editor.make_layers import make_sane_timebase
 from auto_editor.timeline import v3
 from auto_editor.utils.func import aspect_ratio
@@ -102,7 +102,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
             file_info[file] = {"type": "timeline"}
             continue
 
-        src = initFileInfo(file, log)
+        src = FileInfo.init(file, log)
 
         if len(src.videos) + len(src.audios) + len(src.subtitles) == 0:
             file_info[file] = {"type": "unknown"}

auto_editor/cmds/levels.py

@@ -5,11 +5,11 @@ from dataclasses import dataclass, field
 from fractions import Fraction
 from typing import TYPE_CHECKING
 
-import av
+import bv
 import numpy as np
 
 from auto_editor.analyze import *
-from auto_editor.ffwrapper import initFileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.lang.palet import env
 from auto_editor.lib.contracts import is_bool, is_nat, is_nat1, is_str, is_void, orc
 from auto_editor.utils.bar import initBar
@@ -87,7 +87,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
     bar = initBar("none")
     log = Log(quiet=True)
 
-    sources = [initFileInfo(path, log) for path in args.input]
+    sources = [FileInfo.init(path, log) for path in args.input]
     if len(sources) < 1:
         log.error("levels needs at least one input file")
 
@@ -134,7 +134,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
                 if (arr := levels.read_cache("audio", (obj["stream"],))) is not None:
                     print_arr(arr)
                 else:
-                    container = av.open(src.path, "r")
+                    container = bv.open(src.path, "r")
                     audio_stream = container.streams.audio[obj["stream"]]
 
                     values = []
@@ -155,7 +155,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
                 if (arr := levels.read_cache("motion", mobj)) is not None:
                     print_arr(arr)
                 else:
-                    container = av.open(src.path, "r")
+                    container = bv.open(src.path, "r")
                     video_stream = container.streams.video[obj["stream"]]
 
                     values = []

auto_editor/cmds/repl.py

@@ -7,7 +7,7 @@ from os import environ
 
 import auto_editor
 from auto_editor.analyze import initLevels
-from auto_editor.ffwrapper import initFileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.lang.palet import ClosingError, Lexer, Parser, env, interpret
 from auto_editor.lang.stdenv import make_standard_env
 from auto_editor.lib.data_structs import print_str
@@ -48,11 +48,6 @@ def repl_options(parser: ArgumentParser) -> ArgumentParser:
         type=frame_rate,
         help="Set custom timebase",
     )
-    parser.add_argument(
-        "--temp-dir",
-        metavar="PATH",
-        help="Set where the temporary directory is located",
-    )
     return parser
 
 
@@ -60,8 +55,8 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
     args = repl_options(ArgumentParser(None)).parse_args(REPL_Args, sys_args)
 
     if args.input:
-        log = Log(quiet=True, temp_dir=args.temp_dir)
-        sources = [initFileInfo(path, log) for path in args.input]
+        log = Log(quiet=True)
+        sources = [FileInfo.init(path, log) for path in args.input]
         src = sources[0]
         tb = src.get_fps() if args.timebase is None else args.timebase
         env["timebase"] = tb

auto_editor/cmds/subdump.py

@@ -1,18 +1,72 @@
 import sys
+from dataclasses import dataclass, field
 
-import av
-from av.subtitles.subtitle import AssSubtitle
+import bv
+from bv.subtitles.subtitle import AssSubtitle
+
+from auto_editor.json import dump
+from auto_editor.vanparse import ArgumentParser
+
+
+@dataclass(slots=True)
+class SubdumpArgs:
+    help: bool = False
+    input: list[str] = field(default_factory=list)
+    json: bool = False
 
 
 def main(sys_args: list[str] = sys.argv[1:]) -> None:
-    for i, input_file in enumerate(sys_args):
-        with av.open(input_file) as container:
+    parser = ArgumentParser("subdump")
+    parser.add_required("input", nargs="*")
+    parser.add_argument("--json", flag=True)
+    args = parser.parse_args(SubdumpArgs, sys_args)
+
+    do_filter = True
+
+    if args.json:
+        data = {}
+        for input_file in args.input:
+            container = bv.open(input_file)
             for s in range(len(container.streams.subtitles)):
-                print(f"file: {input_file} ({s}:{container.streams.subtitles[s].name})")
-                for subset in container.decode(subtitles=s):
-                    for sub in subset:
+                entry_data = []
+
+                input_stream = container.streams.subtitles[s]
+                assert input_stream.time_base is not None
+                for packet in container.demux(input_stream):
+                    if (
+                        packet.dts is None
+                        or packet.pts is None
+                        or packet.duration is None
+                    ):
+                        continue
+
+                    start = packet.pts * input_stream.time_base
+                    end = start + packet.duration * input_stream.time_base
+
+                    startf = round(float(start), 3)
+                    endf = round(float(end), 3)
+
+                    if do_filter and endf - startf <= 0.02:
+                        continue
+
+                    for sub in packet.decode():
                         if isinstance(sub, AssSubtitle):
-                            print(sub.ass.decode("utf-8", errors="ignore"))
+                            content = sub.dialogue.decode("utf-8", errors="ignore")
+                            entry_data.append([startf, endf, content])
+
+                data[f"{input_file}:{s}"] = entry_data
+            container.close()
+
+        dump(data, sys.stdout, indent=4)
+        return
+
+    for i, input_file in enumerate(args.input):
+        with bv.open(input_file) as container:
+            for s in range(len(container.streams.subtitles)):
+                print(f"file: {input_file} ({s}:{container.streams.subtitles[s].name})")
+                for sub2 in container.decode(subtitles=s):
+                    if isinstance(sub2, AssSubtitle):
+                        print(sub2.ass.decode("utf-8", errors="ignore"))
         print("------")
 
 

auto_editor/cmds/test.py

@@ -11,10 +11,10 @@ from hashlib import sha256
 from tempfile import mkdtemp
 from time import perf_counter
 
-import av
+import bv
 import numpy as np
 
-from auto_editor.ffwrapper import FileInfo, initFileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.lang.palet import Lexer, Parser, env, interpret
 from auto_editor.lang.stdenv import make_standard_env
 from auto_editor.lib.data_structs import Char
@@ -62,7 +62,7 @@ log = Log()
 
 
 def fileinfo(path: str) -> FileInfo:
-    return initFileInfo(path, log)
+    return FileInfo.init(path, log)
 
 
 def calculate_sha256(filename: str) -> str:
@@ -73,6 +73,10 @@ def calculate_sha256(filename: str) -> str:
     return sha256_hash.hexdigest()
 
 
+class SkipTest(Exception):
+    pass
+
+
 class Runner:
     def __init__(self) -> None:
         self.program = [sys.executable, "-m", "auto_editor"]
@@ -157,35 +161,58 @@ class Runner:
         file = "resources/testsrc.mp4"
         out = self.main([file], ["--faststart"]) + ".mp4"
         fast = calculate_sha256(out)
-        with av.open(out) as container:
-            assert isinstance(container.streams[0], av.VideoStream)
-            assert isinstance(container.streams[1], av.AudioStream)
+        with bv.open(out) as container:
+            assert isinstance(container.streams[0], bv.VideoStream)
+            assert isinstance(container.streams[1], bv.AudioStream)
 
         out = self.main([file], ["--no-faststart"]) + ".mp4"
         nofast = calculate_sha256(out)
-        with av.open(out) as container:
-            assert isinstance(container.streams[0], av.VideoStream)
-            assert isinstance(container.streams[1], av.AudioStream)
+        with bv.open(out) as container:
+            assert isinstance(container.streams[0], bv.VideoStream)
+            assert isinstance(container.streams[1], bv.AudioStream)
 
         out = self.main([file], ["--fragmented"]) + ".mp4"
         frag = calculate_sha256(out)
-        with av.open(out) as container:
-            assert isinstance(container.streams[0], av.VideoStream)
-            assert isinstance(container.streams[1], av.AudioStream)
+        with bv.open(out) as container:
+            assert isinstance(container.streams[0], bv.VideoStream)
+            assert isinstance(container.streams[1], bv.AudioStream)
 
         assert fast != nofast, "+faststart is not being applied"
         assert frag not in (fast, nofast), "fragmented output should diff."
 
     def test_example(self) -> None:
         out = self.main(["example.mp4"], [], output="example_ALTERED.mp4")
-        with av.open(out) as container:
+        with bv.open(out) as container:
+            assert container.duration is not None
+            assert container.duration > 17300000 and container.duration < 2 << 24
+
+            assert len(container.streams) == 2
+            video = container.streams[0]
+            audio = container.streams[1]
+            assert isinstance(video, bv.VideoStream)
+            assert isinstance(audio, bv.AudioStream)
+            assert video.base_rate == 30
+            assert video.average_rate is not None
+            assert video.average_rate == 30, video.average_rate
+            assert (video.width, video.height) == (1280, 720)
+            assert video.codec.name == "h264"
+            assert video.language == "eng"
+            assert audio.codec.name == "aac"
+            assert audio.sample_rate == 48000
+            assert audio.language == "eng"
+            assert audio.layout.name == "stereo"
+
+    def test_to_mono(self) -> None:
+        out = self.main(["example.mp4"], ["-layout", "mono"], output="example_mono.mp4")
+        with bv.open(out) as container:
             assert container.duration is not None
             assert container.duration > 17300000 and container.duration < 2 << 24
 
+            assert len(container.streams) == 2
             video = container.streams[0]
             audio = container.streams[1]
-            assert isinstance(video, av.VideoStream)
-            assert isinstance(audio, av.AudioStream)
+            assert isinstance(video, bv.VideoStream)
+            assert isinstance(audio, bv.AudioStream)
             assert video.base_rate == 30
             assert video.average_rate is not None
             assert video.average_rate == 30, video.average_rate
@@ -195,6 +222,7 @@ class Runner:
             assert audio.codec.name == "aac"
             assert audio.sample_rate == 48000
             assert audio.language == "eng"
+            assert audio.layout.name == "mono"
 
     # PR #260
     def test_high_speed(self):
@@ -261,19 +289,19 @@ class Runner:
         self.check([path, "--no-open"], "must have an extension")
 
     def test_silent_threshold(self):
-        with av.open("resources/new-commentary.mp3") as container:
-            assert container.duration / av.time_base == 6.732
+        with bv.open("resources/new-commentary.mp3") as container:
+            assert container.duration / bv.time_base == 6.732
 
         out = self.main(
             ["resources/new-commentary.mp3"], ["--edit", "audio:threshold=0.1"]
         )
         out += ".mp3"
 
-        with av.open(out) as container:
-            assert container.duration / av.time_base == 6.552
+        with bv.open(out) as container:
+            assert container.duration / bv.time_base == 6.552
 
     def test_track(self):
-        out = self.main(["resources/multi-track.mov"], ["--keep_tracks_seperate"], "te")
+        out = self.main(["resources/multi-track.mov"], []) + ".mov"
         assert len(fileinfo(out).audios) == 2
 
     def test_export_json(self):
@@ -328,8 +356,18 @@ class Runner:
         assert cn.videos[0].height == 380
         assert cn.audios[0].samplerate == 48000
 
+    # def test_premiere_multi(self):
+    #     p_xml = self.main([f"resources/multi-track.mov"], ["-exp"], "multi.xml")
+
+    #     cn = fileinfo(self.main([p_xml], []))
+    #     assert len(cn.videos) == 1
+    #     assert len(cn.audios) == 2
+
     def test_premiere(self):
         for test_name in all_files:
+            if test_name == "multi-track.mov":
+                continue
+
             p_xml = self.main([f"resources/{test_name}"], ["-exp"], "out.xml")
             self.main([p_xml], [])
 
@@ -357,30 +395,24 @@ class Runner:
             ["--edit", "audio:stream=1"],
             "multi-track_ALTERED.mov",
         )
-        assert len(fileinfo(out).audios) == 1
+        assert len(fileinfo(out).audios) == 2
 
     def test_concat(self):
         out = self.main(["example.mp4"], ["--cut-out", "0,171"], "hmm.mp4")
         self.main(["example.mp4", out], ["--debug"])
 
     def test_concat_mux_tracks(self):
-        out = self.main(
-            ["example.mp4", "resources/multi-track.mov"], [], "concat_mux.mov"
-        )
+        inputs = ["example.mp4", "resources/multi-track.mov"]
+        out = self.main(inputs, ["--mix-audio-streams"], "concat_mux.mov")
         assert len(fileinfo(out).audios) == 1
 
     def test_concat_multi_tracks(self):
         out = self.main(
-            ["resources/multi-track.mov", "resources/multi-track.mov"],
-            ["--keep-tracks-separate"],
-            "out.mov",
+            ["resources/multi-track.mov", "resources/multi-track.mov"], [], "out.mov"
         )
         assert len(fileinfo(out).audios) == 2
-        out = self.main(
-            ["example.mp4", "resources/multi-track.mov"],
-            ["--keep-tracks-separate"],
-            "out.mov",
-        )
+        inputs = ["example.mp4", "resources/multi-track.mov"]
+        out = self.main(inputs, [], "out.mov")
         assert len(fileinfo(out).audios) == 2
 
     def test_frame_rate(self):
@@ -464,6 +496,21 @@ class Runner:
         out2 = self.main([out], ["-c:v", "prores"], "prores2.mkv")
         assert fileinfo(out2).videos[0].pix_fmt == "yuv422p10le"
 
+    def test_decode_hevc(self):
+        out = self.main(["resources/testsrc-hevc.mp4"], ["-c:v", "h264"]) + ".mp4"
+        output = fileinfo(out)
+        assert output.videos[0].codec == "h264"
+        assert output.videos[0].pix_fmt == "yuv420p"
+
+    def test_encode_hevc(self):
+        if os.environ.get("GITHUB_ACTIONS") == "true":
+            raise SkipTest()
+
+        out = self.main(["resources/testsrc.mp4"], ["-c:v", "hevc"], "out.mkv")
+        output = fileinfo(out)
+        assert output.videos[0].codec == "hevc"
+        assert output.videos[0].pix_fmt == "yuv420p"
+
     #  Issue 280
     def test_SAR(self):
         out = self.main(["resources/SAR-2by3.mp4"], [], "2by3_out.mp4")
@@ -646,16 +693,21 @@ def run_tests(runner: Runner, tests: list[Callable], args: TestArgs) -> None:
 
     def timed_test(test_func):
         start_time = perf_counter()
+        skipped = False
         try:
             test_func()
             success = True
+        except SkipTest:
+            skipped = True
         except Exception as e:
             success = False
             exception = e
         end_time = perf_counter()
         duration = end_time - start_time
 
-        if success:
+        if skipped:
+            return (SkipTest, duration, None)
+        elif success:
             return (True, duration, None)
         else:
             return (False, duration, exception)
@@ -674,17 +726,15 @@ def run_tests(runner: Runner, tests: list[Callable], args: TestArgs) -> None:
             total_time += dur
             index += 1
 
-            if success:
+            msg = f"{name:<26} ({index}/{total})  {round(dur, 2):<5} secs  "
+            if success == SkipTest:
                 passed += 1
-                print(
-                    f"{name:<26} ({index}/{total})  {round(dur, 2):<4} secs  [\033[1;32mPASSED\033[0m]",
-                    flush=True,
-                )
+                print(f"{msg}[\033[38;2;125;125;125;mSKIPPED\033[0m]", flush=True)
+            elif success:
+                passed += 1
+                print(f"{msg}[\033[1;32mPASSED\033[0m]", flush=True)
             else:
-                print(
-                    f"{name:<26} ({index}/{total})  {round(dur, 2):<4} secs  \033[1;31m[FAILED]\033[0m",
-                    flush=True,
-                )
+                print(f"{msg}\033[1;31m[FAILED]\033[0m", flush=True)
                 if args.no_fail_fast:
                     print(f"\n{exception}")
                 else: