auto-editor 24.29.1__py3-none-any.whl → 24.30.1__py3-none-any.whl

auto_editor/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "24.29.1"
-version = "24w29a"
+__version__ = "24.30.1"
+version = "24w30a"

auto_editor/analyze.py

@@ -4,23 +4,25 @@ import os
 import re
 from dataclasses import dataclass
 from fractions import Fraction
+from math import ceil
 from typing import TYPE_CHECKING
 
+import av
 import numpy as np
+from av.audio.fifo import AudioFifo
+from av.subtitles.subtitle import AssSubtitle
 
 from auto_editor import version
 from auto_editor.utils.subtitle_tools import convert_ass_to_text
-from auto_editor.wavfile import read
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator
     from fractions import Fraction
     from typing import Any
 
-    from av.filter import FilterContext
     from numpy.typing import NDArray
 
     from auto_editor.ffwrapper import FileInfo
-    from auto_editor.output import Ensure
     from auto_editor.utils.bar import Bar
     from auto_editor.utils.log import Log
 
@@ -28,7 +30,6 @@ if TYPE_CHECKING:
 @dataclass(slots=True)
 class FileSetup:
     src: FileInfo
-    ensure: Ensure
     strict: bool
     tb: Fraction
     bar: Bar
@@ -40,11 +41,6 @@ class LevelError(Exception):
     pass
 
 
-def link_nodes(*nodes: FilterContext) -> None:
-    for c, n in zip(nodes, nodes[1:]):
-        c.link_to(n)
-
-
 def mut_remove_small(
     arr: NDArray[np.bool_], lim: int, replace: int, with_: int
 ) -> None:
@@ -92,9 +88,90 @@ def obj_tag(tag: str, tb: Fraction, obj: dict[str, Any]) -> str:
     return key
 
 
+def iter_audio(src, tb: Fraction, stream: int = 0) -> Iterator[float]:
+    fifo = AudioFifo()
+    try:
+        container = av.open(src.path, "r")
+        audio_stream = container.streams.audio[stream]
+        sample_rate = audio_stream.rate
+
+        exact_size = (1 / tb) * sample_rate
+        accumulated_error = 0
+
+        # Resample so that audio data is between [-1, 1]
+        resampler = av.AudioResampler(
+            av.AudioFormat("flt"), audio_stream.layout, sample_rate
+        )
+
+        for frame in container.decode(audio=stream):
+            frame.pts = None  # Skip time checks
+
+            for reframe in resampler.resample(frame):
+                fifo.write(reframe)
+
+            while fifo.samples >= ceil(exact_size):
+                size_with_error = exact_size + accumulated_error
+                current_size = round(size_with_error)
+                accumulated_error = size_with_error - current_size
+
+                audio_chunk = fifo.read(current_size)
+                assert audio_chunk is not None
+                arr = audio_chunk.to_ndarray().flatten()
+                yield float(np.max(np.abs(arr)))
+
+    finally:
+        container.close()
+
+
+def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[float]:
+    container = av.open(src.path, "r")
+
+    video = container.streams.video[stream]
+    video.thread_type = "AUTO"
+
+    prev_frame = None
+    current_frame = None
+    total_pixels = src.videos[0].width * src.videos[0].height
+    index = 0
+    prev_index = -1
+
+    graph = av.filter.Graph()
+    graph.link_nodes(
+        graph.add_buffer(template=video),
+        graph.add("scale", f"{width}:-1"),
+        graph.add("format", "gray"),
+        graph.add("gblur", f"sigma={blur}"),
+        graph.add("buffersink"),
+    ).configure()
+
+    for unframe in container.decode(video):
+        if unframe.pts is None:
+            continue
+
+        graph.push(unframe)
+        frame = graph.pull()
+        assert frame.time is not None
+        index = round(frame.time * tb)
+
+        current_frame = frame.to_ndarray()
+        if prev_frame is None:
+            value = 0.0
+        else:
+            # Use `int16` to avoid underflow with `uint8` datatype
+            diff = np.abs(prev_frame.astype(np.int16) - current_frame.astype(np.int16))
+            value = np.count_nonzero(diff) / total_pixels
+
+        for _ in range(index - prev_index):
+            yield value
+
+        prev_frame = current_frame
+        prev_index = index
+
+    container.close()
+
+
 @dataclass(slots=True)
 class Levels:
-    ensure: Ensure
     src: FileInfo
     tb: Fraction
     bar: Bar
@@ -107,26 +184,16 @@ class Levels:
             if (arr := self.read_cache("audio", {"stream": 0})) is not None:
                 return len(arr)
 
-            sr, samples = read(self.ensure.audio(self.src, 0))
-            samp_count = len(samples)
-            del samples
-
-            samp_per_ticks = sr / self.tb
-            ticks = int(samp_count / samp_per_ticks)
-            self.log.debug(f"Audio Length: {ticks}")
-            self.log.debug(
-                f"... without rounding: {float(samp_count / samp_per_ticks)}"
-            )
-            return ticks
+            result = sum(1 for _ in iter_audio(self.src, self.tb, 0))
+            self.log.debug(f"Audio Length: {result}")
+            return result
 
         # If there's no audio, get length in video metadata.
-        import av
-
-        with av.open(f"{self.src.path}") as cn:
-            if len(cn.streams.video) < 1:
+        with av.open(self.src.path) as container:
+            if len(container.streams.video) == 0:
                 self.log.error("Could not get media duration")
 
-            video = cn.streams.video[0]
+            video = container.streams.video[0]
 
             if video.duration is None or video.time_base is None:
                 dur = 0
@@ -171,56 +238,70 @@ class Levels:
         return arr
 
     def audio(self, stream: int) -> NDArray[np.float64]:
-        if stream > len(self.src.audios) - 1:
+        if stream >= len(self.src.audios):
             raise LevelError(f"audio: audio stream '{stream}' does not exist.")
 
         if (arr := self.read_cache("audio", {"stream": stream})) is not None:
             return arr
 
-        sr, samples = read(self.ensure.audio(self.src, stream))
-
-        if len(samples) == 0:
-            raise LevelError(f"audio: stream '{stream}' has no samples.")
-
-        def get_max_volume(s: np.ndarray) -> float:
-            return max(float(np.max(s)), -float(np.min(s)))
-
-        max_volume = get_max_volume(samples)
-        self.log.debug(f"Max volume: {max_volume}")
+        with av.open(self.src.path, "r") as container:
+            audio = container.streams.audio[stream]
+            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)
+            else:
+                inaccurate_dur = 1024
 
