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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 25.1.0
+Version: 25.2.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.2.0/auto_editor/__init__.py

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

{auto_editor-25.1.0 → auto_editor-25.2.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
 

{auto_editor-25.1.0 → auto_editor-25.2.0}/auto_editor/lang/stdenv.py

@@ -20,6 +20,7 @@ if TYPE_CHECKING:
 
 
 def make_standard_env() -> dict[str, Any]:
+    import os.path
     from cmath import sqrt as complex_sqrt
     from functools import reduce
     from operator import add, ge, gt, is_, le, lt, mod, mul
@@ -135,6 +136,22 @@ def make_standard_env() -> dict[str, Any]:
         Sym("float64"): np.float64,
     }
 
+    @dataclass(slots=True)
+    class InputPort:
+        name: str
+        port: Any
+        closed: bool
+
+        def close(self) -> None:
+            if not self.closed:
+                self.closed = True
+                self.port.close()
+
+        def __str__(self) -> str:
+            return f"#<input-port:{self.name}>"
+
+        __repr__ = __str__
+
     @dataclass(slots=True)
     class OutputPort:
         name: str
@@ -152,6 +169,13 @@ def make_standard_env() -> dict[str, Any]:
 
         __repr__ = __str__
 
+    def initInPort(name: str) -> InputPort | Literal[False]:
+        try:
+            port = open(name, encoding="utf-8")
+        except Exception:
+            return False
+        return InputPort(name, port, False)
+
     def initOutPort(name: str) -> OutputPort | Literal[False]:
         try:
             port = open(name, "w", encoding="utf-8")
@@ -198,14 +222,20 @@ def make_standard_env() -> dict[str, Any]:
         parms: list[str] = []
         for item in node[1]:
             if type(item) is not Sym:
-                raise MyError(f"{node[0]}: must be an identifier")
+                raise MyError(f"{node[0]}: must be an identifier, got: {item} {type(item)}")
 
             parms.append(f"{item}")
 
         return UserProc(env, "", parms, (), node[2:])
 
     def syn_define(env: Env, node: Node) -> None:
+        if len(node) < 2:
+            raise MyError(f"{node[0]}: too few terms")
         if len(node) < 3:
+            if type(node[1]) is Sym:
+                raise MyError(f"{node[0]}: what should `{node[1]}` be defined as?")
+            elif type(node[1]) is tuple and len(node[1]) > 0:
+                raise MyError(f"{node[0]}: function `{node[1][0]}` needs a body.")
             raise MyError(f"{node[0]}: too few terms")
 
         if type(node[1]) is tuple:
@@ -437,6 +467,11 @@ def make_standard_env() -> dict[str, Any]:
             raise MyError(f"{node[0]}: Expected string? got: {print_str(num)}")
         env[name] += num
 
+    def syn_while(env: Env, node: Node) -> None:
+        while my_eval(env, node[1]) == True:
+            for c in node[2:]:
+                my_eval(env, c)
+
     def syn_for(env: Env, node: Node) -> None:
         var, my_iter = check_for_syntax(env, node)
 
@@ -808,6 +843,12 @@ def make_standard_env() -> dict[str, Any]:
             return f"{val.real}{join}{val.imag}i"
         return f"{val}"
 
+    def string_to_number(val) -> float:
+        try:
+            return float(val)
+        except Exception:
+            raise MyError(f"failed to convert {val} to number")
+
     def palet_join(v: Any, s: str) -> str:
         try:
             return s.join(v)
@@ -943,6 +984,7 @@ def make_standard_env() -> dict[str, Any]:
         # loops
         "for": Syntax(syn_for),
         "for-items": Syntax(syn_for_items),
+        "while": Syntax(syn_while),
         # contracts
         "number?": is_num,
         "real?": is_real,
@@ -1102,10 +1144,20 @@ def make_standard_env() -> dict[str, Any]:
             ),
         ),
         # i/o
+        "file-exists?": Proc("file-exists", os.path.isfile, (1, 1), is_str),
+        "open-input-file": Proc("open-input-file", initInPort, (1, 1), is_str),
+        "input-port?": (ip := Contract("input-port?", lambda v: type(v) is InputPort)),
+        "read-line": Proc("read-line",
+            lambda f: (r := f.port.readline(), None if r == "" else r.rstrip())[-1],
+            (1, 1), ip),
         "open-output-file": Proc("open-output-file", initOutPort, (1, 1), is_str),
         "output-port?": (op := Contract("output-port?", lambda v: type(v) is OutputPort)),
-        "close-port": Proc("close-port", OutputPort.close, (1, 1), op),
-        "closed?": Proc("closed?", lambda o: o.closed, (1, 1), op),
+        "port?": (port := Contract("port?", orc(ip, op))),
+        "close-port": Proc("close-port", lambda p: p.close, (1, 1), port),
+        "closed?": Proc("closed?", lambda o: o.closed, (1, 1), port),
+        # subprocess
+        "system": Proc("system", palet_system, (1, 1), is_str),
+        "system*": Proc("system*", palet_system_star, (1, None), is_str),
         # printing
         "display": Proc("display",
             lambda v, f=None: print(display_str(v), end="", file=f), (1, 2), any_p, op),
@@ -1119,10 +1171,9 @@ def make_standard_env() -> dict[str, Any]:
         "assert": Proc("assert", palet_assert, (1, 2), any_p, orc(is_str, False)),
         "error": Proc("error", raise_, (1, 1), is_str),
         "sleep": Proc("sleep", sleep, (1, 1), is_int_or_float),
-        "system": Proc("system", palet_system, (1, 1), is_str),
-        "system*": Proc("system*", palet_system_star, (1, None), is_str),
         # conversions
         "number->string": Proc("number->string", number_to_string, (1, 1), is_num),
+        "string->number": Proc("string->number", string_to_number, (1, 1), is_str),
         "string->vector": Proc(
             "string->vector", lambda s: [Char(c) for c in s], (1, 1), is_str
         ),

{auto_editor-25.1.0 → auto_editor-25.2.0}/auto_editor/lib/contracts.py

@@ -118,6 +118,10 @@ class Proc:
 
         if kws is not None:
             for key, val in kwargs.items():
+                if key not in kws:
+                    raise MyError(
+                        f"{self.name} got an unexpected keyword argument: {key}"
+                    )
                 check = cont[-1] if kws[key] >= len(cont) else cont[kws[key]]
                 if not check_contract(check, val):
                     exp = f"{check}" if callable(check) else print_str(check)

{auto_editor-25.1.0 → auto_editor-25.2.0}/auto_editor/lib/data_structs.py

@@ -54,12 +54,14 @@ class Env:
 
 
 class Sym:
-    __slots__ = ("val", "hash")
+    __slots__ = ("val", "hash", "lineno", "column")
 
-    def __init__(self, val: str):
+    def __init__(self, val: str, lineno: int = -1, column: int = -1):
         assert isinstance(val, str)
         self.val = val
         self.hash = hash(val)
+        self.lineno = lineno
+        self.column = column
 
     def __str__(self) -> str:
         return self.val

{auto_editor-25.1.0 → auto_editor-25.2.0}/auto_editor/render/video.py

@@ -57,21 +57,6 @@ allowed_pix_fmt = {
 }
 
 
-def apply_anchor(x: int, y: int, w: int, h: int, anchor: str) -> tuple[int, int]:
-    if anchor == "ce":
-        x = (x * 2 - w) // 2
-        y = (y * 2 - h) // 2
-    if anchor == "tr":
-        x -= w
-    if anchor == "bl":
-        y -= h
-    if anchor == "br":
-        x -= w
-        y -= h
-    # Use 'tl' by default
-    return x, y
-
-
 def make_solid(width: int, height: int, pix_fmt: str, bg: str) -> av.VideoFrame:
     hex_color = bg.lstrip("#").upper()
     rgb_color = tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))
@@ -292,7 +277,7 @@ def render_av(
                         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)
