stubs ¶

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

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

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

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

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

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

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

@classmethod
def from_param(cls, value: Any, func_except: Any = None) -> Self | None:
    """
    Get the enum member from its int representation.
    """

@classmethod
def from_param_or_video(
    cls,
    value: Any,
    src: vs.VideoNode | vs.VideoFrame | vs.FrameProps,
    strict: bool = False,
    func_except: FuncExceptT | None = None,
) -> Self:
    """
    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.

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

    if value is not None:
        return value

    return cls.from_video(src, strict, func_except)

@classmethod
def from_res(cls, frame: vs.VideoNode | vs.VideoFrame) -> Self:
    """
    Get an enum member from the video resolution with heuristics.
    """

    raise NotImplementedError

@classmethod
def from_video(
    cls, src: vs.VideoNode | vs.VideoFrame | vs.FrameProps, strict: bool = False, func: FuncExceptT | None = None
) -> Self:
    """
    Get an enum member from the frame properties or optionally fall back to resolution when strict=False.
    """

    raise NotImplementedError

@classmethod
def is_unknown(cls, value: int | Self) -> 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
@classmethod
def prop_key(cls) -> str:
    """
    The key used in props to store the enum.
    """

    return f"_{cls.__name__}"