auto-editor 28.1.0__py3-none-any.whl → 29.0.0__py3-none-any.whl

auto_editor/imports/json.py

@@ -1,234 +0,0 @@
-from __future__ import annotations
-
-import os
-from difflib import get_close_matches
-from fractions import Fraction
-from typing import TYPE_CHECKING, Any
-
-from auto_editor.ffwrapper import FileInfo
-from auto_editor.json import load
-from auto_editor.lib.err import MyError
-from auto_editor.timeline import (
-    Clip,
-    Template,
-    audio_builder,
-    v1,
-    v3,
-    visual_objects,
-)
-from auto_editor.utils.cmdkw import ParserError, Required, pAttrs
-from auto_editor.utils.types import CoerceError
-
-if TYPE_CHECKING:
-    from auto_editor.timeline import ASpace, VSpace
-    from auto_editor.utils.log import Log
-
-
-def check_attrs(data: object, log: Log, *attrs: str) -> None:
-    if not isinstance(data, dict):
-        log.error("Data is in wrong shape!")
-
-    for attr in attrs:
-        if attr not in data:
-            log.error(f"'{attr}' attribute not found!")
-
-
-def check_file(path: str, log: Log) -> None:
-    if not os.path.isfile(path):
-        log.error(f"Could not locate media file: '{path}'")
-
-
-def read_v3(tl: Any, log: Log) -> v3:
-    check_attrs(
-        tl,
-        log,
-        "background",
-        "v",
-        "a",
-        "timebase",
-        "resolution",
-        "samplerate",
-    )
-
-    srcs: dict[str, FileInfo] = {}
-
-    def make_src(v: str) -> FileInfo:
-        if v in srcs:
-            return srcs[v]
-        temp = FileInfo.init(v, log)
-        srcs[v] = temp
-        return temp
-
-    def parse_obj(obj: dict[str, Any], build: pAttrs) -> dict[str, Any]:
-        kwargs: dict[str, Any] = {}
-        del obj["name"]
-
-        for attr in build.attrs:
-            assert attr.coerce is not None
-            if attr.default is Required:
-                kwargs[attr.n] = Required
-            else:
-                assert attr.coerce != "source"
-                kwargs[attr.n] = attr.coerce(attr.default)
-
-        for key, val in obj.items():
-            found = False
-            for attr in build.attrs:
-                if key == attr.n:
-                    try:
-                        if attr.coerce == "source":
-                            kwargs[key] = make_src(val)
-                        else:
-                            assert attr.coerce is not None
-                            kwargs[key] = attr.coerce(val)
-                    except CoerceError as e:
-                        raise ParserError(e)
-                    found = True
-                    break
-
-            if not found:
-                all_names = {attr.n for attr in build.attrs}
-                if matches := get_close_matches(key, all_names):
-                    more = f"\n    Did you mean:\n        {', '.join(matches)}"
-                else:
-                    more = (
-                        f"\n    attributes available:\n        {', '.join(all_names)}"
-                    )
-
-                raise ParserError(
-                    f"{build.name} got an unexpected keyword '{key}'\n{more}"
-                )
-
-        for k, v in kwargs.items():
-            if v is Required:
-                raise ParserError(f"'{k}' must be specified.")
-
-        return kwargs
-
-    bg = tl["background"]
-    sr = tl["samplerate"]
-    res = (tl["resolution"][0], tl["resolution"][1])
-    tb = Fraction(tl["timebase"])
-
-    v: Any = []
-    a: list[list[Clip]] = []
-
-    for vlayers in tl["v"]:
-        if vlayers:
-            v_out: VSpace = []
-            for vdict in vlayers:
-                if "name" not in vdict:
-                    log.error("Invalid video object: name not specified")
-                if vdict["name"] not in visual_objects:
-                    log.error(f"Unknown video object: {vdict['name']}")
-                my_vobj, my_build = visual_objects[vdict["name"]]
-
-                try:
-                    v_out.append(my_vobj(**parse_obj(vdict, my_build)))
-                except ParserError as e:
-                    log.error(e)
-
-            v.append(v_out)
-
-    for alayers in tl["a"]:
-        if alayers:
-            a_out = []
-            for adict in alayers:
-                if "name" not in adict:
-                    log.error("Invalid audio object: name not specified")
-                if adict["name"] != "audio":
-                    log.error(f"Unknown audio object: {adict['name']}")
-
-                try:
-                    a_out.append(Clip(**parse_obj(adict, audio_builder)))
-                except ParserError as e:
-                    log.error(e)
-
-            a.append(a_out)
-
-    try:
-        T = Template.init(srcs[next(iter(srcs))])
-    except StopIteration:
-        T = Template(sr, "stereo", res, [], [])
-
-    return v3(tb, bg, T, v, a, v1=None)
-
-
-def read_v1(tl: Any, log: Log) -> v3:
-    from auto_editor.make_layers import clipify
-
-    check_attrs(tl, log, "source", "chunks")
-
-    chunks = tl["chunks"]
-    path = tl["source"]
-
-    check_file(path, log)
-
-    src = FileInfo.init(path, log)
-
-    vtl: VSpace = []
-    atl: ASpace = [[] for _ in range(len(src.audios))]
-
-    # Verify chunks
-    last_end: int | None = None
-    if type(chunks) is not list:
-        log.error("chunks key must be an array")
-
-    for i, chunk in enumerate(chunks):
-        if type(chunk) is not list or len(chunk) != 3:
-            log.error(f"Invalid chunk at chunk {i}")
-        if type(chunk[0]) not in (int, float) or chunk[0] < 0:
-            log.error(f"Invalid start at chunk {i}")
-        if type(chunk[1]) not in (int, float) or chunk[1] <= chunk[0]:
-            log.error(f"Invalid end at chunk {i}")
-        if type(chunk[2]) not in (int, float) or chunk[2] < 0.0 or chunk[2] > 99999.0:
-            log.error(f"Invalid speed at chunk {i}")
-
-        if i == 0 and chunk[0] != 0:
-            log.error("First chunk must start with 0")
-        if i != 0 and chunk[0] != last_end:
-            log.error(f"Invalid start at chunk {i}")
-        last_end = chunk[1]
-
-        if type(chunk[0]) is float or type(chunk[1]) is float or type(chunk[2]) is int:
-            chunks[i] = (int(chunk[0]), int(chunk[1]), float(chunk[2]))
-
-    for c in clipify(chunks, src):
-        if src.videos:
-            if len(vtl) == 0:
-                vtl.append([])
-            vtl[0].append(Clip(c.start, c.dur, c.src, c.offset, 0, c.speed))
-
-        for a in range(len(src.audios)):
-            atl[a].append(Clip(c.start, c.dur, c.src, c.offset, a, c.speed))
-
-    return v3(
-        src.get_fps(),
-        "#000",
-        Template.init(src),
-        vtl,
-        atl,
-        v1(src, chunks),
-    )
-
-
-def read_json(path: str, log: Log) -> v3:
-    try:
-        with open(path, encoding="utf-8", errors="ignore") as f:
-            tl = load(path, f)
-    except FileNotFoundError:
-        log.error(f"File not found: {path}")
-    except MyError as e:
-        log.error(e)
-
-    check_attrs(tl, log, "version")
-
-    ver = tl["version"]
-
-    if ver == "3":
-        return read_v3(tl, log)
-    if ver == "1":
-        return read_v1(tl, log)
-    if type(ver) is not str:
-        log.error("version needs to be a string")
-    log.error(f"Importing version {ver} timelines is not supported.")

auto_editor/json.py

@@ -1,297 +0,0 @@
-from __future__ import annotations
-
-from io import StringIO, TextIOWrapper
-from typing import TYPE_CHECKING
-
-from auto_editor.ffwrapper import FileInfo
-from auto_editor.lib.err import MyError
-
-if TYPE_CHECKING:
-    from typing import Any, NoReturn
-
-    from _typeshed import SupportsWrite
-
-    Token = tuple[int, object]
-
-
-EOF, LCUR, RCUR, LBRAC, RBRAC, COL, COMMA, STR, VAL = range(9)
-str_escape = {
-    "\\": "\\",
-    "/": "/",
-    '"': '"',
-    "b": "\b",
-    "f": "\f",
-    "n": "\n",
-    "r": "\r",
-    "t": "\t",
-}
-
-
-def normalize_string(v: str) -> str:
-    for to, replace in str_escape.items():
-        if to == "/":
-            continue
-        v = v.replace(replace, f"\\{to}")
-    return v
-
-
-class Lexer:
-    __slots__ = ("filename", "text", "pos", "char", "lineno", "column")
-
-    def __init__(self, filename: str, text: str | bytes | TextIOWrapper):
-        self.filename = filename
-        self.pos: int = 0
-        self.lineno: int = 1
-        self.column: int = 1
-
-        if isinstance(text, bytes):
-            self.text: str = text.decode("utf-8", "replace")
-        elif isinstance(text, str):
-            self.text = text
-        else:
-            self.text = text.read()
-
-        self.char: str | None = self.text[self.pos] if text else None
-
-    def error(self, msg: str) -> NoReturn:
-        raise MyError(f"{msg}\n  at {self.filename}:{self.lineno}:{self.column}")
-
-    def advance(self) -> None:
-        if self.char == "\n":
-            self.lineno += 1
-            self.column = 0
-
-        self.pos += 1
-
-        if self.pos > len(self.text) - 1:
-            self.char = None
-        else:
-            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]
-
-    def string(self) -> str:
-        result = StringIO()
-        while self.char is not None and self.char != '"':
-            if self.char == "\\":
-                self.advance()
-                if self.char is None:
-                    break
-
-                if self.char == "u":
-                    buf = ""
-                    for _ in range(4):
-                        self.advance()
-                        if self.char is None:
-                            self.error("\\u escape sequence needs 4 hexs")
-                        buf += self.char
-                    try:
-                        result.write(chr(int(buf, 16)))
-                    except ValueError:
-                        self.error(f"Invalid \\u escape sequence: `{buf}`")
-                if self.char in str_escape:
-                    result.write(str_escape[self.char])
-                    self.advance()
-                    continue
-
-                self.error(f"Unknown escape sequence `\\{self.char}` in string")
-            else:
-                result.write(self.char)
-            self.advance()
-
-        if self.char is None:
-            self.error('Expected a closing `"`')
-
-        self.advance()
-        return result.getvalue()
-
-    def number(self) -> Token:
-        buf = StringIO()
-
-        has_dot = False
-        while self.char is not None and self.char in "-0123456789.":
-            if self.char == ".":
-                if has_dot:
-                    self.error("Number has multiple `.`s")
-                has_dot = True
-            buf.write(self.char)
-            self.advance()
-
-        result = buf.getvalue()
-
-        try:
-            return (VAL, float(result) if has_dot else int(result))
-        except ValueError:
-            self.error(f"`{result}` is not a valid JSON Number")
-
-    def is_whitespace(self) -> bool:
-        return self.char is None or self.char in " \t\n\r\x0b\x0c"
-
-    def get_next_token(self) -> Token:
-        while self.char is not None:
-            while self.char is not None and self.is_whitespace():
-                self.advance()
-            if self.char is None:
-                break
-
-            if self.char == '"':
-                self.advance()
-                return (STR, self.string())
-
-            if self.char == "-":
-                _peek = self.peek()
-                if _peek is not None and _peek in "0123456789.":
-                    return self.number()
-
-            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 (key, None)
-
-            keyword = ""
-            for _ in range(5):  # Longest valid keyword length
-                if self.char is None or self.char in " \t\n\r\x0b\x0c[]}{,":
-                    break
-                keyword += self.char
-                self.advance()
-
-            if keyword == "true":
-                return (VAL, True)
-            if keyword == "false":
-                return (VAL, False)
-            if keyword == "null":
-                return (VAL, None)
-
-            self.error(f"Invalid keyword: `{keyword}`")
-        return (EOF, None)
-
-
-class Parser:
-    __slots__ = ("lexer", "current_token")
-
-    def __init__(self, lexer: Lexer):
-        self.lexer = lexer
-        self.current_token = self.lexer.get_next_token()
-
-    def eat(self) -> None:
-        self.current_token = self.lexer.get_next_token()
-
-    def expr(self) -> Any:
-        self.current_token
-
-        if self.current_token[0] in {STR, VAL}:
-            val = self.current_token[1]
-            self.eat()
-            return val
-
-        if self.current_token[0] == LCUR:
-            self.eat()
-
-            my_dic = {}
-            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[1]
-                if key in my_dic:
-                    self.lexer.error(f"Object has repeated key `{key}`")
-                self.eat()
-                if self.current_token[0] != COL:
-                    self.lexer.error("Expected `:`")
-                self.eat()
-
-                my_dic[key] = self.expr()
-                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[0] == RCUR:
-                        self.lexer.error("Trailing `,` in Object")
-
-            self.eat()
-            return my_dic
-
-        if self.current_token[0] == LBRAC:
-            self.eat()
-            my_arr = []
-            while self.current_token[0] != RBRAC:
-                my_arr.append(self.expr())
-                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[0] == RBRAC:
-                        self.lexer.error("Trailing `,` in array")
-            self.eat()
-            return my_arr
-
-        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:
-    if data is True:
-        file.write("true")
-    elif data is False:
-        file.write("false")
-    elif data is None:
-        file.write("null")
-    elif isinstance(data, str):
-        file.write(f'"{normalize_string(data)}"')
-    elif isinstance(data, FileInfo):
-        file.write(f'"{normalize_string(f"{data.path}")}"')
-    elif isinstance(data, int | float):
-        file.write(f"{data}")
-    elif isinstance(data, list | tuple):
-        file.write("[")
-        if indent is not None:
-            level += indent
-            file.write("\n" + (" " * level))
-
-        for item in data[:-1]:
-            dump(item, file, indent, level)
-            file.write(", " if indent is None else f",\n{' ' * level}")
-        if data:
-            dump(data[-1], file, indent, level)
-        file.write("]" if indent is None else f"\n{' ' * (level - indent)}]")
-    else:
-        my_dic = data if isinstance(data, dict) else data.__dict__
-        file.write("{")
-        if indent is not None:
-            level += indent
-            file.write("\n" + (" " * level))
-        not_first = False
-        for key, item in my_dic.items():
-            if not_first:
-                file.write(", " if indent is None else f",\n{' ' * level}")
-            dump(key, file, indent, level)
-            file.write(": ")
-            dump(item, file, indent, level)
-            not_first = True
-
-        if indent is not None:
-            file.write(f"\n{' ' * (level - indent)}")
-        file.write("}")

