auto-editor 24.3.1__py3-none-any.whl → 24.9.1__py3-none-any.whl

auto_editor/lang/palet.py

@@ -3,11 +3,9 @@ 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
 
-import cmath
-import math
+from cmath import sqrt as complex_sqrt
 from dataclasses import dataclass
 from difflib import get_close_matches
 from fractions import Fraction
@@ -20,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
@@ -49,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 = {
@@ -317,7 +319,6 @@ class Lexer:
 
             result = ""
             has_illegal = False
-            is_method = False
 
             def normal() -> bool:
                 return (
@@ -334,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()
@@ -370,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
@@ -414,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:
@@ -507,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)
 
 
@@ -549,7 +552,7 @@ def int_div(n: int, *m: int) -> int:
 
 
 def _sqrt(v: Number) -> Number:
-    r = cmath.sqrt(v)
+    r = complex_sqrt(v)
     if r.imag == 0:
         if int(r.real) == r.real:
             return int(r.real)
@@ -809,7 +812,7 @@ class UserProc(Proc):
 
 
 @dataclass(slots=True)
-class KeywordProc:
+class KeywordUserProc:
     env: Env
     name: str
     parms: list[str]
@@ -818,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)
 
@@ -954,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
@@ -1396,6 +1382,25 @@ def syn_let_star(env: Env, node: Node) -> Any:
     return my_eval(inner_env, node[-1])
 
 
+def syn_import(env: Env, node: Node) -> None:
+    guard_term(node, 2, 2)
+
+    if type(node[1]) is not Sym:
+        raise MyError("class name must be an identifier")
+
+    module = node[1].val
+    error = MyError(f"No module named `{module}`")
+
+    if module != "math":
+        raise error
+    try:
+        obj = __import__("auto_editor.lang.libmath", fromlist=["lang"])
+    except ImportError:
+        raise error
+
+    env.update(obj.all())
+
+
 def syn_class(env: Env, node: Node) -> None:
     if len(node) < 2:
         raise MyError(f"{node[0]}: Expects at least 1 term")
@@ -1464,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)
@@ -1477,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]
 
@@ -1513,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
 
@@ -1528,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),
@@ -1544,6 +1645,7 @@ env.update({
     "case": Syntax(syn_case),
     "let": Syntax(syn_let),
     "let*": Syntax(syn_let_star),
+    "import": Syntax(syn_import),
     "class": Syntax(syn_class),
     "@r": Syntax(attr),
     # loops
@@ -1615,17 +1717,10 @@ env.update({
     "imag-part": Proc("imag-part", lambda v: v.imag, (1, 1), is_num),
     # reals
     "pow": Proc("pow", pow, (2, 2), is_real),
-    "exp": Proc("exp", math.exp, (1, 1), is_real),
     "abs": Proc("abs", abs, (1, 1), is_real),
-    "ceil": Proc("ceil", math.ceil, (1, 1), is_real),
-    "floor": Proc("floor", math.floor, (1, 1), is_real),
     "round": Proc("round", round, (1, 1), is_real),
     "max": Proc("max", lambda *v: max(v), (1, None), is_real),
     "min": Proc("min", lambda *v: min(v), (1, None), is_real),
-    "sin": Proc("sin", math.sin, (1, 1), is_real),
-    "cos": Proc("cos", math.cos, (1, 1), is_real),
-    "log": Proc("log", math.log, (1, 2), andc(is_real, gt_c(0))),
-    "tan": Proc("tan", math.tan, (1, 1), is_real),
     "mod": Proc("mod", mod, (2, 2), is_int),
     "modulo": Proc("modulo", mod, (2, 2), is_int),
     # symbols

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

@@ -88,7 +88,7 @@ def mux_quality_media(
 ) -> None:
     v_tracks = len(visual_output)
     a_tracks = len(audio_output)
-    s_tracks = len(sub_output)
+    s_tracks = 0 if args.sn else len(sub_output)
 
     cmd = ["-hide_banner", "-y", "-i", f"{src.path}"]
 
@@ -192,7 +192,9 @@ def mux_quality_media(
     if args.extras is not None:
         cmd.extend(args.extras.split(" "))
     cmd.extend(["-strict", "-2"])  # Allow experimental codecs.
-    cmd.extend(["-map", "0:t?"])  # Add input attachments to output.
+
+    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?"])

auto_editor/render/video.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os.path
 from dataclasses import dataclass
 from subprocess import DEVNULL, PIPE
+from sys import platform
 from typing import TYPE_CHECKING
 
 import av
@@ -96,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:
@@ -111,7 +113,6 @@ def make_image_cache(tl: v3) -> dict[tuple[FileInfo, int], np.ndarray]:
                             format="rgb24"
                         )
                         break
-
     return img_cache
 
 
@@ -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",
@@ -198,6 +210,10 @@ def render_av(
         target_pix_fmt,
     ]
 
+    if platform == "darwin":
+        # Fix videotoolbox issue with legacy macs
+        cmd += ["-allow_sw", "1"]
+
     if apply_video_later:
         cmd += ["-c:v", "mpeg4", "-qscale:v", "1"]
     else:
@@ -220,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):
@@ -278,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),
@@ -341,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)
@@ -359,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/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}")
@@ -577,12 +580,6 @@ def main(sys_args: list[str] | None = None):
             ("(pow 4 0.5)", 2.0),
             ("(abs 1.0)", 1.0),
             ("(abs -1)", 1),
-            ("(round 3.5)", 4),
-            ("(round 2.5)", 2),
-            ("(ceil 2.1)", 3),
-            ("(ceil 2.9)", 3),
-            ("(floor 2.1)", 2),
-            ("(floor 2.9)", 2),
             ("(bool? #t)", True),
             ("(bool? #f)", True),
             ("(bool? 0)", False),
@@ -690,9 +687,10 @@ 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"])
 
     tests = []