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

auto_editor/__init__.py

@@ -1 +1 @@
-__version__ = "27.1.1"
+__version__ = "28.0.1"

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/cache.py

@@ -26,7 +26,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
         return
 
     def format_bytes(size: float) -> str:
-        for unit in {"B", "KiB", "MiB", "GiB", "TiB"}:
+        for unit in ("B", "KiB", "MiB", "GiB", "TiB"):
             if size < 1024:
                 return f"{size:.2f} {unit}"
             size /= 1024

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
 
@@ -126,7 +113,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
                 f"{recTb.numerator}/{recTb.denominator}"
             )
 
-        for track, v in enumerate(src.videos):
+        for v in src.videos:
             w, h = v.width, v.height
 
             vid: VideoJson = {
@@ -147,7 +134,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
             }
             file_info[file]["video"].append(vid)
 
-        for track, a in enumerate(src.audios):
+        for a in src.audios:
             aud: AudioJson = {
                 "codec": a.codec,
                 "layout": a.layout,
@@ -158,7 +145,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
             }
             file_info[file]["audio"].append(aud)
 
-        for track, s_stream in enumerate(src.subtitles):
+        for s_stream in src.subtitles:
             sub: SubtitleJson = {"codec": s_stream.codec, "lang": s_stream.lang}
             file_info[file]["subtitle"].append(sub)
 

auto_editor/cmds/palet.py

@@ -14,7 +14,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
 
         env.update(make_standard_env())
         try:
-            interpret(env, Parser(Lexer(sys_args[0], program_text, True)))
+            interpret(env, Parser(Lexer(sys_args[0], program_text)))
         except (MyError, ZeroDivisionError) as e:
             sys.stderr.write(f"error: {e}\n")
             sys.exit(1)

auto_editor/cmds/subdump.py

@@ -21,8 +21,6 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
     parser.add_argument("--json", flag=True)
     args = parser.parse_args(SubdumpArgs, sys_args)
 
-    do_filter = True
-
     if args.json:
         data = {}
         for input_file in args.input:
@@ -46,7 +44,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
                     startf = round(float(start), 3)
                     endf = round(float(end), 3)
 
-                    if do_filter and endf - startf <= 0.02:
+                    if endf - startf <= 0.02:
                         continue
 
                     for sub in packet.decode():
@@ -60,7 +58,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
         dump(data, sys.stdout, indent=4)
         return
 
-    for i, input_file in enumerate(args.input):
+    for input_file in args.input:
         with bv.open(input_file) as container:
             for s in range(len(container.streams.subtitles)):
                 print(f"file: {input_file} ({s}:{container.streams.subtitles[s].name})")

auto_editor/cmds/test.py

@@ -202,6 +202,19 @@ class Runner:
             assert audio.language == "eng"
             assert audio.layout.name == "stereo"
 
+    def test_video_to_mp3(self) -> None:
+        out = self.main(["example.mp4"], [], output="example_ALTERED.mp3")
+        with bv.open(out) as container:
+            assert container.duration is not None
+            assert container.duration > 17300000 and container.duration < 2 << 24
+
+            assert len(container.streams) == 1
+            audio = container.streams[0]
+            assert isinstance(audio, bv.AudioStream)
+            assert audio.codec.name in ("mp3", "mp3float")
+            assert audio.sample_rate == 48000
+            assert audio.layout.name == "stereo"
+
     def test_to_mono(self) -> None:
         out = self.main(["example.mp4"], ["-layout", "mono"], output="example_mono.mp4")
         with bv.open(out) as container:
@@ -290,6 +303,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 +312,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 +320,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 +334,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 +358,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 +389,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 +405,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):
@@ -503,24 +529,21 @@ class Runner:
         assert output.videos[0].pix_fmt == "yuv420p"
 
     def test_encode_hevc(self):
-        if os.environ.get("GITHUB_ACTIONS") == "true":
-            raise SkipTest()
-
         out = self.main(["resources/testsrc.mp4"], ["-c:v", "hevc"], "out.mkv")
         output = fileinfo(out)
         assert output.videos[0].codec == "hevc"
         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,26 +559,26 @@ 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),
             ("238.5", 238.5),
             ("-34", -34),
             ("-98.3", -98.3),
-            ("+3i", 3j),
             ("3sec", 90),
             ("-3sec", -90),
             ("0.2sec", 6),
             ("(+ 4 3)", 7),
             ("(+ 4 3 2)", 9),
             ("(+ 10.5 3)", 13.5),
-            ("(+ 3+4i -2-2i)", 1 + 2j),
-            ("(+ 3+4i -2-2i 5)", 6 + 2j),
             ("(- 4 3)", 1),
             ("(- 3)", -3),
             ("(- 10.5 3)", 7.5),
