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

auto_editor/lib/contracts.py

@@ -5,6 +5,8 @@ from dataclasses import dataclass
 from fractions import Fraction
 from typing import Any
 
+from numpy import float64
+
 from .data_structs import Sym, print_str
 from .err import MyError
 
@@ -41,7 +43,7 @@ def check_contract(c: object, val: object) -> bool:
         return val is True
     if c is False:
         return val is False
-    if type(c) in (int, float, Fraction, complex, str, Sym):
+    if type(c) in (int, float, float64, Fraction, complex, str, Sym):
         return val == c
     raise MyError(f"Invalid contract, got: {print_str(c)}")
 
@@ -163,17 +165,21 @@ is_int = Contract("int?", lambda v: type(v) is int)
 is_nat = Contract("nat?", lambda v: type(v) is int and v > -1)
 is_nat1 = Contract("nat1?", lambda v: type(v) is int and v > 0)
 int_not_zero = Contract("(or/c (not/c 0) int?)", lambda v: v != 0 and is_int(v))
-is_num = Contract("number?", lambda v: type(v) in (int, float, Fraction, complex))
-is_real = Contract("real?", lambda v: type(v) in (int, float, Fraction))
-is_float = Contract("float?", lambda v: type(v) is float)
+is_num = Contract(
+    "number?", lambda v: type(v) in (int, float, float64, Fraction, complex)
+)
+is_real = Contract("real?", lambda v: type(v) in (int, float, float64, Fraction))
+is_float = Contract("float?", lambda v: type(v) in (float, float64))
 is_frac = Contract("frac?", lambda v: type(v) is Fraction)
 is_str = Contract("string?", lambda v: type(v) is str)
 any_p = Contract("any", lambda v: True)
 is_void = Contract("void?", lambda v: v is None)
-is_int_or_float = Contract("(or/c int? float?)", lambda v: type(v) in (int, float))
+is_int_or_float = Contract(
+    "(or/c int? float?)", lambda v: type(v) in (int, float, float64)
+)
 is_threshold = Contract(
     "threshold?",
-    lambda v: type(v) in (int, float) and v >= 0 and v <= 1,  # type: ignore
+    lambda v: type(v) in (int, float, float64) and v >= 0 and v <= 1,  # type: ignore
 )
 is_proc = Contract("procedure?", lambda v: isinstance(v, Proc | Contract))
 

auto_editor/make_layers.py

@@ -18,7 +18,6 @@ from auto_editor.utils.types import Args, CoerceError, time
 if TYPE_CHECKING:
     from numpy.typing import NDArray
 
-    from auto_editor.output import Ensure
     from auto_editor.utils.bar import Bar
     from auto_editor.utils.chunks import Chunks
     from auto_editor.utils.log import Log
@@ -75,7 +74,6 @@ def make_av(src: FileInfo, all_clips: list[list[Clip]]) -> tuple[VSpace, ASpace]
 def run_interpreter_for_edit_option(
     text: str, filesetup: FileSetup
 ) -> NDArray[np.bool_]:
-    ensure = filesetup.ensure
     src = filesetup.src
     tb = filesetup.tb
     bar = filesetup.bar
@@ -87,8 +85,8 @@ def run_interpreter_for_edit_option(
         if log.is_debug:
             log.debug(f"edit: {parser}")
 
-        env["timebase"] = filesetup.tb
-        env["@levels"] = Levels(ensure, src, tb, bar, temp, log)
+        env["timebase"] = tb
+        env["@levels"] = Levels(src, tb, bar, temp, log)
         env["@filesetup"] = filesetup
 
         results = interpret(env, parser)
@@ -139,7 +137,6 @@ def parse_time(val: str, arr: NDArray, tb: Fraction) -> int:  # raises: `CoerceE
 
 def make_timeline(
     sources: list[FileInfo],
-    ensure: Ensure,
     args: Args,
     sr: int,
     bar: Bar,
@@ -169,7 +166,7 @@ def make_timeline(
     concat = np.concatenate
 
     for i, src in enumerate(sources):
-        filesetup = FileSetup(src, ensure, len(sources) < 2, tb, bar, temp, log)
+        filesetup = FileSetup(src, len(sources) < 2, tb, bar, temp, log)
 
         edit_result = run_interpreter_for_edit_option(method, filesetup)
         mut_margin(edit_result, start_margin, end_margin)
@@ -296,22 +293,4 @@ def make_timeline(
     else:
         v1_compatiable = None
 
-    tl = v3(inp, tb, sr, res, args.background, vtl, atl, v1_compatiable)
-
-    # Additional monotonic check, o(n^2) time complexity so disable by default.
-
-    # if len(sources) != 1:
-    #     return tl
-
-    # last_i = 0
-    # for index in range(tl.end):
-    #     for layer in tl.v:
-    #         for lobj in layer:
-    #             if index >= lobj.start and index < (lobj.start + lobj.dur):
-    #                 _i = round((lobj.offset + index - lobj.start) * lobj.speed)
-    #                 if (_i < last_i):
-    #                     print(_i, last_i)
-    #                     raise ValueError("not monotonic")
-    #                 last_i = _i
-
-    return tl
+    return v3(inp, tb, sr, res, args.background, vtl, atl, v1_compatiable)

auto_editor/output.py

@@ -57,7 +57,7 @@ class Ensure:
             output_astream = out_container.add_stream("pcm_s16le", rate=sample_rate)
             assert isinstance(output_astream, av.audio.stream.AudioStream)
 
-            resampler = AudioResampler(format="s16", layout="stereo", rate=sample_rate)  # type: ignore
+            resampler = AudioResampler(format="s16", layout="stereo", rate=sample_rate)
             for i, frame in enumerate(in_container.decode(astream)):
                 if i % 1500 == 0:
                     bar.tick(0 if frame.time is None else frame.time)
@@ -99,7 +99,7 @@ def _ffset(option: str, value: str | None) -> list[str]:
     return [option] + [value]
 
 
-def video_quality(args: Args, ctr: Container) -> list[str]:
+def video_quality(args: Args) -> list[str]:
     return (
         _ffset("-b:v", args.video_bitrate)
         + ["-c:v", args.video_codec]
@@ -174,7 +174,7 @@ def mux_quality_media(
     for is_video, path in visual_output:
         if is_video:
             if apply_v:
-                cmd += video_quality(args, ctr)
+                cmd += video_quality(args)
             else:
                 # Real video is only allowed on track 0
                 cmd += ["-c:v:0", "copy"]
@@ -211,7 +211,7 @@ def mux_quality_media(
             cmd.extend(["-c:s", scodec])
         elif ctr.scodecs is not None:
             if scodec not in ctr.scodecs:
-                scodec = ctr.scodecs[0]
+                scodec = ctr.default_sub
             cmd.extend(["-c:s", scodec])
 
     if a_tracks > 0:

auto_editor/preview.py

@@ -6,7 +6,6 @@ from statistics import fmean, median
 from typing import TextIO
 
 from auto_editor.analyze import Levels
-from auto_editor.output import Ensure
 from auto_editor.timeline import v3
 from auto_editor.utils.bar import Bar
 from auto_editor.utils.func import to_timecode
@@ -49,7 +48,7 @@ def all_cuts(tl: v3, in_len: int) -> list[int]:
     return cut_lens
 
 
-def preview(ensure: Ensure, tl: v3, temp: str, log: Log) -> None:
+def preview(tl: v3, temp: str, log: Log) -> None:
     log.conwrite("")
     tb = tl.tb
 
@@ -66,7 +65,7 @@ def preview(ensure: Ensure, tl: v3, temp: str, log: Log) -> None:
 
     in_len = 0
     for src in all_sources:
-        in_len += Levels(ensure, src, tb, Bar("none"), temp, log).media_length
+        in_len += Levels(src, tb, Bar("none"), temp, log).media_length
 
     out_len = tl.out_len()
 

auto_editor/render/subtitle.py

@@ -49,7 +49,7 @@ class SubtitleParser:
         self.codec = codec
         self.contents = []
 
-        if codec == "ass":
+        if codec == "ass" or codec == "ssa":
             time_code = re.compile(r"(.*)(\d+:\d+:[\d.]+)(.*)(\d+:\d+:[\d.]+)(.*)")
         elif codec == "webvtt":
             time_code = re.compile(r"()(\d+:[\d.]+)( --> )(\d+:[\d.]+)(\n.*)")

auto_editor/render/video.py

@@ -17,8 +17,6 @@ from auto_editor.utils.types import color
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
-    from av.filter import FilterContext
-
     from auto_editor.ffwrapper import FFmpeg, FileInfo
     from auto_editor.timeline import v3
     from auto_editor.utils.bar import Bar
@@ -33,11 +31,6 @@ class VideoFrame:
     src: FileInfo
 
 
-def link_nodes(*nodes: FilterContext) -> None:
-    for c, n in zip(nodes, nodes[1:]):
-        c.link_to(n)
-
-
 # From: github.com/PyAV-Org/PyAV/blob/main/av/video/frame.pyx
 allowed_pix_fmt = {
     "yuv420p",
@@ -98,12 +91,11 @@ def make_image_cache(tl: v3) -> dict[tuple[FileInfo, int], np.ndarray]:
                     for frame in cn.decode(my_stream):
                         if obj.width != 0:
                             graph = av.filter.Graph()
-                            link_nodes(
+                            graph.link_nodes(
                                 graph.add_buffer(template=my_stream),
                                 graph.add("scale", f"{obj.width}:-1"),
                                 graph.add("buffersink"),
-                            )
-                            graph.vpush(frame)
+                            ).vpush(frame)
                             frame = graph.vpull()
                         img_cache[(obj.src, obj.width)] = frame.to_ndarray(
                             format="rgb24"
@@ -177,7 +169,7 @@ def render_av(
         target_width = max(round(tl.res[0] * args.scale), 2)
         target_height = max(round(tl.res[1] * args.scale), 2)
         scale_graph = av.filter.Graph()
-        link_nodes(
+        scale_graph.link_nodes(
             scale_graph.add(
                 "buffer", video_size="1x1", time_base="1/1", pix_fmt=target_pix_fmt
             ),
@@ -213,7 +205,7 @@ def render_av(
     if apply_video_later:
         cmd += ["-c:v", "mpeg4", "-qscale:v", "1"]
     else:
-        cmd += video_quality(args, ctr)
+        cmd += video_quality(args)
 
     # Setting SAR requires re-encoding so we do it here.
     if src is not None and src.videos and (sar := src.videos[0].sar) is not None:
@@ -293,7 +285,7 @@ def render_av(
                     if (frame.width, frame.height) != tl.res:
                         width, height = tl.res
                         graph = av.filter.Graph()
-                        link_nodes(
+                        graph.link_nodes(
                             graph.add_buffer(template=my_stream),
                             graph.add(
                                 "scale",
@@ -301,21 +293,19 @@ def render_av(
                             ),
                             graph.add("pad", f"{width}:{height}:-1:-1:color={bg}"),
                             graph.add("buffersink"),
-                        )
-                        graph.vpush(frame)
+                        ).vpush(frame)
                         frame = graph.vpull()
                 elif isinstance(obj, TlRect):
                     graph = av.filter.Graph()
                     x, y = apply_anchor(obj.x, obj.y, obj.width, obj.height, obj.anchor)
-                    link_nodes(
+                    graph.link_nodes(
                         graph.add_buffer(template=my_stream),
                         graph.add(
                             "drawbox",
                             f"x={x}:y={y}:w={obj.width}:h={obj.height}:color={obj.fill}:t=fill",
                         ),
                         graph.add("buffersink"),
-                    )
-                    graph.vpush(frame)
+                    ).vpush(frame)
                     frame = graph.vpull()
                 elif isinstance(obj, TlImage):
                     img = img_cache[(obj.src, obj.width)]

auto_editor/subcommands/levels.py

@@ -2,22 +2,30 @@ from __future__ import annotations
 
 import sys
 from dataclasses import dataclass, field
+from fractions import Fraction
 from typing import TYPE_CHECKING
 
 import numpy as np
 
-from auto_editor.analyze import LevelError, Levels, builder_map
-from auto_editor.ffwrapper import FFmpeg, initFileInfo
+from auto_editor.analyze import LevelError, Levels, iter_audio, iter_motion
+from auto_editor.ffwrapper import initFileInfo
 from auto_editor.lang.palet import env
-from auto_editor.output import Ensure
+from auto_editor.lib.contracts import is_bool, is_nat, is_nat1, is_str, is_void, orc
 from auto_editor.utils.bar import Bar
-from auto_editor.utils.cmdkw import ParserError, parse_with_palet
+from auto_editor.utils.cmdkw import (
+    ParserError,
+    Required,
+    parse_with_palet,
+    pAttr,
+    pAttrs,
+)
 from auto_editor.utils.func import setup_tempdir
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import frame_rate
 from auto_editor.vanparse import ArgumentParser
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator
     from fractions import Fraction
 
     from numpy.typing import NDArray
@@ -28,8 +36,6 @@ class LevelArgs:
     input: list[str] = field(default_factory=list)
     edit: str = "audio"
     timebase: Fraction | None = None
-    ffmpeg_location: str | None = None
-    my_ffmpeg: bool = False
     help: bool = False
 
 
@@ -47,16 +53,12 @@ def levels_options(parser: ArgumentParser) -> ArgumentParser:
         type=frame_rate,
         help="Set custom timebase",
     )
-    parser.add_argument("--ffmpeg-location", help="Point to your custom ffmpeg file")
-    parser.add_argument(
-        "--my-ffmpeg",
-        flag=True,
-        help="Use the ffmpeg on your PATH instead of the one packaged",
-    )
     return parser
 
 
 def print_arr(arr: NDArray) -> None:
+    print("")
+    print("@start")
     if arr.dtype == np.float64:
         for a in arr:
             sys.stdout.write(f"{a:.20f}\n")
@@ -66,14 +68,25 @@ def print_arr(arr: NDArray) -> None:
     else:
         for a in arr:
             sys.stdout.write(f"{a}\n")
+    sys.stdout.flush()
+    print("")
+
+
+def print_arr_gen(arr: Iterator[int | float]) -> None:
+    print("")
+    print("@start")
+    for a in arr:
+        if isinstance(a, float):
+            print(f"{a:.20f}")
+        else:
+            print(a)
+    print("")
 
 
 def main(sys_args: list[str] = sys.argv[1:]) -> None:
     parser = levels_options(ArgumentParser("levels"))
     args = parser.parse_args(LevelArgs, sys_args)
 
-    ffmpeg = FFmpeg(args.ffmpeg_location, args.my_ffmpeg)
-
     bar = Bar("none")
     temp = setup_tempdir(None, Log())
     log = Log(quiet=True, temp=temp)
@@ -85,44 +98,48 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
     src = sources[0]
 
     tb = src.get_fps() if args.timebase is None else args.timebase
-    ensure = Ensure(ffmpeg, bar, src.get_sr(), temp, log)
 
     if ":" in args.edit:
         method, attrs = args.edit.split(":", 1)
     else:
         method, attrs = args.edit, ""
 
-    for src in sources:
-        print("")
-        print("@start")
+    audio_builder = pAttrs("audio", pAttr("stream", 0, is_nat))
+    motion_builder = pAttrs(
+        "motion",
+        pAttr("stream", 0, is_nat),
+        pAttr("blur", 9, is_nat),
+        pAttr("width", 400, is_nat1),
+    )
+    subtitle_builder = pAttrs(
+        "subtitle",
+        pAttr("pattern", Required, is_str),
+        pAttr("stream", 0, is_nat),
+        pAttr("ignore-case", False, is_bool),
+        pAttr("max-count", None, orc(is_nat, is_void)),
+    )
 
-        levels = Levels(ensure, src, tb, bar, temp, log)
+    builder_map = {
+        "audio": audio_builder,
+        "motion": motion_builder,
+        "subtitle": subtitle_builder,
+    }
 
+    for src in sources:
         if method in builder_map:
-            builder = builder_map[method]
-
             try:
-                obj = parse_with_palet(attrs, builder, env)
+                obj = parse_with_palet(attrs, builder_map[method], env)
             except ParserError as e:
                 log.error(e)
 
-            if "threshold" in obj:
-                del obj["threshold"]
-
+        levels = Levels(src, tb, bar, temp, log)
         try:
             if method == "audio":
-                print_arr(levels.audio(obj["stream"]))
+                print_arr_gen(iter_audio(src, tb, **obj))
             elif method == "motion":
-                print_arr(levels.motion(obj["stream"], obj["blur"], obj["width"]))
+                print_arr_gen(iter_motion(src, tb, **obj))
             elif method == "subtitle":
-                print_arr(
-                    levels.subtitle(
-                        obj["pattern"],
-                        obj["stream"],
-                        obj["ignore_case"],
-                        obj["max_count"],
-                    )
-                )
+                print_arr(levels.subtitle(**obj))
             elif method == "none":
                 print_arr(levels.none())
             elif method == "all/e":
@@ -132,8 +149,6 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
         except LevelError as e:
             log.error(e)
 
-    sys.stdout.flush()
-    print("")
     log.cleanup()
 
 

auto_editor/subcommands/repl.py

@@ -6,11 +6,10 @@ from fractions import Fraction
 
 import auto_editor
 from auto_editor.analyze import FileSetup, Levels
-from auto_editor.ffwrapper import FFmpeg, initFileInfo
+from auto_editor.ffwrapper import initFileInfo
 from auto_editor.lang.palet import ClosingError, Lexer, Parser, env, interpret
 from auto_editor.lib.data_structs import print_str
 from auto_editor.lib.err import MyError
-from auto_editor.output import Ensure
 from auto_editor.utils.bar import Bar
 from auto_editor.utils.func import setup_tempdir
 from auto_editor.utils.log import Log
@@ -48,12 +47,6 @@ def repl_options(parser: ArgumentParser) -> ArgumentParser:
         type=frame_rate,
         help="Set custom timebase",
     )
-    parser.add_argument("--ffmpeg-location", help="Point to your custom ffmpeg file")
-    parser.add_argument(
-        "--my-ffmpeg",
-        flag=True,
-        help="Use the ffmpeg on your PATH instead of the one packaged",
-    )
     parser.add_argument(
         "--temp-dir",
         metavar="PATH",
@@ -68,16 +61,14 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
     if args.input:
         temp = setup_tempdir(args.temp_dir, Log())
         log = Log(quiet=True, temp=temp)
-        ffmpeg = FFmpeg(args.ffmpeg_location, args.my_ffmpeg, False)
         strict = len(args.input) < 2
         sources = [initFileInfo(path, log) for path in args.input]
         src = sources[0]
         tb = src.get_fps() if args.timebase is None else args.timebase
-        bar = Bar("none")
-        ensure = Ensure(ffmpeg, bar, src.get_sr(), temp, log)
+        bar = Bar("modern")
         env["timebase"] = tb
-        env["@levels"] = Levels(ensure, src, tb, bar, temp, log)
-        env["@filesetup"] = FileSetup(src, ensure, strict, tb, bar, temp, log)
+        env["@levels"] = Levels(src, tb, bar, temp, log)
+        env["@filesetup"] = FileSetup(src, strict, tb, bar, temp, log)
 
     print(f"Auto-Editor {auto_editor.version} ({auto_editor.__version__})")
     text = None

auto_editor/subcommands/subdump.py

@@ -1,7 +1,7 @@
 import sys
 
 import av
-from av.subtitles.subtitle import AssSubtitle, TextSubtitle
+from av.subtitles.subtitle import AssSubtitle
 
 
 def main(sys_args: list[str] = sys.argv[1:]) -> None:
@@ -9,13 +9,10 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
         with av.open(input_file) as container:
             for s in range(len(container.streams.subtitles)):
                 print(f"file: {input_file} ({s}:{container.streams.subtitles[s].name})")
-                for packet in container.demux(subtitles=s):
-                    for subset in packet.decode():
-                        for sub in subset.rects:
-                            if isinstance(sub, AssSubtitle):
-                                print(sub.ass.decode("utf-8", errors="ignore"))
-                            elif isinstance(sub, TextSubtitle):
-                                print(sub.text.decode("utf-8", errors="ignore"))
+                for subset in container.decode(subtitles=s):
+                    for sub in subset:
+                        if isinstance(sub, AssSubtitle):
+                            print(sub.ass.decode("utf-8", errors="ignore"))
         print("------")