auto-editor 27.1.1__py3-none-any.whl → 28.0.1__py3-none-any.whl

auto_editor/imports/fcp7.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+from fractions import Fraction
+from typing import TYPE_CHECKING
+from urllib.parse import unquote
+from xml.etree.ElementTree import Element
+
+from auto_editor.ffwrapper import FileInfo
+from auto_editor.timeline import ASpace, Clip, Template, VSpace, v3
+
+if TYPE_CHECKING:
+    from auto_editor.utils.log import Log
+
+
+SUPPORTED_EFFECTS = ("timeremap",)
+
+
+def show(ele: Element, limit: int, depth: int = 0) -> None:
+    print(
+        f"{' ' * (depth * 4)}<{ele.tag} {ele.attrib}> {ele.text.strip() if ele.text is not None else ''}"
+    )
+    for child in ele:
+        if isinstance(child, Element) and depth < limit:
+            show(child, limit, depth + 1)
+
+
+def read_filters(clipitem: Element, log: Log) -> float:
+    for effect_tag in clipitem:
+        if effect_tag.tag in {"enabled", "start", "end"}:
+            continue
+        if len(effect_tag) < 3:
+            log.error("<effect> requires: <effectid> <name> and one <parameter>")
+        for i, effects in enumerate(effect_tag):
+            if i == 0 and effects.tag != "name":
+                log.error("<effect>: <name> must be first tag")
+            if i == 1 and effects.tag != "effectid":
+                log.error("<effect>: <effectid> must be second tag")
+                if effects.text not in SUPPORTED_EFFECTS:
+                    log.error(f"`{effects.text}` is not a supported effect.")
+
+            if i > 1:
+                for j, parms in enumerate(effects):
+                    if j == 0:
+                        if parms.tag != "parameterid":
+                            log.error("<parameter>: <parameterid> must be first tag")
+                        if parms.text != "speed":
+                            break
+
+                    if j > 0 and parms.tag == "value":
+                        if parms.text is None:
+                            log.error("<value>: number required")
+                        return float(parms.text) / 100
+
+    return 1.0
+
+
+def uri_to_path(uri: str) -> str:
+    # Handle inputs like:
+    # /Users/wyattblue/projects/auto-editor/example.mp4
+    # file:///Users/wyattblue/projects/auto-editor/example.mp4
+    # file:///C:/Users/WyattBlue/projects/auto-editor/example.mp4
+    # file://localhost/Users/wyattblue/projects/auto-editor/example.mp4
+
+    if uri.startswith("file://localhost/"):
+        uri = uri[16:]
+    elif uri.startswith("file://"):
+        # Windows-style paths
+        uri = uri[8:] if len(uri) > 8 and uri[9] == ":" else uri[7:]
+    else:
+        return uri
+    return unquote(uri)
+
+
+def read_tb_ntsc(tb: int, ntsc: bool) -> Fraction:
+    if ntsc:
+        if tb == 24:
+            return Fraction(24000, 1001)
+        if tb == 30:
+            return Fraction(30000, 1001)
+        if tb == 60:
+            return Fraction(60000, 1001)
+        return tb * Fraction(999, 1000)
+
+    return Fraction(tb)
+
+
+def fcp7_read_xml(path: str, log: Log) -> v3:
+    def xml_bool(val: str) -> bool:
+        if val == "TRUE":
+            return True
+        if val == "FALSE":
+            return False
+        raise TypeError("Value must be 'TRUE' or 'FALSE'")
+
+    try:
+        tree = ET.parse(path)
+    except FileNotFoundError:
+        log.error(f"Could not find '{path}'")
+
+    root = tree.getroot()
+
+    def parse(ele: Element, schema: dict) -> dict:
+        new: dict = {}
+        for key, val in schema.items():
+            if isinstance(val, dict) and "__arr" in val:
+                new[key] = []
+
+        is_arr = False
+        for child in ele:
+            if child.tag not in schema:
+                continue
+
+            if schema[child.tag] is None:
+                new[child.tag] = child
+                continue
+
+            if isinstance(schema[child.tag], dict):
+                val = parse(child, schema[child.tag])
+                is_arr = "__arr" in schema[child.tag]
+            else:
+                val = schema[child.tag](child.text)
+
+            if child.tag in new:
+                if not is_arr:
+                    log.error(f"<{child.tag}> can only occur once")
+                new[child.tag].append(val)
+            else:
+                new[child.tag] = [val] if is_arr else val
+
+        return new
+
+    def check(ele: Element, tag: str) -> None:
+        if tag != ele.tag:
+            log.error(f"Expected '{tag}' tag, got '{ele.tag}'")
+
+    check(root, "xmeml")
+    check(root[0], "sequence")
+    result = parse(
+        root[0],
+        {
+            "name": str,
+            "duration": int,
+            "rate": {
+                "timebase": Fraction,
+                "ntsc": xml_bool,
+            },
+            "media": None,
+        },
+    )
+
+    tb = read_tb_ntsc(result["rate"]["timebase"], result["rate"]["ntsc"])
+    av = parse(
+        result["media"],
+        {
+            "video": None,
+            "audio": None,
+        },
+    )
+
+    sources: dict[str, FileInfo] = {}
+    vobjs: VSpace = []
+    aobjs: ASpace = []
+
+    vclip_schema = {
+        "format": {
+            "samplecharacteristics": {
+                "width": int,
+                "height": int,
+            },
+        },
+        "track": {
+            "__arr": "",
+            "clipitem": {
+                "__arr": "",
+                "start": int,
+                "end": int,
+                "in": int,
+                "out": int,
+                "file": None,
+                "filter": None,
+            },
+        },
+    }
+
+    aclip_schema = {
+        "format": {"samplecharacteristics": {"samplerate": int}},
+        "track": {
+            "__arr": "",
+            "clipitem": {
+                "__arr": "",
+                "start": int,
+                "end": int,
+                "in": int,
+                "out": int,
+                "file": None,
+                "filter": None,
+            },
+        },
+    }
+
+    sr = 48000
+    res = (1920, 1080)
+
+    if "video" in av:
+        tracks = parse(av["video"], vclip_schema)
+
+        if "format" in tracks:
+            width = tracks["format"]["samplecharacteristics"]["width"]
+            height = tracks["format"]["samplecharacteristics"]["height"]
+            res = width, height
+
+        for t, track in enumerate(tracks["track"]):
+            if len(track["clipitem"]) > 0:
+                vobjs.append([])
+            for clipitem in track["clipitem"]:
+                file_id = clipitem["file"].attrib["id"]
+                if file_id not in sources:
+                    fileobj = parse(clipitem["file"], {"pathurl": str})
+
+                    if "pathurl" in fileobj:
+                        sources[file_id] = FileInfo.init(
+                            uri_to_path(fileobj["pathurl"]),
+                            log,
+                        )
+                    else:
+                        show(clipitem["file"], 3)
+                        log.error(
+                            f"'pathurl' child element not found in {clipitem['file'].tag}"
+                        )
+
+                if "filter" in clipitem:
+                    speed = read_filters(clipitem["filter"], log)
+                else:
+                    speed = 1.0
+
+                start = clipitem["start"]
+                dur = clipitem["end"] - start
+                offset = clipitem["in"]
+
+                vobjs[t].append(
+                    Clip(start, dur, sources[file_id], offset, stream=0, speed=speed)
+                )
+
+    if "audio" in av:
+        tracks = parse(av["audio"], aclip_schema)
+        if "format" in tracks:
+            sr = tracks["format"]["samplecharacteristics"]["samplerate"]
+
+        for t, track in enumerate(tracks["track"]):
+            if len(track["clipitem"]) > 0:
+                aobjs.append([])
+            for clipitem in track["clipitem"]:
+                file_id = clipitem["file"].attrib["id"]
+                if file_id not in sources:
+                    fileobj = parse(clipitem["file"], {"pathurl": str})
+                    sources[file_id] = FileInfo.init(
+                        uri_to_path(fileobj["pathurl"]), log
+                    )
+
+                if "filter" in clipitem:
+                    speed = read_filters(clipitem["filter"], log)
+                else:
+                    speed = 1.0
+
+                start = clipitem["start"]
+                dur = clipitem["end"] - start
+                offset = clipitem["in"]
+
+                aobjs[t].append(
+                    Clip(start, dur, sources[file_id], offset, stream=0, speed=speed)
+                )
+
+    T = Template.init(sources[next(iter(sources))], sr, res=res)
+    return v3(tb, "#000", T, vobjs, aobjs, v1=None)

