auto-editor 25.3.0__py3-none-any.whl → 25.3.1__py3-none-any.whl

auto_editor/__init__.py

@@ -1 +1 @@
-__version__ = "25.3.0"
+__version__ = "25.3.1"

auto_editor/__main__.py

@@ -1,11 +1,15 @@
 #!/usr/bin/env python3
 
+import re
 import sys
 from os import environ
+from os.path import exists, isdir, isfile, lexists, splitext
+from subprocess import run
 
 import auto_editor
 from auto_editor.edit import edit_media
-from auto_editor.ffwrapper import FFmpeg
+from auto_editor.ffwrapper import FFmpeg, initFFmpeg
+from auto_editor.utils.func import get_stdout
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import (
     Args,
@@ -20,7 +24,6 @@ from auto_editor.utils.types import (
     speed_range,
     time_range,
 )
-from auto_editor.validate_input import valid_input
 from auto_editor.vanparse import ArgumentParser
 
 
@@ -274,6 +277,50 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
     return parser
 
 
+def download_video(my_input: str, args: Args, ffmpeg: FFmpeg, log: Log) -> str:
+    log.conwrite("Downloading video...")
+
+    def get_domain(url: str) -> str:
+        t = __import__("urllib").parse.urlparse(url).netloc
+        return ".".join(t.split(".")[-2:])
+
+    download_format = args.download_format
+    if download_format is None and get_domain(my_input) == "youtube.com":
+        download_format = "bestvideo[ext=mp4]+bestaudio[ext=m4a]"
+
+    if args.output_format is None:
+        output_format = re.sub(r"\W+", "-", splitext(my_input)[0]) + ".%(ext)s"
+    else:
+        output_format = args.output_format
+
+    yt_dlp_path = args.yt_dlp_location
+
+    cmd = ["--ffmpeg-location", ffmpeg.path]
+
+    if download_format is not None:
+        cmd.extend(["-f", download_format])
+
+    cmd.extend(["-o", output_format, my_input])
+
+    if args.yt_dlp_extras is not None:
+        cmd.extend(args.yt_dlp_extras.split(" "))
+
+    try:
+        location = get_stdout(
+            [yt_dlp_path, "--get-filename", "--no-warnings"] + cmd
+        ).strip()
+    except FileNotFoundError:
+        log.error("Program `yt-dlp` must be installed and on PATH.")
+
+    if not isfile(location):
+        run([yt_dlp_path] + cmd)
+
+    if not isfile(location):
+        log.error(f"Download file wasn't created: {location}")
+
+    return location
+
+
 def main() -> None:
     subcommands = ("test", "info", "levels", "subdump", "desc", "repl", "palet")
 
@@ -284,8 +331,7 @@ def main() -> None:
         obj.main(sys.argv[2:])
         return
 
-    ff_color = "AV_LOG_FORCE_NOCOLOR"
-    no_color = bool(environ.get("NO_COLOR")) or bool(environ.get(ff_color))
+    no_color = bool(environ.get("NO_COLOR") or environ.get("AV_LOG_FORCE_NOCOLOR"))
     log = Log(no_color=no_color)
 
     args = main_options(ArgumentParser("Auto-Editor")).parse_args(
@@ -327,13 +373,28 @@ def main() -> None:
     is_machine = args.progress == "machine"
     log = Log(args.debug, args.quiet, args.temp_dir, is_machine, no_color)
 
-    ffmpeg = FFmpeg(
+    ffmpeg = initFFmpeg(
+        log,
         args.ffmpeg_location,
         args.my_ffmpeg,
         args.show_ffmpeg_commands,
         args.show_ffmpeg_output,
     )
-    paths = valid_input(args.input, ffmpeg, args, log)
+    paths = []
+    for my_input in args.input:
+        if my_input.startswith("http://") or my_input.startswith("https://"):
+            paths.append(download_video(my_input, args, ffmpeg, log))
+        else:
+            if not splitext(my_input)[1]:
+                if isdir(my_input):
+                    log.error("Input must be a file or a URL, not a directory.")
+                if exists(my_input):
+                    log.error(f"Input file must have an extension: {my_input}")
+                if lexists(my_input):
+                    log.error(f"Input file is a broken symbolic link: {my_input}")
+                if my_input.startswith("-"):
+                    log.error(f"Option/Input file doesn't exist: {my_input}")
+            paths.append(my_input)
 
     try:
         edit_media(paths, ffmpeg, args, log)

auto_editor/analyze.py

@@ -14,13 +14,11 @@ from av.audio.fifo import AudioFifo
 from av.subtitles.subtitle import AssSubtitle
 
 from auto_editor import __version__
-from auto_editor.utils.subtitle_tools import convert_ass_to_text
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import Iterator, Sequence
     from fractions import Fraction
     from pathlib import Path
-    from typing import Any
 
     from numpy.typing import NDArray
 
@@ -156,10 +154,10 @@ 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:
+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}:{kind}:{tb}:"
-    return key + ",".join(f"{v}" for v in obj.values())
+    return key + ",".join(f"{v}" for v in obj)
 
 
 @dataclass(slots=True)
@@ -174,7 +172,7 @@ class Levels:
     @property
     def media_length(self) -> int:
         if self.src.audios:
-            if (arr := self.read_cache("audio", {"stream": 0})) is not None:
+            if (arr := self.read_cache("audio", (0,))) is not None:
                 return len(arr)
 
             result = sum(1 for _ in iter_audio(self.src, self.tb, 0))
@@ -202,7 +200,7 @@ class Levels:
     def all(self) -> NDArray[np.bool_]:
         return np.zeros(self.media_length, dtype=np.bool_)
 
-    def read_cache(self, kind: str, obj: dict[str, Any]) -> None | np.ndarray:
+    def read_cache(self, kind: str, obj: Sequence[object]) -> None | np.ndarray:
         if self.no_cache:
             return None
 
@@ -221,7 +219,7 @@ class Levels:
         self.log.debug("Using cache")
         return npzfile[key]
 
-    def cache(self, arr: np.ndarray, kind: str, obj: dict[str, Any]) -> np.ndarray:
+    def cache(self, arr: np.ndarray, kind: str, obj: Sequence[object]) -> np.ndarray:
         if self.no_cache:
             return arr
 
@@ -238,7 +236,7 @@ class Levels:
         if stream >= len(self.src.audios):
             raise LevelError(f"audio: audio stream '{stream}' does not exist.")
 
-        if (arr := self.read_cache("audio", {"stream": stream})) is not None:
+        if (arr := self.read_cache("audio", (stream,))) is not None:
             return arr
 
         with av.open(self.src.path, "r") as container:
@@ -265,13 +263,13 @@ class Levels:
             index += 1
 
         bar.end()
-        return self.cache(result[:index], "audio", {"stream": stream})
+        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):
             raise LevelError(f"motion: video stream '{stream}' does not exist.")
 
-        mobj = {"stream": stream, "width": width, "blur": blur}
+        mobj = (stream, width, blur)
         if (arr := self.read_cache("motion", mobj)) is not None:
             return arr
 
@@ -360,11 +358,10 @@ class Levels:
                 san_end = round((start + dur) * self.tb)
 
                 for sub in subset:
-                    if isinstance(sub, AssSubtitle):
-                        line = convert_ass_to_text(sub.ass.decode(errors="ignore"))
-                    else:
+                    if not isinstance(sub, AssSubtitle):
                         continue
 
+                    line = sub.dialogue.decode(errors="ignore")
                     if line and re.search(re_pattern, line):
                         result[san_start:san_end] = 1
                         count += 1

auto_editor/edit.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import os
+import sys
+from subprocess import run
 from typing import Any
 
 from auto_editor.ffwrapper import FFmpeg, FileInfo, initFileInfo
@@ -15,7 +17,6 @@ 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
-from auto_editor.utils.func import open_with_system_default
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import Args
 
@@ -328,7 +329,7 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
         total_frames = tl.v1.chunks[-1][1] - 1
         clip_num = 0
         for chunk in tl.v1.chunks:
-            if chunk[2] == 99999:
+            if chunk[2] == 0 or chunk[2] >= 99999:
                 continue
 
             padded_chunks = pad_chunk(chunk, total_frames)
@@ -354,11 +355,23 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
 
     log.stop_timer()
 
-    if not args.no_open and export in ("default", "audio", "clip-sequence"):
+    if not args.no_open and export in ("default", "audio"):
         if args.player is None:
-            open_with_system_default(output, log)
+            if sys.platform == "win32":
+                try:
+                    os.startfile(output)
+                except OSError:
+                    log.warning(f"Could not find application to open file: {output}")
+            else:
+                try:  # MacOS case
+                    run(["open", output])
+                except Exception:
+                    try:  # WSL2 case
+                        run(["cmd.exe", "/C", "start", output])
+                    except Exception:
+                        try:  # Linux case
+                            run(["xdg-open", output])
+                        except Exception:
+                            log.warning(f"Could not open output file: {output}")
         else:
-            import subprocess
-            from shlex import split
-
-            subprocess.run(split(args.player) + [output])
+            run(__import__("shlex").split(args.player) + [output])

auto_editor/ffwrapper.py

@@ -1,83 +1,59 @@
 from __future__ import annotations
 
 import os.path
-import subprocess
 import sys
 from dataclasses import dataclass
 from fractions import Fraction
 from pathlib import Path
 from re import search
 from shutil import which
-from subprocess import PIPE, Popen
+from subprocess import PIPE, Popen, run
 from typing import Any
 
 import av
 
-from auto_editor.utils.func import get_stdout
 from auto_editor.utils.log import Log
 
 
-class FFmpeg:
-    __slots__ = ("debug", "show_cmd", "path", "version")
-
-    def __init__(
-        self,
-        ff_location: str | None = None,
-        my_ffmpeg: bool = False,
-        show_cmd: bool = False,
-        debug: bool = False,
-    ):
-        def _set_ff_path(ff_location: str | None, my_ffmpeg: bool) -> str:
-            if ff_location is not None:
-                return ff_location
-            if my_ffmpeg:
-                return "ffmpeg"
-
-            try:
-                import ae_ffmpeg
-
-                return ae_ffmpeg.get_path()
-            except ImportError:
-                return "ffmpeg"
-
-        self.debug = debug
-        self.show_cmd = show_cmd
-        _path: str | None = _set_ff_path(ff_location, my_ffmpeg)
-
-        if _path == "ffmpeg":
-            _path = which("ffmpeg")
-
-        if _path is None:
-            Log().error("Did not find ffmpeg on PATH.")
-        self.path = _path
-
+def initFFmpeg(
+    log: Log, ff_location: str | None, my_ffmpeg: bool, show_cmd: bool, debug: bool
+) -> FFmpeg:
+    if ff_location is not None:
+        program = ff_location
+    elif my_ffmpeg:
+        program = "ffmpeg"
+    else:
         try:
-            _version = get_stdout([self.path, "-version"]).split("\n")[0]
-            self.version = _version.replace("ffmpeg version", "").strip().split(" ")[0]
-        except FileNotFoundError:
-            Log().error("ffmpeg must be installed and on PATH.")
+            import ae_ffmpeg
 
-    def print(self, message: str) -> None:
-        if self.debug:
-            sys.stderr.write(f"FFmpeg: {message}\n")
+            program = ae_ffmpeg.get_path()
+        except ImportError:
+            program = "ffmpeg"
 
-    def print_cmd(self, cmd: list[str]) -> None:
-        if self.show_cmd:
-            sys.stderr.write(f"{' '.join(cmd)}\n\n")
+    path: str | None = which(program)
+    if path is None:
+        log.error("Did not find ffmpeg on PATH.")
+
+    return FFmpeg(log, path, show_cmd, debug)
+
+
+@dataclass(slots=True)
+class FFmpeg:
+    log: Log
+    path: str
+    show_cmd: bool
+    debug: bool
 
     def run(self, cmd: list[str]) -> None:
         cmd = [self.path, "-hide_banner", "-y"] + cmd
         if not self.debug:
             cmd.extend(["-nostats", "-loglevel", "error"])
-        self.print_cmd(cmd)
-        subprocess.run(cmd)
+        if self.show_cmd:
+            sys.stderr.write(f"{' '.join(cmd)}\n\n")
+        run(cmd)
 
     def run_check_errors(
-        self,
-        cmd: list[str],
-        log: Log,
-        show_out: bool = False,
-        path: str | None = None,
+        self, cmd: list[str], show_out: bool = False, path: str | None = None
     ) -> None:
         process = self.Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
         _, stderr = process.communicate()
@@ -104,40 +80,27 @@ class FFmpeg:
 
         for item in error_list:
             if check := search(item, output):
-                log.error(check.group())
+                self.log.error(check.group())
 
         if path is not None and not os.path.isfile(path):
-            log.error(f"The file {path} was not created.")
-        elif show_out and not self.debug:
+            self.log.error(f"The file {path} was not created.")
+        if show_out and not self.debug:
             print(f"stderr: {output}")
 
     def Popen(
         self, cmd: list[str], stdin: Any = None, stdout: Any = PIPE, stderr: Any = None
     ) -> Popen:
-        cmd = [self.path] + cmd
-        self.print_cmd(cmd)
-        return Popen(cmd, stdin=stdin, stdout=stdout, stderr=stderr)
-
-    def pipe(self, cmd: list[str]) -> str:
-        cmd = [self.path, "-y"] + cmd
-
-        self.print_cmd(cmd)
-        output = get_stdout(cmd)
-        self.print(output)
-        return output
+        if self.show_cmd:
+            sys.stderr.write(f"{self.path} {' '.join(cmd)}\n\n")
+        return Popen([self.path] + cmd, stdin=stdin, stdout=stdout, stderr=stderr)
 
 
-def mux(input: Path, output: Path, stream: int, codec: str | None = None) -> None:
+def mux(input: Path, output: Path, stream: int) -> 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)
+    output_audio_stream = output_container.add_stream("pcm_s16le")
 
     for frame in input_container.decode(input_audio_stream):
         packet = output_audio_stream.encode(frame)

auto_editor/output.py

@@ -241,4 +241,4 @@ def mux_quality_media(
         cmd.extend(["-map", "0:d?"])
 
     cmd.append(output_path)
-    ffmpeg.run_check_errors(cmd, log, path=output_path)
+    ffmpeg.run_check_errors(cmd, path=output_path)

auto_editor/render/audio.py

@@ -180,7 +180,6 @@ def process_audio_clip(
     output_bytes = io.BytesIO()
     output_file = av.open(output_bytes, mode="w", format="wav")
     output_stream = output_file.add_stream("pcm_s16le", rate=sr)
-    assert isinstance(output_stream, av.audio.AudioStream)
 
     graph = av.filter.Graph()
     args = [graph.add_abuffer(template=input_stream)]
@@ -212,7 +211,7 @@ def process_audio_clip(
         while True:
             try:
                 aframe = graph.pull()
-                assert isinstance(aframe, av.audio.AudioFrame)
+                assert isinstance(aframe, av.AudioFrame)
                 for packet in output_stream.encode(aframe):
                     output_file.mux(packet)
             except (av.BlockingIOError, av.EOFError):

auto_editor/render/subtitle.py

@@ -112,13 +112,15 @@ class SubtitleParser:
         self.contents = new_content
 
     def write(self, file_path: str) -> None:
+        codec = self.codec
         with open(file_path, "w", encoding="utf-8") as file:
             file.write(self.header)
             for c in self.contents:
                 file.write(
-                    f"{c.before}{to_timecode(c.start / self.tb, self.codec)}"
-                    f"{c.middle}{to_timecode(c.end / self.tb, self.codec)}"
-                    f"{c.after}"
+                    f"{c.before}{to_timecode(c.start / self.tb, codec)}"
+                    + f"{c.middle}{to_timecode(c.end / self.tb, codec)}"
+                    + c.after
+                    + ("\n" if codec == "webvtt" else "")
                 )
             file.write(self.footer)
 

auto_editor/render/video.py

@@ -339,7 +339,7 @@ def render_av(
         process2.wait()
     except (OSError, BrokenPipeError):
         bar.end()
-        ffmpeg.run_check_errors(cmd, log, True)
+        ffmpeg.run_check_errors(cmd, True)
         log.error("FFmpeg Error!")
 
     log.debug(f"Total frames saved seeking: {frames_saved}")

auto_editor/subcommands/test.py

@@ -186,7 +186,7 @@ def main(sys_args: list[str] | None = None):
         "wav/pcm-f32le.wav",
         "wav/pcm-s32le.wav",
         "multi-track.mov",
-        "subtitle.mp4",
+        "mov_text.mp4",
         "testsrc.mkv",
     )
 
@@ -222,7 +222,8 @@ def main(sys_args: list[str] | None = None):
         run.raw(["levels", "resources/new-commentary.mp3"])
 
     def subdump():
-        run.raw(["subdump", "resources/subtitle.mp4"])
+        run.raw(["subdump", "resources/mov_text.mp4"])
+        run.raw(["subdump", "resources/webvtt.mkv"])
 
     def desc():
         run.raw(["desc", "example.mp4"])
@@ -357,7 +358,13 @@ def main(sys_args: list[str] | None = None):
         run.main(["example.mp4"], ["--export", 'premiere:name="Foo Bar"'])
 
     def export_subtitles():
-        cn = fileinfo(run.main(["resources/subtitle.mp4"], []))
+        cn = fileinfo(run.main(["resources/mov_text.mp4"], []))
+
+        assert len(cn.videos) == 1
+        assert len(cn.audios) == 1
+        assert len(cn.subtitles) == 1
+
+        cn = fileinfo(run.main(["resources/webvtt.mkv"], []))
 
         assert len(cn.videos) == 1
         assert len(cn.audios) == 1

auto_editor/utils/func.py

@@ -10,8 +10,6 @@ if TYPE_CHECKING:
 
     from numpy.typing import NDArray
 
-    from auto_editor.utils.log import Log
-
     BoolList = NDArray[np.bool_]
     BoolOperand = Callable[[BoolList, BoolList], BoolList]
 
@@ -135,30 +133,6 @@ def human_readable_time(time_in_secs: float) -> str:
     return f"{time_in_secs} {units}"
 
 
-def open_with_system_default(path: str, log: Log) -> None:
-    import sys
-    from subprocess import run
-
-    if sys.platform == "win32":
-        from os import startfile
-
-        try:
-            startfile(path)
-        except OSError:
-            log.warning("Could not find application to open file.")
-    else:
-        try:  # MacOS case
-            run(["open", path])
-        except Exception:
-            try:  # WSL2 case
-                run(["cmd.exe", "/C", "start", path])
-            except Exception:
-                try:  # Linux case
-                    run(["xdg-open", path])
-                except Exception:
-                    log.warning("Could not open output file.")
-
-
 def append_filename(path: str, val: str) -> str:
     from os.path import splitext
 

{auto_editor-25.3.0.dist-info → auto_editor-25.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 25.3.0
+Version: 25.3.1
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense
@@ -12,7 +12,7 @@ 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.0.*
+Requires-Dist: pyav ==13.1.*
 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.dist-info → auto_editor-25.3.1.dist-info}/RECORD

@@ -1,14 +1,13 @@
-auto_editor/__init__.py,sha256=V88FPgx32W4RJtvMHBXxRB94vigVyEqLl2H3hz7xxsc,23
-auto_editor/__main__.py,sha256=XUzQoN8mMrm0RVqOHnkl-ksw53Klk7fHdGhJObtDZfE,10102
-auto_editor/analyze.py,sha256=0WgeEzb1BB3C1MvaGfWZGg35MTYEL1YdHFYqwguSPbc,11869
-auto_editor/edit.py,sha256=0dYqFAP1TwBh-40k14dEAaLUDhzqoZFFLuaNxs45Dis,11740
-auto_editor/ffwrapper.py,sha256=88r-1DN0hD33myt4-tGMqphLJYU7wBl75lYs6MaNJQE,8634
+auto_editor/__init__.py,sha256=2StKlE00iLSdWP1B73T1WJb76-2gk0h3rPFRqAk5ZXM,23
+auto_editor/__main__.py,sha256=0t_yI-o11iwDm_LlUW_u84LsX89cv0GuHMfc0NKlp68,12228
+auto_editor/analyze.py,sha256=uCi21659BB-lbPwZ6yxNLekS6Q3yoB2ypLNXPhmhTfg,11688
+auto_editor/edit.py,sha256=9G2_g_8FEzQrvB3Ez9M5vtgrIS0feZeA4DdxT9cdObA,12319
+auto_editor/ffwrapper.py,sha256=K-gs5mAdcwPaaZVdU1yOl7ckptO7eJ_zLQM8V7vwxaA,7491
 auto_editor/help.py,sha256=BFiP7vBz42TUzum4-zaQIrV1OY7kHeN0pe0MPE0T5xw,7997
 auto_editor/make_layers.py,sha256=8uFy5SvMArAP-5slYJrxa_iGAEwimQBFeM-T01VORVw,8995
-auto_editor/output.py,sha256=Ai5JtSK0-wYED9cS0A2BXbMO6e09aMcaZOIsupOsPJ8,8002
+auto_editor/output.py,sha256=TbwiFL7CQnPv5_Pv0bSaE2faLvepxaIf5_xMvDAFXjQ,7997
 auto_editor/preview.py,sha256=HUsjmV9Fx73rZ26BXrpz9z-z_e4oiui3u9e7qbbGoBY,3037
 auto_editor/timeline.py,sha256=tIty8O8jD6TR2Sw2bivUtYtdnpplfuOXT7Dfc-gekr8,8174
-auto_editor/validate_input.py,sha256=_9vtbNxodhVPf4PzTAH67LSj2K-HS6kShJOARmUMJdY,2904
 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
@@ -28,9 +27,9 @@ auto_editor/lib/contracts.py,sha256=lExGQymcQUmwG5lC1lO4qm4GY8W0q_yzK_miTaAoPA4,
 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=Jo6d4r75QkkDRPBLFd5UQ4JsWC9sx9rnJ80Gf8R2pfg,9715
-auto_editor/render/subtitle.py,sha256=CNcU_hmLwfZ2yvmSllIK-pB7ge_YdXHR-fnnOVUO9m8,4425
-auto_editor/render/video.py,sha256=OWtziP6l9AuMdeb3I7CBv8SlgaXS5BcRilCX47BkadU,12492
+auto_editor/render/audio.py,sha256=QF3nQMChIxL0GVy4AONvsnqrX_nqT31RrogLwxwWAO8,9650
+auto_editor/render/subtitle.py,sha256=HCWL9HvFXZPeGUd0mI1K5okHnKf1f6hw-DgPFFPOKA0,4499
+auto_editor/render/video.py,sha256=gQJx_zcqvL__WJNG8mfFWblSr8XFkuCeIW3nCXoIdKU,12487
 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=t5n43HLt9hpMFSIfGV777X4zIPBAFugOKlpCfRjiKxY,6921
@@ -38,21 +37,20 @@ auto_editor/subcommands/levels.py,sha256=ChJMDTd34-jgxewqHRmmd3VNhFdy964w0DcQG0l
 auto_editor/subcommands/palet.py,sha256=ONzTqemaQq9YEfIOsDRNnwzfqnEMUMSXIQrETxyroRU,749
 auto_editor/subcommands/repl.py,sha256=DuMz5kImoZFSVMZh6sPQxqZXMbRXPCvXoW3G-MJfivc,3166
 auto_editor/subcommands/subdump.py,sha256=af_XBf7kaevqHn1A71z8C-7x8pS5WKD9FE_ugkCw6rk,665
-auto_editor/subcommands/test.py,sha256=aGB9muIl4b49j_vpll-Sv8O-yqRU646_Dv_hL6GdWgU,25443
+auto_editor/subcommands/test.py,sha256=ovYMX5_Fm1qSq8_ojnBj78W9vqkZImoNkbdCSIFFft0,25668
 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=uW_qDGQ6UzLPRbB20HTLrCmhMlWVXSfgyQMr4MyGErU,5734
 auto_editor/utils/container.py,sha256=RnpoMmMYmn7o69LmMbBFHW4TsP3K52jYDhG9qzWXmAs,2720
 auto_editor/utils/encoder.py,sha256=auNYo7HXbcU4iTUCc0LE5lpwFmSvdWvBm6-5KIaRK8w,2983
-auto_editor/utils/func.py,sha256=kcxCOqe-tg6k-kxutIran8LpffRiHDjKB6rm-ngFiSU,4460
+auto_editor/utils/func.py,sha256=3p5f6BxC6wMjsolLSfrcx7OwVQnMRAprwBI7MQ8TjB0,3725
 auto_editor/utils/log.py,sha256=M2QKeQHMRNLm3HMVUKedZPRprT2u5dipOStiO4miPBk,3613
-auto_editor/utils/subtitle_tools.py,sha256=TjjVPiT8bWzZJcrZjF7ddpgfIsVkLE4LyxXzBswHAGU,693
 auto_editor/utils/types.py,sha256=BWj0YalUpWwXfEN7AEL5s_j22lscZOH-eb7x_dYuXfY,11471
-docs/build.py,sha256=8nJM_CgkSL5ilvzcJDGNjzoWpCphPJKZKguHazG6YK8,1641
-auto_editor-25.3.0.dist-info/LICENSE,sha256=yiq99pWITHfqS0pbZMp7cy2dnbreTuvBwudsU-njvIM,1210
-auto_editor-25.3.0.dist-info/METADATA,sha256=2X6Gs23pxl1aDj5NT5yVlFHoluhP0z838ADlO3v2oQw,6148
-auto_editor-25.3.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-auto_editor-25.3.0.dist-info/entry_points.txt,sha256=-H7zdTw4MqnAcwrN5xTNkGIhzZtJMxS9r6lTMeR9-aA,240
-auto_editor-25.3.0.dist-info/top_level.txt,sha256=jBV5zlbWRbKOa-xaWPvTD45QL7lGExx2BDzv-Ji4dTw,17
-auto_editor-25.3.0.dist-info/RECORD,,
+docs/build.py,sha256=CM-ZWgQk8wSNjivx_-6wGIaG7cstrNKsX2d4TzFVivE,1642
+auto_editor-25.3.1.dist-info/LICENSE,sha256=yiq99pWITHfqS0pbZMp7cy2dnbreTuvBwudsU-njvIM,1210
+auto_editor-25.3.1.dist-info/METADATA,sha256=0GOm0ktkMSsxqnTtALdMBcxK_IrYPMgFuSjUN-Xs9F0,6148
+auto_editor-25.3.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+auto_editor-25.3.1.dist-info/entry_points.txt,sha256=-H7zdTw4MqnAcwrN5xTNkGIhzZtJMxS9r6lTMeR9-aA,240
+auto_editor-25.3.1.dist-info/top_level.txt,sha256=jBV5zlbWRbKOa-xaWPvTD45QL7lGExx2BDzv-Ji4dTw,17
+auto_editor-25.3.1.dist-info/RECORD,,

docs/build.py

@@ -49,5 +49,6 @@ def main():
             print(e)
             quit(1)
 
+
 if __name__ == "__main__":
     main()

auto_editor/utils/subtitle_tools.py

@@ -1,29 +0,0 @@
-def convert_ass_to_text(ass_text: str) -> str:
-    result = ""
-    comma_count = i = 0
-
-    while comma_count < 8 and i < len(ass_text):
-        if ass_text[i] == ",":
-            comma_count += 1
-        i += 1
-
-    state = False
-    while i < len(ass_text):
-        char = ass_text[i]
-        next_char = "" if i + 1 >= len(ass_text) else ass_text[i + 1]
-
-        if char == "\\" and next_char == "N":
-            result += "\n"
-            i += 2
-            continue
-
-        if not state:
-            if char == "{":
-                state = True
-            else:
-                result += ass_text[i]
-        elif char == "}":
-            state = False
-        i += 1
-
-    return result

auto_editor/validate_input.py

@@ -1,88 +0,0 @@
-from __future__ import annotations
-
-import re
-import subprocess
-import sys
-from os.path import exists, isdir, isfile, lexists, splitext
-
-from auto_editor.ffwrapper import FFmpeg
-from auto_editor.utils.func import get_stdout
-from auto_editor.utils.log import Log
-from auto_editor.utils.types import Args
-
-
-def get_domain(url: str) -> str:
-    from urllib.parse import urlparse
-
-    t = urlparse(url).netloc
-    return ".".join(t.split(".")[-2:])
-
-
-def download_video(my_input: str, args: Args, ffmpeg: FFmpeg, log: Log) -> str:
-    log.conwrite("Downloading video...")
-
-    download_format = args.download_format
-
-    if download_format is None and get_domain(my_input) == "youtube.com":
-        download_format = "bestvideo[ext=mp4]+bestaudio[ext=m4a]"
-
-    if args.output_format is None:
-        output_format = re.sub(r"\W+", "-", splitext(my_input)[0]) + ".%(ext)s"
-    else:
-        output_format = args.output_format
-
-    yt_dlp_path = args.yt_dlp_location
-
-    cmd = ["--ffmpeg-location", ffmpeg.path]
-
-    if download_format is not None:
-        cmd.extend(["-f", download_format])
-
-    cmd.extend(["-o", output_format, my_input])
-
-    if args.yt_dlp_extras is not None:
-        cmd.extend(args.yt_dlp_extras.split(" "))
-
-    try:
-        location = get_stdout(
-            [yt_dlp_path, "--get-filename", "--no-warnings"] + cmd
-        ).strip()
-    except FileNotFoundError:
-        msg = "Could not find program 'yt-dlp' when attempting to download a URL. Install yt-dlp with "
-        if sys.platform == "win32":
-            msg += "your favorite package manager (pip, choco, winget)."
-        elif sys.platform == "darwin":
-            msg += "brew or pip and make sure it's in PATH."
-        else:
-            msg += "pip or your favorite package manager and make sure it's in PATH."
-        log.error(msg)
-
-    if not isfile(location):
-        subprocess.run([yt_dlp_path] + cmd)
-
-    if not isfile(location):
-        log.error(f"Download file wasn't created: {location}")
-
-    return location
-
-
-def valid_input(inputs: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> list[str]:
-    result = []
-
-    for my_input in inputs:
-        if my_input.startswith("http://") or my_input.startswith("https://"):
-            result.append(download_video(my_input, args, ffmpeg, log))
-        else:
-            _, ext = splitext(my_input)
-            if ext == "":
-                if isdir(my_input):
-                    log.error("Input must be a file or a URL, not a directory.")
-                if exists(my_input):
-                    log.error(f"Input file must have an extension: {my_input}")
-                if lexists(my_input):
-                    log.error(f"Input file is a broken symbolic link: {my_input}")
-                if my_input.startswith("-"):
-                    log.error(f"Option/Input file doesn't exist: {my_input}")
-            result.append(my_input)
-
-    return result