auto-editor 23.35.1__py3-none-any.whl → 23.40.1__py3-none-any.whl

auto_editor/lib/contracts.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable
+from dataclasses import dataclass
 from fractions import Fraction
 from typing import Any
 
@@ -8,49 +9,27 @@ from .data_structs import Sym, print_str
 from .err import MyError
 
 
-class Proc:
-    __slots__ = ("name", "proc", "arity", "contracts")
-
-    def __init__(
-        self,
-        name: str,
-        proc: Callable,
-        arity: tuple[int, int | None] = (1, None),
-        contracts: list[Any] | None = None,
-    ):
-        self.name = name
-        self.proc = proc
-        self.arity = arity
-        self.contracts = contracts
-
-    def __str__(self) -> str:
-        return f"#<procedure:{self.name}>"
-
-    __repr__ = __str__
-
-    def __call__(self, *args: Any) -> Any:
-        return self.proc(*args)
-
-
+@dataclass(slots=True)
 class Contract:
     # Convenient flat contract class
-    __slots__ = ("name", "c")
+    name: str
+    c: Callable[[object], bool]
 
-    def __init__(self, name: str, c: Callable[[object], bool]):
-        self.name = name
-        self.c = c
+    def __call__(self, *v: object) -> bool:
+        if len(v) != 1:
+            o = self.name
+            raise MyError(f"`{o}` has an arity mismatch. Expected 1, got {len(v)}")
+        return self.c(v[0])
 
     def __str__(self) -> str:
-        return f"<procedure:{self.name}>"
+        return self.name
 
-    __repr__ = __str__
-
-    def __call__(self, v: object) -> bool:
-        return self.c(v)
+    def __repr__(self) -> str:
+        return f"#<proc:{self.name} (1 1)>"
 
 
 def check_contract(c: object, val: object) -> bool:
-    if isinstance(c, Contract):
+    if type(c) is Contract:
         return c(val)
     if (
         isinstance(c, Proc)
@@ -62,16 +41,70 @@ def check_contract(c: object, val: object) -> bool:
         return val is True
     if c is False:
         return val is False
-
-    if type(c) is int:
-        return val == c
     if type(c) in (int, float, Fraction, complex, str, Sym):
         return val == c
     raise MyError(f"Invalid contract, got: {print_str(c)}")
 
 
+def check_args(
+    o: str,
+    values: list | tuple,
+    arity: tuple[int, int | None],
+    cont: tuple[Any, ...],
+) -> None:
+    lower, upper = arity
+    amount = len(values)
+
+    assert not (upper is not None and lower > upper)
+    base = f"`{o}` has an arity mismatch. Expected "
+
+    if lower == upper and len(values) != lower:
+        raise MyError(f"{base}{lower}, got {amount}")
+    if upper is None and amount < lower:
+        raise MyError(f"{base}at least {lower}, got {amount}")
+    if upper is not None and (amount > upper or amount < lower):
+        raise MyError(f"{base}between {lower} and {upper}, got {amount}")
+
+    if not cont:
+        return
+
+    for i, val in enumerate(values):
+        check = cont[-1] if i >= len(cont) else cont[i]
+        if not check_contract(check, val):
+            exp = f"{check}" if callable(check) else print_str(check)
+            raise MyError(f"`{o}` expected a {exp}, got {print_str(val)}")
+
+
+class Proc:
+    __slots__ = ("name", "proc", "arity", "contracts")
+
+    def __init__(
+        self, n: str, p: Callable, a: tuple[int, int | None] = (1, None), *c: Any
+    ):
+        self.name = n
+        self.proc = p
+        self.arity = a
+        self.contracts: tuple[Any, ...] = c
+
+    def __call__(self, *args: Any) -> Any:
+        check_args(self.name, args, self.arity, self.contracts)
+        return self.proc(*args)
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        n = "inf" if self.arity[1] is None else f"{self.arity[1]}"
+
+        if self.contracts is None:
+            c = ""
+        else:
+            c = " (" + " ".join([f"{c}" for c in self.contracts]) + ")"
+        return f"#<proc:{self.name} ({self.arity[0]} {n}){c}>"
+
+
 def is_contract(c: object) -> bool:
-    if isinstance(c, Contract):
+    if type(c) is Contract:
         return True
     if (
         isinstance(c, Proc)
@@ -86,8 +119,8 @@ def is_contract(c: object) -> bool:
 
 is_bool = Contract("bool?", lambda v: type(v) is bool)
 is_int = Contract("int?", lambda v: type(v) is int)
-is_uint = Contract("uint?", lambda v: type(v) is int and v > -1)
-is_nat = Contract("nat?", lambda v: type(v) is int and v > 0)
+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, Fraction, complex))
 is_real = Contract("real?", lambda v: type(v) in (int, float, Fraction))
