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

auto_editor/__init__.py

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

auto_editor/__main__.py

@@ -8,16 +8,15 @@ from subprocess import run
 
 import auto_editor
 from auto_editor.edit import edit_media
-from auto_editor.ffwrapper import FFmpeg, initFFmpeg
+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 (
     Args,
-    bitrate,
-    color,
     frame_rate,
     margin,
     number,
+    parse_color,
     resolution,
     sample_rate,
     speed,
@@ -109,7 +108,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",
     )
@@ -167,11 +166,6 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         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",
@@ -180,12 +174,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",
@@ -205,16 +193,8 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         "--video-bitrate",
         "-b:v",
         metavar="BITRATE",
-        type=bitrate,
         help="Set the number of bits per second for video",
     )
-    parser.add_argument(
-        "--video-quality-scale",
-        "-qscale:v",
-        "-q:v",
-        metavar="SCALE",
-        help="Set a value to the ffmpeg option -qscale:v",
-    )
     parser.add_argument(
         "--scale",
         type=number,
@@ -238,7 +218,6 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         "--audio-bitrate",
         "-b:a",
         metavar="BITRATE",
-        type=bitrate,
         help="Set the number of bits per second for audio",
     )
     parser.add_argument(
@@ -281,7 +260,7 @@ def download_video(my_input: str, args: Args, ffmpeg: FFmpeg, log: Log) -> str:
     log.conwrite("Downloading video...")
 
     def get_domain(url: str) -> str:
-        t = __import__("urllib").parse.urlparse(url).netloc
+        t = __import__("urllib.parse", fromlist=["parse"]).urlparse(url).netloc
         return ".".join(t.split(".")[-2:])
 
     download_format = args.download_format
@@ -295,7 +274,7 @@ def download_video(my_input: str, args: Args, ffmpeg: FFmpeg, log: Log) -> str:
 
     yt_dlp_path = args.yt_dlp_location
 
-    cmd = ["--ffmpeg-location", ffmpeg.path]
+    cmd = ["--ffmpeg-location", ffmpeg.get_path("yt-dlp", log)]
 
     if download_format is not None:
         cmd.extend(["-f", download_format])
@@ -373,13 +352,7 @@ 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,
-    )
+    ffmpeg = FFmpeg(args.ffmpeg_location)
     paths = []
     for my_input in args.input:
         if my_input.startswith("http://") or my_input.startswith("https://"):

auto_editor/edit.py

@@ -2,13 +2,18 @@ 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.lib.contracts import is_int, is_str
-from auto_editor.make_layers import make_timeline
-from auto_editor.output import Ensure, mux_quality_media
+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
 from auto_editor.render.video import render_av
@@ -27,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
 
@@ -92,11 +97,19 @@ def set_audio_codec(
     codec: str, src: FileInfo | None, out_ext: str, ctr: Container, log: Log
 ) -> str:
     if codec == "auto":
-        codec = "aac" if (src is None or not src.audios) else src.audios[0].codec
+        if src is None or not src.audios:
+            codec = "aac"
+        else:
+            codec = src.audios[0].codec
+            ctx = av.Codec(codec)
+            if ctx.audio_formats is None:
+                codec = "aac"
         if codec not in ctr.acodecs and ctr.default_aud != "none":
-            return ctr.default_aud
+            codec = ctr.default_aud
         if codec == "mp3float":
-            return "mp3"
+            codec = "mp3"
+        if codec is None:
+            codec = "aac"
         return codec
 
     if codec == "copy":
@@ -106,9 +119,8 @@ def set_audio_codec(
             log.error("Input file does not have an audio stream to copy codec from.")
         codec = src.audios[0].codec
 
-    if codec != "unset":
-        if ctr.acodecs is None or codec not in ctr.acodecs:
-            log.error(codec_error.format(codec, out_ext))
+    if ctr.acodecs is None or codec not in ctr.acodecs:
+        log.error(codec_error.format(codec, out_ext))
 
     return codec
 
@@ -153,7 +165,7 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
     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
 
@@ -232,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":
@@ -256,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())
@@ -270,62 +282,144 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
     if args.keep_tracks_separate and ctr.max_audios == 1:
         log.warning(f"'{out_ext}' container doesn't support multiple audio tracks.")
 
-    def make_media(tl: v3, output: str) -> None:
+    def make_media(tl: v3, output_path: str) -> None:
         assert src is not None
 
