prefilters ¶

@abstractmethod
def __call__(
    self, clip: vs.VideoNode, planes: Planes = None, full_range: bool | float = False, **kwargs: Any
) -> vs.VideoNode | PrefilterPartial: ...

def __call__(
    self, clip: vs.VideoNode, planes: Planes = None, full_range: bool | float = False, **kwargs: Any
) -> vs.VideoNode:
    """
    Apply a sequence of prefilters to the given clip.

    Args:
        clip: Clip to be preprocessed.
        planes: Planes to be preprocessed.
        full_range: Whether to return a prefiltered clip in full range.
        **kwargs: Additional keyword arguments passed to each prefilter.

    Returns:
        Preprocessed clip.
    """
    for pref in self.prefilters:
        clip = pref(clip, planes, full_range, **kwargs)

    return clip

def __call__(
    self,
    clip: vs.VideoNode | MissingT = MISSING,
    planes: Planes = None,
    full_range: bool | float = False,
    **kwargs: Any,
) -> vs.VideoNode | PrefilterPartial:
    """
    Run the selected prefilter.

    Args:
        clip: Clip to be preprocessed.
        planes: Planes to be preprocessed.
        full_range: Whether to return a prefiltered clip in full range.
        **kwargs: Additional arguments to pass to the specified prefilter.

    Returns:
        Preprocessed clip or Partial Prefilter.
    """
    if clip is MISSING:
        return PrefilterPartial(self, planes, full_range, **kwargs)

    out = _run_prefilter(self, clip, planes, **kwargs)

    if full_range is not False:
        if full_range is True:
            full_range = 2.0

        return prefilter_to_full_range(out, full_range)

    return out

@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!s})" for name, value in cls.__members__.items()),
        reason=value,
    ) from None

def __call__(
    self,
    clip: vs.VideoNode,
    planes: Planes | MissingT = MISSING,
    full_range: bool | float | MissingT = MISSING,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Apply the prefilter to the given clip with optional argument overrides.

    Args:
        clip: Clip to be preprocessed.
        planes: Optional override for the planes to preprocess. If not provided, the default set in the constructor
            is used.
        full_range: Optional override for full range setting. If not provided, the default set in the constructor is
            used.
        **kwargs: Additional keyword arguments to override or extend the stored ones.

    Returns:
        Preprocessed clip.
    """
    return self.prefilter(
        clip,
        self.planes if planes is MISSING else planes,
        self.full_range if full_range is MISSING else full_range,
        **self.kwargs | kwargs,
    )