auto-editor 26.3.2__py3-none-any.whl → 27.0.0__py3-none-any.whl

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 *
@@ -749,6 +751,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 +1180,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

@@ -13,11 +13,12 @@ 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.utils.func import mut_margin
-from auto_editor.utils.types import Args, CoerceError, time
+from auto_editor.utils.types import CoerceError, time
 
 if TYPE_CHECKING:
     from numpy.typing import NDArray
 
+    from auto_editor.__main__ import Args
     from auto_editor.utils.bar import Bar
     from auto_editor.utils.chunks import Chunks
     from auto_editor.utils.log import Log

auto_editor/output.py

@@ -3,18 +3,18 @@ from __future__ import annotations
 import os.path
 from dataclasses import dataclass, field
 
-import av
-from av.audio.resampler import AudioResampler
+import bv
+from bv.audio.resampler import AudioResampler
 
 from auto_editor.ffwrapper import FileInfo
 from auto_editor.utils.bar import Bar
 from auto_editor.utils.log import Log
-from auto_editor.utils.types import _split_num_str
+from auto_editor.utils.types import split_num_str
 
 
 def parse_bitrate(input_: str, log: Log) -> int:
     try:
-        val, unit = _split_num_str(input_)
+        val, unit = split_num_str(input_)
     except Exception as e:
         log.error(e)
 
@@ -53,8 +53,8 @@ class Ensure:
             bar = self._bar
             self.log.debug(f"Making external audio: {out_path}")
 
