auto-editor 24.3.1__tar.gz → 24.9.1__tar.gz

{auto-editor-24.3.1/auto_editor.egg-info → auto-editor-24.9.1}/PKG-INFO

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

auto-editor-24.9.1/auto_editor/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "24.9.1"
+version = "24w09a"

{auto-editor-24.3.1 → auto-editor-24.9.1}/auto_editor/__main__.py

@@ -255,6 +255,11 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         help="Apply audio rendering to all audio tracks. Applied right before rendering the output file.",
     )
     parser.add_text("Miscellaneous:")
+    parser.add_argument(
+        "-sn",
+        flag=True,
+        help="Disable the inclusion of subtitle streams in the output file",
+    )
     parser.add_argument(
         "--extras",
         metavar="CMD",

{auto-editor-24.3.1 → auto-editor-24.9.1}/auto_editor/analyze.py

@@ -21,13 +21,10 @@ from auto_editor.lib.contracts import (
 from auto_editor.lib.data_structs import Sym
 from auto_editor.render.subtitle import SubtitleParser
 from auto_editor.utils.cmdkw import (
-    ParserError,
     Required,
-    parse_with_palet,
     pAttr,
     pAttrs,
 )
-from auto_editor.utils.func import boolop
 from auto_editor.wavfile import read
 
 if TYPE_CHECKING:
@@ -38,7 +35,6 @@ if TYPE_CHECKING:
     from numpy.typing import NDArray
 
     from auto_editor.ffwrapper import FileInfo
-    from auto_editor.lib.data_structs import Env
     from auto_editor.output import Ensure
     from auto_editor.utils.bar import Bar
     from auto_editor.utils.log import Log
@@ -412,81 +408,3 @@ class Levels:
 
         self.bar.end()
         return self.cache("motion", mobj, threshold_list[:index])
-
-
-def edit_method(val: str, filesetup: FileSetup, env: Env) -> NDArray[np.bool_]:
-    assert isinstance(filesetup, FileSetup)
-    src = filesetup.src
-    tb = filesetup.tb
-    ensure = filesetup.ensure
-    strict = filesetup.strict
-    bar = filesetup.bar
-    temp = filesetup.temp
-    log = filesetup.log
-
-    if ":" in val:
-        method, attrs = val.split(":", 1)
-    else:
-        method, attrs = val, ""
-
-    levels = Levels(ensure, src, tb, bar, temp, log)
-
-    if method == "none":
-        return levels.none()
-    if method == "all/e":
-        return levels.all()
-
-    try:
-        obj = parse_with_palet(attrs, builder_map[method], env)
-    except ParserError as e:
-        log.error(e)
-
-    try:
-        if method == "audio":
-            s = obj["stream"]
-            if s == "all" or s == Sym("all"):
-                total_list: NDArray[np.bool_] | None = None
-                for s in range(len(src.audios)):
-                    audio_list = to_threshold(levels.audio(s), obj["threshold"])
-                    if total_list is None:
-                        total_list = audio_list
-                    else:
-                        total_list = boolop(total_list, audio_list, np.logical_or)
-
-                if total_list is None:
-                    if strict:
-                        log.error("Input has no audio streams.")
-                    stream_data = levels.all()
-                else:
-                    stream_data = total_list
-            else:
-                assert isinstance(s, int)
-                stream_data = to_threshold(levels.audio(s), obj["threshold"])
-
-            assert isinstance(obj["minclip"], int)
-            assert isinstance(obj["mincut"], int)
-
-            mut_remove_small(stream_data, obj["minclip"], replace=1, with_=0)
-            mut_remove_small(stream_data, obj["mincut"], replace=0, with_=1)
-
-            return stream_data
-
-        if method == "motion":
-            return to_threshold(
-                levels.motion(obj["stream"], obj["blur"], obj["width"]),
-                obj["threshold"],
-            )
-
-        if method == "subtitle":
-            return levels.subtitle(
-                obj["pattern"],
-                obj["stream"],
-                obj["ignore_case"],
-                obj["max_count"],
-            )
-    except LevelError as e:
-        if strict:
-            log.error(e)
-
-        return levels.all()
-    raise ValueError("Unreachable")

{auto-editor-24.3.1 → auto-editor-24.9.1}/auto_editor/edit.py

@@ -215,7 +215,7 @@ def edit_media(
 
     if tl is None:
         # Extract subtitles in their native format.
-        if src is not None and len(src.subtitles) > 0:
+        if src is not None and len(src.subtitles) > 0 and not args.sn:
             cmd = ["-i", f"{src.path}", "-hide_banner"]
             for s, sub in enumerate(src.subtitles):
                 cmd.extend(["-map", f"0:s:{s}"])
@@ -246,7 +246,7 @@ def edit_media(
     if export["export"] == "premiere":
         from auto_editor.formats.fcp7 import fcp7_write_xml
 
-        fcp7_write_xml(export["name"], ffmpeg, output, tl, log)
+        fcp7_write_xml(export["name"], output, tl, log)
         return
 
     if export["export"] in ("final-cut-pro", "resolve"):
@@ -283,7 +283,7 @@ def edit_media(
         sub_output = []
         apply_later = False
 
-        if ctr.allow_subtitle:
+        if ctr.allow_subtitle and not args.sn:
             sub_output = make_new_subtitles(tl, ffmpeg, temp, log)
 
         if ctr.allow_audio:

{auto-editor-24.3.1 → auto-editor-24.9.1}/auto_editor/ffwrapper.py

@@ -235,14 +235,17 @@ def initFileInfo(path: str, ffmpeg: FFmpeg, log: Log) -> FileInfo:
                 ]
             )
             _sar, c_range, c_space, c_primary, c_transfer = _raw.strip().split("\n")
-        except Exception as e:
-            raise e
+        except Exception:
+            log.debug("Unexpected ffprobe shape")
 
         if v.sample_aspect_ratio is None:
-            try:
-                sar = Fraction(_sar.replace(":", "/"))
-            except Exception:
+            if _sar is None:
                 sar = Fraction(1)
+            else:
+                try:
+                    sar = Fraction(_sar.replace(":", "/"))
+                except Exception:
+                    sar = Fraction(1)
         else:
             sar = v.sample_aspect_ratio
 

{auto-editor-24.3.1 → auto-editor-24.9.1}/auto_editor/formats/fcp11.py

@@ -143,9 +143,6 @@ def fcp11_write_xml(
             "start": fraction(int(clip.offset // clip.speed)),
             "tcFormat": "NDF",
         }
-        if clip.start == 0:
-            del clip_properties["start"]
-
         asset = SubElement(spine, "asset-clip", clip_properties)
         if clip.speed != 1:
             # See the "Time Maps" section.
@@ -171,7 +168,7 @@ def fcp11_write_xml(
     if flavor == "resolve" and warn:
         log.warning(
             "DaVinci Resolve may take a very long time when importing timelines with "
-            "speed effects. Consider switching to a good editor, like Premiere Pro, "
+            "speed effects. Consider switching to Premiere Pro, "
             "Final Cut Pro, or ShotCut (free)"
         )
     tree = ElementTree(fcpxml)

{auto-editor-24.3.1 → auto-editor-24.9.1}/auto_editor/formats/fcp7.py

@@ -10,7 +10,7 @@ from xml.etree.ElementTree import Element
 from auto_editor.ffwrapper import FFmpeg, FileInfo, initFileInfo
 from auto_editor.timeline import ASpace, TlAudio, TlVideo, VSpace, v3
 
-from .utils import Validator, make_tracks_dir, show
+from .utils import Validator, show
 
 if TYPE_CHECKING:
     from auto_editor.utils.log import Log
@@ -25,9 +25,6 @@ Also, Premiere itself will happily output subtlety incorrect XML files that don'
 come back the way they started.
 """
 
-PIXEL_ASPECT_RATIO = "square"
-COLORDEPTH = "24"
-ANAMORPHIC = "FALSE"
 DEPTH = "16"
 
 
@@ -121,21 +118,6 @@ def read_tb_ntsc(tb: int, ntsc: bool) -> Fraction:
     return Fraction(tb)
 
 
-"""
-(define/c (read-tb-ntsc [tb int?] [ntsc bool?] -> frac?)
-    (if ntsc
-        (cond
-            ((= tb 24) 24000/1001)
-            ((= tb 30) 30000/1001)
-            ((= tb 60) 60000/1001)
-            (else (* tb 999/1000))
-        )
-        (* tb 1/1)
-    )
-)
-"""
-
-
 def speedup(speed: float) -> Element:
     fil = Element("filter")
     effect = ET.SubElement(fil, "effect")
@@ -164,28 +146,6 @@ def speedup(speed: float) -> Element:
     return fil
 
 
-"""
-(define/c (speedup [speed float?] -> element?)
-    (xml (filter (effect
-        (name "Time Remap")
-        (effectid "timeremap")
-        (parameter #:authoringApp "PremierePro"
-            (parameterid "variablespeed") (name "variablespeed")
-            (valuemin "0") (valuemax "1") (value "0")
-        )
-        (parameter #:authoringApp "PremierePro"
-            (parameterid "speed") (name "speed")
-            (valuemin "-100000") (valuemax "100000") (value (number->string speed))
-        )
-        (parameter #:authoringApp "PremierePro"
-            (parameterid "frameblending") (name "frameblending")
-            (value "FALSE")
-        )
-    )))
-)
-"""
-
-
 SUPPORTED_EFFECTS = ("timeremap",)
 
 
@@ -403,48 +363,32 @@ def media_def(
         ET.SubElement(rate, "ntsc").text = ntsc
         ET.SubElement(vschar, "width").text = f"{tl.res[0]}"
         ET.SubElement(vschar, "height").text = f"{tl.res[1]}"
-        ET.SubElement(vschar, "anamorphic").text = ANAMORPHIC
-        ET.SubElement(vschar, "pixelaspectratio").text = PIXEL_ASPECT_RATIO
+        ET.SubElement(vschar, "pixelaspectratio").text = "square"
 
-    if len(src.audios) > 0:
+    for aud in src.audios:
         audiodef = ET.SubElement(mediadef, "audio")
         aschar = ET.SubElement(audiodef, "samplecharacteristics")
         ET.SubElement(aschar, "depth").text = DEPTH
         ET.SubElement(aschar, "samplerate").text = f"{tl.sr}"
-        ET.SubElement(audiodef, "channelcount").text = f"{src.audios[0].channels}"
+        ET.SubElement(audiodef, "channelcount").text = f"{aud.channels}"
 
 
-def fcp7_write_xml(name: str, ffmpeg: FFmpeg, output: str, tl: v3, log: Log) -> None:
+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[tuple[FileInfo, int], str] = {}
-    src_to_id: dict[tuple[FileInfo, int], str] = {}
-    src_to_src: dict[tuple[FileInfo, int], FileInfo] = {}
+    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):
-        path_resolve = f"{src.path.resolve()}"
         the_id = f"file-{len(src_to_id)+1}"
+        src_to_url[src] = f"{src.path.resolve()}"
+        src_to_id[src] = the_id
 
-        src_to_url[(src, 0)] = path_resolve
-        src_to_id[(src, 0)] = the_id
-
-        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", path_resolve, "-map", f"0:a:{i}", f"{newtrack}"])
-
-                new_src = initFileInfo(f"{newtrack}", ffmpeg, log)
-                src_to_url[(src, i)] = f"{newtrack.resolve()}"
-                src_to_id[(src, i)] = f"file-{len(src_to_id)+1}"
-                src_to_src[(src, i)] = new_src
-
-    xmeml = ET.Element("xmeml", version="4")
-    sequence = ET.SubElement(xmeml, "sequence")
+    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")
@@ -455,14 +399,13 @@ def fcp7_write_xml(name: str, ffmpeg: FFmpeg, output: str, tl: v3, log: Log) ->
     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
-    ET.SubElement(vschar, "fielddominance").text = "none"
-    ET.SubElement(vschar, "colordepth").text = COLORDEPTH
-    ET.SubElement(vschar, "width").text = f"{width}"
-    ET.SubElement(vschar, "height").text = f"{height}"
-    ET.SubElement(vschar, "pixelaspectratio").text = PIXEL_ASPECT_RATIO
 
     if len(tl.v) > 0 and len(tl.v[0]) > 0:
         track = ET.SubElement(video, "track")
@@ -476,25 +419,26 @@ def fcp7_write_xml(name: str, ffmpeg: FFmpeg, output: str, tl: v3, log: Log) ->
             _out = f"{int(clip.offset / clip.speed) + clip.dur}"
 
             clipitem = ET.SubElement(track, "clipitem", id=f"clipitem-{j+1}")
-            ET.SubElement(clipitem, "masterclipid").text = "masterclip-2"
             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
 
-            _id = src_to_id[(clip.src, 0)]
+            _id = src_to_id[clip.src]
             filedef = ET.SubElement(clipitem, "file", id=_id)
 
-            pathurl = src_to_url[(clip.src, 0)]
+            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))
 
-            for i in range(len(src.audios) + 1):
+            for i in range(len(src.audios) * 2 + 1):  # `2` because stereo.
                 link = ET.SubElement(clipitem, "link")
                 ET.SubElement(
                     link, "linkclipref"
@@ -502,8 +446,6 @@ def fcp7_write_xml(name: str, ffmpeg: FFmpeg, output: str, tl: v3, log: Log) ->
                 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)
-                if i > 0:
-                    ET.SubElement(link, "groupindex").text = "1"
 
     # Audio definitions and clips
     audio = ET.SubElement(media, "audio")
@@ -513,66 +455,63 @@ def fcp7_write_xml(name: str, ffmpeg: FFmpeg, output: str, tl: v3, log: Log) ->
     ET.SubElement(aschar, "depth").text = DEPTH
     ET.SubElement(aschar, "samplerate").text = str(tl.sr)
 
-    for t, aclips in enumerate(tl.a):
-        track = ET.Element(
-            "track", currentExplodedTrackIndex="0", premiereTrackType="Stereo"
-        )
-
-        for j, aclip in enumerate(aclips):
-            src = aclip.src
-
-            _start = f"{aclip.start}"
-            _end = f"{aclip.start + aclip.dur}"
-            _in = f"{int(aclip.offset / aclip.speed)}"
-            _out = f"{int(aclip.offset / aclip.speed) + aclip.dur}"
-
-            if not src.videos:
-                clip_item_num = j + 1
-                master_id = "1"
-            else:
-                clip_item_num = len(aclips) + 1 + j + (t * len(aclips))
-                master_id = "2"
-
-            clipitem = ET.SubElement(
-                track,
-                "clipitem",
-                id=f"clipitem-{clip_item_num}",
-                premiereChannelType="stereo",
+    t = 0
+    for aclips in tl.a:
+        for channelcount in range(0, 2):  # Because "stereo" is hardcoded.
+            t += 1
+            track = ET.Element(
+                "track",
+                currentExplodedTrackIndex=f"{channelcount}",
+                totalExplodedTrackCount="2",  # Because "stereo" is hardcoded.
+                premiereTrackType="Stereo",
             )
-            ET.SubElement(clipitem, "masterclipid").text = f"masterclip-{master_id}"
-            ET.SubElement(clipitem, "name").text = src.path.stem
-            ET.SubElement(clipitem, "start").text = _start
-            ET.SubElement(clipitem, "end").text = _end
-            ET.SubElement(clipitem, "in").text = _in
-            ET.SubElement(clipitem, "out").text = _out
-
-            _id = src_to_id[(aclip.src, aclip.stream)]
-            pathurl = src_to_url[(aclip.src, aclip.stream)]
 
-            if aclip.stream > 0:
-                my_src = src_to_src[(aclip.src, aclip.stream)]
-            else:
-                my_src = aclip.src
-
-            filedef = ET.SubElement(clipitem, "file", id=_id)
-            if pathurl not in file_defs:
-                media_def(filedef, pathurl, my_src, tl, timebase, ntsc)
-                file_defs.add(pathurl)
+            if src.videos:
+                ET.SubElement(track, "outputchannelindex").text = f"{channelcount + 1}"
 
-            sourcetrack = ET.SubElement(clipitem, "sourcetrack")
-            ET.SubElement(sourcetrack, "mediatype").text = "audio"
-            ET.SubElement(sourcetrack, "trackindex").text = "1"
-            labels = ET.SubElement(clipitem, "labels")
-            ET.SubElement(labels, "label2").text = "Iris"
+            for j, aclip in enumerate(aclips):
+                src = aclip.src
 
-            if aclip.speed != 1:
-                clipitem.append(speedup(aclip.speed * 100))
+                _start = f"{aclip.start}"
+                _end = f"{aclip.start + aclip.dur}"
+                _in = f"{int(aclip.offset / aclip.speed)}"
+                _out = f"{int(aclip.offset / aclip.speed) + aclip.dur}"
 
-            if src.videos:
-                ET.SubElement(clipitem, "outputchannelindex").text = "1"
+                if not src.videos:
+                    clip_item_num = j + 1
+                else:
+                    clip_item_num = len(aclips) + 1 + j + (t * len(aclips))
 
-        audio.append(track)
+                clipitem = ET.SubElement(
+                    track,
+                    "clipitem",
+                    id=f"clipitem-{clip_item_num}",
+                    premiereChannelType="stereo",
+                )
+                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
+
+                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)
+
+                sourcetrack = ET.SubElement(clipitem, "sourcetrack")
+                ET.SubElement(sourcetrack, "mediatype").text = "audio"
+                ET.SubElement(sourcetrack, "trackindex").text = f"{t}"
+                labels = ET.SubElement(clipitem, "labels")
+                ET.SubElement(labels, "label2").text = "Iris"
+
+                if aclip.speed != 1:
+                    clipitem.append(speedup(aclip.speed * 100))
+
+            audio.append(track)
 
     tree = ET.ElementTree(xmeml)
-    ET.indent(tree, space="\t", level=0)
+    ET.indent(tree, space="  ", level=0)
     tree.write(output, xml_declaration=True, encoding="utf-8")

{auto-editor-24.3.1 → auto-editor-24.9.1}/auto_editor/help.py

@@ -25,16 +25,19 @@ will set the speed from 400 ticks to 800 ticks to 2.5x
 If timebase is 30, 400 ticks to 800 means 13.33 to 26.66 seconds
 """.strip(),
         "--edit-based-on": """
-Evalutes a palet expression that returns a bool-array?. The array is then used for
+Evaluates a palet expression that returns a bool-array?. The array is then used for
 editing.
 
 Editing Methods:
  - audio  ; Audio silence/loudness detection
     - threshold threshold? : 4%
-    - stream (or/c nat? 'all "all") : 0
+    - stream (or/c nat? 'all) : 'all
     - mincut nat? : 6
     - minclip nat? : 3
 
+ ; mincut is more significant, there it has a larger default value.
+ ; minclip gets applied first, then mincut
+
  - motion  ; Motion detection specialized for noisy real-life videos
     - threshold threshold? : 2%
     - stream nat? : 0
@@ -150,10 +153,6 @@ The special value `unset` may also be used, and means: Don't pass any value to f
 """.strip(),
         "--video-bitrate": """
 `--video-bitrate` sets the target bitrate for the video encoder. It accepts the same format as `--audio-bitrate` and the special `unset` value is allowed.
-""".strip(),
-        "--silent-threshold": """
-Silent threshold is a percentage where 0% represents absolute silence and 100% represents the highest volume in the media file.
-Setting the threshold to `0%` will cut only out areas where area is absolutely silence.
 """.strip(),
         "--margin": """
 Default value: 0.2s,0.2s

auto-editor-24.9.1/auto_editor/lang/libmath.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import math
+
+from auto_editor.lib.contracts import Proc, andc, between_c, gt_c, is_real
+
+
+def all() -> dict[str, object]:
+    return {
+        "exp": Proc("exp", math.exp, (1, 1), is_real),
+        "ceil": Proc("ceil", math.ceil, (1, 1), is_real),
+        "floor": Proc("floor", math.floor, (1, 1), is_real),
+        "sin": Proc("sin", math.sin, (1, 1), is_real),
+        "cos": Proc("cos", math.cos, (1, 1), is_real),
+        "tan": Proc("tan", math.tan, (1, 1), is_real),
+        "asin": Proc("asin", math.asin, (1, 1), between_c(-1, 1)),
+        "acos": Proc("acos", math.acos, (1, 1), between_c(-1, 1)),
+        "atan": Proc("atan", math.atan, (1, 1), is_real),
+        "log": Proc("log", math.log, (1, 2), andc(is_real, gt_c(0))),
+        "pi": math.pi,
+        "e": math.e,
+        "tau": math.tau,
+    }