auto-editor 26.0.0__py3-none-any.whl → 26.1.0__py3-none-any.whl

auto_editor/render/audio.py

@@ -2,13 +2,12 @@ from __future__ import annotations
 
 import io
 from pathlib import Path
-from platform import system
-from subprocess import PIPE
 
 import av
 import numpy as np
+from av.filter.loudnorm import stats
 
-from auto_editor.ffwrapper import FFmpeg, FileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.lang.json import Lexer, Parser
 from auto_editor.lang.palet import env
 from auto_editor.lib.contracts import andc, between_c, is_int_or_float
@@ -17,6 +16,7 @@ from auto_editor.output import Ensure
 from auto_editor.timeline import TlAudio, v3
 from auto_editor.utils.bar import Bar
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
+from auto_editor.utils.container import Container
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import Args
 from auto_editor.wavfile import AudioData, read, write
@@ -56,25 +56,11 @@ def parse_norm(norm: str, log: Log) -> dict | None:
         log.error(e)
 
 
-def parse_ebu_bytes(norm: dict, stderr: bytes, log: Log) -> tuple[str, str]:
-    start = end = 0
-    lines = stderr.splitlines()
-
-    for index, line in enumerate(lines):
-        if line.startswith(b"[Parsed_loudnorm"):
-            start = index + 1
-            continue
-        if start != 0 and line.startswith(b"}"):
-            end = index + 1
-            break
-
-    if start == 0 or end == 0:
-        log.error(f"Invalid loudnorm stats.\n{stderr!r}")
-
+def parse_ebu_bytes(norm: dict, stat: bytes, log: Log) -> tuple[str, str]:
     try:
-        parsed = Parser(Lexer("loudnorm", b"\n".join(lines[start:end]))).expr()
+        parsed = Parser(Lexer("loudnorm", stat)).expr()
     except MyError:
-        log.error(f"Invalid loudnorm stats.\n{start=},{end=}\n{stderr!r}")
+        log.error(f"Invalid loudnorm stats.\n{stat!r}")
 
     for key in ("input_i", "input_tp", "input_lra", "input_thresh", "target_offset"):
         val = float(parsed[key])
@@ -101,30 +87,17 @@ def parse_ebu_bytes(norm: dict, stderr: bytes, log: Log) -> tuple[str, str]:
 
 
 def apply_audio_normalization(
-    ffmpeg: FFmpeg, norm: dict, pre_master: Path, path: Path, log: Log
+    norm: dict, pre_master: Path, path: Path, log: Log
 ) -> None:
     if norm["tag"] == "ebu":
         first_pass = (
-            f"loudnorm=i={norm['i']}:lra={norm['lra']}:tp={norm['tp']}:"
-            f"offset={norm['gain']}:print_format=json"
+            f"i={norm['i']}:lra={norm['lra']}:tp={norm['tp']}:" f"offset={norm['gain']}"
         )
         log.debug(f"audio norm first pass: {first_pass}")
-        file_null = "NUL" if system() in ("Windows", "cli") else "/dev/null"
-        cmd = [
-            "-hide_banner",
-            "-i",
-            f"{pre_master}",
-            "-af",
-            first_pass,
-            "-vn",
-            "-sn",
-            "-f",
-            "null",
-            file_null,
-        ]
-        process = ffmpeg.Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
-        stderr = process.communicate()[1]
-        name, filter_args = parse_ebu_bytes(norm, stderr, log)
+        with av.open(f"{pre_master}") as container:
+            stats_ = stats(first_pass, container.streams.audio[0])
+
+        name, filter_args = parse_ebu_bytes(norm, stats_, log)
     else:
         assert "t" in norm
 
@@ -238,12 +211,84 @@ def process_audio_clip(
     return read(output_bytes)[1]
 
 
+def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
+    mixed_audio = None
+    max_length = 0
+
+    # First pass: determine the maximum length
+    for path in audio_paths:
+        container = av.open(path)
+        stream = container.streams.audio[0]
+
+        # Calculate duration in samples
+        assert stream.duration is not None
+        assert stream.time_base is not None
+        duration_samples = int(stream.duration * sr / stream.time_base.denominator)
+        max_length = max(max_length, duration_samples)
+        container.close()
+
+    # Second pass: read and mix audio
+    for path in audio_paths:
+        container = av.open(path)
+        stream = container.streams.audio[0]
+
+        resampler = av.audio.resampler.AudioResampler(
+            format="s16", layout="mono", rate=sr
+        )
+
+        audio_array: list[np.ndarray] = []
+        for frame in container.decode(audio=0):
+            frame.pts = None
+            resampled = resampler.resample(frame)[0]
+            audio_array.extend(resampled.to_ndarray().flatten())
+
+        # Pad or truncate to max_length
+        current_audio = np.array(audio_array[:max_length])
+        if len(current_audio) < max_length:
+            current_audio = np.pad(
+                current_audio, (0, max_length - len(current_audio)), "constant"
+            )
+
+        if mixed_audio is None:
+            mixed_audio = current_audio.astype(np.float32)
+        else:
+            mixed_audio += current_audio.astype(np.float32)
+
+        container.close()
+
+    if mixed_audio is None:
+        raise ValueError("mixed_audio is None")
+
+    # Normalize the mixed audio
+    max_val = np.max(np.abs(mixed_audio))
+    if max_val > 0:
+        mixed_audio = mixed_audio * (32767 / max_val)
+    mixed_audio = mixed_audio.astype(np.int16)  # type: ignore
+
+    output_container = av.open(output_path, mode="w")
+    output_stream = output_container.add_stream("pcm_s16le", rate=sr)
+
+    chunk_size = sr  # Process 1 second at a time
+    for i in range(0, len(mixed_audio), chunk_size):
+        # Shape becomes (1, samples) for mono
+        chunk = np.array([mixed_audio[i : i + chunk_size]])
+
+        frame = av.AudioFrame.from_ndarray(chunk, format="s16", layout="mono")
+        frame.rate = sr
+        frame.pts = i  # Set presentation timestamp
+
+        output_container.mux(output_stream.encode(frame))
+
+    output_container.mux(output_stream.encode(None))
+    output_container.close()
+
+
 def make_new_audio(
-    tl: v3, ensure: Ensure, args: Args, ffmpeg: FFmpeg, bar: Bar, log: Log
+    tl: v3, ctr: Container, ensure: Ensure, args: Args, bar: Bar, log: Log
 ) -> list[str]:
     sr = tl.sr
     tb = tl.tb
-    output = []
+    output: list[str] = []
     samples: dict[tuple[FileInfo, int], AudioData] = {}
 
     norm = parse_norm(args.audio_normalize, log)
@@ -313,7 +358,7 @@ def make_new_audio(
                 with open(pre_master, "wb") as fid:
                     write(fid, sr, arr)
 
-                apply_audio_normalization(ffmpeg, norm, pre_master, path, log)
+                apply_audio_normalization(norm, pre_master, path, log)
 
         bar.end()
 
@@ -321,4 +366,9 @@ def make_new_audio(
         Path(temp, "asdf.map").unlink(missing_ok=True)
     except PermissionError:
         pass
+
+    if not (args.keep_tracks_separate and ctr.max_audios is None) and len(output) > 1:
+        new_a_file = f"{Path(temp, 'new_audio.wav')}"
+        mix_audio_files(sr, output, new_a_file)
+        return [new_a_file]
     return output

auto_editor/render/subtitle.py

@@ -157,12 +157,12 @@ def make_srt(input_: Input, stream: int) -> str:
     return output_bytes.getvalue()
 
 
-def _ensure(input_: Input, format: str, stream: int, log: Log) -> str:
+def _ensure(input_: Input, format: str, stream: int) -> str:
     output_bytes = io.BytesIO()
     output = av.open(output_bytes, "w", format=format)
 
     in_stream = input_.streams.subtitles[stream]
-    out_stream = output.add_stream(template=in_stream)
+    out_stream = output.add_stream_from_template(in_stream)
 
     for packet in input_.demux(in_stream):
         if packet.dts is None:
@@ -187,7 +187,9 @@ def make_new_subtitles(tl: v3, log: Log) -> list[str]:
             continue
 
         parser = SubtitleParser(tl.tb)
-        if sub.codec in ("webvtt", "ass", "ssa"):
+        if sub.codec == "ssa":
+            format = "ass"
+        elif sub.codec in ("webvtt", "ass"):
             format = sub.codec
         else:
             log.error(f"Unknown subtitle codec: {sub.codec}")
@@ -195,8 +197,8 @@ def make_new_subtitles(tl: v3, log: Log) -> list[str]:
         if sub.codec == "mov_text":
             ret = make_srt(input_, s)
         else:
-            ret = _ensure(input_, format, s, log)
-        parser.parse(ret, sub.codec)
+            ret = _ensure(input_, format, s)
+        parser.parse(ret, format)
         parser.edit(tl.v1.chunks)
 
         new_path = os.path.join(log.temp, f"new{s}s.{sub.ext}")

auto_editor/render/video.py

@@ -8,7 +8,6 @@ import numpy as np
 
 from auto_editor.output import parse_bitrate
 from auto_editor.timeline import TlImage, TlRect, TlVideo
-from auto_editor.utils.types import color
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -203,7 +202,7 @@ def render_av(
 
     bar.start(tl.end, "Creating new video")
 
-    bg = color(args.background)
+    bg = args.background
     null_frame = make_solid(target_width, target_height, target_pix_fmt, bg)
     frame_index = -1
 

auto_editor/subcommands/info.py

@@ -163,6 +163,8 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
             file_info[file]["subtitle"].append(sub)
 
     if args.json:
+        if sys.platform == "win32":
+            sys.stdout.reconfigure(encoding="utf-8")
         dump(file_info, sys.stdout, indent=4)
         return
 

auto_editor/subcommands/levels.py

@@ -5,9 +5,10 @@ from dataclasses import dataclass, field
 from fractions import Fraction
 from typing import TYPE_CHECKING
 
+import av
 import numpy as np
 
-from auto_editor.analyze import LevelError, Levels, iter_audio, iter_motion
+from auto_editor.analyze import *
 from auto_editor.ffwrapper import initFileInfo
 from auto_editor.lang.palet import env
 from auto_editor.lib.contracts import is_bool, is_nat, is_nat1, is_str, is_void, orc
@@ -130,9 +131,19 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
         levels = Levels(src, tb, bar, False, log, strict=True)
         try:
             if method == "audio":
-                print_arr_gen(iter_audio(src, tb, **obj))
+                container = av.open(src.path, "r")
+                audio_stream = container.streams.audio[obj["stream"]]
+                log.experimental(audio_stream.codec)
+                print_arr_gen(iter_audio(audio_stream, tb))
+                container.close()
+
             elif method == "motion":
-                print_arr_gen(iter_motion(src, tb, **obj))
+                container = av.open(src.path, "r")
+                video_stream = container.streams.video[obj["stream"]]
+                log.experimental(video_stream.codec)
+                print_arr_gen(iter_motion(video_stream, tb, obj["blur"], obj["width"]))
+                container.close()
+
             elif method == "subtitle":
                 print_arr(levels.subtitle(**obj))
             elif method == "none":

auto_editor/subcommands/test.py

@@ -360,7 +360,7 @@ def main(sys_args: list[str] | None = None):
                 """{"version": "1", "source": "example.mp4", "chunks": [ [0, 26, 1.0], [26, 34, 0] ]}"""
             )
 
-        return run.main(["v1.json"], [])
+        return "v1.json", run.main(["v1.json"], [])
 
     def premiere_named_export():
         run.main(["example.mp4"], ["--export", 'premiere:name="Foo Bar"'])

auto_editor/timeline.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 from auto_editor.ffwrapper import initFileInfo, mux
 from auto_editor.lib.contracts import *
 from auto_editor.utils.cmdkw import Required, pAttr, pAttrs
-from auto_editor.utils.types import color, natural, number, threshold
+from auto_editor.utils.types import natural, number, parse_color, threshold
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -165,7 +165,7 @@ rect_builder = pAttrs(
     pAttr("y", Required, is_int, int),
     pAttr("width", Required, is_int, int),
     pAttr("height", Required, is_int, int),
-    pAttr("fill", "#c4c4c4", is_str, color),
+    pAttr("fill", "#c4c4c4", is_str, parse_color),
 )
 visual_objects = {
     "rect": (TlRect, rect_builder),

auto_editor/utils/cmdkw.py

@@ -35,11 +35,6 @@ class pAttrs:
         self.attrs = attrs
 
 
-def _norm_name(s: str) -> str:
-    # Python does not allow - in variable names
-    return s.replace("-", "_")
-
-
 class PLexer:
     __slots__ = ("text", "pos", "char")
 
@@ -101,6 +96,10 @@ def parse_with_palet(
     KEYWORD_SEP = "="
     kwargs: dict[str, Any] = {}
 
+    def _norm_name(s: str) -> str:
+        # Python does not allow - in variable names
+        return s.replace("-", "_")
+
     def go(text: str, c: Any) -> Any:
         try:
             env = _env if isinstance(_env, Env) else Env(_env)
@@ -174,9 +173,7 @@ def parse_with_palet(
     return kwargs
 
 
-def parse_method(
-    name: str, text: str, env: Env
-) -> tuple[str, list[Any], dict[str, Any]]:
+def parse_method(name: str, text: str) -> tuple[str, list[Any], dict[str, Any]]:
     from auto_editor.lang.palet import Lexer, Parser
 
     # Positional Arguments

auto_editor/utils/container.py

@@ -55,12 +55,9 @@ def codec_type(x: str) -> str:
         return "subtitle"
 
     try:
-        return Codec(x, "r").type
+        return Codec(x, "w").type
     except Exception:
-        try:
-            return Codec(x, "w").type
-        except Exception:
-            return ""
+        return ""
 
 
 def container_constructor(ext: str) -> Container:

auto_editor/utils/func.py

@@ -81,21 +81,10 @@ def mut_margin(arr: BoolList, start_m: int, end_m: int) -> None:
             arr[max(i + end_m, 0) : i] = False
 
 
-def merge(start_list: np.ndarray, end_list: np.ndarray) -> BoolList:
-    result = np.zeros((len(start_list)), dtype=np.bool_)
-
-    for i, item in enumerate(start_list):
-        if item == True:
-            where = np.where(end_list[i:])[0]
-            if len(where) > 0:
-                result[i : where[0]] = True
-    return result
-
-
 def get_stdout(cmd: list[str]) -> str:
     from subprocess import DEVNULL, PIPE, Popen
 
-    stdout, _ = Popen(cmd, stdin=DEVNULL, stdout=PIPE, stderr=PIPE).communicate()
+    stdout = Popen(cmd, stdin=DEVNULL, stdout=PIPE, stderr=PIPE).communicate()[0]
     return stdout.decode("utf-8", "replace")
 
 
@@ -116,25 +105,3 @@ def aspect_ratio(width: int, height: int) -> tuple[int, int]:
 
     c = gcd(width, height)
     return width // c, height // c
-
-
-def human_readable_time(time_in_secs: float) -> str:
-    units = "seconds"
-    if time_in_secs >= 3600:
-        time_in_secs = round(time_in_secs / 3600, 1)
-        if time_in_secs % 1 == 0:
-            time_in_secs = round(time_in_secs)
-        units = "hours"
-    if time_in_secs >= 60:
-        time_in_secs = round(time_in_secs / 60, 1)
-        if time_in_secs >= 10 or time_in_secs % 1 == 0:
-            time_in_secs = round(time_in_secs)
-        units = "minutes"
-    return f"{time_in_secs} {units}"
-
-
-def append_filename(path: str, val: str) -> str:
-    from os.path import splitext
-
-    root, ext = splitext(path)
-    return root + val + ext

auto_editor/utils/log.py

@@ -7,6 +7,8 @@ from tempfile import mkdtemp
 from time import perf_counter, sleep
 from typing import NoReturn
 
+import av
+
 
 class Log:
     __slots__ = ("is_debug", "quiet", "machine", "no_color", "_temp", "_ut", "_s")
@@ -97,6 +99,10 @@ class Log:
 
             sys.stdout.write(f"Finished. took {second_len} seconds ({minute_len})\n")
 
+    def experimental(self, codec: av.Codec) -> None:
+        if codec.experimental:
+            self.error(f"`{codec.name}` is an experimental codec")
+
     def error(self, message: str | Exception) -> NoReturn:
         if self.is_debug and isinstance(message, Exception):
             self.cleanup()

auto_editor/utils/types.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import re
 from dataclasses import dataclass, field
 from fractions import Fraction
-from typing import Literal
 
 
 class CoerceError(Exception):
@@ -156,16 +155,7 @@ def speed_range(val: str) -> tuple[float, str, str]:
     return number(a[0]), a[1], a[2]
 
 
-Stream = int | Literal["all"]
-
-
-def stream(val: str) -> Stream:
-    if val == "all" or val == "'all":
-        return "all"
-    return natural(val)
-
-
-def color(val: str) -> str:
+def parse_color(val: str) -> str:
     """
     Convert a color str into an RGB tuple
 
@@ -219,22 +209,18 @@ class Args:
     frame_rate: Fraction | None = None
     sample_rate: int | None = None
     resolution: tuple[int, int] | None = None
-    background: str = "#000"
-    edit_based_on: str = "audio"
+    background: str = "#000000"
+    edit: str = "audio"
     keep_tracks_separate: bool = False
     audio_normalize: str = "#f"
     export: str | None = None
     player: str | None = None
     no_open: bool = False
     temp_dir: str | None = None
-    ffmpeg_location: str | None = None
-    my_ffmpeg: bool = False
     progress: str = "modern"
     version: bool = False
     debug: bool = False
     config: bool = False
-    show_ffmpeg_commands: bool = False
-    show_ffmpeg_output: bool = False
     quiet: bool = False
     preview: bool = False
     no_cache: bool = False

{auto_editor-26.0.0.dist-info → auto_editor-26.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 26.0.0
+Version: 26.1.0
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense
@@ -11,9 +11,8 @@ Keywords: video,audio,media,editor,editing,processing,nonlinear,automatic,silenc
 Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy <3.0,>=1.23.0
-Requires-Dist: pyav ==13.1.*
-Requires-Dist: ae-ffmpeg ==1.2.*
+Requires-Dist: numpy<3.0,>=1.24
+Requires-Dist: pyav==14.*
 
 <p align="center"><img src="https://auto-editor.com/img/auto-editor-banner.webp" title="Auto-Editor" width="700"></p>
 

auto_editor-26.1.0.dist-info/RECORD

@@ -0,0 +1,55 @@
+auto_editor/__init__.py,sha256=8MQdwPYn_Y7GCbtRLrmuh9XSy5S52w2pxd3bulKs9Ag,23
+auto_editor/__main__.py,sha256=eAsNa1BP4Y6Oyp4l838YmcxEwsM0LUdbaGeNFELe4h0,11124
+auto_editor/analyze.py,sha256=HyRdnty3VW9ZTwwPwjsZp3bLVRLvII_1Y6NlEItDKfw,11947
+auto_editor/edit.py,sha256=eEMRaQbn0jylfJ6D_egnUXjoMCbdQVsAu7MDrn-xlGo,15950
+auto_editor/ffwrapper.py,sha256=Tct_Q-uy5F51h8M7UFam50UzRFpgkBvUamJP1AoKVvc,4749
+auto_editor/help.py,sha256=CzfDTsL4GuGu596ySHKj_wKnxGR9h8B0KUdkZpo33oE,8044
+auto_editor/make_layers.py,sha256=vEeJt0PnE1vc9-cQZ_AlXVDjvWhObRCWJSCQGraoMvU,9016
+auto_editor/output.py,sha256=ho8Lpqz4Sv_Gw0Vj2OvG39s83xHpyZlvtRNryTPbXqc,2563
+auto_editor/preview.py,sha256=HUsjmV9Fx73rZ26BXrpz9z-z_e4oiui3u9e7qbbGoBY,3037
+auto_editor/timeline.py,sha256=XfaH9cH-RB-MObOpMr5IfLcqJcjmabO1XwkUkT3_FQM,8186
+auto_editor/vanparse.py,sha256=f0vViZ-aYtDxEyVrFHJ5X2pPTQAfqtw3N2gZgzn51kU,10002
+auto_editor/wavfile.py,sha256=1HbZ4L8IBD6Fbg3pd5MQG4ZXy48YZA05t8XllSplhWk,9499
+auto_editor/formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_editor/formats/fcp11.py,sha256=qzo-qpHYsiHjOPjGBWjBeJUAACDmo8ijJkjslHTQH6Q,5196
+auto_editor/formats/fcp7.py,sha256=LYkGtZC_dmbHQDg1wYP7XQYS74NEon6ws8c5MDdTd90,20275
+auto_editor/formats/json.py,sha256=Br-xHVHj59C0OPP2FwfJeht_fImepRXsaw0iDFvK7-w,7693
+auto_editor/formats/shotcut.py,sha256=-ES854LLFCMCBe100JRJedDmuk8zPev17aQMTrzPv-g,4923
+auto_editor/formats/utils.py,sha256=LYXDiqOk9WwUorLGw2D0M7In9BNDkoKikNawuks7hqE,1648
+auto_editor/lang/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_editor/lang/json.py,sha256=OsNcYlfEj8ZLlzLK-gkLcrCCKI7mJz9rpe-6XLr4f9U,9231
+auto_editor/lang/libintrospection.py,sha256=6H1rGp0wqaCud5IPaoEmzULGnYt6ec7_0h32ATcw2oY,261
+auto_editor/lang/libmath.py,sha256=z33A161Oe6vYYK7R6pgYjdZZe63dQkN38Qf36TL3prg,847
+auto_editor/lang/palet.py,sha256=jHSO8R4eAbMeiQaGwCLih6z0pPGoJEcmPgSvsTpF8EA,24139
+auto_editor/lang/stdenv.py,sha256=3UnVgLaTT7hQMhquDmv-mQx82jtr_YOYstwZAwvXfJY,43754
+auto_editor/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_editor/lib/contracts.py,sha256=lExGQymcQUmwG5lC1lO4qm4GY8W0q_yzK_miTaAoPA4,7586
+auto_editor/lib/data_structs.py,sha256=dcsXgsLLzbmFDUZucoirzewPALsKzoxz7z5L22_QJM8,7091
+auto_editor/lib/err.py,sha256=UlszQJdzMZwkbT8x3sY4GkCV_5x9yrd6uVVUzvA8iiI,35
+auto_editor/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_editor/render/audio.py,sha256=1iOQCeRXfRz28cqnHp2XeK-f3_UnPf80AKQAfifGvdE,12584
+auto_editor/render/subtitle.py,sha256=lf2l1QWJgFiqlpQWWBwSlKJnSgW8Lkfi59WrJMbIDqM,6240
+auto_editor/render/video.py,sha256=dje0RNW2dKILfTzt0VAF0WR6REfGOsc6l17pP1Z4ooA,12215
+auto_editor/subcommands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_editor/subcommands/desc.py,sha256=GDrKJYiHMaeTrplZAceXl1JwoqD78XsV2_5lc0Xd7po,869
+auto_editor/subcommands/info.py,sha256=UDdoxd6_fqSoRPwthkWXqnpxHp7dJQ0Dn96lYX_ubWc,7010
+auto_editor/subcommands/levels.py,sha256=psSSIsGfzr9j0HGKp2yvK6nMlrkLwxkwsyI0uF2xb_c,4496
+auto_editor/subcommands/palet.py,sha256=ONzTqemaQq9YEfIOsDRNnwzfqnEMUMSXIQrETxyroRU,749
+auto_editor/subcommands/repl.py,sha256=TF_I7zsFY7-KdgidrqjafTz7o_eluVbLvgTcOBG-UWQ,3449
+auto_editor/subcommands/subdump.py,sha256=af_XBf7kaevqHn1A71z8C-7x8pS5WKD9FE_ugkCw6rk,665
+auto_editor/subcommands/test.py,sha256=bR3MQvW1P_cKDwd1hRa2t-n3GqgRGGv5D3IBnfrH8-0,25787
+auto_editor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_editor/utils/bar.py,sha256=hG_NiYeuM90TdILzAJORft-UOS5grwWN3SbRuj6upsI,3998
+auto_editor/utils/chunks.py,sha256=J-eGKtEz68gFtRrj1kOSgH4Tj_Yz6prNQ7Xr-d9NQJw,52
+auto_editor/utils/cmdkw.py,sha256=aUGBvBel2Ko1o6Rwmr4rEL-BMc5hEnzYLbyZ1GeJdcY,5729
+auto_editor/utils/container.py,sha256=Wf1ZL0tvXWl6m1B9mK_SkgVl89ilV_LpwlQq0TVroCc,2704
+auto_editor/utils/func.py,sha256=kB-pNDn20M6YT7sljyd_auve5teK-E2G4TgwVOAIuJw,2754
+auto_editor/utils/log.py,sha256=C1b-vnszSsohMd5fyaRcCuf0OPobZVMkV77cP-_JNP4,3776
+auto_editor/utils/types.py,sha256=7BF7R7DA5eKmtI6f5ia7bOYNL0u_2sviiPsE1VmP0lc,10724
+docs/build.py,sha256=CM-ZWgQk8wSNjivx_-6wGIaG7cstrNKsX2d4TzFVivE,1642
+auto_editor-26.1.0.dist-info/LICENSE,sha256=yiq99pWITHfqS0pbZMp7cy2dnbreTuvBwudsU-njvIM,1210
+auto_editor-26.1.0.dist-info/METADATA,sha256=QDfveFTnxTtnA2WqZTvgM4vNGQ1sTnziQ2MSAyqF5WQ,6109
+auto_editor-26.1.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+auto_editor-26.1.0.dist-info/entry_points.txt,sha256=-H7zdTw4MqnAcwrN5xTNkGIhzZtJMxS9r6lTMeR9-aA,240
+auto_editor-26.1.0.dist-info/top_level.txt,sha256=jBV5zlbWRbKOa-xaWPvTD45QL7lGExx2BDzv-Ji4dTw,17
+auto_editor-26.1.0.dist-info/RECORD,,

{auto_editor-26.0.0.dist-info → auto_editor-26.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any