vrfcd 0.1.1__py3-none-any.whl

vrfcd/__init__.py

@@ -0,0 +1,14 @@
+from .distance import compute_van_rossum_distance
+from .kernels import distance_to_functional_matrix
+from .graph import build_functional_graph
+from .communities import detect_communities
+from .pipeline import VRFCDPipeline, VRFCDResult
+
+__all__ = [
+    "compute_van_rossum_distance",
+    "distance_to_functional_matrix",
+    "build_functional_graph",
+    "detect_communities",
+    "VRFCDPipeline",
+    "VRFCDResult",
+]

vrfcd/communities.py

@@ -0,0 +1,130 @@
+from collections import Counter
+
+import networkx as nx
+from networkx.algorithms.community import louvain_communities
+
+
+def detect_communities(
+    G,
+    method="louvain",
+    seed=42,
+    resolution=1.0,
+    threshold=1e-10,
+):
+    """
+    Detect communities in a weighted functional graph.
+
+    Parameters
+    ----------
+    G : networkx.Graph
+        Weighted graph.
+    method : {"louvain", "leiden"}
+        Community detection method.
+    seed : int
+        Random seed.
+    resolution : float
+        Louvain resolution parameter.
+    threshold : float
+        Louvain threshold parameter.
+
+    Returns
+    -------
+    partition : dict
+        Mapping node -> community label.
+    """
+
+    if method == "louvain":
+        communities = louvain_communities(
+            G,
+            weight="weight",
+            seed=seed,
+            resolution=resolution,
+            threshold=threshold,
+        )
+
+        partition = {node: cid for cid, comm in enumerate(communities) for node in comm}
+
+    elif method == "leiden":
+        try:
+            import igraph as ig
+            import leidenalg
+        except ImportError as exc:
+            raise ImportError(
+                "Leiden requires optional dependencies. "
+                "Install using: pip install -e '.[leiden]'"
+            ) from exc
+
+        nodes = list(G.nodes())
+        node_to_idx = {node: idx for idx, node in enumerate(nodes)}
+
+        edges = [(node_to_idx[u], node_to_idx[v]) for u, v in G.edges()]
+
+        weights = [G[u][v].get("weight", 1.0) for u, v in G.edges()]
+
+        g_ig = ig.Graph()
+        g_ig.add_vertices(len(nodes))
+        g_ig.add_edges(edges)
+        g_ig.es["weight"] = weights
+        g_ig.vs["name"] = nodes
+
+        part = leidenalg.find_partition(
+            g_ig,
+            leidenalg.ModularityVertexPartition,
+            weights="weight",
+            seed=seed,
+        )
+
+        partition = {}
+
+        for cid, comm in enumerate(part):
+            for idx in comm:
+                partition[g_ig.vs[idx]["name"]] = cid
+
+    else:
+        raise ValueError("method must be 'louvain' or 'leiden'.")
+
+    return partition
+
+
+def add_community_attributes(G, partition, attribute="community"):
+    """
+    Add community labels as node attributes.
+    """
+
+    G_out = G.copy()
+    nx.set_node_attributes(G_out, partition, attribute)
+    return G_out
+
+
+def community_counts(partition):
+    """
+    Count nodes in each community.
+    """
+
+    return Counter(partition.values())
+
+
+def make_partition_weighted_graph(
+    G,
+    partition,
+    within_scale=2.0,
+    between_scale=0.5,
+):
+    """
+    Modify edge weights for plotting.
+
+    Within-community edges are strengthened and between-community edges
+    are weakened.
+    """
+
+    G_comm = G.copy()
+
+    for u, v, data in G_comm.edges(data=True):
+        w = data.get("weight", 1.0)
+
+        if partition[u] == partition[v]:
+            data["weight"] = w * within_scale
+        else:
+            data["weight"] = w * between_scale
+
+    return G_comm

vrfcd/distance.py

