bmtool 0.7.1.1__py3-none-any.whl → 0.7.1.3__py3-none-any.whl

bmtool/analysis/entrainment.py

@@ -2,7 +2,7 @@
 Module for entrainment analysis
 """
 
-from typing import Dict, List
+from typing import Dict, List, Optional, Union
 
 import numba
 import numpy as np
@@ -41,7 +41,7 @@ def align_spike_times_with_lfp(lfp: xr.DataArray, timestamps: np.ndarray) -> np.
         (timestamps >= lfp.time.values[0]) & (timestamps <= lfp.time.values[-1])
     ].copy()
     # set the time axis of the spikes to match the lfp
-    timestamps = timestamps - lfp.time.values[0]
+    # timestamps = timestamps - lfp.time.values[0]
     return timestamps
 
 
@@ -127,33 +127,33 @@ def calculate_signal_signal_plv(
     return plv
 
 
-def calculate_spike_lfp_plv(
-    spike_times: np.ndarray = None,
-    lfp_data=None,
-    spike_fs: float = None,
-    lfp_fs: float = None,
-    filter_method: str = "butter",
-    freq_of_interest: float = None,
-    lowcut: float = None,
-    highcut: float = None,
+def _get_spike_phases(
+    spike_times: np.ndarray,
+    lfp_data: Union[np.ndarray, xr.DataArray],
+    spike_fs: float,
+    lfp_fs: float,
+    filter_method: str = "wavelet",
+    freq_of_interest: Optional[float] = None,
+    lowcut: Optional[float] = None,
+    highcut: Optional[float] = None,
     bandwidth: float = 2.0,
-    filtered_lfp_phase: np.ndarray = None,
-) -> float:
+    filtered_lfp_phase: Optional[Union[np.ndarray, xr.DataArray]] = None,
+) -> np.ndarray:
     """
-    Calculate spike-lfp unbiased phase locking value
+    Helper function to get spike phases from LFP data.
 
     Parameters
     ----------
     spike_times : np.ndarray
         Array of spike times
-    lfp_data : np.ndarray
+    lfp_data : Union[np.ndarray, xr.DataArray]
         Local field potential time series data. Not required if filtered_lfp_phase is provided.
-    spike_fs : float, optional
-        Sampling frequency in Hz of the spike times, only needed if spike times and LFP have different sampling rates
+    spike_fs : float
+        Sampling frequency in Hz of the spike times
     lfp_fs : float
         Sampling frequency in Hz of the LFP data
     filter_method : str, optional
-        Method to use for filtering, either 'wavelet' or 'butter' (default: 'butter')
+        Method to use for filtering, either 'wavelet' or 'butter' (default: 'wavelet')
     freq_of_interest : float, optional
         Desired frequency for wavelet phase extraction, required if filter_method='wavelet'
     lowcut : float, optional
@@ -167,12 +167,9 @@ def calculate_spike_lfp_plv(
 
     Returns
     -------
-    float
-        Phase Locking Value (unbiased)
+    np.ndarray
+        Array of phases at spike times
     """
-
-    if spike_fs is None:
-        spike_fs = lfp_fs
     # Convert spike times to sample indices
     spike_times_seconds = spike_times / spike_fs
 
@@ -194,7 +191,7 @@ def calculate_spike_lfp_plv(
             valid_indices = [idx for idx in spike_indices if 0 <= idx < len(lfp_data)]
 
     if len(valid_indices) <= 1:
-        return 0
+        return np.array([])
 
     # Get instantaneous phase
     if filtered_lfp_phase is None:
@@ -212,10 +209,73 @@ def calculate_spike_lfp_plv(
 
     # Get phases at spike times
     if isinstance(instantaneous_phase, xr.DataArray):
-        spike_phases = instantaneous_phase.sel(time=valid_indices).values
+        spike_phases = instantaneous_phase.sel(time=valid_indices, method="nearest").values
     else:
         spike_phases = instantaneous_phase[valid_indices]
 
+    return spike_phases
+
+
+def calculate_spike_lfp_plv(
+    spike_times: np.ndarray = None,
+    lfp_data=None,
+    spike_fs: float = None,
+    lfp_fs: float = None,
+    filter_method: str = "butter",
+    freq_of_interest: float = None,
+    lowcut: float = None,
+    highcut: float = None,
+    bandwidth: float = 2.0,
+    filtered_lfp_phase: np.ndarray = None,
+) -> float:
+    """
+    Calculate spike-lfp unbiased phase locking value
+
+    Parameters
+    ----------
+    spike_times : np.ndarray
+        Array of spike times
+    lfp_data : np.ndarray
+        Local field potential time series data. Not required if filtered_lfp_phase is provided.
+    spike_fs : float, optional
+        Sampling frequency in Hz of the spike times, only needed if spike times and LFP have different sampling rates
+    lfp_fs : float
+        Sampling frequency in Hz of the LFP data
+    filter_method : str, optional
+        Method to use for filtering, either 'wavelet' or 'butter' (default: 'butter')
+    freq_of_interest : float, optional
+        Desired frequency for wavelet phase extraction, required if filter_method='wavelet'
+    lowcut : float, optional
+        Lower frequency bound (Hz) for butterworth bandpass filter, required if filter_method='butter'
+    highcut : float, optional
+        Upper frequency bound (Hz) for butterworth bandpass filter, required if filter_method='butter'
+    bandwidth : float, optional
+        Bandwidth parameter for wavelet filter when method='wavelet' (default: 2.0)
+    filtered_lfp_phase : np.ndarray, optional
+        Pre-computed instantaneous phase of the filtered LFP. If provided, the function will skip the filtering step.
+
+    Returns
+    -------
+    float
+        Phase Locking Value (unbiased)
+    """
+
+    spike_phases = _get_spike_phases(
+        spike_times=spike_times,
+        lfp_data=lfp_data,
+        spike_fs=spike_fs,
+        lfp_fs=lfp_fs,
+        filter_method=filter_method,
+        freq_of_interest=freq_of_interest,
+        lowcut=lowcut,
+        highcut=highcut,
+        bandwidth=bandwidth,
+        filtered_lfp_phase=filtered_lfp_phase,
+    )
+
+    if len(spike_phases) <= 1:
+        return 0
+
     # Number of spikes
     N = len(spike_phases)
 
@@ -316,57 +376,26 @@ def calculate_ppc(
     float
         Pairwise Phase Consistency value
     """
-    if spike_fs is None:
-        spike_fs = lfp_fs
-    # Convert spike times to sample indices
-    spike_times_seconds = spike_times / spike_fs
-
-    # Then convert from seconds to samples at the new sampling rate
-    spike_indices = np.round(spike_times_seconds * lfp_fs).astype(int)
 
-    # Filter indices to ensure they're within bounds of the LFP signal
-    if isinstance(lfp_data, xr.DataArray):
-        if filtered_lfp_phase is not None:
-            valid_indices = align_spike_times_with_lfp(
-                lfp=filtered_lfp_phase, timestamps=spike_indices
-            )
-        else:
-            valid_indices = align_spike_times_with_lfp(lfp=lfp_data, timestamps=spike_indices)
-    elif isinstance(lfp_data, np.ndarray):
-        if filtered_lfp_phase is not None:
-            valid_indices = [idx for idx in spike_indices if 0 <= idx < len(filtered_lfp_phase)]
-        else:
-            valid_indices = [idx for idx in spike_indices if 0 <= idx < len(lfp_data)]
-
-    if len(valid_indices) <= 1:
+    spike_phases = _get_spike_phases(
+        spike_times=spike_times,
+        lfp_data=lfp_data,
+        spike_fs=spike_fs,
+        lfp_fs=lfp_fs,
+        filter_method=filter_method,
+        freq_of_interest=freq_of_interest,
+        lowcut=lowcut,
+        highcut=highcut,
+        bandwidth=bandwidth,
+        filtered_lfp_phase=filtered_lfp_phase,
+    )
+
+    if len(spike_phases) <= 1:
         return 0
 
-    # Get instantaneous phase
-    if filtered_lfp_phase is None:
-        instantaneous_phase = get_lfp_phase(
-            lfp_data=lfp_data,
-            filter_method=filter_method,
-            freq_of_interest=freq_of_interest,
-            lowcut=lowcut,
-            highcut=highcut,
-            bandwidth=bandwidth,
-            fs=lfp_fs,
-        )
-    else:
-        instantaneous_phase = filtered_lfp_phase
-
-    # Get phases at spike times
-    if isinstance(instantaneous_phase, xr.DataArray):
-        spike_phases = instantaneous_phase.sel(time=valid_indices).values
-    else:
-        spike_phases = instantaneous_phase[valid_indices]
-
     n_spikes = len(spike_phases)
 
     # Calculate PPC (Pairwise Phase Consistency)
-    if n_spikes <= 1:
-        return 0
-
     # Explicit calculation of pairwise phase consistency
     # Vectorized computation for efficiency
     if ppc_method == "numpy":
@@ -434,56 +463,25 @@ def calculate_ppc2(
         Pairwise Phase Consistency 2 (PPC2) value
     """
 
-    if spike_fs is None:
-        spike_fs = lfp_fs
-    # Convert spike times to sample indices
-    spike_times_seconds = spike_times / spike_fs
-
-    # Then convert from seconds to samples at the new sampling rate
-    spike_indices = np.round(spike_times_seconds * lfp_fs).astype(int)
-
-    # Filter indices to ensure they're within bounds of the LFP signal
-    if isinstance(lfp_data, xr.DataArray):
-        if filtered_lfp_phase is not None:
-            valid_indices = align_spike_times_with_lfp(
-                lfp=filtered_lfp_phase, timestamps=spike_indices
-            )
-        else:
-            valid_indices = align_spike_times_with_lfp(lfp=lfp_data, timestamps=spike_indices)
-    elif isinstance(lfp_data, np.ndarray):
-        if filtered_lfp_phase is not None:
-            valid_indices = [idx for idx in spike_indices if 0 <= idx < len(filtered_lfp_phase)]
-        else:
-            valid_indices = [idx for idx in spike_indices if 0 <= idx < len(lfp_data)]
-
-    if len(valid_indices) <= 1:
+    spike_phases = _get_spike_phases(
+        spike_times=spike_times,
+        lfp_data=lfp_data,
+        spike_fs=spike_fs,
+        lfp_fs=lfp_fs,
+        filter_method=filter_method,
+        freq_of_interest=freq_of_interest,
+        lowcut=lowcut,
+        highcut=highcut,
+        bandwidth=bandwidth,
+        filtered_lfp_phase=filtered_lfp_phase,
+    )
+
+    if len(spike_phases) <= 1:
         return 0
 
-    # Get instantaneous phase
-    if filtered_lfp_phase is None:
-        instantaneous_phase = get_lfp_phase(
-            lfp_data=lfp_data,
-            filter_method=filter_method,
-            freq_of_interest=freq_of_interest,
-            lowcut=lowcut,
-            highcut=highcut,
-            bandwidth=bandwidth,
-            fs=lfp_fs,
-        )
-    else:
-        instantaneous_phase = filtered_lfp_phase
-
-    # Get phases at spike times
-    if isinstance(instantaneous_phase, xr.DataArray):
-        spike_phases = instantaneous_phase.sel(time=valid_indices).values
-    else:
-        spike_phases = instantaneous_phase[valid_indices]
     # Calculate PPC2 according to Vinck et al. (2010), Equation 6
     n = len(spike_phases)
 
-    if n <= 1:
-        return 0
-
     # Convert phases to unit vectors in the complex plane
     unit_vectors = np.exp(1j * spike_phases)
 
@@ -575,7 +573,7 @@ def calculate_entrainment_per_cell(
     for pop in pop_names:
         skip_count = 0
         pop_spikes = spike_df[spike_df["pop_name"] == pop]
-        nodes = pop_spikes["node_ids"].unique()
+        nodes = sorted(pop_spikes["node_ids"].unique())  # sort so all nodes are processed in order
         entrainment_dict[pop] = {}
         print(f"Processing {pop} population")
         for node in tqdm(nodes):
@@ -714,3 +712,55 @@ def calculate_spike_rate_power_correlation(
             correlation_results[pop][freq] = {"correlation": corr, "p_value": p_val}
 
     return correlation_results, frequencies
+
+
+def get_spikes_in_cycle(spike_df, lfp_data, spike_fs=1000, lfp_fs=400, band=(30, 80)):
+    """
+    Analyze spike timing relative to oscillation phases.
+
+    Parameters:
+    -----------
+    spike_df : pd.DataFrame
+    lfp_data : np.array
+        Raw LFP signal
+    fs : float
+        Sampling frequency of LFP in Hz
+    gamma_band : tuple
+        Lower and upper bounds of gamma frequency band in Hz
+
+    Returns:
+    --------
+    phase_data : dict
+        Dictionary containing phase values for each spike and neuron population
+    """
+    filtered_lfp = butter_bandpass_filter(lfp_data, band[0], band[1], lfp_fs)
+
+    # Calculate phase using Hilbert transform
+    analytic_signal = signal.hilbert(filtered_lfp)
+    phase = np.angle(analytic_signal)
+    amplitude = np.abs(analytic_signal)
+
+    # Get unique neuron populations
+    neuron_pops = spike_df["pop_name"].unique()
+
+    # Get the phase at each spike time for each neuron population
+    phase_data = {}
+
+    for pop in neuron_pops:
+        # Get spike times for this population
+        pop_spikes = spike_df[spike_df["pop_name"] == pop]["timestamps"].values
+
+        # Convert spike times to sample indices
+        spike_times_seconds = pop_spikes / spike_fs
+
+        # Then convert from seconds to samples at the new sampling rate
+        spike_indices = np.round(spike_times_seconds * lfp_fs).astype(int)
+
+        # Ensure spike times are within LFP data range
+        valid_indices = (spike_indices >= 0) & (spike_indices < len(phase))
+
+        if np.any(valid_indices):
+            valid_samples = spike_indices[valid_indices]
+            phase_data[pop] = phase[valid_samples]
+
+    return phase_data, filtered_lfp, phase, amplitude

bmtool/analysis/spikes.py

@@ -398,3 +398,58 @@ def compare_firing_over_times(
         print(f"    p-value: {p_val}")
         print(f"    Significant difference (p<0.05): {'Yes' if p_val < 0.05 else 'No'}")
     return
+
+
+def find_bursting_cells(
+    df: pd.DataFrame, burst_threshold: float = 10, rename_bursting_cells: bool = False
+) -> pd.DataFrame:
+    """
+    Finds bursting cells in a population based on a time difference threshold.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame containing spike data with columns for timestamps, node_ids, and pop_name
+    burst_threshold : float, optional
+        Time difference threshold in milliseconds to identify bursts
+    rename_bursting_cells : bool, optional
+        If True, returns a DataFrame with bursting cells renamed in their pop_name column
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame with bursting cells renamed in their pop_name column
+    """
+    # Create a new DataFrame with the time differences
+    diff_df = df.copy()
+    diff_df["time_diff"] = df.groupby("node_ids")["timestamps"].diff()
+
+    # Create a column indicating whether each time difference is a burst
+    diff_df["is_burst_instance"] = diff_df["time_diff"] < burst_threshold
+
+    # Group by node_ids and check if any row has a burst instance
+    burst_summary = diff_df.groupby("node_ids")["is_burst_instance"].any()
+
+    # Convert to a DataFrame with reset index
+    burst_cells = burst_summary.reset_index(name="is_burst")
+
+    # merge with original df to get timestamps
+    burst_cells = pd.merge(burst_cells, df, on="node_ids")
+
+    # Create a mask for burst cells that don't already have "_bursters" in their name
+    burst_mask = (burst_cells["is_burst"] is True) & (
+        ~burst_cells["pop_name"].str.contains("_bursters")
+    )
+
+    # Add "_bursters" suffix only to those cells
+    if rename_bursting_cells:
+        burst_cells.loc[burst_mask, "pop_name"] = (
+            burst_cells.loc[burst_mask, "pop_name"] + "_bursters"
+        )
+
+    for pop in burst_cells["pop_name"].unique():
+        print(
+            f"Number of bursters in {pop}: {burst_cells[burst_cells['pop_name'] == pop]['node_ids'].nunique()}"
+        )
+
+    return burst_cells

bmtool/bmplot/entrainment.py

@@ -1,5 +1,8 @@
 import matplotlib.pyplot as plt
+import numpy as np
 import seaborn as sns
+from matplotlib.gridspec import GridSpec
+from scipy import stats
 
 
 def plot_spike_power_correlation(correlation_results, frequencies, pop_names):
@@ -48,3 +51,152 @@ def plot_spike_power_correlation(correlation_results, frequencies, pop_names):
     plt.tight_layout()
 
     plt.show()
+
+
+def plot_cycle_with_spike_histograms(phase_data, bins=36, pop_name=None):
+    """
+    Plot an idealized gamma cycle with spike histograms for different neuron populations.
+
+    Parameters:
+    -----------
+    phase_data : dict
+        Dictionary containing phase values for each spike and neuron population
+    fs : float
+        Sampling frequency of LFP in Hz
+    bins : int
+        Number of bins for the phase histogram (default 36 gives 10-degree bins)
+    pop_name : list
+        List of population names to be plotted
+    """
+    sns.set_style("whitegrid")
+    # Create a figure with subplots
+    fig = plt.figure(figsize=(12, 8))
+    gs = GridSpec(len(pop_name) + 1, 1, height_ratios=[1.5] + [1] * len(pop_name))
+
+    # Top subplot: Idealized gamma cycle
+    ax_gamma = fig.add_subplot(gs[0])
+
+    # Create an idealized gamma cycle
+    x = np.linspace(-np.pi, np.pi, 1000)
+    y = np.sin(x)
+
+    ax_gamma.plot(x, y, "b-", linewidth=2)
+    ax_gamma.set_title("Cycle with Neuron Population Spike Distributions", fontsize=14)
+    ax_gamma.set_ylabel("Amplitude", fontsize=12)
+    ax_gamma.set_xlim(-np.pi, np.pi)
+    ax_gamma.set_xticks(np.linspace(-np.pi, np.pi, 9))
+    ax_gamma.set_xticklabels(["-180°", "-135°", "-90°", "-45°", "0°", "45°", "90°", "135°", "180°"])
+    ax_gamma.grid(True)
+    ax_gamma.axhline(y=0, color="k", linestyle="-", alpha=0.3)
+    ax_gamma.axvline(x=0, color="k", linestyle="--", alpha=0.3)
+
+    # Generate a color map for the different populations
+    colors = plt.cm.tab10(np.linspace(0, 1, len(pop_name)))
+
+    # Add histograms for each neuron population
+    for i, pop_name in enumerate(pop_name):
+        ax_hist = fig.add_subplot(gs[i + 1], sharex=ax_gamma)
+
+        # Compute histogram
+        hist, bin_edges = np.histogram(phase_data[pop_name], bins=bins, range=(-np.pi, np.pi))
+        bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+
+        # Normalize histogram
+        if np.sum(hist) > 0:
+            hist = hist / np.sum(hist) * 100  # Convert to percentage
+
+        # Plot histogram
+        ax_hist.bar(bin_centers, hist, width=2 * np.pi / bins, alpha=0.7, color=colors[i])
+        ax_hist.set_ylabel(f"{pop_name}\nSpikes (%)", fontsize=10)
+
+        # Add grid to align with gamma cycle
+        ax_hist.grid(True, alpha=0.3)
+        ax_hist.set_ylim(0, max(hist) * 1.2)  # Add some headroom
+
+    # Set x-label for the last subplot
+    ax_hist.set_xlabel("Phase (degrees)", fontsize=12)
+
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_ppc_by_population(ppc_dict, pop_names, freqs, figsize=(15, 8), title=None):
+    """
+    Plot PPC for all node populations on one graph with mean and standard error.
+
+    Parameters:
+    -----------
+    ppc_dict : dict
+        Dictionary containing PPC data organized by population, node, and frequency
+    pop_names : list
+        List of population names to plot data for
+    freqs : list
+        List of frequencies to plot
+    figsize : tuple
+        Figure size for the plot
+    """
+    # Set up the visualization style
+    sns.set_style("whitegrid")
+    plt.figure(figsize=figsize)
+
+    # Calculate the width of each group of bars
+    n_groups = len(freqs)
+    n_populations = len(pop_names)
+    group_width = 0.8
+    bar_width = group_width / n_populations
+
+    # Color palette for different populations
+    pop_colors = sns.color_palette(n_colors=n_populations)
+
+    # For tracking x-axis positions and labels
+    x_centers = np.arange(n_groups)
+    tick_labels = [str(freq) for freq in freqs]
+
+    # Process and plot data for each population
+    for i, pop in enumerate(pop_names):
+        # Store mean and SE for each frequency in this population
+        means = []
+        errors = []
+        valid_freqs_idx = []
+
+        # Collect and process data for all frequencies in this population
+        for freq_idx, freq in enumerate(freqs):
+            freq_values = []
+
+            # Collect values across all nodes for this frequency
+            for node in ppc_dict[pop]:
+                try:
+                    ppc_value = ppc_dict[pop][node][freq]
+                    freq_values.append(ppc_value)
+                except KeyError:
+                    continue
+
+            # If we have data for this frequency
+            if freq_values:
+                mean_val = np.mean(freq_values)
+                se_val = stats.sem(freq_values)
+                means.append(mean_val)
+                errors.append(se_val)
+                valid_freqs_idx.append(freq_idx)
+
+        # Calculate x positions for this population's bars
+        # Each population's bars are offset within their frequency group
+        x_positions = x_centers[valid_freqs_idx] + (i - n_populations / 2 + 0.5) * bar_width
+
+        # Plot bars with error bars
+        plt.bar(
+            x_positions, means, width=bar_width * 0.9, color=pop_colors[i], alpha=0.7, label=pop
+        )
+        plt.errorbar(x_positions, means, yerr=errors, fmt="none", ecolor="black", capsize=4)
+
+    # Set up the plot labels and legend
+    plt.xlabel("Frequency")
+    plt.ylabel("PPC Value")
+    if title:
+        plt.title(title)
+    plt.xticks(x_centers, tick_labels)
+    plt.legend(title="Population")
+
+    # Adjust layout and save
+    plt.tight_layout()
+    plt.show()

{bmtool-0.7.1.1.dist-info → bmtool-0.7.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmtool
-Version: 0.7.1.1
+Version: 0.7.1.3
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 
@@ -38,7 +38,6 @@ Requires-Dist: PyWavelets
 Requires-Dist: numba
 Provides-Extra: dev
 Requires-Dist: ruff>=0.1.0; extra == "dev"
-Requires-Dist: pyright>=1.1.0; extra == "dev"
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Dynamic: author

{bmtool-0.7.1.1.dist-info → bmtool-0.7.1.3.dist-info}/RECORD

@@ -8,13 +8,13 @@ bmtool/plot_commands.py,sha256=Dxm_RaT4CtHnfsltTtUopJ4KVbfhxtktEB_b7bFEXII,12716
 bmtool/singlecell.py,sha256=I2yolbAnNC8qpnRkNdnDCLidNW7CktmBuRrcowMZJ3A,45041
 bmtool/synapses.py,sha256=wlRY7IixefPzafqG6k2sPIK4s6PLG9Kct-oCaVR29wA,64269
 bmtool/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bmtool/analysis/entrainment.py,sha256=Nzrt1pKHEDzrx9TYnsE0sbevxl4iht1fymA29khq8Pg,26841
+bmtool/analysis/entrainment.py,sha256=uG2TWbeYJEg_VQB6pKEWlrVBzQ6M4h6FSAZR4GMKp-E,28178
 bmtool/analysis/lfp.py,sha256=S2JvxkjcK3-EH93wCrhqNSFY6cX7fOq74pz64ibHKrc,26556
 bmtool/analysis/netcon_reports.py,sha256=VnPZNKPaQA7oh1q9cIatsqQudm4cOtzNtbGPXoiDCD0,2909
-bmtool/analysis/spikes.py,sha256=ScP4EeX2QuEd_FXyj3W0WWgZKvZwwneuWuKFe3xwaCY,15115
+bmtool/analysis/spikes.py,sha256=Mz0e7XOey_6eWQDZAU0ePjDzDMDTFkMbWSA5YWDooYk,17122
 bmtool/bmplot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/bmplot/connections.py,sha256=P1JBG4xCbLVq4sfQuUE6c3dO949qajrjdQcrazdmDS4,53861
-bmtool/bmplot/entrainment.py,sha256=TC2qJV0Z6YiK5X7bEpiEyf7nZiWU__466Uhq0kbrhIY,1611
+bmtool/bmplot/entrainment.py,sha256=VSlZvcSeXLr5OxGvmWcGU4s7JS7vOL38lq1XC69O_AE,6926
 bmtool/bmplot/lfp.py,sha256=SNpbWGOUnYEgnkeBw5S--aPN5mIGD22Gw2Pwus0_lvY,2034
 bmtool/bmplot/netcon_reports.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/bmplot/spikes.py,sha256=Lg8V3ynYCqk-QJvq-BOInjZMHYHrxHgXjtDOX67df-A,11148
@@ -26,9 +26,9 @@ bmtool/util/commands.py,sha256=Nn-R-4e9g8ZhSPZvTkr38xeKRPfEMANB9Lugppj82UI,68564
 bmtool/util/util.py,sha256=owce5BEusZO_8T5x05N2_B583G26vWAy7QX29V0Pj0Y,62818
 bmtool/util/neuron/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/util/neuron/celltuner.py,sha256=lokRLUM1rsdSYBYrNbLBBo39j14mm8TBNVNRnSlhHCk,94868
-bmtool-0.7.1.1.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.7.1.1.dist-info/METADATA,sha256=ONMkDOU2sGv2xzC9jbP5z9HdGFI2HGO_2fwS6cIBj3w,3623
-bmtool-0.7.1.1.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-bmtool-0.7.1.1.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.7.1.1.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.7.1.1.dist-info/RECORD,,
+bmtool-0.7.1.3.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
+bmtool-0.7.1.3.dist-info/METADATA,sha256=GpvzWhlfyNgHHCfhakOBeeablgTAOCHeQFvhnExZ-X8,3577
+bmtool-0.7.1.3.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+bmtool-0.7.1.3.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
+bmtool-0.7.1.3.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
+bmtool-0.7.1.3.dist-info/RECORD,,