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

auto_editor/utils/container.py

@@ -1,102 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TypedDict
-
-import bv
-from bv.codec import Codec
-
-from auto_editor.utils.log import Log
-
-
-class DictContainer(TypedDict, total=False):
-    max_videos: int | None
-    max_audios: int | None
-    max_subtitles: int | None
-    samplerate: list[int] | None
-
-
-@dataclass(slots=True)
-class Container:
-    allow_image: bool
-    vcodecs: set[str]
-    acodecs: set[str]
-    scodecs: set[str]
-    default_vid: str
-    default_aud: str
-    default_sub: str
-    max_videos: int | None = None
-    max_audios: int | None = None
-    max_subtitles: int | None = None
-    samplerate: list[int] | None = None  # Any samplerate is allowed
-
-
-containers: dict[str, DictContainer] = {
-    "aac": {"max_audios": 1},
-    "adts": {"max_audios": 1},
-    "ass": {"max_subtitles": 1},
-    "ssa": {"max_subtitles": 1},
-    "apng": {"max_videos": 1},
-    "gif": {"max_videos": 1},
-    "wav": {"max_audios": 1},
-    "ast": {"max_audios": 1},
-    "mp3": {"max_audios": 1},
-    "flac": {"max_audios": 1},
-    "srt": {"max_subtitles": 1},
-    "vtt": {"max_subtitles": 1},
-    "swf": {"samplerate": [44100, 22050, 11025]},
-}
-
-
-def codec_type(x: str) -> str:
-    if x in {"vp9", "vp8", "h264", "hevc", "av1", "gif", "apng"}:
-        return "video"
-    if x in {"aac", "flac", "mp3"}:
-        return "audio"
-    if x in {"ass", "ssa", "srt"}:
-        return "subtitle"
-
-    try:
-        return Codec(x, "w").type
-    except Exception:
-        return ""
-
-
-def container_constructor(ext: str, log: Log) -> Container:
-    try:
-        container = bv.open(f".{ext}", "w")
-    except ValueError:
-        log.error(f"Could not find a suitable format for extension: {ext}")
-
-    codecs = container.supported_codecs
-    if ext == "webm":
-        vdefault = "vp9"
-    else:
-        vdefault = container.default_video_codec
-    adefault = container.default_audio_codec
-    sdefault = container.default_subtitle_codec
-    if sdefault == "none" and ext == "mp4":
-        sdefault = "srt"
-
-    container.close()
-    vcodecs = set()
-    acodecs = set()
-    scodecs = set()
-
-    for codec in codecs:
-        if ext == "wav" and codec == "aac":
-            continue
-        kind = codec_type(codec)
-        if kind == "video":
-            vcodecs.add(codec)
-        if kind == "audio":
-            acodecs.add(codec)
-        if kind == "subtitle":
-            scodecs.add(codec)
-
-    allow_image = ext in {"mp4", "mkv"}
-    kwargs = containers[ext] if ext in containers else {}
-
-    return Container(
-        allow_image, vcodecs, acodecs, scodecs, vdefault, adefault, sdefault, **kwargs
-    )

auto_editor/utils/func.py

