bmtool 0.7.3__py3-none-any.whl → 0.7.4__py3-none-any.whl

bmtool/bmplot/connections.py

@@ -13,6 +13,8 @@ import numpy as np
 import pandas as pd
 from IPython import get_ipython
 
+from neuron import h
+
 from ..util import util
 
 use_description = """
@@ -981,7 +983,7 @@ def distance_delay_plot(
     plt.show()
 
 
-def plot_synapse_location(config: str, source: str, target: str, sids: str, tids: str) -> tuple:
+def plot_synapse_location(config: str, source: str, target: str, sids: str, tids: str, syn_feature: str = 'afferent_section_id') -> tuple:
     """
     Generates a connectivity matrix showing synaptic distribution across different cell sections.
     Note does exclude gap junctions since they dont have an afferent id stored in the h5 file!
@@ -998,6 +1000,8 @@ def plot_synapse_location(config: str, source: str, target: str, sids: str, tids
         Column name in nodes file containing source population identifiers
     tids : str
         Column name in nodes file containing target population identifiers
+    syn_feature : str, default 'afferent_section_id'
+        Synaptic feature to analyze ('afferent_section_id' or 'afferent_section_pos')
 
     Returns
     -------
@@ -1011,22 +1015,22 @@ def plot_synapse_location(config: str, source: str, target: str, sids: str, tids
     RuntimeError
         If template loading or cell instantiation fails
     """
-    import matplotlib.pyplot as plt
-    import numpy as np
-    from neuron import h
-
     # Validate inputs
     if not all([config, source, target, sids, tids]):
         raise ValueError(
             "Missing required parameters: config, source, target, sids, and tids must be provided"
         )
 
+    # Fix the validation logic - it was using 'or' instead of 'and'
+    if syn_feature not in ["afferent_section_id", "afferent_section_pos"]:
+        raise ValueError("Currently only syn features supported are afferent_section_id or afferent_section_pos")
+
     try:
         # Load mechanisms and template
         util.load_templates_from_config(config)
     except Exception as e:
         raise RuntimeError(f"Failed to load templates from config: {str(e)}")
-
+    
     try:
         # Load node and edge data
         nodes, edges = util.load_nodes_edges_from_config(config)
@@ -1036,17 +1040,17 @@ def plot_synapse_location(config: str, source: str, target: str, sids: str, tids
         target_nodes = nodes[target]
         source_nodes = nodes[source]
         edges = edges[f"{source}_to_{target}"]
-        # Find edges with NaN afferent_section_id
-        nan_edges = edges[edges["afferent_section_id"].isna()]
+        
+        # Find edges with NaN values in the specified feature
+        nan_edges = edges[edges[syn_feature].isna()]
         # Print information about removed edges
         if not nan_edges.empty:
             unique_indices = sorted(list(set(nan_edges.index.tolist())))
-            print(f"Removing {len(nan_edges)} edges with missing afferent_section_id")
+            print(f"Removing {len(nan_edges)} edges with missing {syn_feature}")
             print(f"Unique indices removed: {unique_indices}")
             
-        # Filter out edges with NaN afferent_section_id
-        edges = edges[edges["afferent_section_id"].notna()]
-
+        # Filter out edges with NaN values in the specified feature
+        edges = edges[edges[syn_feature].notna()]
 
     except Exception as e:
         raise RuntimeError(f"Failed to load nodes and edges: {str(e)}")
@@ -1116,7 +1120,7 @@ def plot_synapse_location(config: str, source: str, target: str, sids: str, tids
                 section_mapping = section_mappings[target_model_template]
 
                 # Calculate section distribution
-                section_counts = filtered_edges["afferent_section_id"].value_counts()
+                section_counts = filtered_edges[syn_feature].value_counts()
                 section_percentages = (section_counts / total_connections * 100).round(1)
 
                 # Format section distribution text - show all sections
@@ -1125,16 +1129,17 @@ def plot_synapse_location(config: str, source: str, target: str, sids: str, tids
                     section_name = section_mapping.get(section_id, f"sec_{section_id}")
                     section_display.append(f"{section_name}:{percentage}%")
 
+
                 num_connections[source_idx, target_idx] = total_connections
                 text_data[source_idx, target_idx] = "\n".join(section_display)
 
             except Exception as e:
                 print(f"Warning: Error processing {target_model_template}: {str(e)}")
                 num_connections[source_idx, target_idx] = total_connections
-                text_data[source_idx, target_idx] = "Section info N/A"
+                text_data[source_idx, target_idx] = "Feature info N/A"
 
     # Create the plot
-    title = f"Synaptic Distribution by Section: {source} to {target}"
+    title = f"Synaptic Distribution by {syn_feature.replace('_', ' ').title()}: {source} to {target}"
     fig, ax = plot_connection_info(
         text=text_data,
         num=num_connections,

bmtool/bmplot/lfp.py

@@ -1,7 +1,6 @@
 import matplotlib.pyplot as plt
 import numpy as np
-
-from bmtool.analysis.lfp import gen_aperiodic
+from fooof.sim.gen import gen_aperiodic
 
 
 def plot_spectrogram(

bmtool/synapses.py

@@ -20,68 +20,104 @@ from tqdm.notebook import tqdm
 
 from bmtool.util.util import load_templates_from_config
 
+DEFAULT_GENERAL_SETTINGS = {
+    "vclamp": True,
+    "rise_interval": (0.1, 0.9),
+    "tstart": 500.0,
+    "tdur": 100.0,
+    "threshold": -15.0,
+    "delay": 1.3,
+    "weight": 1.0,
+    "dt": 0.025,
+    "celsius": 20,
+}
+
+DEFAULT_GAP_JUNCTION_GENERAL_SETTINGS = {
+    "tstart": 500.0,
+    "tdur": 500.0,
+    "dt": 0.025,
+    "celsius": 20,
+}
+
 
 class SynapseTuner:
     def __init__(
         self,
-        mechanisms_dir: str = None,
-        templates_dir: str = None,
-        config: str = None,
-        conn_type_settings: dict = None,
-        connection: str = None,
-        general_settings: dict = None,
-        json_folder_path: str = None,
+        mechanisms_dir: Optional[str] = None,
+        templates_dir: Optional[str] = None,
+        config: Optional[str] = None,
+        conn_type_settings: Optional[dict] = None,
+        connection: Optional[str] = None,
+        general_settings: Optional[dict] = None,
+        json_folder_path: Optional[str] = None,
         current_name: str = "i",
-        other_vars_to_record: list = None,
-        slider_vars: list = None,
+        other_vars_to_record: Optional[list] = None,
+        slider_vars: Optional[list] = None,
+        hoc_cell: Optional[object] = None,
     ) -> None:
         """
-        Initialize the SynapseModule class with connection type settings, mechanisms, and template directories.
+        Initialize the SynapseTuner class with connection type settings, mechanisms, and template directories.
 
         Parameters:
         -----------
-        mechanisms_dir : str
+        mechanisms_dir : Optional[str]
             Directory path containing the compiled mod files needed for NEURON mechanisms.
-        templates_dir : str
+        templates_dir : Optional[str]
             Directory path containing cell template files (.hoc or .py) loaded into NEURON.
-        conn_type_settings : dict
+        conn_type_settings : Optional[dict]
             A dictionary containing connection-specific settings, such as synaptic properties and details.
-        connection : str
+        connection : Optional[str]
             Name of the connection type to be used from the conn_type_settings dictionary.
-        general_settings : dict
+        general_settings : Optional[dict]
             General settings dictionary including parameters like simulation time step, duration, and temperature.
-        json_folder_path : str, optional
+        json_folder_path : Optional[str]
             Path to folder containing JSON files with additional synaptic properties to update settings.
         current_name : str, optional
             Name of the synaptic current variable to be recorded (default is 'i').
-        other_vars_to_record : list, optional
+        other_vars_to_record : Optional[list]
             List of additional synaptic variables to record during the simulation (e.g., 'Pr', 'Use').
-        slider_vars : list, optional
+        slider_vars : Optional[list]
             List of synaptic variables you would like sliders set up for the STP sliders method by default will use all parameters in spec_syn_param.
-
+        hoc_cell : Optional[object]
+            An already loaded NEURON cell object. If provided, template loading and cell setup will be skipped.
         """
-        if config is None and (mechanisms_dir is None or templates_dir is None):
-            raise ValueError(
-                "Either a config file or both mechanisms_dir and templates_dir must be provided."
-            )
+        self.hoc_cell = hoc_cell
 
-        if config is None:
-            neuron.load_mechanisms(mechanisms_dir)
-            h.load_file(templates_dir)
-        else:
-            # loads both mech and templates
-            load_templates_from_config(config)
+        if hoc_cell is None:
+            if config is None and (mechanisms_dir is None or templates_dir is None):
+                raise ValueError(
+                    "Either a config file, both mechanisms_dir and templates_dir, or a hoc_cell must be provided."
+                )
 
-        self.conn_type_settings = conn_type_settings
+            if config is None:
+                neuron.load_mechanisms(mechanisms_dir)
+                h.load_file(templates_dir)
+            else:
+                # loads both mech and templates
+                load_templates_from_config(config)
+
+        if conn_type_settings is None:
+            raise ValueError("conn_type_settings must be provided.")
+        if connection is None:
+            raise ValueError("connection must be provided.")
+        if connection not in conn_type_settings:
+            raise ValueError(f"connection '{connection}' not found in conn_type_settings.")
+
+        self.conn_type_settings: dict = conn_type_settings
         if json_folder_path:
             print(f"updating settings from json path {json_folder_path}")
             self._update_spec_syn_param(json_folder_path)
-        self.general_settings = general_settings
+        # Use default general settings if not provided
+        if general_settings is None:
+            self.general_settings: dict = DEFAULT_GENERAL_SETTINGS.copy()
+        else:
+            # Merge defaults with user-provided
+            self.general_settings = {**DEFAULT_GENERAL_SETTINGS, **general_settings}
         self.conn = self.conn_type_settings[connection]
         self.synaptic_props = self.conn["spec_syn_param"]
-        self.vclamp = general_settings["vclamp"]
+        self.vclamp = self.general_settings["vclamp"]
         self.current_name = current_name
-        self.other_vars_to_record = other_vars_to_record
+        self.other_vars_to_record = other_vars_to_record or []
         self.ispk = None
 
         if slider_vars:
@@ -94,25 +130,26 @@ class SynapseTuner:
                 # If the key is missing from synaptic_props, get the value using getattr
                 if key not in self.synaptic_props:
                     try:
-                        # Get the alternative value from getattr dynamically
                         self._set_up_cell()
                         self._set_up_synapse()
                         value = getattr(self.syn, key)
-                        # print(value)
                         self.slider_vars[key] = value
                     except AttributeError as e:
                         print(f"Error accessing '{key}' in syn {self.syn}: {e}")
-
         else:
             self.slider_vars = self.synaptic_props
 
-        h.tstop = general_settings["tstart"] + general_settings["tdur"]
-        h.dt = general_settings["dt"]  # Time step (resolution) of the simulation in ms
+        h.tstop = self.general_settings["tstart"] + self.general_settings["tdur"]
+        h.dt = self.general_settings["dt"]  # Time step (resolution) of the simulation in ms
         h.steps_per_ms = 1 / h.dt
-        h.celsius = general_settings["celsius"]
+        h.celsius = self.general_settings["celsius"]
 
         # get some stuff set up we need for both SingleEvent and Interactive Tuner
-        self._set_up_cell()
+        # Only set up cell if hoc_cell was not provided
+        if self.hoc_cell is None:
+            self._set_up_cell()
+        else:
+            self.cell = self.hoc_cell
         self._set_up_synapse()
 
         self.nstim = h.NetStim()
@@ -137,7 +174,7 @@ class SynapseTuner:
 
         self._set_up_recorders()
 
-    def _update_spec_syn_param(self, json_folder_path):
+    def _update_spec_syn_param(self, json_folder_path: str) -> None:
         """
         Update specific synaptic parameters using JSON files located in the specified folder.
 
@@ -146,6 +183,8 @@ class SynapseTuner:
         json_folder_path : str
             Path to folder containing JSON files, where each JSON file corresponds to a connection type.
         """
+        if not self.conn_type_settings:
+            return
         for conn_type, settings in self.conn_type_settings.items():
             json_file_path = os.path.join(json_folder_path, f"{conn_type}.json")
             if os.path.exists(json_file_path):
@@ -155,13 +194,17 @@ class SynapseTuner:
             else:
                 print(f"JSON file for {conn_type} not found.")
 
-    def _set_up_cell(self):
+    def _set_up_cell(self) -> None:
         """
         Set up the neuron cell based on the specified connection settings.
+        This method is only called when hoc_cell is not provided.
         """
-        self.cell = getattr(h, self.conn["spec_settings"]["post_cell"])()
+        if self.hoc_cell is None:
+            self.cell = getattr(h, self.conn["spec_settings"]["post_cell"])()
+        else:
+            self.cell = self.hoc_cell
 
-    def _set_up_synapse(self):
+    def _set_up_synapse(self) -> None:
         """
         Set up the synapse on the target cell according to the synaptic parameters in `conn_type_settings`.
 
@@ -176,7 +219,7 @@ class SynapseTuner:
             )
         )
         for key, value in self.conn["spec_syn_param"].items():