+                    x, y = obj.x, obj.y
                     graph.link_nodes(
                         graph.add_buffer(template=my_stream),
                         graph.add(
@@ -307,9 +292,7 @@ def render_av(
                     array = frame.to_ndarray(format="rgb24")
 
                     overlay_h, overlay_w, _ = img.shape
-                    x_pos, y_pos = apply_anchor(
-                        obj.x, obj.y, overlay_w, overlay_h, obj.anchor
-                    )
+                    x_pos, y_pos = obj.x, obj.y
 
                     x_start = max(x_pos, 0)
                     y_start = max(y_pos, 0)

{auto_editor-25.1.0 → auto_editor-25.2.0}/auto_editor/timeline.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 
 from auto_editor.lib.contracts import *
 from auto_editor.utils.cmdkw import Required, pAttr, pAttrs
-from auto_editor.utils.types import anchor, color, natural, number, threshold
+from auto_editor.utils.types import color, natural, number, threshold
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -88,7 +88,6 @@ class TlImage:
     y: int
     width: int
     opacity: float
-    anchor: str
 
     def as_dict(self) -> dict:
         return {
@@ -100,7 +99,6 @@ class TlImage:
             "y": self.y,
             "width": self.width,
             "opacity": self.opacity,
-            "anchor": self.anchor,
         }
 
 
@@ -112,7 +110,6 @@ class TlRect:
     y: int
     width: int
     height: int
-    anchor: str
     fill: str
 
     def as_dict(self) -> dict:
@@ -124,7 +121,6 @@ class TlRect:
             "y": self.y,
             "width": self.width,
             "height": self.height,
-            "anchor": self.anchor,
             "fill": self.fill,
         }
 
@@ -157,7 +153,6 @@ img_builder = pAttrs(
     pAttr("y", Required, is_int, int),
     pAttr("width", 0, is_nat, natural),
     pAttr("opacity", 1, is_threshold, threshold),
-    pAttr("anchor", "ce", is_str, anchor),
 )
 rect_builder = pAttrs(
     "rect",
@@ -167,7 +162,6 @@ rect_builder = pAttrs(
     pAttr("y", Required, is_int, int),
     pAttr("width", Required, is_int, int),
     pAttr("height", Required, is_int, int),
-    pAttr("anchor", "ce", is_str, anchor),
     pAttr("fill", "#c4c4c4", is_str, color),
 )
 visual_objects = {

{auto_editor-25.1.0 → auto_editor-25.2.0}/auto_editor/utils/cmdkw.py

@@ -177,8 +177,7 @@ def parse_with_palet(
 def parse_method(
     name: str, text: str, env: Env
 ) -> tuple[str, list[Any], dict[str, Any]]:
-    from auto_editor.lang.palet import Lexer, Parser, interpret
-    from auto_editor.lib.err import MyError
+    from auto_editor.lang.palet import Lexer, Parser
 
     # Positional Arguments
     #    audio:0.04,0,6,3
@@ -197,18 +196,13 @@ def parse_method(
         if "=" in arg:
             key, val = arg.split("=", 1)
 
-            results = interpret(env, Parser(Lexer(name, val)))
-            if not results:
-                raise MyError("Results must be of length > 0")
-
-            kwargs[key] = results[-1]
+            result = Parser(Lexer(name, val)).expr()
+            kwargs[key] = result
             allow_positional_args = False
 
         elif allow_positional_args:
-            results = interpret(env, Parser(Lexer(name, arg)))
-            if not results:
-                raise MyError("Results must be of length > 0")
-            args.append(results[-1])
+            result = Parser(Lexer(name, arg)).expr()
+            args.append(result)
         else:
             raise ParserError(f"{name} positional argument follows keyword argument.")
 

{auto_editor-25.1.0 → auto_editor-25.2.0}/auto_editor/utils/types.py

@@ -148,13 +148,6 @@ def time(val: str, tb: Fraction) -> int:
     return int(num)
 
 
-def anchor(val: str) -> str:
-    allowed = ("tl", "tr", "bl", "br", "ce")
-    if val not in allowed:
-        raise CoerceError(f"Anchor must be: {' '.join(allowed)}")
-    return val
-
-
 def margin(val: str) -> tuple[str, str]:
     vals = val.strip().split(",")
     if len(vals) == 1:

{auto_editor-25.1.0 → auto_editor-25.2.0}/auto_editor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 25.1.0
+Version: 25.2.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.2.0/auto_editor.egg-info/requires.txt

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

{auto_editor-25.1.0 → auto_editor-25.2.0}/pyproject.toml

@@ -7,10 +7,10 @@ description = "Auto-Editor: Effort free video editing!"
 readme = "README.md"
 license = { text = "Unlicense" }
 authors = [{ name = "WyattBlue", email = "wyattblue@auto-editor.com" }]
-requires-python = ">=3.10"
+requires-python = ">=3.10,<3.14"
 dependencies = [
-    "numpy>=1.23.0",
-    "pyav==12.3.*",
+    "numpy>=1.23.0,<3.0",
+    "pyav==13.0.*",
     "ae-ffmpeg==1.2.*",
 ]
 keywords = [

auto_editor-25.1.0/auto_editor/__init__.py

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

auto_editor-25.1.0/auto_editor.egg-info/requires.txt

@@ -1,3 +0,0 @@
-numpy>=1.23.0
-pyav==12.3.*
-ae-ffmpeg==1.2.*