visfeats 0.1__py3-none-any.whl

visfeats/__init__.py

@@ -0,0 +1,85 @@
+import logging
+from collections.abc import Sequence
+from importlib.util import find_spec
+from typing import Dict, Union
+
+from PIL import Image
+
+from .chromatic import hsv_features
+from .spatial_frequency import spatial_frequency_features
+from .memorability import memorability_resmem
+from .misc import rms
+
+logger = logging.getLogger(__name__)
+
+_FEATURES = {
+    "hsv_features": hsv_features,
+    "spatial_frequency_features": spatial_frequency_features,
+    "rms": rms,
+    "memorability_resmem": memorability_resmem,
+}
+
+__all__ = [
+    "extract_all_features",
+    "spatial_frequency_features",
+    "hsv_features",
+    "rms",
+    "memorability_resmem",
+]
+
+
+def extract_all_features(
+    image: Image.Image,
+    features: Union[str, Sequence[str]] = "all",
+) -> Dict[str, float]:
+    """Extract selected visual features from an image.
+
+    Parameters
+    ----------
+    image : PIL.Image.Image
+        Input image in any Pillow mode.
+    features : str or sequence of str, default="all"
+        ``"all"`` selects every package-level feature. A feature name or
+        sequence of feature names selects only those features. Available
+        names are ``"hsv_features"``, ``"spatial_frequency_features"``,
+                ``"rms"``, and ``"memorability_resmem"``.
+
+    Returns
+    -------
+    dict of {str: float}
+        A flat mapping of feature names to values. Multi-value features
+        contribute their own keys. ``memorability_resmem`` is skipped with a
+        warning if the optional ``resmem`` package is not installed.
+
+    Raises
+    ------
+    ValueError
+        If any requested feature name is not available.
+    """
+    if isinstance(features, str):
+        selected = list(_FEATURES) if features == "all" else [features]
+    else:
+        selected = list(dict.fromkeys(features))
+
+    unknown = set(selected) - _FEATURES.keys()
+    if unknown:
+        names = ", ".join(sorted(unknown))
+        raise ValueError(f"Unknown feature name(s): {names}")
+
+    extracted: Dict[str, float] = {}
+    for name in selected:
+        if name == "memorability_resmem" and find_spec("resmem") is None:
+            logger.warning(
+                "Skipping memorability_resmem because the optional `resmem` "
+                "package is not installed. Install it with: "
+                "pip install 'visfeats[resmem]'"
+            )
+            continue
+
+        result = _FEATURES[name](image)
+        if isinstance(result, dict):
+            extracted.update(result)
+        else:
+            extracted[name] = float(result)
+
+    return extracted

visfeats/chromatic.py

@@ -0,0 +1,60 @@
+from PIL import Image
+from skimage import color
+import numpy as np
+from scipy.stats import circmean, entropy
+
+HSV_RANGE = (0.0, 1.0)
+
+
+def hsv_features(image: Image.Image, bins: int = 100) -> dict:
+    """Compute the mean and entropy of the HSV channels of an image.
+
+    Parameters
+    ----------
+    image : PIL.Image.Image
+        Input image.
+    bins : int, default=100
+        Number of bins for the histograms used to compute entropy.
+
+    Returns
+    -------
+    dict of {str: float}
+        A mapping of feature names to values:
+
+        ==================  ======================================
+        Key                 Description
+        ==================  ======================================
+        hue_mean            Circular mean hue in [0, 1).
+        saturation_mean     Mean saturation in [0, 1].
+        value_mean          Mean value (brightness) in [0, 1].
+        hue_entropy         Entropy of the hue histogram.
+        saturation_entropy  Entropy of the saturation histogram.
+        value_entropy       Entropy of the value histogram.
+        ==================  ======================================
+
+    Notes
+    -----
+    The image is converted to RGB, then to HSV using
+    ``skimage.color.rgb2hsv``. The mean and histogram entropy are computed
+    for each channel.
+    """
+    rgb = image.convert("RGB")
+    array = np.array(rgb)
+    hsv = color.rgb2hsv(array)
+
+    hue = hsv[:, :, 0]
+    saturation = hsv[:, :, 1]
+    value = hsv[:, :, 2]
+
+    hue_pk = np.histogram(hue, bins=bins, range=HSV_RANGE, density=True)
+    saturation_pk = np.histogram(saturation, bins=bins, range=HSV_RANGE, density=True)
+    value_pk = np.histogram(value, bins=bins, range=HSV_RANGE, density=True)
+
+    return {
+        "hue_mean": float(circmean(hue, high=1.0, low=0.0)),  # circular mean of hue
+        "saturation_mean": float(saturation.mean()),
+        "value_mean": float(value.mean()),
+        "hue_entropy": float(entropy(hue_pk[0])),
+        "saturation_entropy": float(entropy(saturation_pk[0])),
+        "value_entropy": float(entropy(value_pk[0])),
+    }

visfeats/memorability.py

@@ -0,0 +1,52 @@
+from functools import lru_cache
+
+from PIL import Image
+
+
+@lru_cache(maxsize=1)
+def _load_resmem():
+    # Import within function so resmem/torch load only when needed.
+    try:
+        from resmem import ResMem, transformer
+    except ImportError as error:
+        raise ImportError(
+            "memorability_resmem requires the optional dependency `resmem`. "
+            "Install it with: pip install resmem"
+        ) from error
+
+    model = ResMem(pretrained=True)
+    model.eval()
+    return model, transformer
+
+
+def memorability_resmem(image: Image.Image) -> float:
+    """Estimate the intrinsic memorability of an image.
+
+    The image is converted to RGB, preprocessed with the ResMem transformer
+    (resized to 227 x 227 and normalized), and passed through the pretrained
+    ResMem network, a residual neural network trained to predict human
+    memorability scores (Needell and Bainbridge, 2022). The model is loaded
+    once per process and reused across calls.
+
+    Parameters
+    ----------
+    image : PIL.Image.Image
+        Input image in any Pillow mode; converted to RGB internally.
+
+    Returns
+    -------
+    float
+        Predicted memorability score in [0, 1]; higher values indicate a
+        more memorable image.
+
+    References
+    ----------
+    .. [1] Needell, C. D., & Bainbridge, W. A. (2022).
+        Embracing new techniques in deep learning for estimating image memorability.
+        Computational Brain & Behavior. https://doi.org/10.1007/s42113-022-00126-5
+    """
+    model, transformer = _load_resmem()
+    image = image.convert("RGB")
+    image_x = transformer(image)
+    prediction = model(image_x.view(-1, 3, 227, 227))
+    return float(prediction.detach().numpy().squeeze())

visfeats/misc.py

@@ -0,0 +1,23 @@
+import numpy as np
+from PIL import Image
+
+
+def rms(image: Image.Image) -> float:
+    """Compute the root-mean-square (RMS) contrast of an image.
+
+    The image is converted to 8-bit grayscale and the RMS contrast is the
+    population standard deviation of the pixel intensities (values in
+    [0, 255]).
+
+    Parameters
+    ----------
+    image : PIL.Image.Image
+        Input image in any Pillow mode; converted to grayscale internally.
+
+    Returns
+    -------
+    float
+        RMS contrast. 0 for a uniform image; 127.5 is the maximum.
+    """
+    grayscale = image.convert("L")
+    return float(np.array(grayscale).std())

visfeats/spatial_frequency.py

@@ -0,0 +1,272 @@
+from typing import Dict, Tuple
+
+import numpy as np
+from PIL import Image
+from scipy import fft
+
+
+def _pad_and_resize_image(
+    image: Image.Image,
+    size: int = 1024,
+    pad: bool = True,
+) -> np.ndarray:
+    """Convert to grayscale, optionally pad to a square, then resize to ``size``."""
+    grayscale = np.asarray(image.convert("L"), dtype=np.float64)
+
+    if pad:
+        height, width = grayscale.shape
+
+        # Redies et al. pad using a uniform border at the image mean gray value.
+        side = max(height, width)
+        padded = np.full((side, side), grayscale.mean(), dtype=np.float64)
+
+        y0 = (side - height) // 2
+        x0 = (side - width) // 2
+        padded[y0 : y0 + height, x0 : x0 + width] = grayscale
+        grayscale = padded
+
+    # Pillow's F mode is float32; it preserves fractional values during bicubic
+    # resize (passing float64 with mode="F" would misread the buffer).
+    resized = Image.fromarray(grayscale.astype(np.float32), mode="F").resize(
+        (size, size),
+        resample=Image.Resampling.BICUBIC,
+    )
+
+    return np.asarray(resized, dtype=np.float64)
+
+
+def _centered_power_spectrum(
+    grayscale: np.ndarray,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Return the centered 2D power spectrum and its (fy, fx) frequency grids."""
+    height, width = grayscale.shape
+    if height != width:
+        raise ValueError("Expected a square image.")
+
+    spectrum = fft.fftshift(fft.fft2(grayscale))
+    power = np.abs(spectrum) ** 2
+
+    # Frequencies expressed in cycles per image, rather than cycles/pixel.
+    # For a 1024-pixel image, values span roughly -512 to +511 cycles/image.
+    frequencies = fft.fftshift(fft.fftfreq(height)) * height
+    fy, fx = np.meshgrid(frequencies, frequencies, indexing="ij")
+
+    return power, fy, fx
+
+
+def _radially_averaged_power_spectrum(
+    grayscale: np.ndarray,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Return radial spatial frequencies and mean power for a square image."""
+    power, fy, fx = _centered_power_spectrum(grayscale)
+    radius = np.hypot(fx, fy)
+
+    # Annular radial bins: 0-1, 1-2, 2-3 ... cycles/image.
+    radial_index = np.floor(radius).astype(np.intp)
+    max_radius = radial_index.max()
+
+    power_sum = np.bincount(
+        radial_index.ravel(),
+        weights=power.ravel(),
+        minlength=max_radius + 1,
+    )
+    sample_count = np.bincount(
+        radial_index.ravel(),
+        minlength=max_radius + 1,
+    )
+
+    radial_power = np.divide(
+        power_sum,
+        sample_count,
+        out=np.zeros_like(power_sum, dtype=np.float64),
+        where=sample_count > 0,
+    )
+
+    radial_frequency = np.arange(max_radius + 1, dtype=np.float64)
+
+    return radial_frequency, radial_power
+
+
+def _spectral_centroid_and_variance(grayscale: np.ndarray) -> Tuple[float, float]:
+    """Return the power-weighted mean frequency and orientation circular variance."""
+    power, fy, fx = _centered_power_spectrum(grayscale)
+
+    # Exclude DC: it carries the mean luminance and has no defined orientation.
+    nonzero = np.hypot(fx, fy) > 0
+    power = power[nonzero]
+    radius = np.hypot(fx, fy)[nonzero]
+    angle = np.arctan2(fy, fx)[nonzero]
+
+    total_power = power.sum()
+    if total_power == 0:
+        raise ValueError("Total power of the Fourier spectrum is zero.")
+
+    centroid = (radius * power).sum() / total_power
+
+    # Orientation is axial (theta and theta + pi are equivalent in a
+    # real-valued image's spectrum), so angles are doubled before averaging.
+    resultant = np.abs((power * np.exp(2j * angle)).sum()) / total_power
+
+    return float(centroid), float(1.0 - resultant)
+
+
+def _dimensionality(power: np.ndarray) -> float:
+    """Slope of log magnitude versus log rank of the radially averaged spectrum."""
+    # Skip the DC bin; rank all remaining components by magnitude.
+    magnitude = np.sqrt(power[1:])
+    magnitude = magnitude[magnitude > 0]
+    if magnitude.size < 2:
+        raise ValueError("At least two non-zero Fourier components are required.")
+
+    ranked = np.sort(magnitude)[::-1]
+    ranks = np.arange(1, ranked.size + 1)
+    return float(np.polyfit(np.log10(ranks), np.log10(ranked), deg=1)[0])
+
+
+def spatial_frequency_features(
+    image: Image.Image,
+    size: int = 1024,
+    min_frequency: float = 10.0,
+    max_frequency: float = 256.0,
+    log_bins: int = 17,
+    pad: bool = True,
+) -> Dict[str, float]:
+    """
+    Calculate Fourier slope, Fourier sigma, dimensionality, spectral centroid,
+    and spectral variance of an image.
+
+    All are derived from the Fourier power spectrum of the grayscale image.
+
+    Parameters
+    ----------
+    image : PIL.Image.Image
+        Input image.
+    size : int, default=1024
+        Square analysis resolution.
+    min_frequency : float, default=10.0
+        Lowest fitted radial spatial frequency, in cycles/image.
+    max_frequency : float, default=256.0
+        Highest fitted radial spatial frequency, in cycles/image.
+    log_bins : int, default=17
+        Number of log-spaced frequency bins used before fitting [2]_.
+    pad : bool, default=True
+        Whether to pad non-square images to a square with the mean gray value
+        before resizing. If False, the image is resized directly to
+        ``size`` x ``size``, which distorts the aspect ratio of non-square
+        images.
+
+    Returns
+    -------
+    dict
+        ====================  ==============================================
+        Key                   Description
+        ====================  ==============================================
+        ``fourier_slope``     Slope of log power versus log frequency
+                              (about -2 for natural scenes and many
+                              artworks).
+        ``fourier_sigma``     Mean squared residual of the binned data
+                              around the fitted line.
+        ``dimensionality``    Slope of log magnitude versus log rank of the
+                              ranked spectrum (see Notes).
+        ``spectral_centroid`` Power-weighted mean spatial frequency, in
+                              cycles/image.
+        ``spectral_variance`` Circular variance of the power spectrum over
+                              orientation, in [0, 1] (see Notes).
+        ====================  ==============================================
+
+    Notes
+    -----
+    1. Convert to grayscale, optionally (``pad``) pad to a square with the
+       mean gray value, and resize to ``size`` by bicubic interpolation [1]_.
+    2. Compute the 2D power spectrum and average it in annular bins of
+       1 cycle/image.
+    3. ``fourier_slope`` and ``fourier_sigma``: keep bins between
+       ``min_frequency`` and ``max_frequency``, average log power and log
+       frequency within ``log_bins`` log-spaced bins, and fit a least-squares
+       line. The slope is ``fourier_slope``; the mean squared residual is
+       ``fourier_sigma`` [2]_.
+    4. ``dimensionality``: using all bins except DC (no frequency
+       restriction), rank the magnitudes (square root of power) from largest
+       to smallest and fit a line to log magnitude versus log rank [3]_.
+    5. ``spectral_centroid``: using the full 2D power spectrum without DC,
+       the mean radial frequency weighted by power (center of mass).
+    6. ``spectral_variance``: circular variance, ``1 - R``, of the spectral
+       orientation weighted by power, where ``R`` is the length of the
+       power-weighted mean resultant vector of the doubled orientation angles
+       (the spectrum is point-symmetric). 0 means all power lies along one
+       orientation; 1 means power is spread evenly across orientations.
+
+    .. [1] Redies, C., Grebenkina, M., Mohseni, M., Kaduhm, A., & Dobel, C. (2020).
+       Global Image Properties Predict Ratings of Affective Pictures. Frontiers in Psychology, 11.
+       https://doi.org/10.3389/fpsyg.2020.00953
+    .. [2] Redies, C., Hasenstein, J., & Denzler, J. (2008).
+       Fractal-like image statistics in visual art: Similarity to natural scenes. Spatial Vision, 21(1–2), 137–148.
+       https://doi.org/10.1163/156856807782753921
+    .. [3] Uran, C., Peter, A., Lazar, A., Barnes, W., Klon-Lipok, J., Shapcott, K. A., Roese, R.,
+       Fries, P., Singer, W., & Vinck, M. (2022).
+       Predictive coding of natural images by V1 firing rates and rhythmic synchronization. Neuron, 110(7),
+       1240-1257.e8. https://doi.org/10.1016/j.neuron.2022.01.002
+    """
+    grayscale = _pad_and_resize_image(image, size=size, pad=pad)
+    frequency, power = _radially_averaged_power_spectrum(grayscale)
+    dimensionality = _dimensionality(power)
+    centroid, variance = _spectral_centroid_and_variance(grayscale)
+    # Exclude DC (0 cycles/image) and restrict to the published fit range.
+    valid = (
+        (frequency >= min_frequency)
+        & (frequency <= max_frequency)
+        & (power > 0)
+        & np.isfinite(power)
+    )
+
+    frequency = frequency[valid]
+    power = power[valid]
+
+    if frequency.size < 2:
+        raise ValueError("Not enough valid Fourier frequencies to fit a line.")
+
+    log_frequency = np.log10(frequency)
+    log_power = np.log10(power)
+
+    # Equally spaced bins in log-frequency space.
+    edges = np.linspace(
+        np.log10(min_frequency),
+        np.log10(max_frequency),
+        log_bins + 1,
+    )
+    bin_index = np.digitize(log_frequency, edges, right=False) - 1
+    bin_index = np.clip(bin_index, 0, log_bins - 1)
+
+    counts = np.bincount(bin_index, minlength=log_bins)
+    x_sum = np.bincount(
+        bin_index,
+        weights=log_frequency,
+        minlength=log_bins,
+    )
+    y_sum = np.bincount(
+        bin_index,
+        weights=log_power,
+        minlength=log_bins,
+    )
+
+    occupied = counts > 0
+    x = x_sum[occupied] / counts[occupied]
+    y = y_sum[occupied] / counts[occupied]
+
+    if x.size < 2:
+        raise ValueError("Not enough occupied log-frequency bins to fit a line.")
+
+    # y = intercept + slope * x
+    slope, intercept = np.polyfit(x, y, deg=1)
+    fitted_y = intercept + slope * x
+
+    # Redies et al. (2007): sum of squared deviations / number of points.
+    fourier_sigma = np.mean((y - fitted_y) ** 2)
+
+    return {
+        "fourier_slope": float(slope),
+        "fourier_sigma": float(fourier_sigma),
+        "dimensionality": dimensionality,
+        "spectral_centroid": centroid,
+        "spectral_variance": variance,
+    }

visfeats-0.1.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: visfeats
+Version: 0.1
+Summary: A library for extracting global visual features
+Author-email: Qian Chu <qianchu99@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scikit-image
+Provides-Extra: resmem
+Requires-Dist: resmem; extra == "resmem"
+Provides-Extra: dev
+Requires-Dist: resmem; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Dynamic: license-file
+
+# VisFeats: Extraction of Global Visual Features from Images
+
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
+
+VisFeats is a library for extracting global visual features from images.
+
+## Installation
+
+VisFeats is installable via PyPI:
+
+```bash
+pip install visfeats
+```
+
+Or via GitHub (for the latest development version):
+
+```bash
+pip install git+https://github.com/ncc-brain/VisFeats.git
+```
+
+## Usage
+
+To use VisFeats, first load an image using PIL:
+
+```python
+from PIL import Image
+image = Image.open("path/to/your/image.jpg")
+```
+
+All functions in VisFeats take a PIL ``Image.Image`` as input and return the corresponding feature values. Available features are described below.
+
+### Extract multiple features
+
+Use `extract_all_features` to collect all package-level features, or pass a
+feature name or list of names to select a subset. The result is a flat
+dictionary.
+
+```python
+from visfeats import extract_all_features
+
+features = extract_all_features(image, features=["rms", "hsv_features"])
+```
+
+### Mean and entropy of HSV channels
+
+Chromatic features describe color in HSV (Hue, Saturation, Value) space, including channel means and entropies. The `hsv_features` function returns a dictionary with six keys:
+
+- `hue_mean`
+- `saturation_mean`
+- `value_mean`
+- `hue_entropy`
+- `saturation_entropy`
+- `value_entropy`
+
+```python
+from visfeats import hsv_features
+features = hsv_features(image)
+```
+
+### Spatial frequency features
+
+Spatial frequency features capture the distribution of different spatial frequencies in an image, which relate to the level of detail and texture. The `spatial_frequency_features` function extracts these features:
+
+- `fourier_slope`
+- `fourier_sigma`
+- `dimensionality`
+- `spectral_centroid`
+- `spectral_variance`
+
+```python
+from visfeats import spatial_frequency_features
+features = spatial_frequency_features(image)
+```
+
+### Memorability
+
+While memorability is often considered a subjective property, recent research has shown that it can be predicted from image content. Here the `memorability_resmem` function estimates intrinsic memorability using the pretrained ResMem model described by [Needell and Bainbridge (2022)](https://doi.org/10.1007/s42113-022-00126-5).
+
+ResMem is an optional dependency. It can be installed along with VisFeats using:
+
+```bash
+pip install "visfeats[resmem]"
+```
+
+Or separately with:
+
+```bash
+pip install resmem
+```
+
+Then you can use the `memorability_resmem` function to estimate the memorability of an image:
+
+```python
+from visfeats import memorability_resmem
+resmem_score = memorability_resmem(image)
+```
+
+### Other features
+
+#### RMS contrast
+
+The `rms` function computes the root-mean-square contrast as the population standard deviation of the image's grayscale pixel intensities.
+
+```python
+from visfeats import rms
+rms_contrast = rms(image)
+```

visfeats-0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+visfeats/__init__.py,sha256=rprYLjIT0pEu-MelUy1msGVLwKTzpCCxh3uZ6BGK0SA,2552
+visfeats/chromatic.py,sha256=0SFdIygC6g5CzQu7_LBZh3-2frAgV311jNMjr7HBOrM,2091
+visfeats/memorability.py,sha256=TotQGk6R2l0I-42ilJMesl6SEDmK-HunrgWrFlGn9dw,1719
+visfeats/misc.py,sha256=YfLC2ptyKxx5yI_T9uKI1mES49qlVTdGVLa5ZDvMacI,628
+visfeats/spatial_frequency.py,sha256=3cdEqD-U_Ce-0Rt76BA2yS-unHSjfucaVPxPiTbbGPU,10387
+visfeats-0.1.dist-info/licenses/LICENSE,sha256=Kp1DPQGh36k51G0yLkCg_spVbXzIi66A3FbmfEfylaE,1065
+visfeats-0.1.dist-info/METADATA,sha256=SbsKrwc_QiqFxA-0iyFOhUL364vD27Vbibn5mN9g54I,3495
+visfeats-0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+visfeats-0.1.dist-info/top_level.txt,sha256=BOjMNuJsd_gpQqQaG67djZI-cOCdYOrHkmvinMAerPM,9
+visfeats-0.1.dist-info/RECORD,,

visfeats-0.1.dist-info/WHEEL

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

visfeats-0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Qian Chu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

visfeats-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+visfeats