-        visual_output = []
-        audio_output = []
-        sub_output = []
-        apply_later = False
+        output = av.open(output_path, "w")
 
-        ensure = Ensure(ffmpeg, bar, samplerate, log)
         if ctr.default_sub != "none" and not args.sn:
-            sub_output = make_new_subtitles(tl, ensure, log.temp)
+            sub_paths = make_new_subtitles(tl, log)
+        else:
+            sub_paths = []
 
         if ctr.default_aud != "none":
-            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, 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(log.temp, f"{v}.{vid.codec}")
-                    # fmt: off
-                    ffmpeg.run(["-i", f"{src.path}", "-map", "0:v", "-map", "-0:V",
-                        "-c", "copy", out_path])
-                    # fmt: on
-                    visual_output.append((False, out_path))
-
-        log.conwrite("Writing output file")
-        mux_quality_media(
-            ffmpeg,
-            visual_output,
-            audio_output,
-            sub_output,
-            apply_later,
-            ctr,
-            output,
-            tl.tb,
-            args,
-            src,
-            log,
-        )
+            ensure = Ensure(bar, samplerate, log)
+            audio_paths = make_new_audio(tl, ctr, ensure, args, ffmpeg, bar, log)
+        else:
+            audio_paths = []
+
+        # Setup audio
+        if audio_paths:
+            try:
+                audio_encoder = av.Codec(args.audio_codec)
+            except av.FFmpegError as e:
+                log.error(e)
+            if audio_encoder.audio_formats is None:
+                log.error(f"{args.audio_codec}: No known audio formats avail.")
+            audio_format = audio_encoder.audio_formats[0]
+            resampler = AudioResampler(format=audio_format, layout="stereo", rate=tl.sr)
+
+        audio_streams: list[av.AudioStream] = []
+        audio_inputs = []
+        audio_gen_frames = []
+        for i, audio_path in enumerate(audio_paths):
+            audio_stream = output.add_stream(
+                args.audio_codec,
+                format=audio_format,
+                rate=tl.sr,
+                time_base=Fraction(1, tl.sr),
+            )
+            if not isinstance(audio_stream, av.AudioStream):
+                log.error(f"Not a known audio codec: {args.audio_codec}")
+
+            if args.audio_bitrate != "auto":
+                audio_stream.bit_rate = parse_bitrate(args.audio_bitrate, log)
+                log.debug(f"audio bitrate: {audio_stream.bit_rate}")
+            else:
+                log.debug(f"[auto] audio bitrate: {audio_stream.bit_rate}")
+            if i < len(src.audios) and src.audios[i].lang is not None:
+                audio_stream.metadata["language"] = src.audios[i].lang  # type: ignore
+
+            audio_streams.append(audio_stream)
+            audio_input = av.open(audio_path)
+            audio_inputs.append(audio_input)
+            audio_gen_frames.append(audio_input.decode(audio=0))
+
+        # Setup subtitles
+        subtitle_streams = []
+        subtitle_inputs = []
+        sub_gen_frames = []
+
+        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]
+            )
+            if i < len(src.subtitles) and src.subtitles[i].lang is not None:
+                subtitle_stream.metadata["language"] = src.subtitles[i].lang  # type: ignore
+
+            subtitle_streams.append(subtitle_stream)
+            sub_gen_frames.append(subtitle_input.demux(subtitles=0))
+
+        # Setup video
+        if ctr.default_vid != "none" and tl.v:
+            vframes = render_av(output, tl, args, bar, log)
+            output_stream = next(vframes)
+        else:
+            output_stream, vframes = None, iter([])
+
+        # Process frames
+        while True:
+            audio_frames = [next(frames, None) for frames in audio_gen_frames]
+            video_frame = next(vframes, None)
+            subtitle_frames = [next(packet, None) for packet in sub_gen_frames]
+
+            if (
+                all(frame is None for frame in audio_frames)
+                and video_frame is None
+                and all(packet is None for packet in subtitle_frames)
+            ):
+                break
+
+            for audio_stream, audio_frame in zip(audio_streams, audio_frames):
+                if audio_frame:
+                    for reframe in resampler.resample(audio_frame):
+                        output.mux(audio_stream.encode(reframe))
+
+            for subtitle_stream, packet in zip(subtitle_streams, subtitle_frames):
+                if not packet or packet.dts is None:
+                    continue
+                packet.stream = subtitle_stream
+                output.mux(packet)
+
+            if video_frame:
+                try:
+                    output.mux(output_stream.encode(video_frame))
+                except av.error.ExternalError:
+                    log.error(
+                        f"Generic error for encoder: {output_stream.name}\n"
+                        "Perhaps video quality settings are too low?"
+                    )
+                except av.FFmpegError as e:
+                    log.error(e)
+
+        # Flush streams
+        if output_stream is not None:
+            output.mux(output_stream.encode(None))
+        for audio_stream in audio_streams:
+            output.mux(audio_stream.encode(None))
+
+        # Close resources
+        for audio_input in audio_inputs:
+            audio_input.close()
+        for subtitle_input in subtitle_inputs:
+            subtitle_input.close()
+        output.close()
 
     if export == "clip-sequence":
         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,98 +1,40 @@
 from __future__ import annotations
 
-import os.path
-import sys
 from dataclasses import dataclass
 from fractions import Fraction
 from pathlib import Path
-from re import search
 from shutil import which
-from subprocess import PIPE, Popen, run
-from typing import Any
+from subprocess import PIPE, Popen
 
 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)
+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:
-    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 run_check_errors(
-        self, cmd: list[str], show_out: bool = False, path: str | None = None
-    ) -> None:
-        process = self.Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
-        _, stderr = process.communicate()
-
-        if process.stdin is not None:
-            process.stdin.close()
-        output = stderr.decode("utf-8", "replace")
-
-        error_list = (
-            r"Unknown encoder '.*'",
-            r"-q:v qscale not available for encoder\. Use -b:v bitrate instead\.",
-            r"Specified sample rate .* is not supported",
-            r'Unable to parse option value ".*"',
-            r"Error setting option .* to value .*\.",
-            r"Undefined constant or missing '.*' in '.*'",
-            r"DLL .* failed to open",
-            r"Incompatible pixel format '.*' for codec '[A-Za-z0-9_]*'",
-            r"Unrecognized option '.*'",
-            r"Permission denied",
-        )
+    ffmpeg_location: str | None
+    path: str | None = None
 
-        if self.debug:
-            print(f"stderr: {output}")
+    def get_path(self, reason: str, log: Log) -> str:
+        if self.path is not None:
+            return self.path
 
-        for item in error_list:
-            if check := search(item, output):
-                self.log.error(check.group())
+        self.path = _get_ffmpeg(reason, self.ffmpeg_location, log)
+        return self.path
 
-        if path is not None and not os.path.isfile(path):
-            self.log.error(f"The file {path} was not created.")
-        if show_out and not self.debug:
-            print(f"stderr: {output}")
+    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)
 
-    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)
+        return Popen([self.path] + cmd, stdout=PIPE, stderr=PIPE)
 
 
 def mux(input: Path, output: Path, stream: int) -> None:
@@ -103,13 +45,9 @@ def mux(input: Path, output: Path, stream: int) -> None:
     output_audio_stream = output_container.add_stream("pcm_s16le")
 
     for frame in input_container.decode(input_audio_stream):
-        packet = output_audio_stream.encode(frame)
-        if packet:
-            output_container.mux(packet)
+        output_container.mux(output_audio_stream.encode(frame))
 
-    packet = output_audio_stream.encode(None)
-    if packet:
-        output_container.mux(packet)
+    output_container.mux(output_audio_stream.encode(None))
 
     output_container.close()
     input_container.close()

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

@@ -148,11 +148,12 @@ Beware that the temp directory can get quite big.
         "--my-ffmpeg": "This is equivalent to `--ffmpeg-location ffmpeg`.",
         "--audio-bitrate": """
 `--audio-bitrate` sets the target bitrate for the audio encoder.
-The value accepts a natural number and the units: ``, `k`, `K`, and `M`.
-The special value `unset` may also be used, and means: Don't pass any value to ffmpeg, let it choose a default bitrate.
+By default, the value is `auto` (let the encoder decide).
+It can be set to a natural number with units: ``, `k`, `K`, `M`, or `G`.
+
 """.strip(),
         "--video-bitrate": """
-`--video-bitrate` sets the target bitrate for the video encoder. It accepts the same format as `--audio-bitrate` and the special `unset` value is allowed.
+`--video-bitrate` sets the target bitrate for the video encoder. `auto` is set as the default. It accepts the same format as `--audio-bitrate`
 """.strip(),
         "--margin": """
 Default value: 0.2s,0.2s

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 "+"