auto-editor 26.0.0__py3-none-any.whl → 26.1.0__py3-none-any.whl

auto_editor/__init__.py

@@ -1 +1 @@
-__version__ = "26.0.0"
+__version__ = "26.1.0"

auto_editor/__main__.py

@@ -8,15 +8,14 @@ from subprocess import run
 
 import auto_editor
 from auto_editor.edit import edit_media
-from auto_editor.ffwrapper import FFmpeg, initFFmpeg
 from auto_editor.utils.func import get_stdout
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import (
     Args,
-    color,
     frame_rate,
     margin,
     number,
+    parse_color,
     resolution,
     sample_rate,
     speed,
@@ -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",
@@ -108,7 +106,7 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
     parser.add_argument(
         "--background",
         "-b",
-        type=color,
+        type=parse_color,
         metavar="COLOR",
         help="Set the background as a solid RGB color",
     )
@@ -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,16 +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_argument(
-        "--my-ffmpeg",
-        flag=True,
-        help="Use the ffmpeg on your PATH instead of the one packaged",
-    )
     parser.add_text("Display Options:")
     parser.add_argument(
         "--progress",
@@ -179,12 +167,6 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         help="Set what type of progress bar to use",
     )
     parser.add_argument("--debug", flag=True, help="Show debugging messages and values")
-    parser.add_argument(
-        "--show-ffmpeg-commands", flag=True, help="Show ffmpeg commands"
-    )
-    parser.add_argument(
-        "--show-ffmpeg-output", flag=True, help="Show ffmpeg stdout and stderr"
-    )
     parser.add_argument("--quiet", "-q", flag=True, help="Display less output")
     parser.add_argument(
         "--preview",
@@ -252,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"
     )
@@ -267,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:
@@ -283,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.path]
-
+    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
@@ -337,6 +311,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"]),
         ],
     )
 
@@ -363,17 +338,10 @@ def main() -> None:
     is_machine = args.progress == "machine"
     log = Log(args.debug, args.quiet, args.temp_dir, is_machine, no_color)
 
-    ffmpeg = initFFmpeg(
-        log,
-        args.ffmpeg_location,
-        args.my_ffmpeg,
-        args.show_ffmpeg_commands,
-        args.show_ffmpeg_output,
-    )
     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):
@@ -387,7 +355,7 @@ def main() -> None:
             paths.append(my_input)
 
     try:
-        edit_media(paths, ffmpeg, args, log)
+        edit_media(paths, args, log)
     except KeyboardInterrupt:
         log.error("Keyboard Interrupt")
     log.cleanup()

auto_editor/analyze.py

@@ -27,6 +27,9 @@ if TYPE_CHECKING:
     from auto_editor.utils.log import Log
 
 
+__all__ = ("LevelError", "Levels", "iter_audio", "iter_motion")
+
+
 class LevelError(Exception):
     pass
 
@@ -69,45 +72,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))
-
-    finally:
-        container.close()
+        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
 
+            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 +122,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,8 +151,6 @@ 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)
@@ -175,7 +173,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
 
@@ -239,21 +241,26 @@ 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)
         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))
@@ -263,6 +270,7 @@ class Levels:
             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,20 +281,25 @@ 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)
         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))

auto_editor/edit.py

@@ -3,15 +3,16 @@ from __future__ import annotations
 import os
 import sys
 from fractions import Fraction
+from os.path import splitext
 from subprocess import run
 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 make_timeline
+from auto_editor.make_layers import clipify, make_av, make_timeline
 from auto_editor.output import Ensure, parse_bitrate
 from auto_editor.render.audio import make_new_audio
 from auto_editor.render.subtitle import make_new_subtitles
@@ -31,7 +32,7 @@ def set_output(
     if src is None:
         root, ext = "out", ".mp4"
     else:
-        root, ext = os.path.splitext(str(src.path) if out is None else out)
+        root, ext = splitext(src.path if out is None else out)
         if ext == "":
             ext = src.path.suffix
 
@@ -159,12 +160,12 @@ 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
 
     if paths:
-        path_ext = os.path.splitext(paths[0])[1].lower()
+        path_ext = splitext(paths[0])[1].lower()
         if path_ext == ".xml":
             from auto_editor.formats.fcp7 import fcp7_read_xml
 
@@ -243,7 +244,7 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
         from auto_editor.formats.fcp7 import fcp7_write_xml
 
         is_resolve = export.startswith("resolve")
-        fcp7_write_xml(export_ops["name"], output, is_resolve, tl, log)
+        fcp7_write_xml(export_ops["name"], output, is_resolve, tl)
         return
 
     if export == "final-cut-pro":
@@ -267,7 +268,7 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
         shotcut_write_mlt(output, tl)
         return
 
-    out_ext = os.path.splitext(output)[1].replace(".", "")
+    out_ext = splitext(output)[1].replace(".", "")
 
     # Check if export options make sense.
     ctr = container_constructor(out_ext.lower())
@@ -293,27 +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, ensure, args, ffmpeg, bar, log)
-            if (
-                not (args.keep_tracks_separate and ctr.max_audios is None)
-                and len(audio_paths) > 1
-            ):
-                # Merge all the audio a_tracks into one.
-                new_a_file = os.path.join(log.temp, "new_audio.wav")
-                new_cmd = []
-                for path in audio_paths:
-                    new_cmd.extend(["-i", path])
-                new_cmd.extend(
-                    [
-                        "-filter_complex",
-                        f"amix=inputs={len(audio_paths)}:duration=longest",
-                        "-ac",
-                        "2",
-                        new_a_file,
-                    ]
-                )
-                ffmpeg.run(new_cmd)
-                audio_paths = [new_a_file]
+            audio_paths = make_new_audio(tl, ctr, ensure, args, bar, log)
         else:
             audio_paths = []
 
