auto-editor 26.3.3__py3-none-any.whl → 27.1.0__py3-none-any.whl

auto_editor/formats/json.py

@@ -6,11 +6,12 @@ from difflib import get_close_matches
 from fractions import Fraction
 from typing import Any
 
-from auto_editor.ffwrapper import FileInfo, initFileInfo
-from auto_editor.lang.json import Lexer, Parser, dump
+from auto_editor.ffwrapper import FileInfo
+from auto_editor.json import dump, load
 from auto_editor.lib.err import MyError
 from auto_editor.timeline import (
     ASpace,
+    Template,
     TlAudio,
     TlVideo,
     VSpace,
@@ -59,7 +60,7 @@ def read_v3(tl: Any, log: Log) -> v3:
     def make_src(v: str) -> FileInfo:
         if v in srcs:
             return srcs[v]
-        temp = initFileInfo(v, log)
+        temp = FileInfo.init(v, log)
         srcs[v] = temp
         return temp
 
@@ -151,11 +152,11 @@ def read_v3(tl: Any, log: Log) -> v3:
             a.append(a_out)
 
     try:
-        src = srcs[next(iter(srcs))]
+        T = Template.init(srcs[next(iter(srcs))])
     except StopIteration:
-        src = None
+        T = Template(sr, "stereo", res, [], [])
 
-    return v3(src, tb, sr, res, bg, v, a, v1=None)
+    return v3(tb, bg, T, v, a, v1=None)
 
 
 def read_v1(tl: Any, log: Log) -> v3:
@@ -168,7 +169,7 @@ def read_v1(tl: Any, log: Log) -> v3:
 
     check_file(path, log)
 
-    src = initFileInfo(path, log)
+    src = FileInfo.init(path, log)
 
     vtl: VSpace = []
     atl: ASpace = [[] for _ in range(len(src.audios))]
@@ -207,11 +208,9 @@ def read_v1(tl: Any, log: Log) -> v3:
             atl[a].append(TlAudio(c.start, c.dur, c.src, c.offset, c.speed, 1, a))
 
     return v3(
-        src,
         src.get_fps(),
-        src.get_sr(),
-        src.get_res(),
         "#000",
+        Template.init(src),
         vtl,
         atl,
         v1(src, chunks),
@@ -221,7 +220,7 @@ def read_v1(tl: Any, log: Log) -> v3:
 def read_json(path: str, log: Log) -> v3:
     with open(path, encoding="utf-8", errors="ignore") as f:
         try:
-            tl = Parser(Lexer(path, f)).expr()
+            tl = load(path, f)
         except MyError as e:
             log.error(e)
 

auto_editor/{lang/json.py → json.py}

@@ -11,29 +11,10 @@ if TYPE_CHECKING:
 
     from _typeshed import SupportsWrite
 
-
-class Token:
-    __slots__ = ("type", "value")
-
-    def __init__(self, type: int, value: object):
-        self.type = type
-        self.value = value
-
-    def __str__(self) -> str:
-        return f"{self.type=} {self.value=}"
-
-    __repr__ = __str__
+    Token = tuple[int, object]
 
 
 EOF, LCUR, RCUR, LBRAC, RBRAC, COL, COMMA, STR, VAL = range(9)
-table = {
-    "{": LCUR,
-    "}": RCUR,
-    "[": LBRAC,
-    "]": RBRAC,
-    ":": COL,
-    ",": COMMA,
-}
 str_escape = {
     "\\": "\\",
     "/": "/",
@@ -88,6 +69,12 @@ class Lexer:
             self.char = self.text[self.pos]
             self.column += 1
 
+    def rewind(self) -> None:
+        self.pos = 0
+        self.lineno = 1
+        self.column = 1
+        self.char = self.text[self.pos] if self.text else None
+
     def peek(self) -> str | None:
         peek_pos = self.pos + 1
         return None if peek_pos > len(self.text) - 1 else self.text[peek_pos]
@@ -142,7 +129,7 @@ class Lexer:
         result = buf.getvalue()
 
         try:
-            return Token(VAL, float(result) if has_dot else int(result))
+            return (VAL, float(result) if has_dot else int(result))
         except ValueError:
             self.error(f"`{result}` is not a valid JSON Number")
 
@@ -158,7 +145,7 @@ class Lexer:
 
             if self.char == '"':
                 self.advance()
-                return Token(STR, self.string())
+                return (STR, self.string())
 
             if self.char == "-":
                 _peek = self.peek()
@@ -168,10 +155,11 @@ class Lexer:
             if self.char in "0123456789.":
                 return self.number()
 
+            table = {"{": LCUR, "}": RCUR, "[": LBRAC, "]": RBRAC, ":": COL, ",": COMMA}
             if self.char in table:
                 key = table[self.char]
                 self.advance()
-                return Token(key, None)
+                return (key, None)
 
             keyword = ""
             for i in range(5):  # Longest valid keyword length
@@ -181,14 +169,14 @@ class Lexer:
                 self.advance()
 
             if keyword == "true":
-                return Token(VAL, True)
+                return (VAL, True)
             if keyword == "false":
-                return Token(VAL, False)
+                return (VAL, False)
             if keyword == "null":
-                return Token(VAL, None)
+                return (VAL, None)
 
             self.error(f"Invalid keyword: `{keyword}`")
-        return Token(EOF, None)
+        return (EOF, None)
 
 
 class Parser:
@@ -204,49 +192,49 @@ class Parser:
     def expr(self) -> Any:
         self.current_token
 
-        if self.current_token.type in {STR, VAL}:
-            val = self.current_token.value
+        if self.current_token[0] in {STR, VAL}:
+            val = self.current_token[1]
             self.eat()
             return val
 
-        if self.current_token.type == LCUR:
+        if self.current_token[0] == LCUR:
             self.eat()
 
             my_dic = {}
-            while self.current_token.type != RCUR:
-                if self.current_token.type != STR:
-                    if self.current_token.type in {LBRAC, VAL}:
+            while self.current_token[0] != RCUR:
+                if self.current_token[0] != STR:
+                    if self.current_token[0] in {LBRAC, VAL}:
                         self.lexer.error("JSON Objects only allow strings as keys")
                     self.lexer.error("Expected closing `}`")
-                key = self.current_token.value
+                key = self.current_token[1]
                 if key in my_dic:
                     self.lexer.error(f"Object has repeated key `{key}`")
                 self.eat()
-                if self.current_token.type != COL:
+                if self.current_token[0] != COL:
                     self.lexer.error("Expected `:`")
                 self.eat()
 
                 my_dic[key] = self.expr()
-                if self.current_token.type != RCUR:
-                    if self.current_token.type != COMMA:
+                if self.current_token[0] != RCUR:
+                    if self.current_token[0] != COMMA:
                         self.lexer.error("Expected `,` between Object entries")
                     self.eat()
-                    if self.current_token.type == RCUR:
+                    if self.current_token[0] == RCUR:
                         self.lexer.error("Trailing `,` in Object")
 
             self.eat()
             return my_dic
 
-        if self.current_token.type == LBRAC:
+        if self.current_token[0] == LBRAC:
             self.eat()
             my_arr = []
-            while self.current_token.type != RBRAC:
+            while self.current_token[0] != RBRAC:
                 my_arr.append(self.expr())
-                if self.current_token.type != RBRAC:
-                    if self.current_token.type != COMMA:
+                if self.current_token[0] != RBRAC:
+                    if self.current_token[0] != COMMA:
                         self.lexer.error("Expected `,` between array entries")
                     self.eat()
-                    if self.current_token.type == RBRAC:
+                    if self.current_token[0] == RBRAC:
                         self.lexer.error("Trailing `,` in array")
             self.eat()
             return my_arr
@@ -254,6 +242,14 @@ class Parser:
         raise MyError(f"Unknown token: {self.current_token}")
 
 
+def load(path: str, f: str | bytes | TextIOWrapper) -> dict[str, object]:
+    lexer = Lexer(path, f)
+    if lexer.get_next_token()[0] != LCUR:
+        raise MyError("Expected JSON Object")
+    lexer.rewind()
+    return Parser(lexer).expr()
+
+
 def dump(
     data: object, file: SupportsWrite[str], indent: int | None = None, level: int = 0
 ) -> None:

auto_editor/lang/palet.py

@@ -646,8 +646,8 @@ stack_trace_manager = StackTraceManager()
 
 
 def my_eval(env: Env, node: object) -> Any:
-    def make_trace(sym: Sym) -> str:
-        return f"  at {sym.val} ({sym.lineno}:{sym.column})"
+    def make_trace(sym: object) -> str:
+        return f"  at {sym.val} ({sym.lineno}:{sym.column})" if type(sym) is Sym else ""
 
     if type(node) is Sym:
         val = env.get(node.val)

auto_editor/lang/stdenv.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+import bv
+
 from auto_editor.analyze import mut_remove_large, mut_remove_small
 from auto_editor.lib.contracts import *
 from auto_editor.lib.data_structs import *
@@ -11,6 +13,7 @@ from .palet import Syntax, env, is_boolarr, is_iterable, my_eval, p_slice, raise
 if TYPE_CHECKING:
     from typing import Any, Literal
 
+    import numpy as np
     from numpy.typing import NDArray
 
     Number = int | float | complex | Fraction
@@ -749,6 +752,13 @@ def make_standard_env() -> dict[str, Any]:
             raise MyError("@r: attribute must be an identifier")
 
         base = my_eval(env, node[1])
+
+        if hasattr(base, "__pyx_vtable__"):
+            try:
+                return getattr(base, node[2].val)
+            except AttributeError as e:
+                raise MyError(e)
+
         if type(base) is PaletClass:
             if type(name := node[2]) is not Sym:
                 raise MyError("@r: class attribute must be an identifier")
@@ -1171,6 +1181,9 @@ def make_standard_env() -> dict[str, Any]:
             "string->vector", lambda s: [Char(c) for c in s], (1, 1), is_str
         ),
         "range->vector": Proc("range->vector", list, (1, 1), is_range),
+        # av
+        "encoder": Proc("encoder", lambda x: bv.Codec(x, "w"), (1, 1), is_str),
+        "decoder": Proc("decoder", lambda x: bv.Codec(x), (1, 1), is_str),
         # reflexion
         "var-exists?": Proc("var-exists?", lambda sym: sym.val in env, (1, 1), is_symbol),
         "rename": Syntax(syn_rename),

auto_editor/make_layers.py

@@ -11,7 +11,7 @@ from auto_editor.ffwrapper import FileInfo
 from auto_editor.lang.palet import Lexer, Parser, env, interpret, is_boolean_array
 from auto_editor.lib.data_structs import print_str
 from auto_editor.lib.err import MyError
-from auto_editor.timeline import ASpace, TlAudio, TlVideo, VSpace, v1, v3
+from auto_editor.timeline import ASpace, Template, TlAudio, TlVideo, VSpace, v1, v3
 from auto_editor.utils.func import mut_margin
 from auto_editor.utils.types import CoerceError, time
 
@@ -99,16 +99,17 @@ def parse_time(val: str, arr: NDArray, tb: Fraction) -> int:  # raises: `CoerceE
 
 
 def make_timeline(
-    sources: list[FileInfo],
-    args: Args,
-    sr: int,
-    bar: Bar,
-    log: Log,
+    sources: list[FileInfo], args: Args, sr: int, bar: Bar, log: Log
 ) -> v3:
     inp = None if not sources else sources[0]
 
     if inp is None:
-        tb, res = Fraction(30), (1920, 1080)
+        tb = (
+            Fraction(30)
+            if args.frame_rate is None
+            else make_sane_timebase(args.frame_rate)
+        )
+        res = (1920, 1080) if args.resolution is None else args.resolution
     else:
         tb = make_sane_timebase(
             inp.get_fps() if args.frame_rate is None else args.frame_rate
@@ -302,4 +303,13 @@ def make_timeline(
     else:
         v1_compatiable = None
 
-    return v3(inp, tb, sr, res, args.background, vtl, atl, v1_compatiable)
+    if len(vtl) == 0 and len(atl) == 0:
+        log.error("Timeline is empty, nothing to do.")
+
+    if inp is None:
+        layout = "stereo" if args.audio_layout is None else args.audio_layout
+        template = Template(sr, layout, res, [], [])
+    else:
+        template = Template.init(inp, sr, args.audio_layout, res)
+
+    return v3(tb, args.background, template, vtl, atl, v1_compatiable)