raricode 0.0.1__py3-none-any.whl

raricode/__init__.py

@@ -0,0 +1,36 @@
+import logging
+
+import click
+from shelltastic import shell
+
+from raricode.commands.cropdetect import cropdetect
+from raricode.commands.ffmpeg_info import ffmpeginfo
+from raricode.commands.transcode import transcode
+from raricode.exception import RaricodeException
+from raricode.utils.logging import setup_logging
+
+LOGGER = logging.getLogger(__name__)
+
+
+@click.group()
+@click.version_option()
+@click.option("--verbose", "-v", count=True, help="Turn on verbose logging")
+def main_command(verbose: int):
+    # Setup logging
+    setup_logging(verbose)
+
+    # Ensure ffmpeg is available on the path
+    ffmpeg_bin = shell.which("ffmpeg")
+    if ffmpeg_bin:
+        LOGGER.debug("ffmpeg bin: %s", ffmpeg_bin)
+    else:
+        raise RaricodeException("ffmpeg is not on the path")
+
+
+main_command.command(transcode)
+main_command.command(cropdetect)
+main_command.command(ffmpeginfo)
+
+
+def main() -> None:
+    main_command()

raricode/__main__.py

@@ -0,0 +1,4 @@
+from raricode import main
+
+if __name__ == "__main__":
+    main()

raricode/click_custom/mutually_exclusive.py

@@ -0,0 +1,25 @@
+from click import Option, UsageError
+
+
+class MutuallyExclusiveOption(Option):
+    def __init__(self, *args, **kwargs):
+        self.mutually_exclusive = set(kwargs.pop("mutually_exclusive", []))
+        help = kwargs.get("help", "")
+        if self.mutually_exclusive:
+            ex_str = ", ".join(self.mutually_exclusive)
+            kwargs["help"] = help + (
+                " NOTE: This argument is mutually exclusive with "
+                " arguments: [" + ex_str + "]."
+            )
+        super().__init__(*args, **kwargs)
+
+    def handle_parse_result(self, ctx, opts, args):
+        print(opts)
+        if self.mutually_exclusive.intersection(opts) and self.name in opts:
+            raise UsageError(
+                "Illegal usage: `{}` is mutually exclusive with arguments `{}`.".format(
+                    self.name, ", ".join(self.mutually_exclusive)
+                )
+            )
+
+        return super().handle_parse_result(ctx, opts, args)

raricode/commands/cropdetect.py