@@ -105,13 +138,13 @@ is_proc = Contract("procedure?", lambda v: isinstance(v, (Proc, Contract)))
 
 def andc(*cs: object) -> Proc:
     return Proc(
-        "flat-and/c", lambda v: all([check_contract(c, v) for c in cs]), (1, 1), [any_p]
+        "flat-and/c", lambda v: all([check_contract(c, v) for c in cs]), (1, 1), any_p
     )
 
 
 def orc(*cs: object) -> Proc:
     return Proc(
-        "flat-or/c", lambda v: any([check_contract(c, v) for c in cs]), (1, 1), [any_p]
+        "flat-or/c", lambda v: any([check_contract(c, v) for c in cs]), (1, 1), any_p
     )
 
 
@@ -135,7 +168,11 @@ def lt_c(n: int | float | Fraction) -> Proc:
     return Proc(f"(</c {n})", lambda i: i < n, (1, 1), [is_real])
 
 
-def between_c(n: int | float | Fraction, m: int | float | Fraction) -> Proc:
+def between_c(n: Any, m: Any) -> Proc:
     if m > n:
-        return Proc(f"(between/c {n} {m})", lambda i: is_real(i) and i <= m and i >= n)
-    return Proc(f"(between/c {n} {m})", lambda i: is_real(i) and i <= n and i >= m)
+        return Proc(
+            f"(between/c {n} {m})", lambda i: is_real(i) and i <= m and i >= n, (1, 1)
+        )
+    return Proc(
+        f"(between/c {n} {m})", lambda i: is_real(i) and i <= n and i >= m, (1, 1)
+    )

auto_editor/lib/data_structs.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
 from fractions import Fraction
 from io import StringIO
 from typing import Any
@@ -66,6 +67,61 @@ class Sym:
         return type(obj) is Sym and self.hash == obj.hash
 
 
+class Keyword:
+    __slots__ = "val"
+
+    def __init__(self, val: str):
+        self.val = val
+
+    def __str__(self) -> str:
+        return f"#:{self.val}"
+
+    __repr__ = __str__
+
+    def __eq__(self, obj: object) -> bool:
+        return type(obj) is Keyword and self.val == obj.val
+
+
+class QuotedKeyword:
+    __slots__ = "val"
+
+    def __init__(self, val: Keyword | str):
+        self.val = val if isinstance(val, Keyword) else Keyword(val)
+
+    def __str__(self) -> str:
+        return f"{self.val}"
+
+    __repr__ = __str__
+
+    def __eq__(self, obj: object) -> bool:
+        return type(obj) is QuotedKeyword and self.val == obj.val
+
+
+class Quoted:
+    __slots__ = "val"
+
+    def __init__(self, val: list):
+        self.val = val
+
+    def __len__(self) -> int:
+        return len(self.val)
+
+    def __getitem__(self, key: int | slice) -> Any:
+        if isinstance(key, slice):
+            return Quoted(self.val[key])
+
+        return self.val[key]
+
+    def __iter__(self) -> Iterator:
+        return self.val.__iter__()
+
+    def __contains__(self, item: object) -> bool:
+        return item in self.val
+
+    def __eq__(self, obj: object) -> bool:
+        return type(obj) is Quoted and self.val == obj.val
+
+
 class Char:
     __slots__ = "val"
 
@@ -123,10 +179,20 @@ def display_str(val: object) -> str:
         return f"{val.real}{join}{val.imag}i"
     if type(val) is np.bool_:
         return "1" if val else "0"
-
-    if isinstance(val, Fraction):
+    if type(val) is Fraction:
         return f"{val.numerator}/{val.denominator}"
-    if isinstance(val, list):
+
+    if type(val) is Quoted:
+        if not val:
+            return "()"
+        result = StringIO()
+        result.write(f"({display_str(val[0])}")
+        for item in val[1:]:
+            result.write(f" {display_str(item)}")
+        result.write(")")
+        return result.getvalue()
+
+    if type(val) is list:
         if not val:
             return "#()"
         result = StringIO()
