soifunc 0.11.3__tar.gz → 0.14.0__tar.gz

{soifunc-0.11.3 → soifunc-0.14.0}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: soifunc
-Version: 0.11.3
+Version: 0.14.0
 Summary: Soichiro's VapourSynth Functions Collection
 License: MIT
+License-File: LICENSE
 Author: Josh Holmer
 Author-email: jholmer.in@gmail.com
 Requires-Python: >=3.12,<4.0
@@ -10,8 +11,9 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: vapoursynth (>=68)
-Requires-Dist: vsjetpack (>=0.5.2,<0.6.0)
+Requires-Dist: vsjetpack (>=1.0.0,<2.0.0)
 Description-Content-Type: text/markdown
 
 ## soifunc

{soifunc-0.11.3 → soifunc-0.14.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "soifunc"
-version = "0.11.3"
+version = "0.14.0"
 description = "Soichiro's VapourSynth Functions Collection"
 authors = ["Josh Holmer <jholmer.in@gmail.com>"]
 license = "MIT"
@@ -9,11 +9,11 @@ readme = "README.md"
 [tool.poetry.dependencies]
 python = ">=3.12,<4.0"
 vapoursynth = ">=68"
-vsjetpack = "^0.5.2"
+vsjetpack = "^1.0.0"
 
 [tool.poetry.group.dev.dependencies]
-black = "^25.1.0"
-isort = "^6.0.1"
+black = "^25.9.0"
+isort = "^7.0.0"
 pre-commit = "^4.2.0"
 
 [build-system]

soifunc-0.14.0/soifunc/deband.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from vsdeband import f3k_deband
+from vsmasktools import dre_edgemask
+from vstools import (
+    UnsupportedVideoFormatError,
+    VariableFormatError,
+    check_variable,
+    core,
+    vs,
+)
+
+__all__ = [
+    "retinex_deband",
+]
+
+
+def retinex_deband(
+    clip: vs.VideoNode,
+    threshold: int,
+    showmask: bool = False,
+) -> vs.VideoNode:
+    """Debanding using contrast-adaptive edge masking.
+
+    Args:
+        clip: Input video (8-16bit YUV required).
+        threshold: Debanding strength (0-255). Default ~16-48 recommended.
+        showmask: If True, return edge mask instead of debanded clip.
+
+    Returns:
+        Debanded video clip or edge mask.
+
+    Note:
+        Does not add grain. Use vsdeband.AddNoise for post-denoising.
+    """
+    if threshold < 0 or threshold > 255:
+        raise ValueError(f"threshold must be between 0-255, got {threshold}")
+
+    if not check_variable(clip, retinex_deband):
+        raise VariableFormatError("clip must have constant format and fps")
+
+    if (
+        clip.format.color_family != vs.YUV
+        or clip.format.sample_type != vs.INTEGER
+        or clip.format.bits_per_sample > 16
+    ):
+        raise UnsupportedVideoFormatError(
+            retinex_deband,
+            clip.format,
+            "The format {format.name} is not supported! It must be an 8-16bit integer YUV bit format!",
+        )
+
+    mask: vs.VideoNode = dre_edgemask.CLAHE(clip)
+
+    if showmask:
+        return mask
+
+    # The threshold value that `retinex_deband` takes is relative
+    # to 8-bit videos, but `f3kdb` changed their threshold
+    # values to be relative to 10-bit videos some time after this
+    # function was created. To keep this function compatible,
+    # we shift our threshold from 8-bit to 10-bit.
+    deband = f3k_deband(clip, thr=(threshold << 2))
+    return core.std.MaskedMerge(deband, clip, mask)

{soifunc-0.11.3 → soifunc-0.14.0}/soifunc/denoise.py

@@ -3,17 +3,18 @@ from __future__ import annotations
 from typing import Callable, Optional
 
 import vsdenoise
-from vsdenoise import DFTTest, bm3d, mc_degrain
-from vstools import core, vs
+from vsdenoise import DFTTest, bm3d, mc_degrain, nl_means
+from vstools import core, depth, get_u, get_y, join, split, vs
 
 __all__ = ["MCDenoise", "magic_denoise", "hqbm3d", "mc_dfttest"]
 
 
 def hqbm3d(
     clip: vs.VideoNode,
-    luma_str: float = 0.45,
+    luma_str: float = 0.5,
     chroma_str: float = 0.4,
     profile: bm3d.Profile = bm3d.Profile.FAST,
+    tr: int = 1,
 ) -> vs.VideoNode:
     """
     High-quality presets for motion compensated denoising.
@@ -39,12 +40,24 @@ def hqbm3d(
         ),
         planes=None,
     )
-    out = bm3d(clip, sigma=luma_str, tr=1, ref=mv, profile=profile, planes=0)
-    return vsdenoise.nl_means(out, h=chroma_str, tr=1, ref=mv, planes=[1, 2])
+    [y, u, v] = split(clip)
+    [y_mv, u_mv, v_mv] = split(mv)
+    out_y = bm3d(y, sigma=luma_str, tr=tr, ref=y_mv, profile=profile)
+    if not hasattr(core, "nlm_cuda") and hasattr(core, "knlm"):
+        # the KNLMeansCL would force extra depth conversions
+        # and re-processing of the luma plane, so avoid it.
+        nlm_backend = nl_means.Backend.ISPC
+    else:
+        nlm_backend = nl_means.Backend.AUTO
+    out_u = nl_means(u, h=chroma_str, tr=tr, ref=u_mv, backend=nlm_backend)
+    out_v = nl_means(v, h=chroma_str, tr=tr, ref=v_mv, backend=nlm_backend)
+    return join(out_y, out_u, out_v, prop_src=clip)
 
 
 def mc_dfttest(
-    clip: vs.VideoNode, thSAD: int = 75, noisy: bool = False
+    clip: vs.VideoNode,
+    thSAD: int = 75,
+    tr: int = 2,
 ) -> vs.VideoNode:
     """
     A motion-compensated denoiser using DFTTEST.
@@ -52,19 +65,14 @@ def mc_dfttest(
     Turn it up to 150 or more if you really need to nuke something.
     It does a decent job at preserving details, but not nearly as good
     as bm3d, so this is not recommended on clean, high-quality sources.
-
-    The `noisy` parameter did help preserve more detail on high-quality but grainy sources.
-    Currently it is deprecated, as the presets in `vsdenoise` changed,
-    but it may be un-deprecated in the future.
     """
-    # TODO: Do we need to tweak anything for the `noisy` param?
     blksize = select_block_size(clip)
     return mc_degrain(
         clip,
         prefilter=vsdenoise.Prefilter.DFTTEST,
         preset=vsdenoise.MVToolsPreset.HQ_SAD,
         thsad=thSAD,
-        tr=2,
+        tr=tr,
         refine=3 if blksize > 16 else 2,
         blksize=blksize,
     )

soifunc-0.14.0/soifunc/interpolate.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import vstools
+from vsscale import autoselect_backend
+from vstools import vs
+
+if TYPE_CHECKING:
+    from vsmlrt import backendT
+
+__all__ = ["rate_doubler", "decimation_fixer", "replace_dupes"]
+
+
+def rate_doubler(
+    clip: vs.VideoNode, multi: int = 2, backend: backendT | None = None
+) -> vs.VideoNode:
+    """
+    A utility to scale the framerate of a video via frame interpolation.
+
+    Probably shouldn't just go spraying this everywhere,
+    it's more for fun and science than anything.
+    """
+    import vsmlrt
+
+    width = clip.width
+    height = clip.height
+    format = clip.format
+    matrix = vstools.Matrix.from_video(clip)
+    transfer = vstools.Transfer.from_video(clip)
+    primaries = vstools.Primaries.from_video(clip)
+    clip = clip.misc.SCDetect()
+    clip = clip.resize.Bicubic(
+        format=vs.RGBS,
+        width=next_multiple_of(64, width),
+        height=next_multiple_of(64, height),
+    )
+    clip = vsmlrt.RIFE(
+        clip,
+        multi=multi,
+        model=vsmlrt.RIFEModel.v4_25_heavy,
+        # Why these defaults? Because running ML stuff on AMD on Windows sucks hard.
+        # Trial and error led me to finally find that ORT_DML works.
+        backend=(backend if backend else autoselect_backend()),
+    )
+    # TODO: Handle other chroma samplings
+    clip = clip.resize.Bicubic(
+        format=format,
+        width=width,
+        height=height,
+        matrix=matrix,
+        transfer=transfer,
+        primaries=primaries,
+    )
+    return clip
+
+
+def replace_dupes(
+    clip: vs.VideoNode,
+    max_length: int = 5,
+    backend: backendT | None = None,
+    threshold: float = 0.001,
+) -> vs.VideoNode:
+    """
+    Detects strings of duplicate frames in a video and replaces them
+    with interpolated frames from RIFE.
+
+    Max number of continuous duplicates to detect is determined by the `max_length` parameter.
+    `threshold` is the maximum average pixel difference (0-1 scale) to consider frames as duplicates.
+    Lower values are stricter (frames must be more similar to be considered duplicates).
+    """
+    import vsmlrt
+
+    # Store original properties
+    width = clip.width
+    height = clip.height
+    format = clip.format
+    matrix = vstools.Matrix.from_video(clip)
+    transfer = vstools.Transfer.from_video(clip)
+    primaries = vstools.Primaries.from_video(clip)
+
+    # Compute frame differences using PlaneStats
+    # This compares each frame with the previous one
+    diff_clip = clip.std.PlaneStats(clip[0] + clip)
+
+    # Prepare clip for RIFE (convert to RGBS and resize to multiple of 64)
+    rife_clip = clip.resize.Bicubic(
+        format=vs.RGBS,
+        width=next_multiple_of(64, width),
+        height=next_multiple_of(64, height),
+    )
+
+    # Create interpolated frames using RIFE (double the framerate)
+    interpolated = vsmlrt.RIFE(
+        rife_clip,
+        multi=2,
+        model=vsmlrt.RIFEModel.v4_25_heavy,
+        backend=(backend if backend else autoselect_backend()),
+    )
+
+    # Convert interpolated frames back to original format
+    interpolated = interpolated.resize.Bicubic(
+        format=format,
+        width=width,
+        height=height,
+        matrix=matrix,
+        transfer=transfer,
+        primaries=primaries,
+    )
+
+    # Track sequence state for lazy evaluation
+    state = {"prev_len": 0}
+
+    def select_frame(n):
+        """
+        Select interpolated frame if current frame is a duplicate,
+        otherwise use original. Copies PlaneStatsDiff property to output
+        to help users calibrate the threshold parameter.
+        """
+        if n == 0 or n == clip.num_frames - 1:
+            state["prev_len"] = 0
+            # Frame 0 and final frame are never duplicates
+            # (no previous frame for 0, no next frame for final)
+            output = clip[n : n + 1]
+            diff_val = (
+                0.0
+                if n == 0
+                else diff_clip.get_frame(n).props.get("PlaneStatsDiff", 1.0)
+            )
+            return output.std.SetFrameProp(prop="PlaneStatsDiff", floatval=diff_val)
+
+        # Get difference from PlaneStats (lazy evaluation)
+        f = diff_clip.get_frame(n)
+        diff = f.props.get("PlaneStatsDiff", 1.0)
+
+        # Determine if this is a duplicate
+        if diff < threshold:
+            new_len = state["prev_len"] + 1
+            if new_len <= max_length:
+                state["prev_len"] = new_len
+                is_dupe = True
+            else:
+                state["prev_len"] = 0
+                is_dupe = False
+        else:
+            state["prev_len"] = 0
+            is_dupe = False
+
+        if is_dupe:
+            # Use interpolated frame between previous and current
+            # If the original sequence is 0 1 2 where 0 and 1 are dupes,
+            # the interpolated sequence will have 0 1 2 3 4 5
+            # where 3 is the interpolated frame we want to fetch
+            # to replace frame 1..
+
+            output = interpolated[n * 2 + 1 : n * 2 + 2]
+        else:
+            output = clip[n : n + 1]
+
+        # Attach PlaneStatsDiff property to output frame for threshold calibration
+        return output.std.SetFrameProp(prop="PlaneStatsDiff", floatval=diff)
+
+    # Apply frame selection with lazy evaluation
+    result = clip.std.FrameEval(select_frame)
+
+    return result
+
+
+def decimation_fixer(
+    clip: vs.VideoNode, cycle: int, offset: int = 0, backend: backendT | None = None
+) -> vs.VideoNode:
+    """
+    Attempts to interpolate frames that were removed by bad decimation.
+    Only works with static decimation cycles.
+    `cycle` should be the output cycle, i.e. what did the idiot who decimated this
+    pass into the decimation filter to achieve this monstrosity?
+
+    Yeah, I know, "ThiS is bAd AND yOu shoUldn'T Do IT".
+    Maybe people shouldn't decimate clips that don't need decimation.
+    Sometimes you can't "just get a better source".
+    """
+    import vsmlrt
+
+    if offset >= cycle - 1:
+        raise Exception("offset must be less than cycle - 1")
+    if cycle <= 0:
+        raise Exception("cycle must be greater than zero")
+
+    width = clip.width
+    height = clip.height
+    fps = clip.fps
+    format = clip.format
+    input_cycle = cycle - 1
+    matrix = vstools.Matrix.from_video(clip)
+    transfer = vstools.Transfer.from_video(clip)
+    primaries = vstools.Primaries.from_video(clip)
+    clip = clip.misc.SCDetect()
+    clip = clip.resize.Bicubic(
+        format=vs.RGBS,
+        width=next_multiple_of(64, width),
+        height=next_multiple_of(64, height),
+    )
+    doubled = vsmlrt.RIFE(
+        clip,
+        model=vsmlrt.RIFEModel.v4_25_heavy,
+        backend=(backend if backend else autoselect_backend()),
+    )
+
+    out_clip = None
+    # This is the frame after our insertion point
+    src_frame = offset
+    last_src_frame = 0
+    # This is the frame we want to grab from the doubled clip
+    doub_frame = offset * 2 - 1
+    while src_frame < clip.num_frames:
+        if src_frame > 0:
+            interp = doubled[doub_frame]
+            if out_clip is None:
+                out_clip = clip[last_src_frame:src_frame] + interp
+            else:
+                out_clip = out_clip + clip[last_src_frame:src_frame] + interp
+        last_src_frame = src_frame
+        src_frame += input_cycle
+        doub_frame += input_cycle * 2
+    out_clip += clip[last_src_frame:]
+    out_clip = out_clip.std.AssumeFPS(
+        fpsnum=fps.numerator * cycle // input_cycle, fpsden=fps.denominator
+    )
+
+    out_clip = out_clip.resize.Bicubic(
+        format=format,
+        width=width,
+        height=height,
+        matrix=matrix,
+        transfer=transfer,
+        primaries=primaries,
+    )
+    return out_clip
+
+
+def next_multiple_of(multiple: int, param: int) -> int:
+    rem = param % multiple
+    if rem == 0:
+        return param
+    return param + (multiple - rem)

soifunc-0.14.0/soifunc/resize.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from vsaa.deinterlacers import NNEDI3
+from vskernels import Hermite, LeftShift, Spline36, TopShift
+from vsscale import ArtCNN
+from vstools import (
+    VariableFormatError,
+    check_variable_format,
+    is_gpu_available,
+    join,
+    vs,
+)
+
+__all__ = [
+    "good_resize",
+]
+
+
+def good_resize(
+    clip: vs.VideoNode,
+    width: int,
+    height: int,
+    shift: tuple[TopShift | list[TopShift], LeftShift | list[LeftShift]] = (0, 0),
+    gpu: bool | None = None,
+    anime: bool = False,
+) -> vs.VideoNode:
+    """High quality resizing filter
+
+    Parameters
+    ----------
+    clip: VideoNode
+        Video clip to apply resizing to.
+    width: int
+        Target width to resize to.
+    height: int
+        Target height to resize to.
+    shift: tuple[float, float], optional
+        Horizontal and vertical amount of shift to apply.
+    gpu: bool, optional
+        Whether to allow usage of GPU for ArtCNN.
+        Defaults to None, which will auto-select based on available mlrt and hardware.
+    anime: bool, optional
+        Enables scalers that are better tuned toward anime.
+        Defaults to False.
+    """
+
+    if gpu is None:
+        gpu = is_gpu_available()
+
+    is_upscale = clip.width < width or clip.height < height
+    chroma_scaler = Spline36()
+
+    # We've ended up where the only special case is anime + upscale + GPU enabled
+    if anime and is_upscale and gpu:
+        luma_scaler = ArtCNN(scaler=Hermite(sigmoid=True))
+    elif is_upscale:
+        luma_scaler = NNEDI3(scaler=Hermite(sigmoid=True))
+    else:
+        luma_scaler = Hermite(sigmoid=True)
+
+    if not check_variable_format(clip, "good_resize"):
+        raise VariableFormatError("Invalid clip format for good_resize")
+
+    luma = luma_scaler.scale(clip, width, height, shift)
+
+    # Grayscale doesn't need chroma processing
+    if clip.format.num_planes == 1:
+        return luma
+
+    chroma = chroma_scaler.scale(clip, width, height, shift)
+
+    return join(luma, chroma)

soifunc-0.11.3/soifunc/deband.py

@@ -1,46 +0,0 @@
-from __future__ import annotations
-
-from vsdeband import f3k_deband
-from vsmasktools import dre_edgemask
-from vstools import InvalidVideoFormatError, check_variable, core, vs
-
-__all__ = [
-    "retinex_deband",
-]
-
-
-def retinex_deband(
-    clip: vs.VideoNode,
-    threshold: int,
-    showmask: bool = False,
-) -> vs.VideoNode:
-    """
-    Debanding using a contrast-adaptive edge mask to preserve details
-    even in dark areas.
-    
-    "medium" `threshold` in f3kdb is 48. I think that's a bit strong.
-    16 might be a more sane starting point. Increase as needed.
-
-    This function does not add grain on its own. Use another function like
-    `vsdeband.AddNoise` to do that.
-    """
-    assert check_variable(clip, retinex_deband)
-
-    if (
-        clip.format.color_family != vs.YUV
-        or clip.format.sample_type != vs.INTEGER
-        or clip.format.bits_per_sample > 16
-    ):
-        raise InvalidVideoFormatError(
-            retinex_deband,
-            clip.format,
-            "The format {format.name} is not supported! It must be an 8-16bit integer YUV bit format!",
-        )
-
-    mask = dre_edgemask.CLAHE(clip)
-
-    if showmask:
-        return mask
-
-    deband = f3k_deband(clip, thr=(threshold << 2))
-    return core.std.MaskedMerge(deband, clip, mask)

soifunc-0.11.3/soifunc/interpolate.py

@@ -1,134 +0,0 @@
-from __future__ import annotations
-
-import platform
-from typing import TYPE_CHECKING
-
-import vstools
-from vsscale import autoselect_backend
-from vstools import vs
-
-if TYPE_CHECKING:
-    from vsmlrt import backendT
-
-__all__ = ["rate_doubler", "decimation_fixer"]
-
-
-def rate_doubler(
-    clip: vs.VideoNode, multi: int = 2, backend: backendT | None = None
-) -> vs.VideoNode:
-    """
-    A utility to scale the framerate of a video via frame interpolation.
-
-    Probably shouldn't just go spraying this everywhere,
-    it's more for fun and science than anything.
-    """
-    import vsmlrt
-
-    width = clip.width
-    height = clip.height
-    matrix = vstools.Matrix.from_video(clip)
-    transfer = vstools.Transfer.from_video(clip)
-    primaries = vstools.Primaries.from_video(clip)
-    clip = clip.misc.SCDetect()
-    clip = clip.resize.Bicubic(
-        format=vs.RGBS,
-        width=next_multiple_of(64, width),
-        height=next_multiple_of(64, height),
-    )
-    clip = vsmlrt.RIFE(
-        clip,
-        multi=multi,
-        model=vsmlrt.RIFEModel.v4_25_heavy,
-        # Why these defaults? Because running ML stuff on AMD on Windows sucks hard.
-        # Trial and error led me to finally find that ORT_DML works.
-        backend=(backend if backend else autoselect_backend()),
-    )
-    # TODO: Handle other chroma samplings
-    clip = clip.resize.Bicubic(
-        format=vs.YUV420P16,
-        width=width,
-        height=height,
-        matrix=matrix,
-        transfer=transfer,
-        primaries=primaries,
-    )
-    return clip
-
-
-def decimation_fixer(
-    clip: vs.VideoNode, cycle: int, offset: int = 0, backend: backendT | None = None
-) -> vs.VideoNode:
-    """
-    Attempts to interpolate frames that were removed by bad decimation.
-    Only works with static decimation cycles.
-    `cycle` should be the output cycle, i.e. what did the idiot who decimated this
-    pass into the decimation filter to achieve this monstrosity?
-
-    Yeah, I know, "ThiS is bAd AND yOu shoUldn'T Do IT".
-    Maybe people shouldn't decimate clips that don't need decimation.
-    Sometimes you can't "just get a better source".
-    """
-    import vsmlrt
-
-    if offset >= cycle - 1:
-        raise Exception("offset must be less than cycle - 1")
-    if cycle <= 0:
-        raise Exception("cycle must be greater than zero")
-
-    width = clip.width
-    height = clip.height
-    fps = clip.fps
-    input_cycle = cycle - 1
-    matrix = vstools.Matrix.from_video(clip)
-    transfer = vstools.Transfer.from_video(clip)
-    primaries = vstools.Primaries.from_video(clip)
-    clip = clip.misc.SCDetect()
-    clip = clip.resize.Bicubic(
-        format=vs.RGBS,
-        width=next_multiple_of(64, width),
-        height=next_multiple_of(64, height),
-    )
-    doubled = vsmlrt.RIFE(
-        clip,
-        model=vsmlrt.RIFEModel.v4_25_heavy,
-        backend=(backend if backend else autoselect_backend()),
-    )
-
-    out_clip = None
-    # This is the frame after our insertion point
-    src_frame = offset
-    last_src_frame = 0
-    # This is the frame we want to grab from the doubled clip
-    doub_frame = offset * 2 - 1
-    while src_frame < clip.num_frames:
-        if src_frame > 0:
-            interp = doubled[doub_frame]
-            if out_clip is None:
-                out_clip = clip[last_src_frame:src_frame] + interp
-            else:
-                out_clip = out_clip + clip[last_src_frame:src_frame] + interp
-        last_src_frame = src_frame
-        src_frame += input_cycle
-        doub_frame += input_cycle * 2
-    out_clip += clip[last_src_frame:]
-    out_clip = out_clip.std.AssumeFPS(
-        fpsnum=fps.numerator * cycle // input_cycle, fpsden=fps.denominator
-    )
-
-    # TODO: Handle other chroma samplings
-    out_clip = out_clip.resize.Bicubic(
-        format=vs.YUV420P16,
-        width=width,
-        height=height,
-        matrix=matrix,
-        transfer=transfer,
-        primaries=primaries,
-    )
-    return out_clip
-
-
-def next_multiple_of(multiple: int, param: int) -> int:
-    rem = param % multiple
-    if rem == 0:
-        return param
-    return param + (multiple - rem)

soifunc-0.11.3/soifunc/resize.py

@@ -1,112 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from inspect import getfullargspec
-from typing import Any
-
-from vsaa.deinterlacers import NNEDI3
-from vskernels import (
-    Hermite,
-    Scaler,
-    ScalerLike,
-    Spline36,
-)
-from vsscale import ArtCNN, GenericScaler
-from vstools import check_variable_format, inject_self, is_gpu_available, join, vs
-
-__all__ = [
-    "good_resize",
-    "HybridScaler",
-]
-
-
-def good_resize(
-    clip: vs.VideoNode,
-    width: int,
-    height: int,
-    shift: tuple[float, float] = (0, 0),
-    gpu: bool | None = None,
-    anime: bool = False,
-) -> vs.VideoNode:
-    """High quality resizing filter
-
-    Parameters
-    ----------
-    clip: VideoNode
-        Video clip to apply resizing to.
-    width: int
-        Target width to resize to.
-    height: int
-        Target height to resize to.
-    shift: tuple[float, float], optional
-        Horizontal and vertical amount of shift to apply.
-    gpu: bool, optional
-        Whether to allow usage of GPU for ArtCNN.
-        Defaults to None, which will auto-select based on available mlrt and hardware.
-    anime: bool, optional
-        Enables scalers that are better tuned toward anime.
-        Defaults to False.
-    """
-
-    if gpu is None:
-        gpu = is_gpu_available()
-
-    is_upscale = clip.width < width or clip.height < height
-    chroma_scaler = Spline36()
-
-    # We've ended up where the only special case is anime + upscale + GPU enabled
-    if anime and is_upscale and gpu:
-        luma_scaler = ArtCNN(scaler=Hermite(sigmoid=True))
-    elif is_upscale:
-        luma_scaler = NNEDI3(scaler=Hermite(sigmoid=True))
-    else:
-        luma_scaler = Hermite(sigmoid=True)
-
-    return HybridScaler(luma_scaler, chroma_scaler).scale(
-        clip, width, height, shift=shift
-    )
-
-
-@dataclass
-class HybridScaler(GenericScaler):
-    luma_scaler: ScalerLike
-    chroma_scaler: ScalerLike
-
-    def __post_init__(self) -> None:
-        super().__post_init__()
-
-        self._luma = Scaler.ensure_obj(self.luma_scaler)
-        self._chroma = Scaler.ensure_obj(self.chroma_scaler)
-
-    @Scaler.cached_property
-    def kernel_radius(self) -> int:
-        return self._luma.kernel_radius
-
-    def scale(  # type:ignore
-        self,
-        clip: vs.VideoNode,
-        width: int,
-        height: int,
-        shift: tuple[float, float] = (0, 0),
-        **kwargs: Any,
-    ) -> vs.VideoNode:
-        assert check_variable_format(clip, self.__class__)
-
-        luma = self._luma.scale(clip, width, height, shift, **kwargs)
-
-        if clip.format.num_planes == 1:
-            return luma
-
-        chroma = self._chroma.scale(clip, width, height, shift, **kwargs)
-
-        return join(luma, chroma)
-
-
-def _get_scaler(scaler: ScalerLike, **kwargs: Any) -> Scaler:
-    scaler_cls = Scaler.from_param(scaler, _get_scaler)
-
-    args = getfullargspec(scaler_cls).args
-
-    clean_kwargs = {key: value for key, value in kwargs.items() if key in args}
-
-    return scaler_cls(**clean_kwargs)