@@ -0,0 +1,188 @@
+import functools
+import logging
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+import click
+from shelltastic import CaptureMode, shell
+
+from raricode.utils.block_printer import BlockPrinter
+from raricode.utils.rate import RateRingBuffer
+
+LOGGER = logging.getLogger(__name__)
+
+
+class CropDetectDetails:
+    def __init__(self, crop_detect_line: str) -> None:
+        if not crop_detect_line.startswith("[Parsed_cropdetect"):
+            self.is_valid = False
+            split_line = None
+        else:
+            self.is_valid = True
+            split_line = crop_detect_line.split()
+
+        self.x1: int = int(split_line[3].split(":")[1]) if split_line else 0
+        self.x2: int = int(split_line[4].split(":")[1]) if split_line else 0
+        self.y1: int = int(split_line[5].split(":")[1]) if split_line else 0
+        self.y2: int = int(split_line[6].split(":")[1]) if split_line else 0
+        self.w: int = int(split_line[7].split(":")[1]) if split_line else 0
+        self.h: int = int(split_line[8].split(":")[1]) if split_line else 0
+        self.x: int = int(split_line[9].split(":")[1]) if split_line else 0
+        self.y: int = int(split_line[10].split(":")[1]) if split_line else 0
+        self.pts: int = int(split_line[11].split(":")[1]) if split_line else 0
+        self.t: float = float(split_line[12].split(":")[1]) if split_line else 0
+        self.limit: float = float(split_line[13].split(":")[1]) if split_line else 0
+        self.crop: str = split_line[14].split("=")[1] if split_line else ""
+
+    def __str__(self) -> str:
+        return str(self.__dict__)
+
+
+@functools.total_ordering
+@dataclass(slots=True, kw_only=True)
+class CropStat:
+    crop: str
+    count: int
+    percentage: float
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CropStat):
+            return NotImplemented
+        return self.count == other.count
+
+    def __lt__(self, other):
+        if not isinstance(other, CropStat):
+            return NotImplemented
+        return self.count < other.count
+
+    def __str__(self) -> str:
+        return f"crop={self.crop} ({(self.percentage * 100):.1f}%): {self.count}"
+
+
+class CropStats:
+    def __init__(self) -> None:
+        self.__stats: dict[str, int] = {}
+        self.total = 0
+        self._rate = RateRingBuffer(rate_period=10, bucket_window=1)
+
+    def add(self, crop: CropDetectDetails):
+        if crop.is_valid:
+            self.__stats[crop.crop] = (
+                self.__stats[crop.crop] + 1 if self.__stats.get(crop.crop) else 1
+            )
+            self.total += 1
+            self._rate.accumulate(1)
+
+    def stats(self, threshold_percentage: float | None = None):
+        if threshold_percentage is None:
+            threshold_percentage = 0
+        return [
+            CropStat(crop=k, count=v, percentage=v / self.total)
+            for k, v in self.__stats.items()
+            if v / self.total >= threshold_percentage
+        ]
+
+    def rate(self) -> float:
+        return self._rate.rate()
+
+
+@click.argument("video_file")
+@click.option(
+    "--display-threshold",
+    default=10,
+    type=float,
+    help="Percentage threshold in order to display crop in printout.",
+)
+@click.option(
+    "--minframes",
+    default=2000,
+    type=int,
+    help="Minimum number of frames to check before accepting a crop setting",
+)
+@click.option(
+    "--threshold",
+    default=80,
+    type=float,
+    help="Percentage of frames that must match before accepting a crop setting",
+)
+def cropdetect(
+    video_file: str, threshold: float, minframes: int, display_threshold: float
+):
+    """
+    Detect the crop settings for a video.
+
+    By default, a crop setting is accepted as the correct setting if its
+    at least 80% of the frames checked after checking 2000 frames.
+
+    --threshold and --minframes can be used to configure this acceptance critera.
+    """
+    video_file_path = Path(video_file)
+    display_threshold = (
+        display_threshold / 100
+    )  # Convert from percentage to float percentage
+    threshold = threshold / 100  # Convert from percentage to float percentage
+    if video_file_path.exists():
+        print(f"{video_file_path}")
+    else:
+        LOGGER.error(f"{video_file_path} does not exists")
+        sys.exit(1)
+
+    with shell.run_async(
+        [
+            "ffmpeg",
+            "-i",
+            str(video_file_path),
+            "-vf",
+            "cropdetect=round=2",
+            "-an",
+            "-f",
+            "null",
+            "-",
+        ],
+        stderr=CaptureMode.PIPE,
+    ) as async_result:
+        assert async_result.stderr is not None
+
+        stats = CropStats()
+        last_print = time.perf_counter()
+        block_printer = BlockPrinter()
+        next_check_frames = minframes
+
+        print("----------------------------------------")
+
+        for line in async_result.stderr:
+            # Decode line
+            line_decoded = line.decode()
+            LOGGER.debug("%s", line_decoded)
+            crop_details = CropDetectDetails(line_decoded)
+            LOGGER.debug("%s", crop_details)
+            stats.add(crop_details)
+
+            if stats.total >= next_check_frames:
+                if stats.stats(threshold):
+                    async_result.terminate()
+                    break
+                next_check_frames += 50
+
+            if time.perf_counter() - last_print >= 0.1:
+                with block_printer.replace_block() as p:
+                    p.print(f"Frames Checked: {stats.total} ({stats.rate():.1f}f/s)")
+                    p.print("----------------------------------------")
+                    for stat in sorted(stats.stats(display_threshold), reverse=True):
+                        p.print(stat)
+                    p.print("----------------------------------------")
+                last_print = time.perf_counter()
+
+        # Final Print
+        with block_printer.replace_block() as p:
+            p.print(f"Frames Checked: {stats.total} ({stats.rate():.1f}f/s)")
+            p.print("----------------------------------------")
+            for stat in sorted(stats.stats(display_threshold), reverse=True):
+                p.print(stat)
+            p.print("----------------------------------------")
+
+        # Print Result
+        detected_crop = max(stats.stats())
+        print(f"Detected Crop: {detected_crop.crop}")

raricode/commands/ffmpeg_info.py

@@ -0,0 +1,10 @@
+import logging
+
+from shelltastic import shell
+
+LOGGER = logging.getLogger(__name__)
+
+
+def ffmpeginfo():
+    print(f"ffmpeg bin: {shell.which('ffmpeg')}")
+    shell.run("ffmpeg -version")