@@ -0,0 +1,109 @@
+import numpy as np
+from scipy import signal
+from joblib import Parallel, delayed
+
+
+def compute_van_rossum_distance(
+    spike_matrix,
+    t,
+    t_R,
+    traces=False,
+    n_jobs=6,
+    normalise=True,
+    verbose=10,
+):
+    """
+    Compute the normalised van Rossum distance matrix.
+
+    Parameters
+    ----------
+    spike_matrix : array-like, shape (n_neurons, n_time_bins)
+        Binary or count spike matrix.
+    t : array-like, shape (n_time_bins,)
+        Time axis.
+    t_R : float
+        van Rossum kernel time constant.
+    traces : bool, default=False
+        If True, also return convolved spike traces.
+    n_jobs : int, default=6
+        Number of parallel workers.
+    normalise : bool, default=True
+        If True, divide distances by sqrt average spike count.
+    verbose : int, default=10
+        Joblib verbosity.
+
+    Returns
+    -------
+    D : ndarray
+        van Rossum distance matrix.
+    waveforms : ndarray, optional
+        Convolved spike traces.
+    """
+
+    t = np.asarray(t, dtype=float)
+
+    if not isinstance(spike_matrix, np.ndarray):
+        spike_matrix = np.asarray(spike_matrix.todense())
+    else:
+        spike_matrix = np.asarray(spike_matrix)
+
+    if spike_matrix.ndim != 2:
+        raise ValueError("spike_matrix must have shape (n_neurons, n_time_bins).")
+
+    if spike_matrix.shape[1] != len(t):
+        raise ValueError("Length of t must match the number of time bins.")
+
+    if t_R <= 0:
+        raise ValueError("t_R must be positive.")
+
+    dt = np.mean(np.diff(t))
+    n_neurons, n_time = spike_matrix.shape
+
+    kernel = np.exp(-t / t_R)
+
+    waveforms = np.zeros((n_neurons, n_time))
+
+    for j in range(n_neurons):
+        waveforms[j, :] = signal.convolve(
+            spike_matrix[j, :],
+            kernel,
+            mode="full",
+        )[:n_time]
+
+    spike_counts = (spike_matrix > 0).sum(axis=1)
+
+    def compute_row(j):
+        waveform_difference = waveforms - waveforms[j]
+
+        raw = np.sqrt(dt * np.sum(waveform_difference**2, axis=1) / t_R)
+
+        if normalise:
+            avg_spikes = np.sqrt((spike_counts + spike_counts[j]) / 2)
+
+            row = np.divide(
+                raw,
+                avg_spikes,
+                out=np.zeros_like(raw),
+                where=avg_spikes > 0,
+            )
+        else:
+            row = raw
+
+        return j, row
+
+    results = Parallel(n_jobs=n_jobs, verbose=verbose)(
+        delayed(compute_row)(j) for j in range(n_neurons)
+    )
+
+    D = np.zeros((n_neurons, n_neurons))
+
+    for j, row in results:
+        D[j, :] = row
+
+    D = 0.5 * (D + D.T)
+    np.fill_diagonal(D, 0.0)
+
+    if traces:
+        return D, waveforms
+
+    return D

vrfcd/graph.py

@@ -0,0 +1,55 @@
+import numpy as np
+import networkx as nx
+
+
+def build_functional_graph(
+    A,
+    node_names=None,
+    threshold=0.0,
+):
+    """
+    Build a weighted NetworkX graph from a functional adjacency matrix.
+
+    Parameters
+    ----------
+    A : ndarray
+        Functional adjacency matrix.
+    node_names : list, optional
+        Node labels.
+    threshold : float
+        Only edges with weight > threshold are added.
+
+    Returns
+    -------
+    G : networkx.Graph
+        Weighted graph.
+    """
+
+    A = np.asarray(A, dtype=float)
+
+    if A.ndim != 2 or A.shape[0] != A.shape[1]:
+        raise ValueError("A must be a square matrix.")
+
+    n = A.shape[0]
+
+    if node_names is None:
+        node_names = list(range(n))
+
+    if len(node_names) != n:
+        raise ValueError("node_names must have length equal to A.shape[0].")
+
+    G = nx.Graph()
+    G.add_nodes_from(node_names)
+
+    for i in range(n):
+        for j in range(i + 1, n):
+            weight = A[i, j]
+
+            if weight > threshold:
+                G.add_edge(
+                    node_names[i],
+                    node_names[j],
+                    weight=float(weight),
+                )
+
+    return G

vrfcd/kernels.py

@@ -0,0 +1,71 @@
+import numpy as np
+
+
+def distance_to_functional_matrix(
+    D,
+    kernel="minmax",
+    beta=0.1,
+    q_low=0.0,
+    q_high=1.0,
+    zero_diagonal=True,
+):
+    """
+    Convert a van Rossum distance matrix into a functional matrix.
+
+    Parameters
+    ----------
+    D : ndarray
+        Distance matrix.
+    kernel : {"clipping", "exponential", "minmax"}
+        Similarity transformation.
+    beta : float
+        Scale parameter for the exponential kernel.
+    q_low : float
+        Lower quantile for minmax scaling.
+    q_high : float
+        Upper quantile for minmax scaling.
+    zero_diagonal : bool
+        Whether to set the diagonal of A to zero.
+
+    Returns
+    -------
+    A : ndarray
+        Functional adjacency matrix.
+    """
+
+    D = np.asarray(D, dtype=float)
+
+    if D.ndim != 2 or D.shape[0] != D.shape[1]:
+        raise ValueError("D must be a square matrix.")
+
+    if kernel not in {"clipping", "exponential", "minmax"}:
+        raise ValueError("kernel must be one of: 'clipping', 'exponential', 'minmax'.")
+
+    if kernel == "clipping":
+        D_cap = np.clip(D, 0.0, 1.0)
+        A = 1.0 - D_cap
+
+    elif kernel == "exponential":
+        if beta <= 0:
+            raise ValueError("beta must be positive.")
+        A = np.exp(-D / beta)
+
+    elif kernel == "minmax":
+        dvals = D[np.triu_indices_from(D, k=1)]
+
+        lo = np.quantile(dvals, q_low)
+        hi = np.quantile(dvals, q_high)
+
+        if np.isclose(hi, lo):
+            A = np.zeros_like(D)
+        else:
+            Dnorm = (D - lo) / (hi - lo)
+            Dnorm = np.clip(Dnorm, 0.0, 1.0)
+            A = 1.0 - Dnorm
+
+    A = 0.5 * (A + A.T)
+
+    if zero_diagonal:
+        np.fill_diagonal(A, 0.0)
+
+    return A

vrfcd/pipeline.py

@@ -0,0 +1,131 @@
+from dataclasses import dataclass
+
+from .distance import compute_van_rossum_distance
+from .kernels import distance_to_functional_matrix
+from .graph import build_functional_graph
+from .communities import (
+    detect_communities,
+    add_community_attributes,
+    make_partition_weighted_graph,
+    community_counts,
+)
+
+
+@dataclass
+class VRFCDResult:
+    D: object
+    A: object
+    G: object
+    partition: dict | None = None
+    G_partitioned: object | None = None
+    counts: object | None = None
+    waveforms: object | None = None
+
+
+class VRFCDPipeline:
+    """
+    End-to-end pipeline:
+
+        spike matrix -> van Rossum distance -> functional matrix
+        -> weighted graph -> community labels
+    """
+
+    def __init__(
+        self,
+        t_R,
+        kernel="minmax",
+        beta=0.1,
+        q_low=0.0,
+        q_high=1.0,
+        graph_threshold=0.0,
+        community_method="louvain",
+        seed=42,
+        n_jobs=6,
+        traces=False,
+        normalise=True,
+        verbose=10,
+    ):
+        self.t_R = t_R
+        self.kernel = kernel
+        self.beta = beta
+        self.q_low = q_low
+        self.q_high = q_high
+        self.graph_threshold = graph_threshold
+        self.community_method = community_method
+        self.seed = seed
+        self.n_jobs = n_jobs
+        self.traces = traces
+        self.normalise = normalise
+        self.verbose = verbose
+
+    def fit(self, spike_matrix, t, node_names=None, detect=True):
+        """
+        Run the full VRFCD pipeline.
+        """
+
+        if self.traces:
+            D, waveforms = compute_van_rossum_distance(
+                spike_matrix,
+                t,
+                self.t_R,
+                traces=True,
+                n_jobs=self.n_jobs,
+                normalise=self.normalise,
+                verbose=self.verbose,
+            )
+        else:
+            D = compute_van_rossum_distance(
+                spike_matrix,
+                t,
+                self.t_R,
+                traces=False,
+                n_jobs=self.n_jobs,
+                normalise=self.normalise,
+                verbose=self.verbose,
+            )
+            waveforms = None
+
+        A = distance_to_functional_matrix(
+            D,
+            kernel=self.kernel,
+            beta=self.beta,
+            q_low=self.q_low,
+            q_high=self.q_high,
+        )
+
+        G = build_functional_graph(
+            A,
+            node_names=node_names,
+            threshold=self.graph_threshold,
+        )
+
+        if detect:
+            partition = detect_communities(
+                G,
+                method=self.community_method,
+                seed=self.seed,
+            )
+
+            G_with_partition = add_community_attributes(G, partition)
+
+            G_partitioned = make_partition_weighted_graph(
+                G_with_partition,
+                partition,
+            )
+
+            counts = community_counts(partition)
+
+        else:
+            partition = None
+            G_partitioned = None
+            counts = None
+
+        return VRFCDResult(
+            D=D,
+            A=A,
+            G=G,
+            partition=partition,
+            G_partitioned=G_partitioned,
+            counts=counts,
+            waveforms=waveforms,
+        )

vrfcd/plotting.py

@@ -0,0 +1,119 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import networkx as nx
+
+
+def plot_matrix(
+    M,
+    title=None,
+    colorbar_title=None,
+    cmap="inferno",
+    figsize=(7, 6),
+    xlabel="Neuron index $j$",
+    ylabel="Neuron index $i$",
+    savepath=None,
+    fontsize=18,
+):
+    """
+    Plot a distance or functional matrix.
+    """
+
+    M = np.asarray(M)
+
+    fig, ax = plt.subplots(figsize=figsize)
+
+    im = ax.imshow(
+        M,
+        cmap=cmap,
+        vmin=np.min(M),
+        vmax=np.max(M),
+        origin="lower",
+        interpolation="nearest",
+        aspect="equal",
+    )
+
+    cbar = fig.colorbar(im, ax=ax, pad=0.03)
+
+    if colorbar_title is not None:
+        cbar.ax.set_title(colorbar_title, fontsize=fontsize, pad=10)
+
+    cbar.ax.tick_params(labelsize=fontsize)
+
+    ax.set_xlabel(xlabel, fontsize=fontsize)
+    ax.set_ylabel(ylabel, fontsize=fontsize)
+
+    ax.tick_params(axis="both", labelsize=fontsize)
+
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+    if title is not None:
+        ax.set_title(title, fontsize=fontsize)
+
+    plt.tight_layout()
+
+    if savepath is not None:
+        fig.savefig(savepath, dpi=300, bbox_inches="tight")
+
+    return fig, ax
+
+
+def plot_functional_network(
+    G,
+    partition=None,
+    pos=None,
+    weight_attr="weight",
+    layout_seed=42,
+    figsize=(5, 4),
+    node_size=500,
+    title=r"Network representation of $A(t_R)$",
+    savepath=None,
+    fontsize=18,
+):
+    """
+    Plot weighted functional network.
+
+    If partition is supplied, nodes are coloured by community.
+    """
+
+    if pos is None:
+        pos = nx.spring_layout(G, weight=weight_attr, seed=layout_seed)
+
+    fig, ax = plt.subplots(figsize=figsize)
+
+    if partition is None:
+        node_colors = "lightgray"
+    else:
+        node_colors = [partition[n] for n in G.nodes()]
+
+    nx.draw_networkx_nodes(
+        G,
+        pos,
+        node_size=node_size,
+        node_color=node_colors,
+        edgecolors="black",
+        linewidths=1.2,
+        cmap=plt.cm.tab10,
+        ax=ax,
+    )
+
+    widths = [max(0.2, G[u][v].get(weight_attr, 1.0)) for u, v in G.edges()]
+
+    nx.draw_networkx_edges(
+        G,
+        pos,
+        width=widths,
+        alpha=0.8,
+        edge_color="black",
+        ax=ax,
+    )
+
+    ax.set_title(title, fontsize=fontsize)
+    ax.axis("off")
+
+    plt.tight_layout()
+
+    if savepath is not None:
+        fig.savefig(savepath, dpi=300, bbox_inches="tight")
+
+    return fig, ax, pos

vrfcd-0.1.1.dist-info/METADATA

@@ -0,0 +1,278 @@
+Metadata-Version: 2.4
+Name: vrfcd
+Version: 0.1.1
+Summary: van Rossum distance based functional community detection for spike trains
+Author-email: Indranil Ghosh <indranilg49@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/indrag49/vrfcd
+Project-URL: Repository, https://github.com/indrag49/vrfcd
+Project-URL: Issues, https://github.com/indrag49/vrfcd/issues
+Keywords: computational-neuroscience,spike-trains,van-rossum-distance,functional-connectivity,community-detection,network-science
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: networkx
+Requires-Dist: joblib
+Requires-Dist: scikit-learn
+Provides-Extra: leiden
+Requires-Dist: igraph; extra == "leiden"
+Requires-Dist: leidenalg; extra == "leiden"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: jupyter; extra == "dev"
+Dynamic: license-file
+
+# vrfcd
+
+![](assets/logo.png)
+
+`vrfcd` stands for **van Rossum Functional Community Detection**.
+
+This is a `Python` package for constructing functional connectivity networks from neural spike-train data
+using the van Rossum distance, and then detecting functional assemblies in the resulting weighted network.
+The package is designed for computational neuroscience workflows where the input data are spike rasters.
+The goal is to identify groups of neurons with similar temporal spiking structure.
+
+## Workflow
+![](assets/SampleNew2.png)
+
+Given a ```spike train``` as input the workflow is a four step process:
+```
+- Compute the van Rossum distance matrix
+- Transform it into functional adjacency matrix
+- Prepare the weighted `networkX` graph
+- Perform community detection on the graph
+```
+
+## Features
+`vrfcd` provides tools to:
+
+- compute a normalised van Rossum distance matrix from spike-train raster datasets,
+- convert the distance matrix into a functional adjacency matrix using different similarity transformations,
+- construct a weighted functional graph from the adjacency matrix,
+- detect communitues using either the Louvain or Leiden community detection algorithm,
+- visualise the distance matrix, functional matrix, and network representation, and
+- run the full analysis using a single pipeline interface.
+
+
+## Installation
+
+```bash
+pip install vrfcd
+```
+
+For development:
+
+```bash
+git clone https://github.com/indranilg49/vrfcd.git
+cd vrfcd
+pip install -e ".[dev]"
+```
+
+For optional Leiden community detection:
+
+```bash
+pip install -e ".[dev,leiden]"
+```
+
+## Simple usage
+
+```bash
+import numpy as np
+from vrfcd import VRFCDPipeline
+
+pipeline = VRFCDPipeline( t_R=0.01, kernel="minmax", community_method="louvain", n_jobs=4, )
+
+result = pipeline.fit(spike_matrix, t_axis)
+
+D = result.D
+A = result.A
+G = result.G
+
+partition = result.partition
+```
+
+Here `spike_matrix` should have the shape of `n_neurons x n_time_bins`, and `t_axis` should be the corresponding
+time axis. Note that if the time axis comes from experimental data with absolute time stamps, it is a good idea
+to rescale it so that it starts at zero:
+
+```bash
+t_axis = t_axis - t_axis[0]
+```
+
+## Main functions
+
+- ```compute_van_rossum_distance```
+
+```bash
+from vrfcd import compute_van_rossum_distance
+```
+
+This computes the pairwise van Rossum distance matrix between spike trains.
+
+```bash
+D = compute_van_rossum_distance(
+    spike_matrix,
+    t_axis,
+    t_R=0.01,
+    traces=False,
+    n_jobs=4,
+)
+```
+
+The parameter `t_R` controls the time scale of the exponential filter used in the van Rossum distance.
+Smaller values of `t_R` make the distance more sensitive to precise spike timing, while larger values smooth
+spike trains over a longer temporal window.
+
+If `traces=True`, the function also returns the convolved spike-train waveforms:
+
+```bash
+D, waveforms = compute_van_rossum_distance( spike_matrix, t_axis, t_R=0.01, traces=True, )
+```
+
+- ```distance_to_functional_matrix```
+
+```bash
+from vrfcd import distance_to_functional_matrix
+```
+
+This converts the van Rossum distance matrix into a functional adjacency matrix.
+
+```bash
+A = distance_to_functional_matrix( D, kernel="minmax", )
+```
+
+This package currently supports three similarity transformations.
+
+```kernel = "clipping"```
+
+When using this, the distances are capped at 1 and converted to similarities using: A = 1-D.
+
+```kernel = "exponential"```
+
+When using this, the distances are rescaled using an exponential kernel: A = exp(-D/beta). The parameter
+`beta` controls how quickly similarity decays with distance.
+
+```bash
+A = distance_to_functional_matrix( D, kernel="exponential", beta=0.1, )
+```
+
+```kernel = "minmax"```
+
+When using this, the distances are rescaled using a min-max transformation:
+
+```bash
+A = distance_to_functional_matrix(
+    D,
+    kernel="minmax",
+    q_low=0.0,
+    q_high=1.0,
+)
+```
+
+This maps small distances to high functional similarity and large distances to low functional similarity. 
+The diagonal of the resulting matrix is set to 0 by default.
+
+- ```build_functional_graph```
+
+```bash
+from vrfcd import build_functional_graph
+```
+
+This builds a weighted `networkX` graph from the functional adjacency matrix.
+
+```bash
+G = build_functional_graph( A, threshold=0.0, )
+```
+
+In the graph representation, each neuron is a node, and edges are weighted by the functional similarity values
+in `A`. The `threshold` parameter can be used to remove weak functional connections.
+
+- ```detect_communities```
+
+```bash
+from vrfcd import detect_communities
+```
+
+This function detects communities in the weighted functional graph.
+
+```bash
+partition = detect_communities( G, method="louvain", seed=42, )
+```
+
+The output is a disctionary mapping each node to a community label. The package currently supports two 
+methods for community detection:
+
+```bash
+method = "louvain"
+method = "leiden"
+```
+
+The Louvain method works with the core dependencies. In order to use Leiden, you will need to install the optional dependencies
+`igraph` and `leidenalg` additionally.
+
+## Pipeline interface
+
+Here we outline the easiest way to use the package through `VRFCDPipeline`.
+
+```bash
+from vrfcd import VRFCDPipeline 
+
+pipeline = VRFCDPipeline( t_R=0.01, kernel="minmax", q_low=0.0, q_high=1.0, community_method="louvain", n_jobs=4, traces=True, )
+
+result = pipeline.fit(spike_matrix, t_axis)
+```
+
+The pipeline returns a `VRFCDResult` object containing:
+
+- `result.D`: van Rossum distance matrix
+- `result.A`: functional adjacency matrix
+- `result.G`: community labels
+- `result.partition`: graph with community attributes
+- `result.G_partitioned`: van Rossum distance matrix
+- `result.counts`: number of nodes in each community
+- `result.waveforms`: convolved spike traces, if `traces=True`
+
+This allows the full analysis to be run in one step while still giving access to every intermediate object.
+
+## Plotting
+
+`vrfcd` also includes helper functions for viusalisation.
+
+```bash
+from vrfcd.plotting import plot_matrix, plot_functional_network
+```
+
+To plot the van Rossum distance matrix:
+
+```bash
+plot_matrix( result.D, colorbar_title=r"$\tilde{D}(t_R)$", savepath="distance_matrix.pdf", )
+```
+
+To plot the adjacency matrix:
+
+```bash
+plot_matrix( result.A, colorbar_title=r"$A(t_R)$", savepath="functional_matrix.pdf", )
+```
+
+To plot the functional network:
+
+```bash
+plot_functional_network( result.G_partitioned, partition=result.partition, savepath="functional_network.pdf", )
+```
+
+## Overview
+
+This package is intended for exploratory and research-focused analysis of spike-train data. It is particularly useful when 
+one wants to compare neurons based on spike timing, construct a functional network from these similarities,
+and identify groups of neurons with similar temporal spiking patterns. This package can be used with synthetic spike raster,
+simulated spiking network models, and experimental recordings such as Neuropixels spike-train datasets.
+
+
+

vrfcd-0.1.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+vrfcd/__init__.py,sha256=4rxSSBS-S3oA7YrS6qsDJDtaIEAj-KS2qhYcdBkLDmE,419
+vrfcd/communities.py,sha256=8-Ado-FMFe9vH-xNJYYUQfTueiz_764JK5fh03XL0XQ,3017
+vrfcd/distance.py,sha256=1ouv4NvqyCMgFtbLMpmPsqXzhlXQO9i8uR3MWN2Yh3A,2665
+vrfcd/graph.py,sha256=lRjtgDdZzvy6d4gYzifN2HCVpUJy6rkePSIpzH7R9Ag,1173
+vrfcd/kernels.py,sha256=AhOI1fr2xxnlGGp19OZDBUdlD23I5su54EurUngN7ww,1710
+vrfcd/pipeline.py,sha256=_etbYix_lki82nHNBkkWhfzzpAVUHnJ0WR1z53ryZz4,3246
+vrfcd/plotting.py,sha256=os53Fzy8_vKqAMZRpTx-6Me7FBdGzHOfZ107RP2sLcM,2489
+vrfcd-0.1.1.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vrfcd-0.1.1.dist-info/METADATA,sha256=3LGr1-dwsAbWxJvOk4wMUkMaft3_ET1J6LRh6U3DFK0,7980
+vrfcd-0.1.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+vrfcd-0.1.1.dist-info/top_level.txt,sha256=j3yae39lvtgTi3UTrID7haeqDTn4iRbD4m4iVlLeT7o,6
+vrfcd-0.1.1.dist-info/RECORD,,

vrfcd-0.1.1.dist-info/WHEEL

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

vrfcd-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+vrfcd