generic ¶

def __init__(
    self,
    func: FuncExcept,
    formats: Iterable[VideoFormatLike | HoldsVideoFormat],
    message: SupportsString = "All specified formats must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, formats, message, **kwargs)

def __init__(
    self,
    func: FuncExcept,
    clip: VideoFormatLike | HoldsVideoFormat,
    ref: VideoFormatLike | HoldsVideoFormat,
    message: SupportsString = "The format of ref and main clip must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, clip, ref, message, **kwargs)

def __init__(
    self,
    func: FuncExcept,
    key: str,
    message: SupportsString = 'Error while trying to get frame prop "{key}"!',
    **kwargs: Any,
) -> None:
    super().__init__(message, func, key=key, **kwargs)

def __init__(
    self,
    func: FuncExcept,
    framerates: Iterable[vs.VideoNode | Fraction | tuple[int, int] | float],
    message: SupportsString = "All the framerates must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, framerates, message, **kwargs)

def __init__(
    self,
    func: FuncExcept,
    clip: vs.VideoNode | Fraction | tuple[int, int] | float,
    ref: vs.VideoNode | Fraction | tuple[int, int] | float,
    message: SupportsString = "The framerate of the ref and main clip must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, clip, ref, message, **kwargs)

def __init__(
    self,
    func: FuncExcept,
    var_name: str,
    message: SupportsString = '"{var_name}" can\'t be greater than the clip length!',
    **kwargs: Any,
) -> None:
    super().__init__(message, func, var_name=var_name, **kwargs)

def __init__(
    self,
    func: FuncExcept,
    lengths: Iterable[int | Sized],
    message: SupportsString = "All the lengths must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, lengths, message, iter(map(self._item_to_name, lengths)), **kwargs)

def __init__(
    self,
    func: FuncExcept,
    clip: int | vs.RawNode,
    ref: int | vs.RawNode,
    message: SupportsString = "The main clip and ref clip length must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, clip, ref, message, **kwargs)

def __init__(
    self,
    func: FuncExcept,
    resolutions: Iterable[Resolution | vs.VideoNode],
    message: SupportsString = "All the resolutions must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, resolutions, message, **kwargs)

def __init__(
    self,
    func: FuncExcept,
    clip: Resolution | vs.VideoNode,
    ref: Resolution | vs.VideoNode,
    message: SupportsString = "The resolution of ref and main clip must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, clip, ref, message, **kwargs)

def __init__(
    self, func: FuncExcept, message: SupportsString = "You must set `tff` for this clip!", **kwargs: Any
) -> None:
    super().__init__(message, func, **kwargs)

def __init__(
    self,
    func: FuncExcept | None,
    wrong: VideoFormatLike
    | HoldsVideoFormat
    | vs.ColorFamily
    | Iterable[VideoFormatLike | HoldsVideoFormat | vs.ColorFamily],
    correct: VideoFormatLike
    | HoldsVideoFormat
    | vs.ColorFamily
    | Iterable[VideoFormatLike | HoldsVideoFormat | vs.ColorFamily] = vs.YUV,
    message: SupportsString = "Input clip must be of {correct} color family, not {wrong}.",
    **kwargs: Any,
) -> None:
    """
    Initialize the exception.

    Args:
        func: Function where the exception was raised.
        wrong: The unsupported color family(ies).
        correct: The expected color family(ies).
        message: Exception message template supporting `{correct}` and `{wrong}` placeholders.
        **kwargs: Additional keyword arguments passed to the exception.
    """
    from ..utils import get_color_family

    super().__init__(
        func,
        {get_color_family(c).name for c in to_arr(wrong)},  # type: ignore[arg-type]
        {get_color_family(c).name for c in to_arr(correct)},  # type: ignore[arg-type]
        message,
        **kwargs,
    )

def __init__(
    self,
    func: FuncExcept,
    wrong: vs.VideoNode | Fraction | Iterable[vs.VideoNode | Fraction],
    correct: vs.VideoNode | Fraction | Iterable[vs.VideoNode | Fraction],
    message: SupportsString = "Input clip must be of {correct} framerate, not {wrong}.",
    **kwargs: Any,
) -> None:
    """
    Initialize the exception.

    Args:
        func: Function where the exception was raised.
        wrong: The unsupported framerate(s).
        correct: The expected framerate(s).
        message: Exception message template supporting `{correct}` and `{wrong}` placeholders.
        **kwargs: Additional keyword arguments passed to the exception.
    """
    from ..utils import get_framerate

    super().__init__(
        func,
        {get_framerate(f) for f in to_arr(wrong)},  # type: ignore[arg-type]
        {get_framerate(f) for f in to_arr(correct)},  # type: ignore[arg-type]
        message,
        **kwargs,
    )

def __init__(
    self,
    func: FuncExcept | None,
    wrong: VideoFormatLike
    | HoldsVideoFormat
    | vs.SampleType
    | Iterable[VideoFormatLike | HoldsVideoFormat | vs.SampleType],
    correct: VideoFormatLike
    | HoldsVideoFormat
    | vs.SampleType
    | Iterable[VideoFormatLike | HoldsVideoFormat | vs.SampleType],
    message: SupportsString = "Input clip must be of {correct} sample type, not {wrong}.",
    **kwargs: Any,
) -> None:
    """
    Initialize the exception.

    Args:
        func: Function where the exception was raised.
        wrong: The unsupported sample type(s).
        correct: The expected sample type(s).
        message: Exception message template supporting `{correct}` and `{wrong}` placeholders.
        **kwargs: Additional keyword arguments passed to the exception.
    """
    from ..utils import get_sample_type

    super().__init__(
        func,
        {get_sample_type(c).name for c in to_arr(wrong)},  # type: ignore[arg-type]
        {get_sample_type(c).name for c in to_arr(correct)},  # type: ignore[arg-type]
        message,
        **kwargs,
    )

def __init__(
    self,
    func: FuncExcept,
    wrong: str | VideoFormatLike | HoldsVideoFormat | Iterable[str | VideoFormatLike | HoldsVideoFormat],
    correct: str | VideoFormatLike | HoldsVideoFormat | Iterable[str | VideoFormatLike | HoldsVideoFormat],
    message: SupportsString = "Input clip must be of {correct} subsampling, not {wrong}.",
    **kwargs: Any,
) -> None:
    """
    Initialize the exception.

    Args:
        func: Function where the exception was raised.
        wrong: The unsupported subsampling(s).
        correct: The expected subsampling(s).
        message: Exception message template supporting `{correct}` and `{wrong}` placeholders.
        **kwargs: Additional keyword arguments passed to the exception.
    """
    from ..utils import get_subsampling

    super().__init__(
        func,
        {f if isinstance(f, str) else get_subsampling(f) for f in to_arr(wrong)},  # type: ignore[arg-type]
        {f if isinstance(f, str) else get_subsampling(f) for f in to_arr(correct)},  # type: ignore[arg-type]
        message,
        **kwargs,
    )

def __init__(
    self,
    func: FuncExcept,
    wrong: SupportsInt | Iterable[SupportsInt],
    correct: SupportsInt | Iterable[SupportsInt] = (1, 2),
    message: SupportsString = "Timecodes version be in {correct}, not {wrong}.",
    **kwargs: Any,
) -> None:
    """
    Initialize the exception.

    Args:
        func: Function where the exception was raised.
        wrong: The unsupported timecode(s).
        correct: The expected timecode(s).
        message: Exception message template supporting `{correct}` and `{wrong}` placeholders.
        **kwargs: Additional keyword arguments passed to the exception.
    """
    super().__init__(func, {int(t) for t in to_arr(wrong)}, {int(t) for t in to_arr(correct)}, message, **kwargs)

def __init__(
    self,
    func: FuncExcept | None,
    wrong: VideoFormatLike | HoldsVideoFormat | Iterable[VideoFormatLike | HoldsVideoFormat],
    correct: VideoFormatLike | HoldsVideoFormat | Iterable[VideoFormatLike | HoldsVideoFormat],
    message: SupportsString = "Input clip must be of {correct} format, not {wrong}.",
    **kwargs: Any,
) -> None:
    """
    Initialize the exception.

    Args:
        func: Function where the exception was raised.
        wrong: The unsupported video format(s).
        correct: The expected video format(s).
        message: Exception message template supporting `{correct}` and `{wrong}` placeholders.
        **kwargs: Additional keyword arguments passed to the exception.
    """
    from ..utils import get_video_format

    super().__init__(
        func,
        {get_video_format(f).name for f in to_arr(wrong)},  # type: ignore[arg-type]
        {get_video_format(f).name for f in to_arr(correct)},  # type: ignore[arg-type]
        message,
        **kwargs,
    )

def __init__(
    self, func: FuncExcept, message: SupportsString = "Variable-format clips not supported!", **kwargs: Any
) -> None:
    super().__init__(message, func, **kwargs)

def __init__(
    self, func: FuncExcept, message: SupportsString = "Variable-resolution clips not supported!", **kwargs: Any
) -> None:
    super().__init__(message, func, **kwargs)