bmtool 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

bmtool/bmplot.py

@@ -3,7 +3,6 @@ Want to be able to take multiple plot names in and plot them all at the same tim
 https://stackoverflow.com/questions/458209/is-there-a-way-to-detach-matplotlib-plots-so-that-the-computation-can-continue
 """
 from .util import util
-
 import argparse,os,sys
 
 import numpy as np
@@ -267,6 +266,82 @@ def divergence_connection_matrix(config=None,title=None,sources=None, targets=No
     plot_connection_info(syn_info,data,source_labels,target_labels,title, save_file=save_file)
     return
 
+def gap_junction_matrix(config=None,title=None,sources=None, targets=None, sids=None,tids=None, no_prepend_pop=False,save_file=None,type='convergence'):
+    """
+    Generates connection plot displaying gap junction data.
+    config: A BMTK simulation config 
+    sources: network name(s) to plot
+    targets: network name(s) to plot
+    sids: source node identifier 
+    tids: target node identifier
+    no_prepend_pop: dictates if population name is displayed before sid or tid when displaying graph
+    save_file: If plot should be saved
+    type:'convergence' or 'percent' connections
+    """
+    if not config:
+        raise Exception("config not defined")
+    if not sources or not targets:
+        raise Exception("Sources or targets not defined")
+    if type !='convergence' and type!='percent':
+        raise Exception("type must be 'convergence' or 'percent'")
+    sources = sources.split(",")
+    targets = targets.split(",")
+    if sids:
+        sids = sids.split(",")
+    else:
+        sids = []
+    if tids:
+        tids = tids.split(",")
+    else:
+        tids = []
+    syn_info, data, source_labels, target_labels = util.gap_junction_connections(config=config,nodes=None,edges=None,sources=sources,targets=targets,sids=sids,tids=tids,prepend_pop=not no_prepend_pop,type=type)
+    
+    
+    def filter_rows(syn_info, data, source_labels, target_labels):
+        new_syn_info = syn_info
+        new_data = data
+        new_source_labels = source_labels
+        new_target_labels = target_labels
+        for row in new_data:
+            row_index = -1
+            try:
+                if((np.isnan(row).all())): #checks if all of a row is nan
+                    row_index = np.where(np.isnan(new_data)==np.isnan(row))[0][0]  
+            except:
+                row_index = -1
+            finally:          
+                if(all(x==0 for x in row)): #checks if all of a row is zeroes
+                    row_index = np.where(new_data==row)[0][0] 
+                if row_index!=-1:   #deletes corresponding row accordingly in all relevant variables.
+                    new_syn_info = np.delete(new_syn_info,row_index,0) 
+                    new_data = np.delete(new_data,row_index,0)
+                    new_source_labels = np.delete(new_source_labels,row_index)
+        return new_syn_info, new_data,new_source_labels,new_target_labels
+
+    def filter_rows_and_columns(syn_info,data,source_labels,target_labels):
+        syn_info, data, source_labels, target_labels = filter_rows(syn_info, data, source_labels, target_labels)
+        transposed_syn_info = np.transpose(syn_info) #transpose everything and put it in to make sure columns get filtered
+        transposed_data = np.transpose(data)
+        transposed_source_labels = target_labels
+        transposed_target_labels = source_labels
+        syn_info, data, source_labels, target_labels = filter_rows(transposed_syn_info, transposed_data, transposed_source_labels, transposed_target_labels)
+        filtered_syn_info = np.transpose(syn_info) #transpose everything back to original order after filtering.
+        filtered_data = np.transpose(data)
+        filtered_source_labels = target_labels
+        filtered_target_labels = source_labels
+        return filtered_syn_info,filtered_data,filtered_source_labels,filtered_target_labels
+    
+    syn_info, data, source_labels, target_labels = filter_rows_and_columns(syn_info, data, source_labels, target_labels)
+
+    if title == None or title=="":
+        title = 'Gap Junction'
+        if type == 'convergence':
+            title+=' Syn Convergence'
+        elif type == 'percent':
+            title+=' Percent Connectivity'
+    plot_connection_info(syn_info,data,source_labels,target_labels,title, save_file=save_file)
+    return
+    
 def connection_histogram(config=None,nodes=None,edges=None,sources=[],targets=[],sids=[],tids=[],prepend_pop=True,synaptic_info='0',
                       source_cell = None,target_cell = None,include_gap=True):
     """

bmtool/connectors.py

@@ -4,6 +4,7 @@ from scipy.special import erf
 from scipy.optimize import minimize_scalar
 from functools import partial
 import time
+import types
 
 rng = np.random.default_rng()
 
@@ -11,6 +12,13 @@ rng = np.random.default_rng()
 ############################## CONNECT CELLS #################################
 
 # Utility Functions
+def num_prop(ratio, N):
+    """Calculate numbers of total N in proportion to ratio"""
+    ratio = np.asarray(ratio)
+    p = np.cumsum(np.insert(ratio.ravel(), 0, 0))  # cumulative proportion
+    return np.diff(np.round(N / p[-1] * p).astype(int)).reshape(ratio.shape)
+
+
 def decision(prob, size=None):
     """
     Make single random decision based on input probability.
@@ -76,10 +84,10 @@ class DistantDependentProbability(ProbabilityFunction):
         assert(min_dist >= 0 and min_dist < max_dist)
         self.min_dist, self.max_dist = min_dist, max_dist
 
-    def __call__(self, dist):
+    def __call__(self, dist, *arg, **kwargs):
         """Return probability for single distance input"""
         if dist >= self.min_dist and dist <= self.max_dist:
-            return self.probability(dist).item()
+            return self.probability(dist)
         else:
             return 0.
 
@@ -88,7 +96,10 @@ class DistantDependentProbability(ProbabilityFunction):
         dist = np.asarray(dist)
         dec = np.zeros(dist.shape, dtype=bool)
         mask = (dist >= self.min_dist) & (dist <= self.max_dist)
-        dec[mask] = decisions(self.probability(dist[mask]))
+        dist = dist[mask]
+        prob = np.empty(dist.shape)
+        prob[:] = self.probability(dist)
+        dec[mask] = decisions(prob)
         return dec
 
 
@@ -99,7 +110,7 @@ class UniformInRange(DistantDependentProbability):
         super().__init__(min_dist=min_dist, max_dist=max_dist)
         self.p = np.array(p)
         assert(self.p.size == 1)
-        assert(self.p >= 0. and self.p <= 1.)
+        assert(p >= 0. and p <= 1.)
 
     def probability(self, dist):
         return self.p
@@ -127,7 +138,7 @@ class GaussianDropoff(DistantDependentProbability):
             input pmax, and calculate pmax. See calc_pmax_from_ptotal() method.
         ptotal_dist_range: Distance range for calculating pmax when ptotal is
         specified. If not specified, set to range (min_dist, max_dist).
-        dist_type: spherical or cylindrical for distance metric.
+        dist_type: 'spherical' or 'cylindrical' for distance metric.
             Used when ptotal is specified.
 
     Returns:
@@ -215,6 +226,51 @@ class GaussianDropoff(DistantDependentProbability):
             self.probability = probability
 
 
+class NormalizedReciprocalRate(ProbabilityFunction):
+    """Reciprocal connection probability given normalized reciprocal rate.
+    Normalized reciprocal rate is defined as the ratio between the reciprocal
+    connection probability and the connection probability for a randomly
+    connected network where the two unidirectional connections between any pair
+    of neurons are independent. NRR = pr / (p0 * p1)
+    
+    Parameters:
+        NRR: a constant or distance dependent function for normalized reciprocal
+            rate. When being a function, it should be accept vectorized input.
+    Returns:
+        A callable object that returns the probability value.
+    """
+
+    def __init__(self, NRR=1.):
+        self.NRR = NRR if callable(NRR) else lambda *x: NRR
+
+    def probability(self, dist, p0, p1):
+        """Allow numpy array input and return probability in numpy array"""
+        return p0 * p1 * self.NRR(dist)
+
+    def __call__(self, dist, p0, p1, *arg, **kwargs):
+        """Return probability for single distance input"""
+        return self.probability(dist, p0, p1)
+
+    def decisions(self, dist, p0, p1, cond=None):
+        """Return bool array of decisions
+        dist: distance (scalar or array). Will be ignored if NRR is constant.
+        p0, p1: forward and backward probability (scalar or array)
+        cond: A tuple (direction, array of outcomes) representing the condition.
+            Conditional probability will be returned if specified. The condition
+            event is determined by connection direction (0 for forward, or 1 for
+            backward) and outcomes (bool array of whether connection exists).
+        """
+        dist, p0, p1 = map(np.asarray, (dist, p0, p1))
+        pr = np.empty(dist.shape)
+        pr[:] = self.probability(dist, p0, p1)
+        pr = np.clip(pr, a_min=np.fmax(p0 + p1 - 1., 0.), a_max=np.fmin(p0, p1))
+        if cond is not None:
+            mask = np.asarray(cond[1])
+            pr[mask] /= p1 if cond[0] else p0
+            pr[~mask] = 0.
+        return decisions(pr)
+
+
 # Connector Classes
 class AbstractConnector(ABC):
     """Abstract base class for connectors"""
@@ -231,22 +287,6 @@ class AbstractConnector(ABC):
         `connection_rule` method."""
         return NotImplemented
 
-    @staticmethod
-    def is_same_pop(source, target, quick=True):
-        """Whether two NodePool objects direct to the same population"""
-        if quick:
-            # Quick check (compare filter conditions)
-            same = (source.network_name == target.network_name and
-                    source._NodePool__properties ==
-                    target._NodePool__properties)
-        else:
-            # Strict check (compare all nodes)
-            same = (source.network_name == target.network_name and
-                    len(source) == len(target) and
-                    all([s.node_id == t.node_id
-                         for s, t in zip(source, target)]))
-        return same
-
     @staticmethod
     def constant_function(val):
         """Convert a constant to a constant function"""
@@ -255,7 +295,23 @@ class AbstractConnector(ABC):
         return constant
 
 
-# Helper class
+# Helper functions
+def is_same_pop(source, target, quick=False):
+    """Check whether two NodePool objects direct to the same population"""
+    if quick:
+        # Quick check (compare filter conditions)
+        same = (source.network_name == target.network_name and
+                source._NodePool__properties ==
+                target._NodePool__properties)
+    else:
+        # Strict check (compare all nodes)
+        same = (source.network_name == target.network_name and
+                len(source) == len(target) and
+                all([s.node_id == t.node_id
+                     for s, t in zip(source, target)]))
+    return same
+
+
 class Timer(object):
     def __init__(self, unit='sec'):
         if unit == 'ms':
@@ -303,7 +359,7 @@ def rho_2_pr(p0, p1, rho):
 
 class ReciprocalConnector(AbstractConnector):
     """
-    Object for building connections in bmtk network model with reciprocal
+    Object for buiilding connections in bmtk network model with reciprocal
     probability within a single population (or between two populations).
 
     Algorithm:
@@ -388,10 +444,17 @@ class ReciprocalConnector(AbstractConnector):
         symmetric_p1_arg: Whether p0_arg and p1_arg are identical. If this is
             set to True, argument p1_arg will be ignored. This is forced to be
             True when the population is recurrent.
-        pr, pr_arg: Probability of reciprocal connection and its input argument
-            when it is a function, similar to p0, p0_arg, p1, p1_arg. It can be
-            a function when it has an explicit relation with some node
-            properties such as distance.
+        pr, pr_arg: Probability of reciprocal connection and its first input
+            argument when it is a function, similar to p0, p0_arg, p1, p1_arg.
+            It can be a function when it has an explicit relation with some node
+            properties such as distance. A function pr requires two additional
+            positional arguments p0 and p1 even if they are not used, i.e.,
+            pr(pr_arg, p0, p1), just in case pr is dependent on p0 and p1, e.g.,
+            when normalized reciprocal rate NRR = pr/(p0*p1) is given.
+            When pr_arg is a string, the same value as p1_arg will be used for
+            pr_arg if the string contains '1', e.g., '1', 'p1'. Otherwise, e.g.,
+            '', '0', 'p0', p0_arg will be used for pr_arg. Specifying this can
+            avoid recomputing pr_arg when it's given by p0_arg or p1_arg.
         estimate_rho: Whether estimate rho that result in an overall pr. This
             is forced to be False if pr is a function or if rho is specified.
             To estimate rho, all the pairs with possible connections, meaning
@@ -425,6 +488,10 @@ class ReciprocalConnector(AbstractConnector):
             into the connection matrix to reduce memory consumption.
         autapses: Whether to allow connecting a cell to itself. Default: False.
             This is ignored when the population is not recurrent.
+        quick_pop_check: Whether to use quick method to check if source and
+            target populations are the same. Default: False.
+            Quick method checks only whether filter conditions match.
+            Strict method checks whether all node id's match considering order.
         cache_data: Whether to cache the values of p0, p0_arg, p1, p1_arg
             during estimation of rho. This improves performance when
             estimate_rho is True while not creating a significant overhead in
@@ -465,7 +532,7 @@ class ReciprocalConnector(AbstractConnector):
                  pr=0., pr_arg=None, estimate_rho=True, rho=None,
                  dist_range_forward=None, dist_range_backward=None,
                  n_syn0=1, n_syn1=1, autapses=False,
-                 cache_data=True, verbose=True):
+                 quick_pop_check=False, cache_data=True, verbose=True):
         args = locals()
         var_set = ('p0', 'p0_arg', 'p1', 'p1_arg',
                    'pr', 'pr_arg', 'n_syn0', 'n_syn1')
@@ -480,6 +547,7 @@ class ReciprocalConnector(AbstractConnector):
         self.rho = rho
 
         self.autapses = autapses
+        self.quick = quick_pop_check
         self.cache = self.ConnectorCache(cache_data and self.estimate_rho)
         self.verbose = verbose
 
@@ -493,8 +561,8 @@ class ReciprocalConnector(AbstractConnector):
         if self.stage:
             # check whether the correct populations
             if (source is None or target is None or
-                    not self.is_same_pop(source, self.target) or
-                    not self.is_same_pop(target, self.source)):
+                    not is_same_pop(source, self.target, quick=self.quick) or
+                    not is_same_pop(target, self.source, quick=self.quick)):
                 raise ValueError("Source or target population not consistent.")
             # Skip adding nodes for the backward stage.
             return
@@ -508,7 +576,7 @@ class ReciprocalConnector(AbstractConnector):
             raise ValueError("Target nodes do not exists")
 
         # Setup nodes
-        self.recurrent = self.is_same_pop(self.source, self.target, quick=True)
+        self.recurrent = is_same_pop(self.source, self.target, quick=self.quick)
         self.source_ids = [s.node_id for s in self.source]
         self.n_source = len(self.source_ids)
         self.source_list = list(self.source)
@@ -551,6 +619,7 @@ class ReciprocalConnector(AbstractConnector):
             self.enable = enable
             self._output = {}
             self.cache_dict = {}
+            self.set_next_it()
             self.write_mode()
 
         def cache_output(self, func, func_name, cache=True):
@@ -606,9 +675,14 @@ class ReciprocalConnector(AbstractConnector):
                     self.enable = False
             self.mode = 'read'
 
-        def next_it(self):
+        def set_next_it(self):
             if self.enable:
-                self.iter_count += 1
+                def next_it():
+                    self.iter_count += 1
+            else:
+                def next_it():
+                    pass
+            self.next_it = next_it
 
     def node_2_idx_input(self, var_func, reverse=False):
         """Convert a function that accept nodes as input
@@ -703,6 +777,13 @@ class ReciprocalConnector(AbstractConnector):
 
     # *** A sequence of major methods executed during build ***
     def setup_variables(self):
+        # If pr_arg is string, use the same value as p0_arg or p1_arg
+        if isinstance(self.vars['pr_arg'], str):
+            pr_arg_func = 'p1_arg' if '1' in self.vars['pr_arg'] else 'p0_arg'
+            self.vars['pr_arg'] = self.vars[pr_arg_func]
+        else:
+            pr_arg_func = None
+
         callable_set = set()
         # Make constant variables constant functions
         for name, var in self.vars.items():
@@ -718,6 +799,21 @@ class ReciprocalConnector(AbstractConnector):
             var = self.vars[name]
             setattr(self, name, self.node_2_idx_input(var, '1' in name))
 
+        # Set up function for pr_arg if use value from p0_arg or p1_arg
+        if pr_arg_func is None:
+            self._pr_arg = self.pr_arg  # use specified pr_arg
+        else:
+            self._pr_arg_val = 0.  # storing current value from p_arg
+            p_arg = getattr(self, pr_arg_func)
+            def p_arg_4_pr(*args, **kwargs):
+                val = p_arg(*args, **kwargs)
+                self._pr_arg_val = val
+                return val
+            setattr(self, pr_arg_func, p_arg_4_pr)
+            def pr_arg(self, *arg):
+                return self._pr_arg_val
+            self._pr_arg = types.MethodType(pr_arg, self)
+
     def cache_variables(self):
         # Select cacheable attrilbutes
         cache_set = {'p0', 'p0_arg', 'p1', 'p1_arg'}
@@ -825,7 +921,7 @@ class ReciprocalConnector(AbstractConnector):
             if forward:
                 forward = decision(p0)
             if backward:
-                pr = self.pr(self.pr_arg(i, j))
+                pr = self.pr(self._pr_arg(i, j), p0, p1)
                 backward = decision(self.cond_backward(forward, p0, p1, pr))
 
             # Make connection
@@ -849,7 +945,7 @@ class ReciprocalConnector(AbstractConnector):
         if self.verbose:
             self.timer.report('Total time for creating connection matrix')
             if self.wrong_pr:
-                print("\nWarning: Value of 'pr' outside the bounds occurs.\n")
+                print("Warning: Value of 'pr' outside the bounds occurred.\n")
             self.connection_number_info()
 
     def make_connection(self):
@@ -949,7 +1045,7 @@ class ReciprocalConnector(AbstractConnector):
 
 class UnidirectionConnector(AbstractConnector):
     """
-    Object for building unidirectional connections in bmtk network model with
+    Object for buiilding unidirectional connections in bmtk network model with
     given probability within a single population (or between two populations).
 
     Parameters:
@@ -1081,9 +1177,80 @@ class UnidirectionConnector(AbstractConnector):
               % (100. * self.n_conn / self.n_pair))
 
 
-class CorrelatedGapJunction(UnidirectionConnector):
+class GapJunction(UnidirectionConnector):
+    """
+    Object for buiilding gap junction connections in bmtk network model with
+    given probabilities within a single population which is uncorrelated with
+    the recurrent chemical synapses in this population.
+
+    Parameters:
+        p, p_arg: Probability of forward connection and its input argument when
+            it is a function, similar to p0, p0_arg in ReciprocalConnector. It
+            can be a constant or a deterministic function whose value must be
+            within range [0, 1]. When p is constant, the connection is
+            homogenous.
+        verbose: Whether show verbose information in console.
+
+    Returns:
+        An object that works with BMTK to build edges in a network.
+
+    Important attributes:
+        Similar to `UnidirectionConnector`.
     """
-    Object for building gap junction connections in bmtk network model with
+
+    def __init__(self, p=1., p_arg=None, verbose=True):
+        super().__init__(p=p, p_arg=p_arg, verbose=verbose)
+
+    def setup_nodes(self, source=None, target=None):
+        super().setup_nodes(source=source, target=target)
+        if len(self.source) != len(self.target):
+            raise ValueError("Source and target must be the same for "
+                             "gap junction.")
+        self.n_source = len(self.source)
+
+    def make_connection(self, source, target, *args, **kwargs):
+        """Assign gap junction per iteration using one_to_one iterator"""
+        # Initialize in the first iteration
+        if self.iter_count == 0:
+            self.initialize()
+            if self.verbose:
+                src_str, _ = self.get_nodes_info()
+                print("\nStart building gap junction \n  in " + src_str)
+
+        # Consider each pair only once
+        nsyns = 0
+        i, j = divmod(self.iter_count, self.n_source)
+        if i < j:
+            p_arg = self.p_arg(source, target)
+            p = self.p(p_arg)
+            possible = p > 0
+            self.n_poss += possible
+            if possible and decision(p):
+                nsyns = 1
+                sid, tid = source.node_id, target.node_id
+                self.add_conn_prop(sid, tid, p_arg)
+                self.add_conn_prop(tid, sid, p_arg)
+                self.n_conn += 1
+
+        self.iter_count += 1
+
+        # Detect end of iteration
+        if self.iter_count == self.n_pair:
+            if self.verbose:
+                self.connection_number_info()
+                self.timer.report('Done! \nTime for building connections')
+        return nsyns
+
+    def connection_number_info(self):
+        n_pair = self.n_pair
+        self.n_pair = (n_pair - len(self.source)) // 2
+        super().connection_number_info()
+        self.n_pair = n_pair
+
+
+class CorrelatedGapJunction(GapJunction):
+    """
+    Object for buiilding gap junction connections in bmtk network model with
     given probabilities within a single population which could be correlated
     with the recurrent chemical synapses in this population.
 
@@ -1120,13 +1287,6 @@ class CorrelatedGapJunction(UnidirectionConnector):
             conn_prop = conn_prop[0]
         self.ref_conn_prop = conn_prop
 
-    def setup_nodes(self, source=None, target=None):
-        super().setup_nodes(source=source, target=target)
-        if len(self.source) != len(self.target):
-            raise ValueError("Source and target must be the same for "
-                             "gap junction.")
-        self.n_source = len(self.source)
-
     def conn_exist(self, sid, tid):
         trg_dict = self.ref_conn_prop.get(sid)
         if trg_dict is not None and tid in trg_dict:
@@ -1153,7 +1313,7 @@ class CorrelatedGapJunction(UnidirectionConnector):
         if self.iter_count == 0:
             self.initialize()
             if self.verbose:
-                src_str, trg_str = self.get_nodes_info()
+                src_str, _ = self.get_nodes_info()
                 print("\nStart building gap junction \n  in " + src_str)
 
         # Consider each pair only once
@@ -1182,15 +1342,9 @@ class CorrelatedGapJunction(UnidirectionConnector):
                 self.timer.report('Done! \nTime for building connections')
         return nsyns
 
-    def connection_number_info(self):
-        n_pair = self.n_pair
-        self.n_pair = (n_pair - len(self.source)) // 2
-        super().connection_number_info()
-        self.n_pair = n_pair
-
 
 class OneToOneSequentialConnector(AbstractConnector):
-    """Object for building one to one correspondence connections in bmtk
+    """Object for buiilding one to one correspondence connections in bmtk
     network model with between two populations. One of the population can
     consist of multiple sub-populations. These sub-populations need to be added
     sequentially using setup_nodes() and edge_params() methods followed by BMTK
@@ -1337,21 +1491,24 @@ FLUC_STDEV = 0.2  # ms
 DELAY_LOWBOUND = 0.2  # ms must be greater than h.dt
 DELAY_UPBOUND = 2.0  # ms
 
-def syn_dist_delay_feng(source, target,
-                        min_delay=SYN_MIN_DELAY, velocity=SYN_VELOCITY,
-                        fluc_stdev=FLUC_STDEV, connector=None):
+def syn_dist_delay_feng(source, target, min_delay=SYN_MIN_DELAY,
+                        velocity=SYN_VELOCITY, fluc_stdev=FLUC_STDEV,
+                        delay_bound=(DELAY_LOWBOUND, DELAY_UPBOUND),
+                        connector=None):
     """Synpase delay linearly dependent on distance.
     min_delay: minimum delay (ms)
     velocity: synapse conduction velocity (micron/ms)
     fluc_stdev: standard deviation of random Gaussian fluctuation (ms)
+    delay_bound: (lower, upper) bounds of delay (ms)
+    connector: connector object from which to read distance
     """
     if connector is None:
         dist = euclid_dist(target['positions'], source['positions'])
     else:
         dist = connector.get_conn_prop(source.node_id, target.node_id)
     del_fluc = fluc_stdev * rng.normal()
-    delay = dist / SYN_VELOCITY + SYN_MIN_DELAY + del_fluc
-    delay = min(max(delay, DELAY_LOWBOUND), DELAY_UPBOUND)
+    delay = dist / velocity + min_delay + del_fluc
+    delay = min(max(delay, delay_bound[0]), delay_bound[1])
     return delay
 
 
@@ -1373,4 +1530,4 @@ def syn_dist_delay_feng_section_PN(source, target, p=0.9,
 
 def syn_uniform_delay_section(source, target, low=DELAY_LOWBOUND,
                               high=DELAY_UPBOUND, **kwargs):
-    return rng.uniform(low, high)
+    return rng.uniform(low, high)

bmtool/graphs.py

@@ -0,0 +1,170 @@
+import networkx as nx
+import plotly.graph_objects as go
+import pandas as pd
+import bmtool.util.util as u
+import pandas as pd
+
+
+def generate_graph(config,source,target):
+    """
+    returns a graph object
+    config: A BMTK simulation config 
+    source: network name 
+    target: network name
+    """
+    nodes,edges = u.load_nodes_edges_from_config(config)
+    nodes_source = nodes[source]
+    nodes_target = nodes[target]
+    if source != target:
+        # Concatenate the DataFrames if source and target are different nodes
+        nodes = pd.concat([nodes_source, nodes_target])
+    else:
+        nodes = nodes[source]
+    edge_to_grap = source+"_to_"+target
+    edges = edges[edge_to_grap]
+
+    # Create an empty graph
+    G = nx.Graph()
+
+    # Add nodes to the graph with their positions and labels
+    for index, node_data in nodes.iterrows():
+        G.add_node(index, pos=(node_data['pos_x'], node_data['pos_y'], node_data['pos_z']), label=node_data['pop_name'])
+
+    # Add edges to the graph
+    for _, row in edges.iterrows():
+        G.add_edge(row['source_node_id'], row['target_node_id'])
+
+    return G
+
+
+def plot_graph(Graph=None,show_edges = False,title = None):
+    """
+    Generate an interactive plot of the network
+    Graph: A Graph object
+    show_edges: Boolean to show edges in graph plot
+    title: A string for the title of the graph
+    
+    """
+
+    # Extract node positions
+    node_positions = nx.get_node_attributes(Graph, 'pos')
+    node_x = [data[0] for data in node_positions.values()]
+    node_y = [data[1] for data in node_positions.values()]
+    node_z = [data[2] for data in node_positions.values()]
+
+    # Create edge traces
+    edge_x = []
+    edge_y = []
+    edge_z = []
+    for edge in Graph.edges():
+        x0, y0, z0 = node_positions[edge[0]]
+        x1, y1, z1 = node_positions[edge[1]]
+        edge_x.extend([x0, x1, None])
+        edge_y.extend([y0, y1, None])
+        edge_z.extend([z0, z1, None])
+
+    # Create edge trace
+    edge_trace = go.Scatter3d(
+        x=edge_x,
+        y=edge_y,
+        z=edge_z,
+        line=dict(width=1, color='#888'),
+        hoverinfo='none',
+        mode='lines',
+        opacity=0.2)
+
+    # Create node trace
+    node_trace = go.Scatter3d(
+        x=node_x,
+        y=node_y,
+        z=node_z,
+        mode='markers',
+        hoverinfo='text',
+        marker=dict(
+            showscale=True,
+            colorscale='YlGnBu',  # Adjust color scale here
+            reversescale=True,
+            color=[len(list(Graph.neighbors(node))) for node in Graph.nodes()],  # Assign color data here
+            size=5,  # Adjust the size of the nodes here
+            colorbar=dict(
+                thickness=15,
+                title='Node Connections',
+                xanchor='left',
+                titleside='right'
+            ),
+            line_width=2,
+            cmin=0,  # Adjust color scale range here
+            cmax=max([len(list(Graph.neighbors(node))) for node in Graph.nodes()])   # Adjust color scale range here
+        ))
+
+    # Define hover text for nodes
+    node_hover_text = [f'Node ID: {node_id}<br>Population Name: {node_data["label"]}<br># of Connections: {len(list(Graph.neighbors(node_id)))}' for node_id, node_data in Graph.nodes(data=True)]
+    node_trace.hovertext = node_hover_text
+
+    # Create figure
+    if show_edges:
+        graph_prop = [edge_trace,node_trace]
+    else:
+        graph_prop = [node_trace]
+
+    if title == None:
+        title = '3D plot'
+    
+    fig = go.Figure(data=graph_prop,
+                    layout=go.Layout(
+                        title=title,
+                        titlefont_size=16,
+                        showlegend=False,
+                        hovermode='closest',
+                        margin=dict(b=20, l=5, r=5, t=40),
+                        scene=dict(
+                            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                            zaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
+                        ),
+                        width=800,
+                        height=800
+                    ))
+
+    # Show figure
+    fig.show()
+
+
+def export_node_connections_to_csv(Graph, filename):
+    """
+    Generates a csv file with node type and all connections that node receives 
+    Graph: a Graph object
+    filename: A string for the name of output must end in .csv
+    """
+    # Create an empty dictionary to store the connections for each node
+    node_connections = {}
+
+    # Iterate over each node in the graph
+    for node in Graph.nodes():
+        # Initialize a dictionary to store the connections for the current node
+        connections = {}
+        node_label = Graph.nodes[node]['label']
+
+        # Iterate over each neighbor of the current node
+        for neighbor in Graph.neighbors(node):
+            # Get the label of the neighbor node
+            neighbor_label = Graph.nodes[neighbor]['label']
+
+            # Increment the connection count for the current node and neighbor label
+            connections[f'{neighbor_label} Connections'] = connections.get(f'{neighbor_label} Connections', 0) + 1
+
+        # Add the connections information for the current node to the dictionary
+        connections['Node Label'] = node_label
+        node_connections[node] = connections
+
+    # Convert the dictionary to a DataFrame
+    df = pd.DataFrame(node_connections).fillna(0).T
+
+    # Reorder columns so that 'Node Label' is the leftmost column
+    cols = df.columns.tolist()
+    cols = ['Node Label'] + [col for col in cols if col != 'Node Label']
+    df = df[cols]
+
+    # Write the DataFrame to a CSV file
+    df.to_csv(filename)
+

bmtool/singlecell.py

@@ -217,8 +217,8 @@ class Passive(CurrentClamp):
         self.v_final_time = self.t_vec[self.index_v_final]
 
         t_idx = slice(self.index_v_rest, self.index_v_final + 1)
-        self.v_vec_inj = self.v_vec.as_numpy()[t_idx].copy()
-        self.t_vec_inj = self.t_vec.as_numpy()[t_idx].copy() - self.v_rest_time
+        self.v_vec_inj = np.array(self.v_vec)[t_idx]
+        self.t_vec_inj = np.array(self.t_vec)[t_idx] - self.v_rest_time
 
         self.v_diff = self.cell_v_final - self.v_rest
         self.r_in = self.v_diff / self.inj_amp # MegaOhms
@@ -388,8 +388,8 @@ class ZAP(CurrentClamp):
         self.v_rest_time = self.t_vec[self.index_v_rest]
 
         t_idx = slice(self.index_v_rest, self.index_v_final + 1)
-        self.v_vec_inj = self.v_vec.as_numpy()[t_idx].copy() - self.v_rest
-        self.t_vec_inj = self.t_vec.as_numpy()[t_idx].copy() - self.v_rest_time
+        self.v_vec_inj = np.array(self.v_vec)[t_idx] - self.v_rest
+        self.t_vec_inj = np.array(self.t_vec)[t_idx] - self.v_rest_time
 
         self.cell_v_amp_max = np.abs(self.v_vec_inj).max()
         self.Z = np.fft.rfft(self.v_vec_inj) / np.fft.rfft(self.zap_vec_inj) # MOhms

bmtool/util/util.py

@@ -258,18 +258,20 @@ def load_nodes_from_paths(node_paths):
             for group_id in range(n_group):
                 group = nodes_grp[str(group_id)]
                 idx = node_group_id == group_id
+                group_node = node_id[idx]
+                group_index = node_group_index[idx]
                 for prop in group:
                     if prop == 'positions':
-                        positions = group[prop][node_group_index[idx]]
+                        positions = group[prop][group_index]
                         for i in range(positions.shape[1]):
                             if pos_labels[i] not in nodes_df:
                                 nodes_df[pos_labels[i]] = np.nan
-                            nodes_df.loc[node_id, pos_labels[i]] = positions[:, i]
+                            nodes_df.loc[group_node, pos_labels[i]] = positions[:, i]
                     else:
                         # create new column with NaN if property does not exist
                         if prop not in nodes_df: 
                             nodes_df[prop] = np.nan
-                        nodes_df.loc[idx, prop] = tuple(group[prop][node_group_index[idx]])
+                        nodes_df.loc[group_node, prop] = group[prop][group_index]
                         prop_dtype[prop] = group[prop].dtype
             # convert to original data type if possible
             for prop, dtype in prop_dtype.items():
@@ -615,7 +617,9 @@ def connection_totals(config=None,nodes=None,edges=None,sources=[],targets=[],si
         return total
     return relation_matrix(config,nodes,edges,sources,targets,sids,tids,prepend_pop,relation_func=total_connection_relationship,synaptic_info=synaptic_info)
 
-def percent_connections(config=None,nodes=None,edges=None,sources=[],targets=[],sids=[],tids=[],prepend_pop=True,method=None,include_gap=True):
+
+def percent_connections(config=None,nodes=None,edges=None,sources=[],targets=[],sids=[],tids=[],prepend_pop=True,type='convergence',method=None,include_gap=True):
+
 
     def precent_func(**kwargs): 
         edges = kwargs["edges"]
@@ -644,8 +648,12 @@ def percent_connections(config=None,nodes=None,edges=None,sources=[],targets=[],
         num_bi = (cons_recip.count().source_node_id - cons_recip_dedup.count().source_node_id)
         num_uni = total_cons - num_bi    
 
-        num_sources = s_list.apply(pd.Series.value_counts)[source_id_type].dropna().sort_index().loc[source_id]
-        num_targets = t_list.apply(pd.Series.value_counts)[target_id_type].dropna().sort_index().loc[target_id]
+        #num_sources = s_list.apply(pd.Series.value_counts)[source_id_type].dropna().sort_index().loc[source_id]
+        #num_targets = t_list.apply(pd.Series.value_counts)[target_id_type].dropna().sort_index().loc[target_id]
+
+        num_sources = s_list[source_id_type].value_counts().sort_index().loc[source_id]
+        num_targets = t_list[target_id_type].value_counts().sort_index().loc[target_id]
+
 
         total = round(total_cons / (num_sources*num_targets) * 100,2)
         uni = round(num_uni / (num_sources*num_targets) * 100,2)
@@ -660,6 +668,7 @@ def percent_connections(config=None,nodes=None,edges=None,sources=[],targets=[],
 
     return relation_matrix(config,nodes,edges,sources,targets,sids,tids,prepend_pop,relation_func=precent_func)
 
+
 def connection_divergence(config=None,nodes=None,edges=None,sources=[],targets=[],sids=[],tids=[],prepend_pop=True,convergence=False,method='mean+std',include_gap=True):
 
     import pandas as pd
@@ -680,41 +689,97 @@ def connection_divergence(config=None,nodes=None,edges=None,sources=[],targets=[
 
         if convergence:
             if method == 'min':
-                count = cons.apply(pd.Series.value_counts).target_node_id.dropna().min()
+                count = cons['target_node_id'].value_counts().min()
                 return round(count,2)
             elif method == 'max':
-                count = cons.apply(pd.Series.value_counts).target_node_id.dropna().max()
+                count = cons['target_node_id'].value_counts().max()
                 return round(count,2)
             elif method == 'std':
-                std = cons.apply(pd.Series.value_counts).target_node_id.dropna().std()
+                std = cons['target_node_id'].value_counts().std()
                 return round(std,2)
             elif method == 'mean': 
                 mean = cons['target_node_id'].value_counts().mean()
                 return round(mean,2)
             elif method == 'mean+std': #default is mean + std
                 mean = cons['target_node_id'].value_counts().mean()
-                std = cons.apply(pd.Series.value_counts).target_node_id.dropna().std()
+                std = cons['target_node_id'].value_counts().std()
+                #std = cons.apply(pd.Series.value_counts).target_node_id.dropna().std() no longer a valid way
                 return (round(mean,2)), (round(std,2))
         else: #divergence
             if method == 'min':
-                count = cons.apply(pd.Series.value_counts).source_node_id.dropna().min()
+                count = cons['source_node_id'].value_counts().min()
                 return round(count,2)
             elif method == 'max':
-                count = cons.apply(pd.Series.value_counts).source_node_id.dropna().max()
+                count = cons['source_node_id'].value_counts().max()
                 return round(count,2)
             elif method == 'std':
-                std = cons.apply(pd.Series.value_counts).source_node_id.dropna().std()
+                std = cons['source_node_id'].value_counts().std()
                 return round(std,2)
             elif method == 'mean': 
                 mean = cons['source_node_id'].value_counts().mean()
                 return round(mean,2)
             elif method == 'mean+std': #default is mean + std
                 mean = cons['source_node_id'].value_counts().mean()
-                std = cons.apply(pd.Series.value_counts).source_node_id.dropna().std()
+                std = cons['source_node_id'].value_counts().std()
                 return (round(mean,2)), (round(std,2))
 
     return relation_matrix(config,nodes,edges,sources,targets,sids,tids,prepend_pop,relation_func=total_connection_relationship)
 
+def gap_junction_connections(config=None,nodes=None,edges=None,sources=[],targets=[],sids=[],tids=[],prepend_pop=True,type='convergence'):
+    import pandas as pd
+
+    
+    def total_connection_relationship(**kwargs): #reduced version of original function; only gets mean+std
+        edges = kwargs["edges"]
+        source_id_type = kwargs["sid"]
+        target_id_type = kwargs["tid"]
+        source_id = kwargs["source_id"]
+        target_id = kwargs["target_id"]
+
+        cons = edges[(edges[source_id_type] == source_id) & (edges[target_id_type]==target_id)] 
+        #print(cons)
+        
+        cons = cons[cons['is_gap_junction'] == True] #only gap_junctions
+        mean = cons['target_node_id'].value_counts().mean()
+        std = cons['target_node_id'].value_counts().std()
+        return (round(mean,2)), (round(std,2))
+    
+    def precent_func(**kwargs): #barely different than original function; only gets gap_junctions.
+        edges = kwargs["edges"]
+        source_id_type = kwargs["sid"]
+        target_id_type = kwargs["tid"]
+        source_id = kwargs["source_id"]
+        target_id = kwargs["target_id"]
+        t_list = kwargs["target_nodes"]
+        s_list = kwargs["source_nodes"]
+
+        cons = edges[(edges[source_id_type] == source_id) & (edges[target_id_type]==target_id)]
+        #add functionality that shows only the one's with gap_junctions
+        cons = cons[cons['is_gap_junction'] == True]
+        total_cons = cons.count().source_node_id
+
+        num_sources = s_list[source_id_type].value_counts().sort_index().loc[source_id]
+        num_targets = t_list[target_id_type].value_counts().sort_index().loc[target_id]
+
+
+        total = round(total_cons / (num_sources*num_targets) * 100,2)
+        return total
+    
+    if type == 'convergence':
+        return relation_matrix(config,nodes,edges,sources,targets,sids,tids,prepend_pop,relation_func=total_connection_relationship)
+    elif type == 'percent':
+        return relation_matrix(config,nodes,edges,sources,targets,sids,tids,prepend_pop,relation_func=precent_func)
+        
+
+def gap_junction_percent_connections(config=None,nodes=None,edges=None,sources=[],targets=[],sids=[],tids=[],prepend_pop=True,method=None):
+    import pandas as pd
+    
+        
+        
+    
+    
+        
+    
 def connection_probabilities(config=None,nodes=None,edges=None,sources=[],
     targets=[],sids=[],tids=[],prepend_pop=True,dist_X=True,dist_Y=True,dist_Z=True,num_bins=10,include_gap=True):
     
@@ -753,11 +818,11 @@ def connection_probabilities(config=None,nodes=None,edges=None,sources=[],
         def eudist(df,use_x=True,use_y=True,use_z=True):
             def _dist(x):
                 if len(x) == 6:
-                    return distance.euclidean((x[0],x[1],x[2]),(x[3],x[4],x[5]))
+                    return distance.euclidean((x.iloc[0], x.iloc[1], x.iloc[2]), (x.iloc[3], x.iloc[4], x.iloc[5]))
                 elif len(x) == 4:
-                    return distance.euclidean((x[0],x[1]),(x[2],x[3]))
+                    return distance.euclidean((x.iloc[0],x.iloc[1]),(x.iloc[2],x.iloc[3]))
                 elif len(x) == 2:
-                    return distance.euclidean((x[0]),(x[1]))
+                    return distance.euclidean((x.iloc[0]),(x.iloc[1]))
                 else:
                     return -1
 
@@ -835,6 +900,7 @@ def connection_graph_edge_types(config=None,nodes=None,edges=None,sources=[],tar
 
     return relation_matrix(config,nodes,edges,sources,targets,sids,tids,prepend_pop,relation_func=synapse_type_relationship,return_type=object)
 
+
 def edge_property_matrix(edge_property, config=None, nodes=None, edges=None, sources=[],targets=[],sids=[],tids=[],prepend_pop=True,report=None,time=-1,time_compare=None):
     
     var_report = None
@@ -906,10 +972,11 @@ def percent_connectivity(config=None,nodes=None,edges=None,sources=[],targets=[]
 
     return ret, source_labels, target_labels
     
-    
+
 def connection_average_synapses():
     return
 
+
 def connection_divergence_average_old(config=None, nodes=None, edges=None,populations=[],convergence=False):
     """
     For each cell in source count # of connections in target and average

{bmtool-0.5.2.dist-info → bmtool-0.5.4.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: bmtool
-Version: 0.5.2
+Version: 0.5.4
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 
-Author: Tyler Banks
-Author-email: tbanks@mail.missouri.edu
+Author: Neural Engineering Laboratory at the University of Missouri
+Author-email: gregglickert@mail.missouri.edu
 License: MIT
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
@@ -28,6 +28,7 @@ Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: questionary
 Requires-Dist: pynmodlt
+Requires-Dist: plotly
 
 # bmtool
 A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/neuron/) and [BMTK](https://alleninstitute.github.io/bmtk/) models easier.
@@ -40,6 +41,7 @@ A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/
 - [Single Cell](#Single-Cell-Module)
 - [Connectors](#Connectors-Module)
 - [Bmplot](#bmplot-Module)
+- [Graphs](#graphs-module)
 
 ## Getting Started
 
@@ -391,6 +393,7 @@ net.add_edges(**connector.edge_params())
 - [Percent connections](#Percent-connection-plot)
 - [Convergence connnections](#convergence-plot)
 - [Divergence connections](#divergence-plot)
+- [Gap Junction connections](#gap-junction-plot)
 - [connection histogram](#connection-histogram)
 - [probability connection](#probability-of-connection-plot)
 - [3D location](#3d-position-plot)
@@ -452,6 +455,17 @@ bmplot.divergence_connection_matrix(config='config.json',sources='LA',targets='L
     
 ![png](readme_figures/output_25_0.png)
     
+### Gap Junction plot
+#### While gap junctions can be include in the above plots, you can use this function to only view gap junctions.Type can be either 'convergence' or 'percent' connections to generate different plots
+
+
+```python
+bmplot.gap_junction_matrix(config='config.json',sources='LA',targets='LA',sids='pop_name',tids='pop_name',no_prepend_pop=True,type='percent')
+```
+
+
+    
+![png](output_gap.png)
 
 
 ### Connection histogram 
@@ -776,5 +790,127 @@ bmplot.plot_basic_cell_info(config_file='config.json')
 
 
     'LA'
+## Graphs Module
+- [Generate graph](#generate-graph)
+- [Plot Graph](#plot-graph)
+- [Connectioon table](#generate-graph-connection-table)
+
+### Generate Graph
+
+
+```python
+from bmtool import graphs
+import networkx as nx
+
+Graph = graphs.generate_graph(config='config.json',source='LA',target='LA')
+print("Number of nodes:", Graph.number_of_nodes())
+print("Number of edges:", Graph.number_of_edges())
+print("Node labels:", set(nx.get_node_attributes(Graph, 'label').values()))
+```
+
+    Number of nodes: 2000
+    Number of edges: 84235
+    Node labels: {'SOM', 'PNc', 'PNa', 'PV'}
+
+
+### Plot Graph
+#### Generates an interactive plot showing nodes, edges and # of connections
+
+
+```python
+graphs.plot_graph(Graph)
+```
+
+
+
+### Generate graph connection table
+#### Generates a CSV of all cells and the number of connections each individual cell receives
+
+
+```python
+import pandas as pd
+graphs.export_node_connections_to_csv(Graph, 'node_connections.csv')
+df = pd.read_csv('node_connections.csv')
+df.head()
+```
+
+
+
+
+<div>
+<style scoped>
+    .dataframe tbody tr th:only-of-type {
+        vertical-align: middle;
+    }
+
+    .dataframe tbody tr th {
+        vertical-align: top;
+    }
+
+    .dataframe thead th {
+        text-align: right;
+    }
+</style>
+<table border="1" class="dataframe">
+  <thead>
+    <tr style="text-align: right;">
+      <th></th>
+      <th>Unnamed: 0</th>
+      <th>Node Label</th>
+      <th>PNc Connections</th>
+      <th>PV Connections</th>
+      <th>SOM Connections</th>
+      <th>PNa Connections</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <th>0</th>
+      <td>0</td>
+      <td>PNa</td>
+      <td>15</td>
+      <td>11</td>
+      <td>9</td>
+      <td>6</td>
+    </tr>
+    <tr>
+      <th>1</th>
+      <td>1</td>
+      <td>PNa</td>
+      <td>24</td>
+      <td>25</td>
+      <td>6</td>
+      <td>21</td>
+    </tr>
+    <tr>
+      <th>2</th>
+      <td>2</td>
+      <td>PNa</td>
+      <td>27</td>
+      <td>28</td>
+      <td>12</td>
+      <td>25</td>
+    </tr>
+    <tr>
+      <th>3</th>
+      <td>3</td>
+      <td>PNa</td>
+      <td>19</td>
+      <td>27</td>
+      <td>15</td>
+      <td>35</td>
+    </tr>
+    <tr>
+      <th>4</th>
+      <td>4</td>
+      <td>PNa</td>
+      <td>25</td>
+      <td>11</td>
+      <td>8</td>
+      <td>16</td>
+    </tr>
+  </tbody>
+</table>
+</div>
 
 

{bmtool-0.5.2.dist-info → bmtool-0.5.4.dist-info}/RECORD

@@ -1,21 +1,22 @@
 bmtool/__init__.py,sha256=ZStTNkAJHJxG7Pwiy5UgCzC4KlhMS5pUNPtUJZVwL_Y,136
 bmtool/__main__.py,sha256=TmFkmDxjZ6250nYD4cgGhn-tbJeEm0u-EMz2ajAN9vE,650
-bmtool/bmplot.py,sha256=Eg3P2wwY_k1TBqzZTxNSxRk-Sw36u3uMp9Kdb5vP9YE,35922
-bmtool/connectors.py,sha256=C1ALOMpqZ_oRRMWC5QDota3AwqsIaLGwqM2rUNACIAg,59610
+bmtool/bmplot.py,sha256=MiUJ4KoN2v285en0aBdrTqrWIaZJEnb2DPzS3kYaCdM,39680
+bmtool/connectors.py,sha256=t8L25eb19vZgCduWW8fJFSrEyUQ4_zGNaENMomw0d0Q,66376
+bmtool/graphs.py,sha256=j6xEXSFCoeh3mdoyXAKEjWRk8oFbNAesAbddmzAMIs0,5752
 bmtool/manage.py,sha256=_lCU0qBQZ4jSxjzAJUd09JEetb--cud7KZgxQFbLGSY,657
 bmtool/plot_commands.py,sha256=Tqujyf0c0u8olhiHOMwgUSJXIIE1hgjv6otb25G9cA0,12298
-bmtool/singlecell.py,sha256=kwGYE4JLhYAblXGkevWBuGNhBNQL1fndmXvDHbkINPY,24997
+bmtool/singlecell.py,sha256=2kepmupsUs_QVPHmH9GURvmUyYCNBSvF1G1_6lFjDyM,24965
 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
 bmtool/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/util/commands.py,sha256=zJF-fiLk0b8LyzHDfvewUyS7iumOxVnj33IkJDzux4M,64396
-bmtool/util/util.py,sha256=RPdZNhtAUYL6slF4jA-HcQg3TlXCzusIFSctW2I_MOw,53496
+bmtool/util/util.py,sha256=J9fA73DnPF8Kp8CWONDFCuNza9e_3PNTd0jXuVb5iFs,56060
 bmtool/util/neuron/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/util/neuron/celltuner.py,sha256=xSRpRN6DhPFz4q5buq_W8UmsD7BbUrkzYBEbKVloYss,87194
-bmtool-0.5.2.dist-info/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.5.2.dist-info/METADATA,sha256=Xtwo9QyTFEuQlBac-h9mcWuyilUxAu1HKT1hwttAxUM,21237
-bmtool-0.5.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-bmtool-0.5.2.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.5.2.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.5.2.dist-info/RECORD,,
+bmtool-0.5.4.dist-info/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
+bmtool-0.5.4.dist-info/METADATA,sha256=8g09f8qLcPIooyxWd2kmi0_vLlVWoviRv35ardQD2xg,24084
+bmtool-0.5.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+bmtool-0.5.4.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
+bmtool-0.5.4.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
+bmtool-0.5.4.dist-info/RECORD,,

{bmtool-0.5.2.dist-info → bmtool-0.5.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any