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

auto_editor/imports/fcp7.py

@@ -7,7 +7,7 @@ from urllib.parse import unquote
 from xml.etree.ElementTree import Element
 
 from auto_editor.ffwrapper import FileInfo
-from auto_editor.timeline import ASpace, Template, TlAudio, TlVideo, VSpace, v3
+from auto_editor.timeline import ASpace, Clip, Template, VSpace, v3
 
 if TYPE_CHECKING:
     from auto_editor.utils.log import Log
@@ -213,7 +213,7 @@ def fcp7_read_xml(path: str, log: Log) -> v3:
         for t, track in enumerate(tracks["track"]):
             if len(track["clipitem"]) > 0:
                 vobjs.append([])
-            for i, clipitem in enumerate(track["clipitem"]):
+            for clipitem in track["clipitem"]:
                 file_id = clipitem["file"].attrib["id"]
                 if file_id not in sources:
                     fileobj = parse(clipitem["file"], {"pathurl": str})
@@ -239,7 +239,7 @@ def fcp7_read_xml(path: str, log: Log) -> v3:
                 offset = clipitem["in"]
 
                 vobjs[t].append(
-                    TlVideo(start, dur, sources[file_id], offset, speed, stream=0)
+                    Clip(start, dur, sources[file_id], offset, stream=0, speed=speed)
                 )
 
     if "audio" in av:
@@ -250,7 +250,7 @@ def fcp7_read_xml(path: str, log: Log) -> v3:
         for t, track in enumerate(tracks["track"]):
             if len(track["clipitem"]) > 0:
                 aobjs.append([])
-            for i, clipitem in enumerate(track["clipitem"]):
+            for clipitem in track["clipitem"]:
                 file_id = clipitem["file"].attrib["id"]
                 if file_id not in sources:
                     fileobj = parse(clipitem["file"], {"pathurl": str})
@@ -268,9 +268,7 @@ def fcp7_read_xml(path: str, log: Log) -> v3:
                 offset = clipitem["in"]
 
                 aobjs[t].append(
-                    TlAudio(
-                        start, dur, sources[file_id], offset, speed, volume=1, stream=0
-                    )
+                    Clip(start, dur, sources[file_id], offset, stream=0, speed=speed)
                 )
 
     T = Template.init(sources[next(iter(sources))], sr, res=res)

auto_editor/imports/json.py

