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

auto_editor/{formats → exports}/fcp7.py

@@ -7,9 +7,7 @@ from typing import TYPE_CHECKING
 from xml.etree.ElementTree import Element
 
 from auto_editor.ffwrapper import FileInfo
-from auto_editor.timeline import ASpace, Template, TlAudio, TlVideo, VSpace, v3
-
-from .utils import Validator, show
+from auto_editor.timeline import TlVideo, v3
 
 if TYPE_CHECKING:
     from auto_editor.utils.log import Log
@@ -27,28 +25,6 @@ come back the way they started.
 DEPTH = "16"
 
 
-def uri_to_path(uri: str) -> str:
-    urllib = __import__("urllib.parse", fromlist=["parse"])
-
-    if uri.startswith("file://localhost/"):
-        uri = uri[16:]
-    elif uri.startswith("file://"):
-        # Windows-style paths
-        if len(uri) > 8 and uri[9] == ":":
-            uri = uri[8:]
-        else:
-            uri = uri[7:]
-    else:
-        return uri
-
-    return urllib.parse.unquote(uri)
-
-    # /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
-
-
 def set_tb_ntsc(tb: Fraction) -> tuple[int, str]:
     # See chart: https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/FinalCutPro_XML/FrameRate/FrameRate.html#//apple_ref/doc/uid/TP30001158-TPXREF103
     if tb == Fraction(24000, 1001):
@@ -65,19 +41,6 @@ def set_tb_ntsc(tb: Fraction) -> tuple[int, str]:
     return int(tb), "FALSE"
 
 
-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 speedup(speed: float) -> Element:
     fil = Element("filter")
     effect = ET.SubElement(fil, "effect")
@@ -139,167 +102,6 @@ def read_filters(clipitem: Element, log: Log) -> float:
     return 1.0
 
 
-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()
-
-    valid = Validator(log)
-
-    valid.check(root, "xmeml")
-    valid.check(root[0], "sequence")
-    result = valid.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 = valid.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 = valid.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 i, clipitem in enumerate(track["clipitem"]):
-                file_id = clipitem["file"].attrib["id"]
-                if file_id not in sources:
-                    fileobj = valid.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(
-                    TlVideo(start, dur, sources[file_id], offset, speed, stream=0)
-                )
-
-    if "audio" in av:
-        tracks = valid.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 i, clipitem in enumerate(track["clipitem"]):
-                file_id = clipitem["file"].attrib["id"]
-                if file_id not in sources:
-                    fileobj = valid.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(
-                    TlAudio(
-                        start, dur, sources[file_id], offset, speed, volume=1, stream=0
-                    )
-                )
-
-    T = Template.init(sources[next(iter(sources))], sr, res=res)
-    return v3(tb, "#000", T, vobjs, aobjs, v1=None)
-
-
 def media_def(
     filedef: Element, url: str, src: FileInfo, tl: v3, tb: int, ntsc: str
 ) -> None:
@@ -472,7 +274,7 @@ def fcp7_write_xml(name: str, output: str, resolve: bool, tl: v3) -> None:
         sequence = ET.SubElement(xmeml, "sequence", explodedTracks="true")
 
     ET.SubElement(sequence, "name").text = name
-    ET.SubElement(sequence, "duration").text = f"{int(tl.out_len())}"
+    ET.SubElement(sequence, "duration").text = f"{len(tl)}"
     rate = ET.SubElement(sequence, "rate")
     ET.SubElement(rate, "timebase").text = f"{timebase}"
     ET.SubElement(rate, "ntsc").text = ntsc
@@ -542,4 +344,7 @@ def fcp7_write_xml(name: str, output: str, resolve: bool, tl: v3) -> None:
 
     tree = ET.ElementTree(xmeml)
     ET.indent(tree, space="  ", level=0)
-    tree.write(output, xml_declaration=True, encoding="utf-8")
+    if output == "-":
+        print(ET.tostring(xmeml, encoding="unicode"))
+    else:
+        tree.write(output, xml_declaration=True, encoding="utf-8")

auto_editor/exports/json.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+from auto_editor.json import dump
+from auto_editor.timeline import v3
+
+if TYPE_CHECKING:
+    from auto_editor.utils.log import Log
+
+
+def make_json_timeline(ver: str, out: str, tl: v3, log: Log) -> None:
+    if ver not in {"v1", "v3"}:
+        log.error(f"Unknown timeline version: {ver}")
+
+    if out == "-":
+        outfile = sys.stdout
+    else:
+        outfile = open(out, "w")
+
+    if ver == "v3":
+        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 out == "-":
+        print("")  # Flush stdout
+    else:
+        outfile.close()

