auto-editor 24.7.1__py3-none-any.whl → 24.13.1__py3-none-any.whl

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/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/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/output.py

@@ -182,18 +182,25 @@ def mux_quality_media(
         cmd += _ffset("-c:a", args.audio_codec) + _ffset("-b:a", args.audio_bitrate)
 
     if same_container and v_tracks > 0:
-        cmd += (
-            _ffset("-color_range", src.videos[0].color_range)
-            + _ffset("-colorspace", src.videos[0].color_space)
-            + _ffset("-color_primaries", src.videos[0].color_primaries)
-            + _ffset("-color_trc", src.videos[0].color_transfer)
-        )
+        color_range = src.videos[0].color_range
+        colorspace = src.videos[0].color_space
+        color_prim = src.videos[0].color_primaries
+        color_trc = src.videos[0].color_transfer
+
+        if color_range == 1 or color_range == 2:
+            cmd.extend(["-color_range", f"{color_range}"])
+        if colorspace in (0, 1) or (colorspace >= 3 and colorspace < 16):
+            cmd.extend(["-colorspace", f"{colorspace}"])
+        if color_prim in (0, 1) or (color_prim >= 4 and color_prim < 17):
+            cmd.extend(["-color_primaries", f"{color_prim}"])
+        if color_trc == 1 or (color_trc >= 4 and color_trc < 22):
+            cmd.extend(["-color_trc", f"{color_trc}"])
 
     if args.extras is not None:
         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/render/video.py

@@ -168,15 +168,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 +200,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 +235,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 +293,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 +357,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 +379,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/subcommands/desc.py

@@ -3,28 +3,26 @@ from __future__ import annotations
 import sys
 from dataclasses import dataclass, field
 
-from auto_editor.ffwrapper import FFmpeg, initFileInfo
+from auto_editor.ffwrapper import initFileInfo
 from auto_editor.utils.log import Log
 from auto_editor.vanparse import ArgumentParser
 
 
 @dataclass(slots=True)
 class DescArgs:
-    ffmpeg_location: str | None = None
     help: bool = False
     input: list[str] = field(default_factory=list)
 
 
 def desc_options(parser: ArgumentParser) -> ArgumentParser:
     parser.add_required("input", nargs="*")
-    parser.add_argument("--ffmpeg-location", help="Point to your custom ffmpeg file")
     return parser
 
 
 def main(sys_args: list[str] = sys.argv[1:]) -> None:
     args = desc_options(ArgumentParser("desc")).parse_args(DescArgs, sys_args)
     for path in args.input:
-        src = initFileInfo(path, FFmpeg(args.ffmpeg_location), Log())
+        src = initFileInfo(path, Log())
         if src.description is not None:
             sys.stdout.write(f"\n{src.description}\n\n")
         else: