auto-editor 26.0.0__tar.gz → 26.0.1__tar.gz

{auto_editor-26.0.0 → auto_editor-26.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 26.0.0
+Version: 26.0.1
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense
@@ -13,7 +13,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy<3.0,>=1.23.0
 Requires-Dist: pyav==13.1.*
-Requires-Dist: ae-ffmpeg==1.2.*
 
 <p align="center"><img src="https://auto-editor.com/img/auto-editor-banner.webp" title="Auto-Editor" width="700"></p>
 

auto_editor-26.0.1/auto_editor/__init__.py

@@ -0,0 +1 @@
+__version__ = "26.0.1"

{auto_editor-26.0.0 → auto_editor-26.0.1}/auto_editor/__main__.py

@@ -8,15 +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,
-    color,
     frame_rate,
     margin,
     number,
+    parse_color,
     resolution,
     sample_rate,
     speed,
@@ -108,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",
     )
@@ -166,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",
@@ -179,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",
@@ -285,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])
@@ -363,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-26.0.0 → auto_editor-26.0.1}/auto_editor/edit.py

@@ -3,6 +3,7 @@ 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
 
@@ -11,7 +12,7 @@ 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.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
 
@@ -164,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
 
@@ -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, ffmpeg, bar, log)
         else:
             audio_paths = []
 
@@ -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-26.0.0 → auto_editor-26.0.1}/auto_editor/ffwrapper.py

@@ -1,61 +1,40 @@
 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
+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
+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
 
-            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.")
+@dataclass(slots=True)
+class FFmpeg:
+    ffmpeg_location: str | None
+    path: str | None = None
 
-    return FFmpeg(log, path, show_cmd, debug)
+    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
 
-@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 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:

{auto_editor-26.0.0 → auto_editor-26.0.1}/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-26.0.0 → auto_editor-26.0.1}/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-26.0.0 → auto_editor-26.0.1}/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-26.0.0 → auto_editor-26.0.1}/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)

{auto_editor-26.0.0 → auto_editor-26.0.1}/auto_editor/render/audio.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import io
 from pathlib import Path
 from platform import system
-from subprocess import PIPE
 
 import av
 import numpy as np
@@ -17,6 +16,7 @@ from auto_editor.output import Ensure
 from auto_editor.timeline import TlAudio, v3
 from auto_editor.utils.bar import Bar
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
+from auto_editor.utils.container import Container
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import Args
 from auto_editor.wavfile import AudioData, read, write
@@ -122,8 +122,7 @@ def apply_audio_normalization(
             "null",
             file_null,
         ]
-        process = ffmpeg.Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
-        stderr = process.communicate()[1]
+        stderr = ffmpeg.Popen("EBU", cmd, log).communicate()[1]
         name, filter_args = parse_ebu_bytes(norm, stderr, log)
     else:
         assert "t" in norm
@@ -238,12 +237,90 @@ def process_audio_clip(
     return read(output_bytes)[1]
 
 
+def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
+    mixed_audio = None
+    max_length = 0
+
+    # First pass: determine the maximum length
+    for path in audio_paths:
+        container = av.open(path)
+        stream = container.streams.audio[0]
+
+        # Calculate duration in samples
+        assert stream.duration is not None
+        assert stream.time_base is not None
+        duration_samples = int(stream.duration * sr / stream.time_base.denominator)
+        max_length = max(max_length, duration_samples)
+        container.close()
+
+    # Second pass: read and mix audio
+    for path in audio_paths:
+        container = av.open(path)
+        stream = container.streams.audio[0]
+
+        resampler = av.audio.resampler.AudioResampler(
+            format="s16", layout="mono", rate=sr
+        )
+
+        audio_array: list[np.ndarray] = []
+        for frame in container.decode(audio=0):
+            frame.pts = None
+            resampled = resampler.resample(frame)[0]
+            audio_array.extend(resampled.to_ndarray().flatten())
+
+        # Pad or truncate to max_length
+        current_audio = np.array(audio_array[:max_length])
+        if len(current_audio) < max_length:
+            current_audio = np.pad(
+                current_audio, (0, max_length - len(current_audio)), "constant"
+            )
+
+        if mixed_audio is None:
+            mixed_audio = current_audio.astype(np.float32)
+        else:
+            mixed_audio += current_audio.astype(np.float32)
+
+        container.close()
+
+    if mixed_audio is None:
+        raise ValueError("mixed_audio is None")
+
+    # Normalize the mixed audio
+    max_val = np.max(np.abs(mixed_audio))
+    if max_val > 0:
+        mixed_audio = mixed_audio * (32767 / max_val)
+    mixed_audio = mixed_audio.astype(np.int16)  # type: ignore
+
+    output_container = av.open(output_path, mode="w")
+    output_stream = output_container.add_stream("pcm_s16le", rate=sr)
+
+    chunk_size = sr  # Process 1 second at a time
+    for i in range(0, len(mixed_audio), chunk_size):
+        # Shape becomes (1, samples) for mono
+        chunk = np.array([mixed_audio[i : i + chunk_size]])
+
+        frame = av.AudioFrame.from_ndarray(chunk, format="s16", layout="mono")
+        frame.rate = sr
+        frame.pts = i  # Set presentation timestamp
+
+        output_container.mux(output_stream.encode(frame))
+
+    output_container.mux(output_stream.encode(None))
+    output_container.close()
+
+
 def make_new_audio(
-    tl: v3, ensure: Ensure, args: Args, ffmpeg: FFmpeg, bar: Bar, log: Log
+    tl: v3,
+    ctr: Container,
+    ensure: Ensure,
+    args: Args,
+    ffmpeg: FFmpeg,
+    bar: Bar,
+    log: Log,
 ) -> list[str]:
     sr = tl.sr
     tb = tl.tb
-    output = []
+    output: list[str] = []
     samples: dict[tuple[FileInfo, int], AudioData] = {}
 
     norm = parse_norm(args.audio_normalize, log)
@@ -321,4 +398,9 @@ def make_new_audio(
         Path(temp, "asdf.map").unlink(missing_ok=True)
     except PermissionError:
         pass
+
+    if not (args.keep_tracks_separate and ctr.max_audios is None) and len(output) > 1:
+        new_a_file = f"{Path(temp, 'new_audio.wav')}"
+        mix_audio_files(sr, output, new_a_file)
+        return [new_a_file]
     return output

{auto_editor-26.0.0 → auto_editor-26.0.1}/auto_editor/render/subtitle.py

@@ -157,7 +157,7 @@ def make_srt(input_: Input, stream: int) -> str:
     return output_bytes.getvalue()
 
 
-def _ensure(input_: Input, format: str, stream: int, log: Log) -> str:
+def _ensure(input_: Input, format: str, stream: int) -> str:
     output_bytes = io.BytesIO()
     output = av.open(output_bytes, "w", format=format)
 
@@ -187,7 +187,9 @@ def make_new_subtitles(tl: v3, log: Log) -> list[str]:
             continue
 
         parser = SubtitleParser(tl.tb)
-        if sub.codec in ("webvtt", "ass", "ssa"):
+        if sub.codec == "ssa":
+            format = "ass"
+        elif sub.codec in ("webvtt", "ass"):
             format = sub.codec
         else:
             log.error(f"Unknown subtitle codec: {sub.codec}")
@@ -195,8 +197,8 @@ def make_new_subtitles(tl: v3, log: Log) -> list[str]:
         if sub.codec == "mov_text":
             ret = make_srt(input_, s)
         else:
-            ret = _ensure(input_, format, s, log)
-        parser.parse(ret, sub.codec)
+            ret = _ensure(input_, format, s)
+        parser.parse(ret, format)
         parser.edit(tl.v1.chunks)
 
         new_path = os.path.join(log.temp, f"new{s}s.{sub.ext}")

{auto_editor-26.0.0 → auto_editor-26.0.1}/auto_editor/render/video.py

@@ -8,7 +8,6 @@ import numpy as np
 
 from auto_editor.output import parse_bitrate
 from auto_editor.timeline import TlImage, TlRect, TlVideo
-from auto_editor.utils.types import color
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -203,7 +202,7 @@ def render_av(
 
     bar.start(tl.end, "Creating new video")
 
-    bg = color(args.background)
+    bg = args.background
     null_frame = make_solid(target_width, target_height, target_pix_fmt, bg)
     frame_index = -1
 

{auto_editor-26.0.0 → auto_editor-26.0.1}/auto_editor/subcommands/test.py

@@ -360,7 +360,7 @@ def main(sys_args: list[str] | None = None):
                 """{"version": "1", "source": "example.mp4", "chunks": [ [0, 26, 1.0], [26, 34, 0] ]}"""
             )
 
-        return run.main(["v1.json"], [])
+        return "v1.json", run.main(["v1.json"], [])
 
     def premiere_named_export():
         run.main(["example.mp4"], ["--export", 'premiere:name="Foo Bar"'])

{auto_editor-26.0.0 → auto_editor-26.0.1}/auto_editor/timeline.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 from auto_editor.ffwrapper import initFileInfo, mux
 from auto_editor.lib.contracts import *
 from auto_editor.utils.cmdkw import Required, pAttr, pAttrs
-from auto_editor.utils.types import color, natural, number, threshold
+from auto_editor.utils.types import natural, number, parse_color, threshold
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -165,7 +165,7 @@ rect_builder = pAttrs(
     pAttr("y", Required, is_int, int),
     pAttr("width", Required, is_int, int),
     pAttr("height", Required, is_int, int),
-    pAttr("fill", "#c4c4c4", is_str, color),
+    pAttr("fill", "#c4c4c4", is_str, parse_color),
 )
 visual_objects = {
     "rect": (TlRect, rect_builder),

{auto_editor-26.0.0 → auto_editor-26.0.1}/auto_editor/utils/cmdkw.py

@@ -35,11 +35,6 @@ class pAttrs:
         self.attrs = attrs
 
 
-def _norm_name(s: str) -> str:
-    # Python does not allow - in variable names
-    return s.replace("-", "_")
-
-
 class PLexer:
     __slots__ = ("text", "pos", "char")
 
@@ -101,6 +96,10 @@ def parse_with_palet(
     KEYWORD_SEP = "="
     kwargs: dict[str, Any] = {}
 
+    def _norm_name(s: str) -> str:
+        # Python does not allow - in variable names
+        return s.replace("-", "_")
+
     def go(text: str, c: Any) -> Any:
         try:
             env = _env if isinstance(_env, Env) else Env(_env)
@@ -174,9 +173,7 @@ def parse_with_palet(
     return kwargs
 
 
-def parse_method(
-    name: str, text: str, env: Env
-) -> tuple[str, list[Any], dict[str, Any]]:
+def parse_method(name: str, text: str) -> tuple[str, list[Any], dict[str, Any]]:
     from auto_editor.lang.palet import Lexer, Parser
 
     # Positional Arguments

{auto_editor-26.0.0 → auto_editor-26.0.1}/auto_editor/utils/container.py

@@ -55,12 +55,9 @@ def codec_type(x: str) -> str:
         return "subtitle"
 
     try:
-        return Codec(x, "r").type
+        return Codec(x, "w").type
     except Exception:
-        try:
-            return Codec(x, "w").type
-        except Exception:
-            return ""
+        return ""
 
 
 def container_constructor(ext: str) -> Container:

{auto_editor-26.0.0 → auto_editor-26.0.1}/auto_editor/utils/func.py

@@ -81,21 +81,10 @@ def mut_margin(arr: BoolList, start_m: int, end_m: int) -> None:
             arr[max(i + end_m, 0) : i] = False
 
 
-def merge(start_list: np.ndarray, end_list: np.ndarray) -> BoolList:
-    result = np.zeros((len(start_list)), dtype=np.bool_)
-
-    for i, item in enumerate(start_list):
-        if item == True:
-            where = np.where(end_list[i:])[0]
-            if len(where) > 0:
-                result[i : where[0]] = True
-    return result
-
-
 def get_stdout(cmd: list[str]) -> str:
     from subprocess import DEVNULL, PIPE, Popen
 
-    stdout, _ = Popen(cmd, stdin=DEVNULL, stdout=PIPE, stderr=PIPE).communicate()
+    stdout = Popen(cmd, stdin=DEVNULL, stdout=PIPE, stderr=PIPE).communicate()[0]
     return stdout.decode("utf-8", "replace")
 
 
@@ -116,25 +105,3 @@ def aspect_ratio(width: int, height: int) -> tuple[int, int]:
 
     c = gcd(width, height)
     return width // c, height // c
-
-
-def human_readable_time(time_in_secs: float) -> str:
-    units = "seconds"
-    if time_in_secs >= 3600:
-        time_in_secs = round(time_in_secs / 3600, 1)
-        if time_in_secs % 1 == 0:
-            time_in_secs = round(time_in_secs)
-        units = "hours"
-    if time_in_secs >= 60:
-        time_in_secs = round(time_in_secs / 60, 1)
-        if time_in_secs >= 10 or time_in_secs % 1 == 0:
-            time_in_secs = round(time_in_secs)
-        units = "minutes"
-    return f"{time_in_secs} {units}"
-
-
-def append_filename(path: str, val: str) -> str:
-    from os.path import splitext
-
-    root, ext = splitext(path)
-    return root + val + ext

{auto_editor-26.0.0 → auto_editor-26.0.1}/auto_editor/utils/types.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import re
 from dataclasses import dataclass, field
 from fractions import Fraction
-from typing import Literal
 
 
 class CoerceError(Exception):
@@ -156,16 +155,7 @@ def speed_range(val: str) -> tuple[float, str, str]:
     return number(a[0]), a[1], a[2]
 
 
-Stream = int | Literal["all"]
-
-
-def stream(val: str) -> Stream:
-    if val == "all" or val == "'all":
-        return "all"
-    return natural(val)
-
-
-def color(val: str) -> str:
+def parse_color(val: str) -> str:
     """
     Convert a color str into an RGB tuple
 
@@ -219,7 +209,7 @@ class Args:
     frame_rate: Fraction | None = None
     sample_rate: int | None = None
     resolution: tuple[int, int] | None = None
-    background: str = "#000"
+    background: str = "#000000"
     edit_based_on: str = "audio"
     keep_tracks_separate: bool = False
     audio_normalize: str = "#f"
@@ -228,13 +218,10 @@ class Args:
     no_open: bool = False
     temp_dir: str | None = None
     ffmpeg_location: str | None = None
-    my_ffmpeg: bool = False
     progress: str = "modern"
     version: bool = False
     debug: bool = False
     config: bool = False
-    show_ffmpeg_commands: bool = False
-    show_ffmpeg_output: bool = False
     quiet: bool = False
     preview: bool = False
     no_cache: bool = False

{auto_editor-26.0.0 → auto_editor-26.0.1}/auto_editor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 26.0.0
+Version: 26.0.1
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense
@@ -13,7 +13,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy<3.0,>=1.23.0
 Requires-Dist: pyav==13.1.*
-Requires-Dist: ae-ffmpeg==1.2.*
 
 <p align="center"><img src="https://auto-editor.com/img/auto-editor-banner.webp" title="Auto-Editor" width="700"></p>
 

{auto_editor-26.0.0 → auto_editor-26.0.1}/auto_editor.egg-info/SOURCES.txt

@@ -52,7 +52,6 @@ auto_editor/utils/bar.py
 auto_editor/utils/chunks.py
 auto_editor/utils/cmdkw.py
 auto_editor/utils/container.py
-auto_editor/utils/encoder.py
 auto_editor/utils/func.py
 auto_editor/utils/log.py
 auto_editor/utils/types.py

{auto_editor-26.0.0 → auto_editor-26.0.1}/auto_editor.egg-info/requires.txt

@@ -1,3 +1,2 @@
 numpy<3.0,>=1.23.0
 pyav==13.1.*
-ae-ffmpeg==1.2.*

{auto_editor-26.0.0 → auto_editor-26.0.1}/pyproject.toml

@@ -11,7 +11,6 @@ requires-python = ">=3.10,<3.14"
 dependencies = [
     "numpy>=1.23.0,<3.0",
     "pyav==13.1.*",
-    "ae-ffmpeg==1.2.*",
 ]
 keywords = [
     "video", "audio", "media", "editor", "editing",

auto_editor-26.0.0/auto_editor/__init__.py

@@ -1 +0,0 @@
-__version__ = "26.0.0"

auto_editor-26.0.0/auto_editor/utils/encoder.py

@@ -1,135 +0,0 @@
-encoders = {
-    "libx264": (
-        "yuv420p",
-        "yuvj420p",
-        "yuv422p",
-        "yuvj422p",
-        "yuv444p",
-        "yuvj444p",
-        "nv12",
-        "nv16",
-        "nv21",
-        "yuv420p10le",
-        "yuv422p10le",
-        "yuv444p10le",
-        "nv20le",
-        "gray",
-        "gray10le",
-    ),
-    "libx264rgb": ("bgr0", "bgr24", "rgb24"),
-    "h264_videotoolbox": ("videotoolbox_vld", "nv12", "yuv420p"),
-    "h264": ("videotoolbox_vld", "nv12", "yuv420p"),
-    "libx265": (
-        "yuv420p",
-        "yuvj420p",
-        "yuv422p",
-        "yuvj422p",
-        "yuv444p",
-        "yuvj444p",
-        "gbrp",
-        "yuv420p10le",
-        "yuv422p10le",
-        "yuv444p10le",
-        "gbrp10le",
-        "yuv420p12le",
-        "yuv422p12le",
-        "yuv444p12le",
-        "gbrp12le",
-        "gray",
-        "gray10le",
-        "gray12le",
-    ),
-    "hevc_videotoolbox": ("videotoolbox_vld", "nv12", "yuv420p", "bgra", "p010le"),
-    "hevc": (
-        "yuv420p",
-        "yuvj420p",
-        "yuv422p",
-        "yuvj422p",
-        "yuv444p",
-        "yuvj444p",
-        "gbrp",
-        "yuv420p10le",
-        "yuv422p10le",
-        "yuv444p10le",
-        "gbrp10le",
-        "yuv420p12le",
-        "yuv422p12le",
-        "yuv444p12le",
-        "gbrp12le",
-        "gray",
-        "gray10le",
-        "gray12le",
-    ),
-    "hevc_nvenc": (
-        "yuv420p",
-        "nv12",
-        "p010le",
-        "yuv444p",
-        "p016le",
-        "yuv444p16le",
-        "bgr0",
-        "rgb0",
-        "gbrp",
-        "gbrp16le",
-        "cuda",
-        "d3d11",
-    ),
-    "hevc_amf": ("yuv420p", "nv12", "d3d11", "dxva2_vld"),
-    "h264_nvenc": (
-        "yuv420p",
-        "nv12",
-        "p010le",
-        "yuv444p",
-        "p016le",
-        "yuv444p16le",
-        "bgr0",
-        "rgb0",
-        "gbrp",
-        "gbrp16le",
-        "cuda",
-        "d3d11",
-    ),
-    "h264_amf": ("yuv420p", "nv12", "d3d11", "dxva2_vld"),
-    "hevc_qsv": ("nv12", "p010le", "yuyv422", "y210le", "qsv", "bgra", "x2rgb10le"),
-    "h264_qsv": ("nv12", "p010le", "qsv"),
-    "vp9": (
-        "yuv420p",
-        "yuva420p",
-        "yuv422p",
-        "yuv440p",
-        "yuv444p",
-        "yuv420p10le",
-        "yuv422p10le",
-        "yuv440p10le",
-        "yuv444p10le",
-        "yuv420p12le",
-        "yuv422p12le",
-        "yuv440p12le",
-        "yuv444p12le",
-        "gbrp",
-        "gbrp10le",
-        "gbrp12le",
-    ),
-    "vp8": ("yuv420p", "yuva420p"),
-    "prores": ("yuv422p10le", "yuv444p10le", "yuva444p10le"),
-    "av1": (
-        "yuv420p",
-        "yuv422p",
-        "yuv444p",
-        "gbrp",
-        "yuv420p10le",
-        "yuv422p10le",
-        "yuv444p10le",
-        "yuv420p12le",
-        "yuv422p12le",
-        "yuv444p12le",
-        "gbrp10le",
-        "gbrp12le",
-        "gray",
-        "gray10le",
-        "gray12le",
-    ),
-    "mpeg4": ("yuv420p"),
-    "mpeg2video": ("yuv420p", "yuv422p"),
-    "mjpeg": ("yuvj420p", "yuvj422p", "yuvj444p"),
-}