Skip to content

placebo

EwaBicubic 

EwaBicubic(
    b: float = 0.0, c: float = 0.5, radius: int | None = None, **kwargs: Any
)

Bases: Placebo

Source code 
105
106
107
108
109
110
111
112
113
def __init__(self, b: float = 0.0, c: float = 0.5, radius: int | None = None, **kwargs: Any) -> None:
    radius = kwargs.pop('taps', radius)

    if radius is None:
        from .bicubic import Bicubic

        radius = Bicubic(b, c).kernel_radius

    super().__init__(radius, b, c, **kwargs)

antiring instance-attribute 

antiring: float = antiring

b instance-attribute 

b: float | None = b

blur instance-attribute 

blur: float = blur

c instance-attribute 

c: float | None = c

clamp instance-attribute 

clamp: float = clamp

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

scale_function class-attribute instance-attribute 

scale_function = Resample

taper instance-attribute 

taper: float = taper

taps instance-attribute 

taps: float | None = taps

ensure_obj classmethod 

ensure_obj(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScalerT
Source code 
186
187
188
189
190
191
192
193
@classmethod
def ensure_obj(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScalerT:
    return _base_ensure_obj(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

from_param classmethod 

from_param(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScalerT]
Source code 
177
178
179
180
181
182
183
184
@classmethod
def from_param(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> type[BaseScalerT]:
    return _base_from_param(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
199
200
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
270
271
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.scale, self.multi)

get_params_args 

get_params_args(
    is_descale: bool,
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any
) -> dict[str, Any]
Source code 
79
80
81
82
83
84
85
86
87
def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> dict[str, Any]:
    return dict(
        width=width, height=height, filter=self._kernel,
        radius=self.taps, param1=self.b, param2=self.c,
        clamp=self.clamp, taper=self.taper, blur=self.blur,
        antiring=self.antiring,
    ) | kwargs

get_scale_args 

get_scale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> dict[str, Any]
Source code 
67
68
69
70
71
72
73
74
75
76
77
@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> dict[str, Any]:
    return (
        dict(sx=shift[1], sy=shift[0])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, width, height, **kwargs)
    )

kernel_radius 

kernel_radius() -> int
Source code 
89
90
91
92
93
94
95
96
97
98
99
@inject_self.cached.property
def kernel_radius(self) -> int:  # type: ignore
    from .bicubic import Bicubic

    if self.taps:
        return ceil(self.taps)

    if self.b or self.c:
        return Bicubic(fallback(self.b, 0), fallback(self.c, 0.5)).kernel_radius

    return 2

multi 

multi(
    clip: VideoNode,
    multi: float = 2,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
239
240
241
242
243
244
245
246
247
248
249
250
251
252
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * multi), ceil(clip.height * multi)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "multi" must result in a positive resolution!', self.multi, multi
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
202
203
204
205
206
207
208
209
210
211
212
213
214
@inject_self.cached.property
def pretty_string(self) -> str:
    attrs = {}

    if hasattr(self, 'b'):
        attrs.update(b=self.b, c=self.c)
    elif hasattr(self, 'taps'):
        attrs['taps'] = self.taps

    if hasattr(self, 'kwargs'):
        attrs.update(self.kwargs)

    return f"{self.__class__.__name__}{' (' + ', '.join(f'{k}={v}' for k, v in attrs.items()) + ')' if attrs else ''}"

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *,
    linear: bool = False,
    sigmoid: bool | tuple[Slope, Center] = False,
    **kwargs: Any
) -> VideoNode
Source code 
82
83
84
85
86
87
88
89
@inject_self.cached
@inject_kwargs_params
def scale(  # type: ignore[override]
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *, linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False, **kwargs: Any
) -> vs.VideoNode:
    ...

EwaGinseng 

EwaGinseng(taps: float = 3.238315484166236, **kwargs: Any)

Bases: Placebo

Source code 
133
134
def __init__(self, taps: float = 3.2383154841662362076499, **kwargs: Any) -> None:
    super().__init__(taps, None, None, **kwargs)

antiring instance-attribute 

antiring: float = antiring

b instance-attribute 

b: float | None = b

blur instance-attribute 

blur: float = blur

c instance-attribute 

c: float | None = c

clamp instance-attribute 

clamp: float = clamp

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

scale_function class-attribute instance-attribute 

scale_function = Resample

taper instance-attribute 

taper: float = taper

taps instance-attribute 

taps: float | None = taps

ensure_obj classmethod 

ensure_obj(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScalerT
Source code 
186
187
188
189
190
191
192
193
@classmethod
def ensure_obj(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScalerT:
    return _base_ensure_obj(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

from_param classmethod 

from_param(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScalerT]
Source code 
177
178
179
180
181
182
183
184
@classmethod
def from_param(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> type[BaseScalerT]:
    return _base_from_param(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
199
200
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
270
271
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.scale, self.multi)

get_params_args 

get_params_args(
    is_descale: bool,
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any
) -> dict[str, Any]
Source code 
79
80
81
82
83
84
85
86
87
def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> dict[str, Any]:
    return dict(
        width=width, height=height, filter=self._kernel,
        radius=self.taps, param1=self.b, param2=self.c,
        clamp=self.clamp, taper=self.taper, blur=self.blur,
        antiring=self.antiring,
    ) | kwargs

get_scale_args 

get_scale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> dict[str, Any]
Source code 
67
68
69
70
71
72
73
74
75
76
77
@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> dict[str, Any]:
    return (
        dict(sx=shift[1], sy=shift[0])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, width, height, **kwargs)
    )

kernel_radius 

kernel_radius() -> int
Source code 
89
90
91
92
93
94
95
96
97
98
99
@inject_self.cached.property
def kernel_radius(self) -> int:  # type: ignore
    from .bicubic import Bicubic

    if self.taps:
        return ceil(self.taps)

    if self.b or self.c:
        return Bicubic(fallback(self.b, 0), fallback(self.c, 0.5)).kernel_radius

    return 2

multi 

multi(
    clip: VideoNode,
    multi: float = 2,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
239
240
241
242
243
244
245
246
247
248
249
250
251
252
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * multi), ceil(clip.height * multi)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "multi" must result in a positive resolution!', self.multi, multi
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
202
203
204
205
206
207
208
209
210
211
212
213
214
@inject_self.cached.property
def pretty_string(self) -> str:
    attrs = {}

    if hasattr(self, 'b'):
        attrs.update(b=self.b, c=self.c)
    elif hasattr(self, 'taps'):
        attrs['taps'] = self.taps

    if hasattr(self, 'kwargs'):
        attrs.update(self.kwargs)

    return f"{self.__class__.__name__}{' (' + ', '.join(f'{k}={v}' for k, v in attrs.items()) + ')' if attrs else ''}"

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *,
    linear: bool = False,
    sigmoid: bool | tuple[Slope, Center] = False,
    **kwargs: Any
) -> VideoNode
Source code 
82
83
84
85
86
87
88
89
@inject_self.cached
@inject_kwargs_params
def scale(  # type: ignore[override]
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *, linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False, **kwargs: Any
) -> vs.VideoNode:
    ...

EwaHann 

EwaHann(taps: float = 3.238315484166236, **kwargs: Any)

Bases: Placebo

Source code 
140
141
def __init__(self, taps: float = 3.2383154841662362076499, **kwargs: Any) -> None:
    super().__init__(taps, None, None, **kwargs)

antiring instance-attribute 

antiring: float = antiring

b instance-attribute 

b: float | None = b

blur instance-attribute 

blur: float = blur

c instance-attribute 

c: float | None = c

clamp instance-attribute 

clamp: float = clamp

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

scale_function class-attribute instance-attribute 

scale_function = Resample

taper instance-attribute 

taper: float = taper

taps instance-attribute 

taps: float | None = taps

ensure_obj classmethod 

ensure_obj(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScalerT
Source code 
186
187
188
189
190
191
192
193
@classmethod
def ensure_obj(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScalerT:
    return _base_ensure_obj(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

from_param classmethod 

from_param(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScalerT]
Source code 
177
178
179
180
181
182
183
184
@classmethod
def from_param(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> type[BaseScalerT]:
    return _base_from_param(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
199
200
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
270
271
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.scale, self.multi)

get_params_args 

get_params_args(
    is_descale: bool,
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any
) -> dict[str, Any]
Source code 
79
80
81
82
83
84
85
86
87
def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> dict[str, Any]:
    return dict(
        width=width, height=height, filter=self._kernel,
        radius=self.taps, param1=self.b, param2=self.c,
        clamp=self.clamp, taper=self.taper, blur=self.blur,
        antiring=self.antiring,
    ) | kwargs

get_scale_args 

get_scale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> dict[str, Any]
Source code 
67
68
69
70
71
72
73
74
75
76
77
@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> dict[str, Any]:
    return (
        dict(sx=shift[1], sy=shift[0])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, width, height, **kwargs)
    )

kernel_radius 

kernel_radius() -> int
Source code 
89
90
91
92
93
94
95
96
97
98
99
@inject_self.cached.property
def kernel_radius(self) -> int:  # type: ignore
    from .bicubic import Bicubic

    if self.taps:
        return ceil(self.taps)

    if self.b or self.c:
        return Bicubic(fallback(self.b, 0), fallback(self.c, 0.5)).kernel_radius

    return 2

multi 

multi(
    clip: VideoNode,
    multi: float = 2,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
239
240
241
242
243
244
245
246
247
248
249
250
251
252
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * multi), ceil(clip.height * multi)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "multi" must result in a positive resolution!', self.multi, multi
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
202
203
204
205
206
207
208
209
210
211
212
213
214
@inject_self.cached.property
def pretty_string(self) -> str:
    attrs = {}

    if hasattr(self, 'b'):
        attrs.update(b=self.b, c=self.c)
    elif hasattr(self, 'taps'):
        attrs['taps'] = self.taps

    if hasattr(self, 'kwargs'):
        attrs.update(self.kwargs)

    return f"{self.__class__.__name__}{' (' + ', '.join(f'{k}={v}' for k, v in attrs.items()) + ')' if attrs else ''}"

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *,
    linear: bool = False,
    sigmoid: bool | tuple[Slope, Center] = False,
    **kwargs: Any
) -> VideoNode
Source code 
82
83
84
85
86
87
88
89
@inject_self.cached
@inject_kwargs_params
def scale(  # type: ignore[override]
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *, linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False, **kwargs: Any
) -> vs.VideoNode:
    ...

EwaJinc 

EwaJinc(taps: float = 3.238315484166236, **kwargs: Any)

Bases: Placebo

Source code 
126
127
def __init__(self, taps: float = 3.2383154841662362076499, **kwargs: Any) -> None:
    super().__init__(taps, None, None, **kwargs)

antiring instance-attribute 

antiring: float = antiring

b instance-attribute 

b: float | None = b

blur instance-attribute 

blur: float = blur

c instance-attribute 

c: float | None = c

clamp instance-attribute 

clamp: float = clamp

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

scale_function class-attribute instance-attribute 

scale_function = Resample

taper instance-attribute 

taper: float = taper

taps instance-attribute 

taps: float | None = taps

ensure_obj classmethod 

ensure_obj(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScalerT
Source code 
186
187
188
189
190
191
192
193
@classmethod
def ensure_obj(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScalerT:
    return _base_ensure_obj(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

from_param classmethod 

from_param(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScalerT]
Source code 
177
178
179
180
181
182
183
184
@classmethod
def from_param(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> type[BaseScalerT]:
    return _base_from_param(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
199
200
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
270
271
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.scale, self.multi)

get_params_args 

get_params_args(
    is_descale: bool,
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any
) -> dict[str, Any]
Source code 
79
80
81
82
83
84
85
86
87
def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> dict[str, Any]:
    return dict(
        width=width, height=height, filter=self._kernel,
        radius=self.taps, param1=self.b, param2=self.c,
        clamp=self.clamp, taper=self.taper, blur=self.blur,
        antiring=self.antiring,
    ) | kwargs

get_scale_args 

get_scale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> dict[str, Any]
Source code 
67
68
69
70
71
72
73
74
75
76
77
@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> dict[str, Any]:
    return (
        dict(sx=shift[1], sy=shift[0])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, width, height, **kwargs)
    )

kernel_radius 

kernel_radius() -> int
Source code 
89
90
91
92
93
94
95
96
97
98
99
@inject_self.cached.property
def kernel_radius(self) -> int:  # type: ignore
    from .bicubic import Bicubic

    if self.taps:
        return ceil(self.taps)

    if self.b or self.c:
        return Bicubic(fallback(self.b, 0), fallback(self.c, 0.5)).kernel_radius

    return 2

multi 

multi(
    clip: VideoNode,
    multi: float = 2,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
239
240
241
242
243
244
245
246
247
248
249
250
251
252
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * multi), ceil(clip.height * multi)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "multi" must result in a positive resolution!', self.multi, multi
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
202
203
204
205
206
207
208
209
210
211
212
213
214
@inject_self.cached.property
def pretty_string(self) -> str:
    attrs = {}

    if hasattr(self, 'b'):
        attrs.update(b=self.b, c=self.c)
    elif hasattr(self, 'taps'):
        attrs['taps'] = self.taps

    if hasattr(self, 'kwargs'):
        attrs.update(self.kwargs)

    return f"{self.__class__.__name__}{' (' + ', '.join(f'{k}={v}' for k, v in attrs.items()) + ')' if attrs else ''}"

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *,
    linear: bool = False,
    sigmoid: bool | tuple[Slope, Center] = False,
    **kwargs: Any
) -> VideoNode
Source code 
82
83
84
85
86
87
88
89
@inject_self.cached
@inject_kwargs_params
def scale(  # type: ignore[override]
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *, linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False, **kwargs: Any
) -> vs.VideoNode:
    ...

EwaLanczos 

EwaLanczos(taps: float = 3.238315484166236, **kwargs: Any)

Bases: Placebo

Source code 
119
120
def __init__(self, taps: float = 3.2383154841662362076499, **kwargs: Any) -> None:
    super().__init__(taps, None, None, **kwargs)

antiring instance-attribute 

antiring: float = antiring

b instance-attribute 

b: float | None = b

blur instance-attribute 

blur: float = blur

c instance-attribute 

c: float | None = c

clamp instance-attribute 

clamp: float = clamp

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

scale_function class-attribute instance-attribute 

scale_function = Resample

taper instance-attribute 

taper: float = taper

taps instance-attribute 

taps: float | None = taps

ensure_obj classmethod 

ensure_obj(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScalerT
Source code 
186
187
188
189
190
191
192
193
@classmethod
def ensure_obj(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScalerT:
    return _base_ensure_obj(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

from_param classmethod 

from_param(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScalerT]
Source code 
177
178
179
180
181
182
183
184
@classmethod
def from_param(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> type[BaseScalerT]:
    return _base_from_param(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
199
200
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
270
271
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.scale, self.multi)

get_params_args 

get_params_args(
    is_descale: bool,
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any
) -> dict[str, Any]
Source code 
79
80
81
82
83
84
85
86
87
def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> dict[str, Any]:
    return dict(
        width=width, height=height, filter=self._kernel,
        radius=self.taps, param1=self.b, param2=self.c,
        clamp=self.clamp, taper=self.taper, blur=self.blur,
        antiring=self.antiring,
    ) | kwargs

get_scale_args 

get_scale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> dict[str, Any]
Source code 
67
68
69
70
71
72
73
74
75
76
77
@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> dict[str, Any]:
    return (
        dict(sx=shift[1], sy=shift[0])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, width, height, **kwargs)
    )

kernel_radius 

kernel_radius() -> int
Source code 
89
90
91
92
93
94
95
96
97
98
99
@inject_self.cached.property
def kernel_radius(self) -> int:  # type: ignore
    from .bicubic import Bicubic

    if self.taps:
        return ceil(self.taps)

    if self.b or self.c:
        return Bicubic(fallback(self.b, 0), fallback(self.c, 0.5)).kernel_radius

    return 2

multi 

multi(
    clip: VideoNode,
    multi: float = 2,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
239
240
241
242
243
244
245
246
247
248
249
250
251
252
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * multi), ceil(clip.height * multi)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "multi" must result in a positive resolution!', self.multi, multi
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
202
203
204
205
206
207
208
209
210
211
212
213
214
@inject_self.cached.property
def pretty_string(self) -> str:
    attrs = {}

    if hasattr(self, 'b'):
        attrs.update(b=self.b, c=self.c)
    elif hasattr(self, 'taps'):
        attrs['taps'] = self.taps

    if hasattr(self, 'kwargs'):
        attrs.update(self.kwargs)

    return f"{self.__class__.__name__}{' (' + ', '.join(f'{k}={v}' for k, v in attrs.items()) + ')' if attrs else ''}"

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *,
    linear: bool = False,
    sigmoid: bool | tuple[Slope, Center] = False,
    **kwargs: Any
) -> VideoNode
Source code 
82
83
84
85
86
87
88
89
@inject_self.cached
@inject_kwargs_params
def scale(  # type: ignore[override]
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *, linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False, **kwargs: Any
) -> vs.VideoNode:
    ...

EwaRobidoux 

EwaRobidoux(**kwargs: Any)

Bases: Placebo

Source code 
147
148
def __init__(self, **kwargs: Any) -> None:
    super().__init__(None, None, None, **kwargs)

antiring instance-attribute 

antiring: float = antiring

b instance-attribute 

b: float | None = b

blur instance-attribute 

blur: float = blur

c instance-attribute 

c: float | None = c

clamp instance-attribute 

clamp: float = clamp

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

scale_function class-attribute instance-attribute 

scale_function = Resample

taper instance-attribute 

taper: float = taper

taps instance-attribute 

taps: float | None = taps

ensure_obj classmethod 

ensure_obj(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScalerT
Source code 
186
187
188
189
190
191
192
193
@classmethod
def ensure_obj(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScalerT:
    return _base_ensure_obj(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

from_param classmethod 

from_param(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScalerT]
Source code 
177
178
179
180
181
182
183
184
@classmethod
def from_param(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> type[BaseScalerT]:
    return _base_from_param(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
199
200
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
270
271
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.scale, self.multi)

get_params_args 

get_params_args(
    is_descale: bool,
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any
) -> dict[str, Any]
Source code 
79
80
81
82
83
84
85
86
87
def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> dict[str, Any]:
    return dict(
        width=width, height=height, filter=self._kernel,
        radius=self.taps, param1=self.b, param2=self.c,
        clamp=self.clamp, taper=self.taper, blur=self.blur,
        antiring=self.antiring,
    ) | kwargs

get_scale_args 

get_scale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> dict[str, Any]
Source code 
67
68
69
70
71
72
73
74
75
76
77
@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> dict[str, Any]:
    return (
        dict(sx=shift[1], sy=shift[0])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, width, height, **kwargs)
    )

kernel_radius 

kernel_radius() -> int
Source code 
89
90
91
92
93
94
95
96
97
98
99
@inject_self.cached.property
def kernel_radius(self) -> int:  # type: ignore
    from .bicubic import Bicubic

    if self.taps:
        return ceil(self.taps)

    if self.b or self.c:
        return Bicubic(fallback(self.b, 0), fallback(self.c, 0.5)).kernel_radius

    return 2

multi 

multi(
    clip: VideoNode,
    multi: float = 2,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
239
240
241
242
243
244
245
246
247
248
249
250
251
252
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * multi), ceil(clip.height * multi)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "multi" must result in a positive resolution!', self.multi, multi
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
202
203
204
205
206
207
208
209
210
211
212
213
214
@inject_self.cached.property
def pretty_string(self) -> str:
    attrs = {}

    if hasattr(self, 'b'):
        attrs.update(b=self.b, c=self.c)
    elif hasattr(self, 'taps'):
        attrs['taps'] = self.taps

    if hasattr(self, 'kwargs'):
        attrs.update(self.kwargs)

    return f"{self.__class__.__name__}{' (' + ', '.join(f'{k}={v}' for k, v in attrs.items()) + ')' if attrs else ''}"

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *,
    linear: bool = False,
    sigmoid: bool | tuple[Slope, Center] = False,
    **kwargs: Any
) -> VideoNode
Source code 
82
83
84
85
86
87
88
89
@inject_self.cached
@inject_kwargs_params
def scale(  # type: ignore[override]
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *, linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False, **kwargs: Any
) -> vs.VideoNode:
    ...

EwaRobidouxSharp 

EwaRobidouxSharp(**kwargs: Any)

Bases: Placebo

Source code 
154
155
def __init__(self, **kwargs: Any) -> None:
    super().__init__(None, None, None, **kwargs)

antiring instance-attribute 

antiring: float = antiring

b instance-attribute 

b: float | None = b

blur instance-attribute 

blur: float = blur

c instance-attribute 

c: float | None = c

clamp instance-attribute 

clamp: float = clamp

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

scale_function class-attribute instance-attribute 

scale_function = Resample

taper instance-attribute 

taper: float = taper

taps instance-attribute 

taps: float | None = taps

ensure_obj classmethod 

ensure_obj(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScalerT
Source code 
186
187
188
189
190
191
192
193
@classmethod
def ensure_obj(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScalerT:
    return _base_ensure_obj(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

from_param classmethod 

from_param(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScalerT]
Source code 
177
178
179
180
181
182
183
184
@classmethod
def from_param(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> type[BaseScalerT]:
    return _base_from_param(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
199
200
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
270
271
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.scale, self.multi)

get_params_args 

get_params_args(
    is_descale: bool,
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any
) -> dict[str, Any]
Source code 
79
80
81
82
83
84
85
86
87
def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> dict[str, Any]:
    return dict(
        width=width, height=height, filter=self._kernel,
        radius=self.taps, param1=self.b, param2=self.c,
        clamp=self.clamp, taper=self.taper, blur=self.blur,
        antiring=self.antiring,
    ) | kwargs

get_scale_args 

get_scale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> dict[str, Any]
Source code 
67
68
69
70
71
72
73
74
75
76
77
@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> dict[str, Any]:
    return (
        dict(sx=shift[1], sy=shift[0])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, width, height, **kwargs)
    )

kernel_radius 

kernel_radius() -> int
Source code 
89
90
91
92
93
94
95
96
97
98
99
@inject_self.cached.property
def kernel_radius(self) -> int:  # type: ignore
    from .bicubic import Bicubic

    if self.taps:
        return ceil(self.taps)

    if self.b or self.c:
        return Bicubic(fallback(self.b, 0), fallback(self.c, 0.5)).kernel_radius

    return 2

multi 

multi(
    clip: VideoNode,
    multi: float = 2,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
239
240
241
242
243
244
245
246
247
248
249
250
251
252
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * multi), ceil(clip.height * multi)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "multi" must result in a positive resolution!', self.multi, multi
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
202
203
204
205
206
207
208
209
210
211
212
213
214
@inject_self.cached.property
def pretty_string(self) -> str:
    attrs = {}

    if hasattr(self, 'b'):
        attrs.update(b=self.b, c=self.c)
    elif hasattr(self, 'taps'):
        attrs['taps'] = self.taps

    if hasattr(self, 'kwargs'):
        attrs.update(self.kwargs)

    return f"{self.__class__.__name__}{' (' + ', '.join(f'{k}={v}' for k, v in attrs.items()) + ')' if attrs else ''}"

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *,
    linear: bool = False,
    sigmoid: bool | tuple[Slope, Center] = False,
    **kwargs: Any
) -> VideoNode
Source code 
82
83
84
85
86
87
88
89
@inject_self.cached
@inject_kwargs_params
def scale(  # type: ignore[override]
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *, linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False, **kwargs: Any
) -> vs.VideoNode:
    ...

Placebo 

Placebo(
    taps: float | None = None,
    b: float | None = None,
    c: float | None = None,
    clamp: float = 0.0,
    blur: float = 0.0,
    taper: float = 0.0,
    antiring: float = 0.0,
    **kwargs: Any
)

Bases: LinearScaler

Abstract Placebo scaler.

Dependencies:

Source code 
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def __init__(
    self,
    taps: float | None = None, b: float | None = None, c: float | None = None,
    clamp: float = 0.0, blur: float = 0.0, taper: float = 0.0,
    antiring: float = 0.0,
    **kwargs: Any
) -> None:
    self.taps = taps
    self.b = b
    self.c = c
    self.clamp = clamp
    self.blur = blur
    self.taper = taper
    self.antiring = antiring
    super().__init__(**kwargs)

antiring instance-attribute 

antiring: float = antiring

b instance-attribute 

b: float | None = b

blur instance-attribute 

blur: float = blur

c instance-attribute 

c: float | None = c

clamp instance-attribute 

clamp: float = clamp

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

scale_function class-attribute instance-attribute 

scale_function = Resample

taper instance-attribute 

taper: float = taper

taps instance-attribute 

taps: float | None = taps

ensure_obj classmethod 

ensure_obj(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScalerT
Source code 
186
187
188
189
190
191
192
193
@classmethod
def ensure_obj(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScalerT:
    return _base_ensure_obj(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

from_param classmethod 

from_param(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScalerT]
Source code 
177
178
179
180
181
182
183
184
@classmethod
def from_param(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> type[BaseScalerT]:
    return _base_from_param(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
199
200
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
270
271
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.scale, self.multi)

get_params_args 

get_params_args(
    is_descale: bool,
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any
) -> dict[str, Any]
Source code 
79
80
81
82
83
84
85
86
87
def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> dict[str, Any]:
    return dict(
        width=width, height=height, filter=self._kernel,
        radius=self.taps, param1=self.b, param2=self.c,
        clamp=self.clamp, taper=self.taper, blur=self.blur,
        antiring=self.antiring,
    ) | kwargs

get_scale_args 

get_scale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> dict[str, Any]
Source code 
67
68
69
70
71
72
73
74
75
76
77
@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> dict[str, Any]:
    return (
        dict(sx=shift[1], sy=shift[0])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, width, height, **kwargs)
    )

kernel_radius 

kernel_radius() -> int
Source code 
89
90
91
92
93
94
95
96
97
98
99
@inject_self.cached.property
def kernel_radius(self) -> int:  # type: ignore
    from .bicubic import Bicubic

    if self.taps:
        return ceil(self.taps)

    if self.b or self.c:
        return Bicubic(fallback(self.b, 0), fallback(self.c, 0.5)).kernel_radius

    return 2

multi 

multi(
    clip: VideoNode,
    multi: float = 2,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
239
240
241
242
243
244
245
246
247
248
249
250
251
252
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * multi), ceil(clip.height * multi)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "multi" must result in a positive resolution!', self.multi, multi
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
202
203
204
205
206
207
208
209
210
211
212
213
214
@inject_self.cached.property
def pretty_string(self) -> str:
    attrs = {}

    if hasattr(self, 'b'):
        attrs.update(b=self.b, c=self.c)
    elif hasattr(self, 'taps'):
        attrs['taps'] = self.taps

    if hasattr(self, 'kwargs'):
        attrs.update(self.kwargs)

    return f"{self.__class__.__name__}{' (' + ', '.join(f'{k}={v}' for k, v in attrs.items()) + ')' if attrs else ''}"

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *,
    linear: bool = False,
    sigmoid: bool | tuple[Slope, Center] = False,
    **kwargs: Any
) -> VideoNode
Source code 
82
83
84
85
86
87
88
89
@inject_self.cached
@inject_kwargs_params
def scale(  # type: ignore[override]
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *, linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False, **kwargs: Any
) -> vs.VideoNode:
    ...