vsavd 0.4.0__py3-none-win_amd64.whl

vsavd/__init__.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from . import _plugin
+from ._types import Accelerators, ChannelMode, Preset
+
+if TYPE_CHECKING:
+    # vapoursynth ships a vapoursynth.pyi stub but no py.typed marker, so mypy
+    # refuses to read it. The `ignore_missing_imports` override in pyproject.toml
+    # covers both that and the case where the package is absent entirely.
+    import vapoursynth as vs
+
+__all__ = ["Nlm", "NlmHQ", "Nl4d", "Preset", "ChannelMode"]
+
+
+def _nlmeans_filter() -> "vs.Function":
+    """Returns the bound `avd.NLMeans` plugin function, loading the plugin first."""
+    import vapoursynth as vs
+
+    core = vs.core
+    _plugin.ensure_loaded(core)
+    return core.avd.NLMeans
+
+
+def _nl4d_filter() -> "vs.Function":
+    """Returns the bound `avd.NL4D` plugin function, loading the plugin first."""
+    import vapoursynth as vs
+
+    core = vs.core
+    _plugin.ensure_loaded(core)
+    return core.avd.NL4D
+
+
+def _forward(fn: "vs.Function", clip: "vs.VideoNode", /, **params: Any) -> "vs.VideoNode":
+    """Calls `fn` with only the parameters the caller actually set."""
+    return fn(clip, **{k: v for k, v in params.items() if v is not None})
+
+
+def Nlm(
+    clip: "vs.VideoNode",
+    *,
+    preset: Preset | None = None,
+    channel_mode: ChannelMode | None = None,
+    device: str | None = None,
+    strength: float | None = None,
+    luma_strength: float | None = None,
+    chroma_strength: float | None = None,
+    motion_compensation: bool | None = None,
+    accelerators: list[Accelerators] | None = None,
+    **kwargs: Any,
+) -> "vs.VideoNode":
+    """
+    Runs the NLMeans denoiser.
+
+    `Nlm` is the regular NLMeans algorithm as originally defined in the paper.
+    See https://github.com/ChillFish8/av-denoise/docs/CHOOSING_AN_ALGORITHM.md for working
+    out what algorithm is right for you.
+
+    Args:
+        clip: The input video node to denoise.
+        preset: Preset name. Unset dials fall back to whatever the av-denoise binary defaults to.
+        channel_mode: Which planes to filter, one of `"luma"`, `"chroma"`, `"lumachroma"` or `"yuv"`.
+        device: Compute device to run on. `"cpu"` selects a software device where the platform offers one,
+            useful for testing, not for real encodes. Example: `"discrete:0"` for discrete GPU 0.
+        strength: Overall filter strength. Mirrors FFmpeg's scaling.
+        luma_strength: Strength override for the luma plane. Mirrors FFmpeg's scaling.
+        chroma_strength: Strength override for the chroma planes. Mirrors FFmpeg's scaling.
+        motion_compensation: Whether to motion-compensate neighbour frames before matching.
+        accelerators: The accelerators to try and use in the order to attempt.
+        **kwargs: Further parameters reachable by name. Not recommended
+
+    Returns:
+        A new `vs.VideoNode` holding the denoised clip.
+
+    Raises:
+        vs.Error: If a parameter that does not apply to the fast variant is passed, or if the clip's format
+            is not supported.
+    """
+
+    accelerators_string: str | None = None
+    if accelerators is not None:
+        accelerators_string = ",".join(accelerators)
+
+    return _forward(
+        _nlmeans_filter(),
+        clip,
+        variant="fast",
+        preset=preset,
+        channel_mode=channel_mode,
+        device=device,
+        strength=strength,
+        luma_strength=luma_strength,
+        chroma_strength=chroma_strength,
+        motion_compensation=motion_compensation,
+        accelerators=accelerators_string,
+        **kwargs,
+    )
+
+
+def NlmHQ(
+    clip: "vs.VideoNode",
+    *,
+    preset: Preset | None = None,
+    channel_mode: ChannelMode | None = None,
+    device: str | None = None,
+    sigma_scale: float | None = None,
+    strength: float | None = None,
+    luma_strength: float | None = None,
+    chroma_strength: float | None = None,
+    motion_compensation: bool | None = None,
+    accelerators: list[Accelerators] | None = None,
+    **kwargs: Any,
+) -> "vs.VideoNode":
+    """
+    Runs the NLMeans-HQ denoiser.
+
+    `NlmHQ` measures the noise level per scene and uses that to drive filtering.
+    See https://github.com/ChillFish8/av-denoise/docs/CHOOSING_AN_ALGORITHM.md for working
+    out what algorithm is right for you.
+
+    Args:
+        clip: The input video node to denoise.
+        preset: Preset name. Unset dials fall back to whatever the av-denoise binary defaults to.
+        channel_mode: Which planes to filter, one of `"luma"`, `"chroma"`, `"lumachroma"` or `"yuv"`.
+        device: Compute device to run on. `"cpu"` selects a software device where the platform offers one,
+            useful for testing, not for real encodes. Example: `"discrete:0"` for discrete GPU 0.
+        sigma_scale: Multiplier nudging the measured noise level up or down.
+            This is the right dial to reach for when leftover grain survives filtering,
+            rather than raising `strength`.
+        strength: Overall filter strength. Raising this to fight leftover grain is the wrong move, grain
+            that survives usually means the noise level read low, correcting `sigma_scale` is the right
+            move instead.
+        luma_strength: Strength override for the luma plane.
+        chroma_strength: Strength override for the chroma planes.
+        motion_compensation: Whether to motion-compensate neighbour frames before matching.
+        accelerators: The accelerators to try and use in the order to attempt.
+        **kwargs: Further parameters reachable by name, documented in the
+            `av-denoise` CLI documentation under their flag names.
+
+    Returns:
+        A new `vs.VideoNode` holding the denoised clip.
+
+    Raises:
+        vs.Error: If a parameter that does not apply to the hq variant is
+            passed, or if the clip's format is not supported.
+    """
+
+    accelerators_string: str | None = None
+    if accelerators is not None:
+        accelerators_string = ",".join(accelerators)
+
+    return _forward(
+        _nlmeans_filter(),
+        clip,
+        variant="hq",
+        preset=preset,
+        channel_mode=channel_mode,
+        device=device,
+        sigma_scale=sigma_scale,
+        strength=strength,
+        luma_strength=luma_strength,
+        chroma_strength=chroma_strength,
+        motion_compensation=motion_compensation,
+        accelerators=accelerators_string,
+        **kwargs,
+    )
+
+
+def Nl4d(
+    clip: "vs.VideoNode",
+    *,
+    preset: Preset | None = None,
+    channel_mode: ChannelMode | None = None,
+    device: str | None = None,
+    lambda_ht_scale: float | None = None,
+    lambda_ht: float | None = None,
+    sigma_scale: float | None = None,
+    spatial_radius: int | None = None,
+    refine: int | None = None,
+    accelerators: list[Accelerators] | None = None,
+    **kwargs: Any,
+) -> "vs.VideoNode":
+    """
+    Runs the NL4D spatio-temporal denoiser.
+
+    See https://github.com/ChillFish8/av-denoise/docs/CHOOSING_AN_ALGORITHM.md for working
+    out what algorithm is right for you.
+
+    Args:
+        clip: The input video node to denoise.
+        preset: Preset name. Unset dials fall back to whatever the av-denoise binary defaults to.
+        channel_mode: Which planes to filter, one of `"luma"`, `"chroma"`, `"lumachroma"` or `"yuv"`.
+        device: Compute device to run on. `"cpu"` selects a software device where the platform offers one,
+            useful for testing, not for real encodes. Example: `"discrete:0"` for discrete GPU 0.
+        lambda_ht_scale: Threshold multiplier a transform coefficient's estimated-noise standard deviations
+            must clear to survive. This  is the main dial, raising it removes more noise and takes more
+            fine detail with it. Try it in steps of about 0.05.
+        lambda_ht: Pins luma and chroma's thresholds to the same absolute number instead of
+            their separate defaults, losing that separation. Prefer `lambda_ht_scale` first.
+        sigma_scale: Multiplier nudging the measured noise level up or down, keeping the per-scene
+            measurement rather than pinning it.
+        spatial_radius: The speed dial. `preset` already resolves it, so setting this explicitly overrides
+            whatever the preset picked. The centre-frame search covers `(2 * radius + 1)^2` positions,
+            so it dominates the work, lowering it is the fastest way to speed a run-up.
+        refine: Half-width of the window searched around each neighbour frame's motion-predicted position.
+            Raise it when motion tracking lands close but not exact.
+        accelerators: The accelerators to try and use in the order to attempt.
+        **kwargs: Further parameters reachable by name, documented in the
+            `av-denoise` CLI documentation under their flag names.
+
+    Returns:
+        A new `vs.VideoNode` holding the denoised clip.
+
+    Raises:
+        vs.Error: If a parameter that does not apply to this filter is
+            passed, or if the clip's format is not supported.
+    """
+
+    accelerators_string: str | None = None
+    if accelerators is not None:
+        accelerators_string = ",".join(accelerators)
+
+    return _forward(
+        _nl4d_filter(),
+        clip,
+        preset=preset,
+        channel_mode=channel_mode,
+        device=device,
+        lambda_ht_scale=lambda_ht_scale,
+        lambda_ht=lambda_ht,
+        sigma_scale=sigma_scale,
+        spatial_radius=spatial_radius,
+        refine=refine,
+        accelerators=accelerators_string,
+        **kwargs,
+    )

vsavd/_plugin.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import pathlib
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # vapoursynth ships a vapoursynth.pyi stub but no py.typed marker, so mypy
+    # refuses to read it. The `ignore_missing_imports` override in pyproject.toml
+    # covers both that and the case where the package is absent entirely.
+    import vapoursynth as vs
+
+_NAMESPACE = "avd"
+_ARTEFACT_GLOB = "_avdenoise_vs*"
+# setuptools-rust names the artefact with the platform's Python extension suffix,
+# which on Windows is `.pyd` rather than `.dll`. `.dll` and `.dylib` stay for a
+# plugin built by hand and copied into a source checkout.
+_ARTEFACT_SUFFIXES = (".so", ".dll", ".dylib", ".pyd")
+
+
+def plugin_path() -> pathlib.Path:
+    """
+    The bundled plugin's absolute path.
+
+    setuptools-rust names the compiled artefact after the ext-module target
+    and picks its suffix based on whether the extension opted into the
+    limited API, so this helper globs for it instead of matching one fixed name.
+    """
+    here = pathlib.Path(__file__).parent
+    candidates = sorted(p for p in here.glob(_ARTEFACT_GLOB) if p.suffix in _ARTEFACT_SUFFIXES)
+    if not candidates:
+        raise RuntimeError(
+            f"no bundled av-denoise plugin found in {here}. "
+            "A source checkout needs the plugin built and copied in, which the wheel does at build time."
+        )
+    if len(candidates) > 1:
+        joined = ", ".join(str(c) for c in candidates)
+        raise RuntimeError(
+            f"multiple candidate av-denoise plugin artefacts found in {here}: {joined}. "
+            "Remove the stale build output and rebuild the wheel."
+        )
+    return candidates[0]
+
+
+def ensure_loaded(core: "vs.Core") -> None:
+    """Registers the plugin with `core` unless it is already there."""
+    if any(p.namespace == _NAMESPACE for p in core.plugins()):
+        return
+    core.std.LoadPlugin(str(plugin_path()))

