generic ¶

@classmethod
def check(cls, func: FuncExceptT, /, *formats: VideoFormatT | HoldsVideoFormatT, **kwargs: Any) -> None: ...

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

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

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

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

    :param to_check:                    Value to check. Must be either a ColorFamily value,
                                        or a value a ColorFamily can be derived from such as VideoFormat.
    :param correct:                     A correct value or an array of correct color families.
    :param func:                        Function returned for custom error handling.
                                        This should only be set by VS package developers.
    :param message:                     Message to print when throwing the exception.
                                        The message will be formatted to display the correct and wrong values
                                        (`{correct}` and `{wrong}` respectively).
    :param 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 = get_color_family(to_check)
    correct_list = [get_color_family(c) for c in to_arr(correct)]  # type: ignore[arg-type]

    if to_check not in correct_list:
        if message is not None:
            kwargs.update(message=message)
        raise InvalidColorFamilyError(func, to_check, correct_list, **kwargs)

@staticmethod
def check(
    func: FuncExceptT,
    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.

    :param to_check:                Value to check. Must be either a VideoNode holding the correct framerate,
                                    a Fraction, a tuple representing a fraction, or a float.
    :param correct:                 A correct value or an array of correct values.
    :param func:                    Function returned for custom error handling.
                                    This should only be set by VS package developers.
    :param message:                 Message to print when throwing the exception.
                                    The message will be formatted to display the correct and wrong values
                                    (`{correct}` and `{wrong}` respectively).
    :param 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: FuncExceptT,
    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.

    :param func:                            Function returned for custom error handling.
                                            This should only be set by VS package developers.
    :param to_check:                        Value to check. Must be an integer representing the timecodes version.
    :param correct:                         A correct value or an array of correct values.
                                            Defaults to [1, 2] (V1, V2).
    :param message:                         Message to print when throwing the exception.
                                            The message will be formatted to display the correct and wrong values
                                            (`{correct}` and `{wrong}` respectively).
    :param 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: FuncExceptT, /, *lengths: int | Sized, **kwargs: Any) -> None: ...

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

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

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