auto-editor 28.0.1__tar.gz → 28.1.0__tar.gz

{auto_editor-28.0.1 → auto_editor-28.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-editor
-Version: 28.0.1
+Version: 28.1.0
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License-Expression: Unlicense
@@ -12,7 +12,7 @@ Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy<3.0,>=2
-Requires-Dist: basswood-av<16,>=15.2.1
+Requires-Dist: av<16,>=15.0
 Dynamic: license-file
 
 <p align="center"><img src="https://auto-editor.com/img/auto-editor-banner.webp" title="Auto-Editor" width="700"></p>

auto_editor-28.1.0/auto_editor/__init__.py

@@ -0,0 +1 @@
+__version__ = "28.1.0"

{auto_editor-28.0.1 → auto_editor-28.1.0}/auto_editor/__main__.py

@@ -441,6 +441,7 @@ def main() -> None:
             ({"--export-to-resolve", "-exr"}, ["--export", "resolve"]),
             ({"--export-to-final-cut-pro", "-exf"}, ["--export", "final-cut-pro"]),
             ({"--export-to-shotcut", "-exs"}, ["--export", "shotcut"]),
+            ({"--export-to-kdenlive", "-exk"}, ["--export", "kdenlive"]),
             ({"--export-as-clip-sequence", "-excs"}, ["--export", "clip-sequence"]),
             ({"--edit-based-on"}, ["--edit"]),
         ],
@@ -454,13 +455,13 @@ def main() -> None:
         buf.write(f"OS: {plat.system()} {plat.release()} {plat.machine().lower()}\n")
         buf.write(f"Python: {plat.python_version()}\nAV: ")
         try:
-            import bv
+            import av
         except (ModuleNotFoundError, ImportError):
             buf.write("not found")
         else:
             try:
-                buf.write(f"{bv.__version__} ")
-                license = bv._core.library_meta["libavcodec"]["license"]
+                buf.write(f"{av.__version__} ")
+                license = av._core.library_meta["libavcodec"]["license"]
                 buf.write(f"({license})")
             except AttributeError:
                 buf.write("error")

{auto_editor-28.0.1 → auto_editor-28.1.0}/auto_editor/analyze.py

@@ -9,10 +9,10 @@ from math import ceil
 from tempfile import gettempdir
 from typing import TYPE_CHECKING
 
-import bv
+import av
 import numpy as np
-from bv.audio.fifo import AudioFifo
-from bv.subtitles.subtitle import AssSubtitle
+from av.audio.fifo import AudioFifo
+from av.subtitles.subtitle import AssSubtitle
 
 from auto_editor import __version__
 
