auto-editor 25.2.0__tar.gz → 25.3.0__tar.gz

{auto_editor-25.2.0 → auto_editor-25.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 25.2.0
+Version: 25.3.0
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense

auto_editor-25.3.0/auto_editor/__init__.py

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

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/__main__.py

@@ -254,6 +254,11 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         flag=True,
         help="Disable the inclusion of subtitle streams in the output file",
     )
+    parser.add_argument(
+        "-dn",
+        flag=True,
+        help="Disable the inclusion of data streams in the output file",
+    )
     parser.add_argument(
         "--extras",
         metavar="CMD",

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/analyze.py

@@ -19,6 +19,7 @@ from auto_editor.utils.subtitle_tools import convert_ass_to_text
 if TYPE_CHECKING:
     from collections.abc import Iterator
     from fractions import Fraction
+    from pathlib import Path
     from typing import Any
 
     from numpy.typing import NDArray
@@ -70,15 +71,6 @@ def mut_remove_large(
             active = False
 
 
-def obj_tag(tag: str, tb: Fraction, obj: dict[str, Any]) -> str:
-    key = f"{tag}:{tb}:"
-    for k, v in obj.items():
-        key += f"{k}={v},"
-
-    key = key[:-1]  # remove unnecessary char
-    return key
-
-
 def iter_audio(src, tb: Fraction, stream: int = 0) -> Iterator[np.float32]:
     fifo = AudioFifo()
     try:
@@ -122,7 +114,7 @@ def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[np.floa
 
     prev_frame = None
     current_frame = None
-    total_pixels = src.videos[0].width * src.videos[0].height
+    total_pixels = None
     index = 0
     prev_index = -1
 
@@ -140,10 +132,13 @@ def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[np.floa
             continue
 
         graph.push(unframe)
-        frame = graph.pull()
+        frame = graph.vpull()
         assert frame.time is not None
         index = round(frame.time * tb)
 
+        if total_pixels is None:
+            total_pixels = frame.width * frame.height
+
         current_frame = frame.to_ndarray()
         if prev_frame is None:
             value = np.float32(0.0)
@@ -161,6 +156,12 @@ def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[np.floa
     container.close()
 
 
+def obj_tag(path: Path, kind: str, tb: Fraction, obj: dict[str, Any]) -> str:
+    mod_time = int(path.stat().st_mtime)
+    key = f"{path.name}:{mod_time:x}:{kind}:{tb}:"
+    return key + ",".join(f"{v}" for v in obj.values())
+
+
 @dataclass(slots=True)
 class Levels:
     src: FileInfo
@@ -201,7 +202,7 @@ class Levels:
     def all(self) -> NDArray[np.bool_]:
         return np.zeros(self.media_length, dtype=np.bool_)
 
-    def read_cache(self, tag: str, obj: dict[str, Any]) -> None | np.ndarray:
+    def read_cache(self, kind: str, obj: dict[str, Any]) -> None | np.ndarray:
         if self.no_cache:
             return None
 
@@ -213,14 +214,14 @@ class Levels:
             self.log.debug(e)
             return None
 
-        key = f"{self.src.path}:{obj_tag(tag, self.tb, obj)}"
+        key = obj_tag(self.src.path, kind, self.tb, obj)
         if key not in npzfile.files:
             return None
 
         self.log.debug("Using cache")
         return npzfile[key]
 
-    def cache(self, arr: np.ndarray, tag: str, obj: dict[str, Any]) -> np.ndarray:
+    def cache(self, arr: np.ndarray, kind: str, obj: dict[str, Any]) -> np.ndarray:
         if self.no_cache:
             return arr
 
@@ -228,8 +229,8 @@ class Levels:
         if not os.path.exists(workdur):
             os.mkdir(workdur)
 
-        tag = obj_tag(tag, self.tb, obj)
-        np.savez(os.path.join(workdur, "cache.npz"), **{f"{self.src.path}:{tag}": arr})
+        key = obj_tag(self.src.path, kind, self.tb, obj)
+        np.savez(os.path.join(workdur, "cache.npz"), **{key: arr})
 
         return arr
 

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/edit.py

@@ -11,7 +11,7 @@ from auto_editor.render.audio import make_new_audio
 from auto_editor.render.subtitle import make_new_subtitles
 from auto_editor.render.video import render_av
 from auto_editor.timeline import v1, v3
-from auto_editor.utils.bar import Bar
+from auto_editor.utils.bar import initBar
 from auto_editor.utils.chunks import Chunk, Chunks
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
 from auto_editor.utils.container import Container, container_constructor
@@ -125,7 +125,9 @@ def parse_export(export: str, log: Log) -> dict[str, Any]:
         "default": pAttrs("default"),
         "premiere": pAttrs("premiere", name_attr),
         "resolve-fcp7": pAttrs("resolve-fcp7", name_attr),
-        "final-cut-pro": pAttrs("final-cut-pro", name_attr),
+        "final-cut-pro": pAttrs(
+            "final-cut-pro", name_attr, pAttr("version", 11, is_int)
+        ),
         "resolve": pAttrs("resolve", name_attr),
         "shotcut": pAttrs("shotcut"),
         "json": pAttrs("json", pAttr("api", 3, is_int)),
@@ -146,7 +148,7 @@ def parse_export(export: str, log: Log) -> dict[str, Any]:
 
 
 def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
-    bar = Bar(args.progress)
+    bar = initBar(args.progress)
     tl = None
 
     if paths:
@@ -232,11 +234,19 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
         fcp7_write_xml(export_ops["name"], output, is_resolve, tl, log)
         return
 
-    if export in ("final-cut-pro", "resolve"):
+    if export == "final-cut-pro":
         from auto_editor.formats.fcp11 import fcp11_write_xml
 
-        is_resolve = export.startswith("resolve")
-        fcp11_write_xml(export_ops["name"], ffmpeg, output, is_resolve, tl, log)
+        ver = export_ops["version"]
+        fcp11_write_xml(export_ops["name"], ver, output, False, tl, log)
+        return
+
+    if export == "resolve":
+        from auto_editor.formats.fcp11 import fcp11_write_xml
+        from auto_editor.timeline import set_stream_to_0
+
+        set_stream_to_0(tl, log)
+        fcp11_write_xml(export_ops["name"], 10, output, True, tl, log)
         return
 
     if export == "shotcut":

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/ffwrapper.py

@@ -127,6 +127,31 @@ class FFmpeg:
         return output
 
 
+def mux(input: Path, output: Path, stream: int, codec: str | None = None) -> None:
+    input_container = av.open(input, "r")
+    output_container = av.open(output, "w")
+
+    input_audio_stream = input_container.streams.audio[stream]
+
+    if codec is None:
+        codec = "pcm_s16le"
+
+    output_audio_stream = output_container.add_stream(codec)
+    assert isinstance(output_audio_stream, av.audio.AudioStream)
+
+    for frame in input_container.decode(input_audio_stream):
+        packet = output_audio_stream.encode(frame)
+        if packet:
+            output_container.mux(packet)
+
+    packet = output_audio_stream.encode(None)
+    if packet:
+        output_container.mux(packet)
+
+    output_container.close()
+    input_container.close()
+
+
 @dataclass(slots=True, frozen=True)
 class VideoStream:
     width: int
@@ -269,7 +294,7 @@ def initFileInfo(path: str, log: Log) -> FileInfo:
 
     desc = cont.metadata.get("description", None)
     bitrate = 0 if cont.bit_rate is None else cont.bit_rate
-    dur = 0 if cont.duration is None else cont.duration / 1_000_000
+    dur = 0 if cont.duration is None else cont.duration / av.time_base
 
     cont.close()
 

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/formats/fcp11.py

@@ -3,17 +3,15 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, cast
 from xml.etree.ElementTree import Element, ElementTree, SubElement, indent
 
-from auto_editor.ffwrapper import FFmpeg, FileInfo, initFileInfo
-
-from .utils import make_tracks_dir
-
 if TYPE_CHECKING:
     from collections.abc import Sequence
     from fractions import Fraction
 
+    from auto_editor.ffwrapper import FileInfo
     from auto_editor.timeline import TlAudio, TlVideo, v3
     from auto_editor.utils.log import Log
 
+
 """
 Export a FCPXML 11 file readable with Final Cut Pro 10.6.8 or later.
 
@@ -54,7 +52,7 @@ def make_name(src: FileInfo, tb: Fraction) -> str:
 
 
 def fcp11_write_xml(
-    group_name: str, ffmpeg: FFmpeg, output: str, resolve: bool, tl: v3, log: Log
+    group_name: str, version: int, output: str, resolve: bool, tl: v3, log: Log
 ) -> None:
     def fraction(val: int) -> str:
         if val == 0:
@@ -68,23 +66,17 @@ def fcp11_write_xml(
     src_dur = int(src.duration * tl.tb)
     tl_dur = src_dur if resolve else tl.out_len()
 
-    all_srcs: list[FileInfo] = [src]
-    all_refs: list[str] = ["r2"]
-    if resolve and len(src.audios) > 1:
-        fold = make_tracks_dir(src)
-
-        for i in range(1, len(src.audios)):
-            newtrack = fold / f"{i}.wav"
-            ffmpeg.run(
-                ["-i", f"{src.path.resolve()}", "-map", f"0:a:{i}", f"{newtrack}"]
-            )
-            all_srcs.append(initFileInfo(f"{newtrack}", log))
-            all_refs.append(f"r{(i + 1) * 2}")
+    if version == 11:
+        ver_str = "1.11"
+    elif version == 10:
+        ver_str = "1.10"
+    else:
+        log.error(f"Unknown final cut pro version: {version}")
 
-    fcpxml = Element("fcpxml", version="1.10" if resolve else "1.11")
+    fcpxml = Element("fcpxml", version=ver_str)
     resources = SubElement(fcpxml, "resources")
 
-    for i, one_src in enumerate(all_srcs):
+    for i, one_src in enumerate(tl.unique_sources()):
         SubElement(
             resources,
             "format",
@@ -126,13 +118,6 @@ def fcp11_write_xml(
     )
     spine = SubElement(sequence, "spine")
 
-    if tl.v and tl.v[0]:
-        clips: Sequence[TlVideo | TlAudio] = cast(Any, tl.v[0])
-    elif tl.a and tl.a[0]:
-        clips = tl.a[0]
-    else:
-        clips = []
-
     def make_clip(ref: str, clip: TlVideo | TlAudio) -> None:
         clip_properties = {
             "name": proj_name,
@@ -157,7 +142,19 @@ def fcp11_write_xml(
                 interp="smooth2",
             )
 
-    for my_ref in all_refs:
+    if tl.v and tl.v[0]:
+        clips: Sequence[TlVideo | TlAudio] = cast(Any, tl.v[0])
+    elif tl.a and tl.a[0]:
+        clips = tl.a[0]
+    else:
+        clips = []
+
+    all_refs: list[str] = ["r2"]
+    if resolve:
+        for i in range(1, len(tl.a)):
+            all_refs.append(f"r{(i + 1) * 2}")
+
+    for my_ref in reversed(all_refs):
         for clip in clips:
             make_clip(my_ref, clip)
 

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/formats/utils.py

@@ -4,9 +4,6 @@ from typing import TYPE_CHECKING
 from xml.etree.ElementTree import Element
 
 if TYPE_CHECKING:
-    from pathlib import Path
-
-    from auto_editor.ffwrapper import FileInfo
     from auto_editor.utils.log import Log
 
 
@@ -19,21 +16,6 @@ def show(ele: Element, limit: int, depth: int = 0) -> None:
             show(child, limit, depth + 1)
 
 
-def make_tracks_dir(src: FileInfo) -> Path:
-    from os import mkdir
-    from shutil import rmtree
-
-    fold = src.path.parent / f"{src.path.stem}_tracks"
-
-    try:
-        mkdir(fold)
-    except OSError:
-        rmtree(fold)
-        mkdir(fold)
-
-    return fold
-
-
 class Validator:
     def __init__(self, log: Log):
         self.log = log

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/output.py

@@ -46,9 +46,9 @@ class Ensure:
             astream = in_container.streams.audio[stream]
 
             if astream.duration is None or astream.time_base is None:
-                dur = 1
+                dur = 1.0
             else:
-                dur = int(astream.duration * astream.time_base)
+                dur = float(astream.duration * astream.time_base)
 
             bar.start(dur, "Extracting audio")
 
@@ -58,8 +58,8 @@ class Ensure:
 
             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)
+                if i % 1500 == 0 and frame.time is not None:
+                    bar.tick(frame.time)
 
                 for new_frame in resampler.resample(frame):
                     for packet in output_astream.encode(new_frame):
@@ -237,8 +237,8 @@ def mux_quality_media(
     if s_tracks > 0:
         cmd.extend(["-map", "0:t?"])  # Add input attachments to output.
 
-    # This was causing a crash for 'example.mp4 multi-track.mov'
-    # cmd.extend(["-map", "0:d?"])
+    if not args.dn:
+        cmd.extend(["-map", "0:d?"])
 
     cmd.append(output_path)
     ffmpeg.run_check_errors(cmd, log, path=output_path)

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/preview.py

@@ -7,7 +7,7 @@ from typing import TextIO
 
 from auto_editor.analyze import Levels
 from auto_editor.timeline import v3
-from auto_editor.utils.bar import Bar
+from auto_editor.utils.bar import initBar
 from auto_editor.utils.func import to_timecode
 from auto_editor.utils.log import Log
 
@@ -65,7 +65,7 @@ def preview(tl: v3, log: Log) -> None:
 
     in_len = 0
     for src in all_sources:
-        in_len += Levels(src, tb, Bar("none"), False, log, False).media_length
+        in_len += Levels(src, tb, initBar("none"), False, log, False).media_length
 
     out_len = tl.out_len()
 

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/render/audio.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import io
 from pathlib import Path
 from platform import system
 from subprocess import PIPE
 
+import av
 import numpy as np
 
 from auto_editor.ffwrapper import FFmpeg, FileInfo
@@ -12,7 +14,7 @@ from auto_editor.lang.palet import env
 from auto_editor.lib.contracts import andc, between_c, is_int_or_float
 from auto_editor.lib.err import MyError
 from auto_editor.output import Ensure
-from auto_editor.timeline import v3
+from auto_editor.timeline import TlAudio, v3
 from auto_editor.utils.bar import Bar
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
 from auto_editor.utils.log import Log
@@ -165,6 +167,68 @@ def apply_audio_normalization(
     ffmpeg.run(["-i", f"{pre_master}"] + cmd + [f"{path}"])
 
 
+def process_audio_clip(
+    clip: TlAudio, samp_list: AudioData, samp_start: int, samp_end: int, sr: int
+) -> AudioData:
+    input_buffer = io.BytesIO()
+    write(input_buffer, sr, samp_list[samp_start:samp_end])
+    input_buffer.seek(0)
+
+    input_file = av.open(input_buffer, "r")
+    input_stream = input_file.streams.audio[0]
+
+    output_bytes = io.BytesIO()
+    output_file = av.open(output_bytes, mode="w", format="wav")
+    output_stream = output_file.add_stream("pcm_s16le", rate=sr)
+    assert isinstance(output_stream, av.audio.AudioStream)
+
+    graph = av.filter.Graph()
+    args = [graph.add_abuffer(template=input_stream)]
+
+    if clip.speed != 1:
+        if clip.speed > 10_000:
+            for _ in range(3):
+                args.append(graph.add("atempo", f"{clip.speed ** (1/3)}"))
+        elif clip.speed > 100:
+            for _ in range(2):
+                args.append(graph.add("atempo", f"{clip.speed ** 0.5}"))
+        elif clip.speed >= 0.5:
+            args.append(graph.add("atempo", f"{clip.speed}"))
+        else:
+            start = 0.5
+            while start * 0.5 > clip.speed:
+                start *= 0.5
+                args.append(graph.add("atempo", "0.5"))
+            args.append(graph.add("atempo", f"{clip.speed / start}"))
+
+    if clip.volume != 1:
+        args.append(graph.add("volume", f"{clip.volume}"))
+
+    args.append(graph.add("abuffersink"))
+    graph.link_nodes(*args).configure()
+
+    for frame in input_file.decode(input_stream):
+        graph.push(frame)
+        while True:
+            try:
+                aframe = graph.pull()
+                assert isinstance(aframe, av.audio.AudioFrame)
+                for packet in output_stream.encode(aframe):
+                    output_file.mux(packet)
+            except (av.BlockingIOError, av.EOFError):
+                break
+
+    # Flush the stream
+    for packet in output_stream.encode(None):
+        output_file.mux(packet)
+
+    input_file.close()
+    output_file.close()
+
+    output_bytes.seek(0)
+    return read(output_bytes)[1]
+
+
 def make_new_audio(
     tl: v3, ensure: Ensure, args: Args, ffmpeg: FFmpeg, bar: Bar, log: Log
 ) -> list[str]:
@@ -175,7 +239,6 @@ def make_new_audio(
 
     norm = parse_norm(args.audio_normalize, log)
 
-    af_tick = 0
     temp = log.temp
 
     if not tl.a or not tl.a[0]:
@@ -191,7 +254,8 @@ def make_new_audio(
         for c, clip in enumerate(layer):
             if (clip.src, clip.stream) not in samples:
                 audio_path = ensure.audio(clip.src, clip.stream)
-                samples[(clip.src, clip.stream)] = read(audio_path)[1]
+                with open(audio_path, "rb") as file:
+                    samples[(clip.src, clip.stream)] = read(file)[1]
 
             if arr is None:
                 leng = max(round((layer[-1].start + layer[-1].dur) * sr / tb), sr // tb)
@@ -214,42 +278,10 @@ def make_new_audio(
             if samp_end > len(samp_list):
                 samp_end = len(samp_list)
 
-            filters: list[str] = []
-
-            if clip.speed != 1:
-                if clip.speed > 10_000:
-                    filters.extend([f"atempo={clip.speed}^.33333"] * 3)
-                elif clip.speed > 100:
-                    filters.extend(
-                        [f"atempo=sqrt({clip.speed})", f"atempo=sqrt({clip.speed})"]
-                    )
-                elif clip.speed >= 0.5:
-                    filters.append(f"atempo={clip.speed}")
-                else:
-                    start = 0.5
-                    while start * 0.5 > clip.speed:
-                        start *= 0.5
-                        filters.append("atempo=0.5")
-                    filters.append(f"atempo={clip.speed / start}")
-
-            if clip.volume != 1:
-                filters.append(f"volume={clip.volume}")
-
-            if not filters:
-                clip_arr = samp_list[samp_start:samp_end]
+            if clip.speed != 1 or clip.volume != 1:
+                clip_arr = process_audio_clip(clip, samp_list, samp_start, samp_end, sr)
             else:
-                af = Path(temp, f"af{af_tick}.wav")
-                af_out = Path(temp, f"af{af_tick}_out.wav")
-
-                # Windows can't replace a file that's already in use, so we have to
-                # cycle through file names.
-                af_tick = (af_tick + 1) % 3
-
-                with open(af, "wb") as fid:
-                    write(fid, sr, samp_list[samp_start:samp_end])
-
-                ffmpeg.run(["-i", f"{af}", "-af", ",".join(filters), f"{af_out}"])
-                clip_arr = read(f"{af_out}")[1]
+                clip_arr = samp_list[samp_start:samp_end]
 
             # Mix numpy arrays
             start = clip.start * sr // tb

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/subcommands/levels.py

@@ -11,7 +11,7 @@ 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.utils.bar import Bar
+from auto_editor.utils.bar import initBar
 from auto_editor.utils.cmdkw import (
     ParserError,
     Required,
@@ -83,7 +83,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
     parser = levels_options(ArgumentParser("levels"))
     args = parser.parse_args(LevelArgs, sys_args)
 
-    bar = Bar("none")
+    bar = initBar("none")
     log = Log(quiet=True)
 
     sources = [initFileInfo(path, log) for path in args.input]

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/subcommands/repl.py

@@ -11,7 +11,7 @@ from auto_editor.lang.palet import ClosingError, Lexer, Parser, env, interpret
 from auto_editor.lang.stdenv import make_standard_env
 from auto_editor.lib.data_structs import print_str
 from auto_editor.lib.err import MyError
-from auto_editor.utils.bar import Bar
+from auto_editor.utils.bar import initBar
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import frame_rate
 from auto_editor.vanparse import ArgumentParser
@@ -64,9 +64,8 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
         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")
         env["timebase"] = tb
-        env["@levels"] = Levels(src, tb, bar, False, log, strict)
+        env["@levels"] = Levels(src, tb, initBar("modern"), False, log, strict)
 
     env.update(make_standard_env())
     print(f"Auto-Editor {auto_editor.__version__}")

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/subcommands/test.py

@@ -405,7 +405,8 @@ def main(sys_args: list[str] | None = None):
             test_file = f"resources/{test_name}"
             results.add(run.main([test_file], []))
             run.main([test_file], ["--edit", "none"])
-            results.add(run.main([test_file], ["-exf"]))
+            results.add(run.main([test_file], ["--export", "final-cut-pro:version=10"]))
+            results.add(run.main([test_file], ["--export", "final-cut-pro:version=11"]))
             results.add(run.main([test_file], ["-exs"]))
             results.add(run.main([test_file], ["--export_as_clip_sequence"]))
             run.main([test_file], ["--stats"])

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/timeline.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+from auto_editor.ffwrapper import initFileInfo, mux
 from auto_editor.lib.contracts import *
 from auto_editor.utils.cmdkw import Required, pAttr, pAttrs
 from auto_editor.utils.types import color, natural, number, threshold
@@ -10,10 +11,12 @@ from auto_editor.utils.types import color, natural, number, threshold
 if TYPE_CHECKING:
     from collections.abc import Iterator
     from fractions import Fraction
+    from pathlib import Path
     from typing import Any
 
     from auto_editor.ffwrapper import FileInfo
     from auto_editor.utils.chunks import Chunks
+    from auto_editor.utils.log import Log
 
 
 @dataclass(slots=True)
@@ -241,6 +244,13 @@ video\n"""
             for a in aclips:
                 yield a.src
 
+    def unique_sources(self) -> Iterator[FileInfo]:
+        seen = set()
+        for source in self.sources:
+            if source.path not in seen:
+                seen.add(source.path)
+                yield source
+
     def _duration(self, layer: Any) -> int:
         total_dur = 0
         for clips in layer:
@@ -276,3 +286,38 @@ video\n"""
             "v": v,
             "a": a,
         }
+
+
+def make_tracks_dir(path: Path) -> Path:
+    from os import mkdir
+    from shutil import rmtree
+
+    tracks_dir = path.parent / f"{path.stem}_tracks"
+
+    try:
+        mkdir(tracks_dir)
+    except OSError:
+        rmtree(tracks_dir)
+        mkdir(tracks_dir)
+
+    return tracks_dir
+
+
+def set_stream_to_0(tl: v3, log: Log) -> None:
+    src = tl.src
+    assert src is not None
+    fold = make_tracks_dir(src.path)
+    cache: dict[Path, FileInfo] = {}
+
+    def make_track(i: int, path: Path) -> FileInfo:
+        newtrack = fold / f"{path.stem}_{i}.wav"
+        if newtrack not in cache:
+            mux(path, output=newtrack, stream=i)
+            cache[newtrack] = initFileInfo(f"{newtrack}", log)
+        return cache[newtrack]
+
+    for alayer in tl.a:
+        for aobj in alayer:
+            if aobj.stream > 0:
+                aobj.src = make_track(aobj.stream, aobj.src.path)
+                aobj.stream = 0

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/utils/bar.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import sys
+from dataclasses import dataclass
 from math import floor
 from shutil import get_terminal_size
 from time import localtime, time
@@ -8,39 +9,50 @@ from time import localtime, time
 from .func import get_stdout_bytes
 
 
-class Bar:
-    def __init__(self, bar_type: str) -> None:
-        self.machine = False
-        self.hide = False
+def initBar(bar_type: str) -> Bar:
+    icon = "⏳"
+    chars: tuple[str, ...] = (" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█")
+    brackets = ("|", "|")
+    machine = hide = False
+
+    if bar_type == "classic":
+        icon = "⏳"
+        chars = ("░", "█")
+        brackets = ("[", "]")
+    if bar_type == "ascii":
+        icon = "& "
+        chars = ("-", "#")
+        brackets = ("[", "]")
+    if bar_type == "machine":
+        machine = True
+    if bar_type == "none":
+        hide = True
+
+    part_width = len(chars) - 1
+
+    ampm = True
+    if sys.platform == "darwin" and bar_type in ("modern", "classic", "ascii"):
+        try:
+            date_format = get_stdout_bytes(
+                ["defaults", "read", "com.apple.menuextra.clock", "Show24Hour"]
+            )
+            ampm = date_format == b"0\n"
+        except FileNotFoundError:
+            pass
 
-        self.icon = "⏳"
-        self.chars: tuple[str, ...] = (" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█")
-        self.brackets = ("|", "|")
+    return Bar(icon, chars, brackets, machine, hide, part_width, ampm, [])
 
-        if bar_type == "classic":
-            self.icon = "⏳"
-            self.chars = ("░", "█")
-            self.brackets = ("[", "]")
-        if bar_type == "ascii":
-            self.icon = "& "
-            self.chars = ("-", "#")
-            self.brackets = ("[", "]")
-        if bar_type == "machine":
-            self.machine = True
-        if bar_type == "none":
-            self.hide = True
-
-        self.part_width = len(self.chars) - 1
-
-        self.ampm = True
-        if sys.platform == "darwin" and bar_type in ("modern", "classic", "ascii"):
-            try:
-                date_format = get_stdout_bytes(
-                    ["defaults", "read", "com.apple.menuextra.clock", "Show24Hour"]
-                )
-                self.ampm = date_format == b"0\n"
-            except FileNotFoundError:
-                pass
+
+@dataclass(slots=True)
+class Bar:
+    icon: str
+    chars: tuple[str, ...]
+    brackets: tuple[str, str]
+    machine: bool
+    hide: bool
+    part_width: int
+    ampm: bool
+    stack: list[tuple[str, int, float, float]]
 
     @staticmethod
     def pretty_time(my_time: float, ampm: bool) -> str:
@@ -62,28 +74,25 @@ class Bar:
         if self.hide:
             return
 
-        progress = 0.0 if self.total == 0 else min(1, max(0, index / self.total))
-        rate = 0.0 if progress == 0 else (time() - self.begin_time) / progress
+        title, len_title, total, begin = self.stack[-1]
+        progress = 0.0 if total == 0 else min(1, max(0, index / total))
+        rate = 0.0 if progress == 0 else (time() - begin) / progress
 
         if self.machine:
-            index = min(index, self.total)
-            secs_til_eta = round(self.begin_time + rate - time(), 2)
-            print(
-                f"{self.title}~{index}~{self.total}~{secs_til_eta}",
-                end="\r",
-                flush=True,
-            )
+            index = min(index, total)
+            secs_til_eta = round(begin + rate - time(), 2)
+            print(f"{title}~{index}~{total}~{secs_til_eta}", end="\r", flush=True)
             return
 
-        new_time = self.pretty_time(self.begin_time + rate, self.ampm)
+        new_time = self.pretty_time(begin + rate, self.ampm)
 
         percent = round(progress * 100, 1)
         p_pad = " " * (4 - len(str(percent)))
         columns = get_terminal_size().columns
-        bar_len = max(1, columns - (self.len_title + 32))
+        bar_len = max(1, columns - (len_title + 32))
         bar_str = self._bar_str(progress, bar_len)
 
-        bar = f"  {self.icon}{self.title} {bar_str} {p_pad}{percent}%  ETA {new_time}"
+        bar = f"  {self.icon}{title} {bar_str} {p_pad}{percent}%  ETA {new_time}"
 
         if len(bar) > columns - 2:
             bar = bar[: columns - 2]
@@ -93,10 +102,7 @@ class Bar:
         sys.stdout.write(bar + "\r")
 
     def start(self, total: float, title: str = "Please wait") -> None:
-        self.title = title
-        self.len_title = len(title)
-        self.total = total
-        self.begin_time = time()
+        self.stack.append((title, len(title), total, time()))
 
         try:
             self.tick(0)
@@ -124,6 +130,7 @@ class Bar:
         )
         return line
 
-    @staticmethod
-    def end() -> None:
+    def end(self) -> None:
         sys.stdout.write(" " * (get_terminal_size().columns - 2) + "\r")
+        if self.stack:
+            self.stack.pop()

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/utils/types.py

@@ -224,6 +224,7 @@ class Args:
     scale: float = 1.0
     extras: str | None = None
     sn: bool = False
+    dn: bool = False
     no_seek: bool = False
     cut_out: list[tuple[str, str]] = field(default_factory=list)
     add_in: list[tuple[str, str]] = field(default_factory=list)

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor/wavfile.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import io
 import struct
 import sys
-from typing import Literal
+from typing import TYPE_CHECKING, Literal
 
 import numpy as np
 
@@ -15,13 +15,17 @@ AudioData = np.memmap | np.ndarray
 Endian = Literal[">", "<"]  # Big Endian, Little Endian
 ByteOrd = Literal["big", "little"]
 
+if TYPE_CHECKING:
+    Reader = io.BufferedReader | io.BytesIO
+    Writer = io.BufferedWriter | io.BytesIO
+
 
 class WavError(Exception):
     pass
 
 
 def _read_fmt_chunk(
-    fid: io.BufferedReader, bytes_order: ByteOrd
+    fid: Reader, bytes_order: ByteOrd
 ) -> tuple[int, int, int, int, int]:
     size = int.from_bytes(fid.read(4), bytes_order)
 
@@ -69,7 +73,7 @@ def _read_fmt_chunk(
 
 
 def _read_data_chunk(
-    fid: io.BufferedReader,
+    fid: Reader,
     format_tag: int,
     channels: int,
     bit_depth: int,
@@ -114,16 +118,22 @@ def _read_data_chunk(
     else:
         n_samples = (size - 1) // block_align
 
-    data = np.memmap(
-        fid, dtype=dtype, mode="c", offset=fid.tell(), shape=(n_samples, channels)
-    )
-    fid.seek(size, 1)
+    if isinstance(fid, io.BufferedReader):
+        data: AudioData = np.memmap(
+            fid, dtype=dtype, mode="c", offset=fid.tell(), shape=(n_samples, channels)
+        )
+        fid.seek(size, 1)
+    else:
+        bytes_per_sample = np.dtype(dtype).itemsize
+        buffer = fid.read(n_samples * channels * bytes_per_sample)
+        data = np.frombuffer(buffer, dtype=dtype).reshape((n_samples, channels))
+
     _handle_pad_byte(fid, size)
 
     return data
 
 
-def _skip_unknown_chunk(fid: io.BufferedReader, en: Endian) -> None:
+def _skip_unknown_chunk(fid: Reader, en: Endian) -> None:
     data = fid.read(4)
 
     if len(data) == 4:
@@ -140,7 +150,7 @@ def _skip_unknown_chunk(fid: io.BufferedReader, en: Endian) -> None:
         )
 
 
-def _read_rf64_chunk(fid: io.BufferedReader) -> tuple[int, int, Endian]:
+def _read_rf64_chunk(fid: Reader) -> tuple[int, int, Endian]:
     # https://tech.ebu.ch/docs/tech/tech3306v1_0.pdf
     # https://www.itu.int/dms_pubrec/itu-r/rec/bs/R-REC-BS.2088-1-201910-I!!PDF-E.pdf
 
@@ -171,7 +181,7 @@ def _read_rf64_chunk(fid: io.BufferedReader) -> tuple[int, int, Endian]:
     return data_size, file_size, en
 
 
-def _read_riff_chunk(sig: bytes, fid: io.BufferedReader) -> tuple[None, int, Endian]:
+def _read_riff_chunk(sig: bytes, fid: Reader) -> tuple[None, int, Endian]:
     en: Endian = "<" if sig == b"RIFF" else ">"
     bytes_order: ByteOrd = "big" if en == ">" else "little"
 
@@ -184,14 +194,12 @@ def _read_riff_chunk(sig: bytes, fid: io.BufferedReader) -> tuple[None, int, End
     return None, file_size, en
 
 
-def _handle_pad_byte(fid: io.BufferedReader, size: int) -> None:
+def _handle_pad_byte(fid: Reader, size: int) -> None:
     if size % 2 == 1:
         fid.seek(1, 1)
 
 
-def read(filename: str) -> tuple[int, AudioData]:
-    fid = open(filename, "rb")
-
+def read(fid: Reader) -> tuple[int, AudioData]:
     file_sig = fid.read(4)
     if file_sig in (b"RIFF", b"RIFX"):
         data_size, file_size, en = _read_riff_chunk(file_sig, fid)
@@ -241,7 +249,7 @@ def read(filename: str) -> tuple[int, AudioData]:
     raise WavError("Found no data")
 
 
-def write(fid: io.BufferedWriter, sr: int, arr: np.ndarray) -> None:
+def write(fid: Writer, sr: int, arr: np.ndarray) -> None:
     channels = 1 if arr.ndim == 1 else arr.shape[1]
     bit_depth = arr.dtype.itemsize * 8
     block_align = channels * (bit_depth // 8)
@@ -290,7 +298,8 @@ def main() -> None:
     with open("test.wav", "wb") as file:
         write(file, 48_000, data)
 
-    read_sr, read_data = read("test.wav")
+    with open("test.wav", "rb") as file:
+        read_sr, read_data = read(file)
 
     assert read_sr == 48_000
     assert np.array_equal(data, read_data)

{auto_editor-25.2.0 → auto_editor-25.3.0}/auto_editor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 25.2.0
+Version: 25.3.0
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense

auto_editor-25.2.0/auto_editor/__init__.py

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