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

auto_editor/analyze.py

@@ -1,393 +0,0 @@
-from __future__ import annotations
-
-import os
-import re
-from dataclasses import dataclass
-from fractions import Fraction
-from hashlib import sha1
-from math import ceil
-from tempfile import gettempdir
-from typing import TYPE_CHECKING
-
-import bv
-import numpy as np
-from bv.audio.fifo import AudioFifo
-from bv.subtitles.subtitle import AssSubtitle
-
-from auto_editor import __version__
-
-if TYPE_CHECKING:
-    from collections.abc import Iterator, Sequence
-    from fractions import Fraction
-
-    from numpy.typing import NDArray
-
-    from auto_editor.ffwrapper import FileInfo
-    from auto_editor.utils.bar import Bar
-    from auto_editor.utils.log import Log
-
-
-__all__ = ("LevelError", "initLevels", "iter_audio", "iter_motion")
-
-
-class LevelError(Exception):
-    pass
-
-
-def mut_remove_small(
-    arr: NDArray[np.bool_], lim: int, replace: int, with_: int
-) -> None:
-    start_p = 0
-    active = False
-    for j, item in enumerate(arr):
-        if item == replace:
-            if not active:
-                start_p = j
-                active = True
-
-            if j == len(arr) - 1 and j - start_p < lim:
-                arr[start_p:] = with_
-        elif active:
-            if j - start_p < lim:
-                arr[start_p:j] = with_
-            active = False
-
-
-def mut_remove_large(
-    arr: NDArray[np.bool_], lim: int, replace: int, with_: int
-) -> None:
-    start_p = 0
-    active = False
-    for j, item in enumerate(arr):
-        if item == replace:
-            if not active:
-                start_p = j
-                active = True
-
-            if j == len(arr) - 1 and j - start_p >= lim:
-                arr[start_p:] = with_
-        elif active:
-            if j - start_p > lim:
-                arr[start_p:j] = with_
-            active = False
-
-
-def iter_audio(audio_stream: bv.AudioStream, tb: Fraction) -> Iterator[np.float32]:
-    fifo = AudioFifo()
-    sr = audio_stream.rate
-
-    exact_size = (1 / tb) * sr
-    accumulated_error = Fraction(0)
-
-    # Resample so that audio data is between [-1, 1]
-    resampler = bv.AudioResampler(bv.AudioFormat("flt"), audio_stream.layout, sr)
-
-    container = audio_stream.container
-    assert isinstance(container, bv.container.InputContainer)
-
-    for frame in container.decode(audio_stream):
-        frame.pts = None  # Skip time checks
-
-        for reframe in resampler.resample(frame):
-            fifo.write(reframe)
-
-        while fifo.samples >= ceil(exact_size):
-            size_with_error = exact_size + accumulated_error
-            current_size = round(size_with_error)
-            accumulated_error = size_with_error - current_size
-
-            audio_chunk = fifo.read(current_size)
-            assert audio_chunk is not None
-            arr = audio_chunk.to_ndarray().flatten()
-            yield np.max(np.abs(arr))
-
-
-def iter_motion(
-    video: bv.VideoStream, tb: Fraction, blur: int, width: int
-) -> Iterator[np.float32]:
-    video.thread_type = "AUTO"
-
-    prev_frame = None
-    current_frame = None
-    total_pixels = None
-    index = 0
-    prev_index = -1
-
-    graph = bv.filter.Graph()
-    graph.link_nodes(
-        graph.add_buffer(template=video),
-        graph.add("scale", f"{width}:-1"),
-        graph.add("format", "gray"),
-        graph.add("gblur", f"sigma={blur}"),
-        graph.add("buffersink"),
-    ).configure()
-
-    container = video.container
-    assert isinstance(container, bv.container.InputContainer)
-
-    for unframe in container.decode(video):
-        if unframe.pts is None:
-            continue
-
-        graph.push(unframe)
-        frame = graph.vpull()
-        assert frame.time is not None
-        index = round(frame.time * tb)
-
-        if total_pixels is None:
-            total_pixels = frame.width * frame.height
-
-        current_frame = frame.to_ndarray()
-        if prev_frame is None:
-            value = np.float32(0.0)
-        else:
-            # Use `int16` to avoid underflow with `uint8` datatype
-            diff = np.abs(prev_frame.astype(np.int16) - current_frame.astype(np.int16))
-            value = np.float32(np.count_nonzero(diff) / total_pixels)
-
-        for _ in range(index - prev_index):
-            yield value
-
-        prev_frame = current_frame
-        prev_index = index
-
-
-@dataclass(slots=True)
-class Levels:
-    container: bv.container.InputContainer
-    name: str
-    mod_time: int
-    tb: Fraction
-    bar: Bar
-    no_cache: bool
-    log: Log
-
-    @property
-    def media_length(self) -> int:
-        container = self.container
-        if container.streams.audio:
-            if (arr := self.read_cache("audio", (0,))) is not None:
-                return len(arr)
-
-            audio_stream = container.streams.audio[0]
-            result = sum(1 for _ in iter_audio(audio_stream, self.tb))
-            container.seek(0)
-            self.log.debug(f"Audio Length: {result}")
-            return result
-
-        # If there's no audio, get length in video metadata.
-        if not container.streams.video:
-            self.log.error("Could not get media duration")
-
-        video = container.streams.video[0]
-        if video.duration is None or video.time_base is None:
-            dur = 0
-        else:
-            dur = int(video.duration * video.time_base * self.tb)
-        self.log.debug(f"Video duration: {dur}")
-        container.seek(0)
-
-        return dur
-
-    def obj_tag(self, kind: str, obj: Sequence[object]) -> str:
-        mod_time = self.mod_time
-        key = f"{self.name}:{mod_time:x}:{self.tb}:" + ",".join(f"{v}" for v in obj)
-        return f"{sha1(key.encode()).hexdigest()[:16]}{kind}"
-
-    def none(self) -> NDArray[np.bool_]:
-        return np.ones(self.media_length, dtype=np.bool_)
-
-    def all(self) -> NDArray[np.bool_]:
-        return np.zeros(self.media_length, dtype=np.bool_)
-
-    def read_cache(self, kind: str, obj: Sequence[object]) -> None | np.ndarray:
-        if self.no_cache:
-            return None
-
-        key = self.obj_tag(kind, obj)
-        cache_file = os.path.join(gettempdir(), f"ae-{__version__}", f"{key}.npz")
-
-        try:
-            with np.load(cache_file, allow_pickle=False) as npzfile:
-                return npzfile["data"]
-        except Exception as e:
-            self.log.debug(e)
-            return None
-
-    def cache(self, arr: np.ndarray, kind: str, obj: Sequence[object]) -> np.ndarray:
-        if self.no_cache:
-            return arr
-
-        workdir = os.path.join(gettempdir(), f"ae-{__version__}")
-        os.makedirs(workdir, exist_ok=True)
-        cache_file = os.path.join(workdir, f"{self.obj_tag(kind, obj)}.npz")
-
-        try:
-            np.savez(cache_file, data=arr)
-        except Exception as e:
-            self.log.warning(f"Cache write failed: {e}")
-
-        cache_entries = []
-        with os.scandir(workdir) as entries:
-            for entry in entries:
-                if entry.name.endswith(".npz"):
-                    cache_entries.append((entry.path, entry.stat().st_mtime))
-
-        if len(cache_entries) > 10:
-            # Sort by modification time, oldest first
-            cache_entries.sort(key=lambda x: x[1])
-            # Remove oldest files until we're back to 10
-            for filepath, _ in cache_entries[:-10]:
-                try:
-                    os.remove(filepath)
-                except OSError:
-                    pass
-
-        return arr
-
-    def audio(self, stream: int) -> NDArray[np.float32]:
-        container = self.container
-        if stream >= len(container.streams.audio):
-            raise LevelError(f"audio: audio stream '{stream}' does not exist.")
-
-        if (arr := self.read_cache("audio", (stream,))) is not None:
-            return arr
-
-        audio = container.streams.audio[stream]
-
-        if audio.duration is not None and audio.time_base is not None:
-            inaccurate_dur = int(audio.duration * audio.time_base * self.tb)
-        elif container.duration is not None:
-            inaccurate_dur = int(container.duration / bv.time_base * self.tb)
-        else:
-            inaccurate_dur = 1024
-
-        bar = self.bar
-        bar.start(inaccurate_dur, "Analyzing audio volume")
-
-        result: NDArray[np.float32] = np.zeros(inaccurate_dur, dtype=np.float32)
-        index = 0
-
-        for value in iter_audio(audio, self.tb):
-            if index > len(result) - 1:
-                result = np.concatenate(
-                    (result, np.zeros(len(result), dtype=np.float32))
-                )
-
-            result[index] = value
-            bar.tick(index)
-            index += 1
-
-        bar.end()
-        container.seek(0)
-        assert len(result) > 0
-        return self.cache(result[:index], "audio", (stream,))
-
-    def motion(self, stream: int, blur: int, width: int) -> NDArray[np.float32]:
-        container = self.container
-        if stream >= len(container.streams.video):
-            raise LevelError(f"motion: video stream '{stream}' does not exist.")
-
-        mobj = (stream, width, blur)
-        if (arr := self.read_cache("motion", mobj)) is not None:
-            return arr
-
-        video = container.streams.video[stream]
-        inaccurate_dur = (
-            1024
-            if video.duration is None or video.time_base is None
-            else int(video.duration * video.time_base * self.tb)
-        )
-        bar = self.bar
-        bar.start(inaccurate_dur, "Analyzing motion")
-
-        result: NDArray[np.float32] = np.zeros(inaccurate_dur, dtype=np.float32)
-        index = 0
-        for value in iter_motion(video, self.tb, blur, width):
-            if index > len(result) - 1:
-                result = np.concatenate(
-                    (result, np.zeros(len(result), dtype=np.float32))
-                )
-            result[index] = value
-            bar.tick(index)
-            index += 1
-
-        bar.end()
-        container.seek(0)
-        return self.cache(result[:index], "motion", mobj)
-
-    def subtitle(
-        self,
-        pattern: str,
-        stream: int,
-        ignore_case: bool,
-        max_count: int | None,
-    ) -> NDArray[np.bool_]:
-        container = self.container
-        if stream >= len(container.streams.subtitles):
-            raise LevelError(f"subtitle: subtitle stream '{stream}' does not exist.")
-
-        try:
-            flags = re.IGNORECASE if ignore_case else 0
-            re_pattern = re.compile(pattern, flags)
-        except re.error as e:
-            self.log.error(e)
-        try:
-            subtitle_stream = container.streams.subtitles[stream]
-            assert isinstance(subtitle_stream.time_base, Fraction)
-        except Exception as e:
-            self.log.error(e)
-
-        # Get the length of the subtitle stream.
-        sub_length = 0
-        for packet in container.demux(subtitle_stream):
-            if packet.pts is None or packet.duration is None:
-                continue
-            sub_length = max(sub_length, packet.pts + packet.duration)
-
-        sub_length = round(sub_length * subtitle_stream.time_base * self.tb)
-        result = np.zeros((sub_length), dtype=np.bool_)
-        del sub_length
-
-        count = 0
-        early_exit = False
-        container.seek(0)
-        for packet in container.demux(subtitle_stream):
-            if packet.pts is None or packet.duration is None:
-                continue
-            if early_exit:
-                break
-
-            if max_count is not None and count >= max_count:
-                early_exit = True
-                break
-
-            start = float(packet.pts * subtitle_stream.time_base)
-            dur = float(packet.duration * subtitle_stream.time_base)
-
-            san_start = round(start * self.tb)
-            san_end = round((start + dur) * self.tb)
-
-            for sub in packet.decode():
-                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
-
-        container.seek(0)
-        return result
-
-
-def initLevels(
-    src: FileInfo, tb: Fraction, bar: Bar, no_cache: bool, log: Log
-) -> Levels:
-    try:
-        container = bv.open(src.path)
-    except bv.FFmpegError as e:
-        log.error(e)
-
-    mod_time = int(src.path.stat().st_mtime)
-    return Levels(container, src.path.name, mod_time, tb, bar, no_cache, log)

auto_editor/cmds/cache.py

@@ -1,69 +0,0 @@
-import glob
-import os
-import sys
-from shutil import rmtree
-from tempfile import gettempdir
-
-import numpy as np
-
-from auto_editor import __version__
-
-
-def main(sys_args: list[str] = sys.argv[1:]) -> None:
-    cache_dir = os.path.join(gettempdir(), f"ae-{__version__}")
-
-    if sys_args and sys_args[0] in {"clean", "clear"}:
-        rmtree(cache_dir, ignore_errors=True)
-        return
-
-    if not os.path.exists(cache_dir):
-        print("Empty cache")
-        return
-
-    cache_files = glob.glob(os.path.join(cache_dir, "*.npz"))
-    if not cache_files:
-        print("Empty cache")
-        return
-
-    def format_bytes(size: float) -> str:
-        for unit in ("B", "KiB", "MiB", "GiB", "TiB"):
-            if size < 1024:
-                return f"{size:.2f} {unit}"
-            size /= 1024
-        return f"{size:.2f} PiB"
-
-    GRAY = "\033[90m"
-    GREEN = "\033[32m"
-    BLUE = "\033[34m"
-    YELLOW = "\033[33m"
-    RESET = "\033[0m"
-
-    total_size = 0
-    for cache_file in cache_files:
-        try:
-            with np.load(cache_file, allow_pickle=False) as npzfile:
-                array = npzfile["data"]
-                key = os.path.basename(cache_file)[:-4]  # Remove .npz extension
-
-                hash_part = key[:16]
-                rest_part = key[16:]
-
-                size = array.nbytes
-                total_size += size
-                size_str = format_bytes(size)
-                size_num, size_unit = size_str.rsplit(" ", 1)
-
-                print(
-                    f"{YELLOW}entry: {GRAY}{hash_part}{RESET}{rest_part}  "
-                    f"{YELLOW}size: {GREEN}{size_num} {BLUE}{size_unit}{RESET}"
-                )
-        except Exception as e:
-            print(f"Error reading {cache_file}: {e}")
-
-    total_str = format_bytes(total_size)
-    total_num, total_unit = total_str.rsplit(" ", 1)
-    print(f"\n{YELLOW}total cache size: {GREEN}{total_num} {BLUE}{total_unit}{RESET}")
-
-
-if __name__ == "__main__":
-    main()

auto_editor/cmds/desc.py

@@ -1,32 +0,0 @@
-import sys
-from dataclasses import dataclass, field
-
-import bv
-
-from auto_editor.vanparse import ArgumentParser
-
-
-@dataclass(slots=True)
-class DescArgs:
-    help: bool = False
-    input: list[str] = field(default_factory=list)
-
-
-def desc_options(parser: ArgumentParser) -> ArgumentParser:
-    parser.add_required("input", nargs="*")
-    return parser
-
-
-def main(sys_args: list[str] = sys.argv[1:]) -> None:
-    args = desc_options(ArgumentParser("desc")).parse_args(DescArgs, sys_args)
-    for path in args.input:
-        try:
-            container = bv.open(path)
-            desc = container.metadata.get("description", None)
-        except Exception:
-            desc = None
-        sys.stdout.write("\nNo description.\n\n" if desc is None else f"\n{desc}\n\n")
-
-
-if __name__ == "__main__":
-    main()

auto_editor/cmds/info.py

@@ -1,213 +0,0 @@
-from __future__ import annotations
-
-import os.path
-import sys
-from dataclasses import dataclass, field
-from typing import Any, Literal, TypedDict
-
-from auto_editor.ffwrapper import FileInfo
-from auto_editor.json import dump
-from auto_editor.make_layers import make_sane_timebase
-from auto_editor.utils.func import aspect_ratio
-from auto_editor.utils.log import Log
-from auto_editor.vanparse import ArgumentParser
-
-
-@dataclass(slots=True)
-class InfoArgs:
-    json: bool = False
-    help: bool = False
-    input: list[str] = field(default_factory=list)
-
-
-def info_options(parser: ArgumentParser) -> ArgumentParser:
-    parser.add_required("input", nargs="*")
-    parser.add_argument("--json", flag=True, help="Export info in JSON format")
-    return parser
-
-
-class VideoJson(TypedDict):
-    codec: str
-    fps: str
-    resolution: list[int]
-    aspect_ratio: list[int]
-    pixel_aspect_ratio: str
-    duration: float
-    pix_fmt: str | None
-    color_range: int
-    color_space: int
-    color_primaries: int
-    color_transfer: int
-    timebase: str
-    bitrate: int
-    lang: str | None
-
-
-class AudioJson(TypedDict):
-    codec: str
-    samplerate: int
-    layout: str
-    duration: float
-    bitrate: int
-    lang: str | None
-
-
-class SubtitleJson(TypedDict):
-    codec: str
-    lang: str | None
-
-
-class ContainerJson(TypedDict):
-    duration: float
-    bitrate: int
-
-
-class MediaJson(TypedDict, total=False):
-    video: list[VideoJson]
-    audio: list[AudioJson]
-    subtitle: list[SubtitleJson]
-    container: ContainerJson
-    type: Literal["media", "timeline", "unknown"]
-    recommendedTimebase: str
-    version: Literal["v1", "v3"]
-    clips: int
-
-
-def main(sys_args: list[str] = sys.argv[1:]) -> None:
-    args = info_options(ArgumentParser("info")).parse_args(InfoArgs, sys_args)
-
-    log = Log(quiet=not args.json)
-
-    file_info: dict[str, MediaJson] = {}
-
-    for file in args.input:
-        if not os.path.isfile(file):
-            log.error(f"Could not find '{file}'")
-
-        ext = os.path.splitext(file)[1]
-        if ext in {".v1", ".v3", ".json", ".xml", ".fcpxml", ".mlt"}:
-            file_info[file] = {"type": "timeline"}
-            continue
-
-        src = FileInfo.init(file, log)
-
-        if len(src.videos) + len(src.audios) + len(src.subtitles) == 0:
-            file_info[file] = {"type": "unknown"}
-            continue
-
-        file_info[file] = {
-            "type": "media",
-            "recommendedTimebase": "30/1",
-            "video": [],
-            "audio": [],
-            "subtitle": [],
-            "container": {
-                "duration": src.duration,
-                "bitrate": src.bitrate,
-            },
-        }
-
-        if src.videos:
-            recTb = make_sane_timebase(src.videos[0].fps)
-            file_info[file]["recommendedTimebase"] = (
-                f"{recTb.numerator}/{recTb.denominator}"
-            )
-
-        for v in src.videos:
-            w, h = v.width, v.height
-
-            vid: VideoJson = {
-                "codec": v.codec,
-                "fps": str(v.fps),
-                "resolution": [w, h],
-                "aspect_ratio": list(aspect_ratio(w, h)),
-                "pixel_aspect_ratio": str(v.sar).replace("/", ":"),
-                "duration": v.duration,
-                "pix_fmt": v.pix_fmt,
-                "color_range": v.color_range,
-                "color_space": v.color_space,
-                "color_primaries": v.color_primaries,
-                "color_transfer": v.color_transfer,
-                "timebase": str(v.time_base),
-                "bitrate": v.bitrate,
-                "lang": v.lang,
-            }
-            file_info[file]["video"].append(vid)
-
-        for a in src.audios:
-            aud: AudioJson = {
-                "codec": a.codec,
-                "layout": a.layout,
-                "samplerate": a.samplerate,
-                "duration": a.duration,
-                "bitrate": a.bitrate,
-                "lang": a.lang,
-            }
-            file_info[file]["audio"].append(aud)
-
-        for s_stream in src.subtitles:
-            sub: SubtitleJson = {"codec": s_stream.codec, "lang": s_stream.lang}
-            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
-
-    def is_null(key: str, val: object) -> bool:
-        return val is None or (key in {"bitrate", "duration"} and val == 0.0)
-
-    def stream_to_text(text: str, label: str, streams: list[dict[str, Any]]) -> str:
-        if len(streams) > 0:
-            text += f" - {label}:\n"
-
-        for s, stream in enumerate(streams):
-            text += f"   - track {s}:\n"
-            for key, value in stream.items():
-                if not is_null(key, value):
-                    if isinstance(value, list):
-                        sep = "x" if key == "resolution" else ":"
-                        value = sep.join(f"{x}" for x in value)
-
-                    if key in {
-                        "color_range",
-                        "color_space",
-                        "color_transfer",
-                        "color_primaries",
-                    }:
-                        if key == "color_range":
-                            if value == 1:
-                                text += "     - color range: 1 (tv)\n"
-                            elif value == 2:
-                                text += "     - color range: 2 (pc)\n"
-                        elif value == 1:
-                            text += f"     - {key.replace('_', ' ')}: 1 (bt709)\n"
-                        elif value != 2:
-                            text += f"     - {key.replace('_', ' ')}: {value}\n"
-                    else:
-                        text += f"     - {key.replace('_', ' ')}: {value}\n"
-        return text
-
-    text = ""
-    for name, info in file_info.items():
-        text += f"{name}:\n"
-
-        for label, streams in info.items():
-            if isinstance(streams, list):
-                text = stream_to_text(text, label, streams)
-                continue
-            elif isinstance(streams, dict):
-                text += " - container:\n"
-                for key, value in streams.items():
-                    if value is not None:
-                        text += f"   - {key}: {value}\n"
-            elif label != "type" or streams != "media":
-                text += f" - {label}: {streams}\n"
-        text += "\n"
-
-    sys.stdout.write(text)
-
-
-if __name__ == "__main__":
-    main()