@@ -1,128 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import numpy as np
-
-from auto_editor.utils.log import Log
-from auto_editor.utils.types import split_num_str
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-    from fractions import Fraction
-
-    from numpy.typing import NDArray
-
-    BoolList = NDArray[np.bool_]
-    BoolOperand = Callable[[BoolList, BoolList], BoolList]
-
-
-def boolop(a: BoolList, b: BoolList, call: BoolOperand) -> BoolList:
-    if len(a) > len(b):
-        k = np.copy(b)
-        k.resize(len(a))
-        b = k
-    if len(b) > len(a):
-        k = np.copy(a)
-        k.resize(len(b))
-        a = k
-
-    return call(a, b)
-
-
-def to_timecode(secs: float | Fraction, fmt: str) -> str:
-    sign = ""
-    if secs < 0:
-        sign = "-"
-        secs = -secs
-
-    _m, _s = divmod(secs, 60)
-    _h, _m = divmod(_m, 60)
-    s, m, h = float(_s), int(_m), int(_h)
-
-    if fmt == "webvtt":
-        if h == 0:
-            return f"{sign}{m:02d}:{s:06.3f}"
-        return f"{sign}{h:02d}:{m:02d}:{s:06.3f}"
-    if fmt in {"srt", "mov_text"}:
-        return f"{sign}{h:02d}:{m:02d}:" + f"{s:06.3f}".replace(".", ",", 1)
-    if fmt == "standard":
-        return f"{sign}{h:02d}:{m:02d}:{s:06.3f}"
-    if fmt == "ass":
-        return f"{sign}{h:d}:{m:02d}:{s:05.2f}"
-    if fmt == "rass":
-        return f"{sign}{h:d}:{m:02d}:{s:02.0f}"
-
-    raise ValueError("to_timecode: Unreachable")
-
-
-def mut_margin(arr: BoolList, start_m: int, end_m: int) -> None:
-    # Find start and end indexes
-    start_index = []
-    end_index = []
-    arrlen = len(arr)
-    for j in range(1, arrlen):
-        if arr[j] != arr[j - 1]:
-            if arr[j]:
-                start_index.append(j)
-            else:
-                end_index.append(j)
-
-    # Apply margin
-    if start_m > 0:
-        for i in start_index:
-            arr[max(i - start_m, 0) : i] = True
-    if start_m < 0:
-        for i in start_index:
-            arr[i : min(i - start_m, arrlen)] = False
-
-    if end_m > 0:
-        for i in end_index:
-            arr[i : min(i + end_m, arrlen)] = True
-    if end_m < 0:
-        for i in end_index:
-            arr[max(i + end_m, 0) : i] = False
-
-
-def get_stdout(cmd: list[str]) -> str:
-    from subprocess import DEVNULL, PIPE, Popen
-
-    stdout = Popen(cmd, stdin=DEVNULL, stdout=PIPE, stderr=PIPE).communicate()[0]
-    return stdout.decode("utf-8", "replace")
-
-
-def get_stdout_bytes(cmd: list[str]) -> bytes:
-    from subprocess import DEVNULL, PIPE, Popen
-
-    return Popen(cmd, stdin=DEVNULL, stdout=PIPE, stderr=PIPE).communicate()[0]
-
-
-def aspect_ratio(width: int, height: int) -> tuple[int, int]:
-    if height == 0:
-        return (0, 0)
-
-    def gcd(a: int, b: int) -> int:
-        while b:
-            a, b = b, a % b
-        return a
-
-    c = gcd(width, height)
-    return width // c, height // c
-
-
-def parse_bitrate(input_: str, log: Log) -> int:
-    try:
-        val, unit = split_num_str(input_)
-    except Exception as e:
-        log.error(e)
-
-    if unit.lower() == "k":
-        return int(val * 1000)
-    if unit == "M":
-        return int(val * 1_000_000)
-    if unit == "G":
-        return int(val * 1_000_000_000)
-    if unit == "":
-        return int(val)
-
-    log.error(f"Unknown bitrate: {input_}")

auto_editor/utils/log.py