-        samp_count = samples.shape[0]
-        samp_per_ticks = sr / self.tb
+        bar = self.bar
+        bar.start(inaccurate_dur, "Analyzing audio volume")
 
-        if samp_per_ticks < 1:
-            self.log.error(
-                f"audio: stream '{stream}'\n  Samplerate ({sr}) must be greater than "
-                f"or equal to timebase ({self.tb})\n"
-                "  Try `-fps 30` and/or `--sample-rate 48000`"
-            )
+        result = np.zeros((inaccurate_dur), dtype=np.float64)
+        index = 0
+        for value in iter_audio(self.src, self.tb, stream):
+            if index > len(result) - 1:
+                result = np.concatenate(
+                    (result, np.zeros((len(result)), dtype=np.float64))
+                )
+            result[index] = value
+            bar.tick(index)
+            index += 1
 
-        audio_ticks = int(samp_count / samp_per_ticks)
-        self.log.debug(
-            f"analyze: audio length: {audio_ticks} ({float(samp_count / samp_per_ticks)})"
-        )
-        self.bar.start(audio_ticks, "Analyzing audio volume")
+        bar.end()
+        return self.cache("audio", {"stream": stream}, result[:index])
 
-        threshold_list = np.zeros((audio_ticks), dtype=np.float64)
+    def motion(self, stream: int, blur: int, width: int) -> NDArray[np.float64]:
+        if stream >= len(self.src.videos):
+            raise LevelError(f"motion: video stream '{stream}' does not exist.")
 
-        if max_volume == 0:  # Prevent dividing by zero
-            return threshold_list
+        mobj = {"stream": stream, "width": width, "blur": blur}
+        if (arr := self.read_cache("motion", mobj)) is not None:
+            return arr
 
-        # Determine when audio is silent or loud.
-        for i in range(audio_ticks):
-            if i % 500 == 0:
-                self.bar.tick(i)
+        with av.open(self.src.path, "r") as container:
+            video = container.streams.video[stream]
+            inaccurate_dur = (
+                1024
+                if video.duration is None or video.time_base is None
+                else int(video.duration * video.time_base * self.tb)
+            )
 
-            start = int(i * samp_per_ticks)
-            end = min(int((i + 1) * samp_per_ticks), samp_count)
+        bar = self.bar
+        bar.start(inaccurate_dur, "Analyzing motion")
 
-            threshold_list[i] = get_max_volume(samples[start:end]) / max_volume
+        result = np.zeros((inaccurate_dur), dtype=np.float64)
+        index = 0
+        for value in iter_motion(self.src, self.tb, stream, blur, width):
+            if index > len(result) - 1:
+                result = np.concatenate(
+                    (result, np.zeros((len(result)), dtype=np.float64))
+                )
+            result[index] = value
+            bar.tick(index)
+            index += 1
 
-        self.bar.end()
-        return self.cache("audio", {"stream": stream}, threshold_list)
+        bar.end()
+        return self.cache("motion", mobj, result[:index])
 
     def subtitle(
         self,
@@ -238,9 +319,6 @@ class Levels:
         except re.error as e:
             self.log.error(e)
 
-        import av
-        from av.subtitles.subtitle import AssSubtitle, TextSubtitle
-
         try:
             container = av.open(self.src.path, "r")
             subtitle_stream = container.streams.subtitles[stream]
@@ -287,8 +365,6 @@ class Levels:
                 for sub in subset:
                     if isinstance(sub, AssSubtitle):
                         line = convert_ass_to_text(sub.ass.decode(errors="ignore"))
-                    elif isinstance(sub, TextSubtitle):
-                        line = sub.text.decode(errors="ignore")
                     else:
                         continue
 
@@ -299,68 +375,3 @@ class Levels:
         container.close()
 
         return result
-
-    def motion(self, stream: int, blur: int, width: int) -> NDArray[np.float64]:
-        import av
-
-        if stream >= len(self.src.videos):
-            raise LevelError(f"motion: video stream '{stream}' does not exist.")
-
-        mobj = {"stream": stream, "width": width, "blur": blur}
-        if (arr := self.read_cache("motion", mobj)) is not None:
-            return arr
-
-        container = av.open(f"{self.src.path}", "r")
-
-        video = container.streams.video[stream]
-        video.thread_type = "AUTO"
-
-        inaccurate_dur = 1 if video.duration is None else video.duration
-        self.bar.start(inaccurate_dur, "Analyzing motion")
-
-        prev_frame = None
-        current_frame = None
-        total_pixels = self.src.videos[0].width * self.src.videos[0].height
-        index = 0
-
-        graph = av.filter.Graph()
-        link_nodes(
-            graph.add_buffer(template=video),
-            graph.add("scale", f"{width}:-1"),
-            graph.add("format", "gray"),
-            graph.add("gblur", f"sigma={blur}"),
-            graph.add("buffersink"),
-        )
-        graph.configure()
-
-        threshold_list = np.zeros((1024), dtype=np.float64)
-
-        for unframe in container.decode(video):
-            graph.push(unframe)
-            frame = graph.pull()
-
-            # Showing progress ...
-            assert frame.time is not None
-            index = int(frame.time * self.tb)
-            if frame.pts is not None:
-                self.bar.tick(frame.pts)
-
-            current_frame = frame.to_ndarray()
-
-            if index > len(threshold_list) - 1:
-                threshold_list = np.concatenate(
-                    (threshold_list, np.zeros((len(threshold_list)), dtype=np.float64)),
-                    axis=0,
-                )
-
-            if prev_frame is not None:
-                # Use `int16` to avoid underflow with `uint8` datatype
-                diff = np.abs(
-                    prev_frame.astype(np.int16) - current_frame.astype(np.int16)
-                )
-                threshold_list[index] = np.count_nonzero(diff) / total_pixels
-
-            prev_frame = current_frame
-
-        self.bar.end()
-        return self.cache("motion", mobj, threshold_list[:index])

auto_editor/edit.py

@@ -68,12 +68,8 @@ def set_video_codec(
 ) -> str:
     if codec == "auto":
         codec = "h264" if (src is None or not src.videos) else src.videos[0].codec
-        if ctr.vcodecs is not None:
-            if ctr.vstrict and codec not in ctr.vcodecs:
-                return ctr.vcodecs[0]
-
-            if codec in ctr.disallow_v:
-                return ctr.vcodecs[0]
+        if codec not in ctr.vcodecs and ctr.default_vid != "none":
+            return ctr.default_vid
         return codec
 
     if codec == "copy":
@@ -83,12 +79,7 @@ def set_video_codec(
             log.error("Input file does not have a video stream to copy codec from.")
         codec = src.videos[0].codec
 
-    if ctr.vstrict:
-        assert ctr.vcodecs is not None
-        if codec not in ctr.vcodecs:
-            log.error(codec_error.format(codec, out_ext))
-
-    if codec in ctr.disallow_v:
+    if ctr.vcodecs is not None and codec not in ctr.vcodecs:
         log.error(codec_error.format(codec, out_ext))
 
     return codec
@@ -99,8 +90,10 @@ def set_audio_codec(
 ) -> str:
     if codec == "auto":
         codec = "aac" if (src is None or not src.audios) else src.audios[0].codec
-        if ctr.acodecs is not None and codec not in ctr.acodecs:
-            return ctr.acodecs[0]
+        if codec not in ctr.acodecs and ctr.default_aud != "none":
+            return ctr.default_aud
+        if codec == "mp3float":
+            return "mp3"
         return codec
 
     if codec == "copy":
@@ -209,10 +202,8 @@ def edit_media(
     else:
         samplerate = args.sample_rate
 
-    ensure = Ensure(ffmpeg, bar, samplerate, temp, log)
-
     if tl is None:
-        tl = make_timeline(sources, ensure, args, samplerate, bar, temp, log)
+        tl = make_timeline(sources, args, samplerate, bar, temp, log)
 
     if export["export"] == "timeline":
         from auto_editor.formats.json import make_json_timeline
@@ -223,7 +214,7 @@ def edit_media(
     if args.preview:
         from auto_editor.preview import preview
 
-        preview(ensure, tl, temp, log)
+        preview(tl, temp, log)
         return
 
     if export["export"] == "json":
@@ -272,13 +263,15 @@ def edit_media(
         sub_output = []
         apply_later = False
 
-        if ctr.allow_subtitle and not args.sn:
+        ensure = Ensure(ffmpeg, bar, samplerate, temp, log)
+
+        if ctr.default_sub != "none" and not args.sn:
             sub_output = make_new_subtitles(tl, ensure, temp)
 
-        if ctr.allow_audio:
+        if ctr.default_aud != "none":
             audio_output = make_new_audio(tl, ensure, args, ffmpeg, bar, temp, log)
 
-        if ctr.allow_video:
+        if ctr.default_vid != "none":
             if tl.v:
                 out_path, apply_later = render_av(ffmpeg, tl, args, bar, ctr, temp, log)
                 visual_output.append((True, out_path))

auto_editor/make_layers.py

@@ -18,7 +18,6 @@ from auto_editor.utils.types import Args, CoerceError, time
 if TYPE_CHECKING:
     from numpy.typing import NDArray
 
-    from auto_editor.output import Ensure
     from auto_editor.utils.bar import Bar
     from auto_editor.utils.chunks import Chunks
     from auto_editor.utils.log import Log
@@ -75,7 +74,6 @@ def make_av(src: FileInfo, all_clips: list[list[Clip]]) -> tuple[VSpace, ASpace]
 def run_interpreter_for_edit_option(
     text: str, filesetup: FileSetup
 ) -> NDArray[np.bool_]:
-    ensure = filesetup.ensure
     src = filesetup.src
     tb = filesetup.tb
     bar = filesetup.bar
@@ -87,8 +85,8 @@ def run_interpreter_for_edit_option(
         if log.is_debug:
             log.debug(f"edit: {parser}")
 
-        env["timebase"] = filesetup.tb
-        env["@levels"] = Levels(ensure, src, tb, bar, temp, log)
+        env["timebase"] = tb
+        env["@levels"] = Levels(src, tb, bar, temp, log)
         env["@filesetup"] = filesetup
 
         results = interpret(env, parser)
@@ -139,7 +137,6 @@ def parse_time(val: str, arr: NDArray, tb: Fraction) -> int:  # raises: `CoerceE
 
 def make_timeline(
     sources: list[FileInfo],
-    ensure: Ensure,
     args: Args,
     sr: int,
     bar: Bar,
@@ -169,7 +166,7 @@ def make_timeline(
     concat = np.concatenate
 
     for i, src in enumerate(sources):
-        filesetup = FileSetup(src, ensure, len(sources) < 2, tb, bar, temp, log)
+        filesetup = FileSetup(src, len(sources) < 2, tb, bar, temp, log)
 
         edit_result = run_interpreter_for_edit_option(method, filesetup)
         mut_margin(edit_result, start_margin, end_margin)

auto_editor/output.py

@@ -57,7 +57,7 @@ class Ensure:
             output_astream = out_container.add_stream("pcm_s16le", rate=sample_rate)
             assert isinstance(output_astream, av.audio.stream.AudioStream)
 
-            resampler = AudioResampler(format="s16", layout="stereo", rate=sample_rate)  # type: ignore
+            resampler = AudioResampler(format="s16", layout="stereo", rate=sample_rate)
             for i, frame in enumerate(in_container.decode(astream)):
                 if i % 1500 == 0:
                     bar.tick(0 if frame.time is None else frame.time)
@@ -99,7 +99,7 @@ def _ffset(option: str, value: str | None) -> list[str]:
     return [option] + [value]
 
 
-def video_quality(args: Args, ctr: Container) -> list[str]:
+def video_quality(args: Args) -> list[str]:
     return (
         _ffset("-b:v", args.video_bitrate)
         + ["-c:v", args.video_codec]
@@ -174,7 +174,7 @@ def mux_quality_media(
     for is_video, path in visual_output:
         if is_video:
             if apply_v:
-                cmd += video_quality(args, ctr)
+                cmd += video_quality(args)
             else:
                 # Real video is only allowed on track 0
                 cmd += ["-c:v:0", "copy"]
@@ -211,7 +211,7 @@ def mux_quality_media(
             cmd.extend(["-c:s", scodec])
         elif ctr.scodecs is not None:
             if scodec not in ctr.scodecs:
-                scodec = ctr.scodecs[0]
+                scodec = ctr.default_sub
             cmd.extend(["-c:s", scodec])
 
     if a_tracks > 0:

auto_editor/preview.py

@@ -6,7 +6,6 @@ from statistics import fmean, median
 from typing import TextIO
 
 from auto_editor.analyze import Levels
-from auto_editor.output import Ensure
 from auto_editor.timeline import v3
 from auto_editor.utils.bar import Bar
 from auto_editor.utils.func import to_timecode
@@ -49,7 +48,7 @@ def all_cuts(tl: v3, in_len: int) -> list[int]:
     return cut_lens
 
 
-def preview(ensure: Ensure, tl: v3, temp: str, log: Log) -> None:
+def preview(tl: v3, temp: str, log: Log) -> None:
     log.conwrite("")
     tb = tl.tb
 
@@ -66,7 +65,7 @@ def preview(ensure: Ensure, tl: v3, temp: str, log: Log) -> None:
 
     in_len = 0
     for src in all_sources:
-        in_len += Levels(ensure, src, tb, Bar("none"), temp, log).media_length
+        in_len += Levels(src, tb, Bar("none"), temp, log).media_length
 
     out_len = tl.out_len()
 

auto_editor/render/subtitle.py

@@ -49,7 +49,7 @@ class SubtitleParser:
         self.codec = codec
         self.contents = []
 
-        if codec == "ass":
+        if codec == "ass" or codec == "ssa":
             time_code = re.compile(r"(.*)(\d+:\d+:[\d.]+)(.*)(\d+:\d+:[\d.]+)(.*)")
         elif codec == "webvtt":
             time_code = re.compile(r"()(\d+:[\d.]+)( --> )(\d+:[\d.]+)(\n.*)")

auto_editor/render/video.py

@@ -17,8 +17,6 @@ from auto_editor.utils.types import color
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
-    from av.filter import FilterContext
-
     from auto_editor.ffwrapper import FFmpeg, FileInfo
     from auto_editor.timeline import v3
     from auto_editor.utils.bar import Bar
@@ -33,11 +31,6 @@ class VideoFrame:
     src: FileInfo
 
 
-def link_nodes(*nodes: FilterContext) -> None:
-    for c, n in zip(nodes, nodes[1:]):
-        c.link_to(n)
-
-
 # From: github.com/PyAV-Org/PyAV/blob/main/av/video/frame.pyx
 allowed_pix_fmt = {
     "yuv420p",
@@ -98,12 +91,11 @@ def make_image_cache(tl: v3) -> dict[tuple[FileInfo, int], np.ndarray]:
                     for frame in cn.decode(my_stream):
                         if obj.width != 0:
                             graph = av.filter.Graph()
-                            link_nodes(
+                            graph.link_nodes(
                                 graph.add_buffer(template=my_stream),
                                 graph.add("scale", f"{obj.width}:-1"),
                                 graph.add("buffersink"),
-                            )
-                            graph.vpush(frame)
+                            ).vpush(frame)
                             frame = graph.vpull()
                         img_cache[(obj.src, obj.width)] = frame.to_ndarray(
                             format="rgb24"
@@ -177,7 +169,7 @@ def render_av(
         target_width = max(round(tl.res[0] * args.scale), 2)
         target_height = max(round(tl.res[1] * args.scale), 2)
         scale_graph = av.filter.Graph()
-        link_nodes(
+        scale_graph.link_nodes(
             scale_graph.add(
                 "buffer", video_size="1x1", time_base="1/1", pix_fmt=target_pix_fmt
             ),
@@ -213,7 +205,7 @@ def render_av(
     if apply_video_later:
         cmd += ["-c:v", "mpeg4", "-qscale:v", "1"]
     else:
-        cmd += video_quality(args, ctr)
+        cmd += video_quality(args)
 
     # Setting SAR requires re-encoding so we do it here.
     if src is not None and src.videos and (sar := src.videos[0].sar) is not None:
@@ -293,7 +285,7 @@ def render_av(
                     if (frame.width, frame.height) != tl.res:
                         width, height = tl.res
                         graph = av.filter.Graph()
-                        link_nodes(
+                        graph.link_nodes(
                             graph.add_buffer(template=my_stream),
                             graph.add(
                                 "scale",
@@ -301,21 +293,19 @@ def render_av(
                             ),
                             graph.add("pad", f"{width}:{height}:-1:-1:color={bg}"),
                             graph.add("buffersink"),
-                        )
-                        graph.vpush(frame)
+                        ).vpush(frame)
                         frame = graph.vpull()
                 elif isinstance(obj, TlRect):
                     graph = av.filter.Graph()
                     x, y = apply_anchor(obj.x, obj.y, obj.width, obj.height, obj.anchor)
-                    link_nodes(
+                    graph.link_nodes(
                         graph.add_buffer(template=my_stream),
                         graph.add(
                             "drawbox",
                             f"x={x}:y={y}:w={obj.width}:h={obj.height}:color={obj.fill}:t=fill",
                         ),
                         graph.add("buffersink"),
-                    )
-                    graph.vpush(frame)
+                    ).vpush(frame)
                     frame = graph.vpull()
                 elif isinstance(obj, TlImage):
                     img = img_cache[(obj.src, obj.width)]

auto_editor/subcommands/levels.py

@@ -2,15 +2,15 @@ from __future__ import annotations
 
 import sys
 from dataclasses import dataclass, field
+from fractions import Fraction
 from typing import TYPE_CHECKING
 
 import numpy as np
 
-from auto_editor.analyze import LevelError, Levels
-from auto_editor.ffwrapper import FFmpeg, initFileInfo
+from auto_editor.analyze import LevelError, Levels, iter_audio, iter_motion
+from auto_editor.ffwrapper import initFileInfo
 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.output import Ensure
 from auto_editor.utils.bar import Bar
 from auto_editor.utils.cmdkw import (
     ParserError,
@@ -25,6 +25,7 @@ from auto_editor.utils.types import frame_rate
 from auto_editor.vanparse import ArgumentParser
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator
     from fractions import Fraction
 
     from numpy.typing import NDArray
@@ -35,8 +36,6 @@ class LevelArgs:
     input: list[str] = field(default_factory=list)
     edit: str = "audio"
     timebase: Fraction | None = None
-    ffmpeg_location: str | None = None
-    my_ffmpeg: bool = False
     help: bool = False
 
 
@@ -54,12 +53,6 @@ def levels_options(parser: ArgumentParser) -> ArgumentParser:
         type=frame_rate,
         help="Set custom timebase",
     )
-    parser.add_argument("--ffmpeg-location", help="Point to your custom ffmpeg file")
-    parser.add_argument(
-        "--my-ffmpeg",
-        flag=True,
-        help="Use the ffmpeg on your PATH instead of the one packaged",
-    )
     return parser
 
 
@@ -79,12 +72,21 @@ def print_arr(arr: NDArray) -> None:
     print("")
 
 
+def print_arr_gen(arr: Iterator[int | float]) -> None:
+    print("")
+    print("@start")
+    for a in arr:
+        if isinstance(a, float):
+            print(f"{a:.20f}")
+        else:
+            print(a)
+    print("")
+
+
 def main(sys_args: list[str] = sys.argv[1:]) -> None:
     parser = levels_options(ArgumentParser("levels"))
     args = parser.parse_args(LevelArgs, sys_args)
 
-    ffmpeg = FFmpeg(args.ffmpeg_location, args.my_ffmpeg)
-
     bar = Bar("none")
     temp = setup_tempdir(None, Log())
     log = Log(quiet=True, temp=temp)
@@ -96,7 +98,6 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
     src = sources[0]
 
     tb = src.get_fps() if args.timebase is None else args.timebase
-    ensure = Ensure(ffmpeg, bar, src.get_sr(), temp, log)
 
     if ":" in args.edit:
         method, attrs = args.edit.split(":", 1)
@@ -131,12 +132,12 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
             except ParserError as e:
                 log.error(e)
 
-        levels = Levels(ensure, src, tb, bar, temp, log)
+        levels = Levels(src, tb, bar, temp, log)
         try:
             if method == "audio":
-                print_arr(levels.audio(**obj))
+                print_arr_gen(iter_audio(src, tb, **obj))
             elif method == "motion":
-                print_arr(levels.motion(**obj))
+                print_arr_gen(iter_motion(src, tb, **obj))
             elif method == "subtitle":
                 print_arr(levels.subtitle(**obj))
             elif method == "none":

auto_editor/subcommands/repl.py

@@ -6,11 +6,10 @@ from fractions import Fraction
 
 import auto_editor
 from auto_editor.analyze import FileSetup, Levels
-from auto_editor.ffwrapper import FFmpeg, initFileInfo
+from auto_editor.ffwrapper import initFileInfo
 from auto_editor.lang.palet import ClosingError, Lexer, Parser, env, interpret
 from auto_editor.lib.data_structs import print_str
 from auto_editor.lib.err import MyError
-from auto_editor.output import Ensure
 from auto_editor.utils.bar import Bar
 from auto_editor.utils.func import setup_tempdir
 from auto_editor.utils.log import Log
@@ -48,12 +47,6 @@ def repl_options(parser: ArgumentParser) -> ArgumentParser:
         type=frame_rate,
         help="Set custom timebase",
     )
-    parser.add_argument("--ffmpeg-location", help="Point to your custom ffmpeg file")
-    parser.add_argument(
-        "--my-ffmpeg",
-        flag=True,
-        help="Use the ffmpeg on your PATH instead of the one packaged",
-    )
     parser.add_argument(
         "--temp-dir",
         metavar="PATH",
@@ -68,16 +61,14 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
     if args.input:
         temp = setup_tempdir(args.temp_dir, Log())
         log = Log(quiet=True, temp=temp)
-        ffmpeg = FFmpeg(args.ffmpeg_location, args.my_ffmpeg, False)
         strict = len(args.input) < 2
         sources = [initFileInfo(path, log) for path in args.input]
         src = sources[0]
         tb = src.get_fps() if args.timebase is None else args.timebase
         bar = Bar("modern")
-        ensure = Ensure(ffmpeg, bar, src.get_sr(), temp, log)
         env["timebase"] = tb
-        env["@levels"] = Levels(ensure, src, tb, bar, temp, log)
-        env["@filesetup"] = FileSetup(src, ensure, strict, tb, bar, temp, log)
+        env["@levels"] = Levels(src, tb, bar, temp, log)
+        env["@filesetup"] = FileSetup(src, strict, tb, bar, temp, log)
 
     print(f"Auto-Editor {auto_editor.version} ({auto_editor.__version__})")
     text = None

auto_editor/subcommands/subdump.py

@@ -1,7 +1,7 @@
 import sys
 
 import av
-from av.subtitles.subtitle import AssSubtitle, TextSubtitle
+from av.subtitles.subtitle import AssSubtitle
 
 
 def main(sys_args: list[str] = sys.argv[1:]) -> None:
@@ -9,13 +9,10 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
         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 packet in container.demux(subtitles=s):
-                    for subset in packet.decode():
-                        for sub in subset.rects:
-                            if isinstance(sub, AssSubtitle):
-                                print(sub.ass.decode("utf-8", errors="ignore"))
-                            elif isinstance(sub, TextSubtitle):
-                                print(sub.text.decode("utf-8", errors="ignore"))
+                for subset in container.decode(subtitles=s):
+                    for sub in subset:
+                        if isinstance(sub, AssSubtitle):
+                            print(sub.ass.decode("utf-8", errors="ignore"))
         print("------")
 
 

auto_editor/utils/container.py

@@ -1,338 +1,96 @@
 from __future__ import annotations
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import TypedDict
 
+import av
+from av.codec import Codec
+
 
 class DictContainer(TypedDict, total=False):
-    allow_video: bool
-    allow_audio: bool
-    allow_subtitle: bool
-    allow_image: bool
     max_videos: int | None
     max_audios: int | None
     max_subtitles: int | None
-    vcodecs: list[str] | None
-    acodecs: list[str] | None
-    scodecs: list[str] | None
-    vstrict: bool
-    sstrict: bool
-    disallow_v: list[str]
     samplerate: list[int] | None
 
 
 @dataclass(slots=True)
 class Container:
-    allow_video: bool = False
-    allow_audio: bool = False
-    allow_subtitle: bool = False
-    allow_image: bool = False
+    allow_image: bool
+    vcodecs: set[str]
+    acodecs: set[str]
+    scodecs: set[str]
+    default_vid: str
+    default_aud: str
+    default_sub: str
     max_videos: int | None = None
     max_audios: int | None = None
     max_subtitles: int | None = None
-    vcodecs: list[str] | None = None
-    acodecs: list[str] | None = None
-    scodecs: list[str] | None = None
-    vstrict: bool = False
-    sstrict: bool = False
-    disallow_v: list[str] = field(default_factory=list)
     samplerate: list[int] | None = None  # Any samplerate is allowed
 
 
-h264_en = [
-    "h264",
-    "libx264",
-    "libx264rgb",
-    "libopenh264",
-    "h264_videotoolbox",
-    "h264_amf",
-    "h264_nvenc",
-    "h264_qsv",
-]
-hevc_en = ["hevc", "libx265", "hevc_videotoolbox", "hevc_amf", "hevc_nvenc", "hevc_qsv"]
-av1_en = ["av1", "libaom-av1", "av1_nvenc", "av1_amf"]
-prores_en = ["prores", "prores_videotoolbox", "prores_aw", "prores_ks"]
-aac_en = ["aac", "aac_at", "libfdk_aac"]
-opus_en = ["opus", "libopus"]
-
-h265: DictContainer = {
-    "allow_video": True,
-    "vcodecs": hevc_en + ["mpeg4"] + h264_en,
-}
-h264: DictContainer = {
-    "allow_video": True,
-    "vcodecs": h264_en + ["mpeg4"] + hevc_en,
-}
-aac: DictContainer = {
-    "allow_audio": True,
-    "max_audios": 1,
-    "acodecs": aac_en,
-}
-ass: DictContainer = {
-    "allow_subtitle": True,
-    "scodecs": ["ass", "ssa"],
-    "max_subtitles": 1,
-    "sstrict": True,
-}
-mp4: DictContainer = {
-    "allow_video": True,
-    "allow_audio": True,
-    "allow_subtitle": True,
-    "allow_image": True,
-    "vcodecs": h264_en + hevc_en + av1_en + ["vp9", "mpeg4", "mpeg2video", "mjpeg"],
-    "acodecs": aac_en + opus_en + ["mp3", "flac", "vorbis", "libvorbis", "ac3", "mp2"],
-    "vstrict": True,
-}
-ogg: DictContainer = {
-    "allow_video": True,
-    "allow_audio": True,
-    "allow_subtitle": True,
-    "vcodecs": ["libtheora", "theora"],
-    "acodecs": opus_en + ["libvorbis", "vorbis", "flac", "speex"],
-    "vstrict": True,
+containers: dict[str, DictContainer] = {
+    "aac": {"max_audios": 1},
+    "adts": {"max_audios": 1},
+    "ass": {"max_subtitles": 1},
+    "ssa": {"max_subtitles": 1},
+    "apng": {"max_videos": 1},
+    "gif": {"max_videos": 1},
+    "wav": {"max_audios": 1},
+    "ast": {"max_audios": 1},
+    "mp3": {"max_audios": 1},
+    "flac": {"max_audios": 1},
+    "srt": {"max_subtitles": 1},
+    "vtt": {"max_subtitles": 1},
+    "swf": {"samplerate": [44100, 22050, 11025]},
 }
 
-mka_audio = (
-    ["libvorbis", "vorbis"]
-    + aac_en
-    + opus_en
-    + [
-        "mp3",
-        "flac",
-        "ac3",
-        "mp2",
-        "wmav2",
-        "pcm_s16le",
-        "pcm_alaw",
-        "pcm_f32le",
-        "pcm_f64le",
-        "pcm_mulaw",
-        "pcm_s16be",
-        "pcm_s24be",
-        "pcm_s24le",
-        "pcm_s32be",
-        "pcm_s32le",
-        "pcm_u8",
-    ]
-)
 
-containers: dict[str, DictContainer] = {
-    # Aliases section
-    "aac": aac,
-    "adts": aac,
-    "ass": ass,
-    "ssa": ass,
-    "264": h264,
-    "h264": h264,
-    "265": h265,
-    "h265": h265,
-    "hevc": h265,
-    "mp4": mp4,
-    "m4a": mp4,
-    "ogg": ogg,
-    "ogv": ogg,
-    "apng": {
-        "allow_video": True,
-        "max_videos": 1,
-        "vcodecs": ["apng"],
-        "vstrict": True,
-    },
-    "gif": {
-        "allow_video": True,
-        "max_videos": 1,
-        "vcodecs": ["gif"],
-        "vstrict": True,
-    },
-    "wav": {
-        "allow_audio": True,
-        "max_audios": 1,
-        "acodecs": [
-            "pcm_s16le",
-            "mp3",
-            "mp2",
-            "wmav2",
-            "pcm_alaw",
-            "pcm_f32le",
-            "pcm_f64le",
-            "pcm_mulaw",
-            "pcm_s24le",
-            "pcm_s32le",
-            "pcm_u8",
-        ],
-    },
-    "ast": {
-        "allow_audio": True,
-        "max_audios": 1,
-        "acodecs": ["pcm_s16be_planar"],
-    },
-    "mp3": {
-        "allow_audio": True,
-        "max_audios": 1,
-        "acodecs": ["mp3"],
-    },
-    "opus": {
-        "allow_audio": True,
-        "acodecs": opus_en + ["flac", "libvorbis", "vorbis", "speex"],
-    },
-    "oga": {
-        "allow_audio": True,
-        "acodecs": opus_en + ["flac", "libvorbis", "vorbis", "speex"],
-    },
-    "flac": {
-        "allow_audio": True,
-        "max_audios": 1,
-        "acodecs": ["flac"],
-    },
-    "webm": {
-        "allow_video": True,
-        "allow_audio": True,
-        "allow_subtitle": True,
-        "vcodecs": ["vp9", "vp8"] + av1_en,
-        "acodecs": opus_en + ["vorbis", "libvorbis"],
-        "scodecs": ["webvtt"],
-        "vstrict": True,
-        "sstrict": True,
-    },
-    "srt": {
-        "allow_subtitle": True,
-        "scodecs": ["srt"],
-        "max_subtitles": 1,
-        "sstrict": True,
-    },
-    "vtt": {
-        "allow_subtitle": True,
-        "scodecs": ["webvtt"],
-        "max_subtitles": 1,
-        "sstrict": True,
-    },
-    "avi": {
-        "allow_video": True,
-        "allow_audio": True,
-        "vcodecs": ["mpeg4"] + h264_en + ["prores", "mjpeg", "mpeg2video", "rawvideo"],
-        "acodecs": ["mp3"]
-        + aac_en
-        + [
-            "flac",
-            "vorbis",
-            "libvorbis",
-            "mp2",
-            "wmav2",
-            "pcm_s16le",
-            "pcm_alaw",
-            "pcm_f32le",
-            "pcm_f64le",
-            "pcm_mulaw",
-            "pcm_s24le",
-            "pcm_s32le",
-            "pcm_u8",
-        ],
-        "disallow_v": hevc_en + ["apng", "gif"],
-    },
-    "wmv": {
-        "allow_video": True,
-        "allow_audio": True,
-        "vcodecs": ["msmpeg4v3"]
-        + h264_en
-        + ["mpeg4", "mpeg2video", "mjpeg", "rawvideo"],
-        "acodecs": ["wmav2"]
-        + aac_en
-        + [
-            "mp3",
-            "flac",
-            "vorbis",
-            "libvorbis",
-            "ac3",
-            "mp2",
-            "pcm_s16le",
-            "pcm_alaw",
-            "pcm_f32le",
-            "pcm_f64le",
-            "pcm_mulaw",
-            "pcm_s24le",
-            "pcm_s32le",
-            "pcm_u8",
-        ],
-        "vstrict": True,
-    },
-    "mkv": {
-        "allow_video": True,
-        "allow_audio": True,
-        "allow_subtitle": True,
-        "allow_image": True,
-        "vcodecs": h264_en
-        + hevc_en
-        + prores_en
-        + [
-            "vp9",
-            "vp8",
-            "mpeg4",
-            "mpeg2video",
-            "msmpeg4v3",
-            "mjpeg",
-            "gif",
-            "rawvideo",
-        ],
-        "acodecs": mka_audio,
-        "disallow_v": ["apng"],
-    },
-    "mka": {
-        "allow_audio": True,
-        "acodecs": mka_audio,
-    },
-    "mov": {
-        "allow_video": True,
-        "allow_audio": True,
-        "allow_subtitle": True,
-        "vcodecs": h264_en
-        + hevc_en
-        + prores_en
-        + [
-            "mpeg4",
-            "mpeg2video",
-            "msmpeg4v3",
-            "mjpeg",
-            "gif",
-            "flv1",
-            "dvvideo",
-            "rawvideo",
-        ],
-        "acodecs": aac_en
-        + [
-            "mp3",
-            "vorbis",
-            "libvorbis",
-            "ac3",
-            "mp2",
-            "wmav2",
-            "pcm_s16le",
-            "pcm_alaw",
-            "pcm_f32be",
-            "pcm_f32le",
-            "pcm_f64be",
-            "pcm_f64le",
-            "pcm_mulaw",
-            "pcm_s16be",
-            "pcm_s24be",
-            "pcm_s24le",
-            "pcm_s32be",
-            "pcm_s32le",
-            "pcm_s8",
-            "pcm_u8",
-        ],
-        "disallow_v": ["apng", "vp9", "vp8"],
-    },
-    "swf": {
-        "allow_video": True,
-        "allow_audio": True,
-        "vcodecs": ["flv1", "mjpeg"],
-        "acodecs": ["mp3"],
-        "vstrict": True,
-        "samplerate": [44100, 22050, 11025],
-    },
-}
+def codec_type(x: str) -> str:
+    if x in ("vp9", "vp8", "h264", "hevc", "av1", "gif", "apng"):
+        return "video"
+    if x in ("aac", "flac", "mp3"):
+        return "audio"
+    if x in ("ass", "ssa", "srt"):
+        return "subtitle"
+
+    try:
+        return Codec(x, "r").type
+    except Exception:
+        try:
+            return Codec(x, "w").type
+        except Exception:
+            return ""
+
+
+def container_constructor(ext: str) -> Container:
+    with av.open(f".{ext}", "w") as container:
+        codecs = container.supported_codecs
+        if ext == "webm":
+            vdefault = "vp9"
+        else:
+            vdefault = container.default_video_codec
+        adefault = container.default_audio_codec
+        sdefault = container.default_subtitle_codec
+
+    vcodecs = set()
+    acodecs = set()
+    scodecs = set()
+
+    for codec in codecs:
+        kind = codec_type(codec)
+        if kind == "video":
+            vcodecs.add(codec)
+            if codec == "h264":
+                vcodecs.add("libx264")
+        if kind == "audio":
+            acodecs.add(codec)
+        if kind == "subtitle":
+            scodecs.add(codec)
 
+    allow_image = ext in ("mp4", "mkv")
+    kwargs = containers[ext] if ext in containers else {}
 
-def container_constructor(key: str) -> Container:
-    if key in containers:
-        return Container(**containers[key])
-    return Container(allow_video=True, allow_audio=True, allow_subtitle=True)
+    return Container(
+        allow_image, vcodecs, acodecs, scodecs, vdefault, adefault, sdefault, **kwargs
+    )

{auto_editor-24.29.1.dist-info → auto_editor-24.30.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 24.29.1
+Version: 24.30.1
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense
@@ -12,7 +12,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy >=1.23.0
-Requires-Dist: pyav ==12.2.*
+Requires-Dist: pyav ==12.3.*
 Requires-Dist: ae-ffmpeg ==1.2.*
 
 <p align="center"><img src="https://auto-editor.com/img/auto-editor-banner.webp" title="Auto-Editor" width="700"></p>

{auto_editor-24.29.1.dist-info → auto_editor-24.30.1.dist-info}/RECORD

@@ -1,12 +1,12 @@
-auto_editor/__init__.py,sha256=wTE-3oMo3sa9_Thlm0qCCBVJbBZIZdsyvXop8tJpD_s,43
+auto_editor/__init__.py,sha256=2eo38rUAsDC2UUJAIJ4AZoh26SJrz93bjEMG1PMKUnQ,43
 auto_editor/__main__.py,sha256=nkb8N_bxF_qld53LWo4c6Y0n9NDRdsPfANpVF1RD1cQ,9863
-auto_editor/analyze.py,sha256=6u-J0D3tucbX1rgsc7i8MqiKSWEtSdIiyqHUeWy0JyQ,11393
-auto_editor/edit.py,sha256=EEB9PJdGpXh5b1vDdSnsEtI8aJEcF64-SNZjFRg6Nrs,11484
+auto_editor/analyze.py,sha256=6siPLoYwEjvbAzPfKZWDEcqtGXIM8n9qNveyCCYLAgI,11769
+auto_editor/edit.py,sha256=yZFLoWqfC2QFEdibp7AlKXMRB-6jHwNDpTW2SlN-4Is,11325
 auto_editor/ffwrapper.py,sha256=jga7-HbQnC4w21qZk4aY4kwLT7UPqkGn6NJPFM5Qssc,7811
 auto_editor/help.py,sha256=BFiP7vBz42TUzum4-zaQIrV1OY7kHeN0pe0MPE0T5xw,7997
-auto_editor/make_layers.py,sha256=g4NUlxiguZ7_XmLx7pd7BAk8JjYpVneVgTQN3iku7VI,9018
-auto_editor/output.py,sha256=5_4HtSkd6Lwv2ATEwLKJuXL1yBGScWAPLxvh_nHrBA4,8101
-auto_editor/preview.py,sha256=fo2BDIkvl96q_ssq8AAu1tl6FN_j23h8987aDPSmjDs,3094
+auto_editor/make_layers.py,sha256=AzfxRkm9ZFjeVwdh3jFT_5_YvVaUMtphVKDtIaDI5bo,8900
+auto_editor/output.py,sha256=OpZG3SvDRumKoU-fZOA-8-hc9pO_uBdO3WTNhDO9LHM,8065
+auto_editor/preview.py,sha256=CVKtSjcX1dNjbBgsD9PTbRBwRV6dxBLkJ_VIkkBuTUY,3032
 auto_editor/timeline.py,sha256=JwcS-8AS5vsoTL_m03aosYijScQef4AGa2lyutQ8wbI,7069
 auto_editor/validate_input.py,sha256=JQt7J5xOBJDp6lnd2sQptpYhf7Z_hyxNEzLsE9E7LKU,2596
 auto_editor/vanparse.py,sha256=p0u1X2gKM_lWB9bg-Lotqq9-bjfLgsVW9-U4Lwbz0aU,10029
@@ -27,29 +27,29 @@ auto_editor/lib/data_structs.py,sha256=EXNcdMsdmZxMRlpbXmIbRoC-YfGzvPZi7EdBQGwvp
 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=pUhD4rQZfUnyzKgpuxNxl_2CUGwbkAWo2356HUAW7VM,8835
-auto_editor/render/subtitle.py,sha256=RUG0hNh0Mbt3IRxef9hKUpUPXvyTa3HVoqoSHYivAT4,4355
-auto_editor/render/video.py,sha256=E1snevFC4mMk_S_oDquJPKyElQfdDodO7EJEQ22JJF8,13202
+auto_editor/render/subtitle.py,sha256=g195kDN0LcwKlZeQMCflXPH5n_74iwCk1RPLSQ5eP34,4373
+auto_editor/render/video.py,sha256=MOhZh72VGe0LVrDE8SzBb-FqXUrnQTIF51zz1qvX2_I,12987
 auto_editor/subcommands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 auto_editor/subcommands/desc.py,sha256=GDrKJYiHMaeTrplZAceXl1JwoqD78XsV2_5lc0Xd7po,869
 auto_editor/subcommands/info.py,sha256=7Sgt9WR0rWxe7juCRKseMxW6gKv3z3voqFcL8-MOVVM,6927
-auto_editor/subcommands/levels.py,sha256=F-hhbRSSQBEo3w57Tu70ZVIgnWL1wV9LH5JkBEKv_SM,4348
+auto_editor/subcommands/levels.py,sha256=ymHwAp2l7HScmdTtNAPDEeDfRVY_rRPRigUCDYx2F40,4220
 auto_editor/subcommands/palet.py,sha256=tbQoRWoT4jR3yu0etGApfprM-oQgXIjC-rIY-QG3nM0,655
-auto_editor/subcommands/repl.py,sha256=7Ex2CBhuLNL6U4jVqt55taDOWQMPyYqNicZaGJMxvvA,3724
-auto_editor/subcommands/subdump.py,sha256=2rIaGVtWWMBbPJ0NouPD7fY5lhk0QD_XKE_4EnAeWPw,892
+auto_editor/subcommands/repl.py,sha256=gEVmZduWwnumMe4GLHi72C_IbmdscYwiz7mjigU97Qk,3300
+auto_editor/subcommands/subdump.py,sha256=af_XBf7kaevqHn1A71z8C-7x8pS5WKD9FE_ugkCw6rk,665
 auto_editor/subcommands/test.py,sha256=UcpJp-PMcoUyz6LDD4y2V6EQ9w1ed66fPZr4GpzJReg,25050
 auto_editor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 auto_editor/utils/bar.py,sha256=RJqkJ8gNr8op_Z-2hh48ExjSonmTPX-RshctK_itv14,3988
 auto_editor/utils/chunks.py,sha256=J-eGKtEz68gFtRrj1kOSgH4Tj_Yz6prNQ7Xr-d9NQJw,52
 auto_editor/utils/cmdkw.py,sha256=XApxw7FZBOEJV9N4LHhdw1GVfHbFfCjr-zCZ1gJsSvY,6002
-auto_editor/utils/container.py,sha256=cl8wN5w-PjShPabnppil56r2dykQCfWdsR45jBbCkuo,7976
+auto_editor/utils/container.py,sha256=CWB55RRzADBuQmX8lhiPaG8iPayGWaebvtmJjgJ6WRA,2497
 auto_editor/utils/encoder.py,sha256=auNYo7HXbcU4iTUCc0LE5lpwFmSvdWvBm6-5KIaRK8w,2983
 auto_editor/utils/func.py,sha256=H38xO6Wxg1TZILVrx-nCowCzj_mqBUtJuOFp4DV3Hsc,4843
 auto_editor/utils/log.py,sha256=ry-C92PRkJ-c8PQYIs1imk1qigDYfsCoLBYK6CQSP7I,2844
 auto_editor/utils/subtitle_tools.py,sha256=TjjVPiT8bWzZJcrZjF7ddpgfIsVkLE4LyxXzBswHAGU,693
 auto_editor/utils/types.py,sha256=zWbU_VkcdP4yHHzKyaSiXu560n5U53i0x5SPkUDsCZU,11570
-auto_editor-24.29.1.dist-info/LICENSE,sha256=yiq99pWITHfqS0pbZMp7cy2dnbreTuvBwudsU-njvIM,1210
-auto_editor-24.29.1.dist-info/METADATA,sha256=2iGS5WK7jDFAhWvhPztV6gwDANq0QMvxQ134hCDS3E0,6138
-auto_editor-24.29.1.dist-info/WHEEL,sha256=-oYQCr74JF3a37z2nRlQays_SX2MqOANoqVjBBAP2yE,91
-auto_editor-24.29.1.dist-info/entry_points.txt,sha256=-H7zdTw4MqnAcwrN5xTNkGIhzZtJMxS9r6lTMeR9-aA,240
-auto_editor-24.29.1.dist-info/top_level.txt,sha256=ky1HUkqq9i034c4CUU_0wBw0xZsxxyGEak1eTbdvpyA,12
-auto_editor-24.29.1.dist-info/RECORD,,
+auto_editor-24.30.1.dist-info/LICENSE,sha256=yiq99pWITHfqS0pbZMp7cy2dnbreTuvBwudsU-njvIM,1210
+auto_editor-24.30.1.dist-info/METADATA,sha256=6PQ4JL2l2YioyyknShGetU4rsQ2Czp8EJHZzMsbo7dA,6138
+auto_editor-24.30.1.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+auto_editor-24.30.1.dist-info/entry_points.txt,sha256=-H7zdTw4MqnAcwrN5xTNkGIhzZtJMxS9r6lTMeR9-aA,240
+auto_editor-24.30.1.dist-info/top_level.txt,sha256=ky1HUkqq9i034c4CUU_0wBw0xZsxxyGEak1eTbdvpyA,12
+auto_editor-24.30.1.dist-info/RECORD,,

{auto_editor-24.29.1.dist-info → auto_editor-24.30.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (71.0.3)
+Generator: setuptools (71.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any