bmtool 0.7.4.1__py3-none-any.whl → 0.7.5.1__py3-none-any.whl

bmtool/singlecell.py

@@ -10,6 +10,8 @@ import pandas as pd
 from neuron import h
 from scipy.optimize import curve_fit
 
+from bmtool.util.util import load_templates_from_config, load_config
+
 
 def load_biophys1():
     """
@@ -1025,19 +1027,62 @@ class ZAP(CurrentClamp):
 
 
 class Profiler:
-    """All in one single cell profiler"""
+    """All in one single cell profiler
+
+    This Profiler now supports being initialized with either explicit
+    `template_dir` and `mechanism_dir` paths or with a BMTK `config` file
+    (which should contain `components.templates_dir` and
+    `components.mechanisms_dir`). When `config` is provided it will be used
+    to load mechanisms and templates via the utility helpers.
+    """
 
-    def __init__(self, template_dir: str = None, mechanism_dir: str = None, dt=None):
+    def __init__(self, template_dir: str = None, mechanism_dir: str = None, dt=None, config: str = None):
+        # initialize to None and then prefer config-derived paths if provided
         self.template_dir = None
         self.mechanism_dir = None
 
-        if not self.template_dir:
-            self.template_dir = template_dir
-        if not self.mechanism_dir:
-            self.mechanism_dir = mechanism_dir
-        self.templates = None
+        # If a BMTK config is provided, load mechanisms/templates from it
+        if config is not None:
+            try:
+                # load and apply the config values for directories
+                conf = load_config(config)
+                # conf behaves like a dict returned by bmtk Config.from_json
+                try:
+                    comps = conf["components"]
+                except Exception:
+                    comps = getattr(conf, "components", None)
+
+                if comps is not None:
+                    # support dict-like and object-like components
+                    try:
+                        self.template_dir = comps.get("templates_dir")
+                    except Exception:
+                        self.template_dir = getattr(comps, "templates_dir", None)
+                    try:
+                        self.mechanism_dir = comps.get("mechanisms_dir")
+                    except Exception:
+                        self.mechanism_dir = getattr(comps, "mechanisms_dir", None)
+
+                # actually load mechanisms and templates using the helper
+                load_templates_from_config(config)
+            except Exception:
+                # fall back to explicit dirs if config parsing/loading fails
+                pass
+
+        else:
+            # fall back to explicit args if not set by config
+            if not self.template_dir:
+                self.template_dir = template_dir
+            if not self.mechanism_dir:
+                self.mechanism_dir = mechanism_dir
+
+            # template_dir is required for loading templates later
+            if self.template_dir is None:
+                raise ValueError("Profiler requires either 'template_dir' or a 'config' containing components.templates_dir")
+
+            self.templates = None
 
-        self.load_templates()
+            self.load_templates()
 
         h.load_file("stdrun.hoc")
         if dt is not None:

bmtool/synapses.py

@@ -8,6 +8,7 @@ import ipywidgets as widgets
 import matplotlib.pyplot as plt
 import neuron
 import numpy as np
+import pandas as pd
 from IPython.display import clear_output, display
 from ipywidgets import HBox, VBox
 from neuron import h
@@ -18,10 +19,10 @@ from scipy.optimize import curve_fit, minimize, minimize_scalar
 from scipy.signal import find_peaks
 from tqdm.notebook import tqdm
 
-from bmtool.util.util import load_templates_from_config
+from bmtool.util.util import load_templates_from_config, load_nodes_from_config, load_edges_from_config, load_config
 
 DEFAULT_GENERAL_SETTINGS = {
-    "vclamp": True,
+    "vclamp": False,
     "rise_interval": (0.1, 0.9),
     "tstart": 500.0,
     "tdur": 100.0,
@@ -43,17 +44,18 @@ DEFAULT_GAP_JUNCTION_GENERAL_SETTINGS = {
 class SynapseTuner:
     def __init__(
         self,
+        conn_type_settings: Optional[Dict[str, dict]] = None,
+        connection: Optional[str] = None,
+        current_name: str = "i",
         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: Optional[list] = None,
-        slider_vars: Optional[list] = None,
+        other_vars_to_record: Optional[List[str]] = None,
+        slider_vars: Optional[List[str]] = None,
         hoc_cell: Optional[object] = None,
+        network: Optional[str] = None,
     ) -> None:
         """
         Initialize the SynapseTuner class with connection type settings, mechanisms, and template directories.
@@ -80,8 +82,28 @@ class SynapseTuner:
             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.