-            in_container = av.open(src.path, "r")
-            out_container = av.open(
+            in_container = bv.open(src.path, "r")
+            out_container = bv.open(
                 out_path, "w", format="wav", options={"rf64": "always"}
             )
             astream = in_container.streams.audio[stream]

auto_editor/render/audio.py

@@ -2,13 +2,14 @@ from __future__ import annotations
 
 import io
 from pathlib import Path
+from typing import TYPE_CHECKING
 
-import av
+import bv
 import numpy as np
-from av.filter.loudnorm import stats
+from bv.filter.loudnorm import stats
 
 from auto_editor.ffwrapper import FileInfo
-from auto_editor.lang.json import Lexer, Parser
+from auto_editor.json import load
 from auto_editor.lang.palet import env
 from auto_editor.lib.contracts import andc, between_c, is_int_or_float
 from auto_editor.lib.err import MyError
@@ -18,9 +19,11 @@ from auto_editor.utils.bar import Bar
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
 from auto_editor.utils.container import Container
 from auto_editor.utils.log import Log
-from auto_editor.utils.types import Args
 from auto_editor.wavfile import AudioData, read, write
 
+if TYPE_CHECKING:
+    from auto_editor.__main__ import Args
+
 norm_types = {
     "ebu": pAttrs(
         "ebu",
@@ -58,12 +61,14 @@ def parse_norm(norm: str, log: Log) -> dict | None:
 
 def parse_ebu_bytes(norm: dict, stat: bytes, log: Log) -> tuple[str, str]:
     try:
-        parsed = Parser(Lexer("loudnorm", stat)).expr()
+        parsed = load("loudnorm", stat)
     except MyError:
         log.error(f"Invalid loudnorm stats.\n{stat!r}")
 
     for key in {"input_i", "input_tp", "input_lra", "input_thresh", "target_offset"}:
-        val = float(parsed[key])
+        val_ = parsed[key]
+        assert isinstance(val_, int | float | str | bytes)
+        val = float(val_)
         if val == float("-inf"):
             parsed[key] = -99
         elif val == float("inf"):
@@ -94,14 +99,14 @@ def apply_audio_normalization(
             f"i={norm['i']}:lra={norm['lra']}:tp={norm['tp']}:offset={norm['gain']}"
         )
         log.debug(f"audio norm first pass: {first_pass}")
-        with av.open(f"{pre_master}") as container:
+        with bv.open(f"{pre_master}") as container:
             stats_ = stats(first_pass, container.streams.audio[0])
 
         name, filter_args = parse_ebu_bytes(norm, stats_, log)
     else:
         assert "t" in norm
 
-        def get_peak_level(frame: av.AudioFrame) -> float:
+        def get_peak_level(frame: bv.AudioFrame) -> float:
             # Calculate peak level in dB
             # Should be equivalent to: -af astats=measure_overall=Peak_level:measure_perchannel=0
             max_amplitude = np.abs(frame.to_ndarray()).max()
@@ -109,7 +114,7 @@ def apply_audio_normalization(
                 return -20.0 * np.log10(max_amplitude)
             return -99.0
 
-        with av.open(pre_master) as container:
+        with bv.open(pre_master) as container:
             max_peak_level = -99.0
             assert len(container.streams.video) == 0
             for frame in container.decode(audio=0):
@@ -121,13 +126,13 @@ def apply_audio_normalization(
         log.print(f"peak adjustment: {adjustment:.3f}dB")
         name, filter_args = "volume", f"{adjustment}"
 
-    with av.open(pre_master) as container:
+    with bv.open(pre_master) as container:
         input_stream = container.streams.audio[0]
 
-        output_file = av.open(path, mode="w")
+        output_file = bv.open(path, mode="w")
         output_stream = output_file.add_stream("pcm_s16le", rate=input_stream.rate)
 
-        graph = av.filter.Graph()
+        graph = bv.filter.Graph()
         graph.link_nodes(
             graph.add_abuffer(template=input_stream),
             graph.add(name, filter_args),
@@ -138,9 +143,9 @@ def apply_audio_normalization(
             while True:
                 try:
                     aframe = graph.pull()
-                    assert isinstance(aframe, av.AudioFrame)
+                    assert isinstance(aframe, bv.AudioFrame)
                     output_file.mux(output_stream.encode(aframe))
-                except (av.BlockingIOError, av.EOFError):
+                except (bv.BlockingIOError, bv.EOFError):
                     break
 
         output_file.mux(output_stream.encode(None))
@@ -154,14 +159,14 @@ def process_audio_clip(
     write(input_buffer, sr, samp_list[samp_start:samp_end])
     input_buffer.seek(0)
 
-    input_file = av.open(input_buffer, "r")
+    input_file = bv.open(input_buffer, "r")
     input_stream = input_file.streams.audio[0]
 
     output_bytes = io.BytesIO()
-    output_file = av.open(output_bytes, mode="w", format="wav")
+    output_file = bv.open(output_bytes, mode="w", format="wav")
     output_stream = output_file.add_stream("pcm_s16le", rate=sr)
 
-    graph = av.filter.Graph()
+    graph = bv.filter.Graph()
     args = [graph.add_abuffer(template=input_stream)]
 
     if clip.speed != 1:
@@ -191,9 +196,9 @@ def process_audio_clip(
         while True:
             try:
                 aframe = graph.pull()
-                assert isinstance(aframe, av.AudioFrame)
+                assert isinstance(aframe, bv.AudioFrame)
                 output_file.mux(output_stream.encode(aframe))
-            except (av.BlockingIOError, av.EOFError):
+            except (bv.BlockingIOError, bv.EOFError):
                 break
 
     # Flush the stream
@@ -217,7 +222,7 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
 
     # First pass: determine the maximum length
     for path in audio_paths:
-        container = av.open(path)
+        container = bv.open(path)
         stream = container.streams.audio[0]
 
         # Calculate duration in samples
@@ -229,10 +234,10 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
 
     # Second pass: read and mix audio
     for path in audio_paths:
-        container = av.open(path)
+        container = bv.open(path)
         stream = container.streams.audio[0]
 
-        resampler = av.audio.resampler.AudioResampler(
+        resampler = bv.audio.resampler.AudioResampler(
             format="s16", layout="mono", rate=sr
         )
 
@@ -265,7 +270,7 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
         mixed_audio = mixed_audio * (32767 / max_val)
     mixed_audio = mixed_audio.astype(np.int16)  # type: ignore
 
-    output_container = av.open(output_path, mode="w")
+    output_container = bv.open(output_path, mode="w")
     output_stream = output_container.add_stream("pcm_s16le", rate=sr)
 
     chunk_size = sr  # Process 1 second at a time
@@ -273,7 +278,7 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
         # Shape becomes (1, samples) for mono
         chunk = np.array([mixed_audio[i : i + chunk_size]])
 
-        frame = av.AudioFrame.from_ndarray(chunk, format="s16", layout="mono")
+        frame = bv.AudioFrame.from_ndarray(chunk, format="s16", layout="mono")
         frame.rate = sr
         frame.pts = i  # Set presentation timestamp
 
@@ -367,7 +372,7 @@ def make_new_audio(
     except PermissionError:
         pass
 
-    if not (args.keep_tracks_separate and ctr.max_audios is None) and len(output) > 1:
+    if args.mix_audio_streams and len(output) > 1:
         new_a_file = f"{Path(temp, 'new_audio.wav')}"
         mix_audio_files(sr, output, new_a_file)
         return [new_a_file]

auto_editor/render/subtitle.py

@@ -6,7 +6,7 @@ import re
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-import av
+import bv
 
 from auto_editor.utils.func import to_timecode
 
@@ -17,7 +17,7 @@ if TYPE_CHECKING:
     from auto_editor.utils.chunks import Chunks
     from auto_editor.utils.log import Log
 
-    Input = av.container.InputContainer
+    Input = bv.container.InputContainer
 
 
 @dataclass(slots=True)
@@ -138,18 +138,14 @@ def make_srt(input_: Input, stream: int) -> str:
         if packet.dts is None or packet.pts is None or packet.duration is None:
             continue
 
-        start = packet.pts * input_stream.time_base
-        end = start + packet.duration * input_stream.time_base
+        start_num = packet.pts * input_stream.time_base
+        start = to_timecode(start_num, "srt")
+        end = to_timecode(start_num + packet.duration * input_stream.time_base, "srt")
 
-        for subset in packet.decode():
-            start_time = to_timecode(start, "srt")
-            end_time = to_timecode(end, "srt")
+        for sub in packet.decode():
+            assert isinstance(sub, bv.subtitles.subtitle.AssSubtitle)
 
-            sub = subset[0]
-            assert len(subset) == 1
-            assert isinstance(sub, av.subtitles.subtitle.AssSubtitle)
-
-            output_bytes.write(f"{s}\n{start_time} --> {end_time}\n")
+            output_bytes.write(f"{s}\n{start} --> {end}\n")
             output_bytes.write(sub.dialogue.decode("utf-8", errors="ignore") + "\n\n")
             s += 1
 
@@ -159,7 +155,7 @@ def make_srt(input_: Input, stream: int) -> str:
 
 def _ensure(input_: Input, format: str, stream: int) -> str:
     output_bytes = io.BytesIO()
-    output = av.open(output_bytes, "w", format=format)
+    output = bv.open(output_bytes, "w", format=format)
 
     in_stream = input_.streams.subtitles[stream]
     out_stream = output.add_stream_from_template(in_stream)
@@ -179,7 +175,7 @@ def make_new_subtitles(tl: v3, log: Log) -> list[str]:
     if tl.v1 is None:
         return []
 
-    input_ = av.open(tl.v1.source.path)
+    input_ = bv.open(tl.v1.source.path)
     new_paths = []
 
     for s, sub in enumerate(tl.v1.source.subtitles):