auto-editor 25.1.0__py3-none-any.whl → 25.3.0__py3-none-any.whl

auto_editor/lang/stdenv.py

@@ -20,6 +20,7 @@ if TYPE_CHECKING:
 
 
 def make_standard_env() -> dict[str, Any]:
+    import os.path
     from cmath import sqrt as complex_sqrt
     from functools import reduce
     from operator import add, ge, gt, is_, le, lt, mod, mul
@@ -135,6 +136,22 @@ def make_standard_env() -> dict[str, Any]:
         Sym("float64"): np.float64,
     }
 
+    @dataclass(slots=True)
+    class InputPort:
+        name: str
+        port: Any
+        closed: bool
+
+        def close(self) -> None:
+            if not self.closed:
+                self.closed = True
+                self.port.close()
+
+        def __str__(self) -> str:
+            return f"#<input-port:{self.name}>"
+
+        __repr__ = __str__
+
     @dataclass(slots=True)
     class OutputPort:
         name: str
@@ -152,6 +169,13 @@ def make_standard_env() -> dict[str, Any]:
 
         __repr__ = __str__
 
+    def initInPort(name: str) -> InputPort | Literal[False]:
+        try:
+            port = open(name, encoding="utf-8")
+        except Exception:
+            return False
+        return InputPort(name, port, False)
+
     def initOutPort(name: str) -> OutputPort | Literal[False]:
         try:
             port = open(name, "w", encoding="utf-8")
@@ -198,14 +222,20 @@ def make_standard_env() -> dict[str, Any]:
         parms: list[str] = []
         for item in node[1]:
             if type(item) is not Sym:
-                raise MyError(f"{node[0]}: must be an identifier")
+                raise MyError(f"{node[0]}: must be an identifier, got: {item} {type(item)}")
 
             parms.append(f"{item}")
 
         return UserProc(env, "", parms, (), node[2:])
 
     def syn_define(env: Env, node: Node) -> None:
+        if len(node) < 2:
+            raise MyError(f"{node[0]}: too few terms")
         if len(node) < 3:
+            if type(node[1]) is Sym:
+                raise MyError(f"{node[0]}: what should `{node[1]}` be defined as?")
+            elif type(node[1]) is tuple and len(node[1]) > 0:
+                raise MyError(f"{node[0]}: function `{node[1][0]}` needs a body.")
             raise MyError(f"{node[0]}: too few terms")
 
         if type(node[1]) is tuple:
@@ -437,6 +467,11 @@ def make_standard_env() -> dict[str, Any]:
             raise MyError(f"{node[0]}: Expected string? got: {print_str(num)}")
         env[name] += num
 
+    def syn_while(env: Env, node: Node) -> None:
+        while my_eval(env, node[1]) == True:
+            for c in node[2:]:
+                my_eval(env, c)
+
     def syn_for(env: Env, node: Node) -> None:
         var, my_iter = check_for_syntax(env, node)
 
@@ -808,6 +843,12 @@ def make_standard_env() -> dict[str, Any]:
             return f"{val.real}{join}{val.imag}i"
         return f"{val}"
 
+    def string_to_number(val) -> float:
+        try:
+            return float(val)
+        except Exception:
+            raise MyError(f"failed to convert {val} to number")
+
     def palet_join(v: Any, s: str) -> str:
         try:
             return s.join(v)
@@ -943,6 +984,7 @@ def make_standard_env() -> dict[str, Any]:
         # loops
         "for": Syntax(syn_for),
         "for-items": Syntax(syn_for_items),
+        "while": Syntax(syn_while),
         # contracts
         "number?": is_num,
         "real?": is_real,
@@ -1102,10 +1144,20 @@ def make_standard_env() -> dict[str, Any]:
             ),
         ),
         # i/o
+        "file-exists?": Proc("file-exists", os.path.isfile, (1, 1), is_str),
+        "open-input-file": Proc("open-input-file", initInPort, (1, 1), is_str),
+        "input-port?": (ip := Contract("input-port?", lambda v: type(v) is InputPort)),
+        "read-line": Proc("read-line",
+            lambda f: (r := f.port.readline(), None if r == "" else r.rstrip())[-1],
+            (1, 1), ip),
         "open-output-file": Proc("open-output-file", initOutPort, (1, 1), is_str),
         "output-port?": (op := Contract("output-port?", lambda v: type(v) is OutputPort)),
-        "close-port": Proc("close-port", OutputPort.close, (1, 1), op),
-        "closed?": Proc("closed?", lambda o: o.closed, (1, 1), op),
+        "port?": (port := Contract("port?", orc(ip, op))),
+        "close-port": Proc("close-port", lambda p: p.close, (1, 1), port),
+        "closed?": Proc("closed?", lambda o: o.closed, (1, 1), port),
+        # subprocess
+        "system": Proc("system", palet_system, (1, 1), is_str),
+        "system*": Proc("system*", palet_system_star, (1, None), is_str),
         # printing
         "display": Proc("display",
             lambda v, f=None: print(display_str(v), end="", file=f), (1, 2), any_p, op),
