auto-editor 26.3.1__tar.gz → 26.3.3__tar.gz

{auto_editor-26.3.1 → auto_editor-26.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: auto-editor
-Version: 26.3.1
+Version: 26.3.3
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense
@@ -21,7 +21,7 @@ Requires-Dist: pyav==14.2.*
 ---
 
 [![Actions Status](https://github.com/wyattblue/auto-editor/workflows/build/badge.svg)](https://github.com/wyattblue/auto-editor/actions)
-<a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 
 Before doing the real editing, you first cut out the "dead space" which is typically silence. This is known as a "first pass". Cutting these is a boring task, especially if the video is very long.
 

{auto_editor-26.3.1 → auto_editor-26.3.3}/README.md

@@ -5,7 +5,7 @@
 ---
 
 [![Actions Status](https://github.com/wyattblue/auto-editor/workflows/build/badge.svg)](https://github.com/wyattblue/auto-editor/actions)
-<a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 
 Before doing the real editing, you first cut out the "dead space" which is typically silence. This is known as a "first pass". Cutting these is a boring task, especially if the video is very long.
 

auto_editor-26.3.3/auto_editor/__init__.py

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

{auto_editor-26.3.1 → auto_editor-26.3.3}/auto_editor/__main__.py

@@ -3,6 +3,9 @@
 import platform as plat
 import re
 import sys
+from dataclasses import dataclass, field
+from fractions import Fraction
+from io import StringIO
 from os import environ
 from os.path import exists, isdir, isfile, lexists, splitext
 from subprocess import run
@@ -11,21 +14,127 @@ import auto_editor
 from auto_editor.utils.func import get_stdout
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import (
-    Args,
+    CoerceError,
     frame_rate,
-    margin,
+    natural,
     number,
     parse_color,
-    resolution,
-    sample_rate,
-    speed,
-    speed_range,
-    time_range,
+    split_num_str,
 )
 from auto_editor.vanparse import ArgumentParser
 
 
+@dataclass(slots=True)
+class Args:
+    input: list[str] = field(default_factory=list)
+    help: bool = False
+
+    # Editing Options
+    margin: tuple[str, str] = ("0.2s", "0.2s")
+    edit: str = "audio"
+    export: str | None = None
+    output: str | None = None
+    silent_speed: float = 99999.0
+    video_speed: float = 1.0
+    cut_out: list[tuple[str, str]] = field(default_factory=list)
+    add_in: list[tuple[str, str]] = field(default_factory=list)
+    set_speed_for_range: list[tuple[float, str, str]] = field(default_factory=list)
+
+    # Timeline Options
+    frame_rate: Fraction | None = None
+    sample_rate: int | None = None
+    resolution: tuple[int, int] | None = None
+    background: str = "#000000"
+
+    # URL download Options
+    yt_dlp_location: str = "yt-dlp"
+    download_format: str | None = None
+    output_format: str | None = None
+    yt_dlp_extras: str | None = None
+
+    # Display Options
+    progress: str = "modern"
+    debug: bool = False
+    quiet: bool = False
+    preview: bool = False
+
+    # Container Settings
+    sn: bool = False
+    dn: bool = False
+    faststart: bool = False
+    no_faststart: bool = False
+    fragmented: bool = False
+    no_fragmented: bool = False
+
+    # Video Rendering
+    video_codec: str = "auto"
+    video_bitrate: str = "auto"
+    vprofile: str | None = None
+    scale: float = 1.0
+    no_seek: bool = False
+
+    # Audio Rendering
+    audio_codec: str = "auto"
+    audio_bitrate: str = "auto"
+    keep_tracks_separate: bool = False
+    audio_normalize: str = "#f"
+
+    # Misc.
+    config: bool = False
+    no_cache: bool = False
+    no_open: bool = False
+    temp_dir: str | None = None
+    player: str | None = None
+    version: bool = False
+
+
 def main_options(parser: ArgumentParser) -> ArgumentParser:
+    def margin(val: str) -> tuple[str, str]:
+        vals = val.strip().split(",")
+        if len(vals) == 1:
+            vals.append(vals[0])
+        if len(vals) != 2:
+            raise CoerceError("--margin has too many arguments.")
+        return vals[0], vals[1]
+
+    def speed(val: str) -> float:
+        _s = number(val)
+        if _s <= 0 or _s > 99999:
+            return 99999.0
+        return _s
+
+    def resolution(val: str | None) -> tuple[int, int] | None:
+        if val is None:
+            return None
+        vals = val.strip().split(",")
+        if len(vals) != 2:
+            raise CoerceError(f"'{val}': Resolution takes two numbers")
+        return natural(vals[0]), natural(vals[1])
+
+    def sample_rate(val: str) -> int:
+        num, unit = split_num_str(val)
+        if unit in {"kHz", "KHz"}:
+            return natural(num * 1000)
+        if unit not in {"", "Hz"}:
+            raise CoerceError(f"Unknown unit: '{unit}'")
+        return natural(num)
+
+    def _comma_coerce(name: str, val: str, num_args: int) -> list[str]:
+        vals = val.strip().split(",")
+        if num_args > len(vals):
+            raise CoerceError(f"Too few arguments for {name}.")
+        if len(vals) > num_args:
+            raise CoerceError(f"Too many arguments for {name}.")
+        return vals
+
+    def time_range(val: str) -> tuple[str, str]:
+        a = _comma_coerce("time_range", val, 2)
+        return a[0], a[1]
+
+    def speed_range(val: str) -> tuple[float, str, str]:
+        a = _comma_coerce("speed_range", val, 3)
+        return number(a[0]), a[1], a[2]
+
     parser.add_required("input", nargs="*", metavar="[file | url ...] [options]")
     parser.add_text("Editing Options:")
     parser.add_argument(
@@ -40,6 +149,16 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         metavar="METHOD",
         help="Set an expression which determines how to make auto edits",
     )
+    parser.add_argument(
+        "--export", "-ex", metavar="EXPORT:ATTRS?", help="Choose the export mode"
+    )
+    parser.add_argument(
+        "--output",
+        "--output-file",
+        "-o",
+        metavar="FILE",
+        help="Set the name/path of the new output file",
+    )
     parser.add_argument(
         "--silent-speed",
         "-s",
@@ -110,12 +229,6 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         metavar="COLOR",
         help="Set the background as a solid RGB color",
     )
-    parser.add_argument(
-        "--add",
-        nargs="*",
-        metavar="OBJ:START,DUR,ATTRS?",
-        help="Insert an audio/video object to the timeline",
-    )
     parser.add_text("URL Download Options:")
     parser.add_argument(
         "--yt-dlp-location",
@@ -137,28 +250,6 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         metavar="CMD",
         help="Add extra options for yt-dlp. Must be in quotes",
     )
-    parser.add_text("Utility Options:")
-    parser.add_argument(
-        "--export", "-ex", metavar="EXPORT:ATTRS?", help="Choose the export mode"
-    )
-    parser.add_argument(
-        "--output-file",
-        "--output",
-        "-o",
-        metavar="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"
-    )
-    parser.add_argument(
-        "--no-open", flag=True, help="Do not open the output file after editing is done"
-    )
-    parser.add_argument(
-        "--temp-dir",
-        metavar="PATH",
-        help="Set where the temporary directory is located",
-    )
     parser.add_text("Display Options:")
     parser.add_argument(
         "--progress",
@@ -174,6 +265,37 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         flag=True,
         help="Show stats on how the input will be cut and halt",
     )
+    parser.add_text("Container Settings:")
+    parser.add_argument(
+        "-sn",
+        flag=True,
+        help="Disable the inclusion of subtitle streams in the output file",
+    )
+    parser.add_argument(
+        "-dn",
+        flag=True,
+        help="Disable the inclusion of data streams in the output file",
+    )
+    parser.add_argument(
+        "--faststart",
+        flag=True,
+        help="Enable movflags +faststart, recommended for web (default)",
+    )
+    parser.add_argument(
+        "--no-faststart",
+        flag=True,
+        help="Disable movflags +faststart, will be faster for large files",
+    )
+    parser.add_argument(
+        "--fragmented",
+        flag=True,
+        help="Use fragmented mp4/mov to allow playback before video is complete\nSee: https://ffmpeg.org/ffmpeg-formats.html#Fragmentation",
+    )
+    parser.add_argument(
+        "--no-fragmented",
+        flag=True,
+        help="Do not use fragmented mp4/mov for better compatibility (default)",
+    )
     parser.add_text("Video Rendering:")
     parser.add_argument(
         "--video-codec",
@@ -231,20 +353,21 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
     )
     parser.add_text("Miscellaneous:")
     parser.add_argument(
-        "-sn",
-        flag=True,
-        help="Disable the inclusion of subtitle streams in the output file",
+        "--config", flag=True, help="When set, look for `config.pal` and run it"
     )
     parser.add_argument(
-        "-dn",
-        flag=True,
-        help="Disable the inclusion of data streams in the output file",
+        "--no-cache", flag=True, help="Don't look for or write a cache file"
     )
     parser.add_argument(
-        "--config", flag=True, help="When set, look for `config.pal` and run it"
+        "--no-open", flag=True, help="Do not open the output file after editing is done"
     )
     parser.add_argument(
-        "--no-cache", flag=True, help="Don't look for or write a cache file"
+        "--temp-dir",
+        metavar="PATH",
+        help="Set where the temporary directory is located",
+    )
+    parser.add_argument(
+        "--player", "-p", metavar="CMD", help="Set player to open output media files"
     )
     parser.add_argument("--version", "-V", flag=True, help="Display version and halt")
     return parser
@@ -320,23 +443,26 @@ def main() -> None:
     )
 
     if args.version:
-        print(auto_editor.__version__)
-        return
+        return print(auto_editor.__version__)
 
     if args.debug and not args.input:
-        print(f"OS: {plat.system()} {plat.release()} {plat.machine().lower()}")
-        print(f"Python: {plat.python_version()}")
-
+        buf = StringIO()
+        buf.write(f"OS: {plat.system()} {plat.release()} {plat.machine().lower()}\n")
+        buf.write(f"Python: {plat.python_version()}\nPyAV: ")
         try:
             import av
-
-            license = av._core.library_meta["libavcodec"]["license"]
-            print(f"PyAV: {av.__version__} ({license})")
         except (ModuleNotFoundError, ImportError):
-            print("PyAV: error")
-
-        print(f"Auto-Editor: {auto_editor.__version__}")
-        return
+            buf.write("not found")
+        else:
+            try:
+                buf.write(f"{av.__version__} ")
+                license = av._core.library_meta["libavcodec"]["license"]
+                buf.write(f"({license})")
+            except AttributeError:
+                buf.write("error")
+
+        buf.write(f"\nAuto-Editor: {auto_editor.__version__}")
+        return print(buf.getvalue())
 
     if not args.input:
         log.error("You need to give auto-editor an input file.")

{auto_editor-26.3.1 → auto_editor-26.3.3}/auto_editor/analyze.py

@@ -19,7 +19,6 @@ from auto_editor import __version__
 if TYPE_CHECKING:
     from collections.abc import Iterator, Sequence
     from fractions import Fraction
-    from pathlib import Path
 
     from numpy.typing import NDArray
 
@@ -28,7 +27,7 @@ if TYPE_CHECKING:
     from auto_editor.utils.log import Log
 
 
-__all__ = ("LevelError", "Levels", "iter_audio", "iter_motion")
+__all__ = ("LevelError", "initLevels", "iter_audio", "iter_motion")
 
 
 class LevelError(Exception):
@@ -153,51 +152,48 @@ def iter_motion(
         prev_index = index
 
 
-def obj_tag(path: Path, kind: str, tb: Fraction, obj: Sequence[object]) -> str:
-    mod_time = int(path.stat().st_mtime)
-    key = f"{path.name}:{mod_time:x}:{tb}:" + ",".join(f"{v}" for v in obj)
-    part1 = sha1(key.encode()).hexdigest()[:16]
-
-    return f"{part1}{kind}"
-
-
 @dataclass(slots=True)
 class Levels:
-    src: FileInfo
+    container: av.container.InputContainer
+    name: str
+    mod_time: int
     tb: Fraction
     bar: Bar
     no_cache: bool
     log: Log
-    strict: bool
 
     @property
     def media_length(self) -> int:
-        if self.src.audios:
+        container = self.container
+        if container.streams.audio:
             if (arr := self.read_cache("audio", (0,))) is not None:
                 return len(arr)
 
-            with av.open(self.src.path, "r") as container:
-                audio_stream = container.streams.audio[0]
-                result = sum(1 for _ in iter_audio(audio_stream, self.tb))
-
+            audio_stream = container.streams.audio[0]
+            result = sum(1 for _ in iter_audio(audio_stream, self.tb))
+            container.seek(0)
             self.log.debug(f"Audio Length: {result}")
             return result
 
         # If there's no audio, get length in video metadata.
-        with av.open(self.src.path) as container:
-            if len(container.streams.video) == 0:
-                self.log.error("Could not get media duration")
-
-            video = container.streams.video[0]
+        if not container.streams.video:
+            self.log.error("Could not get media duration")
 
-            if video.duration is None or video.time_base is None:
-                dur = 0
-            else:
-                dur = int(video.duration * video.time_base * self.tb)
-            self.log.debug(f"Video duration: {dur}")
+        video = container.streams.video[0]
+        if video.duration is None or video.time_base is None:
+            dur = 0
+        else:
+            dur = int(video.duration * video.time_base * self.tb)
+        self.log.debug(f"Video duration: {dur}")
+        container.seek(0)
 
         return dur
 
+    def obj_tag(self, kind: str, obj: Sequence[object]) -> str:
+        mod_time = self.mod_time
+        key = f"{self.name}:{mod_time:x}:{self.tb}:" + ",".join(f"{v}" for v in obj)
+        return f"{sha1(key.encode()).hexdigest()[:16]}{kind}"
+
     def none(self) -> NDArray[np.bool_]:
         return np.ones(self.media_length, dtype=np.bool_)
 
@@ -208,7 +204,7 @@ class Levels:
         if self.no_cache:
             return None
 
-        key = obj_tag(self.src.path, kind, self.tb, obj)
+        key = self.obj_tag(kind, obj)
         cache_file = os.path.join(gettempdir(), f"ae-{__version__}", f"{key}.npz")
 
         try:
@@ -223,11 +219,8 @@ class Levels:
             return arr
 
         workdir = os.path.join(gettempdir(), f"ae-{__version__}")
-        if not os.path.exists(workdir):
-            os.mkdir(workdir)
-
-        key = obj_tag(self.src.path, kind, self.tb, obj)
-        cache_file = os.path.join(workdir, f"{key}.npz")
+        os.makedirs(workdir, exist_ok=True)
+        cache_file = os.path.join(workdir, f"{self.obj_tag(kind, obj)}.npz")
 
         try:
             np.savez(cache_file, data=arr)
@@ -253,13 +246,13 @@ class Levels:
         return arr
 
     def audio(self, stream: int) -> NDArray[np.float32]:
-        if stream >= len(self.src.audios):
+        container = self.container
+        if stream >= len(container.streams.audio):
             raise LevelError(f"audio: audio stream '{stream}' does not exist.")
 
         if (arr := self.read_cache("audio", (stream,))) is not None:
             return arr
 
-        container = av.open(self.src.path, "r")
         audio = container.streams.audio[stream]
 
         if audio.duration is not None and audio.time_base is not None:
@@ -286,32 +279,30 @@ class Levels:
             index += 1
 
         bar.end()
+        container.seek(0)
         assert len(result) > 0
         return self.cache(result[:index], "audio", (stream,))
 
     def motion(self, stream: int, blur: int, width: int) -> NDArray[np.float32]:
-        if stream >= len(self.src.videos):
+        container = self.container
+        if stream >= len(container.streams.video):
             raise LevelError(f"motion: video stream '{stream}' does not exist.")
 
         mobj = (stream, width, blur)
         if (arr := self.read_cache("motion", mobj)) is not None:
             return arr
 
-        container = av.open(self.src.path, "r")
         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)
         )
-
         bar = self.bar
         bar.start(inaccurate_dur, "Analyzing motion")
 
         result: NDArray[np.float32] = np.zeros(inaccurate_dur, dtype=np.float32)
         index = 0
-
         for value in iter_motion(video, self.tb, blur, width):
             if index > len(result) - 1:
                 result = np.concatenate(
@@ -322,6 +313,7 @@ class Levels:
             index += 1
 
         bar.end()
+        container.seek(0)
         return self.cache(result[:index], "motion", mobj)
 
     def subtitle(
@@ -331,7 +323,8 @@ class Levels:
         ignore_case: bool,
         max_count: int | None,
     ) -> NDArray[np.bool_]:
-        if stream >= len(self.src.subtitles):
+        container = self.container
+        if stream >= len(container.streams.subtitles):
             raise LevelError(f"subtitle: subtitle stream '{stream}' does not exist.")
 
         try:
@@ -339,9 +332,7 @@ class Levels:
             re_pattern = re.compile(pattern, flags)
         except re.error as e:
             self.log.error(e)
-
         try:
-            container = av.open(self.src.path, "r")
             subtitle_stream = container.streams.subtitles[stream]
             assert isinstance(subtitle_stream.time_base, Fraction)
         except Exception as e:
@@ -392,6 +383,17 @@ class Levels:
                         result[san_start:san_end] = 1
                         count += 1
 
-        container.close()
-
+        container.seek(0)
         return result
+
+
+def initLevels(
+    src: FileInfo, tb: Fraction, bar: Bar, no_cache: bool, log: Log
+) -> Levels:
+    try:
+        container = av.open(src.path)
+    except av.FFmpegError as e:
+        log.error(e)
+
+    mod_time = int(src.path.stat().st_mtime)
+    return Levels(container, src.path.name, mod_time, tb, bar, no_cache, log)

{auto_editor-26.3.1 → auto_editor-26.3.3}/auto_editor/cmds/levels.py

@@ -128,7 +128,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
             except ParserError as e:
                 log.error(e)
 
-        levels = Levels(src, tb, bar, False, log, strict=True)
+        levels = initLevels(src, tb, bar, False, log)
         try:
             if method == "audio":
                 if (arr := levels.read_cache("audio", (obj["stream"],))) is not None:

{auto_editor-26.3.1 → auto_editor-26.3.3}/auto_editor/cmds/repl.py

@@ -6,7 +6,7 @@ from fractions import Fraction
 from os import environ
 
 import auto_editor
-from auto_editor.analyze import Levels
+from auto_editor.analyze import initLevels
 from auto_editor.ffwrapper import initFileInfo
 from auto_editor.lang.palet import ClosingError, Lexer, Parser, env, interpret
 from auto_editor.lang.stdenv import make_standard_env
@@ -61,12 +61,11 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
 
     if args.input:
         log = Log(quiet=True, temp_dir=args.temp_dir)
-        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
         env["timebase"] = tb
-        env["@levels"] = Levels(src, tb, initBar("modern"), False, log, strict)
+        env["@levels"] = initLevels(src, tb, initBar("modern"), False, log)
 
     env.update(make_standard_env())
     print(f"Auto-Editor {auto_editor.__version__}")