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

auto_editor/__init__.py

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

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

@@ -113,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 = {
@@ -134,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,
@@ -145,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/levels.py

@@ -36,6 +36,7 @@ class LevelArgs:
     input: list[str] = field(default_factory=list)
     edit: str = "audio"
     timebase: Fraction | None = None
+    no_cache: bool = False
     help: bool = False
 
 
@@ -53,16 +54,14 @@ def levels_options(parser: ArgumentParser) -> ArgumentParser:
         type=frame_rate,
         help="Set custom timebase",
     )
+    parser.add_argument("--no-cache", flag=True)
     return parser
 
 
 def print_arr(arr: NDArray) -> None:
     print("")
     print("@start")
-    if arr.dtype in {np.float64, np.float32, np.float16}:
-        for a in arr:
-            sys.stdout.write(f"{a:.20f}\n")
-    elif arr.dtype == np.bool_:
+    if arr.dtype == np.bool_:
         for a in arr:
             sys.stdout.write(f"{1 if a else 0}\n")
     else:
@@ -76,7 +75,7 @@ def print_arr_gen(arr: Iterator[float | np.float32]) -> None:
     print("")
     print("@start")
     for a in arr:
-        print(f"{a:.20f}")
+        print(f"{a}")
     print("")
 
 
@@ -131,7 +130,11 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
         levels = initLevels(src, tb, bar, False, log)
         try:
             if method == "audio":
-                if (arr := levels.read_cache("audio", (obj["stream"],))) is not None:
+                if (
+                    not args.no_cache
+                    and (arr := levels.read_cache("audio", (obj["stream"],)))
+                    is not None
+                ):
                     print_arr(arr)
                 else:
                     container = bv.open(src.path, "r")
@@ -148,11 +151,15 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
                     container.close()
 
                     cache_array = np.array(values, dtype=np.float32)
-                    levels.cache(cache_array, "audio", (obj["stream"],))
+                    if not args.no_cache:
+                        levels.cache(cache_array, "audio", (obj["stream"],))
 
             elif method == "motion":
                 mobj = (obj["stream"], obj["width"], obj["blur"])
-                if (arr := levels.read_cache("motion", mobj)) is not None:
+                if (
+                    not args.no_cache
+                    and (arr := levels.read_cache("motion", mobj)) is not None
+                ):
                     print_arr(arr)
                 else:
                     container = bv.open(src.path, "r")
@@ -171,7 +178,8 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
                     container.close()
 
                     cache_array = np.array(values, dtype=np.float32)
-                    levels.cache(cache_array, "motion", mobj)
+                    if not args.no_cache:
+                        levels.cache(cache_array, "motion", mobj)
 
             elif method == "subtitle":
                 print_arr(levels.subtitle(**obj))

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:
@@ -516,9 +529,6 @@ 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"
@@ -563,15 +573,12 @@ class Runner:
             ("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),
@@ -580,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),
@@ -595,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),
@@ -609,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),
@@ -618,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)", ""),
@@ -698,7 +701,7 @@ class Runner:
         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))
 
@@ -797,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

@@ -29,8 +29,8 @@ if TYPE_CHECKING:
 
 
 def set_output(
-    out: str | None, _export: str | None, path: Path | None, log: Log
-) -> tuple[str, dict[str, Any]]:
+    out: str | None, export: str | None, path: Path | None, log: Log
+) -> tuple[str, str]:
     if out is None or out == "-":
         if path is None:
             log.error("`--output` must be set.")  # When a timeline file is the input.