@@ -1119,10 +1171,9 @@ def make_standard_env() -> dict[str, Any]:
         "assert": Proc("assert", palet_assert, (1, 2), any_p, orc(is_str, False)),
         "error": Proc("error", raise_, (1, 1), is_str),
         "sleep": Proc("sleep", sleep, (1, 1), is_int_or_float),
-        "system": Proc("system", palet_system, (1, 1), is_str),
-        "system*": Proc("system*", palet_system_star, (1, None), is_str),
         # conversions
         "number->string": Proc("number->string", number_to_string, (1, 1), is_num),
+        "string->number": Proc("string->number", string_to_number, (1, 1), is_str),
         "string->vector": Proc(
             "string->vector", lambda s: [Char(c) for c in s], (1, 1), is_str
         ),

auto_editor/lib/contracts.py

@@ -118,6 +118,10 @@ class Proc:
 
         if kws is not None:
             for key, val in kwargs.items():
+                if key not in kws:
+                    raise MyError(
+                        f"{self.name} got an unexpected keyword argument: {key}"
+                    )
                 check = cont[-1] if kws[key] >= len(cont) else cont[kws[key]]
                 if not check_contract(check, val):
                     exp = f"{check}" if callable(check) else print_str(check)

auto_editor/lib/data_structs.py

@@ -54,12 +54,14 @@ class Env:
 
 
 class Sym:
-    __slots__ = ("val", "hash")
+    __slots__ = ("val", "hash", "lineno", "column")
 
-    def __init__(self, val: str):
+    def __init__(self, val: str, lineno: int = -1, column: int = -1):
         assert isinstance(val, str)
         self.val = val
         self.hash = hash(val)
+        self.lineno = lineno
+        self.column = column
 
     def __str__(self) -> str:
         return self.val

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/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/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/render/video.py

@@ -57,21 +57,6 @@ allowed_pix_fmt = {
 }
 
 
-def apply_anchor(x: int, y: int, w: int, h: int, anchor: str) -> tuple[int, int]:
-    if anchor == "ce":
-        x = (x * 2 - w) // 2
-        y = (y * 2 - h) // 2
-    if anchor == "tr":
-        x -= w
-    if anchor == "bl":
-        y -= h
-    if anchor == "br":
-        x -= w
-        y -= h
-    # Use 'tl' by default
-    return x, y
-
-
 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))
@@ -292,7 +277,7 @@ def render_av(
                         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)
+                    x, y = obj.x, obj.y
                     graph.link_nodes(
                         graph.add_buffer(template=my_stream),
                         graph.add(
@@ -307,9 +292,7 @@ def render_av(
                     array = frame.to_ndarray(format="rgb24")
 
                     overlay_h, overlay_w, _ = img.shape
-                    x_pos, y_pos = apply_anchor(
-                        obj.x, obj.y, overlay_w, overlay_h, obj.anchor
-                    )
+                    x_pos, y_pos = obj.x, obj.y
 
                     x_start = max(x_pos, 0)
                     y_start = max(y_pos, 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/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/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/timeline.py

@@ -3,17 +3,20 @@ 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 anchor, color, natural, number, threshold
+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)
@@ -88,7 +91,6 @@ class TlImage:
     y: int
     width: int
     opacity: float
-    anchor: str
 
     def as_dict(self) -> dict:
         return {
@@ -100,7 +102,6 @@ class TlImage:
             "y": self.y,
             "width": self.width,
             "opacity": self.opacity,
-            "anchor": self.anchor,
         }
 
 
@@ -112,7 +113,6 @@ class TlRect:
     y: int
     width: int
     height: int
-    anchor: str
     fill: str
 
     def as_dict(self) -> dict:
@@ -124,7 +124,6 @@ class TlRect:
             "y": self.y,
             "width": self.width,
             "height": self.height,
-            "anchor": self.anchor,
             "fill": self.fill,
         }
 
@@ -157,7 +156,6 @@ img_builder = pAttrs(
     pAttr("y", Required, is_int, int),
     pAttr("width", 0, is_nat, natural),
     pAttr("opacity", 1, is_threshold, threshold),
-    pAttr("anchor", "ce", is_str, anchor),
 )
 rect_builder = pAttrs(
     "rect",
@@ -167,7 +165,6 @@ rect_builder = pAttrs(
     pAttr("y", Required, is_int, int),
     pAttr("width", Required, is_int, int),
     pAttr("height", Required, is_int, int),
-    pAttr("anchor", "ce", is_str, anchor),
     pAttr("fill", "#c4c4c4", is_str, color),
 )
 visual_objects = {
@@ -247,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:
@@ -282,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