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

auto_editor/timeline.py

@@ -1,331 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-from auto_editor.ffwrapper import FileInfo, mux
-from auto_editor.lib.contracts import *
-from auto_editor.utils.cmdkw import Required, pAttr, pAttrs
-from auto_editor.utils.types import CoerceError, natural, number, parse_color
-
-if TYPE_CHECKING:
-    from collections.abc import Iterator
-    from fractions import Fraction
-    from pathlib import Path
-
-    from auto_editor.ffwrapper import FileInfo
-    from auto_editor.utils.chunks import Chunks
-    from auto_editor.utils.log import Log
-
-
-@dataclass(slots=True)
-class v1:
-    """
-    v1 timeline constructor
-    timebase is always the source's average fps
-
-    """
-
-    source: FileInfo
-    chunks: Chunks
-
-    def as_dict(self) -> dict:
-        return {
-            "version": "1",
-            "source": f"{self.source.path.resolve()}",
-            "chunks": self.chunks,
-        }
-
-
-@dataclass(slots=True)
-class Clip:
-    start: int
-    dur: int
-    src: FileInfo
-    offset: int
-    stream: int
-
-    speed: float = 1.0
-    volume: float = 1.0
-
-    def as_dict(self) -> dict:
-        return {
-            "name": "video",
-            "src": self.src,
-            "start": self.start,
-            "dur": self.dur,
-            "offset": self.offset,
-            "speed": self.speed,
-            "stream": self.stream,
-        }
-
-
-@dataclass(slots=True)
-class TlImage:
-    start: int
-    dur: int
-    src: FileInfo
-    x: int
-    y: int
-    width: int
-    opacity: float
-
-    def as_dict(self) -> dict:
-        return {
-            "name": "image",
-            "src": self.src,
-            "start": self.start,
-            "dur": self.dur,
-            "x": self.x,
-            "y": self.y,
-            "width": self.width,
-            "opacity": self.opacity,
-        }
-
-
-@dataclass(slots=True)
-class TlRect:
-    start: int
-    dur: int
-    x: int
-    y: int
-    width: int
-    height: int
-    fill: str
-
-    def as_dict(self) -> dict:
-        return {
-            "name": "rect",
-            "start": self.start,
-            "dur": self.dur,
-            "x": self.x,
-            "y": self.y,
-            "width": self.width,
-            "height": self.height,
-            "fill": self.fill,
-        }
-
-
-def threshold(val: str | float) -> float:
-    num = number(val)
-    if num > 1 or num < 0:
-        raise CoerceError(f"'{val}': Threshold must be between 0 and 1 (0%-100%)")
-    return num
-
-
-video_builder = pAttrs(
-    "video",
-    pAttr("start", Required, is_nat, natural),
-    pAttr("dur", Required, is_nat, natural),
-    pAttr("src", Required, is_str, "source"),
-    pAttr("offset", 0, is_int, natural),
-    pAttr("speed", 1, is_real, number),
-    pAttr("stream", 0, is_nat, natural),
-)
-audio_builder = pAttrs(
-    "audio",
-    pAttr("start", Required, is_nat, natural),
-    pAttr("dur", Required, is_nat, natural),
-    pAttr("src", Required, is_str, "source"),
-    pAttr("offset", 0, is_int, natural),
-    pAttr("speed", 1, is_real, number),
-    pAttr("volume", 1, is_threshold, threshold),
-    pAttr("stream", 0, is_nat, natural),
-)
-img_builder = pAttrs(
-    "image",
-    pAttr("start", Required, is_nat, natural),
-    pAttr("dur", Required, is_nat, natural),
-    pAttr("src", Required, is_str, "source"),
-    pAttr("x", Required, is_int, int),
-    pAttr("y", Required, is_int, int),
-    pAttr("width", 0, is_nat, natural),
-    pAttr("opacity", 1, is_threshold, threshold),
-)
-rect_builder = pAttrs(
-    "rect",
-    pAttr("start", Required, is_nat, natural),
-    pAttr("dur", Required, is_nat, natural),
-    pAttr("x", Required, is_int, int),
-    pAttr("y", Required, is_int, int),
-    pAttr("width", Required, is_int, int),
-    pAttr("height", Required, is_int, int),
-    pAttr("fill", "#c4c4c4", is_str, parse_color),
-)
-visual_objects = {
-    "rect": (TlRect, rect_builder),
-    "image": (TlImage, img_builder),
-    "video": (Clip, video_builder),
-}
-
-VLayer = list[Clip | TlImage | TlRect]
-VSpace = list[VLayer]
-ASpace = list[list[Clip]]
-
-
-@dataclass(slots=True)
-class AudioTemplate:
-    lang: str | None
-
-
-@dataclass(slots=True)
-class SubtitleTemplate:
-    lang: str | None
-
-
-@dataclass(slots=True)
-class Template:
-    sr: int
-    layout: str
-    res: tuple[int, int]
-    audios: list[AudioTemplate]
-    subtitles: list[SubtitleTemplate]
-
-    @classmethod
-    def init(
-        self,
-        src: FileInfo,
-        sr: int | None = None,
-        layout: str | None = None,
-        res: tuple[int, int] | None = None,
-    ) -> Template:
-        alist = [AudioTemplate(x.lang) for x in src.audios]
-        slist = [SubtitleTemplate(x.lang) for x in src.subtitles]
-
-        if sr is None:
-            sr = src.get_sr()
-
-        if layout is None:
-            layout = "stereo" if not src.audios else src.audios[0].layout
-
-        if res is None:
-            res = src.get_res()
-
-        return Template(sr, layout, res, alist, slist)
-
-
-@dataclass
-class v3:
-    tb: Fraction
-    background: str
-    template: Template
-    v: VSpace
-    a: ASpace
-    v1: v1 | None  # Is it v1 compatible (linear and only one source)?
-
-    def __str__(self) -> str:
-        result = f"""
-global
- timebase {self.tb}
- samplerate {self.sr}
- res {self.res[0]}x{self.res[1]}
-
-video\n"""
-
-        for i, layer in enumerate(self.v):
-            result += f" v{i} "
-            for obj in layer:
-                if isinstance(obj, Clip):
-                    result += (
-                        f"[#:start {obj.start} #:dur {obj.dur} #:off {obj.offset}] "
-                    )
-                else:
-                    result += f"[#:start {obj.start} #:dur {obj.dur}] "
-            result += "\n"
-
-        result += "\naudio\n"
-        for i, alayer in enumerate(self.a):
-            result += f" a{i} "
-            for abj in alayer:
-                result += f"[#:start {abj.start} #:dur {abj.dur} #:off {abj.offset}] "
-            result += "\n"
-        return result
-
-    @property
-    def end(self) -> int:
-        end = 0
-        for vclips in self.v:
-            if vclips:
-                v = vclips[-1]
-                end = max(end, v.start + v.dur)
-
-        for aclips in self.a:
-            if aclips:
-                a = aclips[-1]
-                end = max(end, a.start + a.dur)
-
-        return end
-
-    @property
-    def sources(self) -> Iterator[FileInfo]:
-        for vclips in self.v:
-            for v in vclips:
-                if isinstance(v, Clip):
-                    yield v.src
-        for aclips in self.a:
-            for a in aclips:
-                yield a.src
-
-    def unique_sources(self) -> Iterator[FileInfo]:
-        seen = set()
-        for source in self.sources:
-            if source.path not in seen:
-                seen.add(source.path)
-                yield source
-
-    def __len__(self) -> int:
-        result = 0
-        for clips in self.v + self.a:
-            if len(clips) > 0:
-                lastClip = clips[-1]
-                result = max(result, lastClip.start + lastClip.dur)
-
-        return result
-
-    @property
-    def T(self) -> Template:
-        return self.template
-
-    @property
-    def res(self) -> tuple[int, int]:
-        return self.T.res
-
-    @property
-    def sr(self) -> int:
-        return self.T.sr
-
-
-def make_tracks_dir(tracks_dir: Path) -> None:
-    from os import mkdir
-    from shutil import rmtree
-
-    try:
-        mkdir(tracks_dir)
-    except OSError:
-        rmtree(tracks_dir)
-        mkdir(tracks_dir)
-
-
-def set_stream_to_0(tl: v3, log: Log) -> None:
-    dir_exists = False
-    cache: dict[Path, FileInfo] = {}
-
-    def make_track(i: int, path: Path) -> FileInfo:
-        nonlocal dir_exists
-
-        fold = path.parent / f"{path.stem}_tracks"
-        if not dir_exists:
-            make_tracks_dir(fold)
-            dir_exists = True
-
-        newtrack = fold / f"{path.stem}_{i}.wav"
-        if newtrack not in cache:
-            mux(path, output=newtrack, stream=i)
-            cache[newtrack] = FileInfo.init(f"{newtrack}", log)
-        return cache[newtrack]
-
-    for alayer in tl.a:
-        for aobj in alayer:
-            if aobj.stream > 0:
-                aobj.src = make_track(aobj.stream, aobj.src.path)
-                aobj.stream = 0

auto_editor/utils/bar.py

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-import sys
-from dataclasses import dataclass
-from math import floor
-from shutil import get_terminal_size
-from time import localtime, time
-
-from .func import get_stdout_bytes
-
-
-def initBar(bar_type: str) -> Bar:
-    icon = "⏳"
-    chars: tuple[str, ...] = (" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█")
-    brackets = ("|", "|")
-    machine = hide = False
-
-    if bar_type == "classic":
-        icon = "⏳"
-        chars = ("░", "█")
-        brackets = ("[", "]")
-    if bar_type == "ascii":
-        icon = "& "
-        chars = ("-", "#")
-        brackets = ("[", "]")
-    if bar_type == "machine":
-        machine = True
-    if bar_type == "none":
-        hide = True
-
-    part_width = len(chars) - 1
-
-    ampm = True
-    if sys.platform == "darwin" and bar_type in {"modern", "classic", "ascii"}:
-        try:
-            date_format = get_stdout_bytes(
-                ["defaults", "read", "com.apple.menuextra.clock", "Show24Hour"]
-            )
-            ampm = date_format == b"0\n"
-        except FileNotFoundError:
-            pass
-
-    return Bar(icon, chars, brackets, machine, hide, part_width, ampm, [])
-
-
-@dataclass(slots=True)
-class Bar:
-    icon: str
-    chars: tuple[str, ...]
-    brackets: tuple[str, str]
-    machine: bool
-    hide: bool
-    part_width: int
-    ampm: bool
-    stack: list[tuple[str, int, float, float]]
-
-    @staticmethod
-    def pretty_time(my_time: float, ampm: bool) -> str:
-        new_time = localtime(my_time)
-
-        hours = new_time.tm_hour
-        minutes = new_time.tm_min
-
-        if ampm:
-            if hours == 0:
-                hours = 12
-            if hours > 12:
-                hours -= 12
-            ampm_marker = "PM" if new_time.tm_hour >= 12 else "AM"
-            return f"{hours:02}:{minutes:02} {ampm_marker}"
-        return f"{hours:02}:{minutes:02}"
-
-    def tick(self, index: float) -> None:
-        if self.hide:
-            return
-
-        title, len_title, total, begin = self.stack[-1]
-        progress = 0.0 if total == 0 else min(1, max(0, index / total))
-        rate = 0.0 if progress == 0 else (time() - begin) / progress
-
-        if self.machine:
-            index = min(index, total)
-            secs_til_eta = round(begin + rate - time(), 2)
-            print(f"{title}~{index}~{total}~{secs_til_eta}", end="\r", flush=True)
-            return
-
-        new_time = self.pretty_time(begin + rate, self.ampm)
-
-        percent = round(progress * 100, 1)
-        p_pad = " " * (4 - len(str(percent)))
-        columns = get_terminal_size().columns
-        bar_len = max(1, columns - len_title - 35)
-        bar_str = self._bar_str(progress, bar_len)
-
-        bar = f"  {self.icon}{title} {bar_str} {p_pad}{percent}%  ETA {new_time}    \r"
-        sys.stdout.write(bar)
-
-    def start(self, total: float, title: str = "Please wait") -> None:
-        len_title = 0
-        in_escape = False
-
-        for char in title:
-            if not in_escape:
-                if char == "\033":
-                    in_escape = True
-                else:
-                    len_title += 1
-            elif char == "m":
-                in_escape = False
-
-        self.stack.append((title, len_title, total, time()))
-
-        try:
-            self.tick(0)
-        except UnicodeEncodeError:
-            self.icon = "& "
-            self.chars = ("-", "#")
-            self.brackets = ("[", "]")
-            self.part_width = 1
-
-    def _bar_str(self, progress: float, width: int) -> str:
-        whole_width = floor(progress * width)
-        remainder_width = (progress * width) % 1
-        part_width = floor(remainder_width * self.part_width)
-        part_char = self.chars[part_width]
-
-        if width - whole_width - 1 < 0:
-            part_char = ""
-
-        line = (
-            self.brackets[0]
-            + self.chars[-1] * whole_width
-            + part_char
-            + self.chars[0] * (width - whole_width - 1)
-            + self.brackets[1]
-        )
-        return line
-
-    def end(self) -> None:
-        sys.stdout.write(" " * (get_terminal_size().columns - 2) + "\r")
-        if self.stack:
-            self.stack.pop()

auto_editor/utils/chunks.py

@@ -1,2 +0,0 @@
-Chunk = tuple[int, int, float]
-Chunks = list[Chunk]

auto_editor/utils/cmdkw.py

@@ -1,206 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from difflib import get_close_matches
-from typing import TYPE_CHECKING
-
-from auto_editor.lib.data_structs import Env
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-    from typing import Any, Literal
-
-
-class ParserError(Exception):
-    pass
-
-
-class Required:
-    pass
-
-
-@dataclass(slots=True)
-class pAttr:
-    n: str
-    default: Any
-    contract: Any
-    coerce: Callable[[Any], Any] | Literal["source"] | None = None
-
-
-class pAttrs:
-    __slots__ = ("name", "attrs")
-
-    def __init__(self, name: str, *attrs: pAttr):
-        self.name = name
-        self.attrs = attrs
-
-
-class PLexer:
-    __slots__ = ("text", "pos", "char")
-
-    def __init__(self, text: str):
-        self.text = text
-        self.pos: int = 0
-        self.char: str | None = self.text[self.pos] if text else None
-
-    def advance(self) -> None:
-        self.pos += 1
-        self.char = None if self.pos > len(self.text) - 1 else self.text[self.pos]
-
-    def string(self) -> str:
-        result = ""
-        while self.char is not None and self.char != '"':
-            if self.char == "\\":
-                self.advance()
-                if self.char is None:
-                    raise ParserError(
-                        "Expected character for escape sequence, got end of file."
-                    )
-                result += f"\\{self.char}"
-                self.advance()
-            else:
-                result += self.char
-            self.advance()
-
-        self.advance()
-        return f'"{result}"'
-
-    def get_next_token(self) -> str | None:
-        while self.char is not None:
-            if self.char == '"':
-                self.advance()
-                return self.string()
-
-            result = ""
-            while self.char is not None and self.char not in ",":
-                result += self.char
-                self.advance()
-
-            self.advance()
-            return result
-        return None
-
-
-def parse_with_palet(
-    text: str, build: pAttrs, _env: Env | dict[str, Any]
-) -> dict[str, Any]:
-    from auto_editor.lang.palet import Lexer, Parser, interpret
-    from auto_editor.lib.data_structs import print_str
-    from auto_editor.lib.err import MyError
-
-    # Positional Arguments
-    #    --option 0,end,10,20,20,30,#000, ...
-    # Keyword Arguments
-    #    --option start=0,dur=end,x1=10, ...
-
-    KEYWORD_SEP = "="
-    kwargs: dict[str, Any] = {}
-
-    def _norm_name(s: str) -> str:
-        # Python does not allow - in variable names
-        return s.replace("-", "_")
-
-    def go(text: str, c: Any) -> Any:
-        try:
-            env = _env if isinstance(_env, Env) else Env(_env)
-            results = interpret(env, Parser(Lexer(build.name, text)))
-        except MyError as e:
-            raise ParserError(e)
-
-        if not results:
-            raise ParserError("Results must be of length > 0")
-
-        if c(results[-1]) is not True:
-            raise ParserError(
-                f"{build.name}: Expected {c.name}, got {print_str(results[-1])}"
-            )
-
-        return results[-1]
-
-    for attr in build.attrs:
-        kwargs[_norm_name(attr.n)] = attr.default
-
-    allow_positional_args = True
-
-    lexer = PLexer(text)
-    i = 0
-    while (arg := lexer.get_next_token()) is not None:
-        if not arg:
-            continue
-
-        if i + 1 > len(build.attrs):
-            raise ParserError(
-                f"{build.name} has too many arguments, starting with '{arg}'."
-            )
-
-        if KEYWORD_SEP in arg:
-            key, val = arg.split(KEYWORD_SEP, 1)
-
-            allow_positional_args = False
-            found = False
-
-            for attr in build.attrs:
-                if key == attr.n:
-                    kwargs[_norm_name(attr.n)] = go(val, attr.contract)
-                    found = True
-                    break
-
-            if not found:
-                all_names = {attr.n for attr in build.attrs}
-                if matches := get_close_matches(key, all_names):
-                    more = f"\n    Did you mean:\n        {', '.join(matches)}"
-                else:
-                    more = (
-                        f"\n    attributes available:\n        {', '.join(all_names)}"
-                    )
-
-                raise ParserError(
-                    f"{build.name} got an unexpected attribute '{key}'\n{more}"
-                )
-
-        elif allow_positional_args:
-            kwargs[_norm_name(build.attrs[i].n)] = go(arg, build.attrs[i].contract)
-        else:
-            raise ParserError(
-                f"{build.name} positional argument follows keyword argument."
-            )
-        i += 1
-
-    for k, v in kwargs.items():
-        if v is Required:
-            raise ParserError(f"'{k}' must be specified.")
-
-    return kwargs
-
-
-def parse_method(name: str, text: str) -> tuple[str, list[Any], dict[str, Any]]:
-    from auto_editor.lang.palet import Lexer, Parser
-
-    # Positional Arguments
-    #    audio:0.04,0,6,3
-    # Keyword Arguments
-    #    audio:threshold=0.04,stream=0,mincut=6,minclip=3
-
-    args: list[Any] = []
-    kwargs: dict[str, Any] = {}
-
-    allow_positional_args = True
-    lexer = PLexer(text)
-    while (arg := lexer.get_next_token()) is not None:
-        if not arg:
-            continue
-
-        if "=" in arg:
-            key, val = arg.split("=", 1)
-
-            result = Parser(Lexer(name, val)).expr()
-            kwargs[key] = result
-            allow_positional_args = False
-
-        elif allow_positional_args:
-            result = Parser(Lexer(name, arg)).expr()
-            args.append(result)
-        else:
-            raise ParserError(f"{name} positional argument follows keyword argument.")
-
-    return name, args, kwargs