auto-editor 26.0.1__py3-none-any.whl → 26.1.1__py3-none-any.whl

auto_editor/__init__.py

@@ -1 +1 @@
-__version__ = "26.0.1"
+__version__ = "26.1.1"

auto_editor/__main__.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 
+import platform as plat
 import re
 import sys
 from os import environ
@@ -7,8 +8,6 @@ from os.path import exists, isdir, isfile, lexists, splitext
 from subprocess import run
 
 import auto_editor
-from auto_editor.edit import edit_media
-from auto_editor.ffwrapper import FFmpeg
 from auto_editor.utils.func import get_stdout
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import (
@@ -34,13 +33,12 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         "-m",
         type=margin,
         metavar="LENGTH",
-        help='Set sections near "loud" as "loud" too if section is less than LENGTH away.',
+        help='Set sections near "loud" as "loud" too if section is less than LENGTH away',
     )
     parser.add_argument(
-        "--edit-based-on",
         "--edit",
         metavar="METHOD",
-        help="Decide which method to use when making edits",
+        help="Set an expression which determines how to make auto edits",
     )
     parser.add_argument(
         "--silent-speed",
@@ -148,7 +146,7 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         "--output",
         "-o",
         metavar="FILE",
-        help="Set the name/path of the new output file.",
+        help="Set the name/path of the new output file",
     )
     parser.add_argument(
         "--player", "-p", metavar="CMD", help="Set player to open output media files"
@@ -161,11 +159,6 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         metavar="PATH",
         help="Set where the temporary directory is located",
     )
-    parser.add_argument(
-        "--ffmpeg-location",
-        metavar="PATH",
-        help="Set a custom path to the ffmpeg location",
-    )
     parser.add_text("Display Options:")
     parser.add_argument(
         "--progress",
@@ -241,11 +234,6 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         flag=True,
         help="Disable the inclusion of data streams in the output file",
     )
-    parser.add_argument(
-        "--extras",
-        metavar="CMD",
-        help="Add extra options for ffmpeg. Must be in quotes",
-    )
     parser.add_argument(
         "--config", flag=True, help="When set, look for `config.pal` and run it"
     )
@@ -256,7 +244,7 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
     return parser
 
 
-def download_video(my_input: str, args: Args, ffmpeg: FFmpeg, log: Log) -> str:
+def download_video(my_input: str, args: Args, log: Log) -> str:
     log.conwrite("Downloading video...")
 
     def get_domain(url: str) -> str:
@@ -272,18 +260,15 @@ def download_video(my_input: str, args: Args, ffmpeg: FFmpeg, log: Log) -> str:
     else:
         output_format = args.output_format
 
-    yt_dlp_path = args.yt_dlp_location
-
-    cmd = ["--ffmpeg-location", ffmpeg.get_path("yt-dlp", log)]
-
+    cmd = []
     if download_format is not None:
         cmd.extend(["-f", download_format])
 
     cmd.extend(["-o", output_format, my_input])
-
     if args.yt_dlp_extras is not None:
         cmd.extend(args.yt_dlp_extras.split(" "))
 
+    yt_dlp_path = args.yt_dlp_location
     try:
         location = get_stdout(
             [yt_dlp_path, "--get-filename", "--no-warnings"] + cmd
@@ -301,7 +286,16 @@ def download_video(my_input: str, args: Args, ffmpeg: FFmpeg, log: Log) -> str:
 
 
 def main() -> None:
-    subcommands = ("test", "info", "levels", "subdump", "desc", "repl", "palet")
+    subcommands = (
+        "test",
+        "info",
+        "levels",
+        "subdump",
+        "desc",
+        "repl",
+        "palet",
+        "cache",
+    )
 
     if len(sys.argv) > 1 and sys.argv[1] in subcommands:
         obj = __import__(
@@ -326,6 +320,7 @@ def main() -> None:
             ({"--export-as-json"}, ["--export", "json"]),
             ({"--export-as-clip-sequence", "-excs"}, ["--export", "clip-sequence"]),
             ({"--keep-tracks-seperate"}, ["--keep-tracks-separate"]),
+            ({"--edit-based-on"}, ["--edit"]),
         ],
     )
 
@@ -334,15 +329,17 @@ def main() -> None:
         return
 
     if args.debug and not args.input:
-        import platform as plat
+        print(f"OS: {plat.system()} {plat.release()} {plat.machine().lower()}")
+        print(f"Python: {plat.python_version()}")
 
-        import av
+        try:
+            import av
 
-        license = av._core.library_meta["libavcodec"]["license"]
+            license = av._core.library_meta["libavcodec"]["license"]
+            print(f"PyAV: {av.__version__} ({license})")
+        except (ModuleNotFoundError, ImportError):
+            print("PyAV: error")
 
-        print(f"OS: {plat.system()} {plat.release()} {plat.machine().lower()}")
-        print(f"Python: {plat.python_version()}")
-        print(f"PyAV: {av.__version__} ({license})")
         print(f"Auto-Editor: {auto_editor.__version__}")
         return
 
@@ -352,11 +349,10 @@ def main() -> None:
     is_machine = args.progress == "machine"
     log = Log(args.debug, args.quiet, args.temp_dir, is_machine, no_color)
 
-    ffmpeg = FFmpeg(args.ffmpeg_location)
     paths = []
     for my_input in args.input:
         if my_input.startswith("http://") or my_input.startswith("https://"):