@@ -564,7 +587,6 @@ class Runner:
             ("(/ 5)", 0.2),
             ("(/ 6 1)", 6.0),
             ("30/1", Fraction(30)),
-            ("(sqrt -4)", 2j),
             ("(pow 2 3)", 8),
             ("(pow 4 0.5)", 2.0),
             ("(abs 1.0)", 1.0),
@@ -579,7 +601,6 @@ class Runner:
             ("(int? #t)", False),
             ("(int? #f)", False),
             ("(int? 4/5)", False),
-            ("(int? 0+2i)", False),
             ('(int? "hello")', False),
             ('(int? "3")', False),
             ("(float? -23.4)", True),
@@ -593,7 +614,6 @@ class Runner:
             ('(define apple "Red Wood") apple', "Red Wood"),
             ("(= 1 1.0)", True),
             ("(= 1 2)", False),
-            ("(= 2+3i 2+3i 2+3i)", True),
             ("(= 1)", True),
             ("(+)", 0),
             ("(*)", 1),
@@ -602,7 +622,6 @@ class Runner:
             ('(if #f mango "Hi")', "Hi"),
             ('{if (= [+ 3 4] 7) "yes" "no"}', "yes"),
             ("((if #t + -) 3 4)", 7),
-            ("((if #t + oops) 3+3i 4-2i)", 7 + 1j),
             ("((if #f + -) 3 4)", -1),
             ("(when (positive? 3) 17)", 17),
             ("(string)", ""),
@@ -675,14 +694,14 @@ 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"])
         self.raw(["palet", "resources/scripts/testmath.pal"])
 
 
-def run_tests(runner: Runner, tests: list[Callable], args: TestArgs) -> None:
+def run_tests(tests: list[Callable], args: TestArgs) -> None:
     if args.only != []:
         tests = list(filter(lambda t: t.__name__ in args.only, tests))
 
@@ -781,7 +800,7 @@ def main(sys_args: list[str] | None = None) -> None:
             ]
         )
     try:
-        run_tests(run, tests, args)
+        run_tests(tests, args)
     except KeyboardInterrupt:
         print("Testing Interrupted by User.")
         shutil.rmtree(run.temp_dir)

auto_editor/edit.py

@@ -17,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
@@ -31,7 +31,7 @@ if TYPE_CHECKING:
 def set_output(
     out: str | None, _export: str | None, path: Path | None, log: Log
 ) -> tuple[str, dict[str, Any]]:
-    if out is None:
+    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)
@@ -43,16 +43,19 @@ def set_output(
         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)
 
@@ -63,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
 
@@ -134,53 +139,44 @@ 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 = src = use_path = None
 
-    if args.keep_tracks_separate:
-        log.deprecated("--keep-tracks-separate is deprecated.")
-        args.keep_tracks_separate = False
-
     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:
@@ -192,7 +188,8 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
     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:
@@ -211,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
@@ -224,41 +224,41 @@ 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)
+        set_stream_to_0(tl, log)
         fcp11_write_xml(export_ops["name"], 10, output, True, tl, log)
         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.
@@ -286,7 +286,7 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
         output = bv.open(output_path, "w", container_options=options)
 
         # Setup video
-        if ctr.default_vid != "none" and tl.v:
+        if ctr.default_vid not in ("none", "png") and tl.v:
             vframes = render_av(output, tl, args, log)
             output_stream: bv.VideoStream | None
             output_stream = next(vframes)  # type: ignore
@@ -522,7 +522,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,14 +1,15 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, cast
+import xml.etree.ElementTree as ET
+from typing import TYPE_CHECKING, cast
 from xml.etree.ElementTree import Element, ElementTree, SubElement, indent
 
+from auto_editor.timeline import Clip, v3
+
 if TYPE_CHECKING:
-    from collections.abc import Sequence
     from fractions import Fraction
 
     from auto_editor.ffwrapper import FileInfo
-    from auto_editor.timeline import TlAudio, TlVideo, v3
     from auto_editor.utils.log import Log
 
 
@@ -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:
@@ -120,7 +121,7 @@ def fcp11_write_xml(
     )
     spine = SubElement(sequence, "spine")
 
-    def make_clip(ref: str, clip: TlVideo | TlAudio) -> None:
+    def make_clip(ref: str, clip: Clip) -> None:
         clip_properties = {
             "name": proj_name,
             "ref": ref,
@@ -145,7 +146,7 @@ def fcp11_write_xml(
             )
 
     if tl.v and tl.v[0]:
-        clips: Sequence[TlVideo | TlAudio] = cast(Any, tl.v[0])
+        clips = cast(list[Clip], tl.v[0])
     elif tl.a and tl.a[0]:
         clips = tl.a[0]
     else:
@@ -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")