auto-editor 24.19.1__tar.gz → 24.25.1__tar.gz

{auto_editor-24.19.1/auto_editor.egg-info → auto_editor-24.25.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 24.19.1
+Version: 24.25.1
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense
@@ -12,7 +12,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.22.0
-Requires-Dist: pyav==12.0.5
+Requires-Dist: pyav==12.1.0
 Requires-Dist: ae-ffmpeg==1.2.*
 
 <p align="center"><img src="https://auto-editor.com/img/auto-editor-banner.webp" title="Auto-Editor" width="700"></p>
@@ -105,16 +105,14 @@ Auto-Editor can also export to:
 - Individual media clips with `--export clip-sequence`
 
 ### Naming Timelines
-By default, auto-editor will name the timeline to "Auto-Editor Media Group" if the export supports naming.
+Some editors support naming timelines. By default, auto-editor will use the name "Auto-Editor Media Group". For `premiere` `resolve` and `final-cut-pro` export options, you can change the name with the following syntax.
 
 ```
+# for POSIX shells
 auto-editor example.mp4 --export 'premiere:name="Your name here"'
 
-auto-editor example.mp4 --export 'resolve:name="Your name here"'
-
-auto-editor example.mp4 --export 'final-cut-pro:name="Your name here"'
-
-# No other export options support naming
+# for Powershell
+auto-editor example.mp4 --export 'premiere:name=""Your name here""'
 ```
 
 ### Split by Clip

{auto_editor-24.19.1 → auto_editor-24.25.1}/README.md

@@ -88,16 +88,14 @@ Auto-Editor can also export to:
 - Individual media clips with `--export clip-sequence`
 
 ### Naming Timelines
-By default, auto-editor will name the timeline to "Auto-Editor Media Group" if the export supports naming.
+Some editors support naming timelines. By default, auto-editor will use the name "Auto-Editor Media Group". For `premiere` `resolve` and `final-cut-pro` export options, you can change the name with the following syntax.
 
 ```
+# for POSIX shells
 auto-editor example.mp4 --export 'premiere:name="Your name here"'
 
-auto-editor example.mp4 --export 'resolve:name="Your name here"'
-
-auto-editor example.mp4 --export 'final-cut-pro:name="Your name here"'
-
-# No other export options support naming
+# for Powershell
+auto-editor example.mp4 --export 'premiere:name=""Your name here""'
 ```
 
 ### Split by Clip

auto_editor-24.25.1/auto_editor/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "24.25.1"
+version = "24w25a"

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/__main__.py

@@ -1,8 +1,11 @@
 #!/usr/bin/env python3
 
 import sys
+from os import environ
 
 import auto_editor
+from auto_editor.edit import edit_media
+from auto_editor.ffwrapper import FFmpeg
 from auto_editor.utils.func import setup_tempdir
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import (
@@ -277,11 +280,16 @@ def main() -> None:
             f"auto_editor.subcommands.{sys.argv[1]}", fromlist=["subcommands"]
         )
         obj.main(sys.argv[2:])
-        sys.exit()
+        return
+
+    ff_color = "AV_LOG_FORCE_NOCOLOR"
+    no_color = bool(environ.get("NO_COLOR")) or bool(environ.get(ff_color))
+    log = Log(no_color=no_color)
 
     args = main_options(ArgumentParser("Auto-Editor")).parse_args(
         Args,
         sys.argv[1:],
+        log,
         macros=[
             ({"--frame-margin"}, ["--margin"]),
             ({"--export-to-premiere", "-exp"}, ["--export", "premiere"]),
@@ -296,36 +304,32 @@ def main() -> None:
 
     if args.version:
         print(f"{auto_editor.version} ({auto_editor.__version__})")
-        sys.exit()
-
-    from auto_editor.edit import edit_media
-    from auto_editor.ffwrapper import FFmpeg
-
-    log = Log(args.debug, args.quiet)
-    ffmpeg = FFmpeg(
-        args.ffmpeg_location,
-        args.my_ffmpeg,
-        args.show_ffmpeg_commands,
-        args.show_ffmpeg_output,
-    )
+        return
 
-    if args.debug and args.input == []:
+    if args.debug and not args.input:
         import platform as plat
 
-        is64bit = "64-bit" if sys.maxsize > 2**32 else "32-bit"
-        print(f"Python Version: {plat.python_version()} {is64bit}")
+        import av
+
+        print(f"Python Version: {plat.python_version()}")
         print(f"Platform: {plat.system()} {plat.release()} {plat.machine().lower()}")
-        print(f"FFmpeg Version: {ffmpeg.version}\nFFmpeg Path: {ffmpeg.path}")
+        print(f"PyAV Version: {av.__version__}")
         print(f"Auto-Editor Version: {auto_editor.version}")
-        sys.exit()
+        return
 
-    if args.input == []:
+    if not args.input:
         log.error("You need to give auto-editor an input file.")
 
-    temp = setup_tempdir(args.temp_dir, Log())
-    log = Log(args.debug, args.quiet, temp=temp)
+    temp = setup_tempdir(args.temp_dir, log)
+    log = Log(args.debug, args.quiet, temp, args.progress == "machine", no_color)
     log.debug(f"Temp Directory: {temp}")
 
+    ffmpeg = FFmpeg(
+        args.ffmpeg_location,
+        args.my_ffmpeg,
+        args.show_ffmpeg_commands,
+        args.show_ffmpeg_output,
+    )
     paths = valid_input(args.input, ffmpeg, args, log)
 
     try:

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/analyze.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import re
 from dataclasses import dataclass
+from fractions import Fraction
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -19,12 +20,12 @@ from auto_editor.lib.contracts import (
     orc,
 )
 from auto_editor.lib.data_structs import Sym
-from auto_editor.render.subtitle import SubtitleParser
 from auto_editor.utils.cmdkw import (
     Required,
     pAttr,
     pAttrs,
 )
+from auto_editor.utils.subtitle_tools import convert_ass_to_text
 from auto_editor.wavfile import read
 
 if TYPE_CHECKING:
@@ -170,8 +171,6 @@ class Levels:
         # If there's no audio, get length in video metadata.
         import av
 
-        av.logging.set_level(av.logging.PANIC)
-
         with av.open(f"{self.src.path}") as cn:
             if len(cn.streams.video) < 1:
                 self.log.error("Could not get media duration")
@@ -227,11 +226,7 @@ class Levels:
         except Exception:
             json_object = {}
 
-        entry = {
-            "type": str(arr.dtype),
-            "arr": arr.tolist(),
-        }
-
+        entry = {"type": str(arr.dtype), "arr": arr.tolist()}
         src_key = f"{self.src.path}"
 
         if src_key in json_object:
@@ -313,44 +308,75 @@ class Levels:
         except re.error as e:
             self.log.error(e)
 
-        sub_file = self.ensure.subtitle(self.src, stream)
-        parser = SubtitleParser(self.tb)
+        import av
+        from av.subtitles.subtitle import AssSubtitle, TextSubtitle
 
-        with open(sub_file, encoding="utf-8") as file:
-            parser.parse(file.read(), "webvtt")
+        try:
+            container = av.open(self.src.path, "r")
+            subtitle_stream = container.streams.subtitles[stream]
+            assert isinstance(subtitle_stream.time_base, Fraction)
+        except Exception as e:
+            self.log.error(e)
 
-        # stackoverflow.com/questions/9662346/python-code-to-remove-html-tags-from-a-string
-        def cleanhtml(raw_html: str) -> str:
-            cleanr = re.compile("<.*?>")
-            return re.sub(cleanr, "", raw_html)
+        # Get the length of the subtitle stream.
+        sub_length = 0
+        for packet in container.demux(subtitle_stream):
+            if packet.pts is None or packet.duration is None:
+                continue
+            for subset in packet.decode():
+                # See definition of `AVSubtitle`
+                # in: https://ffmpeg.org/doxygen/trunk/avcodec_8h_source.html
+                start = float(packet.pts * subtitle_stream.time_base)
+                dur = float(packet.duration * subtitle_stream.time_base)
 
-        if not parser.contents:
-            self.log.error("subtitle has no valid entries")
+                end = round((start + dur) * self.tb)
+                sub_length = max(sub_length, end)
 
-        result = np.zeros((parser.contents[-1].end), dtype=np.bool_)
+        result = np.zeros((sub_length), dtype=np.bool_)
+        del sub_length
 
         count = 0
-        for content in parser.contents:
-            if max_count is not None and count >= max_count:
+        early_exit = False
+        container.seek(0)
+        for packet in container.demux(subtitle_stream):
+            if packet.pts is None or packet.duration is None:
+                continue
+            if early_exit:
                 break
+            for subset in packet.decode():
+                if max_count is not None and count >= max_count:
+                    early_exit = True
+                    break
+
+                start = float(packet.pts * subtitle_stream.time_base)
+                dur = float(packet.duration * subtitle_stream.time_base)
+
+                san_start = round(start * self.tb)
+                san_end = round((start + dur) * self.tb)
 
-            line = cleanhtml(content.after.strip())
-            if line and re.search(pattern, line):
-                result[content.start : content.end] = 1
-                count += 1
+                for sub in subset:
+                    if isinstance(sub, AssSubtitle):
+                        line = convert_ass_to_text(sub.ass.decode(errors="ignore"))
+                    elif isinstance(sub, TextSubtitle):
+                        line = sub.text.decode(errors="ignore")
+                    else:
+                        continue
+
+                    if line and re.search(pattern, line):
+                        result[san_start:san_end] = 1
+                        count += 1
+
+        container.close()
 
         return result
 
     def motion(self, s: int, blur: int, width: int) -> NDArray[np.float64]:
         import av
 
-        av.logging.set_level(av.logging.PANIC)
-
-        mobj = {"stream": s, "width": width, "blur": blur}
-
         if s >= len(self.src.videos):
             raise LevelError(f"motion: video stream '{s}' does not exist.")
 
+        mobj = {"stream": s, "width": width, "blur": blur}
         if (arr := self.read_cache("motion", mobj)) is not None:
             return arr
 

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/edit.py

@@ -15,7 +15,7 @@ from auto_editor.utils.bar import Bar
 from auto_editor.utils.chunks import Chunk, Chunks
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
 from auto_editor.utils.container import Container, container_constructor
-from auto_editor.utils.log import Log, Timer
+from auto_editor.utils.log import Log
 from auto_editor.utils.types import Args
 
 
@@ -152,7 +152,6 @@ def parse_export(export: str, log: Log) -> dict[str, Any]:
 def edit_media(
     paths: list[str], ffmpeg: FFmpeg, args: Args, temp: str, log: Log
 ) -> None:
-    timer = Timer(args.quiet)
     bar = Bar(args.progress)
     tl = None
 
@@ -191,7 +190,6 @@ def edit_media(
 
     if export["export"] == "timeline":
         log.quiet = True
-        timer.quiet = True
 
     if not args.preview:
         log.conwrite("Starting")
@@ -214,16 +212,7 @@ def edit_media(
     ensure = Ensure(ffmpeg, samplerate, temp, log)
 
     if tl is None:
-        # Extract subtitles in their native format.
-        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}"])
-            for s, sub in enumerate(src.subtitles):
-                cmd.extend([os.path.join(temp, f"{s}s.{sub.ext}")])
-            ffmpeg.run(cmd)
-
-        tl = make_timeline(sources, ffmpeg, ensure, args, samplerate, bar, temp, log)
+        tl = make_timeline(sources, ensure, args, samplerate, bar, temp, log)
 
     if export["export"] == "timeline":
         from auto_editor.formats.json import make_json_timeline
@@ -284,7 +273,7 @@ def edit_media(
         apply_later = False
 
         if ctr.allow_subtitle and not args.sn:
-            sub_output = make_new_subtitles(tl, ffmpeg, temp, log)
+            sub_output = make_new_subtitles(tl, ensure, temp)
 
         if ctr.allow_audio:
             audio_output = make_new_audio(tl, ensure, args, ffmpeg, bar, temp, log)
@@ -358,7 +347,7 @@ def edit_media(
     else:
         make_media(tl, output)
 
-    timer.stop()
+    log.stop_timer()
 
     if not args.no_open and export["export"] in ("default", "audio", "clip-sequence"):
         if args.player is None:

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/ffwrapper.py

@@ -192,8 +192,6 @@ class FileInfo:
 def initFileInfo(path: str, log: Log) -> FileInfo:
     import av
 
-    av.logging.set_level(av.logging.PANIC)
-
     try:
         cont = av.open(path, "r")
     except av.error.InvalidDataError:

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/formats/fcp7.py

@@ -188,7 +188,7 @@ def fcp7_read_xml(path: str, ffmpeg: FFmpeg, log: Log) -> v3:
     try:
         tree = ET.parse(path)
     except FileNotFoundError:
-        log.nofile(path)
+        log.error(f"Could not find '{path}'")
 
     root = tree.getroot()
 

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/formats/json.py

@@ -181,11 +181,11 @@ def read_v1(tl: Any, log: Log) -> v3:
     for i, chunk in enumerate(chunks):
         if type(chunk) is not list or len(chunk) != 3:
             log.error(f"Invalid chunk at chunk {i}")
-        if type(chunk[0]) is not int or chunk[0] < 0:
+        if type(chunk[0]) not in (int, float) or chunk[0] < 0:
             log.error(f"Invalid start at chunk {i}")
-        if type(chunk[1]) is not int or chunk[1] <= chunk[0]:
+        if type(chunk[1]) not in (int, float) or chunk[1] <= chunk[0]:
             log.error(f"Invalid end at chunk {i}")
-        if type(chunk[2]) is not float or chunk[2] < 0.0 or chunk[2] > 99999.0:
+        if type(chunk[2]) not in (int, float) or chunk[2] < 0.0 or chunk[2] > 99999.0:
             log.error(f"Invalid speed at chunk {i}")
 
         if i == 0 and chunk[0] != 0:
@@ -194,6 +194,9 @@ def read_v1(tl: Any, log: Log) -> v3:
             log.error(f"Invalid start at chunk {i}")
         last_end = chunk[1]
 
+        if type(chunk[0]) is float or type(chunk[1]) is float or type(chunk[2]) is int:
+            chunks[i] = (int(chunk[0]), int(chunk[1]), float(chunk[2]))
+
     for c in clipify(chunks, src):
         if src.videos:
             if len(vtl) == 0:

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/make_layers.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 from fractions import Fraction
+from math import ceil
 from typing import TYPE_CHECKING, NamedTuple
 
 import numpy as np
 
 from auto_editor.analyze import FileSetup, Levels
-from auto_editor.ffwrapper import FFmpeg, FileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.lang.palet import Lexer, Parser, env, interpret, is_boolarr
 from auto_editor.lib.data_structs import print_str
 from auto_editor.lib.err import MyError
@@ -110,9 +111,34 @@ def run_interpreter_for_edit_option(
     return result
 
 
+def make_sane_timebase(fps: Fraction) -> Fraction:
+    tb = round(fps, 2)
+
+    ntsc_60 = Fraction(60_000, 1001)
+    ntsc = Fraction(30_000, 1001)
+    film_ntsc = Fraction(24_000, 1001)
+
+    if tb == round(ntsc_60, 2):
+        return ntsc_60
+    if tb == round(ntsc, 2):
+        return ntsc
+    if tb == round(film_ntsc, 2):
+        return film_ntsc
+    return tb
+
+
+def parse_time(val: str, arr: NDArray, tb: Fraction) -> int:  # raises: `CoerceError`
+    if val == "start":
+        return 0
+    if val == "end":
+        return len(arr)
+
+    num = time(val, tb)
+    return num if num >= 0 else num + len(arr)
+
+
 def make_timeline(
     sources: list[FileInfo],
-    ffmpeg: FFmpeg,
     ensure: Ensure,
     args: Args,
     sr: int,
@@ -125,14 +151,9 @@ def make_timeline(
     if inp is None:
         tb, res = Fraction(30), (1920, 1080)
     else:
-        tb = round(inp.get_fps() if args.frame_rate is None else args.frame_rate, 2)
-        ntsc = Fraction(30_000, 1001)
-        film_ntsc = Fraction(24_000, 1001)
-        if tb == round(ntsc, 2):
-            tb = ntsc
-        elif tb == round(film_ntsc, 2):
-            tb = film_ntsc
-
+        tb = make_sane_timebase(
+            inp.get_fps() if args.frame_rate is None else args.frame_rate
+        )
         res = inp.get_res() if args.resolution is None else args.resolution
 
     try:
@@ -171,36 +192,21 @@ def make_timeline(
         speed_hash[len(speed_map) - 1] = speed
         return len(speed_map) - 1
 
-    def parse_time(val: str, arr: NDArray) -> int:
-        if val == "start":
-            return 0
-        if val == "end":
-            return len(arr)
-        try:
-            num = time(val, tb)
-            return num if num >= 0 else num + len(arr)
-        except CoerceError as e:
-            log.error(e)
-
-    def mut_set_range(arr: NDArray, _ranges: list[list[str]], index: float) -> None:
-        for _range in _ranges:
-            assert len(_range) == 2
-            pair = [parse_time(val, arr) for val in _range]
-            arr[pair[0] : pair[1]] = index
-
     try:
-        if len(args.cut_out) > 0:
+        for _range in args.cut_out:
             # always cut out even if 'silent_speed' is not 99,999
-            mut_set_range(speed_index, args.cut_out, get_speed_index(99_999))
+            pair = [parse_time(val, speed_index, tb) for val in _range]
+            speed_index[pair[0] : pair[1]] = get_speed_index(99_999)
 
-        if len(args.add_in) > 0:
+        for _range in args.add_in:
             # set to 'video_speed' index
-            mut_set_range(speed_index, args.add_in, 1.0)
+            pair = [parse_time(val, speed_index, tb) for val in _range]
+            speed_index[pair[0] : pair[1]] = 1
 
         for speed_range in args.set_speed_for_range:
-            speed = speed_range[0]
-            _range = list(speed_range[1:])
-            mut_set_range(speed_index, [_range], get_speed_index(speed))
+            start_in = parse_time(speed_range[1], speed_index, tb)
+            end_in = parse_time(speed_range[2], speed_index, tb)
+            speed_index[start_in:end_in] = get_speed_index(speed_range[0])
     except CoerceError as e:
         log.error(e)
 
@@ -226,21 +232,35 @@ def make_timeline(
         chunks.append((src, start, arr_length, speed_map[arr[j]]))
         return chunks
 
+    # Assert timeline is monotonic because non-monotonic timelines are incorrect
+    # here and causes back-seeking (performance issue) in video rendering.
+
+    # We don't properly check monotonicity for multiple sources, so skip those.
+
+    check_monotonic = len(sources) == 1
+    last_i = 0
+
     clips: list[Clip] = []
-    i = 0
     start = 0
+
     for chunk in echunk(speed_index, src_index):
         if chunk[3] != 99999:
-            dur = round((chunk[2] - chunk[1]) / chunk[3])
+            dur = int((chunk[2] - chunk[1]) / chunk[3])
             if dur == 0:
                 continue
 
-            offset = int(chunk[1] / chunk[3])
+            offset = ceil(chunk[1] / chunk[3])
+
+            if check_monotonic:
+                max_end = start + dur - 1
+                this_i = round((offset + max_end - start) * chunk[3])
+                if this_i < last_i:
+                    raise ValueError("not monotonic", sources, this_i, last_i)
+                last_i = this_i
+
+            clips.append(Clip(start, dur, offset, chunk[3], chunk[0]))
 
-            if not (clips and clips[-1].start == round(start)):
-                clips.append(Clip(start, dur, offset, chunk[3], chunk[0]))
             start += dur
-            i += 1
 
     vtl: VSpace = []
     atl: ASpace = []
@@ -276,4 +296,22 @@ def make_timeline(
     else:
         v1_compatiable = None
 
-    return v3(inp, tb, sr, res, args.background, vtl, atl, v1_compatiable)
+    tl = v3(inp, tb, sr, res, args.background, vtl, atl, v1_compatiable)
+
+    # Additional monotonic check, o(n^2) time complexity so disable by default.
+
+    # if len(sources) != 1:
+    #     return tl
+
+    # last_i = 0
+    # for index in range(tl.end):
+    #     for layer in tl.v:
+    #         for lobj in layer:
+    #             if index >= lobj.start and index < (lobj.start + lobj.dur):
+    #                 _i = round((lobj.offset + index - lobj.start) * lobj.speed)
+    #                 if (_i < last_i):
+    #                     print(_i, last_i)
+    #                     raise ValueError("not monotonic")
+    #                 last_i = _i
+
+    return tl

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/output.py

@@ -16,21 +16,22 @@ class Ensure:
     _sr: int
     temp: str
     log: Log
-    labels: list[tuple[FileInfo, int]] = field(default_factory=list)
-    sub_labels: list[tuple[FileInfo, int]] = field(default_factory=list)
+    _audios: list[tuple[FileInfo, int]] = field(default_factory=list)
+    _subtitles: list[tuple[FileInfo, int, str]] = field(default_factory=list)
 
     def audio(self, src: FileInfo, stream: int) -> str:
         try:
-            label = self.labels.index((src, stream))
+            label = self._audios.index((src, stream))
             first_time = False
         except ValueError:
-            self.labels.append((src, stream))
-            label = len(self.labels) - 1
+            self._audios.append((src, stream))
+            label = len(self._audios) - 1
             first_time = True
 
         out_path = os.path.join(self.temp, f"{label:x}.wav")
 
         if first_time:
+            self.log.debug(f"Making external audio: {out_path}")
             self.log.conwrite("Extracting audio")
 
             cmd = ["-i", f"{src.path}", "-map", f"0:a:{stream}"]
@@ -39,18 +40,18 @@ class Ensure:
 
         return out_path
 
-    def subtitle(self, src: FileInfo, stream: int) -> str:
+    def subtitle(self, src: FileInfo, stream: int, ext: str) -> str:
         try:
-            label = self.sub_labels.index((src, stream))
+            self._subtitles.index((src, stream, ext))
             first_time = False
         except ValueError:
-            self.sub_labels.append((src, stream))
-            label = len(self.sub_labels) - 1
+            self._subtitles.append((src, stream, ext))
             first_time = True
 
-        out_path = os.path.join(self.temp, f"{label:x}.vtt")
+        out_path = os.path.join(self.temp, f"{stream}s.{ext}")
 
         if first_time:
+            self.log.debug(f"Making external subtitle: {out_path}")
             self.log.conwrite("Extracting subtitle")
             self._ffmpeg.run(["-i", f"{src.path}", "-map", f"0:s:{stream}", out_path])
 

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/render/subtitle.py

@@ -10,10 +10,9 @@ from auto_editor.utils.func import to_timecode
 if TYPE_CHECKING:
     from fractions import Fraction
 
-    from auto_editor.ffwrapper import FFmpeg
+    from auto_editor.output import Ensure
     from auto_editor.timeline import v3
     from auto_editor.utils.chunks import Chunks
-    from auto_editor.utils.log import Log
 
 
 @dataclass(slots=True)
@@ -122,26 +121,21 @@ class SubtitleParser:
             file.write(self.footer)
 
 
-def make_new_subtitles(tl: v3, ffmpeg: FFmpeg, temp: str, log: Log) -> list[str]:
+def make_new_subtitles(tl: v3, ensure: Ensure, temp: str) -> list[str]:
     if tl.v1 is None:
         return []
 
     new_paths = []
 
     for s, sub in enumerate(tl.v1.source.subtitles):
-        file_path = os.path.join(temp, f"{s}s.{sub.ext}")
         new_path = os.path.join(temp, f"new{s}s.{sub.ext}")
-
         parser = SubtitleParser(tl.tb)
 
-        if sub.codec in parser.supported_codecs:
-            with open(file_path, encoding="utf-8") as file:
-                parser.parse(file.read(), sub.codec)
-        else:
-            convert_path = os.path.join(temp, f"{s}s_convert.vtt")
-            ffmpeg.run(["-i", file_path, convert_path])
-            with open(convert_path, encoding="utf-8") as file:
-                parser.parse(file.read(), "webvtt")
+        ext = sub.ext if sub.codec in parser.supported_codecs else "vtt"
+        file_path = ensure.subtitle(tl.v1.source, s, ext)
+
+        with open(file_path, encoding="utf-8") as file:
+            parser.parse(file.read(), sub.codec)
 
         parser.edit(tl.v1.chunks)
         parser.write(new_path)

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/render/video.py

@@ -27,9 +27,6 @@ if TYPE_CHECKING:
     from auto_editor.utils.types import Args
 
 
-av.logging.set_level(av.logging.PANIC)
-
-
 @dataclass(slots=True)
 class VideoFrame:
     index: int

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/subcommands/info.py

@@ -7,6 +7,7 @@ from typing import Any, Literal, TypedDict
 
 from auto_editor.ffwrapper import initFileInfo
 from auto_editor.lang.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
@@ -68,6 +69,7 @@ class MediaJson(TypedDict, total=False):
     subtitle: list[SubtitleJson]
     container: ContainerJson
     type: Literal["media", "timeline", "unknown"]
+    recommendedTimebase: str
     version: Literal["v1", "v3"]
     clips: int
 
@@ -81,7 +83,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
 
     for file in args.input:
         if not os.path.isfile(file):
-            log.nofile(file)
+            log.error(f"Could not find '{file}'")
 
         ext = os.path.splitext(file)[1]
         if ext == ".json":
@@ -108,6 +110,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
 
         file_info[file] = {
             "type": "media",
+            "recommendedTimebase": "30/1",
             "video": [],
             "audio": [],
             "subtitle": [],
@@ -117,6 +120,12 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
             },
         }
 
+        if src.videos:
+            recTb = make_sane_timebase(src.videos[0].fps)
+            file_info[file]["recommendedTimebase"] = (
+                f"{recTb.numerator}/{recTb.denominator}"
+            )
+
         for track, v in enumerate(src.videos):
             w, h = v.width, v.height
 

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/subcommands/subdump.py

@@ -1,7 +1,7 @@
 import sys
 
 import av
-from av.subtitles.subtitle import SubtitleSet
+from av.subtitles.subtitle import AssSubtitle, TextSubtitle
 
 
 def main(sys_args: list[str] = sys.argv[1:]) -> None:
@@ -10,12 +10,12 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
             for s in range(len(container.streams.subtitles)):
                 print(f"file: {input_file} ({s}:{container.streams.subtitles[s].name})")
                 for packet in container.demux(subtitles=s):
-                    for item in packet.decode():
-                        if type(item) is SubtitleSet and item:
-                            if item[0].type == b"ass":
-                                print(item[0].ass.decode("utf-8"))
-                            elif item[0].type == b"text":
-                                print(item[0].text)
+                    for subset in packet.decode():
+                        for sub in subset.rects:
+                            if isinstance(sub, AssSubtitle):
+                                print(sub.ass.decode("utf-8", errors="ignore"))
+                            elif isinstance(sub, TextSubtitle):
+                                print(sub.text.decode("utf-8", errors="ignore"))
         print("------")
 
 

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/utils/bar.py

@@ -67,9 +67,9 @@ class Bar:
 
         if self.machine:
             index = min(index, self.total)
-            raw = int(self.begin_time + rate)
+            secs_til_eta = round(self.begin_time + rate - time(), 2)
             print(
-                f"{self.title}~{index}~{self.total}~{self.begin_time}~{raw}",
+                f"{self.title}~{index}~{self.total}~{secs_til_eta}",
                 end="\r",
                 flush=True,
             )

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/utils/log.py

@@ -2,36 +2,28 @@ from __future__ import annotations
 
 import sys
 from datetime import timedelta
-from pathlib import Path
 from shutil import get_terminal_size, rmtree
 from time import perf_counter, sleep
 from typing import NoReturn
 
 
-class Timer:
-    __slots__ = ("start_time", "quiet")
-
-    def __init__(self, quiet: bool = False):
-        self.start_time = perf_counter()
-        self.quiet = quiet
-
-    def stop(self) -> None:
-        if not self.quiet:
-            second_len = round(perf_counter() - self.start_time, 2)
-            minute_len = timedelta(seconds=round(second_len))
-
-            sys.stdout.write(f"Finished. took {second_len} seconds ({minute_len})\n")
-
-
 class Log:
-    __slots__ = ("is_debug", "quiet", "temp")
+    __slots__ = ("is_debug", "quiet", "temp", "machine", "start_time", "no_color")
 
     def __init__(
-        self, show_debug: bool = False, quiet: bool = False, temp: str | None = None
+        self,
+        is_debug: bool = False,
+        quiet: bool = False,
+        temp: str | None = None,
+        machine: bool = False,
+        no_color: bool = True,
     ):
-        self.is_debug = show_debug
+        self.is_debug = is_debug
         self.quiet = quiet
         self.temp = temp
+        self.machine = machine
+        self.no_color = no_color
+        self.start_time = 0 if self.quiet or self.machine else perf_counter()
 
     def debug(self, message: object) -> None:
         if self.is_debug:
@@ -55,17 +47,40 @@ class Log:
                 self.debug(f"Failed to delete temp dir:\n{e}")
 
     def conwrite(self, message: str) -> None:
-        if not self.quiet:
+        if self.machine:
+            print(message, flush=True)
+        elif not self.quiet:
             buffer = " " * (get_terminal_size().columns - len(message) - 3)
             sys.stdout.write(f"  {message}{buffer}\r")
 
+    def print(self, message: str) -> None:
+        if not self.quiet:
+            self.conwrite("")
+            sys.stdout.write(f"{message}\n")
+
+    def warning(self, message: str) -> None:
+        if not self.quiet:
+            self.conwrite("")
+            sys.stderr.write(f"Warning! {message}\n")
+
+    def stop_timer(self) -> None:
+        if not self.quiet and not self.machine:
+            second_len = round(perf_counter() - self.start_time, 2)
+            minute_len = timedelta(seconds=round(second_len))
+
+            sys.stdout.write(f"Finished. took {second_len} seconds ({minute_len})\n")
+
     def error(self, message: str | Exception) -> NoReturn:
         if self.is_debug and isinstance(message, Exception):
             self.cleanup()
             raise message
 
         self.conwrite("")
-        sys.stderr.write(f"Error! {message}\n")
+        if self.no_color:
+            sys.stderr.write(f"Error! {message}\n")
+        else:
+            sys.stderr.write(f"\033[31;40mError! {message}\033[0m\n")
+
         self.cleanup()
         from platform import system
 
@@ -78,16 +93,3 @@ class Log:
                 import os
 
                 os._exit(1)
-
-    def nofile(self, path: str | Path) -> NoReturn:
-        self.error(f"Could not find '{path}'")
-
-    def warning(self, message: str) -> None:
-        if not self.quiet:
-            self.conwrite("")
-            sys.stderr.write(f"Warning! {message}\n")
-
-    def print(self, message: str) -> None:
-        if not self.quiet:
-            self.conwrite("")
-            sys.stdout.write(f"{message}\n")

auto_editor-24.25.1/auto_editor/utils/subtitle_tools.py

@@ -0,0 +1,29 @@
+def convert_ass_to_text(ass_text: str) -> str:
+    result = ""
+    comma_count = i = 0
+
+    while comma_count < 8 and i < len(ass_text):
+        if ass_text[i] == ",":
+            comma_count += 1
+        i += 1
+
+    state = False
+    while i < len(ass_text):
+        char = ass_text[i]
+        next_char = "" if i + 1 >= len(ass_text) else ass_text[i + 1]
+
+        if char == "\\" and next_char == "N":
+            result += "\n"
+            i += 2
+            continue
+
+        if not state:
+            if char == "{":
+                state = True
+            else:
+                result += ass_text[i]
+        elif char == "}":
+            state = False
+        i += 1
+
+    return result

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/utils/types.py

@@ -164,8 +164,9 @@ def margin(val: str) -> tuple[str, str]:
     return vals[0], vals[1]
 
 
-def time_range(val: str) -> list[str]:
-    return _comma_coerce("time_range", val, 2)
+def time_range(val: str) -> tuple[str, str]:
+    a = _comma_coerce("time_range", val, 2)
+    return a[0], a[1]
 
 
 def speed_range(val: str) -> tuple[float, str, str]:
@@ -231,8 +232,8 @@ class Args:
     extras: str | None = None
     sn: bool = False
     no_seek: bool = False
-    cut_out: list[list[str]] = field(default_factory=list)
-    add_in: list[list[str]] = field(default_factory=list)
+    cut_out: list[tuple[str, str]] = field(default_factory=list)
+    add_in: list[tuple[str, str]] = field(default_factory=list)
     set_speed_for_range: list[tuple[float, str, str]] = field(default_factory=list)
     frame_rate: Fraction | None = None
     sample_rate: int | None = None

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/validate_input.py

@@ -81,6 +81,6 @@ def valid_input(inputs: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> list
         else:
             if os.path.isdir(my_input):
                 log.error("Input must be a file or a URL, not a directory.")
-            log.nofile(my_input)
+            log.error(f"Could not find '{my_input}'")
 
     return new_inputs

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor/vanparse.py

@@ -160,25 +160,6 @@ def get_option(name: str, options: list[Options]) -> Options | None:
     return None
 
 
-def parse_value(option: Options | Required, val: str | None) -> Any:
-    if val is None and option.nargs == 1:
-        Log().error(f"{option.names[0]} needs argument.")
-
-    try:
-        value = option.type(val)
-    except CoerceError as e:
-        Log().error(e)
-
-    if option.choices is not None and value not in option.choices:
-        choices = ", ".join(option.choices)
-
-        Log().error(
-            f"{value} is not a choice for {option.names[0]}\nchoices are:\n  {choices}"
-        )
-
-    return value
-
-
 class ArgumentParser:
     def __init__(self, program_name: str | None):
         self.program_name = program_name
@@ -201,6 +182,7 @@ class ArgumentParser:
         self,
         ns_obj: type[T],
         sys_args: list[str],
+        log_: Log | None = None,
         macros: list[tuple[set[str], list[str]]] | None = None,
     ) -> T:
         if not sys_args and self.program_name is not None:
@@ -219,9 +201,26 @@ class ArgumentParser:
             del _macros
         del macros
 
+        log = Log() if log_ is None else log_
         ns = ns_obj()
         option_names: list[str] = []
 
+        def parse_value(option: Options | Required, val: str | None) -> Any:
+            if val is None and option.nargs == 1:
+                log.error(f"{option.names[0]} needs argument.")
+
+            try:
+                value = option.type(val)
+            except CoerceError as e:
+                log.error(e)
+
+            if option.choices is not None and value not in option.choices:
+                log.error(
+                    f"{value} is not a choice for {option.names[0]}\n"
+                    f"choices are:\n  {', '.join(option.choices)}"
+                )
+            return value
+
         program_name = self.program_name
         requireds = self.requireds
         options = self.options
@@ -256,7 +255,7 @@ class ArgumentParser:
                         val = oplist_coerce(arg)
                         ns.__setattr__(oplist_name, getattr(ns, oplist_name) + [val])
                     except (CoerceError, ValueError) as e:
-                        Log().error(e)
+                        log.error(e)
                 elif requireds and not arg.startswith("--"):
                     if requireds[0].nargs == 1:
                         ns.__setattr__(req_list_name, parse_value(requireds[0], arg))
@@ -268,19 +267,19 @@ class ArgumentParser:
 
                     # 'Did you mean' message might appear that options need a comma.
                     if arg.replace(",", "") in option_names:
-                        Log().error(f"Option '{arg}' has an unnecessary comma.")
+                        log.error(f"Option '{arg}' has an unnecessary comma.")
 
                     close_matches = difflib.get_close_matches(arg, option_names)
                     if close_matches:
-                        Log().error(
+                        log.error(
                             f"Unknown {label}: {arg}\n\n    Did you mean:\n        "
                             + ", ".join(close_matches)
                         )
-                    Log().error(f"Unknown {label}: {arg}")
+                    log.error(f"Unknown {label}: {arg}")
             else:
                 if option.nargs != "*":
                     if option in used_options:
-                        Log().error(
+                        log.error(
                             f"Option {option.names[0]} may not be used more than once."
                         )
                     used_options.append(option)

{auto_editor-24.19.1 → auto_editor-24.25.1/auto_editor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 24.19.1
+Version: 24.25.1
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense
@@ -12,7 +12,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.22.0
-Requires-Dist: pyav==12.0.5
+Requires-Dist: pyav==12.1.0
 Requires-Dist: ae-ffmpeg==1.2.*
 
 <p align="center"><img src="https://auto-editor.com/img/auto-editor-banner.webp" title="Auto-Editor" width="700"></p>
@@ -105,16 +105,14 @@ Auto-Editor can also export to:
 - Individual media clips with `--export clip-sequence`
 
 ### Naming Timelines
-By default, auto-editor will name the timeline to "Auto-Editor Media Group" if the export supports naming.
+Some editors support naming timelines. By default, auto-editor will use the name "Auto-Editor Media Group". For `premiere` `resolve` and `final-cut-pro` export options, you can change the name with the following syntax.
 
 ```
+# for POSIX shells
 auto-editor example.mp4 --export 'premiere:name="Your name here"'
 
-auto-editor example.mp4 --export 'resolve:name="Your name here"'
-
-auto-editor example.mp4 --export 'final-cut-pro:name="Your name here"'
-
-# No other export options support naming
+# for Powershell
+auto-editor example.mp4 --export 'premiere:name=""Your name here""'
 ```
 
 ### Split by Clip

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor.egg-info/SOURCES.txt

@@ -57,4 +57,5 @@ auto_editor/utils/container.py
 auto_editor/utils/encoder.py
 auto_editor/utils/func.py
 auto_editor/utils/log.py
+auto_editor/utils/subtitle_tools.py
 auto_editor/utils/types.py

{auto_editor-24.19.1 → auto_editor-24.25.1}/auto_editor.egg-info/requires.txt

@@ -1,3 +1,3 @@
 numpy>=1.22.0
-pyav==12.0.5
+pyav==12.1.0
 ae-ffmpeg==1.2.*

{auto_editor-24.19.1 → auto_editor-24.25.1}/pyproject.toml

@@ -10,7 +10,7 @@ authors = [{ name = "WyattBlue", email = "wyattblue@auto-editor.com" }]
 requires-python = ">=3.10"
 dependencies = [
     "numpy>=1.22.0",
-    "pyav==12.0.5",
+    "pyav==12.1.0",
     "ae-ffmpeg==1.2.*",
 ]
 keywords = [

auto_editor-24.19.1/auto_editor/__init__.py

@@ -1,2 +0,0 @@
-__version__ = "24.19.1"
-version = "24w19a"