-            if isinstance(value, (int, float)):  # Only create sliders for numeric values
+            if isinstance(value, (int, float)):
                 if hasattr(self.syn, key):
                     setattr(self.syn, key, value)
                 else:
@@ -184,7 +227,7 @@ class SynapseTuner:
                         f"Warning: {key} cannot be assigned as it does not exist in the synapse. Check your mod file or spec_syn_param."
                     )
 
-    def _set_up_recorders(self):
+    def _set_up_recorders(self) -> None:
         """
         Set up recording vectors to capture simulation data.
 
@@ -952,11 +995,12 @@ class SynapseTuner:
 class GapJunctionTuner:
     def __init__(
         self,
-        mechanisms_dir: str = None,
-        templates_dir: str = None,
-        config: str = None,
-        general_settings: dict = None,
-        conn_type_settings: dict = None,
+        mechanisms_dir: Optional[str] = None,
+        templates_dir: Optional[str] = None,
+        config: Optional[str] = None,
+        general_settings: Optional[dict] = None,
+        conn_type_settings: Optional[dict] = None,
+        hoc_cell: Optional[object] = None,
     ):
         """
         Initialize the GapJunctionTuner class.
@@ -973,34 +1017,49 @@ class GapJunctionTuner:
             General settings dictionary including parameters like simulation time step, duration, and temperature.
         conn_type_settings : dict
             A dictionary containing connection-specific settings for gap junctions.
+        hoc_cell : object, optional
+            An already loaded NEURON cell object. If provided, template loading and cell creation will be skipped.
         """
-        if config is None and (mechanisms_dir is None or templates_dir is None):
-            raise ValueError(
-                "Either a config file or both mechanisms_dir and templates_dir must be provided."
-            )
+        self.hoc_cell = hoc_cell
 
-        if config is None:
-            neuron.load_mechanisms(mechanisms_dir)
-            h.load_file(templates_dir)
-        else:
-            # this will load both mechs and templates
-            load_templates_from_config(config)
+        if hoc_cell is None:
+            if config is None and (mechanisms_dir is None or templates_dir is None):
+                raise ValueError(
+                    "Either a config file, both mechanisms_dir and templates_dir, or a hoc_cell must be provided."
+                )
+
+            if config is None:
+                neuron.load_mechanisms(mechanisms_dir)
+                h.load_file(templates_dir)
+            else:
+                # this will load both mechs and templates
+                load_templates_from_config(config)
 
-        self.general_settings = general_settings
+        # Use default general settings if not provided, merge with user-provided
+        if general_settings is None:
+            self.general_settings: dict = DEFAULT_GAP_JUNCTION_GENERAL_SETTINGS.copy()
+        else:
+            self.general_settings = {**DEFAULT_GAP_JUNCTION_GENERAL_SETTINGS, **general_settings}
         self.conn_type_settings = conn_type_settings
 
-        h.tstop = general_settings["tstart"] + general_settings["tdur"] + 100.0
-        h.dt = general_settings["dt"]  # Time step (resolution) of the simulation in ms
+        h.tstop = self.general_settings["tstart"] + self.general_settings["tdur"] + 100.0
+        h.dt = self.general_settings["dt"]  # Time step (resolution) of the simulation in ms
         h.steps_per_ms = 1 / h.dt
-        h.celsius = general_settings["celsius"]
-
-        self.cell_name = conn_type_settings["cell"]
+        h.celsius = self.general_settings["celsius"]
 
         # set up gap junctions
         pc = h.ParallelContext()
 
-        self.cell1 = getattr(h, self.cell_name)()
-        self.cell2 = getattr(h, self.cell_name)()
+        # Use provided hoc_cell or create new cells
+        if self.hoc_cell is not None:
+            self.cell1 = self.hoc_cell
+            # For gap junctions, we need two cells, so create a second one if using hoc_cell
+            self.cell_name = conn_type_settings["cell"]
+            self.cell2 = getattr(h, self.cell_name)()
+        else:
+            self.cell_name = conn_type_settings["cell"]
+            self.cell1 = getattr(h, self.cell_name)()
+            self.cell2 = getattr(h, self.cell_name)()
 
         self.icl = h.IClamp(self.cell1.soma[0](0.5))
         self.icl.delay = self.general_settings["tstart"]
@@ -1247,6 +1306,10 @@ class SynapseOptimizer:
             - max_amplitude: maximum synaptic response amplitude
             - rise_time: time for synaptic response to rise from 20% to 80% of peak
             - decay_time: time constant of synaptic response decay
+            - latency: synaptic response latency
+            - half_width: synaptic response half-width
+            - baseline: baseline current
+            - amp: peak amplitude from syn_props
         """
         # Set these to 0 for when we return the dict
         induction = 0
@@ -1255,11 +1318,22 @@ class SynapseOptimizer:
         amp = 0
         rise_time = 0
         decay_time = 0
+        latency = 0
+        half_width = 0
+        baseline = 0
+        syn_amp = 0
 
         if self.run_single_event:
             self.tuner.SingleEvent(plot_and_print=False)
-            rise_time = self.tuner.rise_time
-            decay_time = self.tuner.decay_time
+            # Use the attributes set by SingleEvent method
+            rise_time = getattr(self.tuner, "rise_time", 0)
+            decay_time = getattr(self.tuner, "decay_time", 0)
+            # Get additional syn_props directly
+            syn_props = self.tuner._get_syn_prop()
+            latency = syn_props.get("latency", 0)
+            half_width = syn_props.get("half_width", 0)
+            baseline = syn_props.get("baseline", 0)
+            syn_amp = syn_props.get("amp", 0)
 
         if self.run_train_input:
             self.tuner._simulate_model(self.train_frequency, self.train_delay)
@@ -1276,6 +1350,10 @@ class SynapseOptimizer:
             "max_amplitude": float(amp),
             "rise_time": float(rise_time),
             "decay_time": float(decay_time),
+            "latency": float(latency),
+            "half_width": float(half_width),
+            "baseline": float(baseline),
+            "amp": float(syn_amp),
         }
 
     def _default_cost_function(

{bmtool-0.7.3.dist-info → bmtool-0.7.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmtool
-Version: 0.7.3
+Version: 0.7.4
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 
@@ -36,6 +36,7 @@ Requires-Dist: requests
 Requires-Dist: pyyaml
 Requires-Dist: PyWavelets
 Requires-Dist: numba
+Requires-Dist: tqdm
 Provides-Extra: dev
 Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: pytest>=7.0.0; extra == "dev"

{bmtool-0.7.3.dist-info → bmtool-0.7.4.dist-info}/RECORD

@@ -6,16 +6,16 @@ bmtool/graphs.py,sha256=gBTzI6c2BBK49dWGcfWh9c56TAooyn-KaiEy0Im1HcI,6717
 bmtool/manage.py,sha256=lsgRejp02P-x6QpA7SXcyXdalPhRmypoviIA2uAitQs,608
 bmtool/plot_commands.py,sha256=Dxm_RaT4CtHnfsltTtUopJ4KVbfhxtktEB_b7bFEXII,12716
 bmtool/singlecell.py,sha256=I2yolbAnNC8qpnRkNdnDCLidNW7CktmBuRrcowMZJ3A,45041
-bmtool/synapses.py,sha256=y8UJAqO1jpZY-mY9gVVMN8Dj1r9jD2fI1nAaNQeQfz4,66148
+bmtool/synapses.py,sha256=-kg_TJoqXStIgE5iHpJWpXU6VRKT0YyIVpTw8frNbxA,69653
 bmtool/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/analysis/entrainment.py,sha256=NQloQtVpEWjDzmkZwMWVcm3hSjErHBZfQl1mrBVoIE8,25321
 bmtool/analysis/lfp.py,sha256=S2JvxkjcK3-EH93wCrhqNSFY6cX7fOq74pz64ibHKrc,26556
 bmtool/analysis/netcon_reports.py,sha256=VnPZNKPaQA7oh1q9cIatsqQudm4cOtzNtbGPXoiDCD0,2909
 bmtool/analysis/spikes.py,sha256=3n-xmyEZ7w6CKEND7-aKOAvdDg0lwDuPI5sMdOuPwa0,24637
 bmtool/bmplot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bmtool/bmplot/connections.py,sha256=Tdi-17poEuBBgXcKQ--pcDTDwl029nXg9EConRgZo-k,58928
+bmtool/bmplot/connections.py,sha256=DwnnMp5cUwZC3OqsJqvgTPr4lBzc0sNWYRPmwij0WRk,59337
 bmtool/bmplot/entrainment.py,sha256=BrBMerqyiG2YWAO_OEFv7OJf3yeFz3l9jUt4NamluLc,32837
-bmtool/bmplot/lfp.py,sha256=SNpbWGOUnYEgnkeBw5S--aPN5mIGD22Gw2Pwus0_lvY,2034
+bmtool/bmplot/lfp.py,sha256=7JLozQQJ19ty0ZNyfhkuJAr_K8_pVP9C0flVJd_YXaY,2027
 bmtool/bmplot/netcon_reports.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/bmplot/spikes.py,sha256=odzCSMbFRHp9qthSGQ0WzMWUwNQ7R1Z6gLT6VPF_o5Q,15326
 bmtool/debug/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -26,9 +26,9 @@ bmtool/util/commands.py,sha256=Nn-R-4e9g8ZhSPZvTkr38xeKRPfEMANB9Lugppj82UI,68564
 bmtool/util/util.py,sha256=TAWdGd0tDuouS-JiusMs8WwP7kQpWHPr1nu0XG01TBQ,75056
 bmtool/util/neuron/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/util/neuron/celltuner.py,sha256=lokRLUM1rsdSYBYrNbLBBo39j14mm8TBNVNRnSlhHCk,94868
-bmtool-0.7.3.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.7.3.dist-info/METADATA,sha256=uzyKoEDxd3kJQc89-pzf6wSxR7v3BhBHYEvyqCh5aHM,3575
-bmtool-0.7.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bmtool-0.7.3.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.7.3.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.7.3.dist-info/RECORD,,
+bmtool-0.7.4.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
+bmtool-0.7.4.dist-info/METADATA,sha256=126Cn17YBt6twoBgMXYXK10kOWUXRhnLnGmPr7z7k_4,3595
+bmtool-0.7.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bmtool-0.7.4.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
+bmtool-0.7.4.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
+bmtool-0.7.4.dist-info/RECORD,,