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

auto_editor/__init__.py

@@ -1 +1 @@
-__version__ = "27.1.0"
+__version__ = "28.0.0"

auto_editor/__main__.py

@@ -78,7 +78,6 @@ class Args:
     audio_layout: str | None = None
     audio_bitrate: str = "auto"
     mix_audio_streams: bool = False
-    keep_tracks_separate: bool = False
     audio_normalize: str = "#f"
 
     # Misc.
@@ -353,11 +352,6 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
     parser.add_argument(
         "--mix-audio-streams", flag=True, help="Mix all audio streams together into one"
     )
-    parser.add_argument(
-        "--keep-tracks-separate",
-        flag=True,
-        help="Don't mix all audio streams into one when exporting (default)",
-    )
     parser.add_argument(
         "--audio-normalize",
         metavar="NORM-TYPE",
@@ -447,9 +441,7 @@ def main() -> None:
             ({"--export-to-resolve", "-exr"}, ["--export", "resolve"]),
             ({"--export-to-final-cut-pro", "-exf"}, ["--export", "final-cut-pro"]),
             ({"--export-to-shotcut", "-exs"}, ["--export", "shotcut"]),
-            ({"--export-as-json"}, ["--export", "json"]),
             ({"--export-as-clip-sequence", "-excs"}, ["--export", "clip-sequence"]),
-            ({"--keep-tracks-seperate"}, ["--keep-tracks-separate"]),
             ({"--edit-based-on"}, ["--edit"]),
         ],
     )

auto_editor/cmds/desc.py

@@ -1,10 +1,8 @@
-from __future__ import annotations
-
 import sys
 from dataclasses import dataclass, field
 
-from auto_editor.ffwrapper import FileInfo
-from auto_editor.utils.log import Log
+import bv
+
 from auto_editor.vanparse import ArgumentParser
 
 
@@ -22,11 +20,12 @@ def desc_options(parser: ArgumentParser) -> ArgumentParser:
 def main(sys_args: list[str] = sys.argv[1:]) -> None:
     args = desc_options(ArgumentParser("desc")).parse_args(DescArgs, sys_args)
     for path in args.input:
-        src = FileInfo.init(path, Log())
-        if src.description is not None:
-            sys.stdout.write(f"\n{src.description}\n\n")
-        else:
-            sys.stdout.write("\nNo description.\n\n")
+        try:
+            container = bv.open(path)
+            desc = container.metadata.get("description", None)
+        except Exception:
+            desc = None
+        sys.stdout.write("\nNo description.\n\n" if desc is None else f"\n{desc}\n\n")
 
 
 if __name__ == "__main__":

auto_editor/cmds/info.py

@@ -8,7 +8,6 @@ from typing import Any, Literal, TypedDict
 from auto_editor.ffwrapper import FileInfo
 from auto_editor.json import dump
 from auto_editor.make_layers import make_sane_timebase
-from auto_editor.timeline import v3
 from auto_editor.utils.func import aspect_ratio
 from auto_editor.utils.log import Log
 from auto_editor.vanparse import ArgumentParser
@@ -86,19 +85,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
             log.error(f"Could not find '{file}'")
 
         ext = os.path.splitext(file)[1]
-        if ext == ".json":
-            from auto_editor.formats.json import read_json
-
-            tl = read_json(file, log)
-            file_info[file] = {"type": "timeline"}
-            file_info[file]["version"] = "v3" if isinstance(tl, v3) else "v1"
-
-            clip_lens = [clip.dur / clip.speed for clip in tl.a[0]]
-            file_info[file]["clips"] = len(clip_lens)
-
-            continue
-
-        if ext in {".xml", ".fcpxml", ".mlt"}:
+        if ext in {".v1", ".v3", ".json", ".xml", ".fcpxml", ".mlt"}:
             file_info[file] = {"type": "timeline"}
             continue
 

auto_editor/cmds/test.py

@@ -290,6 +290,7 @@ class Runner:
 
     def test_silent_threshold(self):
         with bv.open("resources/new-commentary.mp3") as container:
+            assert container.duration is not None
             assert container.duration / bv.time_base == 6.732
 
         out = self.main(
@@ -298,6 +299,7 @@ class Runner:
         out += ".mp3"
 
         with bv.open(out) as container:
+            assert container.duration is not None
             assert container.duration / bv.time_base == 6.552
 
     def test_track(self):
@@ -305,7 +307,9 @@ class Runner:
         assert len(fileinfo(out).audios) == 2
 
     def test_export_json(self):
-        out = self.main(["example.mp4"], ["--export_as_json"], "c77130d763d40e8.json")
+        out = self.main(["example.mp4"], ["--export", "v1"], "c77130d763d40e8.json")
+        self.main([out], [])
+        out = self.main(["example.mp4"], ["--export", "v1"], "c77130d763d40e8.v1")
         self.main([out], [])
 
     def test_import_v1(self):
@@ -317,10 +321,19 @@ class Runner:
 
         self.main([path], [])
 
-    def test_premiere_named_export(self):
+    def test_res_with_v1(self):
+        v1 = self.main(["example.mp4"], ["--export", "v1"], "input.v1")
+        out = self.main([v1], ["-res", "720,720"], "output.mp4")
+
+        output = fileinfo(out)
+        assert output.videos[0].width == 720
+        assert output.videos[0].height == 720
+        assert len(output.audios) == 1
+
+    def test_premiere_named_export(self) -> None:
         self.main(["example.mp4"], ["--export", 'premiere:name="Foo Bar"'])
 
-    def test_export_subtitles(self):
+    def test_export_subtitles(self) -> None:
         # cn = fileinfo(self.main(["resources/mov_text.mp4"], [], "movtext_out.mp4"))
 
         # assert len(cn.videos) == 1
@@ -332,7 +345,7 @@ class Runner:
         assert len(cn.audios) == 1
         assert len(cn.subtitles) == 1
 
-    def test_scale(self):
+    def test_scale(self) -> None:
         cn = fileinfo(self.main(["example.mp4"], ["--scale", "1.5"], "scale.mp4"))
         assert cn.videos[0].fps == 30
         assert cn.videos[0].width == 1920
@@ -363,7 +376,7 @@ class Runner:
     #     assert len(cn.videos) == 1
     #     assert len(cn.audios) == 2
 
-    def test_premiere(self):
+    def test_premiere(self) -> None:
         for test_name in all_files:
             if test_name == "multi-track.mov":
                 continue
@@ -379,14 +392,14 @@ class Runner:
             self.main([test_file], ["-exs"])
             self.main([test_file], ["--stats"])
 
-    def test_clip_sequence(self):
+    def test_clip_sequence(self) -> None:
         for test_name in all_files:
             test_file = f"resources/{test_name}"
-            self.main([test_file], ["--export_as_clip_sequence"])
+            self.main([test_file], ["--export", "clip-sequence"])
 
-    def test_codecs(self):
-        self.main(["example.mp4"], ["--video_codec", "h264"])
-        self.main(["example.mp4"], ["--audio_codec", "ac3"])
+    def test_codecs(self) -> None:
+        self.main(["example.mp4"], ["--video-codec", "h264"])
+        self.main(["example.mp4"], ["--audio-codec", "ac3"])
 
     # Issue #241
     def test_multi_track_edit(self):
@@ -512,15 +525,15 @@ class Runner:
         assert output.videos[0].pix_fmt == "yuv420p"
 
     #  Issue 280
-    def test_SAR(self):
+    def test_SAR(self) -> None:
         out = self.main(["resources/SAR-2by3.mp4"], [], "2by3_out.mp4")
         assert fileinfo(out).videos[0].sar == Fraction(2, 3)
 
-    def test_audio_norm_f(self):
-        return self.main(["example.mp4"], ["--audio-normalize", "#f"])
+    def test_audio_norm_f(self) -> None:
+        self.main(["example.mp4"], ["--audio-normalize", "#f"])
 
-    def test_audio_norm_ebu(self):
-        return self.main(
+    def test_audio_norm_ebu(self) -> None:
+        self.main(
             ["example.mp4"], ["--audio-normalize", "ebu:i=-5,lra=20,gain=5,tp=-1"]
         )
 
@@ -536,11 +549,14 @@ class Runner:
                 except MyError as e:
                     raise ValueError(f"{text}\nMyError: {e}")
 
+                result_val = results[-1]
                 if isinstance(expected, np.ndarray):
-                    if not np.array_equal(expected, results[-1]):
+                    if not isinstance(result_val, np.ndarray):
+                        raise ValueError(f"{text}: Result is not an ndarray")
+                    if not np.array_equal(expected, result_val):
                         raise ValueError(f"{text}: Numpy arrays don't match")
-                elif expected != results[-1]:
-                    raise ValueError(f"{text}: Expected: {expected}, got {results[-1]}")
+                elif expected != result_val:
+                    raise ValueError(f"{text}: Expected: {expected}, got {result_val}")
 
         cases(
             ("345", 345),
@@ -675,7 +691,7 @@ class Runner:
             ('#(#("sym" "symbol?") "bool?")', [["sym", "symbol?"], "bool?"]),
         )
 
-    def palet_scripts(self):
+    def palet_scripts(self) -> None:
         self.raw(["palet", "resources/scripts/scope.pal"])
         self.raw(["palet", "resources/scripts/maxcut.pal"])
         self.raw(["palet", "resources/scripts/case.pal"])

auto_editor/edit.py

@@ -5,6 +5,7 @@ import sys
 from fractions import Fraction
 from heapq import heappop, heappush
 from os.path import splitext
+from pathlib import Path
 from subprocess import run
 from typing import TYPE_CHECKING, Any
 
@@ -16,7 +17,7 @@ from auto_editor.make_layers import clipify, make_av, make_timeline
 from auto_editor.render.audio import make_new_audio
 from auto_editor.render.subtitle import make_new_subtitles
 from auto_editor.render.video import render_av
-from auto_editor.timeline import v1, v3
+from auto_editor.timeline import set_stream_to_0, v1, v3
 from auto_editor.utils.bar import initBar
 from auto_editor.utils.chunks import Chunk, Chunks
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
@@ -28,26 +29,33 @@ if TYPE_CHECKING:
 
 
 def set_output(
-    out: str | None, _export: str | None, src: FileInfo | None, log: Log
+    out: str | None, _export: str | None, path: Path | None, log: Log
 ) -> tuple[str, dict[str, Any]]:
-    if src is None:
-        root, ext = "out", ".mp4"
+    if out is None or out == "-":
+        if path is None:
+            log.error("`--output` must be set.")  # When a timeline file is the input.
+        root, ext = splitext(path)
     else:
-        root, ext = splitext(src.path if out is None else out)
-        if ext == "":
-            ext = src.path.suffix
+        root, ext = splitext(out)
+
+    if ext == "":
+        # Use `mp4` as the default, because it is most compatible.
+        ext = ".mp4" if path is None else path.suffix
 
     if _export is None:
-        if ext == ".xml":
-            export = {"export": "premiere"}
-        elif ext == ".fcpxml":
-            export = {"export": "final-cut-pro"}
-        elif ext == ".mlt":
-            export = {"export": "shotcut"}
-        elif ext == ".json":
-            export = {"export": "json"}
-        else:
-            export = {"export": "default"}
+        match ext:
+            case ".xml":
+                export: dict[str, Any] = {"export": "premiere"}
+            case ".fcpxml":
+                export = {"export": "final-cut-pro"}
+            case ".mlt":
+                export = {"export": "shotcut"}
+            case ".json" | ".v1":
+                export = {"export": "v1"}
+            case ".v3":
+                export = {"export": "v3"}
+            case _:
+                export = {"export": "default"}
     else:
         export = parse_export(_export, log)
 
@@ -58,11 +66,13 @@ def set_output(
         "resolve": ".fcpxml",
         "shotcut": ".mlt",
         "json": ".json",
-        "audio": ".wav",
     }
     if export["export"] in ext_map:
         ext = ext_map[export["export"]]
 
+    if out == "-":
+        return "-", export
+
     if out is None:
         return f"{root}_ALTERED{ext}", export
 
@@ -129,65 +139,57 @@ def parse_export(export: str, log: Log) -> dict[str, Any]:
         name, text = exploded
 
     name_attr = pAttr("name", "Auto-Editor Media Group", is_str)
-
-    parsing: dict[str, pAttrs] = {
+    parsing = {
         "default": pAttrs("default"),
         "premiere": pAttrs("premiere", name_attr),
-        "resolve-fcp7": pAttrs("resolve-fcp7", name_attr),
         "final-cut-pro": pAttrs(
             "final-cut-pro", name_attr, pAttr("version", 11, is_int)
         ),
         "resolve": pAttrs("resolve", name_attr),
+        "resolve-fcp7": pAttrs("resolve-fcp7", name_attr),
         "shotcut": pAttrs("shotcut"),
-        "json": pAttrs("json", pAttr("api", 3, is_int)),
-        "timeline": pAttrs("json", pAttr("api", 3, is_int)),
-        "audio": pAttrs("audio"),
+        "v1": pAttrs("v1"),
+        "v3": pAttrs("v3"),
         "clip-sequence": pAttrs("clip-sequence"),
     }
 
     if name in parsing:
         try:
-            _tmp = parse_with_palet(text, parsing[name], {})
-            _tmp["export"] = name
-            return _tmp
+            return {"export": name} | parse_with_palet(text, parsing[name], {})
         except ParserError as e:
             log.error(e)
 
-    log.error(f"'{name}': Export must be [{', '.join([s for s in parsing.keys()])}]")
+    valid_choices = " ".join(f'"{s}"' for s in parsing.keys())
+    log.error(f'Invalid export format: "{name}"\nValid choices: {valid_choices}')
 
 
 def edit_media(paths: list[str], args: Args, log: Log) -> None:
     bar = initBar(args.progress)
-    tl = None
-    src = None
-
-    if args.keep_tracks_separate:
-        log.deprecated("--keep-tracks-separate is deprecated.")
-        args.keep_tracks_separate = False
+    tl = src = use_path = None
 
     if paths:
         path_ext = splitext(paths[0])[1].lower()
         if path_ext == ".xml":
-            from auto_editor.formats.fcp7 import fcp7_read_xml
+            from auto_editor.imports.fcp7 import fcp7_read_xml
 
             tl = fcp7_read_xml(paths[0], log)
         elif path_ext == ".mlt":
-            from auto_editor.formats.shotcut import shotcut_read_mlt
-
-            tl = shotcut_read_mlt(paths[0], log)
-        elif path_ext == ".json":
-            from auto_editor.formats.json import read_json
+            log.error("Reading mlt files not implemented")
+        elif path_ext in {".v1", ".v3", ".json"}:
+            from auto_editor.imports.json import read_json
 
             tl = read_json(paths[0], log)
         else:
             sources = [FileInfo.init(path, log) for path in paths]
-            src = None if not sources else sources[0]
+            src = sources[0]
+            use_path = src.path
 
-    output, export_ops = set_output(args.output, args.export, src, log)
+    output, export_ops = set_output(args.output, args.export, use_path, log)
     assert "export" in export_ops
     export = export_ops["export"]
 
-    if export == "timeline":
+    if output == "-":
+        # When printing to stdout, silence all logs.
         log.quiet = True
 
     if not args.preview:
@@ -206,12 +208,15 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
 
     if tl is None:
         tl = make_timeline(sources, args, samplerate, bar, log)
-
-    if export == "timeline":
-        from auto_editor.formats.json import make_json_timeline
-
-        make_json_timeline(export_ops["api"], 0, tl, log)
-        return
+    else:
+        if args.resolution is not None:
+            tl.T.res = args.resolution
+        if args.background is not None:
+            tl.background = args.background
+        if args.frame_rate is not None:
+            log.warning(
+                "Setting timebase/framerate is not supported when importing timelines"
+            )
 
     if args.preview:
         from auto_editor.preview import preview
@@ -219,29 +224,28 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
         preview(tl, log)
         return
 
-    if export == "json":
-        from auto_editor.formats.json import make_json_timeline
+    if export in {"v1", "v3"}:
+        from auto_editor.exports.json import make_json_timeline
 
-        make_json_timeline(export_ops["api"], output, tl, log)
+        make_json_timeline(export, output, tl, log)
         return
 
     if export in {"premiere", "resolve-fcp7"}:
-        from auto_editor.formats.fcp7 import fcp7_write_xml
+        from auto_editor.exports.fcp7 import fcp7_write_xml
 
         is_resolve = export.startswith("resolve")
         fcp7_write_xml(export_ops["name"], output, is_resolve, tl)
         return
 
     if export == "final-cut-pro":
-        from auto_editor.formats.fcp11 import fcp11_write_xml
+        from auto_editor.exports.fcp11 import fcp11_write_xml
 
         ver = export_ops["version"]
         fcp11_write_xml(export_ops["name"], ver, output, False, tl, log)
         return
 
     if export == "resolve":
-        from auto_editor.formats.fcp11 import fcp11_write_xml
-        from auto_editor.timeline import set_stream_to_0
+        from auto_editor.exports.fcp11 import fcp11_write_xml
 
         assert src is not None
         set_stream_to_0(src, tl, log)
@@ -249,11 +253,13 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
         return
 
     if export == "shotcut":
-        from auto_editor.formats.shotcut import shotcut_write_mlt
+        from auto_editor.exports.shotcut import shotcut_write_mlt
 
         shotcut_write_mlt(output, tl)
         return
 
+    if output == "-":
+        log.error("Exporting media files to stdout is not supported.")
     out_ext = splitext(output)[1].replace(".", "")
 
     # Check if export options make sense.
@@ -517,7 +523,7 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
 
     log.stop_timer()
 
-    if not args.no_open and export in {"default", "audio"}:
+    if not args.no_open and export == "default":
         if args.player is None:
             if sys.platform == "win32":
                 try:

auto_editor/{formats → exports}/fcp11.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import xml.etree.ElementTree as ET
 from typing import TYPE_CHECKING, Any, cast
 from xml.etree.ElementTree import Element, ElementTree, SubElement, indent
 
@@ -70,7 +71,7 @@ def fcp11_write_xml(
     resources = SubElement(fcpxml, "resources")
 
     src_dur = 0
-    tl_dur = 0 if resolve else tl.out_len()
+    tl_dur = 0 if resolve else len(tl)
 
     for i, one_src in enumerate(tl.unique_sources()):
         if i == 0:
@@ -162,4 +163,7 @@ def fcp11_write_xml(
 
     tree = ElementTree(fcpxml)
     indent(tree, space="\t", level=0)
-    tree.write(output, xml_declaration=True, encoding="utf-8")
+    if output == "-":
+        print(ET.tostring(fcpxml, encoding="unicode"))
+    else:
+        tree.write(output, xml_declaration=True, encoding="utf-8")