vsavd/_types.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from typing import Literal
+
+Preset = Literal["veryfast", "fast", "base", "slow", "veryslow"]
+ChannelMode = Literal["luma", "chroma", "lumachroma", "yuv"]
+Accelerators = Literal["cuda", "vulkan", "rocm", "metal"]

vsavd-0.4.0.dist-info/METADATA

@@ -0,0 +1,248 @@
+Metadata-Version: 2.4
+Name: vsavd
+Version: 0.4.0
+Summary: VapourSynth plugin for av-denoise, with typed Python wrappers.
+Author: ChillFish8
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/ChillFish8/av-denoise
+Project-URL: Repository, https://github.com/ChillFish8/av-denoise
+Project-URL: Issues, https://github.com/ChillFish8/av-denoise/issues
+Keywords: vapoursynth,denoise,video,gpu,nlmeans
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: vapoursynth
+Dynamic: description
+Dynamic: description-content-type
+
+# av-denoise VapourSynth plugin (`vsavd`)
+
+This is the home of [av-denoise](https://github.com/ChillFish8/av-denoise) exposed as a VapourSynth plugin to fit within existing filtering 
+pipelines. With caveats.
+
+We provide typed interfaces for all the [supported algorithms](https://github.com/ChillFish8/av-denoise/blob/HEAD/docs/CHOOSING_AN_ALGORITHM.md): 
+
+- `vsavd.Nl4d(...)` for our best in class _NL4D_ denoiser offering higher quality and more effective denoising over V-BM3D.
+- `vsavd.NlmHQ(...)` for our _NLMeans-HQ_ algorithm which provides a higher quality and smarter denoising experience over base NLMeans.
+- `vsavd.Nlm(...)` for quick and dirt NLMeans mirroring FFmpeg's strength scaling.
+
+_All_ algorithms are temporal aware and have inbuilt motion compensation kernels.
+
+### _Here be dragons!_ 🐉
+
+VapourSynth's API significantly restricts how av-denoise can operate and as a result, can produce a worse
+denoising experience compared to the CLI or direct Rust library usage. Primarily because noise estimation
+cannot be incrementally refined over all frames and instead has to be performed only over the temporal
+window.
+
+Performance is a _best effort_ situation, if you have anything which causes frames to arrive to the filter out of order
+your performance can drop by 70-80%.
+
+
+## Table of contents
+
+- [Installing](#installing)
+- [Choosing an algorithm](#choosing-an-algorithm)
+- [Nl4d](#nl4d)
+- [NlmHQ](#nlmhq-nlmeans-hq)
+- [Nlm](#nlm-nlmeans)
+- [Presets](#presets)
+- [Channel modes](#channel-modes)
+- [Devices and accelerators](#devices-and-accelerators)
+- [Shared conventions](#shared-conventions)
+- [Tuning guide](https://github.com/ChillFish8/av-denoise/blob/HEAD/docs/TUNING-VS.md)
+
+## Installing
+
+Pre-built wheels are available for Linux, macOS and Windows, published to PyPI.
+
+_Please note that the wheels for **Linux** and **Windows** are compiled for `vulkan` and `cuda` only. **macOS** is compiled for `metal`.
+ROCm is not recommended and requires manual compilation._
+
+```bash
+pip install vsavd
+```
+
+or, with `uv`:
+
+```bash
+uv add vsavd
+```
+
+Installing `vsavd` bundles the compiled plugin inside the wheel, so there is nothing else to build or load.
+
+## [Choosing an algorithm](https://github.com/ChillFish8/av-denoise/blob/HEAD/docs/CHOOSING_AN_ALGORITHM.md)
+
+Please have a read of the linked page for info about what each algorithm does and its tradeoffs.
+
+**TL;DR: Use NL4D if you're unsure**
+
+## [_Don't do this!_](https://github.com/ChillFish8/av-denoise/blob/HEAD/docs/DONT_DO_THIS.md)
+
+We recommend reading this before deciding how to integrate this into your existing filtering pipeline
+as some things differ quiet heavily to what you are likely used to.
+
+## [Nl4d](https://github.com/ChillFish8/av-denoise/blob/HEAD/docs/CHOOSING_AN_ALGORITHM.md#nl4d)
+
+`Nl4d` is the spatio-temporal denoiser, wrapping `avd.NL4D`. It gives the best noise
+removal and detail retention of the three, at the cost of time.
+
+```python
+import vapoursynth as vs
+import vsavd as avd
+
+core = vs.core
+clip = core.lsmas.LWLibavSource("noisy.mkv")
+clean = avd.Nl4d(clip)
+clean.set_output()
+```
+
+| Parameter         | Type            | CLI equivalent          | Recommended            |
+|-------------------|-----------------|-------------------------|------------------------|
+| `lambda_ht_scale` | float           | `--lambda-ht-scale`     | yes, the main dial     |
+| `sigma_scale`     | float           | `--sigma-scale`         | yes                    |
+| `preset`          | string          | `--preset`              | yes                    |
+| `refine`          | int             | `--refine`              | yes                    |
+| `spatial_radius`  | int             | `--spatial-radius`      | yes, the speed dial    |
+| `lambda_ht`       | float           | `--lambda-ht`           | situational, see below |
+| `channel_mode`    | string          | channel-mode flags      | situational            |
+| `device`          | string          | `--device`              | situational            |
+| `accelerators`    | list of strings | `-A`, `--accelerators`  | situational            |
+
+`lambda_ht_scale` is the threshold multiplier a transform coefficient's estimated-noise
+standard deviations must clear to survive. Raising it removes more noise and takes more
+fine detail with it. Try it in steps of about 0.05 before reaching for `lambda_ht`,
+which pins luma and chroma's thresholds (5.2 and 3.4 by default, these values have been
+manually tuned to provide the subjectively best image for a given grain strength across
+real clips rather than synthetic benchmarks).
+
+`spatial_radius` is the speed dial. `preset` already resolves it, so setting
+`spatial_radius` explicitly overrides whatever the preset would have picked. The
+centre-frame search covers `(2 * radius + 1)^2` positions, so it dominates the work.
+Dropping it is the fastest way to speed a run up.
+
+`refine` is the half-width of the window searched around each neighbour frame's
+motion-predicted position. Raise it when motion tracking lands close but not exact.
+
+`sigma_scale` keeps the per-scene noise measurement and nudges it, which is almost
+always what you actually want.
+
+## [NlmHQ (NLMeans-HQ)](https://github.com/ChillFish8/av-denoise/blob/HEAD/docs/CHOOSING_AN_ALGORITHM.md#nlmeans-hq-nlmeans-high-quality)
+
+`NlmHQ` is the high-quality NLMeans variant, wrapping `avd.NLMeans` with `variant="hq"`.
+It runs a per-scene noise estimator and reads its result into `sigma_scale` rather than
+leaving noise level to a hand-set `strength`. Use it over `Nlm` when you want the
+estimator to pick the noise level for you.
+
+```python
+import vapoursynth as vs
+import vsavd as avd
+
+core = vs.core
+clip = core.lsmas.LWLibavSource("noisy.mkv")
+clean = avd.NlmHQ(clip)
+clean.set_output()
+```
+
+| Parameter             | Type            | CLI equivalent          | Recommended            |
+|-----------------------|-----------------|-------------------------|------------------------|
+| `preset`              | string          | `--preset`              | yes                    |
+| `motion_compensation` | bool            | `--motion-compensation` | yes                    |
+| `sigma_scale`         | float           | `--hq-sigma-scale`      | yes, the main dial     |
+| `chroma_strength`     | float           | `--chroma-strength`     | yes                    |
+| `channel_mode`        | string          | channel-mode flags      | situational            |
+| `strength`            | float           | `--strength`            | situational, see below |
+| `luma_strength`       | float           | `--luma-strength`       | situational            |
+| `device`              | string          | `--device`              | situational            |
+| `accelerators`        | list of strings | `-A`, `--accelerators`  | situational            |
+
+Raising `strength` to fight leftover grain is the wrong move. Grain that survives means
+the noise level read low, and extra strength scrubs detail before it removes grain.
+Correcting `sigma_scale` instead is the right move.
+
+## [Nlm (NLMeans)](https://github.com/ChillFish8/av-denoise/blob/HEAD/docs/CHOOSING_AN_ALGORITHM.md#nlmeans)
+
+`Nlm` is the fast NLMeans variant, wrapping `avd.NLMeans` with `variant="fast"`. It has no
+noise estimator, so it runs quickly and expects you to set `strength` yourself. Reach for
+it when speed matters more than squeezing out the last bit of noise.
+
+```python
+import vapoursynth as vs
+import vsavd as avd
+
+core = vs.core
+clip = core.lsmas.LWLibavSource("noisy.mkv")
+clean = avd.Nlm(clip, strength=1.2)
+clean.set_output()
+```
+
+| Parameter             | Type            | CLI equivalent          | Recommended |
+|-----------------------|-----------------|-------------------------|-------------|
+| `preset`              | string          | `--preset`              | yes         |
+| `motion_compensation` | bool            | `--motion-compensation` | yes         |
+| `chroma_strength`     | float           | `--chroma-strength`     | yes         |
+| `channel_mode`        | string          | channel-mode flags      | situational |
+| `strength`            | float           | `--strength`            | yes         |
+| `luma_strength`       | float           | `--luma-strength`       | situational |
+| `device`              | string          | `--device`              | situational |
+| `accelerators`        | list of strings | `-A`, `--accelerators`  | situational |
+
+`Nlm` has no noise estimator, so `strength` is the dial that sets the noise level. Use
+`NlmHQ` if you would rather have it measured for you.
+
+## Presets
+
+`preset` is the main quality-versus-speed dial. It takes one of five values, from
+fastest to slowest and best-quality: `veryfast`, `fast`, `base`, `slow`, `veryslow`.
+Each preset resolves every unset numeric and string parameter to a value tuned for that speed tier.
+
+Any parameter you set explicitly overrides what the preset would have chosen for it,
+other fields still fall back to the preset's values. This lets you take a preset as a
+starting point and adjust just the dial you care about, as the examples above do.
+
+> [!TIP]
+> Presets exist to be easy levers to adjust, but you can probably still get the quality you want
+> using the `base` preset on NLMeans-HQ and NL4D by tweaking the `*-scale` parameters.
+
+## Channel modes
+
+`channel_mode` selects which planes get denoised, and takes one of four values:
+
+- `luma` denoises the luma plane only, leaving chroma untouched.
+- `chroma` denoises the chroma planes only, leaving luma untouched.
+- `lumachroma` denoises both, luma and chroma independently.
+- `yuv` denoises luma and chroma together as a single pass. It needs a 4:4:4 source,
+  since it requires the chroma planes to be full resolution.
+
+## Devices and accelerators
+
+`device` is typed on all three functions and selects which GPU device runs the filter.
+`device="cpu"` selects a software device where the platform offers one, such as
+lavapipe under Vulkan. It is for testing the pipeline, not for real encodes.
+
+`accelerators` selects which GPU backend to use, for example `["vulkan"]` or `["cuda"]`. 
+Multiple accelerators can be provided and the system will try each accelerator in the order 
+provided, choosing the first accelerator which can work on the host hardware.
+
+> [!IMPORTANT]
+> You can only use accelerators the plugin was compiled with, for example the wheels for
+> Linux and Windows only support `"vulkan"` and `"cuda"`, requesting `"rocm"` would result
+> in an error.
+
+```python
+clean = avd.Nl4d(clip, preset="slow", accelerators=["cuda", "vulkan"])
+```
+
+## Shared conventions
+
+- Every numeric script argument is optional, an unset one falls back to the algorithm's  own default, or to
+  whatever `preset` resolves for that field.
+- `device` and `accelerators` are unset by default rather than pinned to a literal string.
+
+## [Tuning guide](https://github.com/ChillFish8/av-denoise/blob/HEAD/docs/TUNING-VS.md)
+
+For more information about how to adjust the algorithms to best fit your needs.

vsavd-0.4.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+vsavd/__init__.py,sha256=ZdHvVS4h05MB6k4UsSmyqbl4_uSylxeXlpWenwamtbw,9728
+vsavd/_avdenoise_vs.pyd,sha256=upNucZB2kVFnshSNbrcBlR1a1vumKw4e4dLWa7f_T9U,19316224
+vsavd/_plugin.py,sha256=6jvQi8QvkuTinEtd6jMZ7qpFp1fSHKl7RHYdJDKHF8E,1974
+vsavd/_types.py,sha256=nVnIQLbWKotIe_7r631X3T0Gx8ZBCFLsmNqX0nUobMQ,255
+vsavd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vsavd-0.4.0.dist-info/METADATA,sha256=qBd3jA-41W3kkca1jPt-3fLTRHOm-0IFi44wx8nUQZ0,12040
+vsavd-0.4.0.dist-info/WHEEL,sha256=Zx98gwb_dQKckJK3HEOVKnxxD52EfU_PXDG_usMJ2ng,98
+vsavd-0.4.0.dist-info/top_level.txt,sha256=BHlJose3JtWPZ8c-Jz8vkJkB9dosC1zn74TYRlaSNAg,6
+vsavd-0.4.0.dist-info/RECORD,,

vsavd-0.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+

vsavd-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+vsavd