auto-editor 24.7.1__tar.gz → 24.9.1__tar.gz

{auto-editor-24.7.1/auto_editor.egg-info → auto-editor-24.9.1}/PKG-INFO

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

auto-editor-24.9.1/auto_editor/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "24.9.1"
+version = "24w09a"

{auto-editor-24.7.1 → auto-editor-24.9.1}/auto_editor/analyze.py

@@ -21,13 +21,10 @@ from auto_editor.lib.contracts import (
 from auto_editor.lib.data_structs import Sym
 from auto_editor.render.subtitle import SubtitleParser
 from auto_editor.utils.cmdkw import (
-    ParserError,
     Required,
-    parse_with_palet,
     pAttr,
     pAttrs,
 )
-from auto_editor.utils.func import boolop
 from auto_editor.wavfile import read
 
 if TYPE_CHECKING:
@@ -38,7 +35,6 @@ if TYPE_CHECKING:
     from numpy.typing import NDArray
 
     from auto_editor.ffwrapper import FileInfo
-    from auto_editor.lib.data_structs import Env
     from auto_editor.output import Ensure
     from auto_editor.utils.bar import Bar
     from auto_editor.utils.log import Log
@@ -412,81 +408,3 @@ class Levels:
 
         self.bar.end()
         return self.cache("motion", mobj, threshold_list[:index])
-
-
-def edit_method(val: str, filesetup: FileSetup, env: Env) -> NDArray[np.bool_]:
-    assert isinstance(filesetup, FileSetup)
-    src = filesetup.src
-    tb = filesetup.tb
-    ensure = filesetup.ensure
-    strict = filesetup.strict
-    bar = filesetup.bar
-    temp = filesetup.temp
-    log = filesetup.log
-
-    if ":" in val:
-        method, attrs = val.split(":", 1)
-    else:
-        method, attrs = val, ""
-
-    levels = Levels(ensure, src, tb, bar, temp, log)
-
-    if method == "none":
-        return levels.none()
-    if method == "all/e":
-        return levels.all()
-
-    try:
-        obj = parse_with_palet(attrs, builder_map[method], env)
-    except ParserError as e:
-        log.error(e)
-
-    try:
-        if method == "audio":
-            s = obj["stream"]
-            if s == "all" or s == Sym("all"):
-                total_list: NDArray[np.bool_] | None = None
-                for s in range(len(src.audios)):
-                    audio_list = to_threshold(levels.audio(s), obj["threshold"])
-                    if total_list is None:
-                        total_list = audio_list
-                    else:
-                        total_list = boolop(total_list, audio_list, np.logical_or)
-
-                if total_list is None:
-                    if strict:
-                        log.error("Input has no audio streams.")
-                    stream_data = levels.all()
-                else:
-                    stream_data = total_list
-            else:
-                assert isinstance(s, int)
-                stream_data = to_threshold(levels.audio(s), obj["threshold"])
-
-            assert isinstance(obj["minclip"], int)
-            assert isinstance(obj["mincut"], int)
-
-            mut_remove_small(stream_data, obj["minclip"], replace=1, with_=0)
-            mut_remove_small(stream_data, obj["mincut"], replace=0, with_=1)
-
-            return stream_data
-
-        if method == "motion":
-            return to_threshold(
-                levels.motion(obj["stream"], obj["blur"], obj["width"]),
-                obj["threshold"],
-            )
-
-        if method == "subtitle":
-            return levels.subtitle(
-                obj["pattern"],
-                obj["stream"],
-                obj["ignore_case"],
-                obj["max_count"],
-            )
-    except LevelError as e:
-        if strict:
-            log.error(e)
-
-        return levels.all()
-    raise ValueError("Unreachable")

{auto-editor-24.7.1 → auto-editor-24.9.1}/auto_editor/ffwrapper.py

@@ -239,10 +239,13 @@ def initFileInfo(path: str, ffmpeg: FFmpeg, log: Log) -> FileInfo:
             log.debug("Unexpected ffprobe shape")
 
         if v.sample_aspect_ratio is None:
-            try:
-                sar = Fraction(_sar.replace(":", "/"))
-            except Exception:
+            if _sar is None:
                 sar = Fraction(1)
+            else:
+                try:
+                    sar = Fraction(_sar.replace(":", "/"))
+                except Exception:
+                    sar = Fraction(1)
         else:
             sar = v.sample_aspect_ratio
 

{auto-editor-24.7.1 → auto-editor-24.9.1}/auto_editor/formats/fcp7.py

@@ -363,7 +363,6 @@ def media_def(
         ET.SubElement(rate, "ntsc").text = ntsc
         ET.SubElement(vschar, "width").text = f"{tl.res[0]}"
         ET.SubElement(vschar, "height").text = f"{tl.res[1]}"
-        ET.SubElement(vschar, "anamorphic").text = "FALSE"
         ET.SubElement(vschar, "pixelaspectratio").text = "square"
 
     for aud in src.audios:
@@ -389,7 +388,7 @@ def fcp7_write_xml(name: str, output: str, tl: v3, log: Log) -> None:
         src_to_id[src] = the_id
 
     xmeml = ET.Element("xmeml", version="5")
-    sequence = ET.SubElement(xmeml, "sequence")
+    sequence = ET.SubElement(xmeml, "sequence", explodedTracks="true")
     ET.SubElement(sequence, "name").text = name
     ET.SubElement(sequence, "duration").text = f"{int(tl.out_len())}"
     rate = ET.SubElement(sequence, "rate")
@@ -400,13 +399,14 @@ def fcp7_write_xml(name: str, output: str, tl: v3, log: Log) -> None:
     vformat = ET.SubElement(video, "format")
     vschar = ET.SubElement(vformat, "samplecharacteristics")
 
-    rate = ET.SubElement(vschar, "rate")
-    ET.SubElement(rate, "timebase").text = f"{timebase}"
-    ET.SubElement(rate, "ntsc").text = ntsc
     ET.SubElement(vschar, "width").text = f"{width}"
     ET.SubElement(vschar, "height").text = f"{height}"
     ET.SubElement(vschar, "pixelaspectratio").text = "square"
 
+    rate = ET.SubElement(vschar, "rate")
+    ET.SubElement(rate, "timebase").text = f"{timebase}"
+    ET.SubElement(rate, "ntsc").text = ntsc
+
     if len(tl.v) > 0 and len(tl.v[0]) > 0:
         track = ET.SubElement(video, "track")
 
@@ -420,6 +420,7 @@ def fcp7_write_xml(name: str, output: str, tl: v3, log: Log) -> None:
 
             clipitem = ET.SubElement(track, "clipitem", id=f"clipitem-{j+1}")
             ET.SubElement(clipitem, "name").text = src.path.stem
+            ET.SubElement(clipitem, "enabled").text = "TRUE"
             ET.SubElement(clipitem, "start").text = _start
             ET.SubElement(clipitem, "end").text = _end
             ET.SubElement(clipitem, "in").text = _in
@@ -433,6 +434,7 @@ def fcp7_write_xml(name: str, output: str, tl: v3, log: Log) -> None:
                 media_def(filedef, pathurl, clip.src, tl, timebase, ntsc)
                 file_defs.add(pathurl)
 
+            ET.SubElement(clipitem, "compositemode").text = "normal"
             if clip.speed != 1:
                 clipitem.append(speedup(clip.speed * 100))
 
@@ -444,8 +446,6 @@ def fcp7_write_xml(name: str, output: str, tl: v3, log: Log) -> None:
                 ET.SubElement(link, "mediatype").text = "video" if i == 0 else "audio"
                 ET.SubElement(link, "trackindex").text = str(max(i, 1))
                 ET.SubElement(link, "clipindex").text = str(j + 1)
-                if i > 0:
-                    ET.SubElement(link, "groupindex").text = "1"
 
     # Audio definitions and clips
     audio = ET.SubElement(media, "audio")
@@ -489,6 +489,7 @@ def fcp7_write_xml(name: str, output: str, tl: v3, log: Log) -> None:
                     premiereChannelType="stereo",
                 )
                 ET.SubElement(clipitem, "name").text = src.path.stem
+                ET.SubElement(clipitem, "enabled").text = "TRUE"
                 ET.SubElement(clipitem, "start").text = _start
                 ET.SubElement(clipitem, "end").text = _end
                 ET.SubElement(clipitem, "in").text = _in
@@ -502,7 +503,7 @@ def fcp7_write_xml(name: str, output: str, tl: v3, log: Log) -> None:
 
                 sourcetrack = ET.SubElement(clipitem, "sourcetrack")
                 ET.SubElement(sourcetrack, "mediatype").text = "audio"
-                ET.SubElement(sourcetrack, "trackindex").text = f"{t + 1}"
+                ET.SubElement(sourcetrack, "trackindex").text = f"{t}"
                 labels = ET.SubElement(clipitem, "labels")
                 ET.SubElement(labels, "label2").text = "Iris"
 
@@ -512,5 +513,5 @@ def fcp7_write_xml(name: str, output: str, tl: v3, log: Log) -> None:
             audio.append(track)
 
     tree = ET.ElementTree(xmeml)
-    ET.indent(tree, space="\t", level=0)
+    ET.indent(tree, space="  ", level=0)
     tree.write(output, xml_declaration=True, encoding="utf-8")

{auto-editor-24.7.1 → auto-editor-24.9.1}/auto_editor/help.py

@@ -25,16 +25,19 @@ will set the speed from 400 ticks to 800 ticks to 2.5x
 If timebase is 30, 400 ticks to 800 means 13.33 to 26.66 seconds
 """.strip(),
         "--edit-based-on": """
-Evalutes a palet expression that returns a bool-array?. The array is then used for
+Evaluates a palet expression that returns a bool-array?. The array is then used for
 editing.
 
 Editing Methods:
  - audio  ; Audio silence/loudness detection
     - threshold threshold? : 4%
-    - stream (or/c nat? 'all "all") : 0
+    - stream (or/c nat? 'all) : 'all
     - mincut nat? : 6
     - minclip nat? : 3
 
+ ; mincut is more significant, there it has a larger default value.
+ ; minclip gets applied first, then mincut
+
  - motion  ; Motion detection specialized for noisy real-life videos
     - threshold threshold? : 2%
     - stream nat? : 0
@@ -150,10 +153,6 @@ The special value `unset` may also be used, and means: Don't pass any value to f
 """.strip(),
         "--video-bitrate": """
 `--video-bitrate` sets the target bitrate for the video encoder. It accepts the same format as `--audio-bitrate` and the special `unset` value is allowed.
-""".strip(),
-        "--silent-threshold": """
-Silent threshold is a percentage where 0% represents absolute silence and 100% represents the highest volume in the media file.
-Setting the threshold to `0%` will cut only out areas where area is absolutely silence.
 """.strip(),
         "--margin": """
 Default value: 0.2s,0.2s

{auto-editor-24.7.1 → auto-editor-24.9.1}/auto_editor/lang/palet.py

@@ -3,7 +3,6 @@ Palet is a light-weight scripting languge. It handles `--edit` and the `repl`.
 The syntax is inspired by the Racket Programming language.
 """
 
-
 from __future__ import annotations
 
 from cmath import sqrt as complex_sqrt
@@ -19,7 +18,12 @@ from typing import TYPE_CHECKING
 import numpy as np
 from numpy import logical_and, logical_not, logical_or, logical_xor
 
-from auto_editor.analyze import edit_method, mut_remove_large, mut_remove_small
+from auto_editor.analyze import (
+    LevelError,
+    mut_remove_large,
+    mut_remove_small,
+    to_threshold,
+)
 from auto_editor.lib.contracts import *
 from auto_editor.lib.data_structs import *
 from auto_editor.lib.err import MyError
@@ -48,9 +52,8 @@ class ClosingError(MyError):
 ###############################################################################
 
 LPAREN, RPAREN, LBRAC, RBRAC, LCUR, RCUR, EOF = "(", ")", "[", "]", "{", "}", "EOF"
-VAL, QUOTE, SEC, DB, DOT, VLIT = "VAL", "QUOTE", "SEC", "DB", "DOT", "VLIT"
+VAL, QUOTE, SEC, DB, DOT, VLIT, M = "VAL", "QUOTE", "SEC", "DB", "DOT", "VLIT", "M"
 SEC_UNITS = ("s", "sec", "secs", "second", "seconds")
-METHODS = ("audio:", "motion:", "subtitle:")
 brac_pairs = {LPAREN: RPAREN, LBRAC: RBRAC, LCUR: RCUR}
 
 str_escape = {
@@ -316,7 +319,6 @@ class Lexer:
 
             result = ""
             has_illegal = False
-            is_method = False
 
             def normal() -> bool:
                 return (
@@ -333,22 +335,24 @@ class Lexer:
                 else:
                     return self.char_is_norm()
 
+            is_method = False
             while normal():
-                result += self.char
-                if (result + ":") in METHODS:
+                if self.char == ":":
+                    name = result
+                    result = ""
                     is_method = True
                     normal = handle_strings
+                else:
+                    result += self.char
 
                 if self.char in "'`|\\":
                     has_illegal = True
                 self.advance()
 
             if is_method:
-                return Token(VAL, Method(result))
+                from auto_editor.utils.cmdkw import parse_method
 
-            for method in METHODS:
-                if result == method[:-1]:
-                    return Token(VAL, Method(result))
+                return Token(M, parse_method(name, result, env))
 
             if self.char == ".":  # handle `object.method` syntax
                 self.advance()
@@ -369,16 +373,6 @@ class Lexer:
 ###############################################################################
 
 
-@dataclass(slots=True)
-class Method:
-    val: str
-
-    def __str__(self) -> str:
-        return f"#<method:{self.val}>"
-
-    __repr__ = __str__
-
-
 class Parser:
     def __init__(self, lexer: Lexer):
         self.lexer = lexer
@@ -413,6 +407,16 @@ class Parser:
             self.eat()
             return (Sym("pow"), 10, (Sym("/"), token.value, 20))
 
+        if token.type == M:
+            self.eat()
+            name, args, kwargs = token.value
+            _result = [Sym(name)] + args
+            for key, val in kwargs.items():
+                _result.append(Keyword(key))
+                _result.append(val)
+
+            return tuple(_result)
+
         if token.type == DOT:
             self.eat()
             if type(token.value[1].value) is not Sym:
@@ -506,7 +510,7 @@ def initOutPort(name: str) -> OutputPort | Literal[False]:
     return OutputPort(name, port, port.write, False)
 
 
-def raise_(msg: str) -> None:
+def raise_(msg: str | Exception) -> NoReturn:
     raise MyError(msg)
 
 
@@ -808,7 +812,7 @@ class UserProc(Proc):
 
 
 @dataclass(slots=True)
-class KeywordProc:
+class KeywordUserProc:
     env: Env
     name: str
     parms: list[str]
@@ -817,38 +821,21 @@ class KeywordProc:
     arity: tuple[int, None]
     contracts: list[Any] | None = None
 
-    def __call__(self, *args: Any) -> Any:
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
         env = {}
-
-        for i, parm in enumerate(self.parms):
-            if type(args[i]) is Keyword:
-                raise MyError(f"Invalid keyword `{args[i]}`")
-            env[parm] = args[i]
-
-        remain_args = args[len(self.parms) :]
-
-        allow_pos = True
-        pos_index = 0
-        key = ""
-        for arg in remain_args:
-            if type(arg) is Keyword:
-                if key:
-                    raise MyError("Expected value for keyword but got another keyword")
-                key = arg.val
-                allow_pos = False
-            elif key:
-                env[key] = arg
-                key = ""
+        all_parms = self.parms + self.kw_parms
+        for i, arg in enumerate(args):
+            if i >= len(all_parms):
+                raise MyError("Too many arguments")
+            env[all_parms[i]] = arg
+
+        for key, val in kwargs.items():
+            if key in env:
+                raise MyError(
+                    f"Keyword: {key} already fulfilled by positional argument."
+                )
             else:
-                if not allow_pos:
-                    raise MyError("Positional argument not allowed here")
-                if pos_index >= len(self.kw_parms):
-                    base = f"`{self.name}` has an arity mismatch. Expected"
-                    upper = len(self.parms) + len(self.kw_parms)
-                    raise MyError(f"{base} at most {upper}")
-
-                env[self.kw_parms[pos_index]] = arg
-                pos_index += 1
+                env[key] = val
 
         inner_env = Env(env, self.env)
 
@@ -953,7 +940,7 @@ def syn_define(env: Env, node: Node) -> None:
                     raise MyError(f"{node[0]}: must be an identifier")
 
         if kw_only:
-            env[n] = KeywordProc(env, n, parms, kparms, body, (len(parms), None))
+            env[n] = KeywordUserProc(env, n, parms, kparms, body, (len(parms), None))
         else:
             env[n] = UserProc(env, n, parms, (), body)
         return None
@@ -1482,6 +1469,81 @@ def edit_all() -> np.ndarray:
     return env["@levels"].all()
 
 
+def edit_audio(
+    threshold: float = 0.04,
+    stream: object = Sym("all"),
+    mincut: int = 6,
+    minclip: int = 3,
+) -> np.ndarray:
+    if "@levels" not in env or "@filesetup" not in env:
+        raise MyError("Can't use `audio` if there's no input media")
+
+    levels = env["@levels"]
+    src = env["@filesetup"].src
+    strict = env["@filesetup"].strict
+
+    stream_data: NDArray[np.bool_] | None = None
+    if stream == Sym("all"):
+        stream_range = range(0, len(src.audios))
+    else:
+        assert isinstance(stream, int)
+        stream_range = range(stream, stream + 1)
+
+    try:
+        for s in stream_range:
+            audio_list = to_threshold(levels.audio(s), threshold)
+            if stream_data is None:
+                stream_data = audio_list
+            else:
+                stream_data = boolop(stream_data, audio_list, np.logical_or)
+    except LevelError as e:
+        raise_(e) if strict else levels.all()
+
+    if stream_data is not None:
+        mut_remove_small(stream_data, minclip, replace=1, with_=0)
+        mut_remove_small(stream_data, mincut, replace=0, with_=1)
+
+        return stream_data
+
+    stream = 0 if stream == Sym("all") else stream
+    return raise_(f"audio stream '{stream}' does not exist") if strict else levels.all()
+
+
+def edit_motion(
+    threshold: float = 0.02,
+    stream: int = 0,
+    blur: int = 9,
+    width: int = 400,
+) -> np.ndarray:
+    if "@levels" not in env:
+        raise MyError("Can't use `motion` if there's no input media")
+
+    levels = env["@levels"]
+    strict = env["@filesetup"].strict
+    try:
+        return to_threshold(levels.motion(stream, blur, width), threshold)
+    except LevelError as e:
+        return raise_(e) if strict else levels.all()
+
+
+def edit_subtitle(pattern, stream=0, **kwargs):
+    if "@levels" not in env:
+        raise MyError("Can't use `subtitle` if there's no input media")
+
+    levels = env["@levels"]
+    strict = env["@filesetup"].strict
+    if "ignore-case" not in kwargs:
+        kwargs["ignore-case"] = False
+    if "max-count" not in kwargs:
+        kwargs["max-count"] = None
+    ignore_case = kwargs["ignore-case"]
+    max_count = kwargs["max-count"]
+    try:
+        return levels.subtitle(pattern, stream, ignore_case, max_count)
+    except LevelError as e:
+        return raise_(e) if strict else levels.all()
+
+
 def my_eval(env: Env, node: object) -> Any:
     if type(node) is Sym:
         val = env.get(node.val)
@@ -1495,11 +1557,6 @@ def my_eval(env: Env, node: object) -> Any:
             )
         return val
 
-    if isinstance(node, Method):
-        if "@filesetup" not in env:
-            raise MyError("Can't use edit methods if there's no input files")
-        return edit_method(node.val, env["@filesetup"], env)
-
     if type(node) is list:
         return [my_eval(env, item) for item in node]
 
@@ -1531,7 +1588,21 @@ def my_eval(env: Env, node: object) -> Any:
         if type(oper) is Syntax:
             return oper(env, node)
 
-        return oper(*(my_eval(env, c) for c in node[1:]))
+        i = 1
+        args: list[Any] = []
+        kwargs: dict[str, Any] = {}
+        while i < len(node):
+            result = my_eval(env, node[i])
+            if type(result) is Keyword:
+                i += 1
+                if i >= len(node):
+                    raise MyError("Keyword need argument")
+                kwargs[result.val] = my_eval(env, node[i])
+            else:
+                args.append(result)
+            i += 1
+
+        return oper(*args, **kwargs)
 
     return node
 
@@ -1546,6 +1617,18 @@ env.update({
     # edit procedures
     "none": Proc("none", edit_none, (0, 0)),
     "all/e": Proc("all/e", edit_all, (0, 0)),
+    "audio": Proc("audio", edit_audio, (0, 4),
+        is_threshold, orc(is_nat, Sym("all")), is_nat,
+        {"threshold": 0, "stream": 1, "minclip": 2, "mincut": 2}
+    ),
+    "motion": Proc("motion", edit_motion, (0, 4),
+        is_threshold, is_nat, is_nat1,
+        {"threshold": 0, "stream": 1, "blur": 1, "width": 2}
+    ),
+    "subtitle": Proc("subtitle", edit_subtitle, (1, 4),
+        is_str, is_nat, is_bool, orc(is_nat, is_void),
+        {"pattern": 0, "stream": 1, "ignore-case": 2, "max-count": 3}
+    ),
     # syntax
     "lambda": Syntax(syn_lambda),
     "λ": Syntax(syn_lambda),

{auto-editor-24.7.1 → auto-editor-24.9.1}/auto_editor/lib/contracts.py

@@ -47,7 +47,7 @@ def check_contract(c: object, val: object) -> bool:
 
 
 def check_args(
-    o: str,
+    name: str,
     values: list | tuple,
     arity: tuple[int, int | None],
     cont: tuple[Any, ...],
@@ -56,7 +56,7 @@ def check_args(
     amount = len(values)
 
     assert not (upper is not None and lower > upper)
-    base = f"`{o}` has an arity mismatch. Expected "
+    base = f"`{name}` has an arity mismatch. Expected "
 
     if lower == upper and len(values) != lower:
         raise MyError(f"{base}{lower}, got {amount}")
@@ -72,11 +72,11 @@ def check_args(
         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)}")
+            raise MyError(f"`{name}` expected {exp}, but got {print_str(val)}")
 
 
 class Proc:
-    __slots__ = ("name", "proc", "arity", "contracts")
+    __slots__ = ("name", "proc", "arity", "contracts", "kw_contracts")
 
     def __init__(
         self, n: str, p: Callable, a: tuple[int, int | None] = (1, None), *c: Any
@@ -84,11 +84,52 @@ class Proc:
         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)
+        if c and type(c[-1]) is dict:
+            self.kw_contracts: dict[str, int] | None = c[-1]
+            self.contracts: tuple[Any, ...] = c[:-1]
+        else:
+            self.kw_contracts = None
+            self.contracts = c
+
+    def __call__(self, *args: Any, **kwargs: Any):
+        lower, upper = self.arity
+        amount = len(args)
+        cont = self.contracts
+        kws = self.kw_contracts
+
+        assert not (upper is not None and lower > upper)
+        base = f"`{self.name}` has an arity mismatch. Expected "
+
+        if lower == upper and len(args) != 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 self.proc(*args)
+
+        if kws is not None:
+            for key, val in kwargs.items():
+                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)
+                    raise MyError(
+                        f"`{self.name} #:{key}` expected {exp}, but got {print_str(val)}"
+                    )
+
+        elif len(kwargs) > 0:
+            raise MyError("Keyword arguments are not allowed here")
+
+        for i, val in enumerate(args):
+            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"`{self.name}` expected {exp}, but got {print_str(val)}")
+
+        return self.proc(*args, **kwargs)
 
     def __str__(self) -> str:
         return self.name
@@ -137,13 +178,19 @@ is_threshold = Contract(
 is_proc = Contract("procedure?", lambda v: isinstance(v, Proc | Contract))
 
 
+def contract_printer(cs) -> str:
+    return " ".join(
+        c.name if isinstance(c, Proc | Contract) else print_str(c) for c in cs
+    )
+
+
 def andc(*cs: object) -> Proc:
-    name = "(and/c " + " ".join(f"{c}" for c in cs) + ")"
+    name = f"(and/c {contract_printer(cs)})"
     return Proc(name, lambda v: all(check_contract(c, v) for c in cs), (1, 1), any_p)
 
 
 def orc(*cs: object) -> Proc:
-    name = "(or/c " + " ".join(f"{c}" for c in cs) + ")"
+    name = f"(or/c {contract_printer(cs)})"
     return Proc(name, lambda v: any(check_contract(c, v) for c in cs), (1, 1), any_p)
 
 

{auto-editor-24.7.1 → auto-editor-24.9.1}/auto_editor/lib/data_structs.py

@@ -57,6 +57,7 @@ class Sym:
     __slots__ = ("val", "hash")
 
     def __init__(self, val: str):
+        assert isinstance(val, str)
         self.val = val
         self.hash = hash(val)
 

{auto-editor-24.7.1 → auto-editor-24.9.1}/auto_editor/output.py

@@ -193,7 +193,7 @@ def mux_quality_media(
         cmd.extend(args.extras.split(" "))
     cmd.extend(["-strict", "-2"])  # Allow experimental codecs.
 
-    if not args.sn:
+    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'

{auto-editor-24.7.1 → auto-editor-24.9.1}/auto_editor/render/video.py

@@ -97,6 +97,7 @@ def make_image_cache(tl: v3) -> dict[tuple[FileInfo, int], np.ndarray]:
         for obj in clip:
             if isinstance(obj, TlImage) and obj.src not in img_cache:
                 with av.open(obj.src.path) as cn:
+                    assert isinstance(cn, av.InputContainer)
                     my_stream = cn.streams.video[0]
                     for frame in cn.decode(my_stream):
                         if obj.width != 0:
@@ -168,15 +169,26 @@ def render_av(
     log.debug(f"Target pix_fmt: {target_pix_fmt}")
 
     apply_video_later = True
-
-    if args.scale != 1:
-        apply_video_later = False
-    elif args.video_codec in encoders:
+    if 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}")
 
-    width, height = tl.res
+    if args.scale == 1.0:
+        target_width, target_height = tl.res
+        scale_graph = None
+    else:
+        target_width = max(round(tl.res[0] * args.scale), 2)
+        target_height = max(round(tl.res[1] * args.scale), 2)
+        scale_graph = av.filter.Graph()
+        link_nodes(
+            scale_graph.add(
+                "buffer", video_size="1x1", time_base="1/1", pix_fmt=target_pix_fmt
+            ),
+            scale_graph.add("scale", f"{target_width}:{target_height}"),
+            scale_graph.add("buffersink"),
+        )
+
     spedup = os.path.join(temp, "spedup0.mp4")
 
     cmd = [
@@ -189,7 +201,7 @@ def render_av(
         "-pix_fmt",
         target_pix_fmt,
         "-s",
-        f"{width}*{height}",
+        f"{target_width}*{target_height}",
         "-framerate",
         f"{tl.tb}",
         "-i",
@@ -224,7 +236,7 @@ def render_av(
     bar.start(tl.end, "Creating new video")
 
     bg = color(args.background)
-    null_frame = make_solid(width, height, target_pix_fmt, bg)
+    null_frame = make_solid(target_width, target_height, target_pix_fmt, bg)
     frame_index = -1
     try:
         for index in range(tl.end):
@@ -282,7 +294,8 @@ def render_av(
                         if frame.key_frame:
                             log.debug(f"Keyframe {frame_index} {frame.pts}")
 
-                    if frame.width != width or frame.height != height:
+                    if (frame.width, frame.height) != tl.res:
+                        width, height = tl.res
                         graph = av.filter.Graph()
                         link_nodes(
                             graph.add_buffer(template=my_stream),
@@ -345,6 +358,10 @@ def render_av(
 
                     frame = av.VideoFrame.from_ndarray(array, format="rgb24")
 
+            if scale_graph is not None and frame.width != target_width:
+                scale_graph.push(frame)
+                frame = scale_graph.pull()
+
             if frame.format.name != target_pix_fmt:
                 frame = frame.reformat(format=target_pix_fmt)
                 bar.tick(index)
@@ -363,19 +380,4 @@ def render_av(
 
     log.debug(f"Total frames saved seeking: {frames_saved}")
 
-    if args.scale != 1:
-        sped_input = os.path.join(temp, "spedup0.mp4")
-        spedup = os.path.join(temp, "scale0.mp4")
-        scale_filter = f"scale=iw*{args.scale}:ih*{args.scale}"
-
-        cmd = ["-i", sped_input, "-vf", scale_filter, spedup]
-
-        check_errors = ffmpeg.pipe(cmd)
-        if "Error" in check_errors or "failed" in check_errors:
-            if "-allow_sw 1" in check_errors:
-                cmd.insert(-1, "-allow_sw")
-                cmd.insert(-1, "1")
-            # Run again to show errors even if it might not work.
-            ffmpeg.run(cmd)
-
     return spedup, apply_video_later

{auto-editor-24.7.1 → auto-editor-24.9.1}/auto_editor/subcommands/test.py

@@ -132,6 +132,7 @@ def run_tests(tests: list[Callable], args: TestArgs) -> None:
     for index, test in enumerate(tests, start=1):
         name = test.__name__
         start = perf_counter()
+        outputs = None
 
         try:
             outputs = test()
@@ -142,6 +143,8 @@ def run_tests(tests: list[Callable], args: TestArgs) -> None:
             clean_all()
             sys.exit(1)
         except Exception as e:
+            dur = perf_counter() - start
+            total_time += dur
             print(f"{name:<24} ({index}/{total})  {round(dur, 2):<4} secs  [FAILED]")
             if args.no_fail_fast:
                 print(f"\n{e}")
@@ -684,8 +687,8 @@ def main(sys_args: list[str] | None = None):
         )
 
     def palet_scripts():
-        run.raw(["palet", "resources/scripts/maxcut.pal"])
         run.raw(["palet", "resources/scripts/scope.pal"])
+        run.raw(["palet", "resources/scripts/maxcut.pal"])
         run.raw(["palet", "resources/scripts/case.pal"])
         run.raw(["palet", "resources/scripts/testmath.pal"])
 

{auto-editor-24.7.1 → auto-editor-24.9.1}/auto_editor/utils/cmdkw.py

@@ -172,3 +172,44 @@ def parse_with_palet(
             raise ParserError(f"'{k}' must be specified.")
 
     return kwargs
+
+
+def parse_method(
+    name: str, text: str, env: Env
+) -> tuple[str, list[Any], dict[str, Any]]:
+    from auto_editor.lang.palet import Lexer, Parser, interpret
+    from auto_editor.lib.err import MyError
+
+    # Positional Arguments
+    #    audio:0.04,0,6,3
+    # Keyword Arguments
+    #    audio:threshold=0.04,stream=0,mincut=6,minclip=3
+
+    args: list[Any] = []
+    kwargs: dict[str, Any] = {}
+
+    allow_positional_args = True
+    lexer = PLexer(text)
+    while (arg := lexer.get_next_token()) is not None:
+        if not arg:
+            continue
+
+        if "=" in arg:
+            key, val = arg.split("=", 1)
+
+            results = interpret(env, Parser(Lexer(name, val)))
+            if not results:
+                raise MyError("Results must be of length > 0")
+
+            kwargs[key] = results[-1]
+            allow_positional_args = False
+
+        elif allow_positional_args:
+            results = interpret(env, Parser(Lexer(name, arg)))
+            if not results:
+                raise MyError("Results must be of length > 0")
+            args.append(results[-1])
+        else:
+            raise ParserError(f"{name} positional argument follows keyword argument.")
+
+    return name, args, kwargs

{auto-editor-24.7.1 → auto-editor-24.9.1/auto_editor.egg-info}/PKG-INFO

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

auto-editor-24.7.1/auto_editor/__init__.py

@@ -1,2 +0,0 @@
-__version__ = "24.7.1"
-version = "24w07a"