raricode/commands/transcode.py

@@ -0,0 +1,134 @@
+import logging
+
+import click
+
+from raricode.click_custom.mutually_exclusive import MutuallyExclusiveOption
+from raricode.ffmpeg.codec.audio import AudioCodec
+from raricode.ffmpeg.codec.video import VideoCodec
+from raricode.ffmpeg.rate.audio import AudioBitrate
+from raricode.ffmpeg.rate.video import VideoBitrate, VideoCrf
+from raricode.ffmpeg.runner import FfmpegRunner
+
+LOGGER = logging.getLogger(__name__)
+
+
+@click.argument("output")
+@click.option(
+    "-i",
+    "--input",
+    type=str,
+    required=True,
+    help="Input video file",
+)
+@click.option(
+    "--video-codec",
+    "-c:v",
+    type=str,
+    required=True,
+    help="Video codec",
+)
+@click.option(
+    "--video-flag",
+    "-f:v",
+    type=(str, str),
+    multiple=True,
+    help="Video codec flag",
+)
+@click.option(
+    "--audio-codec",
+    "-c:a",
+    type=str,
+    required=True,
+    help="Audio codec",
+)
+@click.option(
+    "--audio-flag",
+    "-f:a",
+    type=(str, str),
+    multiple=True,
+    help="Audio codec flag",
+)
+@click.option(
+    "--crf",
+    "video_crf",
+    cls=MutuallyExclusiveOption,
+    mutually_exclusive=["video_bitrate"],
+    type=int,
+)
+@click.option(
+    "-b:v",
+    "video_bitrate",
+    cls=MutuallyExclusiveOption,
+    mutually_exclusive=["video_crf"],
+    type=str,
+)
+@click.option(
+    "-b:a",
+    "audio_bitrate",
+    type=str,
+)
+@click.option("--dryrun", is_flag=True)
+def transcode(
+    input: str,
+    output: str,
+    video_codec: str,
+    video_flag: tuple[tuple[str, str], ...],
+    video_crf: int | None,
+    video_bitrate: str | None,
+    audio_codec: str,
+    audio_flag: tuple[tuple[str, str], ...],
+    audio_bitrate: str | None,
+    dryrun: bool,
+):
+    """
+    Transcode a video using ffmpeg
+
+    Not meant to be a complete replacement for ffmpeg.
+    """
+    print(f"input: {input}")
+    print(f"output: {output}")
+    print(f"video_codec: {video_codec}")
+    print(f"video_flag: {video_flag}")
+    print(f"video_crf: {video_crf}")
+    print(f"video_bitrate: {video_bitrate}")
+    print(f"audio_codec: {audio_codec}")
+    print(f"audio_flag: {audio_flag}")
+    print(f"audio_bitrate: {audio_bitrate}")
+
+    # Video configs
+    vcodec = VideoCodec(video_codec)
+
+    for flag, param in video_flag:
+        vcodec.set_flag(flag, param)
+
+    video_rate = None
+
+    if video_crf:
+        video_rate = VideoCrf(video_crf)
+
+    if video_bitrate:
+        video_rate = VideoBitrate(video_bitrate)
+
+    # Audio Configs
+    acodec = AudioCodec(audio_codec)
+
+    for flag, param in audio_flag:
+        acodec.set_flag(flag, param)
+
+    audio_rate = None
+
+    if audio_bitrate:
+        audio_rate = AudioBitrate(audio_bitrate)
+
+    # Run ffmpeg
+    runner = FfmpegRunner(
+        video_codec=vcodec,
+        audio_codec=acodec,
+        video_rate=video_rate,
+        audio_rate=audio_rate,
+    )
+
+    if dryrun:
+        runner.dry_run(input, output)
+    else:
+        runner.run(input, output)

raricode/exception.py

@@ -0,0 +1,2 @@
+class RaricodeException(Exception):
+    """Top level exception for all raricode exceptions"""

raricode/ffmpeg/codec/audio.py

@@ -0,0 +1,26 @@
+class AudioCodec:
+    def __init__(self, codec: str) -> None:
+        self.codec = codec
+        self.flags: dict[str, str | None] = {}
+
+    def set_flag(self, flag: str, setting: str | None = None):
+        self.flags[flag] = setting
+
+    def remove_flag(self, flag: str):
+        del self.flags[flag]
+
+    def ffmpeg_codec_settings(self) -> list[str]:
+        settings = ["-c:a", self.codec]
+
+        for flag, setting in self.flags.items():
+            settings.append(flag)
+            if setting:
+                settings.append(setting)
+
+        return settings
+
+    def __str__(self) -> str:
+        return " ".join(self.ffmpeg_codec_settings())
+
+    def __repr__(self) -> str:
+        return f"VideoCodec({self.codec}, {self.flags})"

raricode/ffmpeg/codec/video.py

@@ -0,0 +1,26 @@
+class VideoCodec:
+    def __init__(self, codec: str) -> None:
+        self.codec = codec
+        self.flags: dict[str, str | None] = {}
+
+    def set_flag(self, flag: str, setting: str | None = None):
+        self.flags[flag] = setting
+
+    def remove_flag(self, flag: str):
+        del self.flags[flag]
+
+    def ffmpeg_codec_settings(self) -> list[str]:
+        settings = ["-c:v", self.codec]
+
+        for flag, setting in self.flags.items():
+            settings.append(flag)
+            if setting:
+                settings.append(setting)
+
+        return settings
+
+    def __str__(self) -> str:
+        return " ".join(self.ffmpeg_codec_settings())
+
+    def __repr__(self) -> str:
+        return f"VideoCodec({self.codec}, {self.flags})"

raricode/ffmpeg/cropdetect.py

@@ -0,0 +1,3 @@
+class CropDetect:
+    def __init__(self) -> None:
+        pass

raricode/ffmpeg/rate/audio.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+
+
+class AudioRate(ABC):
+    @abstractmethod
+    def rate_config(self) -> list[str]:
+        raise NotImplementedError
+
+
+class AudioBitrate(AudioRate):
+    def __init__(self, bitrate: str) -> None:
+        super().__init__()
+        self.bitrate = bitrate
+
+    def rate_config(self) -> list[str]:
+        return ["-b:a", self.bitrate]

raricode/ffmpeg/rate/video.py

@@ -0,0 +1,56 @@
+from abc import ABC, abstractmethod
+
+
+class VideoRate(ABC):
+    @abstractmethod
+    def rate_config(self) -> list[str]:
+        raise NotImplementedError
+
+
+class VideoCrf(VideoRate):
+    def __init__(
+        self,
+        crf: int,
+        min_bitrate: str | None = None,
+        max_bitrate: str | None = None,
+    ) -> None:
+        super().__init__()
+        self.crf = crf
+        self.min_bitrate = min_bitrate
+        self.max_bitrate = max_bitrate
+
+    def rate_config(self) -> list[str]:
+        rate_conf = ["-crf", str(self.crf)]
+
+        if self.min_bitrate:
+            rate_conf.extend(["-minrate", self.min_bitrate])
+
+        if self.max_bitrate:
+            rate_conf.extend(["-maxrate", self.max_bitrate])
+
+        return rate_conf
+
+
+class VideoBitrate(VideoRate):
+    def __init__(
+        self,
+        bitrate: str,
+        *,
+        min_bitrate: str | None = None,
+        max_bitrate: str | None = None,
+    ) -> None:
+        super().__init__()
+        self.bitrate = bitrate
+        self.min_bitrate = min_bitrate
+        self.max_bitrate = max_bitrate
+
+    def rate_config(self) -> list[str]:
+        rate_conf = ["-b:v", self.bitrate]
+
+        if self.min_bitrate:
+            rate_conf.extend(["-minrate", self.min_bitrate])
+
+        if self.max_bitrate:
+            rate_conf.extend(["-maxrate", self.max_bitrate])
+
+        return rate_conf

raricode/ffmpeg/runner.py