@@ -42,33 +42,33 @@ def set_output(
         # Use `mp4` as the default, because it is most compatible.
         ext = ".mp4" if path is None else path.suffix
 
-    if _export is None:
+    if export is None:
         match ext:
             case ".xml":
-                export: dict[str, Any] = {"export": "premiere"}
+                export = "premiere"
             case ".fcpxml":
-                export = {"export": "final-cut-pro"}
+                export = "final-cut-pro"
             case ".mlt":
-                export = {"export": "shotcut"}
+                export = "shotcut"
             case ".json" | ".v1":
-                export = {"export": "v1"}
+                export = "v1"
             case ".v3":
-                export = {"export": "v3"}
+                export = "v3"
             case _:
-                export = {"export": "default"}
-    else:
-        export = parse_export(_export, log)
-
-    ext_map = {
-        "premiere": ".xml",
-        "resolve-fcp7": ".xml",
-        "final-cut-pro": ".fcpxml",
-        "resolve": ".fcpxml",
-        "shotcut": ".mlt",
-        "json": ".json",
-    }
-    if export["export"] in ext_map:
-        ext = ext_map[export["export"]]
+                export = "default"
+
+    match export:
+        case "premiere" | "resolve-fcp7":
+            ext = ".xml"
+        case "final-cut-pro" | "resolve":
+            ext = ".fcpxml"
+        case "shotcut":
+            ext = ".mlt"
+        case "v1":
+            if ext != ".json":
+                ext = ".v1"
+        case "v3":
+            ext = ".v3"
 
     if out == "-":
         return "-", export
@@ -184,9 +184,13 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
             src = sources[0]
             use_path = src.path
 
-    output, export_ops = set_output(args.output, args.export, use_path, log)
-    assert "export" in export_ops
-    export = export_ops["export"]
+    if args.export is None:
+        output, export = set_output(args.output, args.export, use_path, log)
+        export_ops: dict[str, Any] = {"export": export}
+    else:
+        export_ops = parse_export(args.export, log)
+        export = export_ops["export"]
+        output, _ = set_output(args.output, export, use_path, log)
 
     if output == "-":
         # When printing to stdout, silence all logs.
@@ -247,8 +251,7 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
     if export == "resolve":
         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
 
@@ -287,7 +290,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

auto_editor/exports/fcp11.py

@@ -1,17 +1,10 @@
-from __future__ import annotations
-
 import xml.etree.ElementTree as ET
-from typing import TYPE_CHECKING, Any, cast
+from fractions import Fraction
 from xml.etree.ElementTree import Element, ElementTree, SubElement, indent
 
-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
-
+from auto_editor.ffwrapper import FileInfo
+from auto_editor.timeline import Clip, v3
+from auto_editor.utils.log import Log
 
 """
 Export a FCPXML 11 file readable with Final Cut Pro 10.6.8 or later.
@@ -52,6 +45,35 @@ def make_name(src: FileInfo, tb: Fraction) -> str:
     return "FFVideoFormatRateUndefined"
 
 
+def parseSMPTE(val: str, fps: Fraction, log: Log) -> int:
+    if len(val) == 0:
+        return 0
+    try:
+        parts = val.split(":")
+        if len(parts) != 4:
+            raise ValueError(f"Invalid SMPTE format: {val}")
+
+        hours, minutes, seconds, frames = map(int, parts)
+
+        if (
+            hours < 0
+            or minutes < 0
+            or minutes >= 60
+            or seconds < 0
+            or seconds >= 60
+            or frames < 0
+        ):
+            raise ValueError(f"Invalid SMPTE values: {val}")
+
+        if frames >= fps:
+            raise ValueError(f"Frame count {frames} exceeds fps {fps}")
+
+        total_frames = (hours * 3600 + minutes * 60 + seconds) * fps + frames
+        return int(round(total_frames))
+    except (ValueError, ZeroDivisionError) as e:
+        log.error(f"Cannot parse SMPTE timecode '{val}': {e}")
+
+
 def fcp11_write_xml(
     group_name: str, version: int, output: str, resolve: bool, tl: v3, log: Log
 ) -> None:
@@ -90,12 +112,14 @@ def fcp11_write_xml(
             height=f"{tl.res[1]}",
             colorSpace=get_colorspace(one_src),
         )
+
+        startPoint = parseSMPTE(one_src.timecode, tl.tb, log)
         r2 = SubElement(
             resources,
             "asset",
             id=f"r{i * 2 + 2}",
             name=one_src.path.stem,
-            start="0s",
+            start=fraction(startPoint),
             hasVideo="1" if one_src.videos else "0",
             format=f"r{i * 2 + 1}",
             hasAudio="1" if one_src.audios else "0",
@@ -121,13 +145,15 @@ 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:
+        startPoint = parseSMPTE(clip.src.timecode, tl.tb, log)
+
         clip_properties = {
             "name": proj_name,
             "ref": ref,
-            "offset": fraction(clip.start),
+            "offset": fraction(clip.start + startPoint),
             "duration": fraction(clip.dur),
-            "start": fraction(clip.offset),
+            "start": fraction(clip.offset + startPoint),
             "tcFormat": "NDF",
         }
         asset = SubElement(spine, "asset-clip", clip_properties)
@@ -146,7 +172,7 @@ def fcp11_write_xml(
             )
 
     if tl.v and tl.v[0]:
-        clips: Sequence[TlVideo | TlAudio] = cast(Any, tl.v[0])
+        clips = [clip for clip in tl.v[0] if isinstance(clip, Clip)]
     elif tl.a and tl.a[0]:
         clips = tl.a[0]
     else:

auto_editor/exports/fcp7.py

@@ -3,14 +3,10 @@ from __future__ import annotations
 import xml.etree.ElementTree as ET
 from fractions import Fraction
 from math import ceil
-from typing import TYPE_CHECKING
 from xml.etree.ElementTree import Element
 
 from auto_editor.ffwrapper import FileInfo
-from auto_editor.timeline import TlVideo, v3
-
-if TYPE_CHECKING:
-    from auto_editor.utils.log import Log
+from auto_editor.timeline import Clip, v3
 
 """
 Premiere Pro uses the Final Cut Pro 7 XML Interchange Format
@@ -69,39 +65,6 @@ def speedup(speed: float) -> Element:
     return fil
 
 
-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> 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 media_def(
     filedef: Element, url: str, src: FileInfo, tl: v3, tb: int, ntsc: str
 ) -> None:
@@ -295,7 +258,7 @@ def fcp7_write_xml(name: str, output: str, resolve: bool, tl: v3) -> None:
         track = ET.SubElement(video, "track")
 
         for j, clip in enumerate(tl.v[0]):
-            assert isinstance(clip, TlVideo)
+            assert isinstance(clip, Clip)
 
             _start = f"{clip.start}"
             _end = f"{clip.start + clip.dur}"

auto_editor/exports/json.py

@@ -1,13 +1,44 @@
-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
+from auto_editor.timeline import Clip, v3
+from auto_editor.utils.log import Log
+
+
+def as_dict(self: v3) -> dict:
+    def aclip_to_dict(self: Clip) -> dict:
+        return {
+            "name": "audio",
+            "src": self.src,
+            "start": self.start,
+            "dur": self.dur,
+            "offset": self.offset,
+            "speed": self.speed,
+            "volume": self.volume,
+            "stream": self.stream,
+        }
+
+    v = []
+    a = []
+    for vlayer in self.v:
+        vb = [vobj.as_dict() for vobj in vlayer]
+        if vb:
+            v.append(vb)
+    for layer in self.a:
+        ab = [aclip_to_dict(clip) for clip in layer]
+        if ab:
+            a.append(ab)
+
+    return {
+        "version": "3",
+        "timebase": f"{self.tb.numerator}/{self.tb.denominator}",
+        "background": self.background,
+        "resolution": self.T.res,
+        "samplerate": self.T.sr,
+        "layout": self.T.layout,
+        "v": v,
+        "a": a,
+    }
 
 
 def make_json_timeline(ver: str, out: str, tl: v3, log: Log) -> None:
@@ -20,7 +51,7 @@ def make_json_timeline(ver: str, out: str, tl: v3, log: Log) -> None:
         outfile = open(out, "w")
 
     if ver == "v3":
-        dump(tl.as_dict(), outfile, indent=2)
+        dump(as_dict(tl), outfile, indent=2)
     else:
         if tl.v1 is None:
             log.error("Timeline can't be converted to v1 format")

auto_editor/exports/shotcut.py

@@ -1,13 +1,8 @@
 import xml.etree.ElementTree as ET
-from typing import TYPE_CHECKING, Any, cast
 
-from auto_editor.timeline import TlAudio, TlVideo, v3
+from auto_editor.timeline import Clip, v3
 from auto_editor.utils.func import aspect_ratio, to_timecode
 
-if TYPE_CHECKING:
-    from collections.abc import Sequence
-
-
 """
 Shotcut uses the MLT timeline format
 
@@ -75,7 +70,7 @@ def shotcut_write_mlt(output: str, tl: v3) -> None:
     producers = 0
 
     if tl.v:
-        clips: Sequence[TlVideo | TlAudio] = cast(Any, tl.v[0])
+        clips = [clip for clip in tl.v[0] if isinstance(clip, Clip)]
     elif tl.a:
         clips = tl.a[0]
     else:

auto_editor/ffwrapper.py

@@ -66,6 +66,7 @@ class FileInfo:
     path: Path
     bitrate: int
     duration: float
+    timecode: str  # in SMPTE
     videos: tuple[VideoStream, ...]
     audios: tuple[AudioStream, ...]
     subtitles: tuple[SubtitleStream, ...]
@@ -165,12 +166,22 @@ class FileInfo:
             ext = sub_exts.get(codec, "vtt")
             subtitles += (SubtitleStream(codec, ext, s.language),)
 
+        def get_timecode() -> str:
+            for d in cont.streams.data:
+                if (result := d.metadata.get("timecode")) is not None:
+                    return result
+            for v in cont.streams.video:
+                if (result := v.metadata.get("timecode")) is not None:
+                    return result
+            return "00:00:00:00"
+
+        timecode = get_timecode()
         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, videos, audios, subtitles)
+        return FileInfo(Path(path), bitrate, dur, timecode, videos, audios, subtitles)
 
     def __repr__(self) -> str:
         return f"@{self.path.name}"