@@ -1,124 +0,0 @@
-import sys
-from datetime import timedelta
-from shutil import get_terminal_size, rmtree
-from tempfile import mkdtemp
-from time import perf_counter, sleep
-from typing import NoReturn
-
-
-class Log:
-    __slots__ = ("is_debug", "quiet", "machine", "no_color", "_temp", "_ut", "_s")
-
-    def __init__(
-        self,
-        is_debug: bool = False,
-        quiet: bool = False,
-        temp_dir: str | None = None,
-        machine: bool = False,
-        no_color: bool = True,
-    ):
-        self.is_debug = is_debug
-        self.quiet = quiet
-        self.machine = machine
-        self.no_color = no_color
-        self._temp: str | None = None
-        self._ut = temp_dir
-        self._s = 0 if self.quiet or self.machine else perf_counter()
-
-    def debug(self, message: object) -> None:
-        if self.is_debug:
-            self.conwrite("")
-            sys.stderr.write(f"Debug: {message}\n")
-
-    @property
-    def temp(self) -> str:
-        if self._temp is not None:
-            return self._temp
-
-        if self._ut is None:
-            result = mkdtemp()
-        else:
-            import os.path
-            from os import listdir, mkdir
-
-            if os.path.isfile(self._ut):
-                self.error("Temp directory cannot be an already existing file.")
-
-            if os.path.isdir(self._ut):
-                if len(listdir(self._ut)) != 0:
-                    self.error("Temp directory should be empty!")
-            else:
-                mkdir(self._ut)
-            result = self._ut
-
-        self.debug(f"Temp Directory: {result}")
-        self._temp = result
-        return result
-
-    def cleanup(self) -> None:
-        if self._temp is None:
-            return
-        try:
-            rmtree(self._temp)
-            self.debug("Removed Temp Directory.")
-        except FileNotFoundError:
-            pass
-        except PermissionError:
-            sleep(0.1)
-            try:
-                rmtree(self._temp)
-                self.debug("Removed Temp Directory.")
-            except Exception as e:
-                self.debug(f"Failed to delete temp dir:\n{e}")
-
-    def conwrite(self, message: str) -> None:
-        if self.machine:
-            print(message, flush=True)
-        elif not self.quiet:
-            buffer = " " * (get_terminal_size().columns - len(message) - 3)
-            sys.stdout.write(f"  {message}{buffer}\r")
-
-    def print(self, message: str) -> None:
-        if not self.quiet:
-            self.conwrite("")
-            sys.stdout.write(f"{message}\n")
-
-    def warning(self, message: str) -> None:
-        if not self.quiet:
-            self.conwrite("")
-            sys.stderr.write(f"Warning! {message}\n")
-
-    def stop_timer(self) -> None:
-        if not self.quiet and not self.machine:
-            second_len = round(perf_counter() - self._s, 2)
-            minute_len = timedelta(seconds=round(second_len))
-
-            sys.stdout.write(f"Finished. took {second_len} seconds ({minute_len})\n")
-
-    @staticmethod
-    def deprecated(message: str) -> None:
-        sys.stderr.write(f"\033[1m\033[33m{message}\033[0m\n")
-
-    def error(self, message: str | Exception) -> NoReturn:
-        if self.is_debug and isinstance(message, Exception):
-            self.cleanup()
-            raise message
-
-        self.conwrite("")
-        if self.no_color:
-            sys.stderr.write(f"Error! {message}\n")
-        else:
-            sys.stderr.write(f"\033[31;40mError! {message}\033[0m\n")
-
-        self.cleanup()
-        from platform import system
-
-        if system() == "Linux":
-            sys.exit(1)
-        else:
-            try:
-                sys.exit(1)
-            except SystemExit:
-                import os
-
-                os._exit(1)

auto_editor/utils/types.py