@@ -0,0 +1,50 @@
+import shlex
+
+from shelltastic import shell
+
+from raricode.ffmpeg.codec.audio import AudioCodec
+from raricode.ffmpeg.codec.video import VideoCodec
+from raricode.ffmpeg.rate.audio import AudioRate
+from raricode.ffmpeg.rate.video import VideoRate
+
+
+class FfmpegRunner:
+    def __init__(
+        self,
+        *,
+        video_codec: VideoCodec | None = None,
+        audio_codec: AudioCodec | None = None,
+        subtitle_codec=None,
+        video_rate: VideoRate | None = None,
+        audio_rate: AudioRate | None = None,
+    ) -> None:
+        self.video_codec = video_codec
+        self.audio_codec = audio_codec
+        self.subtitle_codec = subtitle_codec
+        self.video_rate = video_rate
+        self.audio_rate = audio_rate
+
+    def ffmpeg_command(self, input_file: str, output_file: str) -> list[str]:
+        ffmpeg_cmd = ["ffmpeg", "-i", input_file]
+
+        if self.video_codec:
+            ffmpeg_cmd.extend(self.video_codec.ffmpeg_codec_settings())
+
+        if self.video_rate:
+            ffmpeg_cmd.extend(self.video_rate.rate_config())
+
+        if self.audio_codec:
+            ffmpeg_cmd.extend(self.audio_codec.ffmpeg_codec_settings())
+
+        if self.audio_rate:
+            ffmpeg_cmd.extend(self.audio_rate.rate_config())
+
+        ffmpeg_cmd.append(output_file)
+
+        return ffmpeg_cmd
+
+    def run(self, input_file: str, output_file: str) -> None:
+        shell.run(self.ffmpeg_command(input_file, output_file))
+
+    def dry_run(self, input_file: str, output_file: str) -> None:
+        print(shlex.join(self.ffmpeg_command(input_file, output_file)))

raricode/utils/block_printer.py

