auto-editor 25.0.1__py3-none-any.whl → 25.2.0__py3-none-any.whl

auto_editor/__init__.py

@@ -1 +1 @@
-__version__ = "25.0.1"
+__version__ = "25.2.0"

auto_editor/__main__.py

@@ -259,6 +259,9 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         metavar="CMD",
         help="Add extra options for ffmpeg. Must be in quotes",
     )
+    parser.add_argument(
+        "--config", flag=True, help="When set, look for `config.pal` and run it"
+    )
     parser.add_argument(
         "--no-cache", flag=True, help="Don't look for or write a cache file"
     )

auto_editor/edit.py

@@ -15,6 +15,7 @@ from auto_editor.utils.bar import Bar
 from auto_editor.utils.chunks import Chunk, Chunks
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
 from auto_editor.utils.container import Container, container_constructor
+from auto_editor.utils.func import open_with_system_default
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import Args
 
@@ -45,8 +46,9 @@ def set_output(
 
     ext_map = {
         "premiere": ".xml",
-        "resolve": ".fcpxml",
+        "resolve-fcp7": ".xml",
         "final-cut-pro": ".fcpxml",
+        "resolve": ".fcpxml",
         "shotcut": ".mlt",
         "json": ".json",
         "audio": ".wav",
@@ -122,8 +124,9 @@ def parse_export(export: str, log: Log) -> dict[str, Any]:
     parsing: dict[str, pAttrs] = {
         "default": pAttrs("default"),
         "premiere": pAttrs("premiere", name_attr),
-        "resolve": pAttrs("resolve", name_attr),
+        "resolve-fcp7": pAttrs("resolve-fcp7", name_attr),
         "final-cut-pro": pAttrs("final-cut-pro", name_attr),
+        "resolve": pAttrs("resolve", name_attr),
         "shotcut": pAttrs("shotcut"),
         "json": pAttrs("json", pAttr("api", 3, is_int)),
         "timeline": pAttrs("json", pAttr("api", 3, is_int)),
@@ -176,10 +179,11 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
 
     del paths
 
-    output, export = set_output(args.output_file, args.export, src, log)
-    assert "export" in export
+    output, export_ops = set_output(args.output_file, args.export, src, log)
+    assert "export" in export_ops
+    export = export_ops["export"]
 
-    if export["export"] == "timeline":
+    if export == "timeline":
         log.quiet = True
 
     if not args.preview:
@@ -203,10 +207,10 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
     if tl is None:
         tl = make_timeline(sources, args, samplerate, bar, log)
 
-    if export["export"] == "timeline":
+    if export == "timeline":
         from auto_editor.formats.json import make_json_timeline
 
-        make_json_timeline(export["api"], 0, tl, log)
+        make_json_timeline(export_ops["api"], 0, tl, log)
         return
 
     if args.preview:
@@ -215,25 +219,27 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
         preview(tl, log)
         return
 
-    if export["export"] == "json":
+    if export == "json":
         from auto_editor.formats.json import make_json_timeline
 
-        make_json_timeline(export["api"], output, tl, log)
+        make_json_timeline(export_ops["api"], output, tl, log)
         return
 
-    if export["export"] == "premiere":
+    if export in ("premiere", "resolve-fcp7"):
         from auto_editor.formats.fcp7 import fcp7_write_xml
 
-        fcp7_write_xml(export["name"], output, tl, log)
+        is_resolve = export.startswith("resolve")
+        fcp7_write_xml(export_ops["name"], output, is_resolve, tl, log)
         return
 
-    if export["export"] in ("final-cut-pro", "resolve"):
+    if export in ("final-cut-pro", "resolve"):
         from auto_editor.formats.fcp11 import fcp11_write_xml
 
-        fcp11_write_xml(export["name"], ffmpeg, output, export["export"], tl, log)
+        is_resolve = export.startswith("resolve")
+        fcp11_write_xml(export_ops["name"], ffmpeg, output, is_resolve, tl, log)
         return
 
-    if export["export"] == "shotcut":
+    if export == "shotcut":
         from auto_editor.formats.shotcut import shotcut_write_mlt
 
         shotcut_write_mlt(output, tl)
@@ -297,7 +303,7 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
             log,
         )
 
-    if export["export"] == "clip-sequence":
+    if export == "clip-sequence":
         if tl.v1 is None:
             log.error("Timeline too complex to use clip-sequence export")
 
@@ -338,10 +344,8 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
 
     log.stop_timer()
 
-    if not args.no_open and export["export"] in ("default", "audio", "clip-sequence"):
+    if not args.no_open and export in ("default", "audio", "clip-sequence"):
         if args.player is None:
-            from auto_editor.utils.func import open_with_system_default
-
             open_with_system_default(output, log)
         else:
             import subprocess

auto_editor/formats/fcp11.py

@@ -54,7 +54,7 @@ def make_name(src: FileInfo, tb: Fraction) -> str:
 
 
 def fcp11_write_xml(
-    group_name: str, ffmpeg: FFmpeg, output: str, flavor: str, tl: v3, log: Log
+    group_name: str, ffmpeg: FFmpeg, output: str, resolve: bool, tl: v3, log: Log
 ) -> None:
     def fraction(val: int) -> str:
         if val == 0:
@@ -66,23 +66,22 @@ def fcp11_write_xml(
 
     proj_name = src.path.stem
     src_dur = int(src.duration * tl.tb)
-    tl_dur = src_dur if flavor == "resolve" else tl.out_len()
+    tl_dur = src_dur if resolve else tl.out_len()
 
     all_srcs: list[FileInfo] = [src]
     all_refs: list[str] = ["r2"]
-    if flavor == "resolve":
-        if len(src.audios) > 1:
-            fold = make_tracks_dir(src)
-
-            for i in range(1, len(src.audios)):
-                newtrack = fold / f"{i}.wav"
-                ffmpeg.run(
-                    ["-i", f"{src.path.resolve()}", "-map", f"0:a:{i}", f"{newtrack}"]
-                )
-                all_srcs.append(initFileInfo(f"{newtrack}", log))
-                all_refs.append(f"r{(i + 1) * 2}")
-
-    fcpxml = Element("fcpxml", version="1.10" if flavor == "resolve" else "1.11")
+    if resolve and len(src.audios) > 1:
+        fold = make_tracks_dir(src)
+
+        for i in range(1, len(src.audios)):
+            newtrack = fold / f"{i}.wav"
+            ffmpeg.run(
+                ["-i", f"{src.path.resolve()}", "-map", f"0:a:{i}", f"{newtrack}"]
+            )
+            all_srcs.append(initFileInfo(f"{newtrack}", log))
+            all_refs.append(f"r{(i + 1) * 2}")
+
+    fcpxml = Element("fcpxml", version="1.10" if resolve else "1.11")
     resources = SubElement(fcpxml, "resources")
 
     for i, one_src in enumerate(all_srcs):
@@ -134,7 +133,7 @@ def fcp11_write_xml(
     else:
         clips = []
 
-    def make_clip(ref: str, clip: TlVideo | TlAudio, speed_warn: bool) -> bool:
+    def make_clip(ref: str, clip: TlVideo | TlAudio) -> None:
         clip_properties = {
             "name": proj_name,
             "ref": ref,
@@ -148,7 +147,6 @@ def fcp11_write_xml(
             # See the "Time Maps" section.
             # https://developer.apple.com/documentation/professional_video_applications/fcpxml_reference/story_elements/timemap/
 
-            speed_warn = True
             timemap = SubElement(asset, "timeMap")
             SubElement(timemap, "timept", time="0s", value="0s", interp="smooth2")
             SubElement(
@@ -158,19 +156,11 @@ def fcp11_write_xml(
                 value=fraction(src_dur),
                 interp="smooth2",
             )
-        return speed_warn
 
-    warn = False
     for my_ref in all_refs:
         for clip in clips:
-            warn = make_clip(my_ref, clip, warn)
+            make_clip(my_ref, clip)
 
-    if flavor == "resolve" and warn:
-        log.warning(
-            "DaVinci Resolve may take a very long time when importing timelines with "
-            "speed effects. Consider switching to Premiere Pro, "
-            "Final Cut Pro, or ShotCut (free)"
-        )
     tree = ElementTree(fcpxml)
     indent(tree, space="\t", level=0)
     tree.write(output, xml_declaration=True, encoding="utf-8")

auto_editor/formats/fcp7.py

@@ -151,8 +151,10 @@ SUPPORTED_EFFECTS = ("timeremap",)
 
 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 tag requires: <effectid> <name> and one <parameter>")
+            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")
@@ -266,9 +268,10 @@ def fcp7_read_xml(path: str, log: Log) -> v3:
     if "video" in av:
         tracks = valid.parse(av["video"], vclip_schema)
 
-        width = tracks["format"]["samplecharacteristics"]["width"]
-        height = tracks["format"]["samplecharacteristics"]["height"]
-        res = width, height
+        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:
@@ -304,7 +307,8 @@ def fcp7_read_xml(path: str, log: Log) -> v3:
 
     if "audio" in av:
         tracks = valid.parse(av["audio"], aclip_schema)
-        sr = tracks["format"]["samplecharacteristics"]["samplerate"]
+        if "format" in tracks:
+            sr = tracks["format"]["samplecharacteristics"]["samplerate"]
 
         for t, track in enumerate(tracks["track"]):
             if len(track["clipitem"]) > 0:
@@ -344,6 +348,13 @@ def media_def(
     ET.SubElement(filedef, "name").text = src.path.stem
     ET.SubElement(filedef, "pathurl").text = url
 
+    timecode = ET.SubElement(filedef, "timecode")
+    ET.SubElement(timecode, "string").text = "00:00:00:00"
+    ET.SubElement(timecode, "displayformat").text = "NDF"
+    rate = ET.SubElement(timecode, "rate")
+    ET.SubElement(rate, "timebase").text = f"{tb}"
+    ET.SubElement(rate, "ntsc").text = ntsc
+
     rate = ET.SubElement(filedef, "rate")
     ET.SubElement(rate, "timebase").text = f"{tb}"
     ET.SubElement(rate, "ntsc").text = ntsc
@@ -372,87 +383,53 @@ def media_def(
         ET.SubElement(audiodef, "channelcount").text = f"{aud.channels}"
 
 
-def fcp7_write_xml(name: str, output: str, tl: v3, log: Log) -> None:
-    width, height = tl.res
-    timebase, ntsc = set_tb_ntsc(tl.tb)
-
-    src_to_url: dict[FileInfo, str] = {}
-    src_to_id: dict[FileInfo, str] = {}
-
-    file_defs: set[str] = set()  # Contains urls
-
-    for src in set(tl.sources):
-        the_id = f"file-{len(src_to_id)+1}"
-        src_to_url[src] = f"{src.path.resolve()}"
-        src_to_id[src] = the_id
-
-    xmeml = ET.Element("xmeml", version="5")
-    sequence = ET.SubElement(xmeml, "sequence", explodedTracks="true")
-    ET.SubElement(sequence, "name").text = name
-    ET.SubElement(sequence, "duration").text = f"{int(tl.out_len())}"
-    rate = ET.SubElement(sequence, "rate")
-    ET.SubElement(rate, "timebase").text = f"{timebase}"
-    ET.SubElement(rate, "ntsc").text = ntsc
-    media = ET.SubElement(sequence, "media")
-    video = ET.SubElement(media, "video")
-    vformat = ET.SubElement(video, "format")
-    vschar = ET.SubElement(vformat, "samplecharacteristics")
-
-    ET.SubElement(vschar, "width").text = f"{width}"
-    ET.SubElement(vschar, "height").text = f"{height}"
-    ET.SubElement(vschar, "pixelaspectratio").text = "square"
-
-    rate = ET.SubElement(vschar, "rate")
-    ET.SubElement(rate, "timebase").text = f"{timebase}"
-    ET.SubElement(rate, "ntsc").text = ntsc
-
-    if len(tl.v) > 0 and len(tl.v[0]) > 0:
-        track = ET.SubElement(video, "track")
+def resolve_write_audio(audio: Element, make_filedef, tl: v3) -> None:
+    for t, aclips in enumerate(tl.a):
+        track = ET.SubElement(audio, "track")
+        for j, aclip in enumerate(aclips):
+            src = aclip.src
 
-        for j, clip in enumerate(tl.v[0]):
-            assert isinstance(clip, TlVideo)
+            _start = f"{aclip.start}"
+            _end = f"{aclip.start + aclip.dur}"
+            _in = f"{aclip.offset}"
+            _out = f"{aclip.offset + aclip.dur}"
 
-            _start = f"{clip.start}"
-            _end = f"{clip.start + clip.dur}"
-            _in = f"{clip.offset}"
-            _out = f"{clip.offset + clip.dur}"
+            if not src.videos:
+                clip_item_num = j + 1
+            else:
+                clip_item_num = len(aclips) + 1 + j
 
-            clipitem = ET.SubElement(track, "clipitem", id=f"clipitem-{j+1}")
+            clipitem = ET.SubElement(track, "clipitem", id=f"clipitem-{clip_item_num}")
             ET.SubElement(clipitem, "name").text = src.path.stem
-            ET.SubElement(clipitem, "enabled").text = "TRUE"
             ET.SubElement(clipitem, "start").text = _start
             ET.SubElement(clipitem, "end").text = _end
+            ET.SubElement(clipitem, "enabled").text = "TRUE"
             ET.SubElement(clipitem, "in").text = _in
             ET.SubElement(clipitem, "out").text = _out
 
-            _id = src_to_id[clip.src]
-            filedef = ET.SubElement(clipitem, "file", id=_id)
+            make_filedef(clipitem, aclip.src)
 
-            pathurl = src_to_url[clip.src]
-            if pathurl not in file_defs:
-                media_def(filedef, pathurl, clip.src, tl, timebase, ntsc)
-                file_defs.add(pathurl)
-
-            ET.SubElement(clipitem, "compositemode").text = "normal"
-            if clip.speed != 1:
-                clipitem.append(speedup(clip.speed * 100))
+            sourcetrack = ET.SubElement(clipitem, "sourcetrack")
+            ET.SubElement(sourcetrack, "mediatype").text = "audio"
+            ET.SubElement(sourcetrack, "trackindex").text = f"{t + 1}"
 
-            for i in range(len(src.audios) * 2 + 1):  # `2` because stereo.
+            if src.videos:
                 link = ET.SubElement(clipitem, "link")
-                ET.SubElement(
-                    link, "linkclipref"
-                ).text = f"clipitem-{(i*(len(tl.v[0])))+j+1}"
-                ET.SubElement(link, "mediatype").text = "video" if i == 0 else "audio"
-                ET.SubElement(link, "trackindex").text = str(max(i, 1))
-                ET.SubElement(link, "clipindex").text = str(j + 1)
+                ET.SubElement(link, "linkclipref").text = f"clipitem-{j + 1}"
+                ET.SubElement(link, "mediatype").text = "video"
+                link = ET.SubElement(clipitem, "link")
+                ET.SubElement(link, "linkclipref").text = f"clipitem-{clip_item_num}"
 
-    # Audio definitions and clips
-    audio = ET.SubElement(media, "audio")
+            if aclip.speed != 1:
+                clipitem.append(speedup(aclip.speed * 100))
+
+
+def premiere_write_audio(audio: Element, make_filedef, src: FileInfo, tl: v3) -> None:
     ET.SubElement(audio, "numOutputChannels").text = "2"
     aformat = ET.SubElement(audio, "format")
     aschar = ET.SubElement(aformat, "samplecharacteristics")
     ET.SubElement(aschar, "depth").text = DEPTH
-    ET.SubElement(aschar, "samplerate").text = str(tl.sr)
+    ET.SubElement(aschar, "samplerate").text = f"{tl.sr}"
 
     t = 0
     for aclips in tl.a:
@@ -494,11 +471,7 @@ def fcp7_write_xml(name: str, output: str, tl: v3, log: Log) -> None:
                 ET.SubElement(clipitem, "in").text = _in
                 ET.SubElement(clipitem, "out").text = _out
 
-                pathurl = src_to_url[aclip.src]
-                filedef = ET.SubElement(clipitem, "file", id=src_to_id[aclip.src])
-                if pathurl not in file_defs:
-                    media_def(filedef, pathurl, aclip.src, tl, timebase, ntsc)
-                    file_defs.add(pathurl)
+                make_filedef(clipitem, aclip.src)
 
                 sourcetrack = ET.SubElement(clipitem, "sourcetrack")
                 ET.SubElement(sourcetrack, "mediatype").text = "audio"
@@ -511,6 +484,103 @@ def fcp7_write_xml(name: str, output: str, tl: v3, log: Log) -> None:
 
             audio.append(track)
 
+
+def fcp7_write_xml(name: str, output: str, resolve: bool, tl: v3, log: Log) -> None:
+    width, height = tl.res
+    timebase, ntsc = set_tb_ntsc(tl.tb)
+
+    src_to_url: dict[FileInfo, str] = {}
+    src_to_id: dict[FileInfo, str] = {}
+
+    file_defs: set[str] = set()  # Contains urls
+
+    for src in set(tl.sources):
+        the_id = f"file-{len(src_to_id)+1}"
+        src_to_url[src] = f"{src.path.resolve()}"
+        src_to_id[src] = the_id
+
+    def make_filedef(clipitem: Element, src: FileInfo) -> None:
+        pathurl = src_to_url[src]
+        filedef = ET.SubElement(clipitem, "file", id=src_to_id[src])
+        if pathurl not in file_defs:
+            media_def(filedef, pathurl, src, tl, timebase, ntsc)
+            file_defs.add(pathurl)
+
+    xmeml = ET.Element("xmeml", version="5")
+    if resolve:
+        sequence = ET.SubElement(xmeml, "sequence")
+    else:
+        sequence = ET.SubElement(xmeml, "sequence", explodedTracks="true")
+
+    ET.SubElement(sequence, "name").text = name
+    ET.SubElement(sequence, "duration").text = f"{int(tl.out_len())}"
+    rate = ET.SubElement(sequence, "rate")
+    ET.SubElement(rate, "timebase").text = f"{timebase}"
+    ET.SubElement(rate, "ntsc").text = ntsc
+    media = ET.SubElement(sequence, "media")
+    video = ET.SubElement(media, "video")
+    vformat = ET.SubElement(video, "format")
+    vschar = ET.SubElement(vformat, "samplecharacteristics")
+
+    ET.SubElement(vschar, "width").text = f"{width}"
+    ET.SubElement(vschar, "height").text = f"{height}"
+    ET.SubElement(vschar, "pixelaspectratio").text = "square"
+
+    rate = ET.SubElement(vschar, "rate")
+    ET.SubElement(rate, "timebase").text = f"{timebase}"
+    ET.SubElement(rate, "ntsc").text = ntsc
+
+    if len(tl.v) > 0 and len(tl.v[0]) > 0:
+        track = ET.SubElement(video, "track")
+
+        for j, clip in enumerate(tl.v[0]):
+            assert isinstance(clip, TlVideo)
+
+            _start = f"{clip.start}"
+            _end = f"{clip.start + clip.dur}"
+            _in = f"{clip.offset}"
+            _out = f"{clip.offset + clip.dur}"
+
+            this_clipid = f"clipitem-{j+1}"
+            clipitem = ET.SubElement(track, "clipitem", id=this_clipid)
+            ET.SubElement(clipitem, "name").text = src.path.stem
+            ET.SubElement(clipitem, "enabled").text = "TRUE"
+            ET.SubElement(clipitem, "start").text = _start
+            ET.SubElement(clipitem, "end").text = _end
+            ET.SubElement(clipitem, "in").text = _in
+            ET.SubElement(clipitem, "out").text = _out
+
+            make_filedef(clipitem, clip.src)
+
+            ET.SubElement(clipitem, "compositemode").text = "normal"
+            if clip.speed != 1:
+                clipitem.append(speedup(clip.speed * 100))
+
+            if resolve:
+                link = ET.SubElement(clipitem, "link")
+                ET.SubElement(link, "linkclipref").text = this_clipid
+                link = ET.SubElement(clipitem, "link")
+                ET.SubElement(
+                    link, "linkclipref"
+                ).text = f"clipitem-{(len(tl.v[0]))+j+1}"
+                continue
+
+            for i in range(1 + len(src.audios) * 2):  # `2` because stereo.
+                link = ET.SubElement(clipitem, "link")
+                ET.SubElement(
+                    link, "linkclipref"
+                ).text = f"clipitem-{(i*(len(tl.v[0])))+j+1}"
+                ET.SubElement(link, "mediatype").text = "video" if i == 0 else "audio"
+                ET.SubElement(link, "trackindex").text = f"{max(i, 1)}"
+                ET.SubElement(link, "clipindex").text = f"{j + 1}"
+
+    # Audio definitions and clips
+    audio = ET.SubElement(media, "audio")
+    if resolve:
+        resolve_write_audio(audio, make_filedef, tl)
+    else:
+        premiere_write_audio(audio, make_filedef, src, tl)
+
     tree = ET.ElementTree(xmeml)
     ET.indent(tree, space="  ", level=0)
     tree.write(output, xml_declaration=True, encoding="utf-8")

auto_editor/lang/libintrospection.py

@@ -0,0 +1,10 @@
+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]
+        ),
+    }