@@ -9,9 +9,8 @@ from auto_editor.ffwrapper import FileInfo
 from auto_editor.json import load
 from auto_editor.lib.err import MyError
 from auto_editor.timeline import (
+    Clip,
     Template,
-    TlAudio,
-    TlVideo,
     audio_builder,
     v1,
     v3,
@@ -112,7 +111,7 @@ def read_v3(tl: Any, log: Log) -> v3:
     tb = Fraction(tl["timebase"])
 
     v: Any = []
-    a: list[list[TlAudio]] = []
+    a: list[list[Clip]] = []
 
     for vlayers in tl["v"]:
         if vlayers:
@@ -141,7 +140,7 @@ def read_v3(tl: Any, log: Log) -> v3:
                     log.error(f"Unknown audio object: {adict['name']}")
 
                 try:
-                    a_out.append(TlAudio(**parse_obj(adict, audio_builder)))
+                    a_out.append(Clip(**parse_obj(adict, audio_builder)))
                 except ParserError as e:
                     log.error(e)
 
@@ -198,10 +197,10 @@ def read_v1(tl: Any, log: Log) -> v3:
         if src.videos:
             if len(vtl) == 0:
                 vtl.append([])
-            vtl[0].append(TlVideo(c.start, c.dur, c.src, c.offset, c.speed, 0))
+            vtl[0].append(Clip(c.start, c.dur, c.src, c.offset, 0, c.speed))
 
         for a in range(len(src.audios)):
-            atl[a].append(TlAudio(c.start, c.dur, c.src, c.offset, c.speed, 1, a))
+            atl[a].append(Clip(c.start, c.dur, c.src, c.offset, a, c.speed))
 
     return v3(
         src.get_fps(),

auto_editor/json.py

@@ -89,7 +89,7 @@ class Lexer:
 
                 if self.char == "u":
                     buf = ""
-                    for i in range(4):
+                    for _ in range(4):
                         self.advance()
                         if self.char is None:
                             self.error("\\u escape sequence needs 4 hexs")
@@ -162,7 +162,7 @@ class Lexer:
                 return (key, None)
 
             keyword = ""
-            for i in range(5):  # Longest valid keyword length
+            for _ in range(5):  # Longest valid keyword length
                 if self.char is None or self.char in " \t\n\r\x0b\x0c[]}{,":
                     break
                 keyword += self.char

auto_editor/lang/palet.py

@@ -65,20 +65,11 @@ class Token:
 
 
 class Lexer:
-    __slots__ = (
-        "filename",
-        "text",
-        "allow_lang_prag",
-        "pos",
-        "char",
-        "lineno",
-        "column",
-    )
-
-    def __init__(self, filename: str, text: str, langprag: bool = False):
+    __slots__ = ("filename", "text", "pos", "char", "lineno", "column")
+
+    def __init__(self, filename: str, text: str):
         self.filename = filename
         self.text = text
-        self.allow_lang_prag = langprag
         self.pos: int = 0
         self.lineno: int = 1
         self.column: int = 1
@@ -157,7 +148,7 @@ class Lexer:
                 token = SEC
             elif unit == "dB":
                 token = DB
-            elif unit != "i" and unit != "%":
+            elif unit != "%":
                 return Token(
                     VAL,
                     Sym(result + unit, self.lineno, self.column),
@@ -166,9 +157,7 @@ class Lexer:
                 )
 
         try:
-            if unit == "i":
-                return Token(VAL, complex(result + "j"), self.lineno, self.column)
-            elif unit == "%":
+            if unit == "%":
                 return Token(VAL, float(result) / 100, self.lineno, self.column)
             elif "/" in result:
                 return Token(token, Fraction(result), self.lineno, self.column)
@@ -289,32 +278,6 @@ class Lexer:
                         self.advance()
                     if self.char is None or self.char == "\n":
                         continue
-
-                elif self.char == "l" and self.peek() == "a":
-                    buf = StringIO()
-                    while self.char_is_norm():
-                        assert self.char is not None
-                        buf.write(self.char)
-                        self.advance()
-
-                    result = buf.getvalue()
-                    if result != "lang":
-                        self.error(f"Unknown hash literal `#{result}`")
-                    if not self.allow_lang_prag:
-                        self.error("#lang pragma is not allowed here")
-
-                    self.advance()
-                    buf = StringIO()
-                    while not self.is_whitespace():
-                        assert self.char is not None
-                        buf.write(self.char)
-                        self.advance()
-
-                    result = buf.getvalue()
-                    if result != "palet":
-                        self.error(f"Invalid #lang: {result}")
-                    self.allow_lang_prag = False
-                    continue
                 else:
                     return self.hash_literal()
 

auto_editor/lang/stdenv.py

@@ -19,14 +19,13 @@ if TYPE_CHECKING:
     import numpy as np
     from numpy.typing import NDArray
 
-    Number = int | float | complex | Fraction
+    Number = int | float | Fraction
     BoolList = NDArray[np.bool_]
     Node = tuple
 
 
 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
     from subprocess import run
@@ -512,7 +511,7 @@ def make_standard_env() -> dict[str, Any]:
             for c in node[2:]:
                 my_eval(env, c)
 
-    def syn_quote(env: Env, node: Node) -> Any:
+    def syn_quote(_: Env, node: Node) -> Any:
         guard_term(node, 2, 2)
         if type(node[1]) is Keyword:
             return QuotedKeyword(node[1])
@@ -828,14 +827,6 @@ def make_standard_env() -> dict[str, Any]:
 
         return reduce(lambda a, b: a // b, m, n)
 
-    def _sqrt(v: Number) -> Number:
-        r = complex_sqrt(v)
-        if r.imag == 0:
-            if int(r.real) == r.real:
-                return int(r.real)
-            return r.real
-        return r
-
     def _xor(*vals: Any) -> bool | BoolList:
         if is_boolarr(vals[0]):
             check_args("xor", vals, (2, None), (is_boolarr,))
@@ -844,9 +835,6 @@ def make_standard_env() -> dict[str, Any]:
         return reduce(lambda a, b: a ^ b, vals)
 
     def number_to_string(val: Number) -> str:
-        if isinstance(val, complex):
-            join = "" if val.imag < 0 else "+"
-            return f"{val.real}{join}{val.imag}i"
         return f"{val}"
 
     def string_to_number(val) -> float:
@@ -971,6 +959,7 @@ def make_standard_env() -> dict[str, Any]:
         # syntax
         "lambda": Syntax(syn_lambda),
         "λ": Syntax(syn_lambda),
+        "defn": Syntax(syn_define),
         "define": Syntax(syn_define),
         "define/c": Syntax(syn_definec),
         "set!": Syntax(syn_set),
@@ -997,7 +986,6 @@ def make_standard_env() -> dict[str, Any]:
         "int?": is_int,
         "float?": is_float,
         "frac?": is_frac,
-        "complex?": Contract("complex?", lambda v: type(v) is complex),
         "nat?": is_nat,
         "nat1?": is_nat1,
         "threshold?": is_threshold,
@@ -1052,9 +1040,6 @@ def make_standard_env() -> dict[str, Any]:
         "div": Proc("div", int_div, (2, None), is_int),
         "add1": Proc("add1", lambda z: z + 1, (1, 1), is_num),
         "sub1": Proc("sub1", lambda z: z - 1, (1, 1), is_num),
-        "sqrt": Proc("sqrt", _sqrt, (1, 1), is_num),
-        "real-part": Proc("real-part", lambda v: v.real, (1, 1), is_num),
-        "imag-part": Proc("imag-part", lambda v: v.imag, (1, 1), is_num),
         # reals
         "pow": Proc("pow", pow, (2, 2), is_real),
         "abs": Proc("abs", abs, (1, 1), is_real),

auto_editor/lib/contracts.py

@@ -46,7 +46,7 @@ def check_contract(c: object, val: object) -> bool:
         return val is True
     if c is False:
         return val is False
-    if type(c) in (int, float, float64, Fraction, complex, str, Sym):
+    if type(c) in (int, float, float64, Fraction, str, Sym):
         return val == c
     raise MyError(f"Invalid contract, got: {print_str(c)}")
 
@@ -164,7 +164,7 @@ def is_contract(c: object) -> bool:
         return True
     if c is True or c is False:
         return True
-    return type(c) in (int, float, Fraction, complex, str, Sym)
+    return type(c) in (int, float, Fraction, str, Sym)
 
 
 is_bool = Contract("bool?", lambda v: type(v) is bool)
@@ -172,10 +172,8 @@ is_int = Contract("int?", lambda v: type(v) is int)
 is_nat = Contract("nat?", lambda v: type(v) is int and v > -1)
 is_nat1 = Contract("nat1?", lambda v: type(v) is int and v > 0)
 int_not_zero = Contract("(or/c (not/c 0) int?)", lambda v: v != 0 and is_int(v))
-is_num = Contract(
-    "number?", lambda v: type(v) in (int, float, float64, Fraction, complex)
-)
 is_real = Contract("real?", lambda v: type(v) in (int, float, float64, Fraction))
+is_num = is_real
 is_float = Contract("float?", lambda v: type(v) in (float, float64))
 is_frac = Contract("frac?", lambda v: type(v) is Fraction)
 is_str = Contract("string?", lambda v: type(v) is str)

auto_editor/lib/data_structs.py

@@ -182,9 +182,6 @@ def display_str(val: object) -> str:
         return f"{val}"
     if type(val) is range:
         return "#<range>"
-    if type(val) is complex:
-        join = "" if val.imag < 0 else "+"
-        return f"{val.real}{join}{val.imag}i"
     if type(val) is np.bool_:
         return "1" if val else "0"
     if type(val) is np.float64 or type(val) is np.float32:

auto_editor/make_layers.py

@@ -11,7 +11,7 @@ from auto_editor.ffwrapper import FileInfo
 from auto_editor.lang.palet import Lexer, Parser, env, interpret, is_boolean_array
 from auto_editor.lib.data_structs import print_str
 from auto_editor.lib.err import MyError
-from auto_editor.timeline import ASpace, Template, TlAudio, TlVideo, VSpace, v1, v3
+from auto_editor.timeline import ASpace, Clip, Template, VSpace, v1, v3
 from auto_editor.utils.func import mut_margin
 from auto_editor.utils.types import CoerceError, time
 
@@ -26,7 +26,7 @@ if TYPE_CHECKING:
     BoolList = NDArray[np.bool_]
 
 
-class Clip(NamedTuple):
+class VirClip(NamedTuple):
     start: int
     dur: int
     offset: int
@@ -34,8 +34,8 @@ class Clip(NamedTuple):
     src: FileInfo
 
 
-def clipify(chunks: Chunks, src: FileInfo, start: int = 0) -> list[Clip]:
-    clips: list[Clip] = []
+def clipify(chunks: Chunks, src: FileInfo, start: int = 0) -> list[VirClip]:
+    clips: list[VirClip] = []
     i = 0
     for chunk in chunks:
         if chunk[2] > 0 and chunk[2] < 99999.0:
@@ -46,14 +46,14 @@ def clipify(chunks: Chunks, src: FileInfo, start: int = 0) -> list[Clip]:
             offset = int(chunk[0] / chunk[2])
 
             if not (clips and clips[-1].start == round(start)):
-                clips.append(Clip(start, dur, offset, chunk[2], src))
+                clips.append(VirClip(start, dur, offset, chunk[2], src))
             start += dur
             i += 1
 
     return clips
 
 
-def make_av(src: FileInfo, all_clips: list[list[Clip]]) -> tuple[VSpace, ASpace]:
+def make_av(src: FileInfo, all_clips: list[list[VirClip]]) -> tuple[VSpace, ASpace]:
     assert type(src) is FileInfo
     vtl: VSpace = []
     atl: ASpace = [[] for _ in range(len(src.audios))]
@@ -63,11 +63,11 @@ def make_av(src: FileInfo, all_clips: list[list[Clip]]) -> tuple[VSpace, ASpace]
             if src.videos:
                 if len(vtl) == 0:
                     vtl.append([])
-                vtl[0].append(TlVideo(c.start, c.dur, c.src, c.offset, c.speed, 0))
+                vtl[0].append(Clip(c.start, c.dur, c.src, c.offset, 0, c.speed))
 
         for c in clips:
             for a in range(len(src.audios)):
-                atl[a].append(TlAudio(c.start, c.dur, c.src, c.offset, c.speed, 1, a))
+                atl[a].append(Clip(c.start, c.dur, c.src, c.offset, a, c.speed))
 
     return vtl, atl
 
@@ -139,7 +139,7 @@ def make_timeline(
             interpret(env, parser)
 
     results = []
-    for i, src in enumerate(sources):
+    for src in sources:
         try:
             parser = Parser(Lexer("`--edit`", args.edit))
             if log.is_debug:
@@ -247,7 +247,7 @@ def make_timeline(
     check_monotonic = len(sources) == 1
     last_i = 0
 
-    clips: list[Clip] = []
+    clips: list[VirClip] = []
     start = 0
 
     for chunk in echunk(speed_index, src_index):
@@ -265,7 +265,7 @@ def make_timeline(
                     raise ValueError("not monotonic", sources, this_i, last_i)
                 last_i = this_i
 
-            clips.append(Clip(start, dur, offset, chunk[3], chunk[0]))
+            clips.append(VirClip(start, dur, offset, chunk[3], chunk[0]))
 
             start += dur
 
@@ -275,13 +275,13 @@ def make_timeline(
         if c.src.videos:
             if len(vtl) == 0:
                 vtl.append([])
-            vtl[0].append(TlVideo(c.start, c.dur, c.src, c.offset, c.speed, 0))
+            vtl[0].append(Clip(c.start, c.dur, c.src, c.offset, 0, c.speed))
 
     for c in clips:
         for a in range(len(c.src.audios)):
             if a >= len(atl):
                 atl.append([])
-            atl[a].append(TlAudio(c.start, c.dur, c.src, c.offset, c.speed, 1, a))
+            atl[a].append(Clip(c.start, c.dur, c.src, c.offset, a, c.speed))
 
     # Turn long silent/loud array to formatted chunk list.
     # Example: [1, 1, 1, 2, 2], {1: 1.0, 2: 1.5} => [(0, 3, 1.0), (3, 5, 1.5)]

auto_editor/preview.py

@@ -28,23 +28,24 @@ def time_frame(
 def all_cuts(tl: v3, in_len: int) -> list[int]:
     # Calculate cuts
     tb = tl.tb
-    oe: list[tuple[int, int]] = []
+    clip_spans: list[tuple[int, int]] = []
 
     for clip in tl.a[0]:
         old_offset = clip.offset * clip.speed
-        oe.append((round(old_offset * clip.speed), round(old_offset + clip.dur)))
+        clip_spans.append((round(old_offset), round(old_offset + clip.dur)))
 
     cut_lens = []
     i = 0
-    while i < len(oe) - 1:
-        if i == 0 and oe[i][0] != 0:
-            cut_lens.append(oe[i][1])
+    while i < len(clip_spans) - 1:
+        if i == 0 and clip_spans[i][0] != 0:
+            cut_lens.append(clip_spans[i][0])
 
-        cut_lens.append(oe[i + 1][0] - oe[i][1])
+        cut_lens.append(clip_spans[i + 1][0] - clip_spans[i][1])
         i += 1
 
-    if len(oe) > 0 and oe[-1][1] < round(in_len * tb):
-        cut_lens.append(in_len - oe[-1][1])
+    if len(clip_spans) > 0 and clip_spans[-1][1] < round(in_len / tb):
+        cut_lens.append(in_len - clip_spans[-1][1])
+
     return cut_lens
 
 
@@ -53,19 +54,9 @@ def preview(tl: v3, log: Log) -> None:
     tb = tl.tb
 
     # Calculate input videos length
-    all_sources = set()
-    for vlayer in tl.v:
-        for vclip in vlayer:
-            if hasattr(vclip, "src"):
-                all_sources.add(vclip.src)
-    for alayer in tl.a:
-        for aclip in alayer:
-            if hasattr(aclip, "src"):
-                all_sources.add(aclip.src)
-
     in_len = 0
     bar = initBar("none")
-    for src in all_sources:
+    for src in tl.unique_sources():
         in_len += initLevels(src, tb, bar, False, log).media_length
 
     out_len = len(tl)
@@ -77,7 +68,7 @@ def preview(tl: v3, log: Log) -> None:
     time_frame(fp, "output", out_len, tb, f"{round((out_len / in_len) * 100, 2)}%")
     time_frame(fp, "diff", diff, tb, f"{round((diff / in_len) * 100, 2)}%")
 
-    clip_lens = [clip.dur / clip.speed for clip in tl.a[0]]
+    clip_lens = [clip.dur for clip in tl.a[0]]
     log.debug(clip_lens)
 
     fp.write(f"clips:\n - amount:    {len(clip_lens)}\n")
@@ -90,7 +81,7 @@ def preview(tl: v3, log: Log) -> None:
 
     cut_lens = all_cuts(tl, in_len)
     log.debug(cut_lens)
-    fp.write(f"cuts:\n - amount:    {len(clip_lens)}\n")
+    fp.write(f"cuts:\n - amount:    {len(cut_lens)}\n")
     if len(cut_lens) > 0:
         time_frame(fp, "smallest", min(cut_lens), tb)
         time_frame(fp, "largest", max(cut_lens), tb)

auto_editor/render/audio.py

@@ -15,7 +15,7 @@ from auto_editor.json import load
 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.timeline import TlAudio, v3
+from auto_editor.timeline import Clip, v3
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
 from auto_editor.utils.func import parse_bitrate
 from auto_editor.utils.log import Log
@@ -155,7 +155,7 @@ def apply_audio_normalization(
         output_file.close()
 
 
-def process_audio_clip(clip: TlAudio, data: np.ndarray, sr: int) -> np.ndarray:
+def process_audio_clip(clip: Clip, data: np.ndarray, sr: int, log: Log) -> np.ndarray:
     to_s16 = bv.AudioResampler(format="s16", layout="stereo", rate=sr)
     input_buffer = BytesIO()
 
@@ -217,6 +217,9 @@ def process_audio_clip(clip: TlAudio, data: np.ndarray, sr: int) -> np.ndarray:
             except (bv.BlockingIOError, bv.EOFError):
                 break
 
+    if not all_frames:
+        log.debug(f"No audio frames at {clip=}")
+        return np.zeros_like(data)
     return np.concatenate(all_frames, axis=1)
 
 
@@ -383,7 +386,7 @@ class Getter:
 
     def __init__(self, path: Path, stream: int, rate: int):
         self.container = bv.open(path)
-        self.stream = self.container.streams.audio[0]
+        self.stream = self.container.streams.audio[stream]
         self.rate = rate
 
     def get(self, start: int, end: int) -> np.ndarray:
@@ -454,7 +457,7 @@ def _make_new_audio(tl: v3, fmt: bv.AudioFormat, args: Args, log: Log) -> list[A
         arr: np.ndarray | None = None
         use_iter = False
 
-        for c, clip in enumerate(layer):
+        for clip in layer:
             if (clip.src, clip.stream) not in samples:
                 samples[(clip.src, clip.stream)] = Getter(
                     clip.src.path, clip.stream, sr
@@ -473,7 +476,7 @@ def _make_new_audio(tl: v3, fmt: bv.AudioFormat, args: Args, log: Log) -> list[A
 
             if clip.speed != 1 or clip.volume != 1:
                 clip_arr = process_audio_clip(
-                    clip, getter.get(samp_start, samp_end), sr
+                    clip, getter.get(samp_start, samp_end), sr, log
                 )
             else:
                 clip_arr = getter.get(samp_start, samp_end)

auto_editor/render/video.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 import bv
 import numpy as np
 
-from auto_editor.timeline import TlImage, TlRect, TlVideo
+from auto_editor.timeline import Clip, TlImage, TlRect
 from auto_editor.utils.func import parse_bitrate
 
 if TYPE_CHECKING:
@@ -120,6 +120,7 @@ def render_av(
 
     del codec
     output_stream = output.add_stream(args.video_codec, rate=target_fps)
+    output_stream.options = {"x265-params": "log-level=error"}  # type: ignore
 
     cc = output_stream.codec_context
     if args.vprofile is not None:
@@ -193,7 +194,7 @@ def render_av(
         obj_list: list[VideoFrame | TlRect | TlImage] = []
         for layer in tl.v:
             for lobj in layer:
-                if isinstance(lobj, TlVideo):
+                if isinstance(lobj, Clip):
                     if index >= lobj.start and index < (lobj.start + lobj.dur):
                         _i = round((lobj.offset + index - lobj.start) * lobj.speed)
                         obj_list.append(VideoFrame(_i, lobj.src))