auto-editor 24.30.1__py3-none-any.whl → 25.0.0__py3-none-any.whl

auto_editor/__init__.py

@@ -1,2 +1 @@
-__version__ = "24.30.1"
-version = "24w30a"
+__version__ = "25.0.0"

auto_editor/__main__.py

@@ -6,7 +6,6 @@ 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 (
     Args,
@@ -140,10 +139,7 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
     )
     parser.add_text("Utility Options:")
     parser.add_argument(
-        "--export",
-        "-ex",
-        metavar="EXPORT:ATTRS?",
-        help="Choose the export mode",
+        "--export", "-ex", metavar="EXPORT:ATTRS?", help="Choose the export mode"
     )
     parser.add_argument(
         "--output-file",
@@ -153,15 +149,10 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         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",
+        "--player", "-p", metavar="CMD", help="Set player to open output media files"
     )
     parser.add_argument(
-        "--no-open",
-        flag=True,
-        help="Do not open the output file after editing is done",
+        "--no-open", flag=True, help="Do not open the output file after editing is done"
     )
     parser.add_argument(
         "--temp-dir",
@@ -255,7 +246,7 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
     parser.add_argument(
         "--audio-normalize",
         metavar="NORM-TYPE",
-        help="Apply audio rendering to all audio tracks. Applied right before rendering the output file.",
+        help="Apply audio rendering to all audio tracks. Applied right before rendering the output file",
     )
     parser.add_text("Miscellaneous:")
     parser.add_argument(
@@ -268,6 +259,9 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         metavar="CMD",
         help="Add extra options for ffmpeg. Must be in quotes",
     )
+    parser.add_argument(
+        "--no-cache", flag=True, help="Don't look for or write a cache file"
+    )
     parser.add_argument("--version", "-V", flag=True, help="Display version and halt")
     return parser
 
@@ -303,7 +297,7 @@ def main() -> None:
     )
 
     if args.version:
-        print(f"{auto_editor.version} ({auto_editor.__version__})")
+        print(auto_editor.__version__)
         return
 
     if args.debug and not args.input:
@@ -314,15 +308,14 @@ def main() -> None:
         print(f"OS: {plat.system()} {plat.release()} {plat.machine().lower()}")
         print(f"Python: {plat.python_version()}")
         print(f"PyAV: {av.__version__}")
-        print(f"Auto-Editor: {auto_editor.version}")
+        print(f"Auto-Editor: {auto_editor.__version__}")
         return
 
     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, args.progress == "machine", no_color)
-    log.debug(f"Temp Directory: {temp}")
+    is_machine = args.progress == "machine"
+    log = Log(args.debug, args.quiet, args.temp_dir, is_machine, no_color)
 
     ffmpeg = FFmpeg(
         args.ffmpeg_location,
@@ -333,7 +326,7 @@ def main() -> None:
     paths = valid_input(args.input, ffmpeg, args, log)
 
     try:
-        edit_media(paths, ffmpeg, args, temp, log)
+        edit_media(paths, ffmpeg, args, log)
     except KeyboardInterrupt:
         log.error("Keyboard Interrupt")
     log.cleanup()

auto_editor/analyze.py

@@ -5,6 +5,7 @@ import re
 from dataclasses import dataclass
 from fractions import Fraction
 from math import ceil
+from tempfile import gettempdir
 from typing import TYPE_CHECKING
 
 import av
@@ -12,7 +13,7 @@ import numpy as np
 from av.audio.fifo import AudioFifo
 from av.subtitles.subtitle import AssSubtitle
 
-from auto_editor import version
+from auto_editor import __version__
 from auto_editor.utils.subtitle_tools import convert_ass_to_text
 
 if TYPE_CHECKING:
@@ -27,16 +28,6 @@ if TYPE_CHECKING:
     from auto_editor.utils.log import Log
 
 
-@dataclass(slots=True)
-class FileSetup:
-    src: FileInfo
-    strict: bool
-    tb: Fraction
-    bar: Bar
-    temp: str
-    log: Log
-
-
 class LevelError(Exception):
     pass
 
@@ -88,7 +79,7 @@ def obj_tag(tag: str, tb: Fraction, obj: dict[str, Any]) -> str:
     return key
 
 
-def iter_audio(src, tb: Fraction, stream: int = 0) -> Iterator[float]:
+def iter_audio(src, tb: Fraction, stream: int = 0) -> Iterator[np.float32]:
     fifo = AudioFifo()
     try:
         container = av.open(src.path, "r")
@@ -117,13 +108,13 @@ def iter_audio(src, tb: Fraction, stream: int = 0) -> Iterator[float]:
                 audio_chunk = fifo.read(current_size)
                 assert audio_chunk is not None
                 arr = audio_chunk.to_ndarray().flatten()
-                yield float(np.max(np.abs(arr)))
+                yield np.max(np.abs(arr))
 
     finally:
         container.close()
 
 
-def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[float]:
+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]
@@ -155,11 +146,11 @@ def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[float]:
 
         current_frame = frame.to_ndarray()
         if prev_frame is None:
-            value = 0.0
+            value = np.float32(0.0)
         else:
             # Use `int16` to avoid underflow with `uint8` datatype
             diff = np.abs(prev_frame.astype(np.int16) - current_frame.astype(np.int16))
-            value = np.count_nonzero(diff) / total_pixels
+            value = np.float32(np.count_nonzero(diff) / total_pixels)
 
         for _ in range(index - prev_index):
             yield value
@@ -175,8 +166,9 @@ class Levels:
     src: FileInfo
     tb: Fraction
     bar: Bar
-    temp: str
+    no_cache: bool
     log: Log
+    strict: bool
 
     @property
     def media_length(self) -> int:
@@ -210,9 +202,10 @@ class Levels:
         return np.zeros(self.media_length, dtype=np.bool_)
 
     def read_cache(self, tag: str, obj: dict[str, Any]) -> None | np.ndarray:
-        workfile = os.path.join(
-            os.path.dirname(self.temp), f"ae-{version}", "cache.npz"
-        )
+        if self.no_cache:
+            return None
+
+        workfile = os.path.join(gettempdir(), f"ae-{__version__}", "cache.npz")
 
         try:
             npzfile = np.load(workfile, allow_pickle=False)
@@ -227,8 +220,11 @@ class Levels:
         self.log.debug("Using cache")
         return npzfile[key]
 
-    def cache(self, tag: str, obj: dict[str, Any], arr: np.ndarray) -> np.ndarray:
-        workdur = os.path.join(os.path.dirname(self.temp), f"ae-{version}")
+    def cache(self, arr: np.ndarray, tag: str, obj: dict[str, Any]) -> 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)
 
@@ -237,7 +233,7 @@ class Levels:
 
         return arr
 
-    def audio(self, stream: int) -> NDArray[np.float64]:
+    def audio(self, stream: int) -> NDArray[np.float32]:
         if stream >= len(self.src.audios):
             raise LevelError(f"audio: audio stream '{stream}' does not exist.")
 
@@ -256,21 +252,21 @@ class Levels:
         bar = self.bar
         bar.start(inaccurate_dur, "Analyzing audio volume")
 
-        result = np.zeros((inaccurate_dur), dtype=np.float64)
+        result = np.zeros((inaccurate_dur), dtype=np.float32)
         index = 0
         for value in iter_audio(self.src, self.tb, stream):
             if index > len(result) - 1:
                 result = np.concatenate(
-                    (result, np.zeros((len(result)), dtype=np.float64))
+                    (result, np.zeros((len(result)), dtype=np.float32))
                 )
             result[index] = value
             bar.tick(index)
             index += 1
 
         bar.end()
-        return self.cache("audio", {"stream": stream}, result[:index])
+        return self.cache(result[:index], "audio", {"stream": stream})
 
-    def motion(self, stream: int, blur: int, width: int) -> NDArray[np.float64]:
+    def motion(self, stream: int, blur: int, width: int) -> NDArray[np.float32]:
         if stream >= len(self.src.videos):
             raise LevelError(f"motion: video stream '{stream}' does not exist.")
 
@@ -289,19 +285,19 @@ class Levels:
         bar = self.bar
         bar.start(inaccurate_dur, "Analyzing motion")
 