auto_editor/{formats → exports}/shotcut.py

@@ -1,16 +1,12 @@
-from __future__ import annotations
-
 import xml.etree.ElementTree as ET
 from typing import TYPE_CHECKING, Any, cast
 
-from auto_editor.timeline import v3
+from auto_editor.timeline import TlAudio, TlVideo, v3
 from auto_editor.utils.func import aspect_ratio, to_timecode
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
-    from auto_editor.timeline import TlAudio, TlVideo
-    from auto_editor.utils.log import Log
 
 """
 Shotcut uses the MLT timeline format
@@ -21,10 +17,6 @@ https://mltframework.org/docs/mltxml/
 """
 
 
-def shotcut_read_mlt(path: str, log: Log) -> v3:
-    raise NotImplementedError
-
-
 def shotcut_write_mlt(output: str, tl: v3) -> None:
     mlt = ET.Element(
         "mlt",
@@ -61,7 +53,7 @@ def shotcut_write_mlt(output: str, tl: v3) -> None:
     playlist_bin = ET.SubElement(mlt, "playlist", id="main_bin")
     ET.SubElement(playlist_bin, "property", name="xml_retain").text = "1"
 
-    global_out = to_timecode(tl.out_len() / tb, "standard")
+    global_out = to_timecode(len(tl) / tb, "standard")
 
     producer = ET.SubElement(mlt, "producer", id="bg")
 
@@ -154,4 +146,7 @@ def shotcut_write_mlt(output: str, tl: v3) -> None:
 
     ET.indent(tree, space="\t", level=0)
 
-    tree.write(output, xml_declaration=True, encoding="utf-8")
+    if output == "-":
+        print(ET.tostring(mlt, encoding="unicode"))
+    else:
+        tree.write(output, xml_declaration=True, encoding="utf-8")

auto_editor/ffwrapper.py

@@ -66,7 +66,6 @@ class FileInfo:
     path: Path
     bitrate: int
     duration: float
-    description: str | None
     videos: tuple[VideoStream, ...]
     audios: tuple[AudioStream, ...]
     subtitles: tuple[SubtitleStream, ...]
@@ -166,13 +165,12 @@ class FileInfo:
             ext = sub_exts.get(codec, "vtt")
             subtitles += (SubtitleStream(codec, ext, s.language),)
 
-        desc = cont.metadata.get("description", None)
         bitrate = 0 if cont.bit_rate is None else cont.bit_rate
         dur = 0 if cont.duration is None else cont.duration / bv.time_base
 
         cont.close()
 
-        return FileInfo(Path(path), bitrate, dur, desc, videos, audios, subtitles)
+        return FileInfo(Path(path), bitrate, dur, videos, audios, subtitles)
 
     def __repr__(self) -> str:
         return f"@{self.path.name}"

auto_editor/help.py

@@ -71,26 +71,15 @@ This option controls how timelines are exported.
 
 Export Methods:
  - default    ; Export as a regular media file
-
  - premiere   ; Export as an XML timeline file for Adobe Premiere Pro
-    - name string? : "Auto-Editor Media Group"
-
+    - name : "Auto-Editor Media Group"
  - resolve    ; Export as an XML timeline file for DaVinci Resolve
-    - name string? : "Auto-Editor Media Group"
-
+    - name : "Auto-Editor Media Group"
  - final-cut-pro  ; Export as an XML timeline file for Final Cut Pro
-    - name string? : "Auto-Editor Media Group"
-
- - shotcut    ; Export as an XML timeline file for Shotcut
-
- - json       ; Export as an auto-editor JSON timeline file
-    - api string? : "3"
-
- - timeline   ; Print the auto-editor timeline to stdout
-    - api string? : "3"
-
- - audio      ; Export as a WAV audio file
-
+    - name : "Auto-Editor Media Group"
+ - shotcut ; Export as an XML timeline file for Shotcut
+ - v3 ; Export as an auto-editor v3 timeline file
+ - v1 ; Export as an auto-editor v1 timeline file
  - clip-sequence  ; Export as multiple numbered media files
 
 """.strip(),

auto_editor/imports/fcp7.py

@@ -0,0 +1,277 @@
+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, Template, TlAudio, TlVideo, 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 i, clipitem in enumerate(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(
+                    TlVideo(start, dur, sources[file_id], offset, speed, stream=0)
+                )
+
+    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 i, clipitem in enumerate(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(
+                    TlAudio(
+                        start, dur, sources[file_id], offset, speed, volume=1, stream=0
+                    )
+                )
+
+    T = Template.init(sources[next(iter(sources))], sr, res=res)
+    return v3(tb, "#000", T, vobjs, aobjs, v1=None)