auto_editor/{formats → imports}/json.py

@@ -1,32 +1,27 @@
 from __future__ import annotations
 
 import os
-import sys
 from difflib import get_close_matches
 from fractions import Fraction
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from auto_editor.ffwrapper import FileInfo
-from auto_editor.json import dump, load
+from auto_editor.json import load
 from auto_editor.lib.err import MyError
 from auto_editor.timeline import (
-    ASpace,
+    Clip,
     Template,
-    TlAudio,
-    TlVideo,
-    VSpace,
     audio_builder,
     v1,
     v3,
     visual_objects,
 )
 from auto_editor.utils.cmdkw import ParserError, Required, pAttrs
-from auto_editor.utils.log import Log
 from auto_editor.utils.types import CoerceError
 
-"""
-Make a pre-edited file reference that can be inputted back into auto-editor.
-"""
+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:
@@ -116,7 +111,7 @@ def read_v3(tl: Any, log: Log) -> v3:
     tb = Fraction(tl["timebase"])
 
     v: Any = []
-    a: list[list[TlAudio]] = []
+    a: list[list[Clip]] = []
 
     for vlayers in tl["v"]:
         if vlayers:
@@ -145,7 +140,7 @@ def read_v3(tl: Any, log: Log) -> v3:
                     log.error(f"Unknown audio object: {adict['name']}")
 
                 try:
