generic ¶

@classmethod
def check(cls, func: FuncExcept, /, *formats: VideoFormatLike | HoldsVideoFormat, **kwargs: Any) -> None: ...

@classmethod
def check(  # type: ignore[override]
    cls,
    func: FuncExcept,
    clip: VideoFormatLike | HoldsVideoFormat,
    ref: VideoFormatLike | HoldsVideoFormat,
    /,
    **kwargs: Any,
) -> None: ...

@classmethod
def check(
    cls, func: FuncExcept, /, *framerates: vs.VideoNode | Fraction | tuple[int, int] | float, **kwargs: Any
) -> None: ...

@classmethod
def check(  # type: ignore[override]
    cls,
    func: FuncExcept,
    clip: vs.VideoNode | Fraction | tuple[int, int] | float,
    ref: vs.VideoNode | Fraction | tuple[int, int] | float,
    /,
    **kwargs: Any,
) -> None: ...

@classmethod
def check(
    cls,
    to_check: VideoFormatLike
    | HoldsVideoFormat
    | vs.ColorFamily
    | Iterable[VideoFormatLike | HoldsVideoFormat | vs.ColorFamily],
    correct: VideoFormatLike
    | HoldsVideoFormat
    | vs.ColorFamily
    | Iterable[VideoFormatLike | HoldsVideoFormat | vs.ColorFamily],
    func: FuncExcept | None = None,
    message: SupportsString | None = None,
    **kwargs: Any,
) -> None:
    """
    Check whether the given values are correct, and if not, throw this exception.

    Args:
        to_check: Value to check. Must be either a ColorFamily value, or a value a ColorFamily can be derived from
            such as VideoFormat.
        correct: A correct value or an array of correct color families.
        func: Function returned for custom error handling. This should only be set by VS package developers.
        message: Message to print when throwing the exception. The message will be formatted to display the correct
            and wrong values (`{correct}` and `{wrong}` respectively).
        **kwargs: Keyword arguments to pass on to the exception.

    Raises:
        InvalidColorFamilyError: Given color family is not in list of correct color families.
    """
    from ..functions import to_arr
    from ..utils import get_color_family

    to_check_set = {get_color_family(c) for c in to_arr(to_check)}  # type: ignore[arg-type]
    correct_set = {get_color_family(c) for c in to_arr(correct)}  # type: ignore[arg-type]

    if not to_check_set.issubset(correct_set):
        if message is not None:
            kwargs.update(message=message)
        raise cls(func, to_check_set, correct_set, **kwargs)

@staticmethod
def check(
    func: FuncExcept,
    to_check: vs.VideoNode | Fraction | tuple[int, int] | float,
    correct: vs.VideoNode
    | Fraction
    | tuple[int, int]
    | float
    | Iterable[vs.VideoNode | Fraction | tuple[int, int] | float],
    message: SupportsString = "Input clip must have {correct} framerate, not {wrong}!",
    **kwargs: Any,
) -> None:
    """
    Check whether the given values are correct, and if not, throw this exception.

    Args:
        to_check: Value to check. Must be either a VideoNode holding the correct framerate, a Fraction, a tuple
            representing a fraction, or a float.
        correct: A correct value or an array of correct values.
        func: Function returned for custom error handling. This should only be set by VS package developers.
        message: Message to print when throwing the exception. The message will be formatted to display the correct
            and wrong values (`{correct}` and `{wrong}` respectively).
        **kwargs: Keyword arguments to pass on to the exception.

    Raises:
        InvalidFramerateError: Given framerate is not in list of correct framerates.
    """
    from ..utils import get_framerate

    to_check = get_framerate(to_check)

    def _resolve_correct(val: Any) -> Iterable[vs.VideoNode | Fraction | tuple[int, int] | float]:
        if isinstance(val, Iterable):
            if isinstance(val, tuple) and len(val) == 2 and all(isinstance(x, int) for x in val):
                return [val]
            return val
        return [val]

    correct_list = [get_framerate(c) for c in _resolve_correct(correct)]

    if to_check not in correct_list:
        raise InvalidFramerateError(
            func, to_check, message, wrong=to_check, correct=iter(set(correct_list)), **kwargs
        )

@staticmethod
def check(
    func: FuncExcept,
    to_check: int,
    correct: int | Iterable[int] = [1, 2],
    message: SupportsString = "Timecodes version be in {correct}, not {wrong}!",
    **kwargs: Any,
) -> None:
    """
    Check whether the given values are correct, and if not, throw this exception.

    Args:
        func: Function returned for custom error handling. This should only be set by VS package developers.
        to_check: Value to check. Must be an integer representing the timecodes version.
        correct: A correct value or an array of correct values. Defaults to [1, 2] (V1, V2).
        message: Message to print when throwing the exception. The message will be formatted to display the correct
            and wrong values (`{correct}` and `{wrong}` respectively).
        **kwargs: Keyword arguments to pass on to the exception.

    Raises:
        InvalidTimecodeVersionError: Given timecodes version is not in list of correct versions.
    """
    from ..functions import to_arr

    correct_list = to_arr(correct)

    if to_check not in correct_list:
        raise InvalidTimecodeVersionError(
            func, to_check, message, wrong=to_check, correct=iter(set(correct_list)), **kwargs
        )

@classmethod
def check(cls, func: FuncExcept, /, *lengths: int | Sized, **kwargs: Any) -> None: ...

@classmethod
def check(  # type: ignore[override]
    cls, func: FuncExcept, clip: int | vs.RawNode, ref: int | vs.RawNode, /, **kwargs: Any
) -> None: ...

@classmethod
def check(cls, func: FuncExcept, /, *resolutions: Resolution | vs.VideoNode, **kwargs: Any) -> None: ...

@classmethod
def check(  # type: ignore[override]
    cls, func: FuncExcept, clip: Resolution | vs.VideoNode, ref: Resolution | vs.VideoNode, /, **kwargs: Any
) -> None: ...