@@ -72,7 +72,7 @@ def mut_remove_large(
             active = False
 
 
-def iter_audio(audio_stream: bv.AudioStream, tb: Fraction) -> Iterator[np.float32]:
+def iter_audio(audio_stream: av.AudioStream, tb: Fraction) -> Iterator[np.float32]:
     fifo = AudioFifo()
     sr = audio_stream.rate
 
@@ -80,10 +80,10 @@ def iter_audio(audio_stream: bv.AudioStream, tb: Fraction) -> Iterator[np.float3
     accumulated_error = Fraction(0)
 
     # Resample so that audio data is between [-1, 1]
-    resampler = bv.AudioResampler(bv.AudioFormat("flt"), audio_stream.layout, sr)
+    resampler = av.AudioResampler(av.AudioFormat("flt"), audio_stream.layout, sr)
 
     container = audio_stream.container
-    assert isinstance(container, bv.container.InputContainer)
+    assert isinstance(container, av.container.InputContainer)
 
     for frame in container.decode(audio_stream):
         frame.pts = None  # Skip time checks
@@ -103,7 +103,7 @@ def iter_audio(audio_stream: bv.AudioStream, tb: Fraction) -> Iterator[np.float3
 
 
 def iter_motion(
-    video: bv.VideoStream, tb: Fraction, blur: int, width: int
+    video: av.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 = bv.filter.Graph()
+    graph = av.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, bv.container.InputContainer)
+    assert isinstance(container, av.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: bv.container.InputContainer
+    container: av.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 / bv.time_base * self.tb)
+            inaccurate_dur = int(container.duration / av.time_base * self.tb)
         else:
             inaccurate_dur = 1024
 
@@ -385,8 +385,8 @@ def initLevels(
     src: FileInfo, tb: Fraction, bar: Bar, no_cache: bool, log: Log
 ) -> Levels:
     try:
-        container = bv.open(src.path)
-    except bv.FFmpegError as e:
+        container = av.open(src.path)
+    except av.FFmpegError as e:
         log.error(e)
 
     mod_time = int(src.path.stat().st_mtime)

{auto_editor-28.0.1 → auto_editor-28.1.0}/auto_editor/cmds/desc.py

@@ -1,7 +1,7 @@
 import sys
 from dataclasses import dataclass, field
 
-import bv
+import av
 
 from auto_editor.vanparse import ArgumentParser
 
@@ -21,7 +21,7 @@ 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:
         try:
-            container = bv.open(path)
+            container = av.open(path)
             desc = container.metadata.get("description", None)
         except Exception:
             desc = None

{auto_editor-28.0.1 → auto_editor-28.1.0}/auto_editor/cmds/levels.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 from fractions import Fraction
 from typing import TYPE_CHECKING
 
-import bv
+import av
 import numpy as np
 
 from auto_editor.analyze import *
@@ -36,6 +36,7 @@ class LevelArgs:
     input: list[str] = field(default_factory=list)
     edit: str = "audio"
     timebase: Fraction | None = None
+    no_cache: bool = False
     help: bool = False
 
 
@@ -53,16 +54,14 @@ def levels_options(parser: ArgumentParser) -> ArgumentParser:
         type=frame_rate,
         help="Set custom timebase",
     )
+    parser.add_argument("--no-cache", flag=True)
     return parser
 
 
 def print_arr(arr: NDArray) -> None:
     print("")
     print("@start")
-    if arr.dtype in {np.float64, np.float32, np.float16}:
-        for a in arr:
-            sys.stdout.write(f"{a:.20f}\n")
-    elif arr.dtype == np.bool_:
+    if arr.dtype == np.bool_:
         for a in arr:
             sys.stdout.write(f"{1 if a else 0}\n")
     else:
@@ -76,7 +75,7 @@ def print_arr_gen(arr: Iterator[float | np.float32]) -> None:
     print("")
     print("@start")
     for a in arr:
-        print(f"{a:.20f}")
+        print(f"{a}")
     print("")
 
 
@@ -131,10 +130,14 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
         levels = initLevels(src, tb, bar, False, log)
         try:
             if method == "audio":
-                if (arr := levels.read_cache("audio", (obj["stream"],))) is not None:
+                if (
+                    not args.no_cache
+                    and (arr := levels.read_cache("audio", (obj["stream"],)))
+                    is not None
+                ):
                     print_arr(arr)
                 else:
-                    container = bv.open(src.path, "r")
+                    container = av.open(src.path, "r")
                     audio_stream = container.streams.audio[obj["stream"]]
 
                     values = []
@@ -148,14 +151,18 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
                     container.close()
 
                     cache_array = np.array(values, dtype=np.float32)
-                    levels.cache(cache_array, "audio", (obj["stream"],))
+                    if not args.no_cache:
+                        levels.cache(cache_array, "audio", (obj["stream"],))
 
             elif method == "motion":
                 mobj = (obj["stream"], obj["width"], obj["blur"])
-                if (arr := levels.read_cache("motion", mobj)) is not None:
+                if (
+                    not args.no_cache
+                    and (arr := levels.read_cache("motion", mobj)) is not None
+                ):
                     print_arr(arr)
                 else:
-                    container = bv.open(src.path, "r")
+                    container = av.open(src.path, "r")
                     video_stream = container.streams.video[obj["stream"]]
 
                     values = []
@@ -171,7 +178,8 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
                     container.close()
 
                     cache_array = np.array(values, dtype=np.float32)
-                    levels.cache(cache_array, "motion", mobj)
+                    if not args.no_cache:
+                        levels.cache(cache_array, "motion", mobj)
 
             elif method == "subtitle":
                 print_arr(levels.subtitle(**obj))

{auto_editor-28.0.1 → auto_editor-28.1.0}/auto_editor/cmds/subdump.py

@@ -1,8 +1,8 @@
 import sys
 from dataclasses import dataclass, field
 
-import bv
-from bv.subtitles.subtitle import AssSubtitle
+import av
+from av.subtitles.subtitle import AssSubtitle
 
 from auto_editor.json import dump
 from auto_editor.vanparse import ArgumentParser
@@ -24,7 +24,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
     if args.json:
         data = {}
         for input_file in args.input:
-            container = bv.open(input_file)
+            container = av.open(input_file)
             for s in range(len(container.streams.subtitles)):
                 entry_data = []
 
@@ -59,7 +59,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
         return
 
     for input_file in args.input:
-        with bv.open(input_file) as container:
+        with av.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):

{auto_editor-28.0.1 → auto_editor-28.1.0}/auto_editor/cmds/test.py

@@ -11,8 +11,9 @@ from hashlib import sha256
 from tempfile import mkdtemp
 from time import perf_counter
 
-import bv
+import av
 import numpy as np
+from av import AudioStream, VideoStream
 
 from auto_editor.ffwrapper import FileInfo
 from auto_editor.lang.palet import Lexer, Parser, env, interpret
@@ -58,7 +59,7 @@ all_files = (
     "mov_text.mp4",
     "testsrc.mkv",
 )
-log = Log()
+log = Log(is_debug=True)
 
 
 def fileinfo(path: str) -> FileInfo:
@@ -103,10 +104,11 @@ class Runner:
 
         return output
 
-    def raw(self, cmd: list[str]) -> None:
+    def raw(self, cmd: list[str]) -> str:
         returncode, stdout, stderr = pipe_to_console(self.program + cmd)
         if returncode > 0:
             raise Exception(f"{stdout}\n{stderr}\n")
+        return stdout
 
     def check(self, cmd: list[str], match=None) -> None:
         returncode, stdout, stderr = pipe_to_console(self.program + cmd)
@@ -133,11 +135,13 @@ class Runner:
 
     def test_version(self):
         """Test version flags and debug by itself."""
-        self.raw(["--version"])
-        self.raw(["-V"])
+        v1 = self.raw(["--version"])
+        v2 = self.raw(["-V"])
+        assert "." in v1 and len(v1) > 4
+        assert v1 == v2
 
     def test_parser(self):
-        self.check(["example.mp4", "--video-speed"], "needs argument")
+        self.check(["example.mp4", "--margin"], "needs argument")
 
     def info(self):
         self.raw(["info", "example.mp4"])
@@ -161,36 +165,36 @@ class Runner:
         file = "resources/testsrc.mp4"
         out = self.main([file], ["--faststart"]) + ".mp4"
         fast = calculate_sha256(out)
-        with bv.open(out) as container:
-            assert isinstance(container.streams[0], bv.VideoStream)
-            assert isinstance(container.streams[1], bv.AudioStream)
+        with av.open(out) as container:
+            assert isinstance(container.streams[0], VideoStream)
+            assert isinstance(container.streams[1], AudioStream)
 
         out = self.main([file], ["--no-faststart"]) + ".mp4"
         nofast = calculate_sha256(out)
-        with bv.open(out) as container:
-            assert isinstance(container.streams[0], bv.VideoStream)
-            assert isinstance(container.streams[1], bv.AudioStream)
+        with av.open(out) as container:
+            assert isinstance(container.streams[0], VideoStream)
+            assert isinstance(container.streams[1], AudioStream)
 
         out = self.main([file], ["--fragmented"]) + ".mp4"
         frag = calculate_sha256(out)
-        with bv.open(out) as container:
-            assert isinstance(container.streams[0], bv.VideoStream)
-            assert isinstance(container.streams[1], bv.AudioStream)
+        with av.open(out) as container:
+            assert isinstance(container.streams[0], VideoStream)
+            assert isinstance(container.streams[1], 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 bv.open(out) as container:
+        with av.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 isinstance(video, VideoStream)
+            assert isinstance(audio, AudioStream)
             assert video.base_rate == 30
             assert video.average_rate is not None
             assert video.average_rate == 30, video.average_rate
@@ -204,28 +208,28 @@ class Runner:
 
     def test_video_to_mp3(self) -> None:
         out = self.main(["example.mp4"], [], output="example_ALTERED.mp3")
-        with bv.open(out) as container:
+        with av.open(out) as container:
             assert container.duration is not None
             assert container.duration > 17300000 and container.duration < 2 << 24
 
             assert len(container.streams) == 1
             audio = container.streams[0]
-            assert isinstance(audio, bv.AudioStream)
+            assert isinstance(audio, AudioStream)
             assert audio.codec.name in ("mp3", "mp3float")
             assert audio.sample_rate == 48000
             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:
+        with av.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 isinstance(video, VideoStream)
+            assert isinstance(audio, AudioStream)
             assert video.base_rate == 30
             assert video.average_rate is not None
             assert video.average_rate == 30, video.average_rate
@@ -302,18 +306,18 @@ class Runner:
         self.check([path, "--no-open"], "must have an extension")
 
     def test_silent_threshold(self):
-        with bv.open("resources/new-commentary.mp3") as container:
+        with av.open("resources/new-commentary.mp3") as container:
             assert container.duration is not None
-            assert container.duration / bv.time_base == 6.732
+            assert container.duration / av.time_base == 6.732
 
         out = self.main(
             ["resources/new-commentary.mp3"], ["--edit", "audio:threshold=0.1"]
         )
         out += ".mp3"
 
-        with bv.open(out) as container:
+        with av.open(out) as container:
             assert container.duration is not None
-            assert container.duration / bv.time_base == 6.552
+            assert container.duration / av.time_base == 6.552
 
     def test_track(self):
         out = self.main(["resources/multi-track.mov"], []) + ".mov"

{auto_editor-28.0.1 → auto_editor-28.1.0}/auto_editor/edit.py

@@ -9,7 +9,8 @@ from pathlib import Path
 from subprocess import run
 from typing import TYPE_CHECKING, Any
 
-import bv
+import av
+from av import Codec
 
 from auto_editor.ffwrapper import FileInfo
 from auto_editor.lib.contracts import is_int, is_str
@@ -29,8 +30,8 @@ if TYPE_CHECKING:
 
 
 def set_output(
-    out: str | None, _export: str | None, path: Path | None, log: Log
-) -> tuple[str, dict[str, Any]]:
+    out: str | None, export: str | None, path: Path | None, log: Log
+) -> tuple[str, str]:
     if out is None or out == "-":
         if path is None:
             log.error("`--output` must be set.")  # When a timeline file is the input.
@@ -42,33 +43,37 @@ def set_output(
         # Use `mp4` as the default, because it is most compatible.
         ext = ".mp4" if path is None else path.suffix
 
-    if _export is None:
+    if export is None:
         match ext:
             case ".xml":
-                export: dict[str, Any] = {"export": "premiere"}
+                export = "premiere"
             case ".fcpxml":
-                export = {"export": "final-cut-pro"}
+                export = "final-cut-pro"
             case ".mlt":
-                export = {"export": "shotcut"}
+                export = "shotcut"
+            case ".kdenlive":
+                export = "kdenlive"
             case ".json" | ".v1":
-                export = {"export": "v1"}
+                export = "v1"
             case ".v3":
-                export = {"export": "v3"}
+                export = "v3"
             case _:
-                export = {"export": "default"}
-    else:
-        export = parse_export(_export, log)
-
-    ext_map = {
-        "premiere": ".xml",
-        "resolve-fcp7": ".xml",
-        "final-cut-pro": ".fcpxml",
-        "resolve": ".fcpxml",
-        "shotcut": ".mlt",
-        "json": ".json",
-    }
-    if export["export"] in ext_map:
-        ext = ext_map[export["export"]]
+                export = "default"
+
+    match export:
+        case "premiere" | "resolve-fcp7":
+            ext = ".xml"
+        case "final-cut-pro" | "resolve":
+            ext = ".fcpxml"
+        case "shotcut":
+            ext = ".mlt"
+        case "kdenlive":
+            ext = ".kdenlive"
+        case "v1":
+            if ext != ".json":
+                ext = ".v1"
+        case "v3":
+            ext = ".v3"
 
     if out == "-":
         return "-", export
@@ -79,9 +84,6 @@ def set_output(
     return f"{root}{ext}", export
 
 
-codec_error = "'{}' codec is not supported in '{}' container."
-
-
 def set_video_codec(
     codec: str, src: FileInfo | None, out_ext: str, ctr: Container, log: Log
 ) -> str:
@@ -93,12 +95,14 @@ def set_video_codec(
 
     if ctr.vcodecs is not None and codec not in ctr.vcodecs:
         try:
-            cobj = bv.Codec(codec, "w")
-        except bv.codec.codec.UnknownCodecError:
+            cobj = Codec(codec, "w")
+        except av.codec.codec.UnknownCodecError:
             log.error(f"Unknown encoder: {codec}")
         # Normalize encoder names
-        if cobj.id not in (bv.Codec(x, "w").id for x in ctr.vcodecs):
-            log.error(codec_error.format(codec, out_ext))
+        if cobj.id not in (Codec(x, "w").id for x in ctr.vcodecs):
+            log.error(
+                f"'{codec}' video encoder is not supported in the '{out_ext}' container"
+            )
 
     return codec
 
@@ -111,7 +115,7 @@ def set_audio_codec(
             codec = "aac"
         else:
             codec = src.audios[0].codec
-            if bv.Codec(codec, "w").audio_formats is None:
+            if Codec(codec, "w").audio_formats is None:
                 codec = "aac"
         if codec not in ctr.acodecs and ctr.default_aud != "none":
             codec = ctr.default_aud
@@ -121,13 +125,14 @@ def set_audio_codec(
 
     if ctr.acodecs is None or codec not in ctr.acodecs:
         try:
-            cobj = bv.Codec(codec, "w")
-        except bv.codec.codec.UnknownCodecError:
+            cobj = Codec(codec, "w")
+        except av.codec.codec.UnknownCodecError:
             log.error(f"Unknown encoder: {codec}")
         # Normalize encoder names
-        if cobj.id not in (bv.Codec(x, "w").id for x in ctr.acodecs):
-            log.error(codec_error.format(codec, out_ext))
-
+        if cobj.id not in (Codec(x, "w").id for x in ctr.acodecs):
+            log.error(
+                f"'{codec}' audio encoder is not supported in the '{out_ext}' container"
+            )
     return codec
 
 
@@ -148,6 +153,7 @@ def parse_export(export: str, log: Log) -> dict[str, Any]:
         "resolve": pAttrs("resolve", name_attr),
         "resolve-fcp7": pAttrs("resolve-fcp7", name_attr),
         "shotcut": pAttrs("shotcut"),
+        "kdenlive": pAttrs("kdenlive"),
         "v1": pAttrs("v1"),
         "v3": pAttrs("v3"),
         "clip-sequence": pAttrs("clip-sequence"),
@@ -184,9 +190,13 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
             src = sources[0]
             use_path = src.path
 
-    output, export_ops = set_output(args.output, args.export, use_path, log)
-    assert "export" in export_ops
-    export = export_ops["export"]
+    if args.export is None:
+        output, export = set_output(args.output, args.export, use_path, log)
+        export_ops: dict[str, Any] = {"export": export}
+    else:
+        export_ops = parse_export(args.export, log)
+        export = export_ops["export"]
+        output, _ = set_output(args.output, export, use_path, log)
 
     if output == "-":
         # When printing to stdout, silence all logs.
@@ -257,6 +267,12 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
         shotcut_write_mlt(output, tl)
         return
 
+    if export == "kdenlive":
+        from auto_editor.exports.kdenlive import kdenlive_write
+
+        kdenlive_write(output, tl)
+        return
+
     if output == "-":
         log.error("Exporting media files to stdout is not supported.")
     out_ext = splitext(output)[1].replace(".", "")
@@ -283,26 +299,26 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
         if mov_flags:
             options["movflags"] = "+".join(mov_flags)
 
-        output = bv.open(output_path, "w", container_options=options)
+        output = av.open(output_path, "w", container_options=options)
 
         # Setup video
         if ctr.default_vid not in ("none", "png") and tl.v:
             vframes = render_av(output, tl, args, log)
-            output_stream: bv.VideoStream | None
+            output_stream: av.VideoStream | None
             output_stream = next(vframes)  # type: ignore
         else:
             output_stream, vframes = None, iter([])
 
         # Setup audio
         try:
-            audio_encoder = bv.Codec(args.audio_codec, "w")
-        except bv.FFmpegError as e:
+            audio_encoder = Codec(args.audio_codec, "w")
+        except av.FFmpegError as e:
             log.error(e)
         if audio_encoder.audio_formats is None:
             log.error(f"{args.audio_codec}: No known audio formats avail.")
         fmt = audio_encoder.audio_formats[0]
 
-        audio_streams: list[bv.AudioStream] = []
+        audio_streams: list[av.AudioStream] = []
 
         if ctr.default_aud == "none":
             while len(tl.a) > 0:
@@ -329,7 +345,7 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
         sub_gen_frames = []
 
         for i, sub_path in enumerate(sub_paths):
-            subtitle_input = bv.open(sub_path)
+            subtitle_input = av.open(sub_path)
             subtitle_inputs.append(subtitle_input)
             subtitle_stream = output.add_stream_from_template(
                 subtitle_input.streams.subtitles[0]
@@ -456,14 +472,14 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
                         output.mux(item.stream.encode(item.frame))
                     elif frame_type == "subtitle":
                         output.mux(item.frame)
-                except bv.error.ExternalError:
+                except av.error.ExternalError:
                     log.error(
                         f"Generic error for encoder: {item.stream.name}\n"
                         f"at {item.index} time_base\nPerhaps video quality settings are too low?"
                     )
-                except bv.FileNotFoundError:
+                except av.FileNotFoundError:
                     log.error(f"File not found: {output_path}")
-                except bv.FFmpegError as e:
+                except av.FFmpegError as e:
                     log.error(e)
 
                 if bar_index: