generic ¶

def apply(self: SelfPropEnum, clip: vs.VideoNode) -> vs.VideoNode:
    """Applies the property to the VideoNode."""

    return clip.std.SetFrameProp(self.prop_key, self.value)

@classmethod
def ensure_presence(
    cls: type[SelfPropEnum], clip: vs.VideoNode, value: int | SelfPropEnum | None, func: FuncExceptT | None = None
) -> vs.VideoNode:
    """Ensure the presence of the property in the VideoNode."""

    enum_value = cls.from_param_or_video(value, clip, True, func)

    return clip.std.SetFrameProp(enum_value.prop_key, enum_value.value)

@staticmethod
def ensure_presences(
    clip: vs.VideoNode, prop_enums: Iterable[type[SelfPropEnum] | SelfPropEnum], func: FuncExceptT | None = None
) -> vs.VideoNode:
    """Ensure the presence of multiple PropEnums at once."""

    return clip.std.SetFrameProps(**{
        value.prop_key: value.value  # type: ignore
        for value in [
            cls if isinstance(cls, PropEnum) else cls.from_video(clip, True)
            for cls in prop_enums
        ]
    })

@classmethod
def from_param(cls: Any, value: Any, func_except: Any = None) -> ChromaLocation | None:
    """
    Determine the ChromaLocation through a parameter.

    :param value:           Value or ChromaLocation object.
    :param func_except:     Function returned for custom error handling.
                            This should only be set by VS package developers.

    :return:                ChromaLocation object or None.
    """

@classmethod
def from_param_or_video(
    cls: type[ChromaLocation], value: int | ChromaLocation | ChromaLocationT | None,
    src: vs.VideoNode | vs.VideoFrame | vs.FrameProps,
    strict: bool = False, func_except: FuncExceptT | None = None
) -> ChromaLocation:
    ...

@classmethod
def from_res(cls, frame: vs.VideoNode | vs.VideoFrame) -> ChromaLocation:
    """
    Guess the chroma location based on the clip's resolution.

    :param frame:       Input clip or frame.

    :return:            ChromaLocation object.
    """

    return ChromaLocation.LEFT

@classmethod
def from_video(
    cls, src: vs.VideoNode | vs.VideoFrame | vs.FrameProps, strict: bool = False, func: FuncExceptT | None = None
) -> ChromaLocation:
    """
    Obtain the chroma location of a clip from the frame properties.

    :param src:                             Input clip, frame, or props.
    :param strict:                          Be strict about the properties.
                                            The result may NOT be an unknown value.

    :return:                                ChromaLocation object.

    :raises UndefinedChromaLocationError:   Chroma location is undefined.
    :raises UndefinedChromaLocationError:   Chroma location can not be determined from the frame properties.
    """

    return _base_from_video(cls, src, UndefinedChromaLocationError, strict, func)

@classmethod
def get_offsets(
    cls, chroma_loc: ChromaLocation | vs.VideoNode
) -> tuple[float, float]:
    """
    Get (left,top) shift for chroma relative to luma.

    This is only useful if you MUST use a pre-specified chroma location and shift the chroma yourself.
    """

    if isinstance(chroma_loc, vs.VideoNode):
        assert chroma_loc.format
        subsampling = (chroma_loc.format.subsampling_w, chroma_loc.format.subsampling_h)

        if subsampling in [(1, 0), (1, 1)]:
            offsets = (0.5, 0)
        elif subsampling == (0, 1):
            offsets = (0, 0)
        elif subsampling == (2, 0):
            offsets = (2.5, 0)
        elif subsampling == (2, 2):
            offsets = (2.5, 1)
        elif subsampling == (0, 0):
            offsets = (0, 0)
        else:
            raise UnsupportedSubsamplingError('Unknown subsampling.', cls)

        return offsets

    off_left = off_top = 0.0

    if chroma_loc in {ChromaLocation.LEFT, ChromaLocation.TOP_LEFT, ChromaLocation.BOTTOM_LEFT}:
        off_left += -0.5

    if chroma_loc in {ChromaLocation.TOP, ChromaLocation.TOP_LEFT}:
        off_top += -0.5
    elif chroma_loc in {ChromaLocation.BOTTOM, ChromaLocation.BOTTOM_LEFT}:
        off_top += +0.5

    return off_left, off_top

@classmethod
def is_unknown(cls: type[SelfPropEnum], value: int | SelfPropEnum) -> bool:
    """Whether the value represents an unknown value."""

    return False

@classmethod
def is_valid(cls, value: int) -> bool:
    """Check if the given value is a valid int value of this enum."""
    return int(value) in map(int, cls.__members__.values())

@classproperty
def prop_key(cls: type[SelfPropEnum]) -> str:  # type: ignore
    """The key used in props to store the enum."""

    return f'_{cls.__name__}'

def apply(self: SelfPropEnum, clip: vs.VideoNode) -> vs.VideoNode:
    """Applies the property to the VideoNode."""

    return clip.std.SetFrameProp(self.prop_key, self.value)

@classmethod
def ensure_presence(
    cls, clip: vs.VideoNode, tff: int | FieldBasedT | bool | None, func: FuncExceptT | None = None
) -> vs.VideoNode:
    field_based = cls.from_param_or_video(tff, clip, True, func)

    return clip.std.SetFieldBased(field_based.value)

@staticmethod
def ensure_presences(
    clip: vs.VideoNode, prop_enums: Iterable[type[SelfPropEnum] | SelfPropEnum], func: FuncExceptT | None = None
) -> vs.VideoNode:
    """Ensure the presence of multiple PropEnums at once."""

    return clip.std.SetFrameProps(**{
        value.prop_key: value.value  # type: ignore
        for value in [
            cls if isinstance(cls, PropEnum) else cls.from_video(clip, True)
            for cls in prop_enums
        ]
    })

@classmethod
def from_param(cls: Any, value_or_tff: Any, func_except: Any = None) -> FieldBased | None:
    if isinstance(value_or_tff, bool):
        return FieldBased(1 + value_or_tff)

    return super().from_param(value_or_tff)

@classmethod
def from_param_or_video(
    cls: type[SelfPropEnum], value: Any,
    src: vs.VideoNode | vs.VideoFrame | vs.FrameProps,
    strict: bool = False, func_except: FuncExceptT | None = None
) -> SelfPropEnum:
    """
    Get the enum member from a value that can be casted to this prop value
    or grab it from frame properties.

    If `strict=False`, gather the heuristics using the clip's size or format.

    :param value:           Value to cast.
    :param src:             Clip to get prop from.
    :param strict:          Be strict about the frame properties. Default: False.
    :param func_except:     Function returned for custom error handling.
    """
    value = cls.from_param(value, func_except)

    if value is not None:
        return value  # type: ignore

    return cls.from_video(src, strict, func_except)

@classmethod
def from_res(cls, frame: vs.VideoNode | vs.VideoFrame) -> FieldBased:
    """Guess the Field order from the frame resolution."""

    return cls.PROGRESSIVE

@classmethod
def from_video(
    cls, src: vs.VideoNode | vs.VideoFrame | vs.FrameProps, strict: bool = False, func: FuncExceptT | None = None
) -> FieldBased:
    """
    Obtain the Field order of a clip from the frame properties.

    :param src:                             Input clip, frame, or props.
    :param strict:                          Be strict about the properties.
                                            Will ALWAYS error if the FieldBased is missing.

    :return:                                FieldBased object.

    :raises UndefinedFieldBasedError:       Field order is undefined.
    :raises UndefinedFieldBasedError:       Field order can not be determined from the frame properties.
    """

    return _base_from_video(cls, src, UndefinedFieldBasedError, strict, func)

@classmethod
def is_unknown(cls: type[SelfPropEnum], value: int | SelfPropEnum) -> bool:
    """Whether the value represents an unknown value."""

    return False

@classmethod
def is_valid(cls, value: int) -> bool:
    """Check if the given value is a valid int value of this enum."""
    return int(value) in map(int, cls.__members__.values())

@classproperty
def prop_key(cls: type[SelfPropEnum]) -> str:  # type: ignore
    """The key used in props to store the enum."""

    return f'_{cls.__name__}'