auto-editor 25.1.0__tar.gz → 25.3.0__tar.gz

{auto_editor-25.1.0 → auto_editor-25.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 25.1.0
+Version: 25.3.0
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense
@@ -8,11 +8,11 @@ Project-URL: Bug Tracker, https://github.com/WyattBlue/auto-editor/issues
 Project-URL: Source Code, https://github.com/WyattBlue/auto-editor
 Project-URL: homepage, https://auto-editor.com
 Keywords: video,audio,media,editor,editing,processing,nonlinear,automatic,silence-detect,silence-removal,silence-speedup,motion-detection
-Requires-Python: >=3.10
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy>=1.23.0
-Requires-Dist: pyav==12.3.*
+Requires-Dist: numpy<3.0,>=1.23.0
+Requires-Dist: pyav==13.0.*
 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-25.3.0/auto_editor/__init__.py

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

{auto_editor-25.1.0 → auto_editor-25.3.0}/auto_editor/__main__.py

@@ -254,6 +254,11 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         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(
         "--extras",
         metavar="CMD",

{auto_editor-25.1.0 → auto_editor-25.3.0}/auto_editor/analyze.py

@@ -19,6 +19,7 @@ from auto_editor.utils.subtitle_tools import convert_ass_to_text
 if TYPE_CHECKING:
     from collections.abc import Iterator
     from fractions import Fraction
+    from pathlib import Path
     from typing import Any
 
     from numpy.typing import NDArray
@@ -70,15 +71,6 @@ def mut_remove_large(
             active = False
 
 
-def obj_tag(tag: str, tb: Fraction, obj: dict[str, Any]) -> str:
-    key = f"{tag}:{tb}:"
-    for k, v in obj.items():
-        key += f"{k}={v},"
-
-    key = key[:-1]  # remove unnecessary char
-    return key
-
-
 def iter_audio(src, tb: Fraction, stream: int = 0) -> Iterator[np.float32]:
     fifo = AudioFifo()
     try:
@@ -122,7 +114,7 @@ def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[np.floa
 
     prev_frame = None
     current_frame = None
-    total_pixels = src.videos[0].width * src.videos[0].height
+    total_pixels = None
     index = 0
     prev_index = -1
 
@@ -140,10 +132,13 @@ def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[np.floa
             continue
 
         graph.push(unframe)
-        frame = graph.pull()
+        frame = graph.vpull()
         assert frame.time is not None
         index = round(frame.time * tb)
 
+        if total_pixels is None:
+            total_pixels = frame.width * frame.height
+
         current_frame = frame.to_ndarray()
         if prev_frame is None:
             value = np.float32(0.0)
@@ -161,6 +156,12 @@ def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[np.floa
     container.close()
 
 
+def obj_tag(path: Path, kind: str, tb: Fraction, obj: dict[str, Any]) -> str:
+    mod_time = int(path.stat().st_mtime)
+    key = f"{path.name}:{mod_time:x}:{kind}:{tb}:"
+    return key + ",".join(f"{v}" for v in obj.values())
+
+
 @dataclass(slots=True)
 class Levels:
     src: FileInfo
@@ -201,7 +202,7 @@ class Levels:
     def all(self) -> NDArray[np.bool_]:
         return np.zeros(self.media_length, dtype=np.bool_)
 
-    def read_cache(self, tag: str, obj: dict[str, Any]) -> None | np.ndarray:
+    def read_cache(self, kind: str, obj: dict[str, Any]) -> None | np.ndarray:
         if self.no_cache:
             return None
 
@@ -213,14 +214,14 @@ class Levels:
             self.log.debug(e)
             return None
 
-        key = f"{self.src.path}:{obj_tag(tag, self.tb, obj)}"
+        key = obj_tag(self.src.path, kind, self.tb, obj)
         if key not in npzfile.files:
             return None
 
         self.log.debug("Using cache")
         return npzfile[key]
 
-    def cache(self, arr: np.ndarray, tag: str, obj: dict[str, Any]) -> np.ndarray:
+    def cache(self, arr: np.ndarray, kind: str, obj: dict[str, Any]) -> np.ndarray:
         if self.no_cache:
             return arr
 
@@ -228,8 +229,8 @@ class Levels:
         if not os.path.exists(workdur):
             os.mkdir(workdur)
 
-        tag = obj_tag(tag, self.tb, obj)
-        np.savez(os.path.join(workdur, "cache.npz"), **{f"{self.src.path}:{tag}": arr})
+        key = obj_tag(self.src.path, kind, self.tb, obj)
+        np.savez(os.path.join(workdur, "cache.npz"), **{key: arr})
 
         return arr
 

{auto_editor-25.1.0 → auto_editor-25.3.0}/auto_editor/edit.py

@@ -11,7 +11,7 @@ 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
 from auto_editor.timeline import v1, v3
-from auto_editor.utils.bar import Bar
+from auto_editor.utils.bar import initBar
 from auto_editor.utils.chunks import Chunk, Chunks
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
 from auto_editor.utils.container import Container, container_constructor
@@ -125,7 +125,9 @@ def parse_export(export: str, log: Log) -> dict[str, Any]:
         "default": pAttrs("default"),
         "premiere": pAttrs("premiere", name_attr),
         "resolve-fcp7": pAttrs("resolve-fcp7", name_attr),
-        "final-cut-pro": pAttrs("final-cut-pro", name_attr),
+        "final-cut-pro": pAttrs(
+            "final-cut-pro", name_attr, pAttr("version", 11, is_int)
+        ),
         "resolve": pAttrs("resolve", name_attr),
         "shotcut": pAttrs("shotcut"),
         "json": pAttrs("json", pAttr("api", 3, is_int)),
@@ -146,7 +148,7 @@ def parse_export(export: str, log: Log) -> dict[str, Any]:
 
 
 def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
-    bar = Bar(args.progress)
+    bar = initBar(args.progress)
     tl = None
 
     if paths:
@@ -232,11 +234,19 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
         fcp7_write_xml(export_ops["name"], output, is_resolve, tl, log)
         return
 
-    if export in ("final-cut-pro", "resolve"):
+    if export == "final-cut-pro":
         from auto_editor.formats.fcp11 import fcp11_write_xml
 
-        is_resolve = export.startswith("resolve")
-        fcp11_write_xml(export_ops["name"], ffmpeg, output, is_resolve, tl, log)
+        ver = export_ops["version"]
+        fcp11_write_xml(export_ops["name"], ver, output, False, tl, log)
+        return
+
+    if export == "resolve":
+        from auto_editor.formats.fcp11 import fcp11_write_xml
+        from auto_editor.timeline import set_stream_to_0
+
+        set_stream_to_0(tl, log)
+        fcp11_write_xml(export_ops["name"], 10, output, True, tl, log)
         return
 
     if export == "shotcut":

{auto_editor-25.1.0 → auto_editor-25.3.0}/auto_editor/ffwrapper.py

@@ -127,6 +127,31 @@ class FFmpeg:
         return output
 
 
+def mux(input: Path, output: Path, stream: int, codec: str | None = None) -> None:
+    input_container = av.open(input, "r")
+    output_container = av.open(output, "w")
+
+    input_audio_stream = input_container.streams.audio[stream]
+
+    if codec is None:
+        codec = "pcm_s16le"
+
+    output_audio_stream = output_container.add_stream(codec)
+    assert isinstance(output_audio_stream, av.audio.AudioStream)
+
+    for frame in input_container.decode(input_audio_stream):
+        packet = output_audio_stream.encode(frame)
+        if packet:
+            output_container.mux(packet)
+
+    packet = output_audio_stream.encode(None)
+    if packet:
+        output_container.mux(packet)
+
+    output_container.close()
+    input_container.close()
+
+
 @dataclass(slots=True, frozen=True)
 class VideoStream:
     width: int
@@ -269,7 +294,7 @@ def initFileInfo(path: str, log: Log) -> FileInfo:
 
     desc = cont.metadata.get("description", None)
     bitrate = 0 if cont.bit_rate is None else cont.bit_rate
-    dur = 0 if cont.duration is None else cont.duration / 1_000_000
+    dur = 0 if cont.duration is None else cont.duration / av.time_base
 
     cont.close()
 

{auto_editor-25.1.0 → auto_editor-25.3.0}/auto_editor/formats/fcp11.py

@@ -3,17 +3,15 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, cast
 from xml.etree.ElementTree import Element, ElementTree, SubElement, indent
 
-from auto_editor.ffwrapper import FFmpeg, FileInfo, initFileInfo
-
-from .utils import make_tracks_dir
-
 if TYPE_CHECKING:
     from collections.abc import Sequence
     from fractions import Fraction
 
+    from auto_editor.ffwrapper import FileInfo
     from auto_editor.timeline import TlAudio, TlVideo, v3
     from auto_editor.utils.log import Log
 
+
 """
 Export a FCPXML 11 file readable with Final Cut Pro 10.6.8 or later.
 
@@ -54,7 +52,7 @@ def make_name(src: FileInfo, tb: Fraction) -> str:
 
 
 def fcp11_write_xml(
-    group_name: str, ffmpeg: FFmpeg, output: str, resolve: bool, tl: v3, log: Log
+    group_name: str, version: int, output: str, resolve: bool, tl: v3, log: Log
 ) -> None:
     def fraction(val: int) -> str:
         if val == 0:
@@ -68,23 +66,17 @@ def fcp11_write_xml(
     src_dur = int(src.duration * tl.tb)
     tl_dur = src_dur if resolve else tl.out_len()
 
-    all_srcs: list[FileInfo] = [src]
-    all_refs: list[str] = ["r2"]
-    if resolve and len(src.audios) > 1:
-        fold = make_tracks_dir(src)
-
-        for i in range(1, len(src.audios)):
-            newtrack = fold / f"{i}.wav"
-            ffmpeg.run(
-                ["-i", f"{src.path.resolve()}", "-map", f"0:a:{i}", f"{newtrack}"]
-            )
-            all_srcs.append(initFileInfo(f"{newtrack}", log))
-            all_refs.append(f"r{(i + 1) * 2}")
+    if version == 11:
+        ver_str = "1.11"
+    elif version == 10:
+        ver_str = "1.10"
+    else:
+        log.error(f"Unknown final cut pro version: {version}")
 
-    fcpxml = Element("fcpxml", version="1.10" if resolve else "1.11")
+    fcpxml = Element("fcpxml", version=ver_str)
     resources = SubElement(fcpxml, "resources")
 
-    for i, one_src in enumerate(all_srcs):
+    for i, one_src in enumerate(tl.unique_sources()):
         SubElement(
             resources,
             "format",
@@ -126,13 +118,6 @@ def fcp11_write_xml(
     )
     spine = SubElement(sequence, "spine")
 
-    if tl.v and tl.v[0]:
-        clips: Sequence[TlVideo | TlAudio] = cast(Any, tl.v[0])
-    elif tl.a and tl.a[0]:
-        clips = tl.a[0]
-    else:
-        clips = []
-
     def make_clip(ref: str, clip: TlVideo | TlAudio) -> None:
         clip_properties = {
             "name": proj_name,
@@ -157,7 +142,19 @@ def fcp11_write_xml(
                 interp="smooth2",
             )
 
-    for my_ref in all_refs:
+    if tl.v and tl.v[0]:
+        clips: Sequence[TlVideo | TlAudio] = cast(Any, tl.v[0])
+    elif tl.a and tl.a[0]:
+        clips = tl.a[0]
+    else:
+        clips = []
+
+    all_refs: list[str] = ["r2"]
+    if resolve:
+        for i in range(1, len(tl.a)):
+            all_refs.append(f"r{(i + 1) * 2}")
+
+    for my_ref in reversed(all_refs):
         for clip in clips:
             make_clip(my_ref, clip)
 

{auto_editor-25.1.0 → auto_editor-25.3.0}/auto_editor/formats/utils.py

@@ -4,9 +4,6 @@ from typing import TYPE_CHECKING
 from xml.etree.ElementTree import Element
 
 if TYPE_CHECKING:
-    from pathlib import Path
-
-    from auto_editor.ffwrapper import FileInfo
     from auto_editor.utils.log import Log
 
 
@@ -19,21 +16,6 @@ def show(ele: Element, limit: int, depth: int = 0) -> None:
             show(child, limit, depth + 1)
 
 
-def make_tracks_dir(src: FileInfo) -> Path:
-    from os import mkdir
-    from shutil import rmtree
-
-    fold = src.path.parent / f"{src.path.stem}_tracks"
-
-    try:
-        mkdir(fold)
-    except OSError:
-        rmtree(fold)
-        mkdir(fold)
-
-    return fold
-
-
 class Validator:
     def __init__(self, log: Log):
         self.log = log

{auto_editor-25.1.0 → auto_editor-25.3.0}/auto_editor/lang/palet.py

@@ -60,6 +60,8 @@ str_escape = {
 class Token:
     type: str
     value: Any
+    lineno: int
+    column: int
 
 
 class Lexer:
@@ -156,21 +158,31 @@ class Lexer:
             elif unit == "dB":
                 token = DB
             elif unit != "i" and unit != "%":
-                return Token(VAL, Sym(result + unit))
+                return Token(
+                    VAL,
+                    Sym(result + unit, self.lineno, self.column),
+                    self.lineno,
+                    self.column,
+                )
 
         try:
             if unit == "i":
-                return Token(VAL, complex(result + "j"))
+                return Token(VAL, complex(result + "j"), self.lineno, self.column)
             elif unit == "%":
-                return Token(VAL, float(result) / 100)
+                return Token(VAL, float(result) / 100, self.lineno, self.column)
             elif "/" in result:
-                return Token(token, Fraction(result))
+                return Token(token, Fraction(result), self.lineno, self.column)
             elif "." in result:
-                return Token(token, float(result))
+                return Token(token, float(result), self.lineno, self.column)
             else:
-                return Token(token, int(result))
+                return Token(token, int(result), self.lineno, self.column)
         except ValueError:
-            return Token(VAL, Sym(result + unit))
+            return Token(
+                VAL,
+                Sym(result + unit, self.lineno, self.column),
+                self.lineno,
+                self.column,
+            )
 
     def hash_literal(self) -> Token:
         if self.char == "\\":
@@ -180,7 +192,7 @@ class Lexer:
 
             char = self.char
             self.advance()
-            return Token(VAL, Char(char))
+            return Token(VAL, Char(char), self.lineno, self.column)
 
         if self.char == ":":
             self.advance()
@@ -190,14 +202,14 @@ class Lexer:
                 buf.write(self.char)
                 self.advance()
 
-            return Token(VAL, Keyword(buf.getvalue()))
+            return Token(VAL, Keyword(buf.getvalue()), self.lineno, self.column)
 
         if self.char is not None and self.char in "([{":
             brac_type = self.char
             self.advance()
             if self.char is None:
                 self.close_err(f"Expected a character after #{brac_type}")
-            return Token(VLIT, brac_pairs[brac_type])
+            return Token(VLIT, brac_pairs[brac_type], self.lineno, self.column)
 
         buf = StringIO()
         while self.char_is_norm():
@@ -207,10 +219,10 @@ class Lexer:
 
         result = buf.getvalue()
         if result in ("t", "T", "true"):
-            return Token(VAL, True)
+            return Token(VAL, True, self.lineno, self.column)
 
         if result in ("f", "F", "false"):
-            return Token(VAL, False)
+            return Token(VAL, False, self.lineno, self.column)
 
         self.error(f"Unknown hash literal `#{result}`")
 
@@ -231,17 +243,19 @@ class Lexer:
                 my_str = self.string()
                 if self.char == ".":  # handle `object.method` syntax
                     self.advance()
-                    return Token(DOT, (my_str, self.get_next_token()))
-                return Token(VAL, my_str)
+                    return Token(
+                        DOT, (my_str, self.get_next_token()), self.lineno, self.column
+                    )
+                return Token(VAL, my_str, self.lineno, self.column)
 
             if self.char == "'":
                 self.advance()
-                return Token(QUOTE, "'")
+                return Token(QUOTE, "'", self.lineno, self.column)
 
             if self.char in "(){}[]":
                 _par = self.char
                 self.advance()
-                return Token(_par, _par)
+                return Token(_par, _par, self.lineno, self.column)
 
             if self.char in "+-":
                 _peek = self.peek()
@@ -339,18 +353,27 @@ class Lexer:
             if is_method:
                 from auto_editor.utils.cmdkw import parse_method
 
-                return Token(M, parse_method(name, result, env))
+                return Token(
+                    M, parse_method(name, result, env), self.lineno, self.column
+                )
 
             if self.char == ".":  # handle `object.method` syntax
                 self.advance()
-                return Token(DOT, (Sym(result), self.get_next_token()))
+                return Token(
+                    DOT,
+                    (Sym(result, self.lineno, self.column), self.get_next_token()),
+                    self.lineno,
+                    self.column,
+                )
 
             if has_illegal:
                 self.error(f"Symbol has illegal character(s): {result}")
 
-            return Token(VAL, Sym(result))
+            return Token(
+                VAL, Sym(result, self.lineno, self.column), self.lineno, self.column
+            )
 
-        return Token(EOF, "EOF")
+        return Token(EOF, "EOF", self.lineno, self.column)
 
 
 ###############################################################################
@@ -370,6 +393,7 @@ class Parser:
 
     def expr(self) -> Any:
         token = self.current_token
+        lineno, column = token.lineno, token.column
 
         if token.type == VAL:
             self.eat()
@@ -397,7 +421,7 @@ class Parser:
         if token.type == M:
             self.eat()
             name, args, kwargs = token.value
-            _result = [Sym(name)] + args
+            _result = [Sym(name, lineno, column)] + args
             for key, val in kwargs.items():
                 _result.append(Keyword(key))
                 _result.append(val)
@@ -413,7 +437,7 @@ class Parser:
 
         if token.type == QUOTE:
             self.eat()
-            return (Sym("quote"), self.expr())
+            return (Sym("quote", lineno, column), self.expr())
 
         if token.type in brac_pairs:
             self.eat()
@@ -610,16 +634,41 @@ def edit_subtitle(pattern, stream=0, **kwargs):
         return raise_(e) if levels.strict else levels.all()
 
 
+class StackTraceManager:
+    def __init__(self) -> None:
+        self.stack: list[Sym] = []
+
+    def push(self, sym: Sym) -> None:
+        self.stack.append(sym)
+
+    def pop(self) -> None:
+        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()
+
+
 def my_eval(env: Env, node: object) -> Any:
+    def make_trace(sym: Sym) -> str:
+        return f"  at {sym.val} ({sym.lineno}:{sym.column})"
+
     if type(node) is Sym:
         val = env.get(node.val)
         if type(val) is NotFound:
+            stacktrace = make_trace(node)
             if mat := get_close_matches(node.val, env.data):
                 raise MyError(
-                    f"variable `{node.val}` not found. Did you mean: {mat[0]}"
+                    f"variable `{node.val}` not found. Did you mean: {mat[0]}\n{stacktrace}"
                 )
             raise MyError(
-                f"variable `{node.val}` not found. Did you mean a string literal."
+                f"variable `{node.val}` not found. Did you mean a string literal.\n{stacktrace}"
             )
         return val
 
@@ -631,44 +680,56 @@ def my_eval(env: Env, node: object) -> Any:
             raise MyError("Illegal () expression")
 
         oper = my_eval(env, node[0])
-        if not callable(oper):
-            """
-            ...No one wants to write (aref a x y) when they could write a[x,y].
-            In this particular case there is a way to finesse our way out of the
-            problem. If we treat data structures as if they were functions on indexes,
-            we could write (a x y) instead, which is even shorter than the Perl form.
-            """
-            if is_iterable(oper):
-                length = len(node[1:])
-                if length > 3:
-                    raise MyError(f"{print_str(node[0])}: slice expects 1 argument")
-                if length in (2, 3):
-                    return p_slice(oper, *(my_eval(env, c) for c in node[1:]))
-                if length == 1:
-                    return ref(oper, my_eval(env, node[1]))
+        if isinstance(node[0], Sym):
+            stack_trace_manager.push(node[0])
 
-            raise MyError(
-                f"{print_str(oper)} is not a function. Tried to run with args: {print_str(node[1:])}"
-            )
+        try:
+            if not callable(oper):
+                """
+                ...No one wants to write (aref a x y) when they could write a[x,y].
+                In this particular case there is a way to finesse our way out of the
+                problem. If we treat data structures as if they were functions on indexes,
+                we could write (a x y) instead, which is even shorter than the Perl form.
+                """
+                if is_iterable(oper):
+                    length = len(node[1:])
+                    if length > 3:
+                        raise MyError(f"{print_str(node[0])}: slice expects 1 argument")
+                    if length in (2, 3):
+                        return p_slice(oper, *(my_eval(env, c) for c in node[1:]))
+                    if length == 1:
+                        return ref(oper, my_eval(env, node[1]))
 
-        if type(oper) is Syntax:
-            return oper(env, node)
+                raise MyError(
+                    f"{print_str(oper)} is not a function. Tried to run with args: {print_str(node[1:])}"
+                )
 
-        i = 1
-        args: list[Any] = []
-        kwargs: dict[str, Any] = {}
-        while i < len(node):
-            result = my_eval(env, node[i])
-            if type(result) is Keyword:
+            if type(oper) is Syntax:
+                return oper(env, node)
+
+            i = 1
+            args: list[Any] = []
+            kwargs: dict[str, Any] = {}
+            while i < len(node):
+                result = my_eval(env, node[i])
+                if type(result) is Keyword:
+                    i += 1
+                    if i >= len(node):
+                        raise MyError("Keyword need argument")
+                    kwargs[result.val] = my_eval(env, node[i])
+                else:
+                    args.append(result)
                 i += 1
-                if i >= len(node):
-                    raise MyError("Keyword need argument")
-                kwargs[result.val] = my_eval(env, node[i])
-            else:
-                args.append(result)
-            i += 1
 
-        return oper(*args, **kwargs)
+            return oper(*args, **kwargs)
+        except MyError as e:
+            error_msg = str(e)
+            if not error_msg.endswith(make_trace(node[0])):
+                error_msg += f"\n{make_trace(node[0])}"
+            raise MyError(error_msg)
+        finally:
+            if isinstance(node[0], Sym):
+                stack_trace_manager.pop()
 
     return node