-            paths.append(download_video(my_input, args, ffmpeg, log))
+            paths.append(download_video(my_input, args, log))
         else:
             if not splitext(my_input)[1]:
                 if isdir(my_input):
@@ -369,8 +365,10 @@ def main() -> None:
                     log.error(f"Option/Input file doesn't exist: {my_input}")
             paths.append(my_input)
 
+    from auto_editor.edit import edit_media
+
     try:
-        edit_media(paths, ffmpeg, args, log)
+        edit_media(paths, args, log)
     except KeyboardInterrupt:
         log.error("Keyboard Interrupt")
     log.cleanup()

auto_editor/analyze.py

@@ -4,6 +4,7 @@ import os
 import re
 from dataclasses import dataclass
 from fractions import Fraction
+from hashlib import sha1
 from math import ceil
 from tempfile import gettempdir
 from typing import TYPE_CHECKING
@@ -27,6 +28,9 @@ if TYPE_CHECKING:
     from auto_editor.utils.log import Log
 
 
+__all__ = ("LevelError", "Levels", "iter_audio", "iter_motion")
+
+
 class LevelError(Exception):
     pass
 
@@ -69,45 +73,39 @@ def mut_remove_large(
             active = False
 
 
-def iter_audio(src, tb: Fraction, stream: int = 0) -> Iterator[np.float32]:
+def iter_audio(audio_stream: av.AudioStream, tb: Fraction) -> Iterator[np.float32]:
     fifo = AudioFifo()
-    try:
-        container = av.open(src.path, "r")
-        audio_stream = container.streams.audio[stream]
-        sample_rate = audio_stream.rate
+    sr = audio_stream.rate
 
-        exact_size = (1 / tb) * sample_rate
-        accumulated_error = 0
+    exact_size = (1 / tb) * sr
+    accumulated_error = Fraction(0)
 
-        # Resample so that audio data is between [-1, 1]
-        resampler = av.AudioResampler(
-            av.AudioFormat("flt"), audio_stream.layout, sample_rate
-        )
+    # Resample so that audio data is between [-1, 1]
+    resampler = av.AudioResampler(av.AudioFormat("flt"), audio_stream.layout, sr)
 
-        for frame in container.decode(audio=stream):
-            frame.pts = None  # Skip time checks
+    container = audio_stream.container
+    assert isinstance(container, av.container.InputContainer)
 
-            for reframe in resampler.resample(frame):
-                fifo.write(reframe)
+    for frame in container.decode(audio_stream):
+        frame.pts = None  # Skip time checks
 
-            while fifo.samples >= ceil(exact_size):
-                size_with_error = exact_size + accumulated_error
-                current_size = round(size_with_error)
-                accumulated_error = size_with_error - current_size
+        for reframe in resampler.resample(frame):
+            fifo.write(reframe)
 
-                audio_chunk = fifo.read(current_size)
-                assert audio_chunk is not None
-                arr = audio_chunk.to_ndarray().flatten()
-                yield np.max(np.abs(arr))
+        while fifo.samples >= ceil(exact_size):
+            size_with_error = exact_size + accumulated_error
+            current_size = round(size_with_error)
+            accumulated_error = size_with_error - current_size
 
-    finally:
-        container.close()
+            audio_chunk = fifo.read(current_size)
+            assert audio_chunk is not None
+            arr = audio_chunk.to_ndarray().flatten()
+            yield np.max(np.abs(arr))
 
 
-def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[np.float32]:
-    container = av.open(src.path, "r")
-
-    video = container.streams.video[stream]
+def iter_motion(
+    video: av.VideoStream, tb: Fraction, blur: int, width: int
+) -> Iterator[np.float32]:
     video.thread_type = "AUTO"
 
     prev_frame = None
@@ -125,6 +123,9 @@ def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[np.floa
         graph.add("buffersink"),
     ).configure()
 
+    container = video.container
+    assert isinstance(container, av.container.InputContainer)
+
     for unframe in container.decode(video):
         if unframe.pts is None:
             continue
@@ -151,13 +152,13 @@ def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[np.floa
         prev_frame = current_frame
         prev_index = index
 
-    container.close()
-
 
 def obj_tag(path: Path, kind: str, tb: Fraction, obj: Sequence[object]) -> str:
     mod_time = int(path.stat().st_mtime)
-    key = f"{path.name}:{mod_time:x}:{kind}:{tb}:"
-    return key + ",".join(f"{v}" for v in obj)
+    key = f"{path}:{mod_time:x}:{tb}:" + ",".join(f"{v}" for v in obj)
+    part1 = sha1(key.encode()).hexdigest()[:16]
+
+    return f"{part1}{kind}"
 
 
 @dataclass(slots=True)
@@ -175,7 +176,11 @@ class Levels:
             if (arr := self.read_cache("audio", (0,))) is not None:
                 return len(arr)
 
-            result = sum(1 for _ in iter_audio(self.src, self.tb, 0))
+            with av.open(self.src.path, "r") as container:
+                audio_stream = container.streams.audio[0]
+                self.log.experimental(audio_stream.codec)
+                result = sum(1 for _ in iter_audio(audio_stream, self.tb))
+
             self.log.debug(f"Audio Length: {result}")
             return result
 
@@ -204,31 +209,47 @@ class Levels:
         if self.no_cache:
             return None
 
-        workfile = os.path.join(gettempdir(), f"ae-{__version__}", "cache.npz")
+        key = obj_tag(self.src.path, kind, self.tb, obj)
+        cache_file = os.path.join(gettempdir(), f"ae-{__version__}", f"{key}.npz")
 
         try:
-            npzfile = np.load(workfile, allow_pickle=False)
+            with np.load(cache_file, allow_pickle=False) as npzfile:
+                return npzfile["data"]
         except Exception as e:
             self.log.debug(e)
             return None
 
-        key = obj_tag(self.src.path, kind, self.tb, obj)
-        if key not in npzfile.files:
-            return None
-
-        self.log.debug("Using cache")
-        return npzfile[key]
-
     def cache(self, arr: np.ndarray, kind: str, obj: Sequence[object]) -> np.ndarray:
         if self.no_cache:
             return arr
 
-        workdur = os.path.join(gettempdir(), f"ae-{__version__}")
-        if not os.path.exists(workdur):
-            os.mkdir(workdur)
+        workdir = os.path.join(gettempdir(), f"ae-{__version__}")
+        if not os.path.exists(workdir):
+            os.mkdir(workdir)
 
         key = obj_tag(self.src.path, kind, self.tb, obj)
-        np.savez(os.path.join(workdur, "cache.npz"), **{key: arr})
+        cache_file = os.path.join(workdir, f"{key}.npz")
+
+        try:
+            np.savez(cache_file, data=arr)
+        except Exception as e:
+            self.log.warning(f"Cache write failed: {e}")
+
+        cache_entries = []
+        with os.scandir(workdir) as entries:
+            for entry in entries:
+                if entry.name.endswith(".npz"):
+                    cache_entries.append((entry.path, entry.stat().st_mtime))
+
+        if len(cache_entries) > 10:
+            # Sort by modification time, oldest first
+            cache_entries.sort(key=lambda x: x[1])
+            # Remove oldest files until we're back to 10
+            for filepath, _ in cache_entries[:-10]:
+                try:
+                    os.remove(filepath)
+                except OSError:
+                    pass
 
         return arr
 
@@ -239,30 +260,37 @@ class Levels:
         if (arr := self.read_cache("audio", (stream,))) is not None:
             return arr
 
-        with av.open(self.src.path, "r") as container:
-            audio = container.streams.audio[stream]
-            if audio.duration is not None and audio.time_base is not None:
-                inaccurate_dur = int(audio.duration * audio.time_base * self.tb)
-            elif container.duration is not None:
-                inaccurate_dur = int(container.duration / av.time_base * self.tb)
-            else:
-                inaccurate_dur = 1024
+        container = av.open(self.src.path, "r")
+        audio = container.streams.audio[stream]
+
+        if audio.codec.experimental:
+            self.log.error(f"`{audio.codec.name}` is an experimental codec")
+
+        if audio.duration is not None and audio.time_base is not None:
+            inaccurate_dur = int(audio.duration * audio.time_base * self.tb)
+        elif container.duration is not None:
+            inaccurate_dur = int(container.duration / av.time_base * self.tb)
+        else:
+            inaccurate_dur = 1024
 
         bar = self.bar
         bar.start(inaccurate_dur, "Analyzing audio volume")
 
-        result = np.zeros((inaccurate_dur), dtype=np.float32)
+        result: NDArray[np.float32] = np.zeros(inaccurate_dur, dtype=np.float32)
         index = 0
-        for value in iter_audio(self.src, self.tb, stream):
+
+        for value in iter_audio(audio, self.tb):
             if index > len(result) - 1:
                 result = np.concatenate(
-                    (result, np.zeros((len(result)), dtype=np.float32))
+                    (result, np.zeros(len(result), dtype=np.float32))
                 )
+
             result[index] = value
             bar.tick(index)
             index += 1
 
         bar.end()
+        assert len(result) > 0
         return self.cache(result[:index], "audio", (stream,))
 
     def motion(self, stream: int, blur: int, width: int) -> NDArray[np.float32]:
@@ -273,23 +301,28 @@ class Levels:
         if (arr := self.read_cache("motion", mobj)) is not None:
             return arr
 
-        with av.open(self.src.path, "r") as container:
-            video = container.streams.video[stream]
-            inaccurate_dur = (
-                1024
-                if video.duration is None or video.time_base is None
-                else int(video.duration * video.time_base * self.tb)
-            )
+        container = av.open(self.src.path, "r")
+        video = container.streams.video[stream]
+
+        if video.codec.experimental:
+            self.log.experimental(video.codec)
+
+        inaccurate_dur = (
+            1024
+            if video.duration is None or video.time_base is None
+            else int(video.duration * video.time_base * self.tb)
+        )
 
         bar = self.bar
         bar.start(inaccurate_dur, "Analyzing motion")
 
-        result = np.zeros((inaccurate_dur), dtype=np.float32)
+        result: NDArray[np.float32] = np.zeros(inaccurate_dur, dtype=np.float32)
         index = 0
-        for value in iter_motion(self.src, self.tb, stream, blur, width):
+
+        for value in iter_motion(video, self.tb, blur, width):
             if index > len(result) - 1:
                 result = np.concatenate(
-                    (result, np.zeros((len(result)), dtype=np.float32))
+                    (result, np.zeros(len(result), dtype=np.float32))
                 )
             result[index] = value
             bar.tick(index)

auto_editor/edit.py

@@ -10,7 +10,7 @@ from typing import Any
 import av
 from av import AudioResampler
 
-from auto_editor.ffwrapper import FFmpeg, FileInfo, initFileInfo
+from auto_editor.ffwrapper import FileInfo, initFileInfo
 from auto_editor.lib.contracts import is_int, is_str
 from auto_editor.make_layers import clipify, make_av, make_timeline
 from auto_editor.output import Ensure, parse_bitrate
@@ -160,7 +160,7 @@ def parse_export(export: str, log: Log) -> dict[str, Any]:
     log.error(f"'{name}': Export must be [{', '.join([s for s in parsing.keys()])}]")
 
 
-def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
+def edit_media(paths: list[str], args: Args, log: Log) -> None:
     bar = initBar(args.progress)
     tl = None
 
@@ -294,7 +294,7 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
 
         if ctr.default_aud != "none":
             ensure = Ensure(bar, samplerate, log)
-            audio_paths = make_new_audio(tl, ctr, ensure, args, ffmpeg, bar, log)
+            audio_paths = make_new_audio(tl, ctr, ensure, args, bar, log)
         else:
             audio_paths = []
 
@@ -343,8 +343,8 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
         for i, sub_path in enumerate(sub_paths):
             subtitle_input = av.open(sub_path)
             subtitle_inputs.append(subtitle_input)
-            subtitle_stream = output.add_stream(
-                template=subtitle_input.streams.subtitles[0]
+            subtitle_stream = output.add_stream_from_template(
+                subtitle_input.streams.subtitles[0]
             )
             if i < len(src.subtitles) and src.subtitles[i].lang is not None:
                 subtitle_stream.metadata["language"] = src.subtitles[i].lang  # type: ignore

auto_editor/ffwrapper.py

@@ -3,40 +3,12 @@ from __future__ import annotations
 from dataclasses import dataclass
 from fractions import Fraction
 from pathlib import Path
-from shutil import which
-from subprocess import PIPE, Popen
 
 import av
 
 from auto_editor.utils.log import Log
 
 
-def _get_ffmpeg(reason: str, ffloc: str | None, log: Log) -> str:
-    program = "ffmpeg" if ffloc is None else ffloc
-    if (path := which(program)) is None:
-        log.error(f"{reason} needs ffmpeg cli but couldn't find ffmpeg on PATH.")
-    return path
-
-
-@dataclass(slots=True)
-class FFmpeg:
-    ffmpeg_location: str | None
-    path: str | None = None
-
-    def get_path(self, reason: str, log: Log) -> str:
-        if self.path is not None:
-            return self.path
-
-        self.path = _get_ffmpeg(reason, self.ffmpeg_location, log)
-        return self.path
-
-    def Popen(self, reason: str, cmd: list[str], log: Log) -> Popen:
-        if self.path is None:
-            self.path = _get_ffmpeg(reason, self.ffmpeg_location, log)
-
-        return Popen([self.path] + cmd, stdout=PIPE, stderr=PIPE)
-
-
 def mux(input: Path, output: Path, stream: int) -> None:
     input_container = av.open(input, "r")
     output_container = av.open(output, "w")

auto_editor/help.py

@@ -24,10 +24,23 @@ example:
 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": """
+        "--edit": """
 Evaluates a palet expression that returns a bool-array?. The array is then used for
 editing.
 
+Examples:
+  --edit audio
+  --edit audio:0.03           ;  Change the threshold. Can be a value between 0-1.
+  --edit audio:3%             ;  You can also use the `%` macro.
+  --edit audio:0.03,stream=0  ;  Only consider the first stream for editing.
+  --edit audio:stream=1,threshold=0.05  ; Here's how you use keyword arguments.
+  --edit (or audio:0.04,stream=0 audio:0.08,stream=1)  ; Consider both streams for editing (merge with logical or), but with different thresholds.
+  --edit motion
+  --edit motion:0.02,blur=3
+  --edit (or audio:0.04 motion:0.02,blur=3)
+  --edit none
+  --edit all/e
+
 Editing Methods:
  - audio  ; Audio silence/loudness detection
     - threshold threshold? : 4%
@@ -52,19 +65,6 @@ Editing Methods:
 
  - none   ; Do not modify the media in anyway; mark all sections as "loud" (1).
  - all/e  ; Cut out everything out; mark all sections as "silent" (0).
-
-
-Command-line Examples:
-  --edit audio
-  --edit audio:threshold=4%
-  --edit audio:threshold=0.03
-  --edit audio:stream=1
-  --edit (or audio:4%,stream=0 audio:8%,stream=1) ; `threshold` is first
-  --edit motion
-  --edit motion:threshold=2%,blur=3
-  --edit (or audio:4% motion:2%,blur=3)
-  --edit none
-  --edit all/e
 """.strip(),
         "--export": """
 This option controls how timelines are exported.
@@ -144,8 +144,6 @@ If not set, tempdir will be set with Python's tempfile module
 The directory doesn't have to exist beforehand, however, the root path must be valid.
 Beware that the temp directory can get quite big.
 """.strip(),
-        "--ffmpeg-location": "This takes precedence over `--my-ffmpeg`.",
-        "--my-ffmpeg": "This is equivalent to `--ffmpeg-location ffmpeg`.",
         "--audio-bitrate": """
 `--audio-bitrate` sets the target bitrate for the audio encoder.
 By default, the value is `auto` (let the encoder decide).

auto_editor/make_layers.py

@@ -139,7 +139,7 @@ def make_timeline(
 
     for i, src in enumerate(sources):
         try:
-            parser = Parser(Lexer("`--edit`", args.edit_based_on))
+            parser = Parser(Lexer("`--edit`", args.edit))
             if log.is_debug:
                 log.debug(f"edit: {parser}")
 
@@ -169,6 +169,8 @@ def make_timeline(
         has_loud = concat((has_loud, result))
         src_index = concat((src_index, np.full(len(result), i, dtype=np.int32)))
 
+    assert len(has_loud) > 0
+
     # Setup for handling custom speeds
     speed_index = has_loud.astype(np.uint)
     speed_map = [args.silent_speed, args.video_speed]

auto_editor/render/audio.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 import io
 from pathlib import Path
-from platform import system
 
 import av
 import numpy as np
+from av.filter.loudnorm import stats
 
-from auto_editor.ffwrapper import FFmpeg, FileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.lang.json import Lexer, Parser
 from auto_editor.lang.palet import env
 from auto_editor.lib.contracts import andc, between_c, is_int_or_float
@@ -56,25 +56,11 @@ def parse_norm(norm: str, log: Log) -> dict | None:
         log.error(e)
 
 
-def parse_ebu_bytes(norm: dict, stderr: bytes, log: Log) -> tuple[str, str]:
-    start = end = 0
-    lines = stderr.splitlines()
-
-    for index, line in enumerate(lines):
-        if line.startswith(b"[Parsed_loudnorm"):
-            start = index + 1
-            continue
-        if start != 0 and line.startswith(b"}"):
-            end = index + 1
-            break
-
-    if start == 0 or end == 0:
-        log.error(f"Invalid loudnorm stats.\n{stderr!r}")
-
+def parse_ebu_bytes(norm: dict, stat: bytes, log: Log) -> tuple[str, str]:
     try:
-        parsed = Parser(Lexer("loudnorm", b"\n".join(lines[start:end]))).expr()
+        parsed = Parser(Lexer("loudnorm", stat)).expr()
     except MyError:
-        log.error(f"Invalid loudnorm stats.\n{start=},{end=}\n{stderr!r}")
+        log.error(f"Invalid loudnorm stats.\n{stat!r}")
 
     for key in ("input_i", "input_tp", "input_lra", "input_thresh", "target_offset"):
         val = float(parsed[key])
@@ -101,29 +87,17 @@ def parse_ebu_bytes(norm: dict, stderr: bytes, log: Log) -> tuple[str, str]:
 
 
 def apply_audio_normalization(
-    ffmpeg: FFmpeg, norm: dict, pre_master: Path, path: Path, log: Log
+    norm: dict, pre_master: Path, path: Path, log: Log
 ) -> None:
     if norm["tag"] == "ebu":
         first_pass = (
-            f"loudnorm=i={norm['i']}:lra={norm['lra']}:tp={norm['tp']}:"
-            f"offset={norm['gain']}:print_format=json"
+            f"i={norm['i']}:lra={norm['lra']}:tp={norm['tp']}:" f"offset={norm['gain']}"
         )
         log.debug(f"audio norm first pass: {first_pass}")
-        file_null = "NUL" if system() in ("Windows", "cli") else "/dev/null"
-        cmd = [
-            "-hide_banner",
-            "-i",
-            f"{pre_master}",
-            "-af",
-            first_pass,
-            "-vn",
-            "-sn",
-            "-f",
-            "null",
-            file_null,
-        ]
-        stderr = ffmpeg.Popen("EBU", cmd, log).communicate()[1]
-        name, filter_args = parse_ebu_bytes(norm, stderr, log)
+        with av.open(f"{pre_master}") as container:
+            stats_ = stats(first_pass, container.streams.audio[0])
+
+        name, filter_args = parse_ebu_bytes(norm, stats_, log)
     else:
         assert "t" in norm
 
@@ -310,13 +284,7 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
 
 
 def make_new_audio(
-    tl: v3,
-    ctr: Container,
-    ensure: Ensure,
-    args: Args,
-    ffmpeg: FFmpeg,
-    bar: Bar,
-    log: Log,
+    tl: v3, ctr: Container, ensure: Ensure, args: Args, bar: Bar, log: Log
 ) -> list[str]:
     sr = tl.sr
     tb = tl.tb
@@ -390,7 +358,7 @@ def make_new_audio(
                 with open(pre_master, "wb") as fid:
                     write(fid, sr, arr)
 
-                apply_audio_normalization(ffmpeg, norm, pre_master, path, log)
+                apply_audio_normalization(norm, pre_master, path, log)
 
         bar.end()
 

auto_editor/render/subtitle.py

@@ -162,7 +162,7 @@ def _ensure(input_: Input, format: str, stream: int) -> str:
     output = av.open(output_bytes, "w", format=format)
 
     in_stream = input_.streams.subtitles[stream]
-    out_stream = output.add_stream(template=in_stream)
+    out_stream = output.add_stream_from_template(in_stream)
 
     for packet in input_.demux(in_stream):
         if packet.dts is None:

auto_editor/subcommands/cache.py

@@ -0,0 +1,69 @@
+import glob
+import os
+import sys
+from shutil import rmtree
+from tempfile import gettempdir
+
+import numpy as np
+
+from auto_editor import __version__
+
+
+def main(sys_args: list[str] = sys.argv[1:]) -> None:
+    cache_dir = os.path.join(gettempdir(), f"ae-{__version__}")
+
+    if sys_args and sys_args[0] in ("clean", "clear"):
+        rmtree(cache_dir, ignore_errors=True)
+        return
+
+    if not os.path.exists(cache_dir):
+        print("Empty cache")
+        return
+
+    cache_files = glob.glob(os.path.join(cache_dir, "*.npz"))
+    if not cache_files:
+        print("Empty cache")
+        return
+
+    def format_bytes(size: float) -> str:
+        for unit in ("B", "KiB", "MiB", "GiB", "TiB"):
+            if size < 1024:
+                return f"{size:.2f} {unit}"
+            size /= 1024
+        return f"{size:.2f} PiB"
+
+    GRAY = "\033[90m"
+    GREEN = "\033[32m"
+    BLUE = "\033[34m"
+    YELLOW = "\033[33m"
+    RESET = "\033[0m"
+
+    total_size = 0
+    for cache_file in cache_files:
+        try:
+            with np.load(cache_file, allow_pickle=False) as npzfile:
+                array = npzfile["data"]
+                key = os.path.basename(cache_file)[:-4]  # Remove .npz extension
+
+                hash_part = key[:16]
+                rest_part = key[16:]
+
+                size = array.nbytes
+                total_size += size
+                size_str = format_bytes(size)
+                size_num, size_unit = size_str.rsplit(" ", 1)
+
+                print(
+                    f"{YELLOW}entry: {GRAY}{hash_part}{RESET}{rest_part}  "
+                    f"{YELLOW}size: {GREEN}{size_num} {BLUE}{size_unit}{RESET}"
+                )
+        except Exception as e:
+            print(f"Error reading {cache_file}: {e}")
+
+    total_str = format_bytes(total_size)
+    total_num, total_unit = total_str.rsplit(" ", 1)
+    print(f"\n{YELLOW}total cache size: {GREEN}{total_num} {BLUE}{total_unit}{RESET}")
+
+
+if __name__ == "__main__":
+    main()

auto_editor/subcommands/info.py

@@ -163,6 +163,8 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
             file_info[file]["subtitle"].append(sub)
 
     if args.json:
+        if sys.platform == "win32":
+            sys.stdout.reconfigure(encoding="utf-8")
         dump(file_info, sys.stdout, indent=4)
         return
 

auto_editor/subcommands/levels.py

@@ -5,9 +5,10 @@ from dataclasses import dataclass, field
 from fractions import Fraction
 from typing import TYPE_CHECKING
 
+import av
 import numpy as np
 
-from auto_editor.analyze import LevelError, Levels, iter_audio, iter_motion
+from auto_editor.analyze import *
 from auto_editor.ffwrapper import initFileInfo
 from auto_editor.lang.palet import env
 from auto_editor.lib.contracts import is_bool, is_nat, is_nat1, is_str, is_void, orc
@@ -130,9 +131,19 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
         levels = Levels(src, tb, bar, False, log, strict=True)
         try:
             if method == "audio":
-                print_arr_gen(iter_audio(src, tb, **obj))
+                container = av.open(src.path, "r")
+                audio_stream = container.streams.audio[obj["stream"]]
+                log.experimental(audio_stream.codec)
+                print_arr_gen(iter_audio(audio_stream, tb))
+                container.close()
+
             elif method == "motion":
-                print_arr_gen(iter_motion(src, tb, **obj))
+                container = av.open(src.path, "r")
+                video_stream = container.streams.video[obj["stream"]]
+                log.experimental(video_stream.codec)
+                print_arr_gen(iter_motion(video_stream, tb, obj["blur"], obj["width"]))
+                container.close()
+
             elif method == "subtitle":
                 print_arr(levels.subtitle(**obj))
             elif method == "none":

auto_editor/utils/log.py

@@ -5,7 +5,10 @@ from datetime import timedelta
 from shutil import get_terminal_size, rmtree
 from tempfile import mkdtemp
 from time import perf_counter, sleep
-from typing import NoReturn
+from typing import TYPE_CHECKING, NoReturn
+
+if TYPE_CHECKING:
+    import av
 
 
 class Log:
@@ -97,6 +100,10 @@ class Log:
 
             sys.stdout.write(f"Finished. took {second_len} seconds ({minute_len})\n")
 
+    def experimental(self, codec: av.Codec) -> None:
+        if codec.experimental:
+            self.error(f"`{codec.name}` is an experimental codec")
+
     def error(self, message: str | Exception) -> NoReturn:
         if self.is_debug and isinstance(message, Exception):
             self.cleanup()

auto_editor/utils/types.py

@@ -210,14 +210,13 @@ class Args:
     sample_rate: int | None = None
     resolution: tuple[int, int] | None = None
     background: str = "#000000"
-    edit_based_on: str = "audio"
+    edit: str = "audio"
     keep_tracks_separate: bool = False
     audio_normalize: str = "#f"
     export: str | None = None
     player: str | None = None
     no_open: bool = False
     temp_dir: str | None = None
-    ffmpeg_location: str | None = None
     progress: str = "modern"
     version: bool = False
     debug: bool = False

{auto_editor-26.0.1.dist-info → auto_editor-26.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 26.0.1
+Version: 26.1.1
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense
@@ -11,8 +11,8 @@ Keywords: video,audio,media,editor,editing,processing,nonlinear,automatic,silenc
 Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy <3.0,>=1.23.0
-Requires-Dist: pyav ==13.1.*
+Requires-Dist: numpy<3.0,>=1.24
+Requires-Dist: pyav==14.*
 
 <p align="center"><img src="https://auto-editor.com/img/auto-editor-banner.webp" title="Auto-Editor" width="700"></p>
 

{auto_editor-26.0.1.dist-info → auto_editor-26.1.1.dist-info}/RECORD

@@ -1,10 +1,10 @@
-auto_editor/__init__.py,sha256=IVlNYVWUewREksm_90yLqKeN61i9bI8Lx_lWZz4SObk,23
-auto_editor/__main__.py,sha256=vSvw0fWi4GOIsak_RuOBnMB_CrtNNp8COh7i8LV4acE,11541
-auto_editor/analyze.py,sha256=uCi21659BB-lbPwZ6yxNLekS6Q3yoB2ypLNXPhmhTfg,11688
-auto_editor/edit.py,sha256=_fjvs2UzK84Wl6DVZwyRBbqbxh16z4VPNTHUlvjU9iQ,15977
-auto_editor/ffwrapper.py,sha256=Sx1-9OmAStR73I-RR2XPwWPTmGywM7ssqT9-U0sffA4,5615
-auto_editor/help.py,sha256=62s3L0rlhA7nkkOjtXItRUl779EJ__A7_6E-VFH3J_E,7924
-auto_editor/make_layers.py,sha256=8uFy5SvMArAP-5slYJrxa_iGAEwimQBFeM-T01VORVw,8995
+auto_editor/__init__.py,sha256=2Ltcef2BVJgJx2W5ZkX7r21sdnzR3Zvtu1PYKRHEjLk,23
+auto_editor/__main__.py,sha256=tc0M1MIPYjU5wCEU3EqmleOzaUgksU60qVHO0vRuC10,11310
+auto_editor/analyze.py,sha256=Fv8NA99T1dZzrqlweJNlK7haKjgK13neR9CMw4t6rlY,12716
+auto_editor/edit.py,sha256=eEMRaQbn0jylfJ6D_egnUXjoMCbdQVsAu7MDrn-xlGo,15950
+auto_editor/ffwrapper.py,sha256=Tct_Q-uy5F51h8M7UFam50UzRFpgkBvUamJP1AoKVvc,4749
+auto_editor/help.py,sha256=CzfDTsL4GuGu596ySHKj_wKnxGR9h8B0KUdkZpo33oE,8044
+auto_editor/make_layers.py,sha256=vEeJt0PnE1vc9-cQZ_AlXVDjvWhObRCWJSCQGraoMvU,9016
 auto_editor/output.py,sha256=ho8Lpqz4Sv_Gw0Vj2OvG39s83xHpyZlvtRNryTPbXqc,2563
 auto_editor/preview.py,sha256=HUsjmV9Fx73rZ26BXrpz9z-z_e4oiui3u9e7qbbGoBY,3037
 auto_editor/timeline.py,sha256=XfaH9cH-RB-MObOpMr5IfLcqJcjmabO1XwkUkT3_FQM,8186
@@ -27,13 +27,14 @@ auto_editor/lib/contracts.py,sha256=lExGQymcQUmwG5lC1lO4qm4GY8W0q_yzK_miTaAoPA4,
 auto_editor/lib/data_structs.py,sha256=dcsXgsLLzbmFDUZucoirzewPALsKzoxz7z5L22_QJM8,7091
 auto_editor/lib/err.py,sha256=UlszQJdzMZwkbT8x3sY4GkCV_5x9yrd6uVVUzvA8iiI,35
 auto_editor/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-auto_editor/render/audio.py,sha256=KvhAJf-5_HFkRoaYaKOYraT2uQr65gdayuicWYOpjgk,13376
-auto_editor/render/subtitle.py,sha256=qyP_AZHwGToVBeH8qMSa9LUenMaNmsnJN8w0Y7SXQ3o,6235
+auto_editor/render/audio.py,sha256=1iOQCeRXfRz28cqnHp2XeK-f3_UnPf80AKQAfifGvdE,12584
+auto_editor/render/subtitle.py,sha256=lf2l1QWJgFiqlpQWWBwSlKJnSgW8Lkfi59WrJMbIDqM,6240
 auto_editor/render/video.py,sha256=dje0RNW2dKILfTzt0VAF0WR6REfGOsc6l17pP1Z4ooA,12215
 auto_editor/subcommands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_editor/subcommands/cache.py,sha256=YW_5qH0q5TVzmfOLEO117uqcY7dF6DS619ltVTPIzHQ,1959
 auto_editor/subcommands/desc.py,sha256=GDrKJYiHMaeTrplZAceXl1JwoqD78XsV2_5lc0Xd7po,869
-auto_editor/subcommands/info.py,sha256=t5n43HLt9hpMFSIfGV777X4zIPBAFugOKlpCfRjiKxY,6921
-auto_editor/subcommands/levels.py,sha256=ChJMDTd34-jgxewqHRmmd3VNhFdy964w0DcQG0ls-hY,4079
+auto_editor/subcommands/info.py,sha256=UDdoxd6_fqSoRPwthkWXqnpxHp7dJQ0Dn96lYX_ubWc,7010
+auto_editor/subcommands/levels.py,sha256=psSSIsGfzr9j0HGKp2yvK6nMlrkLwxkwsyI0uF2xb_c,4496
 auto_editor/subcommands/palet.py,sha256=ONzTqemaQq9YEfIOsDRNnwzfqnEMUMSXIQrETxyroRU,749
 auto_editor/subcommands/repl.py,sha256=TF_I7zsFY7-KdgidrqjafTz7o_eluVbLvgTcOBG-UWQ,3449
 auto_editor/subcommands/subdump.py,sha256=af_XBf7kaevqHn1A71z8C-7x8pS5WKD9FE_ugkCw6rk,665
@@ -44,12 +45,12 @@ auto_editor/utils/chunks.py,sha256=J-eGKtEz68gFtRrj1kOSgH4Tj_Yz6prNQ7Xr-d9NQJw,5
 auto_editor/utils/cmdkw.py,sha256=aUGBvBel2Ko1o6Rwmr4rEL-BMc5hEnzYLbyZ1GeJdcY,5729
 auto_editor/utils/container.py,sha256=Wf1ZL0tvXWl6m1B9mK_SkgVl89ilV_LpwlQq0TVroCc,2704
 auto_editor/utils/func.py,sha256=kB-pNDn20M6YT7sljyd_auve5teK-E2G4TgwVOAIuJw,2754
-auto_editor/utils/log.py,sha256=M2QKeQHMRNLm3HMVUKedZPRprT2u5dipOStiO4miPBk,3613
-auto_editor/utils/types.py,sha256=ecjTQmTlKoT9Wbwb_N4p6wC7s3bxiKPmq8sF15WfyVs,10772
-docs/build.py,sha256=CM-ZWgQk8wSNjivx_-6wGIaG7cstrNKsX2d4TzFVivE,1642
-auto_editor-26.0.1.dist-info/LICENSE,sha256=yiq99pWITHfqS0pbZMp7cy2dnbreTuvBwudsU-njvIM,1210
-auto_editor-26.0.1.dist-info/METADATA,sha256=e_JZKirHFmWBAXaCDqXHIOB4J-IIpbuoK72fzhlXMtw,6115
-auto_editor-26.0.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-auto_editor-26.0.1.dist-info/entry_points.txt,sha256=-H7zdTw4MqnAcwrN5xTNkGIhzZtJMxS9r6lTMeR9-aA,240
-auto_editor-26.0.1.dist-info/top_level.txt,sha256=jBV5zlbWRbKOa-xaWPvTD45QL7lGExx2BDzv-Ji4dTw,17
-auto_editor-26.0.1.dist-info/RECORD,,
+auto_editor/utils/log.py,sha256=n5dlJ2CdK_54eiYE02SPgkBdBWABV7tE2p8ONj_F6TM,3813
+auto_editor/utils/types.py,sha256=7BF7R7DA5eKmtI6f5ia7bOYNL0u_2sviiPsE1VmP0lc,10724
+docs/build.py,sha256=POy8X8QOBYe_8A8HI_yiVI_Qg9E5mLpn1z7AHQr0_vQ,1888
+auto_editor-26.1.1.dist-info/LICENSE,sha256=yiq99pWITHfqS0pbZMp7cy2dnbreTuvBwudsU-njvIM,1210
+auto_editor-26.1.1.dist-info/METADATA,sha256=Ovf6CjY_x-lyih-4c1xBZEkL_X0gvifVFthPcLSMOtk,6109
+auto_editor-26.1.1.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
+auto_editor-26.1.1.dist-info/entry_points.txt,sha256=-H7zdTw4MqnAcwrN5xTNkGIhzZtJMxS9r6lTMeR9-aA,240
+auto_editor-26.1.1.dist-info/top_level.txt,sha256=jBV5zlbWRbKOa-xaWPvTD45QL7lGExx2BDzv-Ji4dTw,17
+auto_editor-26.1.1.dist-info/RECORD,,

{auto_editor-26.0.1.dist-info → auto_editor-26.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.7.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

docs/build.py

@@ -2,6 +2,7 @@
 
 import os
 import sys
+from html import escape
 
 # Put 'auto_editor' in Python path
 sys.path.append(os.path.dirname(os.path.dirname(__file__)))
@@ -19,7 +20,7 @@ def main():
 
     with open("src/ref/options.html", "w") as file:
         file.write(
-            '{{ header-desc "Options" "These are the options and flags that auto-editor uses." }}\n'
+            '{{ headerdesc "Options" "These are the options and flags that auto-editor uses." }}\n'
             "<body>\n"
             "{{ nav }}\n"
             '<section class="section">\n'
@@ -27,12 +28,18 @@ def main():
         )
         for op in parser.args:
             if isinstance(op, OptionText):
-                file.write(f"<h2>{op.text}</h2>\n")
+                file.write(f"<h2>{escape(op.text)}</h2>\n")
             else:
-                file.write(f"<h3><code>{op.names[0]}</code></h3>\n")
+                if op.metavar is None:
+                    file.write(f"<h3><code>{op.names[0]}</code></h3>\n")
+                else:
+                    file.write(
+                        f"<h3><code>{op.names[0]} {escape(op.metavar)}</code></h3>\n"
+                    )
+
                 if len(op.names) > 1:
                     file.write(
-                        "<h4><code>"
+                        "<h4>Aliases: <code>"
                         + "</code> <code>".join(op.names[1:])
                         + "</code></h4>\n"
                     )