auto-editor 28.0.2__py3-none-any.whl → 28.1.0__py3-none-any.whl

auto_editor/__init__.py

@@ -1 +1 @@
-__version__ = "28.0.2"
+__version__ = "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/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/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/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 *
@@ -137,7 +137,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> 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 = []
@@ -162,7 +162,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> 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 = []

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/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/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
@@ -50,6 +51,8 @@ def set_output(
                 export = "final-cut-pro"
             case ".mlt":
                 export = "shotcut"
+            case ".kdenlive":
+                export = "kdenlive"
             case ".json" | ".v1":
                 export = "v1"
             case ".v3":
@@ -64,6 +67,8 @@ def set_output(
             ext = ".fcpxml"
         case "shotcut":
             ext = ".mlt"
+        case "kdenlive":
+            ext = ".kdenlive"
         case "v1":
             if ext != ".json":
                 ext = ".v1"
@@ -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"),
@@ -261,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(".", "")
@@ -287,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:
@@ -333,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]
@@ -460,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: