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

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

@@ -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.1/auto_editor/__init__.py

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

{auto_editor-25.3.0 → auto_editor-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-25.3.0 → auto_editor-25.3.1}/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-25.3.0 → auto_editor-25.3.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-25.3.0 → auto_editor-25.3.1}/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-25.3.0 → auto_editor-25.3.1}/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-25.3.0 → auto_editor-25.3.1}/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-25.3.0 → auto_editor-25.3.1}/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-25.3.0 → auto_editor-25.3.1}/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-25.3.0 → auto_editor-25.3.1}/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-25.3.0 → auto_editor-25.3.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 → auto_editor-25.3.1}/auto_editor.egg-info/PKG-INFO

@@ -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 → auto_editor-25.3.1}/auto_editor.egg-info/SOURCES.txt

@@ -11,7 +11,6 @@ auto_editor/make_layers.py
 auto_editor/output.py
 auto_editor/preview.py
 auto_editor/timeline.py
-auto_editor/validate_input.py
 auto_editor/vanparse.py
 auto_editor/wavfile.py
 auto_editor.egg-info/PKG-INFO
@@ -56,6 +55,5 @@ auto_editor/utils/container.py
 auto_editor/utils/encoder.py
 auto_editor/utils/func.py
 auto_editor/utils/log.py
-auto_editor/utils/subtitle_tools.py
 auto_editor/utils/types.py
 docs/build.py

{auto_editor-25.3.0 → auto_editor-25.3.1}/auto_editor.egg-info/requires.txt

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

{auto_editor-25.3.0 → auto_editor-25.3.1}/docs/build.py

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

{auto_editor-25.3.0 → auto_editor-25.3.1}/pyproject.toml

@@ -10,7 +10,7 @@ authors = [{ name = "WyattBlue", email = "wyattblue@auto-editor.com" }]
 requires-python = ">=3.10,<3.14"
 dependencies = [
     "numpy>=1.23.0,<3.0",
-    "pyav==13.0.*",
+    "pyav==13.1.*",
     "ae-ffmpeg==1.2.*",
 ]
 keywords = [

auto_editor-25.3.0/auto_editor/__init__.py

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

auto_editor-25.3.0/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-25.3.0/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