+        network : Optional[str]
+            Name of the specific network dataset to access from the loaded edges data (e.g., 'network_to_network').
+            If not provided, will use all available networks. When a config file is provided, this enables
+            the network dropdown feature in InteractiveTuner for switching between different networks.
+
+        Network Dropdown Feature:
+        -------------------------
+        When initialized with a BMTK config file, the tuner automatically:
+        1. Loads all available network datasets from the config
+        2. Creates a network dropdown in InteractiveTuner (if multiple networks exist)
+        3. Allows dynamic switching between networks, which rebuilds connection types
+        4. Updates connection dropdown options when network is changed
+        5. Preserves current connection if it exists in the new network, otherwise selects the first available
         """
         self.hoc_cell = hoc_cell
+        # Store config and network information for network dropdown functionality
+        self.config = config  # Store config path for network dropdown functionality
+        self.available_networks = []  # Store available networks from config file
+        self.current_network = network  # Store current network selection
+        # Cache for loaded dynamics params JSON by filename to avoid repeated disk reads
+        self._syn_params_cache = {}
+        h.load_file('stdrun.hoc')
 
         if hoc_cell is None:
             if config is None and (mechanisms_dir is None or templates_dir is None):
@@ -95,11 +117,37 @@ class SynapseTuner:
             else:
                 # loads both mech and templates
                 load_templates_from_config(config)
+                # Load available networks from config for network dropdown feature
+                self._load_available_networks()
+                # Prebuild connection type settings for each available network to
+                # make network switching in the UI fast. This will make __init__ slower
+                # but dramatically speed up response when changing the network dropdown.
+                self._prebuilt_conn_type_settings = {}
+                try:
+                    for net in self.available_networks:
+                        self._prebuilt_conn_type_settings[net] = self._build_conn_type_settings_from_config(config, network=net)
+                except Exception as e:
+                    print(f"Warning: error prebuilding conn_type_settings for networks: {e}")
 
         if conn_type_settings is None:
-            raise ValueError("conn_type_settings must be provided.")
+            if config is not None:
+                print("Building conn_type_settings from BMTK config files...")
+                # If we prebuilt per-network settings, use the one for the requested network
+                if hasattr(self, '_prebuilt_conn_type_settings') and network in getattr(self, '_prebuilt_conn_type_settings', {}):
+                    conn_type_settings = self._prebuilt_conn_type_settings[network]
+                else:
+                    conn_type_settings = self._build_conn_type_settings_from_config(config, network=network)
+                print(f"Found {len(conn_type_settings)} connection types: {list(conn_type_settings.keys())}")
+                
+                # If connection is not specified, use the first available connection
+                if connection is None and conn_type_settings:
+                    connection = list(conn_type_settings.keys())[0]
+                    print(f"No connection specified, using first available: {connection}")
+            else:
+                raise ValueError("conn_type_settings must be provided if config is not specified.")
+                
         if connection is None:
-            raise ValueError("connection must be provided.")
+            raise ValueError("connection must be provided or inferable from conn_type_settings.")
         if connection not in conn_type_settings:
             raise ValueError(f"connection '{connection}' not found in conn_type_settings.")
 
@@ -113,12 +161,20 @@ class SynapseTuner:
         else:
             # Merge defaults with user-provided
             self.general_settings = {**DEFAULT_GENERAL_SETTINGS, **general_settings}
+        
+        # Store the initial connection name and set up connection
+        self.current_connection = connection
         self.conn = self.conn_type_settings[connection]
+        self._current_cell_type = self.conn["spec_settings"]["post_cell"]
         self.synaptic_props = self.conn["spec_syn_param"]
         self.vclamp = self.general_settings["vclamp"]
         self.current_name = current_name
         self.other_vars_to_record = other_vars_to_record or []
         self.ispk = None
+        self.input_mode = False  # Add input_mode attribute
+
+        # Store original slider_vars for connection switching
+        self.original_slider_vars = slider_vars or list(self.synaptic_props.keys())
 
         if slider_vars:
             # Start by filtering based on keys in slider_vars
@@ -174,6 +230,497 @@ class SynapseTuner:
 
         self._set_up_recorders()
 
+    def _build_conn_type_settings_from_config(self, config_path: str, node_set: Optional[str] = None, network: Optional[str] = None) -> Dict[str, dict]:
+        """
+        Build conn_type_settings from BMTK simulation and circuit config files using the method used by relation matrix function in util.
+        
+        Parameters:
+        -----------
+        config_path : str
+            Path to the simulation config JSON file.
+        node_set : Optional[str]
+            Specific node set to filter connections for. If None, processes all connections.
+        network : Optional[str]
+            Name of the specific network dataset to access (e.g., 'network_to_network').
+            If None, processes all available networks.
+            
+        Returns:
+        --------
+        Dict[str, dict]
+            Dictionary with connection names as keys and connection settings as values.
+
+        NOTE: a lot of this code could probs be made a bit more simple or just removed i kinda tried a bunch of things and it works now
+        but is kinda complex and some code is probs note needed 
+            
+        """
+        # Load configuration and get nodes and edges using util.py methods
+        config = load_config(config_path)
+        # Ensure the config dict knows its source path so path substitutions can be resolved
+        try:
+            # load_config may return a dict; store path used so callers can resolve $COMPONENTS_DIR
+            config['config_path'] = config_path
+        except Exception:
+            pass
+        nodes = load_nodes_from_config(config_path)
+        edges = load_edges_from_config(config_path)
+        
+        conn_type_settings = {}
+        
+        # If a specific network is requested, only process that one
+        if network:
+            if network not in edges:
+                print(f"Warning: Network '{network}' not found in edges. Available networks: {list(edges.keys())}")
+                return conn_type_settings
+            edge_datasets = {network: edges[network]}
+        else:
+            edge_datasets = edges
+        
+        # Process each edge dataset using the util.py approach
+        for edge_dataset_name, edge_df in edge_datasets.items():
+            if edge_df.empty:
+                continue
+            
+            # Create merged DataFrames with source and target node information like util.py does
+            source_node_df = None
+            target_node_df = None
+
+            # First, try to deterministically parse the edge_dataset_name for patterns like '<src>_to_<tgt>'
+            # e.g., 'network_to_network', 'extnet_to_network'
+            if '_to_' in edge_dataset_name:
+                parts = edge_dataset_name.split('_to_')
+                if len(parts) == 2:
+                    src_name, tgt_name = parts
+                    if src_name in nodes:
+                        source_node_df = nodes[src_name].add_prefix('source_')
+                    if tgt_name in nodes:
+                        target_node_df = nodes[tgt_name].add_prefix('target_')
+
+            # If not found by parsing name, fall back to inspecting a sample edge row which contains
+            # explicit 'source_population' and 'target_population' fields (this avoids reversing source/target)
+            if source_node_df is None or target_node_df is None:
+                sample_edge = edge_df.iloc[0] if len(edge_df) > 0 else None
+                if sample_edge is not None:
+                    # Use explicit population names from the edge entry
+                    source_pop_name = sample_edge.get('source_population', '')
+                    target_pop_name = sample_edge.get('target_population', '')
+                    if source_pop_name in nodes:
+                        source_node_df = nodes[source_pop_name].add_prefix('source_')
+                    if target_pop_name in nodes:
+                        target_node_df = nodes[target_pop_name].add_prefix('target_')
+
+            # As a last resort, attempt to heuristically match by prefix/suffix of the dataset name
+            if source_node_df is None or target_node_df is None:
+                for pop_name, node_df in nodes.items():
+                    if source_node_df is None and (edge_dataset_name.startswith(pop_name) or edge_dataset_name.endswith(pop_name)):
+                        source_node_df = node_df.add_prefix('source_')
+                    elif target_node_df is None and (edge_dataset_name.startswith(pop_name) or edge_dataset_name.endswith(pop_name)):
+                        target_node_df = node_df.add_prefix('target_')
+            
+            # If we still don't have the node data, skip this edge dataset
+            if source_node_df is None or target_node_df is None:
+                print(f"Warning: Could not find node data for edge dataset {edge_dataset_name}")
+                continue
+            
+            # Merge edge data with source node info
+            edges_with_source = pd.merge(
+                edge_df.reset_index(), 
+                source_node_df, 
+                how='left', 
+                left_on='source_node_id', 
+                right_index=True
+            )
+            
+            # Merge with target node info
+            edges_with_nodes = pd.merge(
+                edges_with_source, 
+                target_node_df, 
+                how='left', 
+                left_on='target_node_id', 
+                right_index=True
+            )
+            
+            # Get unique edge types from the merged dataset
+            if 'edge_type_id' in edges_with_nodes.columns:
+                edge_types = edges_with_nodes['edge_type_id'].unique()
+            else:
+                edge_types = [0]  # Single edge type
+            
+            # Process each edge type
+            for edge_type_id in edge_types:
+                # Filter edges for this type
+                if 'edge_type_id' in edges_with_nodes.columns:
+                    edge_type_data = edges_with_nodes[edges_with_nodes['edge_type_id'] == edge_type_id]
+                else:
+                    edge_type_data = edges_with_nodes
+                
+                if len(edge_type_data) == 0:
+                    continue
+                
+                # Get representative edge for this type
+                edge_info = edge_type_data.iloc[0]
+                
+                # Skip gap junctions
+                if 'is_gap_junction' in edge_info and pd.notna(edge_info['is_gap_junction']) and edge_info['is_gap_junction']:
+                    continue
+                
+                # Get population names from the merged data (this is the key improvement!)
+                source_pop = edge_info.get('source_pop_name', '')
+                target_pop = edge_info.get('target_pop_name', '')
+                
+                # Get target cell template from the merged data
+                target_model_template = edge_info.get('target_model_template', '')
+                if target_model_template.startswith('hoc:'):
+                    target_cell_type = target_model_template.replace('hoc:', '')
+                else:
+                    target_cell_type = target_model_template
+                
+                # Create connection name using the actual population names
+                if source_pop and target_pop:
+                    conn_name = f"{source_pop}2{target_pop}"
+                else:
+                    conn_name = f"{edge_dataset_name}_type_{edge_type_id}"
+                
+                # Get synaptic model template
+                model_template = edge_info.get('model_template', 'exp2syn')
+
+                # Build connection settings early so we can attach metadata like dynamics file name
+                conn_settings = {
+                    'spec_settings': {
+                        'post_cell': target_cell_type,
+                        'vclamp_amp': -70.0,  # Default voltage clamp amplitude
+                        'sec_x': 0.5,  # Default location on section
+                        'sec_id': 0,   # Default to soma
+                        # level_of_detail may be overridden by dynamics params below
+                        'level_of_detail': model_template,
+                    },
+                    'spec_syn_param': {}
+                }
+
+                # Load synaptic parameters from dynamics_params file if available.
+                # NOTE: the edge DataFrame produced by load_edges_from_config/load_sonata_edges_to_dataframe
+                # already contains the 'dynamics_params' column (from the CSV) or the
+                # flattened H5 dynamics_params attributes (prefixed with 'dynamics_params/').
+                # Prefer the direct 'dynamics_params' column value from the merged DataFrame
+                # rather than performing ad-hoc string parsing here.
+                syn_params = {}
+                dynamics_file_name = None
+                # Prefer a top-level 'dynamics_params' column if present
+                if 'dynamics_params' in edge_info and pd.notna(edge_info.get('dynamics_params')):
+                    val = edge_info.get('dynamics_params')
+                    # Some CSV loaders can produce bytes or numpy types; coerce to str
+                    try:
+                        dynamics_file_name = str(val).strip()
+                    except Exception:
+                        dynamics_file_name = None
+
+                # If we found a dynamics file name, use it directly (skip token parsing)
+                if dynamics_file_name and dynamics_file_name.upper() != 'NULL':
+                    try:
+                        conn_settings['spec_settings']['dynamics_params_file'] = dynamics_file_name
+                        # use a cache to avoid re-reading the same JSON multiple times
+                        if dynamics_file_name in self._syn_params_cache:
+                            syn_params = self._syn_params_cache[dynamics_file_name]
+                        else:
+                            syn_params = self._load_synaptic_params_from_config(config, dynamics_file_name)
+                            # cache result (even if empty dict) to avoid repeated lookups
+                            self._syn_params_cache[dynamics_file_name] = syn_params
+                    except Exception as e:
+                        print(f"Warning: could not load dynamics_params file '{dynamics_file_name}' for edge {edge_dataset_name}: {e}")
+
+                # If a dynamics params JSON filename was provided, prefer using its basename
+                # as the connection name so that the UI matches the JSON definitions.
+                if dynamics_file_name:
+                    try:
+                        json_base = os.path.splitext(os.path.basename(dynamics_file_name))[0]
+                        # Ensure uniqueness in conn_type_settings
+                        if json_base in conn_type_settings:
+                            # Append edge_type_id to disambiguate
+                            json_base = f"{json_base}_type_{edge_type_id}"
+                        conn_name = json_base
+                    except Exception:
+                        pass
+
+                # If the dynamics params defined a level_of_detail, override the default
+                if isinstance(syn_params, dict) and 'level_of_detail' in syn_params:
+                    conn_settings['spec_settings']['level_of_detail'] = syn_params.get('level_of_detail', model_template)
+
+                # Add synaptic parameters, excluding level_of_detail
+                for key, value in syn_params.items():
+                    if key != 'level_of_detail':
+                        conn_settings['spec_syn_param'][key] = value
+                else:
+                    # Fallback: some SONATA/H5 edge files expose dynamics params as flattened
+                    # columns named like 'dynamics_params/<param>'. If no filename was given,
+                    # gather any such columns from edge_info and use them as spec_syn_param.
+                    for col in edge_info.index:
+                        if isinstance(col, str) and col.startswith('dynamics_params/'):
+                            param_key = col.split('/', 1)[1]
+                            try:
+                                val = edge_info[col]
+                                if pd.notna(val):
+                                    conn_settings['spec_syn_param'][param_key] = val
+                            except Exception:
+                                # Ignore malformed entries
+                                pass
+                
+                # Add weight from edge info if available
+                if 'syn_weight' in edge_info and pd.notna(edge_info['syn_weight']):
+                    conn_settings['spec_syn_param']['initW'] = float(edge_info['syn_weight'])
+                
+                # Handle afferent section information
+                if 'afferent_section_id' in edge_info and pd.notna(edge_info['afferent_section_id']):
+                    conn_settings['spec_settings']['sec_id'] = int(edge_info['afferent_section_id'])
+                
+                if 'afferent_section_pos' in edge_info and pd.notna(edge_info['afferent_section_pos']):
+                    conn_settings['spec_settings']['sec_x'] = float(edge_info['afferent_section_pos'])
+                
+                # Store in connection settings
+                conn_type_settings[conn_name] = conn_settings
+
+        return conn_type_settings
+    
+    def _load_available_networks(self) -> None:
+        """
+        Load available network names from the config file for the network dropdown feature.
+        
+        This method is automatically called during initialization when a config file is provided.
+        It populates the available_networks list which enables the network dropdown in 
+        InteractiveTuner when multiple networks are available.
+        
+        Network Dropdown Behavior:
+        -------------------------
+        - If only one network exists: No network dropdown is shown
+        - If multiple networks exist: Network dropdown appears next to connection dropdown
+        - Networks are loaded from the edges data in the config file
+        - Current network defaults to the first available if not specified during init
+        """
+        if self.config is None:
+            self.available_networks = []
+            return
+            
+        try:
+            edges = load_edges_from_config(self.config)
+            self.available_networks = list(edges.keys())
+            
+            # Set current network to first available if not specified
+            if self.current_network is None and self.available_networks:
+                self.current_network = self.available_networks[0]
+        except Exception as e:
+            print(f"Warning: Could not load networks from config: {e}")
+            self.available_networks = []
+    
+    def _load_synaptic_params_from_config(self, config: dict, dynamics_params: str) -> dict:
+        """
+        Load synaptic parameters from dynamics params file using config information.
+        
+        Parameters:
+        -----------
+        config : dict
+            BMTK configuration dictionary
+        dynamics_params : str
+            Dynamics parameters filename
+            
+        Returns:
+        --------
+        dict
+            Synaptic parameters dictionary
+        """
+        try:
+            # Get the synaptic models directory from config
+            synaptic_models_dir = config.get('components', {}).get('synaptic_models_dir', '')
+            if synaptic_models_dir:
+                # Handle path variables
+                if synaptic_models_dir.startswith('$'):
+                    # This is a placeholder, try to resolve it
+                    config_dir = os.path.dirname(config.get('config_path', ''))
+                    synaptic_models_dir = synaptic_models_dir.replace('$COMPONENTS_DIR', 
+                                                                    os.path.join(config_dir, 'components'))
+                    synaptic_models_dir = synaptic_models_dir.replace('$BASE_DIR', config_dir)
+                
+                dynamics_file = os.path.join(synaptic_models_dir, dynamics_params)
+                
+                if os.path.exists(dynamics_file):
+                    with open(dynamics_file, 'r') as f:
+                        return json.load(f)
+                else:
+                    print(f"Warning: Dynamics params file not found: {dynamics_file}")
+        except Exception as e:
+            print(f"Warning: Error loading synaptic parameters: {e}")
+        
+        return {}
+    
+    @classmethod
+    def list_connections_from_config(cls, config_path: str, network: Optional[str] = None) -> Dict[str, dict]:
+        """
+        Class method to list all available connections from a BMTK config file without creating a tuner.
+        
+        Parameters:
+        -----------
+        config_path : str
+            Path to the simulation config JSON file.
+        network : Optional[str]
+            Name of the specific network dataset to access (e.g., 'network_to_network').
+            If None, processes all available networks.
+            
+        Returns:
+        --------
+        Dict[str, dict]
+            Dictionary with connection names as keys and connection info as values.
+        """
+        # Create a temporary instance just to use the parsing methods
+        temp_tuner = cls.__new__(cls)  # Create without calling __init__
+        conn_type_settings = temp_tuner._build_conn_type_settings_from_config(config_path, network=network)
+        
+        # Create a summary of connections with key info
+        connections_summary = {}
+        for conn_name, settings in conn_type_settings.items():
+            connections_summary[conn_name] = {
+                'post_cell': settings['spec_settings']['post_cell'],
+                'synapse_type': settings['spec_settings']['level_of_detail'],
+                'parameters': list(settings['spec_syn_param'].keys())
+            }
+        
+        return connections_summary
+
+    def _switch_connection(self, new_connection: str) -> None:
+        """
+        Switch to a different connection type and update all related properties.
+        
+        Parameters:
+        -----------
+        new_connection : str
+            Name of the new connection type to switch to.
+        """
+        if new_connection not in self.conn_type_settings:
+            raise ValueError(f"Connection '{new_connection}' not found in conn_type_settings.")
+        
+        # Update current connection
+        self.current_connection = new_connection
+        self.conn = self.conn_type_settings[new_connection]
+        self.synaptic_props = self.conn["spec_syn_param"]
+        
+        # Update slider vars for new connection
+        if hasattr(self, 'original_slider_vars'):
+            # Filter slider vars based on new connection's parameters
+            self.slider_vars = {
+                key: value for key, value in self.synaptic_props.items() 
+                if key in self.original_slider_vars
+            }
+            
+            # Check for missing keys and try to get them from the synapse
+            for key in self.original_slider_vars:
+                if key not in self.synaptic_props:
+                    try:
+                        # We'll get this after recreating the synapse
+                        pass
+                    except AttributeError as e:
+                        print(f"Warning: Could not access '{key}' for connection '{new_connection}': {e}")
+        else:
+            self.slider_vars = self.synaptic_props
+        
+        # Need to recreate the cell if it's different
+        if self.hoc_cell is None:
+            # Check if we need a different cell type
+            new_cell_type = self.conn["spec_settings"]["post_cell"]
+            if not hasattr(self, '_current_cell_type') or self._current_cell_type != new_cell_type:
+                self._current_cell_type = new_cell_type
+                self._set_up_cell()
+        
+        # Recreate synapse for new connection
+        self._set_up_synapse()
+        
+        # Update any missing slider vars from the new synapse
+        if hasattr(self, 'original_slider_vars'):
+            for key in self.original_slider_vars:
+                if key not in self.synaptic_props:
+                    try:
+                        value = getattr(self.syn, key)
+                        self.slider_vars[key] = value
+                    except AttributeError as e:
+                        print(f"Warning: Could not access '{key}' for connection '{new_connection}': {e}")
+        
+        # Recreate NetCon connections with new synapse
+        self.nc = h.NetCon(
+            self.nstim,
+            self.syn,
+            self.general_settings["threshold"],
+            self.general_settings["delay"],
+            self.general_settings["weight"],
+        )
+        self.nc2 = h.NetCon(
+            self.nstim2,
+            self.syn,
+            self.general_settings["threshold"],
+            self.general_settings["delay"],
+            self.general_settings["weight"],
+        )
+        
+        # Recreate voltage clamp with potentially new cell
+        self.vcl = h.VClamp(self.cell.soma[0](0.5))
+        
+        # Recreate recorders for new synapse
+        self._set_up_recorders()
+        
+        # Reset NEURON state
+        h.finitialize()
+        
+        print(f"Successfully switched to connection: {new_connection}")
+
+    def _switch_network(self, new_network: str) -> None:
+        """
+        Switch to a different network and rebuild conn_type_settings for the new network.
+        
+        This method is called when the user selects a different network from the network 
+        dropdown in InteractiveTuner. It performs a complete rebuild of the connection 
+        types available for the new network.
+        
+        Parameters:
+        -----------
+        new_network : str
+            Name of the new network to switch to.
+            
+        Network Switching Process:
+        -------------------------
+        1. Validates the new network exists in available_networks
+        2. Rebuilds conn_type_settings using the new network's edge data
+        3. Updates the connection dropdown with new network's available connections
+        4. Preserves current connection if it exists in new network
+        5. Falls back to first available connection if current doesn't exist
+        6. Recreates synapses and NEURON objects for the new connection
+        7. Updates UI components to reflect the changes
+        """
+        if new_network not in self.available_networks:
+            print(f"Warning: Network '{new_network}' not found in available networks: {self.available_networks}")
+            return
+        
+        if new_network == self.current_network:
+            return  # No change needed
+        
+        # Update current network
+        self.current_network = new_network
+        
+        # Switch conn_type_settings using prebuilt data if available, otherwise build on-demand
+        if self.config:
+            print(f"Switching connections for network: {new_network}")
+            if hasattr(self, '_prebuilt_conn_type_settings') and new_network in self._prebuilt_conn_type_settings:
+                self.conn_type_settings = self._prebuilt_conn_type_settings[new_network]
+            else:
+                # Fallback: build on-demand (slower)
+                self.conn_type_settings = self._build_conn_type_settings_from_config(self.config, network=new_network)
+            
+            # Update available connections and select first one if current doesn't exist
+            available_connections = list(self.conn_type_settings.keys())
+            if self.current_connection not in available_connections and available_connections:
+                self.current_connection = available_connections[0]
+                print(f"Connection '{self.current_connection}' not available in new network. Switched to: {available_connections[0]}")
+            
+            # Switch to the (potentially new) connection
+            if self.current_connection in self.conn_type_settings:
+                self._switch_connection(self.current_connection)
+            
+            print(f"Successfully switched to network: {new_network}")
+            print(f"Available connections: {available_connections}")
+
     def _update_spec_syn_param(self, json_folder_path: str) -> None:
         """
         Update specific synaptic parameters using JSON files located in the specified folder.
@@ -213,11 +760,14 @@ class SynapseTuner:
         - `_set_up_cell()` should be called before setting up the synapse.
         - Synapse location, type, and properties are specified within `spec_syn_param` and `spec_settings`.
         """
-        self.syn = getattr(h, self.conn["spec_settings"]["level_of_detail"])(
-            list(self.cell.all)[self.conn["spec_settings"]["sec_id"]](
-                self.conn["spec_settings"]["sec_x"]
+        try:
+            self.syn = getattr(h, self.conn["spec_settings"]["level_of_detail"])(
+                list(self.cell.all)[self.conn["spec_settings"]["sec_id"]](
+                    self.conn["spec_settings"]["sec_x"]
+                )
             )
-        )
+        except:
+            raise Exception("Make sure the mod file exist you are trying to load check spelling!")
         for key, value in self.conn["spec_syn_param"].items():
             if isinstance(value, (int, float)):
                 if hasattr(self.syn, key):
@@ -741,6 +1291,8 @@ class SynapseTuner:
         Sets up interactive sliders for tuning short-term plasticity (STP) parameters in a Jupyter Notebook.
 
         This method creates an interactive UI with sliders for:
+        - Network selection dropdown (if multiple networks available and config provided)
+        - Connection type selection dropdown
         - Input frequency
         - Delay between pulse trains
         - Duration of stimulation (for continuous input mode)
@@ -752,10 +1304,21 @@ class SynapseTuner:
         - Toggling voltage clamp mode
         - Switching between standard and continuous input modes
 
+        Network Dropdown Feature:
+        ------------------------
+        When the SynapseTuner is initialized with a BMTK config file containing multiple networks:
+        - A network dropdown appears next to the connection dropdown
+        - Users can dynamically switch between networks (e.g., 'network_to_network', 'external_to_network')
+        - Switching networks rebuilds available connections and updates the connection dropdown
+        - The current connection is preserved if it exists in the new network
+        - If multiple networks exist but only one is specified during init, that network is used as default
+
         Notes:
         ------
         Ideal for exploratory parameter tuning and interactive visualization of
         synapse behavior with different parameter values and stimulation protocols.
+        The network dropdown feature enables comprehensive exploration of multi-network
+        BMTK simulations without needing to reinitialize the tuner.
         """
         # Widgets setup (Sliders)
         freqs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 35, 50, 100, 200]
@@ -766,6 +1329,26 @@ class SynapseTuner:
         duration0 = 300
         vlamp_status = self.vclamp
 
+        # Connection dropdown
+        connection_options = list(self.conn_type_settings.keys())
+        w_connection = widgets.Dropdown(
+            options=connection_options,
+            value=self.current_connection,
+            description="Connection:",
+            style={'description_width': 'initial'}
+        )
+
+        # Network dropdown - only shown if config was provided and multiple networks are available
+        # This enables users to switch between different network datasets dynamically
+        w_network = None
+        if self.config is not None and len(self.available_networks) > 1:
+            w_network = widgets.Dropdown(
+                options=self.available_networks,
+                value=self.current_network,
+                description="Network:",
+                style={'description_width': 'initial'}
+            )
+
         w_run = widgets.Button(description="Run Train", icon="history", button_style="primary")
         w_single = widgets.Button(description="Single Event", icon="check", button_style="success")
         w_vclamp = widgets.ToggleButton(
@@ -774,6 +1357,17 @@ class SynapseTuner:
             icon="fast-backward",
             button_style="warning",
         )
+        
+        # Voltage clamp amplitude input
+        default_vclamp_amp = getattr(self.conn['spec_settings'], 'vclamp_amp', -70.0)
+        w_vclamp_amp = widgets.FloatText(
+            value=default_vclamp_amp,
+            description="V_clamp (mV):",
+            step=5.0,
+            style={'description_width': 'initial'},
+            layout=widgets.Layout(width='150px')
+        )
+        
         w_input_mode = widgets.ToggleButton(
             value=False, description="Continuous input", icon="eject", button_style="info"
         )
@@ -785,54 +1379,178 @@ class SynapseTuner:
             options=durations, value=duration0, description="Duration"
         )
 
+        def create_dynamic_sliders():
+            """Create sliders based on current connection's parameters"""
+            sliders = {}
+            for key, value in self.slider_vars.items():
+                if isinstance(value, (int, float)):  # Only create sliders for numeric values
+                    if hasattr(self.syn, key):
+                        if value == 0:
+                            print(
+                                f"{key} was set to zero, going to try to set a range of values, try settings the {key} to a nonzero value if you dont like the range!"
+                            )
+                            slider = widgets.FloatSlider(
+                                value=value, min=0, max=1000, step=1, description=key
+                            )
+                        else:
+                            slider = widgets.FloatSlider(
+                                value=value, min=0, max=value * 20, step=value / 5, description=key
+                            )
+                        sliders[key] = slider
+                    else:
+                        print(f"skipping slider for {key} due to not being a synaptic variable")
+            return sliders
+
         # Generate sliders dynamically based on valid numeric entries in self.slider_vars
-        self.dynamic_sliders = {}
+        self.dynamic_sliders = create_dynamic_sliders()
         print(
             "Setting up slider! The sliders ranges are set by their init value so try changing that if you dont like the slider range!"
         )
-        for key, value in self.slider_vars.items():
-            if isinstance(value, (int, float)):  # Only create sliders for numeric values
-                if hasattr(self.syn, key):
-                    if value == 0:
-                        print(
-                            f"{key} was set to zero, going to try to set a range of values, try settings the {key} to a nonzero value if you dont like the range!"
-                        )
-                        slider = widgets.FloatSlider(
-                            value=value, min=0, max=1000, step=1, description=key
-                        )
-                    else:
-                        slider = widgets.FloatSlider(
-                            value=value, min=0, max=value * 20, step=value / 5, description=key
-                        )
-                    self.dynamic_sliders[key] = slider
-                else:
-                    print(f"skipping slider for {key} due to not being a synaptic variable")
 
+        # Create output widget for displaying results
+        output_widget = widgets.Output()
+        
         def run_single_event(*args):
             clear_output()
             display(ui)
+            display(output_widget)
+            
             self.vclamp = w_vclamp.value
+            # Update voltage clamp amplitude if voltage clamp is enabled
+            if self.vclamp:
+                # Update the voltage clamp amplitude settings
+                self.conn['spec_settings']['vclamp_amp'] = w_vclamp_amp.value
+                # Update general settings if they exist
+                if hasattr(self, 'general_settings'):
+                    self.general_settings['vclamp_amp'] = w_vclamp_amp.value
             # Update synaptic properties based on slider values
             self.ispk = None
-            self.SingleEvent()
+            
+            # Clear previous results and run simulation
+            output_widget.clear_output()
+            with output_widget:
+                self.SingleEvent()
+
+        def on_connection_change(*args):
+            """Handle connection dropdown change"""
+            try:
+                new_connection = w_connection.value
+                if new_connection != self.current_connection:
+                    # Switch to new connection
+                    self._switch_connection(new_connection)
+                    
+                    # Recreate dynamic sliders for new connection
+                    self.dynamic_sliders = create_dynamic_sliders()
+                    
+                    # Update UI
+                    update_ui_layout()
+                    update_ui()
+                    
+            except Exception as e:
+                print(f"Error switching connection: {e}")
+
+        def on_network_change(*args):
+            """
+            Handle network dropdown change events.
+            
+            This callback is triggered when the user selects a different network from 
+            the network dropdown. It coordinates the complete switching process:
+            1. Calls _switch_network() to rebuild connections for the new network
+            2. Updates the connection dropdown options with new network's connections
+            3. Recreates dynamic sliders for the new connection parameters
+            4. Refreshes the entire UI to reflect all changes
+            """
+            if w_network is None:
+                return
+            try:
+                new_network = w_network.value
+                if new_network != self.current_network:
+                    # Switch to new network
+                    self._switch_network(new_network)
+                    
+                    # Update connection dropdown options with new network's connections
+                    connection_options = list(self.conn_type_settings.keys())
+                    w_connection.options = connection_options
+                    if connection_options:
+                        w_connection.value = self.current_connection
+                    
+                    # Recreate dynamic sliders for new connection
+                    self.dynamic_sliders = create_dynamic_sliders()
+                    
+                    # Update UI
+                    update_ui_layout()
+                    update_ui()
+                    
+            except Exception as e:
+                print(f"Error switching network: {e}")
+
+        def update_ui_layout():
+            """
+            Update the UI layout with new sliders and network dropdown.
+            
+            This function reconstructs the entire UI layout including:
+            - Network dropdown (if available) and connection dropdown in the top row
+            - Button controls and input mode toggles
+            - Parameter sliders arranged in columns
+            """
+            nonlocal ui, slider_columns
+            
+            # Add the dynamic sliders to the UI
+            slider_widgets = [slider for slider in self.dynamic_sliders.values()]
+            
+            if slider_widgets:
+                half = len(slider_widgets) // 2
+                col1 = VBox(slider_widgets[:half])
+                col2 = VBox(slider_widgets[half:])
+                slider_columns = HBox([col1, col2])
+            else:
+                slider_columns = VBox([])
+            
+            # Create button row with voltage clamp controls
+            if w_vclamp.value:  # Show voltage clamp amplitude input when toggle is on
+                button_row = HBox([w_run, w_single, w_vclamp, w_vclamp_amp, w_input_mode])
+            else:  # Hide voltage clamp amplitude input when toggle is off
+                button_row = HBox([w_run, w_single, w_vclamp, w_input_mode])
+            
+            # Construct the top row - include network dropdown if available
+            # This creates a horizontal layout with network dropdown (if present) and connection dropdown
+            if w_network is not None:
+                connection_row = HBox([w_network, w_connection])
+            else:
+                connection_row = HBox([w_connection])
+            slider_row = HBox([w_input_freq, self.w_delay, self.w_duration])
+            
+            ui = VBox([connection_row, button_row, slider_row, slider_columns])
 
         # Function to update UI based on input mode
         def update_ui(*args):
             clear_output()
             display(ui)
+            display(output_widget)
+            
             self.vclamp = w_vclamp.value
+            # Update voltage clamp amplitude if voltage clamp is enabled
+            if self.vclamp:
+                self.conn['spec_settings']['vclamp_amp'] = w_vclamp_amp.value
+                if hasattr(self, 'general_settings'):
+                    self.general_settings['vclamp_amp'] = w_vclamp_amp.value
+            
             self.input_mode = w_input_mode.value
             syn_props = {var: slider.value for var, slider in self.dynamic_sliders.items()}
             self._set_syn_prop(**syn_props)
-            if not self.input_mode:
-                self._simulate_model(w_input_freq.value, self.w_delay.value, w_vclamp.value)
-            else:
-                self._simulate_model(w_input_freq.value, self.w_duration.value, w_vclamp.value)
-            amp = self._response_amplitude()
-            self._plot_model(
-                [self.general_settings["tstart"] - self.nstim.interval / 3, self.tstop]
-            )
-            _ = self._calc_ppr_induction_recovery(amp)
+            
+            # Clear previous results and run simulation
+            output_widget.clear_output()
+            with output_widget:
+                if not self.input_mode:
+                    self._simulate_model(w_input_freq.value, self.w_delay.value, w_vclamp.value)
+                else:
+                    self._simulate_model(w_input_freq.value, self.w_duration.value, w_vclamp.value)
+                amp = self._response_amplitude()
+                self._plot_model(
+                    [self.general_settings["tstart"] - self.nstim.interval / 3, self.tstop]
+                )
+                _ = self._calc_ppr_induction_recovery(amp)
 
         # Function to switch between delay and duration sliders
         def switch_slider(*args):
@@ -843,8 +1561,21 @@ class SynapseTuner:
                 self.w_delay.layout.display = ""  # Show delay slider
                 self.w_duration.layout.display = "none"  # Hide duration slider
 
-        # Link input mode to slider switch
+        # Function to handle voltage clamp toggle
+        def on_vclamp_toggle(*args):
+            """Handle voltage clamp toggle changes to show/hide amplitude input"""
+            update_ui_layout()
+            clear_output()
+            display(ui)
+            display(output_widget)
+
+        # Link widgets to their callback functions
+        w_connection.observe(on_connection_change, names="value")
+        # Link network dropdown callback only if network dropdown was created
+        if w_network is not None:
+            w_network.observe(on_network_change, names="value")
         w_input_mode.observe(switch_slider, names="value")
+        w_vclamp.observe(on_vclamp_toggle, names="value")
 
         # Hide the duration slider initially until the user selects it
         self.w_duration.layout.display = "none"  # Hide duration slider
@@ -852,18 +1583,10 @@ class SynapseTuner:
         w_single.on_click(run_single_event)
         w_run.on_click(update_ui)
 
-        # Add the dynamic sliders to the UI
-        slider_widgets = [slider for slider in self.dynamic_sliders.values()]
-
-        button_row = HBox([w_run, w_single, w_vclamp, w_input_mode])
-        slider_row = HBox([w_input_freq, self.w_delay, self.w_duration])
-
-        half = len(slider_widgets) // 2
-        col1 = VBox(slider_widgets[:half])
-        col2 = VBox(slider_widgets[half:])
-        slider_columns = HBox([col1, col2])
-
-        ui = VBox([button_row, slider_row, slider_columns])
+        # Initial UI setup
+        slider_columns = VBox([])
+        ui = VBox([])
+        update_ui_layout()
 
         display(ui)
         update_ui()

{bmtool-0.7.4.1.dist-info → bmtool-0.7.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmtool
-Version: 0.7.4.1
+Version: 0.7.5.1
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.7.4.1.dist-info → bmtool-0.7.5.1.dist-info}/RECORD

@@ -5,8 +5,8 @@ bmtool/connectors.py,sha256=4SJRqBXM145_-nFycGrnlfjSyaoarOr0QkHl00jWq4I,74384
 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=Ayz4swAx0gNG-KtsCDJn3XJ7vw-qDuvSHy6xeIzd9ok,69697
+bmtool/singlecell.py,sha256=xqdLM2TjjnL8YyTy-c3WR6mElTv3E4zkZgkfUh4S5X0,47161
+bmtool/synapses.py,sha256=k-xyZjElz2CHM2oGXqBnFOCd0NusoA6JASzPXHPCj5c,106068
 bmtool/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/analysis/entrainment.py,sha256=NQloQtVpEWjDzmkZwMWVcm3hSjErHBZfQl1mrBVoIE8,25321
 bmtool/analysis/lfp.py,sha256=S2JvxkjcK3-EH93wCrhqNSFY6cX7fOq74pz64ibHKrc,26556
@@ -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.4.1.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.7.4.1.dist-info/METADATA,sha256=TKDtODjH25ZRw2vYbHZWER_RuoAkIOEA3G2Hhpz6PHc,3597
-bmtool-0.7.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bmtool-0.7.4.1.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.7.4.1.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.7.4.1.dist-info/RECORD,,
+bmtool-0.7.5.1.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
+bmtool-0.7.5.1.dist-info/METADATA,sha256=H1XxiaHJuU-Bq_HTck5_z1fm08rTmSNxZYBA7hVcmNk,3597
+bmtool-0.7.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bmtool-0.7.5.1.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
+bmtool-0.7.5.1.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
+bmtool-0.7.5.1.dist-info/RECORD,,