@@ -0,0 +1,128 @@
+import io
+from abc import ABC, abstractmethod
+from contextlib import AbstractContextManager
+from types import TracebackType
+from typing import Any
+
+from raricode.utils import cursor
+
+
+class _AbstractBlockPrinter(ABC):
+    @abstractmethod
+    def print(self, *values, sep=" ", end="\n"):
+        """Print text into the block. Use this instead of normal print."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def replace(self, *values, sep=" ", end="\n"):
+        """Replace the current block text with the given text"""
+        raise NotImplementedError
+
+    def flush(self):
+        pass
+
+    @abstractmethod
+    def clear(self):
+        """Clear all text from the block"""
+        raise NotImplementedError
+
+
+class _BufferedBlockPrinter(_AbstractBlockPrinter, AbstractContextManager):
+    def __init__(self, parent_printer: _AbstractBlockPrinter) -> None:
+        self._parent_printer = parent_printer
+        self._closed = False
+        self._buffer: io.StringIO = io.StringIO()
+
+    def __enter__(self) -> Any:
+        return super().__enter__()
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
+        self.close()
+
+    def _clear_buffer(self):
+        old_buffer = self._buffer
+        self._buffer = io.StringIO()
+        old_buffer.close()
+
+    def close(self):
+        if not self._closed:
+            self.flush()
+            self._buffer.close()
+            self._closed = True
+
+    def print(self, *values, sep=" ", end="\n"):
+        assert not self._closed, f"{self.__class__.__name__} is closed"
+        print(*values, sep=sep, end=end, file=self._buffer)
+
+    def replace(self, *values, sep=" ", end="\n"):
+        # We don't need to worry about flickering at all like in BlockPrinter,
+        # so we can just clear and then call print.
+        self.clear()
+        self.print(*values, sep=sep, end=end)
+
+    def flush(self):
+        assert not self._closed, f"{self.__class__.__name__} is closed"
+        # We replace the block but do not clear the buffer as the user
+        # can still append additional text to the buffer
+        self._parent_printer.replace(self._buffer.getvalue(), end="")
+
+    def clear(self):
+        assert not self._closed, f"{self.__class__.__name__} is closed"
+        # Since we buffer and only write on flush, all we have to do is clear the buffer.
+        self._clear_buffer()
+
+
+class BlockPrinter(_AbstractBlockPrinter):
+    def __init__(self) -> None:
+        self._line_count = 0
+
+    def print(self, *values, sep=" ", end="\n"):
+        with io.StringIO() as str_io:
+            print(*values, sep=sep, end=end, file=str_io)
+            str_io.seek(0)
+            for line in str_io.readlines():
+                print(line, end="")
+                self._line_count += 1
+
+    def replace(self, *values, sep=" ", end="\n"):
+        # Return cursor to top of block and reset line_count
+        cursor.prev_line(self._line_count)
+        self._line_count = 0
+
+        with io.StringIO() as str_io:
+            # Print given text into buffer
+            print(*values, sep=sep, end=end, file=str_io)
+
+            # Loop through lines clear then replace
+            str_io.seek(0)
+            for line in str_io.readlines():
+                cursor.erase_to_end_of_line()
+                print(line, end="")
+                self._line_count += 1
+        # Clear rest of block
+        cursor.clear_screen_to_end()
+
+    def clear(self):
+        # Return cursor to top of block and reset line_count
+        cursor.prev_line(self._line_count)
+        self._line_count = 0
+        # Clear block
+        cursor.clear_screen_to_end()
+
+    def replace_block(self) -> _BufferedBlockPrinter:
+        """
+        Returns a buffer that can be used to replace the block.
+        The replacement is printed all at once on flush or close.
+
+        This can reduce text flickering when replacing using multiple prints.
+
+        Returned buffer must be closed.
+
+        Using BlockPrinter while a buffer is open is undefined behavior.
+        """
+        return _BufferedBlockPrinter(self)

raricode/utils/ctrlseq.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+
+class CtrlSeq:
+    def __init__(self, seq: str, param: None | str | int = None) -> None:
+        """Represents a terminal control sequence."""
+        self._seq = seq
+        self._param = "" if param is None else str(param)
+
+    def __call__(self, param: None | str | int) -> CtrlSeq:
+        """Set control sequence parameter"""
+        return CtrlSeq(self._seq, param)
+
+    def __str__(self) -> str:
+        return f"\033[{self._param}{self._seq}"
+
+    def __repr__(self) -> str:
+        return f"\\033[{self._param}{self._seq}"
+
+
+CUU = CtrlSeq("A")
+"""Cursor Up"""
+
+CUD = CtrlSeq("B")
+"""Cursor Down"""
+
+CUF = CtrlSeq("C")
+"""Cursor Forward"""
+
+CUB = CtrlSeq("D")
+"""Cursor Back"""
+
+CNL = CtrlSeq("E")
+"""Cursor Next Line"""
+
+CPL = CtrlSeq("F")
+"""Cursor Previous Line"""
+
+CHA = CtrlSeq("G")
+"""Cursor Horizontal Absolute"""
+
+CUP = CtrlSeq("H")
+"""Cursor Position"""
+
+ED = CtrlSeq("J")
+"""Erase in Display"""
+
+EL = CtrlSeq("K")
+"""Erase in Line"""
+
+SU = CtrlSeq("S")
+"""Scroll Up"""
+
+SD = CtrlSeq("T")
+"""Scroll Down"""
+
+HVP = CtrlSeq("f")
+"""Horizontal Vertical Position"""

raricode/utils/cursor.py

@@ -0,0 +1,151 @@
+from raricode.utils import ctrlseq
+
+
+def _clean_print(*values: object, sep=" ", file=None, flush=False):
+    print(*values, sep=sep, end="", file=file, flush=flush)
+
+
+def forward(n: int):
+    """
+    Move cursor forwards the given number of columns
+
+    `n` must be positive
+    """
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.CUF(n))
+
+
+def right(n: int):
+    """Alias for forward"""
+    forward(n)
+
+
+def back(n: int):
+    """
+    Move cursor back the given number of columns
+
+    `n` must be positive
+    """
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.CUB(n))
+
+
+def left(n: int):
+    """Alias for back"""
+    back(n)
+
+
+def up(n: int):
+    """
+    Move cursor up the given number of lines
+
+    `n` must be positive
+    """
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.CUU(n))
+
+
+def down(n: int):
+    """
+    Move cursor down the given number of lines
+
+    `n` must be positive
+    """
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.CUD(n))
+
+
+def next_line(n: int):
+    """Move cursor to beginning of line n lines down"""
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.CNL(n))
+
+
+def prev_line(n: int):
+    """Move cursor to beginning of line n lines up"""
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.CPL(n))
+
+
+def horizontal_absolute(column: int):
+    """1 based column position in the current row"""
+    _clean_print(ctrlseq.CHA(column))
+
+
+def position(row: int, column: int):
+    """Move cursor to the specified row and column (1 based)"""
+    _clean_print(ctrlseq.CUP(f"{row};{column}"))
+
+
+def erase_display(n: int | None = None):
+    """
+    Clears screen.
+
+    Accepted values are:
+
+    0 - Clear from cursor to end of screen (Default)</br>
+    1 - Clear from cursor to start of screen</br>
+    2 - Clear entire screen</br>
+    3 - Clear entire screen and scrollback buffer
+    """
+    _clean_print(ctrlseq.ED(n))
+
+
+def clear_screen_to_end():
+    erase_display(0)
+
+
+def clear_screen_to_start():
+    erase_display(1)
+
+
+def clear_screen():
+    erase_display(2)
+
+
+def clear_screen_and_scrollback():
+    erase_display(3)
+
+
+def erase_in_line(n: int | None = None):
+    """
+    Erases text in line. Cursor position does not change.
+
+    Accepted values are:
+
+    0 - Clear from cursor to end of line (Default)</br>
+    1 - Clear from cursor to beginning of line</br>
+    """
+    _clean_print(ctrlseq.EL(n))
+
+
+def erase_to_end_of_line():
+    erase_in_line(0)
+
+
+def erase_to_start_of_line():
+    erase_in_line(1)
+
+
+def scroll_up(n: int):
+    """Scroll whole page up by n lines. New lines are added at the bottom."""
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.SU(n))
+
+
+def scroll_down(n: int):
+    """Scroll whole page down by n lines. New lines are added at the top."""
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.SD(n))
+
+
+def horizontal_vertical_position(row: int, column: int):
+    _clean_print(ctrlseq.HVP(f"{row};{column}"))

raricode/utils/logging.py

@@ -0,0 +1,36 @@
+import logging
+
+_VERBOSITY: int = 0
+
+
+def verbosity() -> int:
+    return _VERBOSITY
+
+
+def setup_logging(verbosity: int, *, prefix=""):
+    global _VERBOSITY
+    _VERBOSITY = verbosity
+
+    # Setup logger
+    if verbosity <= 2:
+        logging.basicConfig(format=f"{prefix}%(message)s")
+    else:
+        logging.basicConfig(
+            format=f"{prefix}%(asctime)s [%(levelname)s] %(message)s {{ %(filename)s:%(lineno)d }}"
+        )
+
+    # Set log level
+    if verbosity <= -2:
+        logging.getLogger().setLevel(logging.CRITICAL)
+
+    if verbosity == -1:
+        logging.getLogger().setLevel(logging.ERROR)
+
+    if verbosity == 0:
+        logging.getLogger().setLevel(logging.WARNING)
+
+    if verbosity == 1:
+        logging.getLogger().setLevel(logging.INFO)
+
+    if verbosity >= 2:
+        logging.getLogger().setLevel(logging.DEBUG)

raricode/utils/rate.py

@@ -0,0 +1,69 @@
+import math
+import time
+
+
+class RateRingBuffer:
+    def __init__(self, rate_period: float = 60, bucket_window: int = 5) -> None:
+        assert rate_period >= bucket_window
+        self.rate_period: float = rate_period
+        self.ring_buffer: list[float | None] = [None] * math.floor(
+            rate_period / bucket_window
+        )
+        self.accumulator = 0
+        self.last_bucket_update = time.time()
+
+    @property
+    def num_of_buckets(self) -> int:
+        return len(self.ring_buffer)
+
+    @property
+    def bucket_window(self) -> float:
+        return self.rate_period / self.num_of_buckets
+
+    def update_buckets(self):
+        # Get how long it's been since bucket update
+        time_since_update = time.time() - self.last_bucket_update
+
+        # If we've breached our window time then roll over the bucket
+        if time_since_update >= self.bucket_window:
+            if time_since_update >= self.rate_period:
+                # If we breached total rate window, just evenly add it to all the buckets
+                rate = self.accumulator / time_since_update  # accum/s
+
+                # Spread rate evenly
+                self.ring_buffer = [rate * self.bucket_window] * self.num_of_buckets
+            else:
+                # Otherwise advance a certain number of buckets
+
+                # How many buckets to advance
+                bucket_advance = max(
+                    math.floor(time_since_update / self.bucket_window), 1
+                )
+
+                # Calculate amount per bucket
+                accum_spread = self.accumulator / bucket_advance
+
+                # Advance buckets
+                self.ring_buffer = self.ring_buffer[bucket_advance:] + (
+                    [accum_spread] * bucket_advance
+                )
+
+            # Advance time
+            # We always advance window increments
+            self.last_bucket_update = self.last_bucket_update + (
+                max(math.floor(time_since_update / self.bucket_window), 1)
+                * self.bucket_window
+            )
+            # Reset accumulator
+            self.accumulator = 0
+
+    def accumulate(self, amount: int):
+        self.accumulator += amount
+        self.update_buckets()
+
+    def rate(self) -> float:
+        self.update_buckets()
+        valid_buckets = [i for i in self.ring_buffer if i is not None]
+        if not valid_buckets:
+            return 0
+        return sum(valid_buckets) / (len(valid_buckets) * self.bucket_window)

raricode-0.0.1.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: raricode
+Version: 0.0.1
+Summary: An ffmpeg trancoding helper
+Author: Bearmine
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Dist: click>=8.4.1
+Requires-Dist: shelltastic>=0.9.0
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# Raricode
+
+A set of trancoding helpers.
+
+## Requirements
+
+[FFmpeg](https://www.ffmpeg.org/) must be installed and available on your path.
+
+## Installation
+
+### Development Installation
+
+Run in repo root:
+
+```sh
+uv tool install --editable .
+```

raricode-0.0.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+raricode/__init__.py,sha256=sUR5zDr_Hg1_sJfsl7r3vowq4eL9JEJK7ztb-FcjTck,915
+raricode/__main__.py,sha256=nF00YRK3q8QPU4O65ZNuEeinYgzUp_kpUWbg2mB_NdQ,65
+raricode/click_custom/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+raricode/click_custom/mutually_exclusive.py,sha256=hA-pteSVngWlCGR9VF46x-gEGx2JKjRoZaX3XrSjCUY,962
+raricode/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+raricode/commands/cropdetect.py,sha256=F_J00XyXDZUBDu7OoNAvR1E4fzAUt50-EcqGfXyhgTY,6354
+raricode/commands/ffmpeg_info.py,sha256=o_aeGpLIZarFswWcngXRhVN1UGcn4d8gOtXLeXXNKSI,187
+raricode/commands/targetsize.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+raricode/commands/transcode.py,sha256=RZLWMG-boEmP1c0RrlEMG6jaVVZVSw1VX_MDscAWVIY,2891
+raricode/exception.py,sha256=PWP1akU6sfw1YSUy4w7qh9qqaB6uO0Siz5O-t-h2TI8,94
+raricode/ffmpeg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+raricode/ffmpeg/codec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+raricode/ffmpeg/codec/audio.py,sha256=HoZ1M-3MAhwl8aZGd-wtDKVpwyRM9MlScXDN6jNWHfQ,742
+raricode/ffmpeg/codec/video.py,sha256=QrVUduqNltOz57vMKm_U-ayOdyDL1Z6gYuEnbKmGIUU,742
+raricode/ffmpeg/cropdetect.py,sha256=pYou2tRaCZQUc6z57HJAT2onBfFvJC9soQaNkCpt62I,63
+raricode/ffmpeg/rate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+raricode/ffmpeg/rate/audio.py,sha256=2XOIIyhNeGUeBh-OXBZ3N6-ig5tS2fkh9Hs_uQNOPQg,370
+raricode/ffmpeg/rate/video.py,sha256=mLRczGrPVS2N7cuLHIMr3tN_C_c4gNlLOv6dQusVdVU,1370
+raricode/ffmpeg/runner.py,sha256=u1D9XdBvDwOwCF1OC30vGixVABInW0ZS5ZoAkbxRGfw,1581
+raricode/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+raricode/utils/block_printer.py,sha256=m_lOFbQQENPwpcciuj1HOVpX29MI-PvLq9fj9GKM9Tc,4167
+raricode/utils/ctrlseq.py,sha256=1CSKnhoTAQbCRY54F9RjzQ7LIoYeieFlLz-CprtjYK0,1116
+raricode/utils/cursor.py,sha256=u5_Un4CxZqGSuTsbBFldkxxfhgmY8qOQoqW5MvJHYtE,3132
+raricode/utils/logging.py,sha256=R-QUroHtXmj1NdRK0rId60qp0EJu5Ncmj8U8fmj73j8,841
+raricode/utils/rate.py,sha256=L3cfvcCJ-VP_lklbUhQ04eBvVB_rmEWCt9tJlQVqByY,2468
+raricode-0.0.1.dist-info/licenses/LICENSE,sha256=FYUuFbYDDqQMEF19Bvm_fSlQQb8Df4FVsNbL2nOnbf0,11338
+raricode-0.0.1.dist-info/WHEEL,sha256=4OL6Foqnnp3xRY5wMkjgc25_i5YJC6dKsC6LPcjqEoU,80
+raricode-0.0.1.dist-info/entry_points.txt,sha256=Swb5JohYGhLGzeQLkbX8vc5AeIaC95THaccIrRThra4,44
+raricode-0.0.1.dist-info/METADATA,sha256=l5BYmmKCADw49NR8G-znU5kdIq6Z0CUW7Oehuq8naaI,531
+raricode-0.0.1.dist-info/RECORD,,

raricode-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.5
+Root-Is-Purelib: true
+Tag: py3-none-any

raricode-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+raricode = raricode:main
+

raricode-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Bearmine
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.