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

auto_editor/render/audio.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 from fractions import Fraction
 from io import BytesIO
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
-import bv
+import av
 import numpy as np
-from bv import AudioFrame
-from bv.filter.loudnorm import stats
+from av import AudioFrame
+from av.filter.loudnorm import stats
 
 from auto_editor.ffwrapper import FileInfo
 from auto_editor.json import load
@@ -22,7 +22,6 @@ from auto_editor.utils.log import Log
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
-    from typing import Any
 
     from auto_editor.__main__ import Args
 
@@ -102,7 +101,7 @@ def apply_audio_normalization(
             f"i={norm['i']}:lra={norm['lra']}:tp={norm['tp']}:offset={norm['gain']}"
         )
         log.debug(f"audio norm first pass: {first_pass}")
-        with bv.open(f"{pre_master}") as container:
+        with av.open(f"{pre_master}") as container:
             stats_ = stats(first_pass, container.streams.audio[0])
 
         name, filter_args = parse_ebu_bytes(norm, stats_, log)
@@ -117,7 +116,7 @@ def apply_audio_normalization(
                 return -20.0 * np.log10(max_amplitude)
             return -99.0
 
-        with bv.open(pre_master) as container:
+        with av.open(pre_master) as container:
             max_peak_level = -99.0
             assert len(container.streams.video) == 0
             for frame in container.decode(audio=0):
@@ -129,13 +128,13 @@ def apply_audio_normalization(
         log.print(f"peak adjustment: {adjustment:.3f}dB")
         name, filter_args = "volume", f"{adjustment}"
 
-    with bv.open(pre_master) as container:
+    with av.open(pre_master) as container:
         input_stream = container.streams.audio[0]
 
-        output_file = bv.open(path, mode="w")
+        output_file = av.open(path, mode="w")
         output_stream = output_file.add_stream("pcm_s16le", rate=input_stream.rate)
 
-        graph = bv.filter.Graph()
+        graph = av.filter.Graph()
         graph.link_nodes(
             graph.add_abuffer(template=input_stream),
             graph.add(name, filter_args),
@@ -148,7 +147,7 @@ def apply_audio_normalization(
                     aframe = graph.pull()
                     assert isinstance(aframe, AudioFrame)
                     output_file.mux(output_stream.encode(aframe))
-                except (bv.BlockingIOError, bv.EOFError):
+                except (av.BlockingIOError, av.EOFError):
                     break
 
         output_file.mux(output_stream.encode(None))
@@ -156,10 +155,10 @@ def apply_audio_normalization(
 
 
 def process_audio_clip(clip: Clip, data: np.ndarray, sr: int, log: Log) -> np.ndarray:
-    to_s16 = bv.AudioResampler(format="s16", layout="stereo", rate=sr)
+    to_s16 = av.AudioResampler(format="s16", layout="stereo", rate=sr)
     input_buffer = BytesIO()
 
-    with bv.open(input_buffer, "w", format="wav") as container:
+    with av.open(input_buffer, "w", format="wav") as container:
         output_stream = container.add_stream(
             "pcm_s16le", sample_rate=sr, format="s16", layout="stereo"
         )
@@ -173,10 +172,10 @@ def process_audio_clip(clip: Clip, data: np.ndarray, sr: int, log: Log) -> np.nd
 
     input_buffer.seek(0)
 
-    input_file = bv.open(input_buffer, "r")
+    input_file = av.open(input_buffer, "r")
     input_stream = input_file.streams.audio[0]
 
-    graph = bv.filter.Graph()
+    graph = av.filter.Graph()
     args = [graph.add_abuffer(template=input_stream)]
 
     if clip.speed != 1:
@@ -202,7 +201,7 @@ def process_audio_clip(clip: Clip, data: np.ndarray, sr: int, log: Log) -> np.nd
     graph.link_nodes(*args).configure()
 
     all_frames = []
-    resampler = bv.AudioResampler(format="s16p", layout="stereo", rate=sr)
+    resampler = av.AudioResampler(format="s16p", layout="stereo", rate=sr)
 
     for frame in input_file.decode(input_stream):
         graph.push(frame)
@@ -214,7 +213,7 @@ def process_audio_clip(clip: Clip, data: np.ndarray, sr: int, log: Log) -> np.nd
                 for resampled_frame in resampler.resample(aframe):
                     all_frames.append(resampled_frame.to_ndarray())
 
-            except (bv.BlockingIOError, bv.EOFError):
+            except (av.BlockingIOError, av.EOFError):
                 break
 
     if not all_frames:
@@ -229,7 +228,7 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
 
     # First pass: determine the maximum length
     for path in audio_paths:
-        container = bv.open(path)
+        container = av.open(path)
         stream = container.streams.audio[0]
 
         # Calculate duration in samples
@@ -241,14 +240,11 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
 
     # Second pass: read and mix audio
     for path in audio_paths:
-        container = bv.open(path)
+        container = av.open(path)
         stream = container.streams.audio[0]
 
-        resampler = bv.audio.resampler.AudioResampler(
-            format="s16", layout="mono", rate=sr
-        )
-
         audio_array: list[np.ndarray] = []
+        resampler = av.AudioResampler(format="s16", layout="mono", rate=sr)
         for frame in container.decode(audio=0):
             frame.pts = None
             resampled = resampler.resample(frame)[0]
@@ -277,7 +273,7 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
         mixed_audio = mixed_audio * (32767 / max_val)
     mixed_audio = mixed_audio.astype(np.int16)
 
-    output_container = bv.open(output_path, mode="w")
+    output_container = av.open(output_path, mode="w")
     output_stream = output_container.add_stream("pcm_s16le", rate=sr)
 
     chunk_size = sr  # Process 1 second at a time
@@ -298,9 +294,9 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
 def file_to_ndarray(src: FileInfo, stream: int, sr: int) -> np.ndarray:
     all_frames = []
 
-    resampler = bv.AudioResampler(format="s16p", layout="stereo", rate=sr)
+    resampler = av.AudioResampler(format="s16p", layout="stereo", rate=sr)
 
-    with bv.open(src.path) as container:
+    with av.open(src.path) as container:
         for frame in container.decode(audio=stream):
             for resampled_frame in resampler.resample(frame):
                 all_frames.append(resampled_frame.to_ndarray())
@@ -311,10 +307,10 @@ def file_to_ndarray(src: FileInfo, stream: int, sr: int) -> np.ndarray:
 def ndarray_to_file(audio_data: np.ndarray, rate: int, out: str | Path) -> None:
     layout = "stereo"
 
-    with bv.open(out, mode="w") as output:
+    with av.open(out, mode="w") as output:
         stream = output.add_stream("pcm_s16le", rate=rate, format="s16", layout=layout)
 
-        frame = bv.AudioFrame.from_ndarray(audio_data, format="s16p", layout=layout)
+        frame = AudioFrame.from_ndarray(audio_data, format="s16p", layout=layout)
         frame.rate = rate
 
         output.mux(stream.encode(frame))
@@ -322,11 +318,11 @@ def ndarray_to_file(audio_data: np.ndarray, rate: int, out: str | Path) -> None:
 
 
 def ndarray_to_iter(
-    audio_data: np.ndarray, fmt: bv.AudioFormat, layout: str, rate: int
+    audio_data: np.ndarray, fmt: av.AudioFormat, layout: str, rate: int
 ) -> Iterator[AudioFrame]:
     chunk_size = rate // 4  # Process 0.25 seconds at a time
 
-    resampler = bv.AudioResampler(rate=rate, format=fmt, layout=layout)
+    resampler = av.AudioResampler(rate=rate, format=fmt, layout=layout)
     for i in range(0, audio_data.shape[1], chunk_size):
         chunk = audio_data[:, i : i + chunk_size]
 
@@ -338,15 +334,15 @@ def ndarray_to_iter(
 
 
 def make_new_audio(
-    output: bv.container.OutputContainer,
-    audio_format: bv.AudioFormat,
+    output: av.container.OutputContainer,
+    audio_format: av.AudioFormat,
     tl: v3,
     args: Args,
     log: Log,
-) -> tuple[list[bv.AudioStream], list[Iterator[AudioFrame]]]:
+) -> tuple[list[av.AudioStream], list[Iterator[AudioFrame]]]:
     audio_inputs = []
     audio_gen_frames = []
-    audio_streams: list[bv.AudioStream] = []
+    audio_streams: list[av.AudioStream] = []
     audio_paths = _make_new_audio(tl, audio_format, args, log)
 
     for i, audio_path in enumerate(audio_paths):
@@ -357,7 +353,7 @@ def make_new_audio(
             layout=tl.T.layout,
             time_base=Fraction(1, tl.sr),
         )
-        if not isinstance(audio_stream, bv.AudioStream):
+        if not isinstance(audio_stream, av.AudioStream):
             log.error(f"Not a known audio codec: {args.audio_codec}")
 
         if args.audio_bitrate != "auto":
@@ -372,7 +368,7 @@ def make_new_audio(
         audio_streams.append(audio_stream)
 
         if isinstance(audio_path, str):
-            audio_input = bv.open(audio_path)
+            audio_input = av.open(audio_path)
             audio_inputs.append(audio_input)
             audio_gen_frames.append(audio_input.decode(audio=0))
         else:
@@ -385,7 +381,7 @@ class Getter:
     __slots__ = ("container", "stream", "rate")
 
     def __init__(self, path: Path, stream: int, rate: int):
-        self.container = bv.open(path)
+        self.container = av.open(path)
         self.stream = self.container.streams.audio[stream]
         self.rate = rate
 
@@ -394,7 +390,7 @@ class Getter:
 
         container = self.container
         stream = self.stream
-        resampler = bv.AudioResampler(format="s16p", layout="stereo", rate=self.rate)
+        resampler = av.AudioResampler(format="s16p", layout="stereo", rate=self.rate)
 
         time_base = stream.time_base
         assert time_base is not None
@@ -436,10 +432,12 @@ class Getter:
         return result  # Return NumPy array with shape (channels, samples)
 
 
-def _make_new_audio(tl: v3, fmt: bv.AudioFormat, args: Args, log: Log) -> list[Any]:
+def _make_new_audio(
+    tl: v3, fmt: av.AudioFormat, args: Args, log: Log
+) -> list[str | Iterator[AudioFrame]]:
     sr = tl.sr
     tb = tl.tb
-    output: list[Any] = []
+    output: list[str | Iterator[AudioFrame]] = []
     samples: dict[tuple[FileInfo, int], Getter] = {}
 
     norm = parse_norm(args.audio_normalize, log)
@@ -449,7 +447,7 @@ def _make_new_audio(tl: v3, fmt: bv.AudioFormat, args: Args, log: Log) -> list[A
 
     layout = tl.T.layout
     try:
-        bv.AudioLayout(layout)
+        av.AudioLayout(layout)
     except ValueError:
         log.error(f"Invalid audio layout: {layout}")
 
@@ -511,7 +509,9 @@ def _make_new_audio(tl: v3, fmt: bv.AudioFormat, args: Args, log: Log) -> list[A
 
     if args.mix_audio_streams and len(output) > 1:
         new_a_file = f"{Path(log.temp, 'new_audio.wav')}"
-        mix_audio_files(sr, output, new_a_file)
+        # When mix_audio_streams is True, output only contains strings
+        audio_paths = cast(list[str], output)
+        mix_audio_files(sr, audio_paths, new_a_file)
         return [new_a_file]
 
     return output

auto_editor/render/subtitle.py

@@ -6,7 +6,7 @@ import re
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-import bv
+import av
 
 from auto_editor.utils.func import to_timecode
 
@@ -17,7 +17,7 @@ if TYPE_CHECKING:
     from auto_editor.utils.chunks import Chunks
     from auto_editor.utils.log import Log
 
-    Input = bv.container.InputContainer
+    Input = av.container.InputContainer
 
 
 @dataclass(slots=True)
@@ -143,7 +143,7 @@ def make_srt(input_: Input, stream: int) -> str:
         end = to_timecode(start_num + packet.duration * input_stream.time_base, "srt")
 
         for sub in packet.decode():
-            assert isinstance(sub, bv.subtitles.subtitle.AssSubtitle)
+            assert isinstance(sub, av.subtitles.subtitle.AssSubtitle)
 
             output_bytes.write(f"{s}\n{start} --> {end}\n")
             output_bytes.write(sub.dialogue.decode("utf-8", errors="ignore") + "\n\n")
@@ -155,7 +155,7 @@ def make_srt(input_: Input, stream: int) -> str:
 
 def _ensure(input_: Input, format: str, stream: int) -> str:
     output_bytes = io.BytesIO()
-    output = bv.open(output_bytes, "w", format=format)
+    output = av.open(output_bytes, "w", format=format)
 
     in_stream = input_.streams.subtitles[stream]
     out_stream = output.add_stream_from_template(in_stream)
@@ -175,7 +175,7 @@ def make_new_subtitles(tl: v3, log: Log) -> list[str]:
     if tl.v1 is None:
         return []
 
-    input_ = bv.open(tl.v1.source.path)
+    input_ = av.open(tl.v1.source.path)
     new_paths = []
 
     for s, sub in enumerate(tl.v1.source.subtitles):

auto_editor/render/video.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-import bv
+import av
 import numpy as np
 
 from auto_editor.timeline import Clip, TlImage, TlRect
@@ -24,12 +24,12 @@ class VideoFrame:
     src: FileInfo
 
 
-def make_solid(width: int, height: int, pix_fmt: str, bg: str) -> bv.VideoFrame:
+def make_solid(width: int, height: int, pix_fmt: str, bg: str) -> av.VideoFrame:
     hex_color = bg.lstrip("#").upper()
     rgb_color = tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))
 
     rgb_array = np.full((height, width, 3), rgb_color, dtype=np.uint8)
-    rgb_frame = bv.VideoFrame.from_ndarray(rgb_array, format="rgb24")
+    rgb_frame = av.VideoFrame.from_ndarray(rgb_array, format="rgb24")
     return rgb_frame.reformat(format=pix_fmt)
 
 
@@ -38,11 +38,11 @@ def make_image_cache(tl: v3) -> dict[tuple[FileInfo, int], np.ndarray]:
     for clip in tl.v:
         for obj in clip:
             if isinstance(obj, TlImage) and (obj.src, obj.width) not in img_cache:
-                with bv.open(obj.src.path) as cn:
+                with av.open(obj.src.path) as cn:
                     my_stream = cn.streams.video[0]
                     for frame in cn.decode(my_stream):
                         if obj.width != 0:
-                            graph = bv.filter.Graph()
+                            graph = av.filter.Graph()
                             graph.link_nodes(
                                 graph.add_buffer(template=my_stream),
                                 graph.add("scale", f"{obj.width}:-1"),
@@ -57,12 +57,12 @@ def make_image_cache(tl: v3) -> dict[tuple[FileInfo, int], np.ndarray]:
 
 
 def render_av(
-    output: bv.container.OutputContainer, tl: v3, args: Args, log: Log
-) -> Iterator[tuple[int, bv.VideoFrame]]:
-    from_ndarray = bv.VideoFrame.from_ndarray
+    output: av.container.OutputContainer, tl: v3, args: Args, log: Log
+) -> Iterator[tuple[int, av.VideoFrame]]:
+    from_ndarray = av.VideoFrame.from_ndarray
 
-    cns: dict[FileInfo, bv.container.InputContainer] = {}
-    decoders: dict[FileInfo, Iterator[bv.VideoFrame]] = {}
+    cns: dict[FileInfo, av.container.InputContainer] = {}
+    decoders: dict[FileInfo, Iterator[av.VideoFrame]] = {}
     seek_cost: dict[FileInfo, int] = {}
     tous: dict[FileInfo, int] = {}
 
@@ -76,7 +76,7 @@ def render_av(
             first_src = src
 
         if src not in cns:
-            cns[src] = bv.open(f"{src.path}")
+            cns[src] = av.open(f"{src.path}")
 
     for src, cn in cns.items():
         if len(cn.streams.video) > 0:
@@ -101,26 +101,21 @@ def render_av(
     log.debug(f"Tous: {tous}")
     log.debug(f"Clips: {tl.v}")
 
-    codec = bv.Codec(args.video_codec, "w")
-
-    need_valid_fmt = True
-    if codec.video_formats is not None:
-        for video_format in codec.video_formats:
-            if pix_fmt == video_format.name:
-                need_valid_fmt = False
-                break
+    output_stream = output.add_stream(args.video_codec, rate=target_fps)
+    output_stream.options = {"x265-params": "log-level=error"}
 
+    need_valid_fmt = not (
+        output_stream.codec.video_formats
+        and any(pix_fmt == vfmt.name for vfmt in output_stream.codec.video_formats)
+    )
     if need_valid_fmt:
-        if codec.canonical_name == "gif":
-            pix_fmt = "rgb8"
-        elif codec.canonical_name == "prores":
-            pix_fmt = "yuv422p10le"
-        else:
-            pix_fmt = "yuv420p"
-
-    del codec
-    output_stream = output.add_stream(args.video_codec, rate=target_fps)
-    output_stream.options = {"x265-params": "log-level=error"}  # type: ignore
+        match output_stream.codec.canonical_name:
+            case "gif":
+                pix_fmt = "rgb8"
+            case "prores":
+                pix_fmt = "yuv422p10le"
+            case _:
+                pix_fmt = "yuv420p"
 
     cc = output_stream.codec_context
     if args.vprofile is not None:
@@ -133,7 +128,7 @@ def render_av(
         cc.profile = args.vprofile.title()
 
     yield output_stream  # type: ignore
-    if not isinstance(output_stream, bv.VideoStream):
+    if not isinstance(output_stream, av.VideoStream):
         log.error(f"Not a known video codec: {args.video_codec}")
     if src.videos and src.videos[0].lang is not None:
         output_stream.metadata["language"] = src.videos[0].lang
@@ -144,7 +139,7 @@ def render_av(
     else:
         target_width = max(round(tl.res[0] * args.scale), 2)
         target_height = max(round(tl.res[1] * args.scale), 2)
-        scale_graph = bv.filter.Graph()
+        scale_graph = av.filter.Graph()
         scale_graph.link_nodes(
             scale_graph.add(
                 "buffer", video_size="1x1", time_base="1/1", pix_fmt=pix_fmt
@@ -246,7 +241,7 @@ def render_av(
 
                 if (frame.width, frame.height) != tl.res:
                     width, height = tl.res
-                    graph = bv.filter.Graph()
+                    graph = av.filter.Graph()
                     graph.link_nodes(
                         graph.add_buffer(template=my_stream),
                         graph.add(
@@ -258,7 +253,7 @@ def render_av(
                     ).vpush(frame)
                     frame = graph.vpull()
             elif isinstance(obj, TlRect):
-                graph = bv.filter.Graph()
+                graph = av.filter.Graph()
                 x, y = obj.x, obj.y
                 graph.link_nodes(
                     graph.add_buffer(template=my_stream),

auto_editor/timeline.py

@@ -282,41 +282,6 @@ video\n"""
 
         return result
 
-    def as_dict(self) -> dict:
-        def aclip_to_dict(self: Clip) -> dict:
-            return {
-                "name": "audio",
-                "src": self.src,
-                "start": self.start,
-                "dur": self.dur,
-                "offset": self.offset,
-                "speed": self.speed,
-                "volume": self.volume,
-                "stream": self.stream,
-            }
-
-        v = []
-        a = []
-        for vlayer in self.v:
-            vb = [vobj.as_dict() for vobj in vlayer]
-            if vb:
-                v.append(vb)
-        for layer in self.a:
-            ab = [aclip_to_dict(clip) for clip in layer]
-            if ab:
-                a.append(ab)
-
-        return {
-            "version": "3",
-            "timebase": f"{self.tb.numerator}/{self.tb.denominator}",
-            "background": self.background,
-            "resolution": self.T.res,
-            "samplerate": self.T.sr,
-            "layout": self.T.layout,
-            "v": v,
-            "a": a,
-        }
-
     @property
     def T(self) -> Template:
         return self.template

auto_editor/utils/container.py

@@ -3,8 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TypedDict
 
-import bv
-from bv.codec import Codec
+from av import Codec, open
 
 from auto_editor.utils.log import Log
 
@@ -64,7 +63,7 @@ def codec_type(x: str) -> str:
 
 def container_constructor(ext: str, log: Log) -> Container:
     try:
-        container = bv.open(f".{ext}", "w")
+        container = open(f".{ext}", "w")
     except ValueError:
         log.error(f"Could not find a suitable format for extension: {ext}")
 

auto_editor/utils/log.py

@@ -100,8 +100,10 @@ class Log:
         sys.stderr.write(f"\033[1m\033[33m{message}\033[0m\n")
 
     def error(self, message: str | Exception) -> NoReturn:
-        if self.is_debug and isinstance(message, Exception):
+        if self.is_debug:
             self.cleanup()
+            if isinstance(message, str):
+                raise Exception(message)
             raise message
 
         self.conwrite("")

{auto_editor-28.0.1.dist-info → auto_editor-28.1.0.dist-info}/METADATA

@@ -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.0.1.dist-info → auto_editor-28.1.0.dist-info}/RECORD

@@ -1,28 +1,29 @@
-auto_editor/__init__.py,sha256=qvc7djhJkqlXmlxcWZWLvK6JKBp01_I3fJuFV5euTBg,23
-auto_editor/__main__.py,sha256=t5Um7M9ess9xYRfmn6iDvJoBqj_KRQLhlkpFdfhx3MU,15478
-auto_editor/analyze.py,sha256=CeJG0LI9wXZk1R-QPrNGPS4za-_Avd8y7H-D437DqLg,12300
-auto_editor/edit.py,sha256=GhOfKIe_FdbBGDQ_WH02CJl7Oi-AwaaSSh73F81h_kA,19234
-auto_editor/ffwrapper.py,sha256=ueYdN7-cBAdJBJbv5yT05iuQP_BPFIrR5hFeMkk5c3U,5040
-auto_editor/help.py,sha256=8Kkos7Bpcn-3YN7ngv0fZp-8a8Qw6b70ZZKerL8SEQ4,7901
+auto_editor/__init__.py,sha256=22AwAEXAu8nCjcGi5JKpN5CwGqL0avyRi9p7xsPeXQk,23
+auto_editor/__main__.py,sha256=46l-4asehWV-GJIDDULm2Sh9RKD6KjVBariy6ijgFSI,15552
+auto_editor/analyze.py,sha256=b3x7efPza_PJ5E6zzSsgqFGYIRRulcpL1AEcrGVcFAg,12300
+auto_editor/edit.py,sha256=pU5uhyKJSsOoSVeZDWBUjWi2_UPEBXXEpHUsCD8CmwA,19690
+auto_editor/ffwrapper.py,sha256=YNGvHnkX0PTHsBx19kc-O3ZAiZX8WoqqZvIfjJ3tovQ,5474
+auto_editor/help.py,sha256=YAw0b_-b6_RXXuDSl6OHevCMrhDocxWbcvoIlj5Qq-E,7959
 auto_editor/json.py,sha256=g6ZsrSOXtjQj-8Otea3TIY2G-HZ6g-IXUblwukgTO1g,9332
-auto_editor/make_layers.py,sha256=Udxn7Vw0Jz9HOarLeswQ-WwTu87PWcsyduBdtFwSOyc,10079
-auto_editor/preview.py,sha256=yYn5jJLQ3TiJiNC6JffaggLVPQfBU558zJeRQz7nCDY,3046
-auto_editor/timeline.py,sha256=ebnEX23HubNm444SIB2QNPkNdZcxHGhci1BpAeVDwcQ,9186
+auto_editor/make_layers.py,sha256=JAel8N1wr3NSmd0LRhEQsMDHQILqcMXjGDZ_qTrs5No,10076
+auto_editor/preview.py,sha256=pBCw21wTORG0-Zs4Zf2anCecTNlnfiCq50tINeOcFmg,2815
+auto_editor/timeline.py,sha256=84k-sSK3c2kTZ28atPoIaWgSecZvO-fOGfsXFlmifP4,8165
 auto_editor/vanparse.py,sha256=Ug5A2QaRqGiw4l55Z_h9T2QU1x0WqRibR7yY5rQ0WTk,10002
 auto_editor/cmds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 auto_editor/cmds/cache.py,sha256=rK06dX3Z1pDAK0t5rqR7S2cMEpnT_Tv17t3Q5qPQKLI,1959
-auto_editor/cmds/desc.py,sha256=kdRJfabdde5thuFOoTXlW3J3G8F0ZvbsJoOkUn7E3GA,805
+auto_editor/cmds/desc.py,sha256=VKs6ibRMbC4I4ro5Qh2B-3xsfnYSwunkyEvgHidBTqk,805
 auto_editor/cmds/info.py,sha256=NwzZu6l6IIdK0ajZdn8WX_iiJwlsMrGIZ2vffDRu3gc,6535
-auto_editor/cmds/levels.py,sha256=2Hbvoy6wMbRRoHdZf25PMqq1uvhRKyPcITNPMpZFo7s,5632
+auto_editor/cmds/levels.py,sha256=sHaaDqCCU8fwV311kL_otVCBanrD37m8KvsIs5BQ1HY,5853
 auto_editor/cmds/palet.py,sha256=t2O_xM82PXUjnSgcHxyt9OG24gwQS4ksR2sKiQ1SvUA,743
 auto_editor/cmds/repl.py,sha256=HSUTDaVykPb5Bd-v_jz_8R7HvFmKOcT_ZVmP-d0AbUY,3247
-auto_editor/cmds/subdump.py,sha256=Zxs9X0gEaQYA5F1EqccJmVUYfI1o3J7ltyc9bvy1tA4,2393
-auto_editor/cmds/test.py,sha256=p7z2cojsiyWnRN_UVeT4iYakkGlsQTjt_dRZ4cSvIQg,29835
+auto_editor/cmds/subdump.py,sha256=QPMX-Tb5ZIU857-u6UXSMf2pkoJON-OQ1zuZjhOFQgk,2393
+auto_editor/cmds/test.py,sha256=sFAbMKC_kTEIvFCjK7sm9cb2HL-ZyE0dNGCJpz-le9M,29946
 auto_editor/exports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-auto_editor/exports/fcp11.py,sha256=LiWHtA-jgwzbiSoBzNBUaTjOEuqnvr3dYBQmdlw7m3Y,5244
+auto_editor/exports/fcp11.py,sha256=uOonQPBoSQSfUpdi58vqDgpZdmN6Jevm2YNPo9m9nI0,6195
 auto_editor/exports/fcp7.py,sha256=shZtn5i66hqGVrpR1PP1hiwKiZirr1cRUxATzbW-BOo,12069
-auto_editor/exports/json.py,sha256=Z7RKtD5-OB3saOtWG9qfI9OrLtylhU9VyfpnVRNcuU8,768
-auto_editor/exports/shotcut.py,sha256=MpzYqDO_XSnd-bKCKQjJFqOf_mSdR9QOWi8_Y1Y_BwY,4696
+auto_editor/exports/json.py,sha256=Q176-MtctEyPVenxbjuhMx_j8oVx-_G4Zwa-PJ3f7oQ,1579
+auto_editor/exports/kdenlive.py,sha256=ZgMivXb2pBEF9zvU0Mnfm_a7CGupcb02jCt9EwDjwoQ,11798
+auto_editor/exports/shotcut.py,sha256=miIOvzM73tUJcHFCe7fUu66YZxEvlDSkV1PHxv8ED8k,4699
 auto_editor/imports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 auto_editor/imports/fcp7.py,sha256=Vep1syViRZOrtZBlF6Ek_eRy0rLINpTso5nrh3uY3zk,8563
 auto_editor/imports/json.py,sha256=5c_vKoS8FzxAWagCetrwATHdnZ2beWQ77g8JYKVM0i8,6993
@@ -30,27 +31,27 @@ auto_editor/lang/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 auto_editor/lang/libintrospection.py,sha256=6H1rGp0wqaCud5IPaoEmzULGnYt6ec7_0h32ATcw2oY,261
 auto_editor/lang/libmath.py,sha256=z33A161Oe6vYYK7R6pgYjdZZe63dQkN38Qf36TL3prg,847
 auto_editor/lang/palet.py,sha256=bsuEWNEefTb0-69Dc4lq4aotqu7aarH1okETK8ab-Gw,22794
-auto_editor/lang/stdenv.py,sha256=munuKA5rkg_5krQ_km92JhoNY6Vio9wo5E79YWlD2eg,43654
+auto_editor/lang/stdenv.py,sha256=Ier6zmn8eFd6cpMdgHnnShjmxXXPWH1ItGyqZQvSkjc,43475
 auto_editor/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 auto_editor/lib/contracts.py,sha256=bADXnFXyq_-Tku59saxwDOlvexfS3wMAMdrKNL-Ql2w,7494
 auto_editor/lib/data_structs.py,sha256=2SxsOXKiY0H95wRIFOrQBjv1ykJUQar0Vr5dK9zZOiQ,6971
 auto_editor/lib/err.py,sha256=UlszQJdzMZwkbT8x3sY4GkCV_5x9yrd6uVVUzvA8iiI,35
 auto_editor/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-auto_editor/render/audio.py,sha256=08Leg9R66ROz8meZyY03e7yfUd5otxdd6DdNO9vX5ys,17518
-auto_editor/render/subtitle.py,sha256=F27T8OsAojUIGTGBWqTdH36h0BnHXSExxIqzOtqyZoE,6129
-auto_editor/render/video.py,sha256=8somlAxtbGMSRREab8psTdIlaETZQ2s2gY20PWY9sww,12072
+auto_editor/render/audio.py,sha256=O4aUBfyLg4-6QmyXoOjwnKmw3n5ZMHvFJKGzu07BpgM,17629
+auto_editor/render/subtitle.py,sha256=6zPRbW2ksoBMDMm449vslLqs8v7htDEe5MRFEjXCGog,6129
+auto_editor/render/video.py,sha256=hrj2b6xJ7cu7JeALF_XaOOxGtJfYYvXAEIgylEXrh9k,11964
 auto_editor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 auto_editor/utils/bar.py,sha256=Ky9JRf37JTgLyvNuIXDfucaUE8H1vBbCqKLjttmsmmo,4156
 auto_editor/utils/chunks.py,sha256=J-eGKtEz68gFtRrj1kOSgH4Tj_Yz6prNQ7Xr-d9NQJw,52
 auto_editor/utils/cmdkw.py,sha256=aUGBvBel2Ko1o6Rwmr4rEL-BMc5hEnzYLbyZ1GeJdcY,5729
-auto_editor/utils/container.py,sha256=CNHChHbhzIrjmDdWw6UzMqscrr9u7A-ZqKWejGjJwYE,2628
+auto_editor/utils/container.py,sha256=tdvTsY5kcz46DAQ7jvKoXk_UPzhsz430kSKEHL7RUTQ,2615
 auto_editor/utils/func.py,sha256=ODyjXnzSDatEu08w398K8_xBKYdXMY3IPHiJpGRZDyQ,3250
-auto_editor/utils/log.py,sha256=wPNf6AabV-0cnoS_bPLv1Lh7llQBtNqPKeh07einOuc,3701
+auto_editor/utils/log.py,sha256=hTBpBpadu6uD161Uhi0X5Ks7aA1azbtjXVNmN_sz1ko,3748
 auto_editor/utils/types.py,sha256=j2hd4zMQ9EftDy41Ji2_PFru_7HEZObd9yKA0BJxFaY,7616
-auto_editor-28.0.1.dist-info/licenses/LICENSE,sha256=yiq99pWITHfqS0pbZMp7cy2dnbreTuvBwudsU-njvIM,1210
+auto_editor-28.1.0.dist-info/licenses/LICENSE,sha256=yiq99pWITHfqS0pbZMp7cy2dnbreTuvBwudsU-njvIM,1210
 docs/build.py,sha256=g1uc1H9T_naGaermUiVMMwUpbT0IWElRhjgT0fvCh8w,1914
-auto_editor-28.0.1.dist-info/METADATA,sha256=DqTFmUbe3CYS0CefGlNadtwH80JaemOw0MOCXtDGCsg,6176
-auto_editor-28.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-auto_editor-28.0.1.dist-info/entry_points.txt,sha256=UAsTc7qJQbnAzHd7KWg-ALo_X9Hj2yDs3M9I2DV3eyI,212
-auto_editor-28.0.1.dist-info/top_level.txt,sha256=jBV5zlbWRbKOa-xaWPvTD45QL7lGExx2BDzv-Ji4dTw,17
-auto_editor-28.0.1.dist-info/RECORD,,
+auto_editor-28.1.0.dist-info/METADATA,sha256=KEs0ikYYnmLrSLLhJXU4tgU9_LZGcCqWl82DjgGfmJI,6165
+auto_editor-28.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+auto_editor-28.1.0.dist-info/entry_points.txt,sha256=UAsTc7qJQbnAzHd7KWg-ALo_X9Hj2yDs3M9I2DV3eyI,212
+auto_editor-28.1.0.dist-info/top_level.txt,sha256=jBV5zlbWRbKOa-xaWPvTD45QL7lGExx2BDzv-Ji4dTw,17
+auto_editor-28.1.0.dist-info/RECORD,,