auto-editor 28.0.2__py3-none-any.whl → 29.0.0__py3-none-any.whl

auto_editor/cmds/levels.py

@@ -1,199 +0,0 @@
-from __future__ import annotations
-
-import sys
-from dataclasses import dataclass, field
-from fractions import Fraction
-from typing import TYPE_CHECKING
-
-import bv
-import numpy as np
-
-from auto_editor.analyze import *
-from auto_editor.ffwrapper import FileInfo
-from auto_editor.lang.palet import env
-from auto_editor.lib.contracts import is_bool, is_nat, is_nat1, is_str, is_void, orc
-from auto_editor.utils.bar import initBar
-from auto_editor.utils.cmdkw import (
-    ParserError,
-    Required,
-    parse_with_palet,
-    pAttr,
-    pAttrs,
-)
-from auto_editor.utils.log import Log
-from auto_editor.utils.types import frame_rate
-from auto_editor.vanparse import ArgumentParser
-
-if TYPE_CHECKING:
-    from collections.abc import Iterator
-    from fractions import Fraction
-
-    from numpy.typing import NDArray
-
-
-@dataclass(slots=True)
-class LevelArgs:
-    input: list[str] = field(default_factory=list)
-    edit: str = "audio"
-    timebase: Fraction | None = None
-    no_cache: bool = False
-    help: bool = False
-
-
-def levels_options(parser: ArgumentParser) -> ArgumentParser:
-    parser.add_required("input", nargs="*")
-    parser.add_argument(
-        "--edit",
-        metavar="METHOD:[ATTRS?]",
-        help="Select the kind of detection to analyze with attributes",
-    )
-    parser.add_argument(
-        "--timebase",
-        "-tb",
-        metavar="NUM",
-        type=frame_rate,
-        help="Set custom timebase",
-    )
-    parser.add_argument("--no-cache", flag=True)
-    return parser
-
-
-def print_arr(arr: NDArray) -> None:
-    print("")
-    print("@start")
-    if arr.dtype == np.bool_:
-        for a in arr:
-            sys.stdout.write(f"{1 if a else 0}\n")
-    else:
-        for a in arr:
-            sys.stdout.write(f"{a}\n")
-    sys.stdout.flush()
-    print("")
-
-
-def print_arr_gen(arr: Iterator[float | np.float32]) -> None:
-    print("")
-    print("@start")
-    for a in arr:
-        print(f"{a}")
-    print("")
-
-
-def main(sys_args: list[str] = sys.argv[1:]) -> None:
-    parser = levels_options(ArgumentParser("levels"))
-    args = parser.parse_args(LevelArgs, sys_args)
-
-    bar = initBar("none")
-    log = Log(quiet=True)
-
-    sources = [FileInfo.init(path, log) for path in args.input]
-    if len(sources) < 1:
-        log.error("levels needs at least one input file")
-
-    src = sources[0]
-
-    tb = src.get_fps() if args.timebase is None else args.timebase
-
-    if ":" in args.edit:
-        method, attrs = args.edit.split(":", 1)
-    else:
-        method, attrs = args.edit, ""
-
-    audio_builder = pAttrs("audio", pAttr("stream", 0, is_nat))
-    motion_builder = pAttrs(
-        "motion",
-        pAttr("stream", 0, is_nat),
-        pAttr("blur", 9, is_nat),
-        pAttr("width", 400, is_nat1),
-    )
-    subtitle_builder = pAttrs(
-        "subtitle",
-        pAttr("pattern", Required, is_str),
-        pAttr("stream", 0, is_nat),
-        pAttr("ignore-case", False, is_bool),
-        pAttr("max-count", None, orc(is_nat, is_void)),
-    )
-
-    builder_map = {
-        "audio": audio_builder,
-        "motion": motion_builder,
-        "subtitle": subtitle_builder,
-    }
-
-    for src in sources:
-        if method in builder_map:
-            try:
-                obj = parse_with_palet(attrs, builder_map[method], env)
-            except ParserError as e:
-                log.error(e)
-
-        levels = initLevels(src, tb, bar, False, log)
-        try:
-            if method == "audio":
-                if (
-                    not args.no_cache
-                    and (arr := levels.read_cache("audio", (obj["stream"],)))
-                    is not None
-                ):
-                    print_arr(arr)
-                else:
-                    container = bv.open(src.path, "r")
-                    audio_stream = container.streams.audio[obj["stream"]]
-
-                    values = []
-
-                    def value_storing_generator() -> Iterator[np.float32]:
-                        for value in iter_audio(audio_stream, tb):
-                            values.append(value)
-                            yield value
-
-                    print_arr_gen(value_storing_generator())
-                    container.close()
-
-                    cache_array = np.array(values, dtype=np.float32)
-                    if not args.no_cache:
-                        levels.cache(cache_array, "audio", (obj["stream"],))
-
-            elif method == "motion":
-                mobj = (obj["stream"], obj["width"], obj["blur"])
-                if (
-                    not args.no_cache
-                    and (arr := levels.read_cache("motion", mobj)) is not None
-                ):
-                    print_arr(arr)
-                else:
-                    container = bv.open(src.path, "r")
-                    video_stream = container.streams.video[obj["stream"]]
-
-                    values = []
-
-                    def value_storing_generator() -> Iterator[np.float32]:
-                        for value in iter_motion(
-                            video_stream, tb, obj["blur"], obj["width"]
-                        ):
-                            values.append(value)
-                            yield value
-
-                    print_arr_gen(value_storing_generator())
-                    container.close()
-
-                    cache_array = np.array(values, dtype=np.float32)
-                    if not args.no_cache:
-                        levels.cache(cache_array, "motion", mobj)
-
-            elif method == "subtitle":
-                print_arr(levels.subtitle(**obj))
-            elif method == "none":
-                print_arr(levels.none())
-            elif method == "all/e":
-                print_arr(levels.all())
-            else:
-                log.error(f"Method: {method} not supported")
-        except LevelError as e:
-            log.error(e)
-
-    log.cleanup()
-
-
-if __name__ == "__main__":
-    main()

auto_editor/cmds/palet.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-import sys
-
-from auto_editor.lang.palet import Lexer, Parser, env, interpret
-from auto_editor.lang.stdenv import make_standard_env
-from auto_editor.lib.err import MyError
-
-
-def main(sys_args: list[str] = sys.argv[1:]) -> None:
-    if sys_args:
-        with open(sys_args[0], encoding="utf-8", errors="ignore") as file:
-            program_text = file.read()
-
-        env.update(make_standard_env())
-        try:
-            interpret(env, Parser(Lexer(sys_args[0], program_text)))
-        except (MyError, ZeroDivisionError) as e:
-            sys.stderr.write(f"error: {e}\n")
-            sys.exit(1)
-
-    else:
-        from .repl import main
-
-        main(sys_args)
-
-
-if __name__ == "__main__":
-    main()

auto_editor/cmds/repl.py

@@ -1,113 +0,0 @@
-from __future__ import annotations
-
-import sys
-from dataclasses import dataclass, field
-from fractions import Fraction
-from os import environ
-
-import auto_editor
-from auto_editor.analyze import initLevels
-from auto_editor.ffwrapper import FileInfo
-from auto_editor.lang.palet import ClosingError, Lexer, Parser, env, interpret
-from auto_editor.lang.stdenv import make_standard_env
-from auto_editor.lib.data_structs import print_str
-from auto_editor.lib.err import MyError
-from auto_editor.utils.bar import initBar
-from auto_editor.utils.log import Log
-from auto_editor.utils.types import frame_rate
-from auto_editor.vanparse import ArgumentParser
-
-try:
-    import readline  # noqa
-except ImportError:
-    pass
-
-
-@dataclass(slots=True)
-class REPL_Args:
-    input: list[str] = field(default_factory=list)
-    debug_parser: bool = False
-    timebase: Fraction | None = None
-    ffmpeg_location: str | None = None
-    my_ffmpeg: bool = False
-    temp_dir: str | None = None
-    help: bool = False
-
-
-def repl_options(parser: ArgumentParser) -> ArgumentParser:
-    parser.add_required("input", nargs="*")
-    parser.add_argument(
-        "--debug-parser",
-        flag=True,
-        help="Print parser value",
-    )
-    parser.add_argument(
-        "--timebase",
-        "-tb",
-        metavar="NUM",
-        type=frame_rate,
-        help="Set custom timebase",
-    )
-    return parser
-
-
-def main(sys_args: list[str] = sys.argv[1:]) -> None:
-    args = repl_options(ArgumentParser(None)).parse_args(REPL_Args, sys_args)
-
-    if args.input:
-        log = Log(quiet=True)
-        sources = [FileInfo.init(path, log) for path in args.input]
-        src = sources[0]
-        tb = src.get_fps() if args.timebase is None else args.timebase
-        env["timebase"] = tb
-        env["@levels"] = initLevels(src, tb, initBar("modern"), False, log)
-
-    env.update(make_standard_env())
-    print(f"Auto-Editor {auto_editor.__version__}")
-    text = None
-
-    no_color = bool(environ.get("NO_COLOR") or environ.get("AV_LOG_FORCE_NOCOLOR"))
-    if no_color:
-        bold_pink = bold_red = reset = ""
-    else:
-        bold_pink = "\033[1;95m"
-        bold_red = "\033[1;31m"
-        reset = "\033[0m"
-
-    try:
-        while True:
-            try:
-                if text is None:
-                    text = input(f"{bold_pink}>{reset} ")
-                else:
-                    text += "\n" + input("   ")
-            except KeyboardInterrupt as e:
-                if text is None:
-                    raise e
-                text = None
-                print("")
-                continue
-
-            try:
-                parser = Parser(Lexer("repl", text))
-                if args.debug_parser:
-                    print(f"parser: {parser}")
-
-                for result in interpret(env, parser):
-                    if result is not None:
-                        sys.stdout.write(f"{print_str(result)}\n")
-                        env["_"] = result
-
-            except ClosingError:
-                continue  # Allow user to continue adding text
-            except MyError as e:
-                print(f"{bold_red}error{reset}: {e}")
-
-            text = None
-
-    except (KeyboardInterrupt, EOFError):
-        print("")
-
-
-if __name__ == "__main__":
-    main()

