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

auto_editor/imports/fcp7.py

@@ -1,275 +0,0 @@
-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/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.")