auto_editor/lang/libintrospection.py

@@ -1,10 +0,0 @@
-from .palet import Syntax
-
-
-def all() -> dict[str, object]:
-    return {
-        "get-current-env": Syntax(lambda env, node: env.data.copy()),
-        "proc-name": Syntax(
-            lambda env, node: [proc := node[1].val, env[proc].name][-1]
-        ),
-    }

auto_editor/lang/libmath.py

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-import math
-
-from auto_editor.lib.contracts import Proc, andc, between_c, gt_c, is_real
-
-
-def all() -> dict[str, object]:
-    return {
-        "exp": Proc("exp", math.exp, (1, 1), is_real),
-        "ceil": Proc("ceil", math.ceil, (1, 1), is_real),
-        "floor": Proc("floor", math.floor, (1, 1), is_real),
-        "sin": Proc("sin", math.sin, (1, 1), is_real),
-        "cos": Proc("cos", math.cos, (1, 1), is_real),
-        "tan": Proc("tan", math.tan, (1, 1), is_real),
-        "asin": Proc("asin", math.asin, (1, 1), between_c(-1, 1)),
-        "acos": Proc("acos", math.acos, (1, 1), between_c(-1, 1)),
-        "atan": Proc("atan", math.atan, (1, 1), is_real),
-        "log": Proc("log", math.log, (1, 2), andc(is_real, gt_c(0))),
-        "pi": math.pi,
-        "e": math.e,
-        "tau": math.tau,
-    }