auto-editor 28.0.1__tar.gz → 28.0.2__tar.gz

{auto_editor-28.0.1 → auto_editor-28.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-editor
-Version: 28.0.1
+Version: 28.0.2
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License-Expression: Unlicense

auto_editor-28.0.2/auto_editor/__init__.py

@@ -0,0 +1 @@
+__version__ = "28.0.2"

{auto_editor-28.0.1 → auto_editor-28.0.2}/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-28.0.1 → auto_editor-28.0.2}/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.

{auto_editor-28.0.1 → auto_editor-28.0.2}/auto_editor/exports/fcp11.py

@@ -1,17 +1,10 @@
-from __future__ import annotations
-
 import xml.etree.ElementTree as ET
-from typing import TYPE_CHECKING, cast
+from fractions import Fraction
 from xml.etree.ElementTree import Element, ElementTree, SubElement, indent
 
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.timeline import Clip, v3
-
-if TYPE_CHECKING:
-    from fractions import Fraction
-
-    from auto_editor.ffwrapper import FileInfo
-    from auto_editor.utils.log import Log
-
+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",
@@ -122,12 +146,14 @@ def fcp11_write_xml(
     spine = SubElement(sequence, "spine")
 
     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 = cast(list[Clip], 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-28.0.2/auto_editor/exports/json.py

@@ -0,0 +1,63 @@
+import sys
+
+from auto_editor.json import dump
+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:
+    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(as_dict(tl), 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-28.0.1 → auto_editor-28.0.2}/auto_editor/exports/shotcut.py

@@ -1,5 +1,4 @@
 import xml.etree.ElementTree as ET
-from typing import cast
 
 from auto_editor.timeline import Clip, v3
 from auto_editor.utils.func import aspect_ratio, to_timecode
@@ -71,7 +70,7 @@ def shotcut_write_mlt(output: str, tl: v3) -> None:
     producers = 0
 
     if tl.v:
-        clips = cast(list[Clip], 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-28.0.1 → auto_editor-28.0.2}/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}"

{auto_editor-28.0.1 → auto_editor-28.0.2}/auto_editor/preview.py

@@ -28,23 +28,24 @@ def time_frame(
 def all_cuts(tl: v3, in_len: int) -> list[int]:
     # Calculate cuts
     tb = tl.tb
-    oe: list[tuple[int, int]] = []
+    clip_spans: list[tuple[int, int]] = []
 
     for clip in tl.a[0]:
         old_offset = clip.offset * clip.speed
-        oe.append((round(old_offset * clip.speed), round(old_offset + clip.dur)))
+        clip_spans.append((round(old_offset), round(old_offset + clip.dur)))
 
     cut_lens = []
     i = 0
-    while i < len(oe) - 1:
-        if i == 0 and oe[i][0] != 0:
-            cut_lens.append(oe[i][1])
+    while i < len(clip_spans) - 1:
+        if i == 0 and clip_spans[i][0] != 0:
+            cut_lens.append(clip_spans[i][0])
 
-        cut_lens.append(oe[i + 1][0] - oe[i][1])
+        cut_lens.append(clip_spans[i + 1][0] - clip_spans[i][1])
         i += 1
 
-    if len(oe) > 0 and oe[-1][1] < round(in_len * tb):
-        cut_lens.append(in_len - oe[-1][1])
+    if len(clip_spans) > 0 and clip_spans[-1][1] < round(in_len / tb):
+        cut_lens.append(in_len - clip_spans[-1][1])
+
     return cut_lens
 
 
@@ -53,19 +54,9 @@ def preview(tl: v3, log: Log) -> None:
     tb = tl.tb
 
     # Calculate input videos length
-    all_sources = set()
-    for vlayer in tl.v:
-        for vclip in vlayer:
-            if hasattr(vclip, "src"):
-                all_sources.add(vclip.src)
-    for alayer in tl.a:
-        for aclip in alayer:
-            if hasattr(aclip, "src"):
-                all_sources.add(aclip.src)
-
     in_len = 0
     bar = initBar("none")
-    for src in all_sources:
+    for src in tl.unique_sources():
         in_len += initLevels(src, tb, bar, False, log).media_length
 
     out_len = len(tl)
@@ -77,7 +68,7 @@ def preview(tl: v3, log: Log) -> None:
     time_frame(fp, "output", out_len, tb, f"{round((out_len / in_len) * 100, 2)}%")
     time_frame(fp, "diff", diff, tb, f"{round((diff / in_len) * 100, 2)}%")
 
-    clip_lens = [clip.dur / clip.speed for clip in tl.a[0]]
+    clip_lens = [clip.dur for clip in tl.a[0]]
     log.debug(clip_lens)
 
     fp.write(f"clips:\n - amount:    {len(clip_lens)}\n")
@@ -90,7 +81,7 @@ def preview(tl: v3, log: Log) -> None:
 
     cut_lens = all_cuts(tl, in_len)
     log.debug(cut_lens)
-    fp.write(f"cuts:\n - amount:    {len(clip_lens)}\n")
+    fp.write(f"cuts:\n - amount:    {len(cut_lens)}\n")
     if len(cut_lens) > 0:
         time_frame(fp, "smallest", min(cut_lens), tb)
         time_frame(fp, "largest", max(cut_lens), tb)

{auto_editor-28.0.1 → auto_editor-28.0.2}/auto_editor/timeline.py

@@ -282,41 +282,6 @@ video\n"""
 
         return result
 
-    def as_dict(self) -> 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,
-        }
-
     @property
     def T(self) -> Template:
         return self.template

{auto_editor-28.0.1 → auto_editor-28.0.2}/auto_editor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-editor
-Version: 28.0.1
+Version: 28.0.2
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License-Expression: Unlicense

auto_editor-28.0.1/auto_editor/__init__.py

@@ -1 +0,0 @@
-__version__ = "28.0.1"

auto_editor-28.0.1/auto_editor/exports/json.py

@@ -1,32 +0,0 @@
-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()