auto_editor/cmds/subdump.py

@@ -1,72 +0,0 @@
-import sys
-from dataclasses import dataclass, field
-
-import bv
-from bv.subtitles.subtitle import AssSubtitle
-
-from auto_editor.json import dump
-from auto_editor.vanparse import ArgumentParser
-
-
-@dataclass(slots=True)
-class SubdumpArgs:
-    help: bool = False
-    input: list[str] = field(default_factory=list)
-    json: bool = False
-
-
-def main(sys_args: list[str] = sys.argv[1:]) -> None:
-    parser = ArgumentParser("subdump")
-    parser.add_required("input", nargs="*")
-    parser.add_argument("--json", flag=True)
-    args = parser.parse_args(SubdumpArgs, sys_args)
-
-    if args.json:
-        data = {}
-        for input_file in args.input:
-            container = bv.open(input_file)
-            for s in range(len(container.streams.subtitles)):
-                entry_data = []
-
-                input_stream = container.streams.subtitles[s]
-                assert input_stream.time_base is not None
-                for packet in container.demux(input_stream):
-                    if (
-                        packet.dts is None
-                        or packet.pts is None
-                        or packet.duration is None
-                    ):
-                        continue
-
-                    start = packet.pts * input_stream.time_base
-                    end = start + packet.duration * input_stream.time_base
-
-                    startf = round(float(start), 3)
-                    endf = round(float(end), 3)
-
-                    if endf - startf <= 0.02:
-                        continue
-
-                    for sub in packet.decode():
-                        if isinstance(sub, AssSubtitle):
-                            content = sub.dialogue.decode("utf-8", errors="ignore")
-                            entry_data.append([startf, endf, content])
-
-                data[f"{input_file}:{s}"] = entry_data
-            container.close()
-
-        dump(data, sys.stdout, indent=4)
-        return
-
-    for input_file in args.input:
-        with bv.open(input_file) as container:
-            for s in range(len(container.streams.subtitles)):
-                print(f"file: {input_file} ({s}:{container.streams.subtitles[s].name})")
-                for sub2 in container.decode(subtitles=s):
-                    if isinstance(sub2, AssSubtitle):
-                        print(sub2.ass.decode("utf-8", errors="ignore"))
-        print("------")
-
-
-if __name__ == "__main__":
-    main()