types ¶

@classmethod
def from_param(cls, value: Any, func_except: FuncExcept | None = None) -> Self:
    """
    Return the enum value from a parameter.

    Args:
        value: Value to instantiate the enum class.
        func_except: Exception function.

    Returns:
        Enum value.

    Raises:
        NotFoundEnumValue: Variable not found in the given enum.
    """
    func_except = func_except or cls.from_param

    try:
        return cls(value)
    except (ValueError, TypeError):
        pass

    if isinstance(func_except, tuple):
        func_name, var_name = func_except
    else:
        func_name, var_name = func_except, repr(cls)

    raise NotFoundEnumValueError(
        'The given value for "{var_name}" argument must be a valid {enum_name}, not "{value}"!\n'
        "Valid values are: [{readable_enum}].",
        func_name,
        var_name=var_name,
        enum_name=cls,
        value=value,
        readable_enum=(f"{name} ({value!r})" for name, value in cls.__members__.items()),
        reason=value,
    ) from None

@cache
def pad_amount(self, size: int, min_amount: int = 2) -> int:
    """
    Return required padding for one dimension.

    MIRROR always returns zero. Other modes pad to an 8-pixel boundary.

    Args:
        size: Dimension size.
        min_amount: Minimum required padding.

    Returns:
        Padding amount.
    """
    if self is BorderHandling.MIRROR:
        return 0

    return (((size + min_amount) + 7) & -8) - size

def prepare_clip(
    self, clip: vs.VideoNode, min_pad: int = 2, shift: tuple[TopShift, LeftShift] = (0, 0)
) -> tuple[vs.VideoNode, tuple[TopShift, LeftShift]]:
    """
    Apply required padding and adjust shift.

    Args:
        clip: Input clip.
        min_pad: Minimum padding before alignment.
        shift: Current (top, left) shift.

    Returns:
        (padded clip, updated shift).
    """
    pad_w, pad_h = (self.pad_amount(size, min_pad) for size in (clip.width, clip.height))

    if pad_w == pad_h == 0:
        return clip, shift

    match self:
        case BorderHandling.ZERO:
            padded = padder.COLOR(clip, pad_w, pad_w, pad_h, pad_h)
        case BorderHandling.REPEAT:
            padded = padder.REPEAT(clip, pad_w, pad_w, pad_h, pad_h)
        case _:
            raise CustomNotImplementedError

    shift = tuple(s + ((p - c) // 2) for s, c, p in zip(shift, *((x.height, x.width) for x in (clip, padded))))

    return padded, shift

@enum_property
def value(self) -> int: ...

def __call__(
    self,
    width: int,
    height: int,
    src_width: float,
    src_height: float,
    shift: tuple[float, float],
    kwargs: dict[str, Any],
) -> tuple[dict[str, Any], tuple[float, float]]:
    """
    Apply sampling model to sizes and shift.

    Args:
        width: Destination width.
        height: Destination height.
        src_width: Current source width.
        src_height: Current source height.
        shift: (x, y) sampling shift.
        kwargs: Parameter dict to update.

    Returns:
        (updated kwargs, updated shift).
    """

    if self is SampleGridModel.MATCH_CENTERS:
        src_width = src_width * (width - 1) / (src_width - 1)
        src_height = src_height * (height - 1) / (src_height - 1)

        kwargs |= {"src_width": src_width, "src_height": src_height}
        shift_x, shift_y, *_ = tuple(
            (x / 2 + y for x, y in zip(((height - src_height), (width - src_width)), shift))
        )
        shift = shift_x, shift_y

    return kwargs, shift

def for_dst(
    self, clip: vs.VideoNode, width: int, height: int, shift: tuple[float, float], **kwargs: Any
) -> tuple[dict[str, Any], tuple[float, float]]:
    """
    Apply grid model using destination sizes.

    Args:
        clip: Source clip.
        width: Destination width.
        height: Destination height.
        shift: Current shift.
        **kwargs: Optional src_width/src_height.

    Returns:
        (updated kwargs, updated shift).
    """

    src_width = kwargs.get("src_width", width)
    src_height = kwargs.get("src_height", height)

    return self(src_width, src_height, width, height, shift, kwargs)

def for_src(
    self, clip: vs.VideoNode, width: int, height: int, shift: tuple[float, float], **kwargs: Any
) -> tuple[dict[str, Any], tuple[float, float]]:
    """
    Apply grid model using source sizes.

    Args:
        clip: Source clip (fallback for src dimensions).
        width: Source width.
        height: Source height.
        shift: Current shift.
        **kwargs: Optional overrides.

    Returns:
        (updated kwargs, updated shift).
    """

    src_width = kwargs.get("src_width", clip.width)
    src_height = kwargs.get("src_height", clip.height)

    return self(width, height, src_width, src_height, shift, kwargs)

@classmethod
def from_param(cls, value: Any, func_except: FuncExcept | None = None) -> Self:
    """
    Return the enum value from a parameter.

    Args:
        value: Value to instantiate the enum class.
        func_except: Exception function.

    Returns:
        Enum value.

    Raises:
        NotFoundEnumValue: Variable not found in the given enum.
    """
    func_except = func_except or cls.from_param

    try:
        return cls(value)
    except (ValueError, TypeError):
        pass

    if isinstance(func_except, tuple):
        func_name, var_name = func_except
    else:
        func_name, var_name = func_except, repr(cls)

    raise NotFoundEnumValueError(
        'The given value for "{var_name}" argument must be a valid {enum_name}, not "{value}"!\n'
        "Valid values are: [{readable_enum}].",
        func_name,
        var_name=var_name,
        enum_name=cls,
        value=value,
        readable_enum=(f"{name} ({value!r})" for name, value in cls.__members__.items()),
        reason=value,
    ) from None

@enum_property
def value(self) -> int: ...