@@ -1,277 +0,0 @@
-from __future__ import annotations
-
-import re
-from fractions import Fraction
-
-
-class CoerceError(Exception):
-    pass
-
-
-def split_num_str(val: str | float) -> tuple[float, str]:
-    if isinstance(val, float | int):
-        return val, ""
-
-    index = 0
-    for char in val:
-        if char not in "0123456789_ .-":
-            break
-        index += 1
-    num, unit = val[:index], val[index:]
-    try:
-        float(num)
-    except ValueError:
-        raise CoerceError(f"Invalid number: '{val}'")
-    return float(num), unit
-
-
-# Numbers: 0, 1, 2, 3, ...
-def natural(val: str | float) -> int:
-    num, unit = split_num_str(val)
-    if unit != "":
-        raise CoerceError(f"'{val}': Natural does not allow units.")
-    if not isinstance(num, int) and not num.is_integer():
-        raise CoerceError(f"'{val}': Natural must be a valid integer.")
-    if num < 0:
-        raise CoerceError(f"'{val}': Natural cannot be negative.")
-    return int(num)
-
-
-def number(val: str | float) -> float:
-    if isinstance(val, str) and "/" in val:
-        nd = val.split("/")
-        if len(nd) != 2:
-            raise CoerceError(f"'{val}': One divisor allowed.")
-        vs = []
-        for v in nd:
-            try:
-                vs.append(int(v))
-            except ValueError:
-                raise CoerceError(
-                    f"'{val}': Numerator and Denominator must be integers."
-                )
-        if vs[1] == 0:
-            raise CoerceError(f"'{val}': Denominator must not be zero.")
-        return vs[0] / vs[1]
-
-    num, unit = split_num_str(val)
-    if unit == "%":
-        return num / 100
-    if unit == "":
-        return num
-    raise CoerceError(f"Unknown unit: '{unit}'")
-
-
-def frame_rate(val: str) -> Fraction:
-    if val == "ntsc":
-        return Fraction(30000, 1001)
-    if val == "ntsc_film":
-        return Fraction(24000, 1001)
-    if val == "pal":
-        return Fraction(25)
-    if val == "film":
-        return Fraction(24)
-    return Fraction(val)
-
-
-def time(val: str, tb: Fraction) -> int:
-    if ":" in val:
-        boxes = val.split(":")
-        if len(boxes) == 2:
-            return round((int(boxes[0]) * 60 + float(boxes[1])) * tb)
-        if len(boxes) == 3:
-            return round(
-                (int(boxes[0]) * 3600 + int(boxes[1]) * 60 + float(boxes[2])) * tb
-            )
-        raise CoerceError(f"'{val}': Invalid time format")
-
-    num, unit = split_num_str(val)
-    if unit in {"s", "sec", "secs", "second", "seconds"}:
-        return round(num * tb)
-    if unit in {"min", "mins", "minute", "minutes"}:
-        return round(num * tb * 60)
-    if unit == "hour":
-        return round(num * tb * 3600)
-
-    if unit != "":
-        raise CoerceError(f"'{val}': Time format got unknown unit: `{unit}`")
-    if not num.is_integer():
-        raise CoerceError(f"'{val}': Time format expects: int?")
-    return int(num)
-
-
-def parse_color(val: str) -> str:
-    """
-    Convert a color str into an RGB tuple
-
-    Accepts:
-        - color names (black, red, blue)
-        - 3 digit hex codes (#FFF, #3AE)
-        - 6 digit hex codes (#3F0401, #005601)
-    """
-
-    color = val.lower()
-
-    if color in colormap:
-        color = colormap[color]
-
-    if re.match("#[a-f0-9]{3}$", color):
-        return "#" + "".join([x * 2 for x in color[1:]])
-
-    if re.match("#[a-f0-9]{6}$", color):
-        return color
-
-    raise ValueError(f"Invalid Color: '{color}'")
-
-
-colormap = {
-    # Taken from https://www.w3.org/TR/css-color-4/#named-color
-    "aliceblue": "#f0f8ff",
-    "antiquewhite": "#faebd7",
-    "aqua": "#00ffff",
-    "aquamarine": "#7fffd4",
-    "azure": "#f0ffff",
-    "beige": "#f5f5dc",
-    "bisque": "#ffe4c4",
-    "black": "#000000",
-    "blanchedalmond": "#ffebcd",
-    "blue": "#0000ff",
-    "blueviolet": "#8a2be2",
-    "brown": "#a52a2a",
-    "burlywood": "#deb887",
-    "cadetblue": "#5f9ea0",
-    "chartreuse": "#7fff00",
-    "chocolate": "#d2691e",
-    "coral": "#ff7f50",
-    "cornflowerblue": "#6495ed",
-    "cornsilk": "#fff8dc",
-    "crimson": "#dc143c",
-    "cyan": "#00ffff",
-    "darkblue": "#00008b",
-    "darkcyan": "#008b8b",
-    "darkgoldenrod": "#b8860b",
-    "darkgray": "#a9a9a9",
-    "darkgrey": "#a9a9a9",
-    "darkgreen": "#006400",
-    "darkkhaki": "#bdb76b",
-    "darkmagenta": "#8b008b",
-    "darkolivegreen": "#556b2f",
-    "darkorange": "#ff8c00",
-    "darkorchid": "#9932cc",
-    "darkred": "#8b0000",
-    "darksalmon": "#e9967a",
-    "darkseagreen": "#8fbc8f",
-    "darkslateblue": "#483d8b",
-    "darkslategray": "#2f4f4f",
-    "darkslategrey": "#2f4f4f",
-    "darkturquoise": "#00ced1",
-    "darkviolet": "#9400d3",
-    "deeppink": "#ff1493",
-    "deepskyblue": "#00bfff",
-    "dimgray": "#696969",
-    "dimgrey": "#696969",
-    "dodgerblue": "#1e90ff",
-    "firebrick": "#b22222",
-    "floralwhite": "#fffaf0",
-    "forestgreen": "#228b22",
-    "fuchsia": "#ff00ff",
-    "gainsboro": "#dcdcdc",
-    "ghostwhite": "#f8f8ff",
-    "gold": "#ffd700",
-    "goldenrod": "#daa520",
-    "gray": "#808080",
-    "grey": "#808080",
-    "green": "#008000",
-    "greenyellow": "#adff2f",
-    "honeydew": "#f0fff0",
-    "hotpink": "#ff69b4",
-    "indianred": "#cd5c5c",
-    "indigo": "#4b0082",
-    "ivory": "#fffff0",
-    "khaki": "#f0e68c",
-    "lavender": "#e6e6fa",
-    "lavenderblush": "#fff0f5",
-    "lawngreen": "#7cfc00",
-    "lemonchiffon": "#fffacd",
-    "lightblue": "#add8e6",
-    "lightcoral": "#f08080",
-    "lightcyan": "#e0ffff",
-    "lightgoldenrodyellow": "#fafad2",
-    "lightgreen": "#90ee90",
-    "lightgray": "#d3d3d3",
-    "lightgrey": "#d3d3d3",
-    "lightpink": "#ffb6c1",
-    "lightsalmon": "#ffa07a",
-    "lightseagreen": "#20b2aa",
-    "lightskyblue": "#87cefa",
-    "lightslategray": "#778899",
-    "lightslategrey": "#778899",
-    "lightsteelblue": "#b0c4de",
-    "lightyellow": "#ffffe0",
-    "lime": "#00ff00",
-    "limegreen": "#32cd32",
-    "linen": "#faf0e6",
-    "magenta": "#ff00ff",
-    "maroon": "#800000",
-    "mediumaquamarine": "#66cdaa",
-    "mediumblue": "#0000cd",
-    "mediumorchid": "#ba55d3",
-    "mediumpurple": "#9370db",
-    "mediumseagreen": "#3cb371",
-    "mediumslateblue": "#7b68ee",
-    "mediumspringgreen": "#00fa9a",
-    "mediumturquoise": "#48d1cc",
-    "mediumvioletred": "#c71585",
-    "midnightblue": "#191970",
-    "mintcream": "#f5fffa",
-    "mistyrose": "#ffe4e1",
-    "moccasin": "#ffe4b5",
-    "navajowhite": "#ffdead",
-    "navy": "#000080",
-    "oldlace": "#fdf5e6",
-    "olive": "#808000",
-    "olivedrab": "#6b8e23",
-    "orange": "#ffa500",
-    "orangered": "#ff4500",
-    "orchid": "#da70d6",
-    "palegoldenrod": "#eee8aa",
-    "palegreen": "#98fb98",
-    "paleturquoise": "#afeeee",
-    "palevioletred": "#db7093",
-    "papayawhip": "#ffefd5",
-    "peachpuff": "#ffdab9",
-    "peru": "#cd853f",
-    "pink": "#ffc0cb",
-    "plum": "#dda0dd",
-    "powderblue": "#b0e0e6",
-    "purple": "#800080",
-    "rebeccapurple": "#663399",
-    "red": "#ff0000",
-    "rosybrown": "#bc8f8f",
-    "royalblue": "#4169e1",
-    "saddlebrown": "#8b4513",
-    "salmon": "#fa8072",
-    "sandybrown": "#f4a460",
-    "seagreen": "#2e8b57",
-    "seashell": "#fff5ee",
-    "sienna": "#a0522d",
-    "silver": "#c0c0c0",
-    "skyblue": "#87ceeb",
-    "slateblue": "#6a5acd",
-    "slategray": "#708090",
-    "slategrey": "#708090",
-    "snow": "#fffafa",
-    "springgreen": "#00ff7f",
-    "steelblue": "#4682b4",
-    "tan": "#d2b48c",
-    "teal": "#008080",
-    "thistle": "#d8bfd8",
-    "tomato": "#ff6347",
-    "turquoise": "#40e0d0",
-    "violet": "#ee82ee",
-    "wheat": "#f5deb3",
-    "white": "#ffffff",
-    "whitesmoke": "#f5f5f5",
-    "yellow": "#ffff00",
-    "yellowgreen": "#9acd32",
-}