bmtool 0.6.7.1__py3-none-any.whl → 0.6.8.1__py3-none-any.whl

bmtool/analysis/spikes.py

@@ -5,7 +5,7 @@ Module for processing BMTK spikes output.
 import h5py
 import pandas as pd
 from bmtool.util.util import load_nodes_from_config
-from typing import Dict, Optional,Tuple, Union
+from typing import Dict, Optional,Tuple, Union, List
 import numpy as np
 import os
 
@@ -40,16 +40,89 @@ def load_spikes_to_df(spike_file: str, network_name: str, sort: bool = True, con
             nodes = load_nodes_from_config(config)
             nodes = nodes[network_name]
 
-            # Check if 'groupby' is a string or a list of strings and handle accordingly
+            # Convert single string to a list for uniform handling
             if isinstance(groupby, str):
-                spikes_df = spikes_df.merge(nodes[groupby], left_on='node_ids', right_index=True, how='left')
-            elif isinstance(groupby, list):
-                for group in groupby:
-                    spikes_df = spikes_df.merge(nodes[group], left_on='node_ids', right_index=True, how='left')
+                groupby = [groupby]
+
+            # Ensure all requested columns exist
+            missing_cols = [col for col in groupby if col not in nodes.columns]
+            if missing_cols:
+                raise KeyError(f"Columns {missing_cols} not found in nodes DataFrame.")
+
+            spikes_df = spikes_df.merge(nodes[groupby], left_on='node_ids', right_index=True, how='left')
 
     return spikes_df
 
 
+def compute_firing_rate_stats(df: pd.DataFrame, groupby: Union[str, List[str]] = "pop_name", start_time: float = None, stop_time: float = None) -> Tuple[pd.DataFrame, pd.DataFrame]:
+    """
+    Computes the firing rates of individual nodes and the mean and standard deviation of firing rates per group.
+
+    Args:
+        df (pd.DataFrame): Dataframe containing spike timestamps and node IDs.
+        groupby (str or list of str, optional): Column(s) to group by (e.g., 'pop_name' or ['pop_name', 'layer']).
+        start_time (float, optional): Start time for the analysis window. Defaults to the minimum timestamp in the data.
+        stop_time (float, optional): Stop time for the analysis window. Defaults to the maximum timestamp in the data.
+
+    Returns:
+        Tuple[pd.DataFrame, pd.DataFrame]: 
+            - The first DataFrame (`pop_stats`) contains the mean and standard deviation of firing rates per group.
+            - The second DataFrame (`individual_stats`) contains the firing rate of each individual node.
+    """
+
+    # Ensure groupby is a list
+    if isinstance(groupby, str):
+        groupby = [groupby]
+    
+    # Ensure all columns exist in the dataframe
+    for col in groupby:
+        if col not in df.columns:
+            raise ValueError(f"Column '{col}' not found in dataframe.")
+
+    # Filter dataframe based on start/stop time
+    if start_time is not None:
+        df = df[df["timestamps"] >= start_time]
+    if stop_time is not None:
+        df = df[df["timestamps"] <= stop_time]
+
+    # Compute total duration for firing rate calculation
+    if start_time is None:
+        min_time = df["timestamps"].min()
+    else:
+        min_time = start_time
+    
+    if stop_time is None: 
+        max_time = df["timestamps"].max()
+    else:
+        max_time = stop_time
+ 
+    duration = max_time - min_time  # Avoid division by zero
+
+    if duration <= 0:
+        raise ValueError("Invalid time window: Stop time must be greater than start time.")
+
+    # Compute firing rate for each node
+    import pandas as pd
+
+    # Compute spike counts per node
+    spike_counts = df["node_ids"].value_counts().reset_index()
+    spike_counts.columns = ["node_ids", "spike_count"]  # Rename columns
+
+    # Merge with original dataframe to get corresponding labels (e.g., 'pop_name')
+    spike_counts = spike_counts.merge(df[["node_ids"] + groupby].drop_duplicates(), on="node_ids", how="left")
+
+    # Compute firing rate
+    spike_counts["firing_rate"] = spike_counts["spike_count"] / duration * 1000 # scale to Hz
+    indivdual_stats = spike_counts
+    
+    # Compute mean and standard deviation per group
+    pop_stats = spike_counts.groupby(groupby)["firing_rate"].agg(["mean", "std"]).reset_index()
+
+    # Rename columns
+    pop_stats.rename(columns={"mean": "firing_rate_mean", "std": "firing_rate_std"}, inplace=True)
+
+    return pop_stats,indivdual_stats
+
 
 def _pop_spike_rate(spike_times: Union[np.ndarray, list], time: Optional[Tuple[float, float, float]] = None, 
                    time_points: Optional[Union[np.ndarray, list]] = None, frequeny: bool = False) -> np.ndarray:

bmtool/bmplot.py

@@ -13,6 +13,7 @@ import matplotlib.colors as colors
 import matplotlib.gridspec as gridspec
 from mpl_toolkits.mplot3d import Axes3D
 from matplotlib.axes import Axes
+import seaborn as sns
 from IPython import get_ipython
 from IPython.display import display, HTML
 import statistics
@@ -20,7 +21,7 @@ import pandas as pd
 import os
 import sys
 import re
-from typing import Optional, Dict
+from typing import Optional, Dict, Union, List
 
 from .util.util import CellVarsFile,load_nodes_from_config #, missing_units
 from bmtk.analyzer.utils import listify
@@ -849,6 +850,169 @@ def raster(spikes_df: Optional[pd.DataFrame] = None, config: Optional[str] = Non
     
     return ax
     
+# uses df from bmtool.analysis.spikes compute_firing_rate_stats
+def plot_firing_rate_pop_stats(firing_stats: pd.DataFrame, groupby: Union[str, List[str]], ax: Optional[Axes] = None, 
+                               color_map: Optional[Dict[str, str]] = None) -> Axes:
+    """
+    Plots a bar graph of mean firing rates with error bars (standard deviation).
+
+    Parameters:
+    ----------
+    firing_stats : pd.DataFrame
+        Dataframe containing 'firing_rate_mean' and 'firing_rate_std'.
+    groupby : str or list of str
+        Column(s) used for grouping.
+    ax : matplotlib.axes.Axes, optional
+        Axes on which to plot the bar chart; if None, a new figure and axes are created.
+    color_map : dict, optional
+        Dictionary specifying colors for each group. Keys should be group names, and values should be color values.
+
+    Returns:
+    -------
+    matplotlib.axes.Axes
+        Axes with the bar plot.
+    """
+    # Ensure groupby is a list for consistent handling
+    if isinstance(groupby, str):
+        groupby = [groupby]
+
+    # Create a categorical column for grouping
+    firing_stats["group"] = firing_stats[groupby].astype(str).agg("_".join, axis=1)
+
+    # Get unique group names
+    unique_groups = firing_stats["group"].unique()
+
+    # Generate colors if no color_map is provided
+    if color_map is None:
+        cmap = plt.get_cmap('viridis')
+        color_map = {group: cmap(i / len(unique_groups)) for i, group in enumerate(unique_groups)}
+    else:
+        # Ensure color_map contains all groups
+        missing_colors = [group for group in unique_groups if group not in color_map]
+        if missing_colors:
+            raise ValueError(f"color_map is missing colors for groups: {missing_colors}")
+
+    # Create new figure and axes if ax is not provided
+    if ax is None:
+        fig, ax = plt.subplots(figsize=(10, 6))
+
+    # Sort data for consistent plotting
+    firing_stats = firing_stats.sort_values(by="group")
+
+    # Extract values for plotting
+    x_labels = firing_stats["group"]
+    means = firing_stats["firing_rate_mean"]
+    std_devs = firing_stats["firing_rate_std"]
+
+    # Get colors for each group
+    colors = [color_map[group] for group in x_labels]
+
+    # Create bar plot
+    bars = ax.bar(x_labels, means, yerr=std_devs, capsize=5, color=colors, edgecolor="black")
+
+    # Add error bars manually with caps
+    _, caps, _ = ax.errorbar(
+        x=np.arange(len(x_labels)), 
+        y=means, 
+        yerr=std_devs, 
+        fmt='none', 
+        capsize=5, 
+        capthick=2, 
+        color="black"
+    )
+
+    # Formatting
+    ax.set_xticks(np.arange(len(x_labels)))
+    ax.set_xticklabels(x_labels, rotation=45, ha="right")
+    ax.set_xlabel("Population Group")
+    ax.set_ylabel("Mean Firing Rate (spikes/s)")
+    ax.set_title("Firing Rate Statistics by Population")
+    ax.grid(axis='y', linestyle='--', alpha=0.7)
+
+    return ax
+
+# uses df from bmtool.analysis.spikes compute_firing_rate_stats
+def plot_firing_rate_distribution(individual_stats: pd.DataFrame, groupby: Union[str, list], ax: Optional[Axes] = None, 
+                                  color_map: Optional[Dict[str, str]] = None, 
+                                  plot_type: Union[str, list] = "box", swarm_alpha: float = 0.6) -> Axes:
+    """
+    Plots a distribution of individual firing rates using one or more plot types
+    (box plot, violin plot, or swarm plot), overlaying them on top of each other.
+
+    Parameters:
+    ----------
+    individual_stats : pd.DataFrame
+        Dataframe containing individual firing rates and corresponding group labels.
+    groupby : str or list of str
+        Column(s) used for grouping.
+    ax : matplotlib.axes.Axes, optional
+        Axes on which to plot the graph; if None, a new figure and axes are created.
+    color_map : dict, optional
+        Dictionary specifying colors for each group. Keys should be group names, and values should be color values.
+    plot_type : str or list of str, optional
+        List of plot types to generate. Options: "box", "violin", "swarm". Default is "box".
+    swarm_alpha : float, optional
+        Transparency of swarm plot points. Default is 0.6.
+
+    Returns:
+    -------
+    matplotlib.axes.Axes
+        Axes with the selected plot type(s) overlayed.
+    """
+    # Ensure groupby is a list for consistent handling
+    if isinstance(groupby, str):
+        groupby = [groupby]
+
+    # Create a categorical column for grouping
+    individual_stats["group"] = individual_stats[groupby].astype(str).agg("_".join, axis=1)
+
+    # Validate plot_type (it can be a list or a single type)
+    if isinstance(plot_type, str):
+        plot_type = [plot_type]
+    
+    for pt in plot_type:
+        if pt not in ["box", "violin", "swarm"]:
+            raise ValueError("plot_type must be one of: 'box', 'violin', 'swarm'.")
+
+    # Get unique groups for coloring
+    unique_groups = individual_stats["group"].unique()
+
+    # Generate colors if no color_map is provided
+    if color_map is None:
+        cmap = plt.get_cmap('viridis')
+        color_map = {group: cmap(i / len(unique_groups)) for i, group in enumerate(unique_groups)}
+    
+    # Ensure color_map contains all groups
+    missing_colors = [group for group in unique_groups if group not in color_map]
+    if missing_colors:
+        raise ValueError(f"color_map is missing colors for groups: {missing_colors}")
+
+    # Create new figure and axes if ax is not provided
+    if ax is None:
+        fig, ax = plt.subplots(figsize=(10, 6))
+
+    # Sort data for consistent plotting
+    individual_stats = individual_stats.sort_values(by="group")
+
+    # Loop over each plot type and overlay them
+    for pt in plot_type:
+        if pt == "box":
+            sns.boxplot(data=individual_stats, x="group", y="firing_rate", ax=ax, palette=color_map, width=0.5)
+        elif pt == "violin":
+            sns.violinplot(data=individual_stats, x="group", y="firing_rate", ax=ax, palette=color_map, inner="quartile", alpha=0.4)
+        elif pt == "swarm":
+            sns.swarmplot(data=individual_stats, x="group", y="firing_rate", ax=ax, palette=color_map, alpha=swarm_alpha)
+
+    # Formatting
+    ax.set_xticklabels(ax.get_xticklabels(), rotation=45, ha="right")
+    ax.set_xlabel("Population Group")
+    ax.set_ylabel("Firing Rate (spikes/s)")
+    ax.set_title("Firing Rate Distribution for individual cells")
+    ax.grid(axis='y', linestyle='--', alpha=0.7)
+
+    return ax
+  
+    
 def plot_3d_positions(config=None, populations_list=None, group_by=None, title=None, save_file=None, subset=None):
     """
     Plots a 3D graph of all cells with x, y, z location.
@@ -1154,164 +1318,3 @@ def plot_report_default(config, report_name, variables, gids):
     plot_report(config_file=config, report_file=report_file, report_name=report_name, variables=variables, gids=gids);
     
     return
-
-# The following code was developed by Matthew Stroud 7/15/21 neural engineering supervisor: Satish Nair
-# This is an extension of bmtool: a development of Tyler Banks. 
-# The goal of the sim_setup() function is to output relevant simulation information that can be gathered by providing only the main configuration file.
-
-
-def sim_setup(config_file='simulation_config.json',network=None):
-    if "JPY_PARENT_PID" in os.environ:
-        print("Inside a notebook:")
-        get_ipython().run_line_magic('matplotlib', 'tk')
-
-    
-    # Output tables that contain the cells involved in the configuration file given. Also returns the first biophysical network found
-    bio=plot_basic_cell_info(config_file)
-    if network == None:
-        network=bio
-
-    print("Please wait. This may take a while depending on your network size...")
-    # Plot connection probabilities
-    plt.close(1)
-    probability_connection_matrix(config=config_file,sources=network,targets=network, no_prepend_pop=True,sids= 'pop_name', tids= 'pop_name', bins=10,line_plot=True,verbose=False)
-    # Gives current clamp information
-    plot_I_clamps(config_file)
-    # Plot spike train info
-    plot_inspikes(config_file)
-    # Using bmtool, print total number of connections between cell groups
-    total_connection_matrix(config=config_file,sources='all',targets='all',sids='pop_name',tids='pop_name',title='All Connections found', size_scalar=2, no_prepend_pop=True, synaptic_info='0')
-    # Plot 3d positions of the network
-    plot_3d_positions(populations='all',config=config_file,group_by='pop_name',title='3D Positions',save_file=None)
-
-def plot_I_clamps(fp):
-    print("Plotting current clamp info...")
-    clamps = util.load_I_clamp_from_config(fp)
-    if not clamps:
-        print("     No current clamps were found.")
-        return
-    time=[]
-    num_clamps=0
-    fig, ax = plt.subplots()
-    ax = plt.gca()
-    for clinfo in clamps:
-        simtime=len(clinfo[0])*clinfo[1]
-        time.append(np.arange(0,simtime,clinfo[1]).tolist())
-
-        line,=ax.plot(time[num_clamps],clinfo[0],drawstyle='steps')
-        line.set_label('I Clamp to: '+str(clinfo[2]))
-        plt.legend()
-        num_clamps=num_clamps+1
-
-def plot_basic_cell_info(config_file):
-    print("Network and node info:")
-    nodes=util.load_nodes_from_config(config_file)
-    if not nodes:
-        print("No nodes were found.")
-        return
-    pd.set_option("display.max_rows", None, "display.max_columns", None)
-    bio=[]
-    i=0
-    j=0
-    for j in nodes:
-        node=nodes[j]
-        node_type_id=node['node_type_id']
-        num_cells=len(node['node_type_id'])
-        if node['model_type'][0]=='virtual':
-            CELLS=[]
-            count=1
-            for i in range(num_cells-1):
-                if(node_type_id[i]==node_type_id[i+1]):
-                    count+=1
-                else:
-                    node_type=node_type_id[i]
-                    pop_name=node['pop_name'][i]
-                    model_type=node['model_type'][i]
-                    CELLS.append([node_type,pop_name,model_type,count])
-                    count=1
-            else:
-                node_type=node_type_id[i]
-                pop_name=node['pop_name'][i]
-                model_type=node['model_type'][i]
-                CELLS.append([node_type,pop_name,model_type,count])
-                count=1
-            df1 = pd.DataFrame(CELLS, columns = ["node_type","pop_name","model_type","count"])
-            print(j+':')
-            notebook = is_notebook()
-            if notebook == True:
-                display(HTML(df1.to_html()))
-            else:
-                print(df1)
-        elif node['model_type'][0]=='biophysical':
-            CELLS=[]
-            count=1
-            node_type_id=node['node_type_id']
-            num_cells=len(node['node_type_id'])
-            for i in range(num_cells-1):
-                if(node_type_id[i]==node_type_id[i+1]):
-                    count+=1
-                else:
-                    node_type=node_type_id[i]
-                    pop_name=node['pop_name'][i]
-                    model_type=node['model_type'][i]
-                    model_template=node['model_template'][i]
-                    morphology=node['morphology'][i] if node['morphology'][i] else ''
-                    CELLS.append([node_type,pop_name,model_type,model_template,morphology,count])
-                    count=1
-            else:
-                node_type=node_type_id[i]
-                pop_name=node['pop_name'][i]
-                model_type=node['model_type'][i]
-                model_template=node['model_template'][i]
-                morphology=node['morphology'][i] if node['morphology'][i] else ''
-                CELLS.append([node_type,pop_name,model_type,model_template,morphology,count])
-                count=1
-            df2 = pd.DataFrame(CELLS, columns = ["node_type","pop_name","model_type","model_template","morphology","count"])
-            print(j+':')
-            bio.append(j)
-            notebook = is_notebook()
-            if notebook == True:
-                display(HTML(df2.to_html()))
-            else:
-                print(df2)
-    if len(bio)>0:      
-        return bio[0]        
-
-def plot_inspikes(fp):
-    
-    print("Plotting spike Train info...")
-    trains = util.load_inspikes_from_config(fp)
-    if not trains:
-        print("No spike trains were found.")
-    num_trains=len(trains)
-
-    time=[]
-    node=[]
-    fig, ax = plt.subplots(num_trains, figsize=(12,12),squeeze=False)
-    fig.subplots_adjust(hspace=0.5, wspace=0.5)
-
-    pos=0
-    for tr in trains:
-        node_group=tr[0][2]
-        if node_group=='':
-            node_group='Defined by gids (y-axis)'
-        time=[]
-        node=[]
-        for sp in tr:
-            node.append(sp[1])
-            time.append(sp[0])
-
-        #plotting spike train
-        
-        ax[pos,0].scatter(time,node,s=1)
-        ax[pos,0].title.set_text('Input Spike Train to: '+node_group)
-        plt.xticks(rotation = 45)
-        if num_trains <=4:
-            ax[pos,0].xaxis.set_major_locator(plt.MaxNLocator(20))
-        if num_trains <=9 and num_trains >4:
-            ax[pos,0].xaxis.set_major_locator(plt.MaxNLocator(4))
-        elif num_trains <9:
-            ax[pos,0].xaxis.set_major_locator(plt.MaxNLocator(2))
-        #fig.suptitle('Input Spike Train to: '+node_group, fontsize=14)
-        fig.show()
-        pos+=1

{bmtool-0.6.7.1.dist-info → bmtool-0.6.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: bmtool
-Version: 0.6.7.1
+Version: 0.6.8.1
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 
@@ -31,6 +31,7 @@ Requires-Dist: pynmodlt
 Requires-Dist: xarray
 Requires-Dist: fooof
 Requires-Dist: requests
+Requires-Dist: pyyaml
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -38,6 +39,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 
@@ -53,6 +55,7 @@ A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/
 - [Synapses](#synapses-module)
 - [Connectors](#connectors-module)
 - [Bmplot](#bmplot-module)
+- [Analysis](#analysis-module)
 - [SLURM](#slurm-module)
 - [Graphs](#graphs-module)
 
@@ -471,7 +474,11 @@ bmplot.plot_network_graph(config='config.json',sources='LA',targets='LA',tids='p
 
     
 ![png](readme_figures/output_35_0.png)
-    
+
+
+## Analysis Module
+### A notebook example of how to use the spikes module can be found [here](examples/analysis/using_spikes.ipynb)
+
 ## SLURM Module
 ### This is an extremely helpful module that can simplify using SLURM too submit your models. There is also features to enable doing a seedSweep. This will vary the parameters of the simulation and make tuning the model easier. An example can be found [here](examples/SLURM/using_BlockRunner.ipynb) 
 

{bmtool-0.6.7.1.dist-info → bmtool-0.6.8.1.dist-info}/RECORD

@@ -1,7 +1,7 @@
 bmtool/SLURM.py,sha256=AKxu_Ln9wuCBVLdOJP4yAN59jYt222DM-iUlsQojNvY,18145
 bmtool/__init__.py,sha256=ZStTNkAJHJxG7Pwiy5UgCzC4KlhMS5pUNPtUJZVwL_Y,136
 bmtool/__main__.py,sha256=TmFkmDxjZ6250nYD4cgGhn-tbJeEm0u-EMz2ajAN9vE,650
-bmtool/bmplot.py,sha256=iTK6q8XEqc8QEAKR152ut_1qdtnMoEe1Uq-4dCrkCA0,53992
+bmtool/bmplot.py,sha256=YoI7StM9qeZqyRfFX4M7oUGFz50tXTDOMIUqjYozj9s,54066
 bmtool/connectors.py,sha256=hWkUUcJ4tmas8NDOFPPjQT-TgTlPcpjuZsYyAW2WkPA,72242
 bmtool/graphs.py,sha256=K8BiughRUeXFVvAgo8UzrwpSClIVg7UfmIcvtEsEsk0,6020
 bmtool/manage.py,sha256=_lCU0qBQZ4jSxjzAJUd09JEetb--cud7KZgxQFbLGSY,657
@@ -10,7 +10,7 @@ bmtool/singlecell.py,sha256=XZAT_2n44EhwqVLnk3qur9aO7oJ-10axJZfwPBslM88,27219
 bmtool/synapses.py,sha256=gIkfLhKDG2dHHCVJJoKuQrFn_Qut843bfk_-s97wu6c,54553
 bmtool/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/analysis/lfp.py,sha256=Zp-aJ8x2KmsI3h_mqvq4u9ixFYu4n0CxQpgdbYnrtYE,14909
-bmtool/analysis/spikes.py,sha256=23k_wFOC9pKQgetxMp1V2z6cZaW2eoIZAZyjFiTfrrM,8560
+bmtool/analysis/spikes.py,sha256=qqJ4zD8xfvSwltlWm_Bhicdngzl6uBqH6Kn5wOMKRc8,11507
 bmtool/debug/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/debug/commands.py,sha256=AwtcR7BUUheM0NxvU1Nu234zCdpobhJv5noX8x5K2vY,583
 bmtool/debug/debug.py,sha256=xqnkzLiH3s-tS26Y5lZZL62qR2evJdi46Gud-HzxEN4,207
@@ -19,9 +19,9 @@ bmtool/util/commands.py,sha256=zJF-fiLk0b8LyzHDfvewUyS7iumOxVnj33IkJDzux4M,64396
 bmtool/util/util.py,sha256=00vOAwTVIifCqouBoFoT0lBashl4fCalrk8fhg_Uq4c,56654
 bmtool/util/neuron/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/util/neuron/celltuner.py,sha256=xSRpRN6DhPFz4q5buq_W8UmsD7BbUrkzYBEbKVloYss,87194
-bmtool-0.6.7.1.dist-info/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.6.7.1.dist-info/METADATA,sha256=qlkGt9KNUlVP7C3J1xgvj23YUHaPD7SlVFzhVhSUceg,20226
-bmtool-0.6.7.1.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
-bmtool-0.6.7.1.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.6.7.1.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.6.7.1.dist-info/RECORD,,
+bmtool-0.6.8.1.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
+bmtool-0.6.8.1.dist-info/METADATA,sha256=YVdlvlptmCrgkau7KEk_HkbEi__QcX0bAxDwe4eExJM,20431
+bmtool-0.6.8.1.dist-info/WHEEL,sha256=tTnHoFhvKQHCh4jz3yCn0WPTYIy7wXx3CJtJ7SJGV7c,91
+bmtool-0.6.8.1.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
+bmtool-0.6.8.1.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
+bmtool-0.6.8.1.dist-info/RECORD,,

{bmtool-0.6.7.1.dist-info → bmtool-0.6.8.1.dist-info}/WHEEL

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