@@ -362,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
@@ -430,14 +411,15 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
         if tl.v1 is None:
             log.error("Timeline too complex to use clip-sequence export")
 
-        from auto_editor.make_layers import clipify, make_av
-        from auto_editor.utils.func import append_filename
-
         def pad_chunk(chunk: Chunk, total: int) -> Chunks:
             start = [] if chunk[0] == 0 else [(0, chunk[0], 99999.0)]
             end = [] if chunk[1] == total else [(chunk[1], total, 99999.0)]
             return start + [chunk] + end
 
+        def append_filename(path: str, val: str) -> str:
+            root, ext = splitext(path)
+            return root + val + ext
+
         total_frames = tl.v1.chunks[-1][1] - 1
         clip_num = 0
         for chunk in tl.v1.chunks:

auto_editor/ffwrapper.py

@@ -1,63 +1,14 @@
 from __future__ import annotations
 
-import sys
 from dataclasses import dataclass
 from fractions import Fraction
 from pathlib import Path
-from shutil import which
-from subprocess import PIPE, Popen, run
-from typing import Any
 
 import av
 
 from auto_editor.utils.log import Log
 
 
-def initFFmpeg(
-    log: Log, ff_location: str | None, my_ffmpeg: bool, show_cmd: bool, debug: bool
-) -> FFmpeg:
-    if ff_location is not None:
-        program = ff_location
-    elif my_ffmpeg:
-        program = "ffmpeg"
-    else:
-        try:
-            import ae_ffmpeg
-
-            program = ae_ffmpeg.get_path()
-        except ImportError:
-            program = "ffmpeg"
-
-    path: str | None = which(program)
-    if path is None:
-        log.error("Did not find ffmpeg on PATH.")
-
-    return FFmpeg(log, path, show_cmd, debug)
-
-
-@dataclass(slots=True)
-class FFmpeg:
-    log: Log
-    path: str
-    show_cmd: bool
-    debug: bool
-
-    def run(self, cmd: list[str]) -> None:
-        cmd = [self.path, "-hide_banner", "-y"] + cmd
-        if not self.debug:
-            cmd.extend(["-nostats", "-loglevel", "error"])
-        if self.show_cmd:
-            sys.stderr.write(f"{' '.join(cmd)}\n\n")
-        run(cmd)
-
-    def Popen(
-        self, cmd: list[str], stdin: Any = None, stdout: Any = PIPE, stderr: Any = None
-    ) -> Popen:
-        if self.show_cmd:
-            sys.stderr.write(f"{self.path} {' '.join(cmd)}\n\n")
-        return Popen([self.path] + cmd, stdin=stdin, stdout=stdout, stderr=stderr)
-
-
 def mux(input: Path, output: Path, stream: int) -> None:
     input_container = av.open(input, "r")
     output_container = av.open(output, "w")

auto_editor/formats/fcp7.py

@@ -485,7 +485,7 @@ def premiere_write_audio(audio: Element, make_filedef, src: FileInfo, tl: v3) ->
             audio.append(track)
 
 
-def fcp7_write_xml(name: str, output: str, resolve: bool, tl: v3, log: Log) -> None:
+def fcp7_write_xml(name: str, output: str, resolve: bool, tl: v3) -> None:
     width, height = tl.res
     timebase, ntsc = set_tb_ntsc(tl.tb)
 

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/lang/palet.py

@@ -353,9 +353,7 @@ class Lexer:
             if is_method:
                 from auto_editor.utils.cmdkw import parse_method
 
-                return Token(
-                    M, parse_method(name, result, env), self.lineno, self.column
-                )
+                return Token(M, parse_method(name, result), self.lineno, self.column)
 
             if self.char == ".":  # handle `object.method` syntax
                 self.advance()
@@ -635,6 +633,8 @@ def edit_subtitle(pattern, stream=0, **kwargs):
 
 
 class StackTraceManager:
+    __slots__ = ("stack",)
+
     def __init__(self) -> None:
         self.stack: list[Sym] = []
 
@@ -645,12 +645,6 @@ class StackTraceManager:
         if self.stack:
             self.stack.pop()
 
-    def get_stacktrace(self) -> str:
-        return "\n".join(
-            f"  at {sym.val} ({sym.lineno}:{sym.column})"
-            for sym in reversed(self.stack)
-        )
-
 
 stack_trace_manager = StackTraceManager()
 

auto_editor/lang/stdenv.py

@@ -14,7 +14,6 @@ if TYPE_CHECKING:
     from numpy.typing import NDArray
 
     Number = int | float | complex | Fraction
-    Real = int | float | Fraction
     BoolList = NDArray[np.bool_]
     Node = tuple
 
@@ -831,12 +830,6 @@ def make_standard_env() -> dict[str, Any]:
         check_args("xor", vals, (2, None), (is_bool,))
         return reduce(lambda a, b: a ^ b, vals)
 
-    def string_ref(s: str, ref: int) -> Char:
-        try:
-            return Char(s[ref])
-        except IndexError:
-            raise MyError(f"string index {ref} is out of range")
-
     def number_to_string(val: Number) -> str:
         if isinstance(val, complex):
             join = "" if val.imag < 0 else "+"

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/output.py

@@ -13,7 +13,10 @@ from auto_editor.utils.types import _split_num_str
 
 
 def parse_bitrate(input_: str, log: Log) -> int:
-    val, unit = _split_num_str(input_)
+    try:
+        val, unit = _split_num_str(input_)
+    except Exception as e:
+        log.error(e)
 
     if unit.lower() == "k":
         return int(val * 1000)