@@ -182,7 +248,9 @@ def print_str(val: object) -> str:
         return f'"{val}"'
     if type(val) is Char:
         return f"{val!r}"
-    if type(val) is Sym:
+    if type(val) is Keyword:
+        return f"'{val}"
+    if type(val) in (Sym, Quoted, QuotedKeyword):
         return f"'{display_str(val)}"
 
     return display_str(val)

auto_editor/make_layers.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any, NamedTuple
 
 import numpy as np
 
-from auto_editor.analyze import FileSetup
+from auto_editor.analyze import FileSetup, Levels
 from auto_editor.ffwrapper import FFmpeg, FileInfo
 from auto_editor.lang.palet import Lexer, Parser, env, interpret, is_boolarr
 from auto_editor.lib.data_structs import print_str
@@ -90,31 +90,40 @@ def make_av(
     return vtl, atl
 
 
-def run_interpreter(
-    text: str,
-    filesetup: FileSetup,
-    log: Log,
+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
+    temp = filesetup.temp
+    log = filesetup.log
+
     try:
         parser = Parser(Lexer("`--edit`", text))
         if log.is_debug:
             log.debug(f"edit: {parser}")
 
         env["timebase"] = filesetup.tb
+        env["@levels"] = Levels(ensure, src, tb, bar, temp, log)
         env["@filesetup"] = filesetup
 
         results = interpret(env, parser)
-    except (MyError, ZeroDivisionError) as e:
-        log.error(e)
 
-    if len(results) == 0:
-        log.error("Expression in --edit must return a bool-array, got nothing")
+        if len(results) == 0:
+            raise MyError("Expression in --edit must return a bool-array, got nothing")
 
-    result = results[-1]
-    if not is_boolarr(result):
-        log.error(
-            f"Expression in --edit must return a bool-array, got {print_str(result)}"
-        )
+        result = results[-1]
+        if callable(result):
+            result = result()
+
+        if not is_boolarr(result):
+            raise MyError(
+                f"Expression in --edit must return a bool-array, got {print_str(result)}"
+            )
+    except MyError as e:
+        log.error(e)
 
     assert isinstance(result, np.ndarray)
     return result
@@ -276,7 +285,7 @@ def make_layers(
 
     for i in map(str, inputs):
         filesetup = FileSetup(sources[i], ensure, len(inputs) < 2, tb, bar, temp, log)
-        has_loud = run_interpreter(method, filesetup, log)
+        has_loud = run_interpreter_for_edit_option(method, filesetup)
 
         if len(mark_loud) > 0:
             mut_set_range(has_loud, mark_loud, loud_speed)

auto_editor/render/video.py

@@ -117,13 +117,10 @@ def render_av(
 
     apply_video_later = True
 
-    if args.video_codec in encoders:
-        apply_video_later = encoders[args.video_codec]["pix_fmt"].isdisjoint(
-            allowed_pix_fmt
-        )
-
     if args.scale != 1:
         apply_video_later = False
+    elif args.video_codec in encoders:
+        apply_video_later = set(encoders[args.video_codec]).isdisjoint(allowed_pix_fmt)
 
     log.debug(f"apply video quality settings now: {not apply_video_later}")
 

auto_editor/subcommands/repl.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 from fractions import Fraction
 
 import auto_editor
-from auto_editor.analyze import FileSetup
+from auto_editor.analyze import FileSetup, Levels
 from auto_editor.ffwrapper import FFmpeg, FileInfo
 from auto_editor.lang.palet import ClosingError, Lexer, Parser, env, interpret
 from auto_editor.lib.data_structs import print_str
@@ -77,9 +77,10 @@ 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, src.get_sr(), temp, log)
-        filesetup = FileSetup(src, ensure, strict, tb, Bar("none"), temp, log)
+        bar = Bar("none")
         env["timebase"] = tb
-        env["@filesetup"] = filesetup
+        env["@levels"] = Levels(ensure, src, tb, bar, temp, log)
+        env["@filesetup"] = FileSetup(src, ensure, strict, tb, bar, temp, log)
 
     print(f"Auto-Editor {auto_editor.version} ({auto_editor.__version__})")
     text = None

auto_editor/subcommands/test.py

@@ -649,8 +649,8 @@ def main(sys_args: list[str] | None = None):
             ("(- 10.5 3)", 7.5),
             ("(* 11.5 3)", 34.5),
             ("(/ 3/4 4)", Fraction(3, 16)),
-            ("(/ 5)", Fraction(1, 5)),
-            ("(/ 6 1)", 6),
+            ("(/ 5)", 0.2),
+            ("(/ 6 1)", 6.0),
             ("30/1", Fraction(30)),
             ("(sqrt -4)", 2j),
             ("(pow 2 3)", 8),
@@ -683,7 +683,7 @@ def main(sys_args: list[str] | None = None):
             ("(float? 21)", False),
             ("(frac? 4/5)", True),
             ("(frac? 3.4)", False),
-            ('(string-append "Hello" " World")', "Hello World"),
+            ('(& "Hello" " World")', "Hello World"),
             ('(define apple "Red Wood") apple', "Red Wood"),
             ("(= 1 1.0)", True),
             ("(= 1 2)", False),

auto_editor/timeline.py

@@ -100,59 +100,59 @@ class TlEllipse(_Visual):
 
 video_builder = pAttrs(
     "video",
-    pAttr("start", Required, is_uint),
-    pAttr("dur", Required, is_uint),
+    pAttr("start", Required, is_nat),
+    pAttr("dur", Required, is_nat),
     pAttr("src", Required, is_str),
     pAttr("offset", 0, is_int),
     pAttr("speed", 1, is_real),
-    pAttr("stream", 0, is_uint),
+    pAttr("stream", 0, is_nat),
 )
 audio_builder = pAttrs(
     "audio",
-    pAttr("start", Required, is_uint),
-    pAttr("dur", Required, is_uint),
+    pAttr("start", Required, is_nat),
+    pAttr("dur", Required, is_nat),
     pAttr("src", Required, is_str),
     pAttr("offset", 0, is_int),
     pAttr("speed", 1, is_real),
     pAttr("volume", 1, is_real),
-    pAttr("stream", 0, is_uint),
+    pAttr("stream", 0, is_nat),
 )
 text_builder = pAttrs(
     "text",
-    pAttr("start", Required, is_uint),
-    pAttr("dur", Required, is_uint),
+    pAttr("start", Required, is_nat),
+    pAttr("dur", Required, is_nat),
     pAttr("content", Required, is_str),
     pAttr("x", 0.5, is_real),
     pAttr("y", 0.5, is_real),
     pAttr("font", "Arial", is_str),
-    pAttr("size", 55, is_uint),
+    pAttr("size", 55, is_nat),
     pAttr("align", "left", is_str),
     pAttr("opacity", 1, is_threshold),
     pAttr("anchor", "ce", is_str),
     pAttr("rotate", 0, is_real),
     pAttr("fill", "#FFF", is_str),
-    pAttr("stroke", 0, is_uint),
+    pAttr("stroke", 0, is_nat),
     pAttr("strokecolor", "#000", is_str),
 )
 
 img_builder = pAttrs(
     "image",
-    pAttr("start", Required, is_uint),
-    pAttr("dur", Required, is_uint),
+    pAttr("start", Required, is_nat),
+    pAttr("dur", Required, is_nat),
     pAttr("src", Required, is_str),
     pAttr("x", 0.5, is_real),
     pAttr("y", 0.5, is_real),
     pAttr("opacity", 1, is_threshold),
     pAttr("anchor", "ce", is_str),
     pAttr("rotate", 0, is_real),
-    pAttr("stroke", 0, is_uint),
+    pAttr("stroke", 0, is_nat),
     pAttr("strokecolor", "#000", is_str),
 )
 
 rect_builder = pAttrs(
     "rect",
-    pAttr("start", Required, is_uint),
-    pAttr("dur", Required, is_uint),
+    pAttr("start", Required, is_nat),
+    pAttr("dur", Required, is_nat),
     pAttr("x", Required, is_real),
     pAttr("y", Required, is_real),
     pAttr("width", Required, is_real),
@@ -161,7 +161,7 @@ rect_builder = pAttrs(
     pAttr("anchor", "ce", is_str),
     pAttr("rotate", 0, is_real),
     pAttr("fill", "#c4c4c4", is_str),
-    pAttr("stroke", 0, is_uint),
+    pAttr("stroke", 0, is_nat),
     pAttr("strokecolor", "#000", is_str),
 )
 ellipse_builder = rect_builder