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

bmtool/bmplot/connections.py

@@ -12,7 +12,6 @@ import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 from IPython import get_ipython
-from neuron import h
 
 from ..util import util
 
@@ -133,6 +132,7 @@ def total_connection_matrix(
         title = "All Synapse .mod Files Used"
     if synaptic_info == "3":
         title = "All Synapse .json Files Used"
+    
     plot_connection_info(
         text, num, source_labels, target_labels, title, syn_info=synaptic_info, save_file=save_file
     )
@@ -981,104 +981,172 @@ def distance_delay_plot(
     plt.show()
 
 
-def plot_synapse_location_histograms(config, target_model, source=None, target=None):
+def plot_synapse_location(config: str, source: str, target: str, sids: str, tids: str) -> tuple:
     """
-    generates a histogram of the positions of the synapses on a cell broken down by section
-    config: a BMTK config
-    target_model: the name of the model_template used when building the BMTK node
-    source: The source BMTK network
-    target: The target BMTK network
-    """
-    # Load mechanisms and template
-
-    util.load_templates_from_config(config)
-
-    # Load node and edge data
-    nodes, edges = util.load_nodes_edges_from_config(config)
-    nodes = nodes[source]
-    edges = edges[f"{source}_to_{target}"]
-
-    # Map target_node_id to model_template
-    edges["target_model_template"] = edges["target_node_id"].map(nodes["model_template"])
-
-    # Map source_node_id to pop_name
-    edges["source_pop_name"] = edges["source_node_id"].map(nodes["pop_name"])
-
-    edges = edges[edges["target_model_template"] == target_model]
-
-    # Create the cell model from target model
-    cell = getattr(h, target_model.split(":")[1])()
-
-    # Create a mapping from section index to section name
-    section_id_to_name = {}
-    for idx, sec in enumerate(cell.all):
-        section_id_to_name[idx] = sec.name()
-
-    # Add a new column with section names based on afferent_section_id
-    edges["afferent_section_name"] = edges["afferent_section_id"].map(section_id_to_name)
-
-    # Get unique sections and source populations
-    unique_pops = edges["source_pop_name"].unique()
-
-    # Filter to only include sections with data
-    section_counts = edges["afferent_section_name"].value_counts()
-    sections_with_data = section_counts[section_counts > 0].index.tolist()
-
-    # Create a figure with subplots for each section
-    plt.figure(figsize=(8, 12))
+    Generates a connectivity matrix showing synaptic distribution across different cell sections.
+    Note does exclude gap junctions since they dont have an afferent id stored in the h5 file!
 
-    # Color map for source populations
-    color_map = plt.cm.tab10(np.linspace(0, 1, len(unique_pops)))
-    pop_colors = {pop: color for pop, color in zip(unique_pops, color_map)}
+    Parameters
+    ----------
+    config : str
+        Path to BMTK config file
+    source : str
+        The source BMTK network name
+    target : str
+        The target BMTK network name
+    sids : str
+        Column name in nodes file containing source population identifiers
+    tids : str
+        Column name in nodes file containing target population identifiers
+
+    Returns
+    -------
+    tuple
+        (matplotlib.figure.Figure, matplotlib.axes.Axes) containing the plot
+
+    Raises
+    ------
+    ValueError
+        If required parameters are missing or invalid
+    RuntimeError
+        If template loading or cell instantiation fails
+    """
+    import matplotlib.pyplot as plt
+    import numpy as np
+    from neuron import h
+
+    # Validate inputs
+    if not all([config, source, target, sids, tids]):
+        raise ValueError(
+            "Missing required parameters: config, source, target, sids, and tids must be provided"
+        )
 
-    # Create a histogram for each section
-    for i, section in enumerate(sections_with_data):
-        ax = plt.subplot(len(sections_with_data), 1, i + 1)
+    try:
+        # Load mechanisms and template
+        util.load_templates_from_config(config)
+    except Exception as e:
+        raise RuntimeError(f"Failed to load templates from config: {str(e)}")
 
-        # Get data for this section
-        section_data = edges[edges["afferent_section_name"] == section]
+    try:
+        # Load node and edge data
+        nodes, edges = util.load_nodes_edges_from_config(config)
+        if source not in nodes or f"{source}_to_{target}" not in edges:
+            raise ValueError(f"Source '{source}' or target '{target}' networks not found in data")
+
+        target_nodes = nodes[target]
+        source_nodes = nodes[source]
+        edges = edges[f"{source}_to_{target}"]
+        # Find edges with NaN afferent_section_id
+        nan_edges = edges[edges["afferent_section_id"].isna()]
+        # Print information about removed edges
+        if not nan_edges.empty:
+            unique_indices = sorted(list(set(nan_edges.index.tolist())))
+            print(f"Removing {len(nan_edges)} edges with missing afferent_section_id")
+            print(f"Unique indices removed: {unique_indices}")
+            
+        # Filter out edges with NaN afferent_section_id
+        edges = edges[edges["afferent_section_id"].notna()]
+
+
+    except Exception as e:
+        raise RuntimeError(f"Failed to load nodes and edges: {str(e)}")
+
+    # Map identifiers while checking for missing values
+    edges["target_model_template"] = edges["target_node_id"].map(target_nodes["model_template"])
+    edges["target_pop_name"] = edges["target_node_id"].map(target_nodes[tids])
+    edges["source_pop_name"] = edges["source_node_id"].map(source_nodes[sids])
+
+    if edges["target_model_template"].isnull().any():
+        print("Warning: Some target nodes missing model template")
+    if edges["target_pop_name"].isnull().any():
+        print("Warning: Some target nodes missing population name")
+    if edges["source_pop_name"].isnull().any():
+        print("Warning: Some source nodes missing population name")
+
+    # Get unique populations
+    source_pops = edges["source_pop_name"].unique()
+    target_pops = edges["target_pop_name"].unique()
+
+    # Initialize matrices
+    num_connections = np.zeros((len(source_pops), len(target_pops)))
+    text_data = np.empty((len(source_pops), len(target_pops)), dtype=object)
+
+    # Create mappings for indices
+    source_pop_to_idx = {pop: idx for idx, pop in enumerate(source_pops)}
+    target_pop_to_idx = {pop: idx for idx, pop in enumerate(target_pops)}
+
+    # Cache for section mappings to avoid recreating cells
+    section_mappings = {}
+
+    # Calculate connectivity statistics
+    for source_pop in source_pops:
+        for target_pop in target_pops:
+            # Filter edges for this source-target pair
+            filtered_edges = edges[
+                (edges["source_pop_name"] == source_pop) & (edges["target_pop_name"] == target_pop)
+            ]
 
-        # Group by source population
-        for pop_name, pop_group in section_data.groupby("source_pop_name"):
-            if len(pop_group) > 0:
-                ax.hist(
-                    pop_group["afferent_section_pos"],
-                    bins=15,
-                    alpha=0.7,
-                    label=pop_name,
-                    color=pop_colors[pop_name],
-                )
+            source_idx = source_pop_to_idx[source_pop]
+            target_idx = target_pop_to_idx[target_pop]
 
-        # Set title and labels
-        ax.set_title(f"{section}", fontsize=10)
-        ax.set_xlabel("Section Position", fontsize=8)
-        ax.set_ylabel("Frequency", fontsize=8)
-        ax.tick_params(labelsize=7)
-        ax.grid(True, alpha=0.3)
+            if len(filtered_edges) == 0:
+                num_connections[source_idx, target_idx] = 0
+                text_data[source_idx, target_idx] = "No connections"
+                continue
 
-        # Only add legend to the first plot
-        if i == 0:
-            ax.legend(fontsize=8)
+            total_connections = len(filtered_edges)
+            target_model_template = filtered_edges["target_model_template"].iloc[0]
 
-    plt.tight_layout()
-    plt.suptitle(
-        "Connection Distribution by Cell Section and Source Population", fontsize=16, y=1.02
+            try:
+                # Get or create section mapping for this model
+                if target_model_template not in section_mappings:
+                    cell_class_name = (
+                        target_model_template.split(":")[1]
+                        if ":" in target_model_template
+                        else target_model_template
+                    )
+                    cell = getattr(h, cell_class_name)()
+
+                    # Create section mapping
+                    section_mapping = {}
+                    for idx, sec in enumerate(cell.all):
+                        section_mapping[idx] = sec.name().split(".")[-1]  # Clean name
+                    section_mappings[target_model_template] = section_mapping
+
+                section_mapping = section_mappings[target_model_template]
+
+                # Calculate section distribution
+                section_counts = filtered_edges["afferent_section_id"].value_counts()
+                section_percentages = (section_counts / total_connections * 100).round(1)
+
+                # Format section distribution text - show all sections
+                section_display = []
+                for section_id, percentage in section_percentages.items():
+                    section_name = section_mapping.get(section_id, f"sec_{section_id}")
+                    section_display.append(f"{section_name}:{percentage}%")
+
+                num_connections[source_idx, target_idx] = total_connections
+                text_data[source_idx, target_idx] = "\n".join(section_display)
+
+            except Exception as e:
+                print(f"Warning: Error processing {target_model_template}: {str(e)}")
+                num_connections[source_idx, target_idx] = total_connections
+                text_data[source_idx, target_idx] = "Section info N/A"
+
+    # Create the plot
+    title = f"Synaptic Distribution by Section: {source} to {target}"
+    fig, ax = plot_connection_info(
+        text=text_data,
+        num=num_connections,
+        source_labels=list(source_pops),
+        target_labels=list(target_pops),
+        title=title,
+        syn_info="1",
     )
-    if is_notebook:
+    if is_notebook():
         plt.show()
     else:
-        pass
-
-    # Create a summary table
-    print("Summary of connections by section and source population:")
-    pivot_table = edges.pivot_table(
-        values="afferent_section_id",
-        index="afferent_section_name",
-        columns="source_pop_name",
-        aggfunc="count",
-        fill_value=0,
-    )
-    print(pivot_table)
+        return fig, ax
 
 
 def plot_connection_info(

bmtool/util/util.py

@@ -16,6 +16,9 @@ import numpy as np
 import pandas as pd
 from neuron import h
 
+from typing import Dict, List, Optional, Union, Any
+from pathlib import Path
+
 # from bmtk.utils.io.cell_vars import CellVarsFile
 # from bmtk.analyzer.cell_vars import _get_cell_report
 # from bmtk.analyzer.io_tools import load_config
@@ -345,95 +348,366 @@ def load_edges(edges_file, edge_types_file):
     return edges  # return (population, edges_df)
 
 
-def load_edges_from_paths(edge_paths):  # network_dir='network'):
+def load_edges_from_paths(
+    file_paths: str, 
+    verbose: bool = False
+) -> Dict[str, pd.DataFrame]:
     """
-    Returns: A dictionary of connections with filenames (minus _edges.h5) as keys
-
-    edge_paths must be in the format in a circuit config file:
-        [
-            {
-            "edges_file":"filepath", (csv)
-            "edge_types_file":"filepath" (h5)
-            },...
-        ]
-    util.load_edges_from_paths([{"edges_file":"network/hippocampus_hippocampus_edges.h5","edge_types_file":"network/hippocampus_hippocampus_edge_types.csv"}])
+    Load multiple SONATA edge files into a dictionary of DataFrames.
+    
+    This function reads a configuration file containing multiple edge file pairs
+    (CSV + H5) and loads each pair into a separate DataFrame. Each DataFrame
+    contains merged edge connectivity and metadata information.
+    
+    Parameters:
+    -----------
+    file_paths str
+        Expected structure:  [{'edge_types_file': ..., 'edges_file': ...}, ...]
+    verbose : bool, default False
+        If True, print detailed information about the loading process
+        
+    Returns:
+    --------
+    Dict[str, pd.DataFrame]
+        Dictionary mapping edge dataset names to DataFrames.
+        Keys are derived from CSV filenames (without '_edge_types.csv' suffix).
+        Values are DataFrames containing merged edge data.
+        
+    Notes:
+    ------
+    - If loading fails for any dataset, an empty DataFrame is stored for that key
+    - Dataset names are extracted from CSV filenames for readability
+    - All edge data follows SONATA format specifications
     """
-    import h5py
-    import pandas as pd
-    # edges_regex = "_edges.h5"
-    # edge_types_regex = "_edge_types.csv"
-
-    # edges_h5_fpaths = glob.glob(os.path.join(network_dir,'*'+edges_regex))
-    # edge_types_fpaths = glob.glob(os.path.join(network_dir,'*'+edge_types_regex))
-
-    # connections = [re.findall('^[A-Za-z0-9]+_[A-Za-z0-9][^_]+', os.path.basename(n))[0] for n in edges_h5_fpaths]
-    edges_dict = {}
-
-    def get_edge_table(edges_file, edge_types_file, population=None):
-        # dataframe where each row is an edge type
-        cm_df = pd.read_csv(edge_types_file, sep=" ")
-        cm_df.set_index("edge_type_id", inplace=True)
-
-        with h5py.File(edges_file, "r") as connections_h5:
-            if population is None:
-                if len(connections_h5["/edges"]) > 1:
-                    raise Exception(
-                        "Multiple populations in edges file. Not currently implemented, should not be hard to do, contact Tyler"
-                    )
-                else:
-                    population = list(connections_h5["/edges"])[0]
-            conn_grp = connections_h5["/edges"][population]
-
-            # dataframe where each row is an edge
-            c_df = pd.DataFrame(
-                {key: conn_grp[key] for key in ("edge_type_id", "source_node_id", "target_node_id")}
-            )
+    
+    # Load configuration and extract edge file information
+   
+    edge_files_list = file_paths
+    
+    if verbose:
+        print(f"Loading {len(edge_files_list)} edge datasets from config: {config}")
+    
+    edges_dict: Dict[str, pd.DataFrame] = {}
+    
+    # Process each edge file pair
+    for i, file_info in enumerate(edge_files_list):
+        csv_path = file_info['edge_types_file']
+        h5_path = file_info['edges_file']
+        
+        # Generate meaningful key from h5 file
+        with h5py.File(h5_path, "r") as connections_h5:
+            key = list(connections_h5["/edges"])[0]
+            
+        if verbose:
+            print(f"\n{'='*60}")
+            print(f"Loading edge set {i+1}/{len(edge_files_list)}: {key}")
+            print(f"{'='*60}")
+        
+        try:
+            # Load individual edge dataset
+            df = load_sonata_edges_to_dataframe(csv_path, h5_path, verbose=verbose)
+            edges_dict[key] = df
+            
+            if verbose:
+                print(f"\nSuccessfully loaded {key}: {df.shape[0]} edges, {df.shape[1]} columns")
+                
+                # Show important columns for verification
+                important_cols = ['edge_type_id', 'source_node_id', 'target_node_id', 
+                                'model_template', 'afferent_section_id']
+                available_important = [col for col in important_cols if col in df.columns]
+                print(f"Key columns available: {available_important}")
+                
+                # Show model template information if available
+                if 'model_template' in df.columns:
+                    unique_templates = df['model_template'].dropna().unique()
+                    print(f"Model templates: {unique_templates}")
+                    
+        except Exception as e:
+            if verbose:
+                print(f"Error loading {key}: {str(e)}")
+            edges_dict[key] = pd.DataFrame()  # Store empty DataFrame on error
+    
+    if verbose:
+        print(f"\n{'='*60}")
+        print("LOADING SUMMARY")
+        print(f"{'='*60}")
+        for key, df in edges_dict.items():
+            if not df.empty:
+                print(f"{key}: {df.shape[0]} edges, {df.shape[1]} columns")
+                if 'model_template' in df.columns:
+                    templates = df['model_template'].dropna().unique()
+                    print(f"  Model templates: {list(templates)}")
+                if 'afferent_section_id' in df.columns:
+                    print(f"  afferent_section_id available")
+            else:
+                print(f"{key}: No data loaded (error occurred)")
+    
+    return edges_dict
 
-            c_df.reset_index(inplace=True)
-            c_df.rename(columns={"index": "edge_id"}, inplace=True)
-            c_df.set_index("edge_type_id", inplace=True)
 
-            # add edge type properties to df of edges
-            edges_df = pd.merge(
-                left=c_df, right=cm_df, how="left", left_index=True, right_index=True
+def load_sonata_edges_to_dataframe(
+    csv_path: Union[str, Path], 
+    h5_path: Union[str, Path], 
+    verbose: bool = False
+) -> pd.DataFrame:
+    """
+    Load SONATA format edge data into a pandas DataFrame.
+    
+    This function combines edge connectivity data from HDF5 files with edge type 
+    metadata from CSV files according to the SONATA specification. H5 attributes 
+    take precedence over CSV attributes when both exist for the same column.
+    
+    Parameters:
+    -----------
+    csv_path : Union[str, Path]
+        Path to the edge types CSV file (space-delimited)
+    h5_path : Union[str, Path]
+        Path to the edges HDF5 file containing connectivity data
+    verbose : bool, default False
+        If True, print detailed information about the loading process
+        
+    Returns:
+    --------
+    pd.DataFrame
+        Combined edge data with columns from both H5 and CSV sources.
+        Columns include:
+        - edge_id: Sequential edge identifier
+        - population: Edge population name
+        - edge_type_id: Edge type identifier for merging with CSV
+        - source_node_id, target_node_id: Connected node IDs
+        - source_population, target_population: Node population names
+        - edge_group_id, edge_group_index: Edge grouping information
+        - Additional attributes from H5 edge groups
+        - Edge type metadata from CSV (model_template, afferent_section_id, etc.)
+        
+    Notes:
+    ------
+    - CSV file must be space-delimited and contain 'edge_type_id' column
+    - H5 file must follow SONATA edge format with required datasets
+    - When both H5 and CSV contain the same attribute, H5 version is kept
+    - Dynamics parameters are flattened with 'dynamics_params/' prefix
+    """
+    
+    # Load edge types CSV (space-delimited)
+    edge_types_df = pd.read_csv(csv_path, sep=' ')
+    
+    if verbose:
+        print(f"Loaded edge types from: {csv_path}")
+        print(f"  Columns: {edge_types_df.columns.tolist()}")
+        print(f"  Shape: {edge_types_df.shape}")
+        print(f"  Unique edge_type_ids: {sorted(edge_types_df['edge_type_id'].unique())}")
+    
+    # Open HDF5 file and process edge data
+    with h5py.File(h5_path, 'r') as h5f:
+        
+        # Navigate to edges group
+        edges_group = h5f['edges']
+        populations = list(edges_group.keys())
+        
+        if verbose:
+            print(f"\nProcessing H5 file: {h5_path}")
+            print(f"  Edge populations: {populations}")
+        
+        # Process each population (typically one per file)
+        all_edges_data: List[pd.DataFrame] = []
+        
+        for pop_name in populations:
+            pop_group = edges_group[pop_name]
+            
+            if verbose:
+                print(f"\n  Processing population: {pop_name}")
+            
+            # Read required SONATA edge datasets
+            edge_type_ids = pop_group['edge_type_id'][:]
+            source_node_ids = pop_group['source_node_id'][:]
+            target_node_ids = pop_group['target_node_id'][:]
+            edge_group_ids = pop_group['edge_group_id'][:]
+            edge_group_indices = pop_group['edge_group_index'][:]
+            
+            if verbose:
+                print(f"    Unique edge_type_ids in H5: {sorted(np.unique(edge_type_ids))}")
+                print(f"    Number of edges: {len(edge_type_ids)}")
+            
+            # Extract node population attributes with proper string handling
+            source_pop = pop_group['source_node_id'].attrs.get('node_population', '')
+            target_pop = pop_group['target_node_id'].attrs.get('node_population', '')
+            
+            # Handle both string and bytes cases for population names
+            if isinstance(source_pop, bytes):
+                source_pop = source_pop.decode()
+            if isinstance(target_pop, bytes):
+                target_pop = target_pop.decode()
+            
+            n_edges = len(edge_type_ids)
+            
+            # Create base DataFrame with core edge attributes
+            edges_df = pd.DataFrame({
+                'edge_id': np.arange(n_edges),  # Sequential edge identifiers
+                'population': pop_name,
+                'edge_type_id': edge_type_ids,
+                'source_node_id': source_node_ids,
+                'target_node_id': target_node_ids,
+                'source_population': source_pop,
+                'target_population': target_pop,
+                'edge_group_id': edge_group_ids,
+                'edge_group_index': edge_group_indices
+            })
+            
+            # Process edge groups to extract additional attributes
+            edge_group_names = [
+                key for key in pop_group.keys() 
+                if key not in ['edge_type_id', 'source_node_id', 'target_node_id', 
+                              'edge_group_id', 'edge_group_index', 'indices']
+            ]
+            
+            # Track which columns come from H5 for precedence handling
+            edge_attributes: Dict[str, np.ndarray] = {}
+            h5_column_names: set = set()
+            
+            # Process each edge group to extract group-specific attributes
+            for group_name in edge_group_names:
+                group = pop_group[group_name]
+                group_id = int(group_name)
+                
+                # Identify edges belonging to this group
+                group_mask = edge_group_ids == group_id
+                group_indices = edge_group_indices[group_mask]
+                
+                # Extract all attributes from this edge group
+                for attr_name in group.keys():
+                    if attr_name == 'dynamics_params': # sonata says this exist but i have yet to see it
+                        # Handle nested dynamics parameters
+                        dynamics_group = group[attr_name]
+                        for param_name in dynamics_group.keys():
+                            param_data = dynamics_group[param_name][:]
+                            full_attr_name = f"dynamics_params/{param_name}"
+                            
+                            # Initialize attribute array if not exists
+                            if full_attr_name not in edge_attributes:
+                                edge_attributes[full_attr_name] = np.full(n_edges, np.nan, dtype=object)
+                            
+                            # Assign data to appropriate edges
+                            edge_attributes[full_attr_name][group_mask] = param_data[group_indices]
+                            h5_column_names.add(full_attr_name)
+                    else:
+                        # Handle regular attributes with proper string decoding
+                        attr_data = group[attr_name][:]
+                        
+                        # Handle string attributes properly
+                        if attr_data.dtype.kind in ['S', 'U']:  # String or Unicode
+                            # Decode bytes to strings if necessary
+                            if attr_data.dtype.kind == 'S':
+                                attr_data = np.array([
+                                    s.decode() if isinstance(s, bytes) else s 
+                                    for s in attr_data
+                                ])
+                        
+                        # Initialize attribute array with appropriate default
+                        if attr_name not in edge_attributes:
+                            if attr_data.dtype.kind in ['S', 'U']:
+                                edge_attributes[attr_name] = np.full(n_edges, '', dtype=object)
+                            else:
+                                edge_attributes[attr_name] = np.full(n_edges, np.nan, dtype=object)
+                        
+                        # Assign data to appropriate edges
+                        edge_attributes[attr_name][group_mask] = attr_data[group_indices]
+                        h5_column_names.add(attr_name)
+            
+            # Add all H5 attributes to the DataFrame
+            for attr_name, attr_values in edge_attributes.items():
+                edges_df[attr_name] = attr_values
+            
+            all_edges_data.append(edges_df)
+    
+    # Combine all populations into single DataFrame
+    if all_edges_data:
+        combined_edges_df = pd.concat(all_edges_data, ignore_index=True)
+    else:
+        combined_edges_df = pd.DataFrame()
+    
+    if verbose:
+        print(f"\n  H5 columns: {sorted(h5_column_names)}")
+        print(f"  CSV columns: {edge_types_df.columns.tolist()}")
+        print(f"  Combined edges before merge: {combined_edges_df.shape}")
+    
+    # Merge H5 data with CSV edge type metadata
+    if not combined_edges_df.empty and not edge_types_df.empty:
+        # Determine merge columns (typically just edge_type_id)
+        merge_cols = []
+        if 'edge_type_id' in combined_edges_df.columns and 'edge_type_id' in edge_types_df.columns:
+            merge_cols.append('edge_type_id')
+        
+        if 'population' in edge_types_df.columns and 'population' in combined_edges_df.columns:
+            merge_cols.append('population')
+        
+        if merge_cols:
+            if verbose:
+                # Debug merge compatibility
+                h5_edge_types = set(combined_edges_df['edge_type_id'].unique())
+                csv_edge_types = set(edge_types_df['edge_type_id'].unique())
+                overlap = h5_edge_types.intersection(csv_edge_types)
+                
+                print(f"\n  Merging on columns: {merge_cols}")
+                print(f"  Edge types in H5: {sorted(h5_edge_types)}")
+                print(f"  Edge types in CSV: {sorted(csv_edge_types)}")
+                print(f"  Overlap: {sorted(overlap)}")
+            
+            # Perform left join to preserve all H5 edges
+            final_df = combined_edges_df.merge(
+                edge_types_df, 
+                on=merge_cols, 
+                how='left', 
+                suffixes=('', '_csv')
             )
-
-            # extra properties of individual edges (see SONATA Data format)
-            if conn_grp.get("0"):
-                edge_group_id = conn_grp["edge_group_id"][()]
-                edge_group_index = conn_grp["edge_group_index"][()]
-                n_group = edge_group_id.max() + 1
-                prop_dtype = {}
-                for group_id in range(n_group):
-                    group = conn_grp[str(group_id)]
-                    idx = edge_group_id == group_id
-                    for prop in group:
-                        # create new column with NaN if property does not exist
-                        if prop not in edges_df:
-                            edges_df[prop] = np.nan
-                        edges_df.loc[idx, prop] = tuple(group[prop][edge_group_index[idx]])
-                        prop_dtype[prop] = group[prop].dtype
-                # convert to original data type if possible
-                for prop, dtype in prop_dtype.items():
-                    edges_df[prop] = edges_df[prop].astype(dtype, errors="ignore")
-
-        return population, edges_df
-
-    # for edges_dict, conn_models_file, conns_file in zip(connections, edge_types_fpaths, edges_h5_fpaths):
-    #    connections_dict[connection] = get_connection_table(conn_models_file,conns_file)
-    try:
-        for nodes in edge_paths:
-            edges_file = nodes["edges_file"]
-            edge_types_file = nodes["edge_types_file"]
-            region_name, region = get_edge_table(edges_file, edge_types_file)
-            edges_dict[region_name] = region
-    except Exception as e:
-        print(repr(e))
-        print("Hint: Are you loading the correct simulation config file?")
-        print("Command Line: bmtool plot --config yourconfig.json <rest of command>")
-        print("Python: bmplot.connection_matrix(config='yourconfig.json')")
-
-    return edges_dict
+            
+            if verbose:
+                print(f"  After merge: {final_df.shape}")
+            
+            # Apply H5 precedence rule: H5 attributes override CSV attributes
+            for col in edge_types_df.columns:
+                if col in merge_cols:
+                    continue  # Skip merge columns
+                    
+                csv_col_name = f"{col}_csv" if f"{col}_csv" in final_df.columns else col
+                
+                # If column exists in H5, handle row-by-row precedence
+                if col in h5_column_names:
+                    if csv_col_name in final_df.columns and csv_col_name != col:
+                        # Row-by-row logic: use CSV value only where H5 is NaN
+                        mask_h5_nan = final_df[col].isna()
+                        final_df.loc[mask_h5_nan, col] = final_df.loc[mask_h5_nan, csv_col_name]
+                        
+                        if verbose and mask_h5_nan.any():
+                            n_filled = mask_h5_nan.sum()
+                            print(f"    Column '{col}': filled {n_filled} NaN values from CSV")
+                        
+                        # Remove CSV version after filling NaN values
+                        final_df = final_df.drop(columns=[csv_col_name])
+                    elif verbose:
+                        print(f"    Column '{col}' exists in H5 only")
+                # If column only in CSV, rename if needed
+                elif csv_col_name in final_df.columns and csv_col_name != col:
+                    final_df = final_df.rename(columns={csv_col_name: col})
+                    if verbose:
+                        print(f"    Added column '{col}' from CSV")
+        else:
+            if verbose:
+                print("  No common merge columns found. Using H5 data only.")
+            final_df = combined_edges_df
+    else:
+        final_df = combined_edges_df
+    
+    if verbose:
+        print(f"\nFinal DataFrame: {final_df.shape}")
+        print(f"Final columns: {final_df.columns.tolist()}")
+    
+    # Set edge_type_id as the index to match old function
+    if 'edge_type_id' in final_df.columns:
+        final_df = final_df.set_index('edge_type_id')
+        if verbose:
+            print(f"Set edge_type_id as index. Final shape: {final_df.shape}")
+    
+    return final_df
 
 
 def load_mechanisms_from_config(config=None):
@@ -604,7 +878,6 @@ def relation_matrix(
             if relation_func:
                 source_nodes = nodes[source].add_prefix("source_")
                 target_nodes = nodes[target].add_prefix("target_")
-
                 c_edges = pd.merge(
                     left=edges[e_name],
                     right=source_nodes,
@@ -856,7 +1129,8 @@ def percent_connections(
         cons = edges[(edges[source_id_type] == source_id) & (edges[target_id_type] == target_id)]
         if not include_gap:
             try:
-                cons = cons[~cons["is_gap_junction"]]
+                gaps = cons["is_gap_junction"]==True
+                cons = cons[~gaps]
             except:
                 raise Exception("no gap junctions found to drop from connections")
 
@@ -1003,7 +1277,7 @@ def gap_junction_connections(
         # print(cons)
 
         try:
-            cons = cons[cons["is_gap_junction"]]
+            cons = cons[cons["is_gap_junction"]==True]
         except:
             raise Exception("no gap junctions found to drop from connections")
         mean = cons["target_node_id"].value_counts().mean()

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

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

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

@@ -13,7 +13,7 @@ bmtool/analysis/lfp.py,sha256=S2JvxkjcK3-EH93wCrhqNSFY6cX7fOq74pz64ibHKrc,26556
 bmtool/analysis/netcon_reports.py,sha256=VnPZNKPaQA7oh1q9cIatsqQudm4cOtzNtbGPXoiDCD0,2909
 bmtool/analysis/spikes.py,sha256=3n-xmyEZ7w6CKEND7-aKOAvdDg0lwDuPI5sMdOuPwa0,24637
 bmtool/bmplot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bmtool/bmplot/connections.py,sha256=KSORZ43v1B5xfiBN6AnAD7tJySVTkLIY3j_zb2r-YPA,55696
+bmtool/bmplot/connections.py,sha256=Tdi-17poEuBBgXcKQ--pcDTDwl029nXg9EConRgZo-k,58928
 bmtool/bmplot/entrainment.py,sha256=BrBMerqyiG2YWAO_OEFv7OJf3yeFz3l9jUt4NamluLc,32837
 bmtool/bmplot/lfp.py,sha256=SNpbWGOUnYEgnkeBw5S--aPN5mIGD22Gw2Pwus0_lvY,2034
 bmtool/bmplot/netcon_reports.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -23,12 +23,12 @@ bmtool/debug/commands.py,sha256=VV00f6q5gzZI503vUPeG40ABLLen0bw_k4-EX-H5WZE,580
 bmtool/debug/debug.py,sha256=9yUFvA4_Bl-x9s29quIEG3pY-S8hNJF3RKBfRBHCl28,208
 bmtool/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/util/commands.py,sha256=Nn-R-4e9g8ZhSPZvTkr38xeKRPfEMANB9Lugppj82UI,68564
-bmtool/util/util.py,sha256=S8sAXwDiISGAqnSXRIgFqxqCRzL5YcxAqP1UGxGA5Z4,62906
+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.2.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.7.2.dist-info/METADATA,sha256=JacxbP2RvvbSuuveedTUJjl8KeqOCKf4FlW-UrRmfCk,3575
-bmtool-0.7.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bmtool-0.7.2.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.7.2.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.7.2.dist-info/RECORD,,
+bmtool-0.7.3.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
+bmtool-0.7.3.dist-info/METADATA,sha256=uzyKoEDxd3kJQc89-pzf6wSxR7v3BhBHYEvyqCh5aHM,3575
+bmtool-0.7.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bmtool-0.7.3.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
+bmtool-0.7.3.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
+bmtool-0.7.3.dist-info/RECORD,,