-                    a_out.append(TlAudio(**parse_obj(adict, audio_builder)))
+                    a_out.append(Clip(**parse_obj(adict, audio_builder)))
                 except ParserError as e:
                     log.error(e)
 
@@ -202,10 +197,10 @@ def read_v1(tl: Any, log: Log) -> v3:
         if src.videos:
             if len(vtl) == 0:
                 vtl.append([])
-            vtl[0].append(TlVideo(c.start, c.dur, c.src, c.offset, c.speed, 0))
+            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(TlAudio(c.start, c.dur, c.src, c.offset, c.speed, 1, a))
+            atl[a].append(Clip(c.start, c.dur, c.src, c.offset, a, c.speed))
 
     return v3(
         src.get_fps(),
@@ -218,11 +213,13 @@ 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:
+    try:
+        with open(path, encoding="utf-8", errors="ignore") as f:
             tl = load(path, f)
-        except MyError as e:
-            log.error(e)
+    except FileNotFoundError:
+        log.error(f"File not found: {path}")
+    except MyError as e:
+        log.error(e)
 
     check_attrs(tl, log, "version")
 
@@ -235,27 +232,3 @@ def read_json(path: str, log: Log) -> v3:
     if type(ver) is not str:
         log.error("version needs to be a string")
     log.error(f"Importing version {ver} timelines is not supported.")
-
-
-def make_json_timeline(ver: int, out: str | int, tl: v3, log: Log) -> None:
-    if ver not in {3, 1}:
-        log.error(f"Version {ver} is not supported!")
-
-    if isinstance(out, str):
-        if not out.endswith(".json"):
-            log.error("Output extension must be .json")
-        outfile: Any = open(out, "w")
-    else:
-        outfile = sys.stdout
-
-    if ver == 3:
-        dump(tl.as_dict(), outfile, indent=2)
-    else:
-        if tl.v1 is None:
-            log.error("Timeline can't be converted to v1 format")
-        dump(tl.v1.as_dict(), outfile, indent=2)
-
-    if isinstance(out, str):
-        outfile.close()
-    else:
-        print("")  # Flush stdout

auto_editor/json.py

@@ -89,7 +89,7 @@ class Lexer:
 
                 if self.char == "u":
                     buf = ""
-                    for i in range(4):
+                    for _ in range(4):
                         self.advance()
                         if self.char is None:
                             self.error("\\u escape sequence needs 4 hexs")
@@ -162,7 +162,7 @@ class Lexer:
                 return (key, None)
 
             keyword = ""
-            for i in range(5):  # Longest valid keyword length
+            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

auto_editor/lang/palet.py

@@ -65,20 +65,11 @@ class Token:
 
 
 class Lexer:
-    __slots__ = (
-        "filename",
-        "text",
-        "allow_lang_prag",
-        "pos",
-        "char",
-        "lineno",
-        "column",
-    )
-
-    def __init__(self, filename: str, text: str, langprag: bool = False):
+    __slots__ = ("filename", "text", "pos", "char", "lineno", "column")
+
+    def __init__(self, filename: str, text: str):
         self.filename = filename
         self.text = text
-        self.allow_lang_prag = langprag
         self.pos: int = 0
         self.lineno: int = 1
         self.column: int = 1
@@ -157,7 +148,7 @@ class Lexer:
                 token = SEC
             elif unit == "dB":
                 token = DB
-            elif unit != "i" and unit != "%":
+            elif unit != "%":
                 return Token(
                     VAL,
                     Sym(result + unit, self.lineno, self.column),
@@ -166,9 +157,7 @@ class Lexer:
                 )
 
         try:
-            if unit == "i":
-                return Token(VAL, complex(result + "j"), self.lineno, self.column)
-            elif unit == "%":
+            if unit == "%":
                 return Token(VAL, float(result) / 100, self.lineno, self.column)
             elif "/" in result:
                 return Token(token, Fraction(result), self.lineno, self.column)
@@ -289,32 +278,6 @@ class Lexer:
                         self.advance()
                     if self.char is None or self.char == "\n":
                         continue
-
-                elif self.char == "l" and self.peek() == "a":
-                    buf = StringIO()
-                    while self.char_is_norm():
-                        assert self.char is not None
-                        buf.write(self.char)
-                        self.advance()
-
-                    result = buf.getvalue()
-                    if result != "lang":
-                        self.error(f"Unknown hash literal `#{result}`")
-                    if not self.allow_lang_prag:
-                        self.error("#lang pragma is not allowed here")
-
-                    self.advance()
-                    buf = StringIO()
-                    while not self.is_whitespace():
-                        assert self.char is not None
-                        buf.write(self.char)
-                        self.advance()
-
-                    result = buf.getvalue()
-                    if result != "palet":
-                        self.error(f"Invalid #lang: {result}")
-                    self.allow_lang_prag = False
-                    continue
                 else:
                     return self.hash_literal()
 
@@ -747,7 +710,7 @@ env.update({
 # fmt: on
 
 
-def interpret(env: Env, parser: Parser) -> list:
+def interpret(env: Env, parser: Parser) -> list[object]:
     result = []
 
     try:

auto_editor/lang/stdenv.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 import bv
@@ -7,23 +8,24 @@ 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 *
+from auto_editor.lib.err import MyError
 
 from .palet import Syntax, env, is_boolarr, is_iterable, my_eval, p_slice, raise_, ref
 
 if TYPE_CHECKING:
+    from fractions import Fraction
     from typing import Any, Literal
 
     import numpy as np
     from numpy.typing import NDArray
 
-    Number = int | float | complex | Fraction
+    Number = int | float | Fraction
     BoolList = NDArray[np.bool_]
     Node = tuple
 
 
 def make_standard_env() -> dict[str, Any]:
     import os.path
-    from cmath import sqrt as complex_sqrt
     from functools import reduce
     from operator import add, ge, gt, is_, le, lt, mod, mul
     from subprocess import run
@@ -509,7 +511,7 @@ def make_standard_env() -> dict[str, Any]:
             for c in node[2:]:
                 my_eval(env, c)
 
-    def syn_quote(env: Env, node: Node) -> Any:
+    def syn_quote(_: Env, node: Node) -> Any:
         guard_term(node, 2, 2)
         if type(node[1]) is Keyword:
             return QuotedKeyword(node[1])
@@ -825,14 +827,6 @@ def make_standard_env() -> dict[str, Any]:
 
         return reduce(lambda a, b: a // b, m, n)
 
-    def _sqrt(v: Number) -> Number:
-        r = complex_sqrt(v)
-        if r.imag == 0:
-            if int(r.real) == r.real:
-                return int(r.real)
-            return r.real
-        return r
-
     def _xor(*vals: Any) -> bool | BoolList:
         if is_boolarr(vals[0]):
             check_args("xor", vals, (2, None), (is_boolarr,))
@@ -841,9 +835,6 @@ def make_standard_env() -> dict[str, Any]:
         return reduce(lambda a, b: a ^ b, vals)
 
     def number_to_string(val: Number) -> str:
-        if isinstance(val, complex):
-            join = "" if val.imag < 0 else "+"
-            return f"{val.real}{join}{val.imag}i"
         return f"{val}"
 
     def string_to_number(val) -> float:
@@ -928,7 +919,7 @@ def make_standard_env() -> dict[str, Any]:
         except Exception:
             raise MyError("hash-ref: invalid key")
 
-    def hash_set(h: dict, k: object, v: object) -> None:
+    def hash_set(h: dict[object, object], k: object, v: object) -> None:
         h[k] = v
 
     def hash_remove(h: dict, v: object) -> None:
@@ -953,7 +944,7 @@ def make_standard_env() -> dict[str, Any]:
         except Exception:
             return False
 
-    def change_file_ext(a, ext) -> str:
+    def change_file_ext(a: str, ext: str) -> str:
         import os.path
 
         base_name = os.path.splitext(a)[0]
@@ -968,6 +959,7 @@ def make_standard_env() -> dict[str, Any]:
         # syntax
         "lambda": Syntax(syn_lambda),
         "λ": Syntax(syn_lambda),
+        "defn": Syntax(syn_define),
         "define": Syntax(syn_define),
         "define/c": Syntax(syn_definec),
         "set!": Syntax(syn_set),
@@ -994,7 +986,6 @@ def make_standard_env() -> dict[str, Any]:
         "int?": is_int,
         "float?": is_float,
         "frac?": is_frac,
-        "complex?": Contract("complex?", lambda v: type(v) is complex),
         "nat?": is_nat,
         "nat1?": is_nat1,
         "threshold?": is_threshold,
@@ -1049,9 +1040,6 @@ def make_standard_env() -> dict[str, Any]:
         "div": Proc("div", int_div, (2, None), is_int),
         "add1": Proc("add1", lambda z: z + 1, (1, 1), is_num),
         "sub1": Proc("sub1", lambda z: z - 1, (1, 1), is_num),
-        "sqrt": Proc("sqrt", _sqrt, (1, 1), is_num),
-        "real-part": Proc("real-part", lambda v: v.real, (1, 1), is_num),
-        "imag-part": Proc("imag-part", lambda v: v.imag, (1, 1), is_num),
         # reals
         "pow": Proc("pow", pow, (2, 2), is_real),
         "abs": Proc("abs", abs, (1, 1), is_real),

auto_editor/lib/contracts.py

@@ -46,7 +46,7 @@ def check_contract(c: object, val: object) -> bool:
         return val is True
     if c is False:
         return val is False
-    if type(c) in (int, float, float64, Fraction, complex, str, Sym):
+    if type(c) in (int, float, float64, Fraction, str, Sym):
         return val == c
     raise MyError(f"Invalid contract, got: {print_str(c)}")
 
@@ -97,7 +97,7 @@ class Proc:
             self.kw_contracts = None
             self.contracts = c
 
-    def __call__(self, *args: Any, **kwargs: Any):
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
         lower, upper = self.arity
         amount = len(args)
         cont = self.contracts
@@ -164,7 +164,7 @@ def is_contract(c: object) -> bool:
         return True
     if c is True or c is False:
         return True
-    return type(c) in (int, float, Fraction, complex, str, Sym)
+    return type(c) in (int, float, Fraction, str, Sym)
 
 
 is_bool = Contract("bool?", lambda v: type(v) is bool)
@@ -172,10 +172,8 @@ is_int = Contract("int?", lambda v: type(v) is int)
 is_nat = Contract("nat?", lambda v: type(v) is int and v > -1)
 is_nat1 = Contract("nat1?", lambda v: type(v) is int and v > 0)
 int_not_zero = Contract("(or/c (not/c 0) int?)", lambda v: v != 0 and is_int(v))
-is_num = Contract(
-    "number?", lambda v: type(v) in (int, float, float64, Fraction, complex)
-)
 is_real = Contract("real?", lambda v: type(v) in (int, float, float64, Fraction))
+is_num = is_real
 is_float = Contract("float?", lambda v: type(v) in (float, float64))
 is_frac = Contract("frac?", lambda v: type(v) is Fraction)
 is_str = Contract("string?", lambda v: type(v) is str)

auto_editor/lib/data_structs.py

@@ -182,9 +182,6 @@ def display_str(val: object) -> str:
         return f"{val}"
     if type(val) is range:
         return "#<range>"
-    if type(val) is complex:
-        join = "" if val.imag < 0 else "+"
-        return f"{val.real}{join}{val.imag}i"
     if type(val) is np.bool_:
         return "1" if val else "0"
     if type(val) is np.float64 or type(val) is np.float32: