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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: auto-editor
-Version: 26.3.1
+Version: 26.3.2
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense

auto_editor-26.3.2/auto_editor/__init__.py

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

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

@@ -3,6 +3,7 @@
 import platform as plat
 import re
 import sys
+from io import StringIO
 from os import environ
 from os.path import exists, isdir, isfile, lexists, splitext
 from subprocess import run
@@ -174,6 +175,27 @@ 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(
+        "--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",
@@ -230,16 +252,6 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         help="Apply audio rendering to all audio tracks. Applied right before rendering the output file",
     )
     parser.add_text("Miscellaneous:")
-    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(
         "--config", flag=True, help="When set, look for `config.pal` and run it"
     )
@@ -320,23 +332,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.2}/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.2}/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.2}/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__}")