-        result = np.zeros((inaccurate_dur), dtype=np.float64)
+        result = np.zeros((inaccurate_dur), dtype=np.float32)
         index = 0
         for value in iter_motion(self.src, self.tb, stream, blur, width):
             if index > len(result) - 1:
                 result = np.concatenate(
-                    (result, np.zeros((len(result)), dtype=np.float64))
+                    (result, np.zeros((len(result)), dtype=np.float32))
                 )
             result[index] = value
             bar.tick(index)
             index += 1
 
         bar.end()
-        return self.cache("motion", mobj, result[:index])
+        return self.cache(result[:index], "motion", mobj)
 
     def subtitle(
         self,

auto_editor/edit.py

@@ -142,9 +142,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, temp: str, log: Log
-) -> None:
+def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
     bar = Bar(args.progress)
     tl = None
 
@@ -203,7 +201,7 @@ def edit_media(
         samplerate = args.sample_rate
 
     if tl is None:
-        tl = make_timeline(sources, args, samplerate, bar, temp, log)
+        tl = make_timeline(sources, args, samplerate, bar, log)
 
     if export["export"] == "timeline":
         from auto_editor.formats.json import make_json_timeline
@@ -214,7 +212,7 @@ def edit_media(
     if args.preview:
         from auto_editor.preview import preview
 
-        preview(tl, temp, log)
+        preview(tl, log)
         return
 
     if export["export"] == "json":
@@ -263,22 +261,22 @@ def edit_media(
         sub_output = []
         apply_later = False
 
-        ensure = Ensure(ffmpeg, bar, samplerate, temp, log)
+        ensure = Ensure(ffmpeg, bar, samplerate, log)
 
         if ctr.default_sub != "none" and not args.sn:
-            sub_output = make_new_subtitles(tl, ensure, temp)
+            sub_output = make_new_subtitles(tl, ensure, log.temp)
 
         if ctr.default_aud != "none":
-            audio_output = make_new_audio(tl, ensure, args, ffmpeg, bar, temp, log)
+            audio_output = make_new_audio(tl, ensure, args, ffmpeg, bar, log)
 
         if ctr.default_vid != "none":
             if tl.v:
-                out_path, apply_later = render_av(ffmpeg, tl, args, bar, ctr, temp, log)
+                out_path, apply_later = render_av(ffmpeg, tl, args, bar, ctr, log)
                 visual_output.append((True, out_path))
 
             for v, vid in enumerate(src.videos, start=1):
                 if ctr.allow_image and vid.codec in ("png", "mjpeg", "webp"):
-                    out_path = os.path.join(temp, f"{v}.{vid.codec}")
+                    out_path = os.path.join(log.temp, f"{v}.{vid.codec}")
                     # fmt: off
                     ffmpeg.run(["-i", f"{src.path}", "-map", "0:v", "-map", "-0:V",
                         "-c", "copy", out_path])
@@ -297,7 +295,6 @@ def edit_media(
             tl.tb,
             args,
             src,
-            temp,
             log,
         )
 

auto_editor/ffwrapper.py

@@ -232,7 +232,7 @@ def initFileInfo(path: str, log: Log) -> FileInfo:
                 vdur,
                 sar,
                 v.time_base,
-                cc.pix_fmt,
+                getattr(v.format, "name", None),
                 cc.color_range,
                 cc.colorspace,
                 cc.color_primaries,

auto_editor/lang/palet.py

@@ -620,42 +620,36 @@ def make_array(dtype: Sym, size: int, v: int = 0) -> np.ndarray:
         raise MyError(f"number too large to be converted to {dtype}")
 
 
-def minclip(oarr: BoolList, _min: int) -> BoolList:
+def minclip(oarr: BoolList, _min: int, /) -> BoolList:
     arr = np.copy(oarr)
     mut_remove_small(arr, _min, replace=1, with_=0)
     return arr
 
 
-def mincut(oarr: BoolList, _min: int) -> BoolList:
+def mincut(oarr: BoolList, _min: int, /) -> BoolList:
     arr = np.copy(oarr)
     mut_remove_small(arr, _min, replace=0, with_=1)
     return arr
 
 
-def maxclip(oarr: BoolList, _min: int) -> BoolList:
+def maxclip(oarr: BoolList, _min: int, /) -> BoolList:
     arr = np.copy(oarr)
     mut_remove_large(arr, _min, replace=1, with_=0)
     return arr
 
 
-def maxcut(oarr: BoolList, _min: int) -> BoolList:
+def maxcut(oarr: BoolList, _min: int, /) -> BoolList:
     arr = np.copy(oarr)
     mut_remove_large(arr, _min, replace=0, with_=1)
     return arr
 
 
-def margin(a: int, b: Any, c: Any = None) -> BoolList:
-    if c is None:
-        check_args("margin", [a, b], (2, 2), (is_int, is_boolarr))
-        oarr = b
-        start, end = a, a
-    else:
-        check_args("margin", [a, b, c], (3, 3), (is_int, is_int, is_boolarr))
-        oarr = c
-        start, end = a, b
-
+def margin(oarr: BoolList, start: int, end: int | None = None, /) -> BoolList:
     arr = np.copy(oarr)
-    mut_margin(arr, start, end)
+    if end is None:
+        mut_margin(arr, start, start)
+    else:
+        mut_margin(arr, start, end)
     return arr
 
 
@@ -1493,12 +1487,12 @@ def edit_audio(
     mincut: int = 6,
     minclip: int = 3,
 ) -> np.ndarray:
-    if "@levels" not in env or "@filesetup" not in env:
+    if "@levels" not in env:
         raise MyError("Can't use `audio` if there's no input media")
 
     levels = env["@levels"]
-    src = env["@filesetup"].src
-    strict = env["@filesetup"].strict
+    src = levels.src
+    strict = levels.strict
 
     stream_data: NDArray[np.bool_] | None = None
     if stream == Sym("all"):
@@ -1537,11 +1531,10 @@ def edit_motion(
         raise MyError("Can't use `motion` if there's no input media")
 
     levels = env["@levels"]
-    strict = env["@filesetup"].strict
     try:
         return levels.motion(stream, blur, width) >= threshold
     except LevelError as e:
-        return raise_(e) if strict else levels.all()
+        return raise_(e) if levels.strict else levels.all()
 
 
 def edit_subtitle(pattern, stream=0, **kwargs):
@@ -1549,7 +1542,6 @@ def edit_subtitle(pattern, stream=0, **kwargs):
         raise MyError("Can't use `subtitle` if there's no input media")
 
     levels = env["@levels"]
-    strict = env["@filesetup"].strict
     if "ignore-case" not in kwargs:
         kwargs["ignore-case"] = False
     if "max-count" not in kwargs:
@@ -1559,7 +1551,7 @@ def edit_subtitle(pattern, stream=0, **kwargs):
     try:
         return levels.subtitle(pattern, stream, ignore_case, max_count)
     except LevelError as e:
-        return raise_(e) if strict else levels.all()
+        return raise_(e) if levels.strict else levels.all()
 
 
 def my_eval(env: Env, node: object) -> Any:
@@ -1741,6 +1733,8 @@ env.update({
     "round": Proc("round", round, (1, 1), is_real),
     "max": Proc("max", lambda *v: max(v), (1, None), is_real),
     "min": Proc("min", lambda *v: min(v), (1, None), is_real),
+    "max-seq": Proc("max-seq", max, (1, 1), is_sequence),
+    "min-seq": Proc("min-seq", min, (1, 1), is_sequence),
     "mod": Proc("mod", mod, (2, 2), is_int),
     "modulo": Proc("modulo", mod, (2, 2), is_int),
     # symbols
@@ -1796,7 +1790,7 @@ env.update({
     "bool-array": Proc(
         "bool-array", lambda *a: np.array(a, dtype=np.bool_), (1, None), is_nat
     ),
-    "margin": Proc("margin", margin, (2, 3)),
+    "margin": Proc("margin", margin, (2, 3), is_boolarr, is_int),
     "mincut": Proc("mincut", mincut, (2, 2), is_boolarr, is_nat),
     "minclip": Proc("minclip", minclip, (2, 2), is_boolarr, is_nat),
     "maxcut": Proc("maxcut", maxcut, (2, 2), is_boolarr, is_nat),

auto_editor/lib/contracts.py

@@ -1,15 +1,18 @@
 from __future__ import annotations
 
-from collections.abc import Callable
 from dataclasses import dataclass
 from fractions import Fraction
-from typing import Any
+from typing import TYPE_CHECKING
 
 from numpy import float64
 
 from .data_structs import Sym, print_str
 from .err import MyError
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from typing import Any
+
 
 @dataclass(slots=True)
 class Contract:

auto_editor/lib/data_structs.py

@@ -185,6 +185,8 @@ def display_str(val: object) -> str:
         return f"{val.real}{join}{val.imag}i"
     if type(val) is np.bool_:
         return "1" if val else "0"
+    if type(val) is np.float64 or type(val) is np.float32:
+        return f"{float(val)}"
     if type(val) is Fraction:
         return f"{val.numerator}/{val.denominator}"
 

auto_editor/make_layers.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, NamedTuple
 
 import numpy as np
 
-from auto_editor.analyze import FileSetup, Levels
+from auto_editor.analyze import Levels
 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
@@ -71,44 +71,6 @@ def make_av(src: FileInfo, all_clips: list[list[Clip]]) -> tuple[VSpace, ASpace]
     return vtl, atl
 
 
-def run_interpreter_for_edit_option(
-    text: str, filesetup: FileSetup
-) -> NDArray[np.bool_]:
-    src = filesetup.src
-    tb = filesetup.tb
-    bar = filesetup.bar
-    temp = filesetup.temp
-    log = filesetup.log
-
-    try:
-        parser = Parser(Lexer("`--edit`", text))
-        if log.is_debug:
-            log.debug(f"edit: {parser}")
-
-        env["timebase"] = tb
-        env["@levels"] = Levels(src, tb, bar, temp, log)
-        env["@filesetup"] = filesetup
-
-        results = interpret(env, parser)
-
-        if len(results) == 0:
-            raise MyError("Expression in --edit must return a bool-array, got nothing")
-
-        result = results[-1]
-        if callable(result):
-            result = result()
-
-        if not is_boolarr(result):
-            raise MyError(
-                f"Expression in --edit must return a bool-array, got {print_str(result)}"
-            )
-    except MyError as e:
-        log.error(e)
-
-    assert isinstance(result, np.ndarray)
-    return result
-
-
 def make_sane_timebase(fps: Fraction) -> Fraction:
     tb = round(fps, 2)
 
@@ -140,7 +102,6 @@ def make_timeline(
     args: Args,
     sr: int,
     bar: Bar,
-    temp: str,
     log: Log,
 ) -> v3:
     inp = None if not sources else sources[0]
@@ -159,20 +120,40 @@ def make_timeline(
     except CoerceError as e:
         log.error(e)
 
-    method = args.edit_based_on
-
     has_loud = np.array([], dtype=np.bool_)
     src_index = np.array([], dtype=np.int32)
     concat = np.concatenate
 
     for i, src in enumerate(sources):
-        filesetup = FileSetup(src, len(sources) < 2, tb, bar, temp, log)
+        try:
+            parser = Parser(Lexer("`--edit`", args.edit_based_on))
+            if log.is_debug:
+                log.debug(f"edit: {parser}")
+
+            env["timebase"] = tb
+            env["@levels"] = Levels(src, tb, bar, args.no_cache, log, len(sources) < 2)
+
+            results = interpret(env, parser)
+
+            if len(results) == 0:
+                log.error("Expression in --edit must return a bool-array, got nothing")
+
+            result = results[-1]
+            if callable(result):
+                result = result()
+        except MyError as e:
+            log.error(e)
+
+        if not is_boolarr(result):
+            log.error(
+                f"Expression in --edit must return a bool-array, got {print_str(result)}"
+            )
+        assert isinstance(result, np.ndarray)
 
-        edit_result = run_interpreter_for_edit_option(method, filesetup)
-        mut_margin(edit_result, start_margin, end_margin)
+        mut_margin(result, start_margin, end_margin)
 
-        has_loud = concat((has_loud, edit_result))
-        src_index = concat((src_index, np.full(len(edit_result), i, dtype=np.int32)))
+        has_loud = concat((has_loud, result))
+        src_index = concat((src_index, np.full(len(result), i, dtype=np.int32)))
 
     # Setup for handling custom speeds
     speed_index = has_loud.astype(np.uint)

auto_editor/output.py

@@ -19,7 +19,6 @@ class Ensure:
     _ffmpeg: FFmpeg
     _bar: Bar
     _sr: int
-    temp: str
     log: Log
     _audios: list[tuple[FileInfo, int]] = field(default_factory=list)
     _subtitles: list[tuple[FileInfo, int, str]] = field(default_factory=list)
@@ -33,7 +32,7 @@ class Ensure:
             label = len(self._audios) - 1
             first_time = True
 
-        out_path = os.path.join(self.temp, f"{label:x}.wav")
+        out_path = os.path.join(self.log.temp, f"{label:x}.wav")
 
         if first_time:
             sample_rate = self._sr
@@ -83,7 +82,7 @@ class Ensure:
             self._subtitles.append((src, stream, ext))
             first_time = True
 
-        out_path = os.path.join(self.temp, f"{stream}s.{ext}")
+        out_path = os.path.join(self.log.temp, f"{stream}s.{ext}")
 
         if first_time:
             self.log.debug(f"Making external subtitle: {out_path}")
@@ -119,7 +118,6 @@ def mux_quality_media(
     tb: Fraction,
     args: Args,
     src: FileInfo,
-    temp: str,
     log: Log,
 ) -> None:
     v_tracks = len(visual_output)
@@ -142,7 +140,7 @@ def mux_quality_media(
                 cmd.extend(["-i", path])
         else:
             # Merge all the audio a_tracks into one.
-            new_a_file = os.path.join(temp, "new_audio.wav")
+            new_a_file = os.path.join(log.temp, "new_audio.wav")
             if a_tracks > 1:
                 new_cmd = []
                 for path in audio_output:
@@ -227,7 +225,7 @@ def mux_quality_media(
             cmd.extend(["-color_range", f"{color_range}"])
         if colorspace in (0, 1) or (colorspace >= 3 and colorspace < 16):
             cmd.extend(["-colorspace", f"{colorspace}"])
-        if color_prim in (0, 1) or (color_prim >= 4 and color_prim < 17):
+        if color_prim == 1 or (color_prim >= 4 and color_prim < 17):
             cmd.extend(["-color_primaries", f"{color_prim}"])
         if color_trc == 1 or (color_trc >= 4 and color_trc < 22):
             cmd.extend(["-color_trc", f"{color_trc}"])

auto_editor/preview.py

@@ -48,7 +48,7 @@ def all_cuts(tl: v3, in_len: int) -> list[int]:
     return cut_lens
 
 
-def preview(tl: v3, temp: str, log: Log) -> None:
+def preview(tl: v3, log: Log) -> None:
     log.conwrite("")
     tb = tl.tb
 
@@ -65,7 +65,7 @@ def preview(tl: v3, temp: str, log: Log) -> None:
 
     in_len = 0
     for src in all_sources:
-        in_len += Levels(src, tb, Bar("none"), temp, log).media_length
+        in_len += Levels(src, tb, Bar("none"), False, log, False).media_length
 
     out_len = tl.out_len()
 

auto_editor/render/audio.py

@@ -166,7 +166,7 @@ def apply_audio_normalization(
 
 
 def make_new_audio(
-    tl: v3, ensure: Ensure, args: Args, ffmpeg: FFmpeg, bar: Bar, temp: str, log: Log
+    tl: v3, ensure: Ensure, args: Args, ffmpeg: FFmpeg, bar: Bar, log: Log
 ) -> list[str]:
     sr = tl.sr
     tb = tl.tb
@@ -176,6 +176,7 @@ def make_new_audio(
     norm = parse_norm(args.audio_normalize, log)
 
     af_tick = 0
+    temp = log.temp
 
     if not tl.a or not tl.a[0]:
         log.error("Trying to render empty audio timeline")