risk-network 0.0.9b11__py3-none-any.whl → 0.0.9b13__py3-none-any.whl

risk/__init__.py

@@ -7,4 +7,4 @@ RISK: RISK Infers Spatial Kinships
 
 from risk.risk import RISK
 
-__version__ = "0.0.9-beta.11"
+__version__ = "0.0.9-beta.13"

risk/neighborhoods/community.py

@@ -12,23 +12,32 @@ from leidenalg import find_partition, RBConfigurationVertexPartition
 from networkx.algorithms.community import greedy_modularity_communities
 
 
-def calculate_greedy_modularity_neighborhoods(network: nx.Graph) -> np.ndarray:
+def calculate_greedy_modularity_neighborhoods(
+    network: nx.Graph, edge_rank_percentile: float = 1.0
+) -> np.ndarray:
     """Calculate neighborhoods using the Greedy Modularity method.
 
     Args:
-        network (nx.Graph): The network graph to analyze for community structure.
+        network (nx.Graph): The network graph.
+        edge_rank_percentile (float, optional): Shortest edge rank percentile threshold for creating
+            subgraphs before clustering.
 
     Returns:
         np.ndarray: A binary neighborhood matrix where nodes in the same community have 1, and others have 0.
     """
+    # Create a subgraph with the shortest edges based on the rank percentile
+    subnetwork = _create_percentile_limited_subgraph(
+        network, edge_rank_percentile=edge_rank_percentile
+    )
     # Detect communities using the Greedy Modularity method
-    communities = greedy_modularity_communities(network)
+    communities = greedy_modularity_communities(subnetwork)
     # Get the list of nodes in the original NetworkX graph
     nodes = list(network.nodes())
     node_index_map = {node: idx for idx, node in enumerate(nodes)}
     # Create a binary neighborhood matrix
-    n_nodes = len(nodes)
-    neighborhoods = np.zeros((n_nodes, n_nodes), dtype=int)
+    num_nodes = len(nodes)
+    # Initialize neighborhoods with zeros and set self-self entries to 1
+    neighborhoods = np.eye(num_nodes, dtype=int)
     # Fill in the neighborhood matrix for nodes in the same community
     for community in communities:
         # Iterate through all pairs of nodes in the same community
@@ -42,23 +51,34 @@ def calculate_greedy_modularity_neighborhoods(network: nx.Graph) -> np.ndarray:
     return neighborhoods
 
 
-def calculate_label_propagation_neighborhoods(network: nx.Graph) -> np.ndarray:
+def calculate_label_propagation_neighborhoods(
+    network: nx.Graph, edge_rank_percentile: float = 1.0
+) -> np.ndarray:
     """Apply Label Propagation to the network to detect communities.
 
     Args:
         network (nx.Graph): The network graph.
+        edge_rank_percentile (float, optional): Shortest edge rank percentile threshold for creating
+            subgraphs before clustering.
 
     Returns:
         np.ndarray: A binary neighborhood matrix on Label Propagation.
     """
+    # Create a subgraph with the shortest edges based on the rank percentile
+    subnetwork = _create_percentile_limited_subgraph(
+        network, edge_rank_percentile=edge_rank_percentile
+    )
     # Apply Label Propagation for community detection
-    communities = nx.algorithms.community.label_propagation.label_propagation_communities(network)
+    communities = nx.algorithms.community.label_propagation.label_propagation_communities(
+        subnetwork
+    )
     # Get the list of nodes in the network
     nodes = list(network.nodes())
     node_index_map = {node: idx for idx, node in enumerate(nodes)}
     # Create a binary neighborhood matrix
     num_nodes = len(nodes)
-    neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
+    # Initialize neighborhoods with zeros and set self-self entries to 1
+    neighborhoods = np.eye(num_nodes, dtype=int)
     # Assign neighborhoods based on community labels using the mapped indices
     for community in communities:
         for node_i in community:
@@ -71,20 +91,29 @@ def calculate_label_propagation_neighborhoods(network: nx.Graph) -> np.ndarray:
 
 
 def calculate_leiden_neighborhoods(
-    network: nx.Graph, resolution: float = 1.0, random_seed: int = 888
+    network: nx.Graph,
+    resolution: float = 1.0,
+    edge_rank_percentile: float = 1.0,
+    random_seed: int = 888,
 ) -> np.ndarray:
     """Calculate neighborhoods using the Leiden method.
 
     Args:
         network (nx.Graph): The network graph.
         resolution (float, optional): Resolution parameter for the Leiden method. Defaults to 1.0.
+        edge_rank_percentile (float, optional): Shortest edge rank percentile threshold for creating
+            subgraphs before clustering.
         random_seed (int, optional): Random seed for reproducibility. Defaults to 888.
 
     Returns:
         np.ndarray: A binary neighborhood matrix where nodes in the same community have 1, and others have 0.
     """
+    # Create a subgraph with the shortest edges based on the rank percentile
+    subnetwork = _create_percentile_limited_subgraph(
+        network, edge_rank_percentile=edge_rank_percentile
+    )
     # Convert NetworkX graph to iGraph
-    igraph_network = ig.Graph.from_networkx(network)
+    igraph_network = ig.Graph.from_networkx(subnetwork)
     # Apply Leiden algorithm using RBConfigurationVertexPartition, which supports resolution
     partition = find_partition(
         igraph_network,
@@ -97,7 +126,8 @@ def calculate_leiden_neighborhoods(
     node_index_map = {node: idx for idx, node in enumerate(nodes)}
     # Create a binary neighborhood matrix
     num_nodes = len(nodes)
-    neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
+    # Initialize neighborhoods with zeros and set self-self entries to 1
+    neighborhoods = np.eye(num_nodes, dtype=int)
     # Assign neighborhoods based on community partitions using the mapped indices
     for community in partition:
         for node_i in community:
@@ -110,28 +140,38 @@ def calculate_leiden_neighborhoods(
 
 
 def calculate_louvain_neighborhoods(
-    network: nx.Graph, resolution: float, random_seed: int = 888
+    network: nx.Graph,
+    resolution: float = 0.1,
+    edge_rank_percentile: float = 1.0,
+    random_seed: int = 888,
 ) -> np.ndarray:
     """Calculate neighborhoods using the Louvain method.
 
     Args:
         network (nx.Graph): The network graph.
-        resolution (float): Resolution parameter for the Louvain method.
+        resolution (float, optional): Resolution parameter for the Louvain method. Defaults to 0.1.
+        edge_rank_percentile (float, optional): Shortest edge rank percentile threshold for creating
+            subgraphs before clustering.
         random_seed (int, optional): Random seed for reproducibility. Defaults to 888.
 
     Returns:
         np.ndarray: A binary neighborhood matrix on the Louvain method.
     """
+    # Create a subgraph with the shortest edges based on the rank percentile
+    subnetwork = _create_percentile_limited_subgraph(
+        network, edge_rank_percentile=edge_rank_percentile
+    )
     # Apply Louvain method to partition the network
     partition = community_louvain.best_partition(
-        network, resolution=resolution, random_state=random_seed
+        subnetwork, resolution=resolution, random_state=random_seed
     )
     # Get the list of nodes in the network and create a mapping to indices
     nodes = list(network.nodes())
     node_index_map = {node: idx for idx, node in enumerate(nodes)}
     # Create a binary neighborhood matrix
     num_nodes = len(nodes)
-    neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
+    # Initialize neighborhoods with zeros and set self-self entries to 1
+    neighborhoods = np.eye(num_nodes, dtype=int)
     # Group nodes by community
     community_groups = {}
     for node, community in partition.items():
@@ -148,58 +188,76 @@ def calculate_louvain_neighborhoods(
     return neighborhoods
 
 
-def calculate_markov_clustering_neighborhoods(network: nx.Graph) -> np.ndarray:
-    """Apply Markov Clustering (MCL) to the network.
+def calculate_markov_clustering_neighborhoods(
+    network: nx.Graph, edge_rank_percentile: float = 1.0
+) -> np.ndarray:
+    """Apply Markov Clustering (MCL) to the network and return a binary neighborhood matrix.
 
     Args:
         network (nx.Graph): The network graph.
+        edge_rank_percentile (float, optional): Shortest edge rank percentile threshold for creating
+            subgraphs before clustering.
 
     Returns:
         np.ndarray: A binary neighborhood matrix on Markov Clustering.
     """
-    # Step 1: Convert the graph to an adjacency matrix
-    nodes = list(network.nodes())
-    node_index_map = {node: idx for idx, node in enumerate(nodes)}
-    # Step 2: Create a reverse mapping from index to node
-    index_node_map = {idx: node for node, idx in node_index_map.items()}
-    adjacency_matrix = nx.to_numpy_array(network, nodelist=nodes)
-    # Step 3: Run Markov Clustering (MCL) on the adjacency matrix
+    # Create a subgraph with the shortest edges based on the rank percentile
+    subnetwork = _create_percentile_limited_subgraph(
+        network, edge_rank_percentile=edge_rank_percentile
+    )
+    # Step 1: Convert the subnetwork to an adjacency matrix
+    subnetwork_nodes = list(subnetwork.nodes())
+    adjacency_matrix = nx.to_numpy_array(subnetwork, nodelist=subnetwork_nodes)
+    # Step 2: Run Markov Clustering (MCL) on the subnetwork's adjacency matrix
     result = mc.run_mcl(adjacency_matrix)
-    # Step 4: Get clusters (communities) from MCL result
     clusters = mc.get_clusters(result)
-    # Step 5: Create a binary neighborhood matrix
+    # Step 3: Prepare the original network nodes and indices
+    nodes = list(network.nodes())
+    node_index_map = {node: idx for idx, node in enumerate(nodes)}
     num_nodes = len(nodes)
-    neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-    # Step 6: Assign neighborhoods based on MCL clusters using the original node labels
+    # Step 4: Initialize the neighborhood matrix for the original network
+    neighborhoods = np.eye(num_nodes, dtype=int)
+    # Step 5: Fill the neighborhoods matrix using the clusters from the subnetwork
     for cluster in clusters:
         for node_i in cluster:
             for node_j in cluster:
-                # Map the matrix indices back to the original node labels
-                original_node_i = index_node_map[node_i]
-                original_node_j = index_node_map[node_j]
-                idx_i = node_index_map[original_node_i]
-                idx_j = node_index_map[original_node_j]
-                neighborhoods[idx_i, idx_j] = 1
+                # Map the indices back to the original network's node indices
+                original_node_i = subnetwork_nodes[node_i]
+                original_node_j = subnetwork_nodes[node_j]
+
+                if original_node_i in node_index_map and original_node_j in node_index_map:
+                    idx_i = node_index_map[original_node_i]
+                    idx_j = node_index_map[original_node_j]
+                    neighborhoods[idx_i, idx_j] = 1
 
     return neighborhoods
 
 
-def calculate_spinglass_neighborhoods(network: nx.Graph) -> np.ndarray:
+def calculate_spinglass_neighborhoods(
+    network: nx.Graph, edge_rank_percentile: float = 1.0
+) -> np.ndarray:
     """Apply Spinglass Community Detection to the network, handling disconnected components.
 
     Args:
-        network (nx.Graph): The input network graph with 'x' and 'y' attributes for node positions.
+        network (nx.Graph): The network graph.
+        edge_rank_percentile (float, optional): Shortest edge rank percentile threshold for creating
+            subgraphs before clustering.
 
     Returns:
         np.ndarray: A binary neighborhood matrix based on Spinglass communities.
     """
+    # Create a subgraph with the shortest edges based on the rank percentile
+    subnetwork = _create_percentile_limited_subgraph(
+        network, edge_rank_percentile=edge_rank_percentile
+    )
     # Step 1: Find connected components in the graph
-    components = list(nx.connected_components(network))
+    components = list(nx.connected_components(subnetwork))
     # Prepare to store community results
     nodes = list(network.nodes())
     node_index_map = {node: idx for idx, node in enumerate(nodes)}
     num_nodes = len(nodes)
-    neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
+    # Initialize neighborhoods with zeros and set self-self entries to 1
+    neighborhoods = np.eye(num_nodes, dtype=int)
     # Step 2: Run Spinglass on each connected component
     for component in components:
         # Extract the subgraph corresponding to the current component
@@ -229,17 +287,25 @@ def calculate_spinglass_neighborhoods(network: nx.Graph) -> np.ndarray:
     return neighborhoods
 
 
-def calculate_walktrap_neighborhoods(network: nx.Graph) -> np.ndarray:
+def calculate_walktrap_neighborhoods(
+    network: nx.Graph, edge_rank_percentile: float = 1.0
+) -> np.ndarray:
     """Apply Walktrap Community Detection to the network.
 
     Args:
         network (nx.Graph): The network graph.
+        edge_rank_percentile (float, optional): Shortest edge rank percentile threshold for creating
+            subgraphs before clustering.
 
     Returns:
         np.ndarray: A binary neighborhood matrix on Walktrap communities.
     """
+    # Create a subgraph with the shortest edges based on the rank percentile
+    subnetwork = _create_percentile_limited_subgraph(
+        network, edge_rank_percentile=edge_rank_percentile
+    )
     # Convert NetworkX graph to iGraph
-    igraph_network = ig.Graph.from_networkx(network)
+    igraph_network = ig.Graph.from_networkx(subnetwork)
     # Apply Walktrap community detection
     communities = igraph_network.community_walktrap().as_clustering()
     # Get the list of nodes in the original NetworkX graph
@@ -247,7 +313,8 @@ def calculate_walktrap_neighborhoods(network: nx.Graph) -> np.ndarray:
     node_index_map = {node: idx for idx, node in enumerate(nodes)}
     # Create a binary neighborhood matrix
     num_nodes = len(nodes)
-    neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
+    # Initialize neighborhoods with zeros and set self-self entries to 1
+    neighborhoods = np.eye(num_nodes, dtype=int)
     # Assign neighborhoods based on community labels
     for community in communities:
         for node_i in community:
@@ -257,3 +324,44 @@ def calculate_walktrap_neighborhoods(network: nx.Graph) -> np.ndarray:
                 neighborhoods[idx_i, idx_j] = 1
 
     return neighborhoods
+
+
+def _create_percentile_limited_subgraph(G: nx.Graph, edge_rank_percentile: float) -> nx.Graph:
+    """Create a subgraph containing the shortest edges based on the specified rank percentile
+    of all edge lengths in the input graph.
+
+    Args:
+        G (nx.Graph): The input graph with 'length' attributes on edges.
+        edge_rank_percentile (float): The rank percentile (between 0 and 1) to filter edges.
+
+    Returns:
+        nx.Graph: A subgraph with nodes and edges where the edges are within the shortest
+        specified rank percentile.
+    """
+    # Step 1: Extract edges with their lengths
+    edges_with_length = [(u, v, d) for u, v, d in G.edges(data=True) if "length" in d]
+    if not edges_with_length:
+        raise ValueError(
+            "No edge lengths found in the graph. Ensure edges have 'length' attributes."
+        )
+
+    # Step 2: Sort edges by length in ascending order
+    edges_with_length.sort(key=lambda x: x[2]["length"])
+    # Step 3: Calculate the cutoff index for the given rank percentile
+    cutoff_index = int(edge_rank_percentile * len(edges_with_length))
+    if cutoff_index == 0:
+        raise ValueError("The rank percentile is too low, resulting in no edges being included.")
+
+    # Step 4: Create the subgraph by selecting only the shortest edges within the rank percentile
+    subgraph = nx.Graph()
+    subgraph.add_nodes_from(G.nodes(data=True))  # Retain all nodes from the original graph
+    subgraph.add_edges_from(edges_with_length[:cutoff_index])
+    # Step 5: Remove nodes with no edges
+    subgraph.remove_nodes_from(list(nx.isolates(subgraph)))
+    # Step 6: Check if the resulting subgraph has no edges and issue a warning
+    if subgraph.number_of_edges() == 0:
+        raise Warning(
+            "The resulting subgraph has no edges. Consider adjusting the rank percentile."
+        )
+
+    return subgraph

risk/neighborhoods/neighborhoods.py

@@ -52,12 +52,13 @@ def get_network_neighborhoods(
     random.seed(random_seed)
     np.random.seed(random_seed)
 
-    # Ensure distance_metric and edge_rank_percentile are lists
+    # Ensure distance_metric is a list/tuple for multi-algorithm handling
     if isinstance(distance_metric, (str, np.ndarray)):
         distance_metric = [distance_metric]
+    # Ensure edge_rank_percentile is a list/tuple for multi-threshold handling
     if isinstance(edge_rank_percentile, (float, int)):
         edge_rank_percentile = [edge_rank_percentile] * len(distance_metric)
-
+    # Check that the number of distance metrics matches the number of edge length thresholds
     if len(distance_metric) != len(edge_rank_percentile):
         raise ValueError(
             "The number of distance metrics must match the number of edge length thresholds."
@@ -67,111 +68,61 @@ def get_network_neighborhoods(
     num_nodes = network.number_of_nodes()
     combined_neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
 
-    # Loop through each distance metric and corresponding edge length threshold
-    for metric, threshold in zip(distance_metric, edge_rank_percentile):
-        # Create a subgraph based on the edge length threshold
-        subgraph = _create_percentile_limited_subgraph(network, edge_rank_percentile=threshold)
-        subgraph_nodes = list(subgraph.nodes)
-        # Calculate neighborhoods based on the specified metric
+    # Loop through each distance metric and corresponding edge rank percentile
+    for metric, percentile in zip(distance_metric, edge_rank_percentile):
+        # Call the appropriate neighborhood function based on the metric
         if metric == "greedy_modularity":
-            neighborhoods = calculate_greedy_modularity_neighborhoods(subgraph)
+            neighborhoods = calculate_greedy_modularity_neighborhoods(
+                network, edge_rank_percentile=percentile
+            )
         elif metric == "label_propagation":
-            neighborhoods = calculate_label_propagation_neighborhoods(subgraph)
+            neighborhoods = calculate_label_propagation_neighborhoods(
+                network, edge_rank_percentile=percentile
+            )
         elif metric == "leiden":
             neighborhoods = calculate_leiden_neighborhoods(
-                subgraph, leiden_resolution, random_seed=random_seed
+                network,
+                resolution=leiden_resolution,
+                edge_rank_percentile=percentile,
+                random_seed=random_seed,
             )
         elif metric == "louvain":
             neighborhoods = calculate_louvain_neighborhoods(
-                subgraph, louvain_resolution, random_seed=random_seed
+                network,
+                resolution=louvain_resolution,
+                edge_rank_percentile=percentile,
+                random_seed=random_seed,
             )
         elif metric == "markov_clustering":
-            neighborhoods = calculate_markov_clustering_neighborhoods(subgraph)
+            neighborhoods = calculate_markov_clustering_neighborhoods(
+                network, edge_rank_percentile=percentile
+            )
         elif metric == "spinglass":
-            neighborhoods = calculate_spinglass_neighborhoods(subgraph)
+            neighborhoods = calculate_spinglass_neighborhoods(
+                network, edge_rank_percentile=percentile
+            )
         elif metric == "walktrap":
-            neighborhoods = calculate_walktrap_neighborhoods(subgraph)
+            neighborhoods = calculate_walktrap_neighborhoods(
+                network, edge_rank_percentile=percentile
+            )
         else:
             raise ValueError(
-                "Invalid distance metric specified. Please choose from 'greedy_modularity', 'label_propagation',"
+                "Incorrect distance metric specified. Please choose from 'greedy_modularity', 'label_propagation',"
                 "'leiden', 'louvain', 'markov_clustering', 'spinglass', 'walktrap'."
             )
 
-        # Expand the neighborhood matrix to match the original network's size
-        expanded_neighborhoods = expand_neighborhood_matrix(
-            neighborhoods, subgraph_nodes, num_nodes
-        )
-        # Sum the expanded neighborhood matrices
-        combined_neighborhoods += expanded_neighborhoods
+        # Sum the neighborhood matrices
+        combined_neighborhoods += neighborhoods
 
-    # Convert combined_neighborhoods to binary: values > 0 are set to 1
-    combined_neighborhoods = (combined_neighborhoods > 0).astype(int)
+    # Ensure that the maximum value in each row is set to 1
+    # This ensures that for each row, only the strongest relationship (the maximum value) is retained,
+    # while all other values are reset to 0. This transformation simplifies the neighborhood matrix by
+    # focusing on the most significant connection per row (or nodes).
+    combined_neighborhoods = _set_max_row_value_to_one(combined_neighborhoods)
 
     return combined_neighborhoods
 
 
-def expand_neighborhood_matrix(
-    subgraph_matrix: np.ndarray, subgraph_nodes: list, original_size: int
-) -> np.ndarray:
-    """Expand a subgraph neighborhood matrix back to the size of the original graph.
-
-    Args:
-        subgraph_matrix (np.ndarray): The neighborhood matrix for the subgraph.
-        subgraph_nodes (list): List of nodes in the subgraph, corresponding to rows/columns in subgraph_matrix.
-        original_size (int): The number of nodes in the original graph.
-
-    Returns:
-        np.ndarray: The expanded matrix with the original size, with subgraph values mapped correctly.
-    """
-    expanded_matrix = np.zeros((original_size, original_size), dtype=int)
-    for i, node_i in enumerate(subgraph_nodes):
-        for j, node_j in enumerate(subgraph_nodes):
-            expanded_matrix[node_i, node_j] = subgraph_matrix[i, j]
-    return expanded_matrix
-
-
-def _create_percentile_limited_subgraph(G: nx.Graph, edge_rank_percentile: float) -> nx.Graph:
-    """Create a subgraph containing all nodes and edges where the edge length is within the
-    specified rank percentile of all edges in the input graph. Isolated nodes are removed.
-
-    Args:
-        G (nx.Graph): The input graph with 'length' attributes on edges.
-        edge_rank_percentile (float): The rank percentile (between 0 and 1) to filter edges.
-
-    Returns:
-        nx.Graph: A subgraph with nodes and edges where the edge length is within the
-        specified percentile, with isolated nodes removed, retaining all original attributes.
-    """
-    # Extract edges with their lengths
-    edges_with_length = [(u, v, d) for u, v, d in G.edges(data=True) if "length" in d]
-    if not edges_with_length:
-        raise ValueError("No edge lengths found. Ensure edges have 'length' attributes.")
-
-    # Sort edges by length in ascending order
-    edges_with_length.sort(key=lambda x: x[2]["length"])
-    # Calculate the cutoff based on the specified rank percentile
-    cutoff_index = int(edge_rank_percentile * len(edges_with_length))
-    if cutoff_index == 0:
-        raise ValueError("The rank percentile is too low, resulting in no edges being included.")
-
-    # Keep only the edges within the specified percentile
-    selected_edges = edges_with_length[:cutoff_index]
-    # Create a new subgraph with the selected edges, retaining all attributes
-    subgraph = nx.Graph()
-    subgraph.add_edges_from((u, v, d) for u, v, d in selected_edges)
-    # Copy over all node attributes from the original graph
-    subgraph.add_nodes_from((node, G.nodes[node]) for node in subgraph.nodes())
-
-    # Remove isolated nodes (if any)
-    isolated_nodes = [node for node, degree in subgraph.degree() if degree == 0]
-    subgraph.remove_nodes_from(isolated_nodes)
-    # Check if the resulting subgraph has no edges
-    if subgraph.number_of_edges() == 0:
-        raise ValueError("The resulting subgraph has no edges. Adjust the rank percentile.")
-
-    return subgraph
-
-
 def _set_max_row_value_to_one(matrix: np.ndarray) -> np.ndarray:
     """For each row in the input matrix, set the maximum value(s) to 1 and all other values to 0. This is particularly
     useful for neighborhood matrices that have undergone multiple neighborhood detection algorithms, where the

{risk_network-0.0.9b11.dist-info → risk_network-0.0.9b13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.9b11
+Version: 0.0.9b13
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>

{risk_network-0.0.9b11.dist-info → risk_network-0.0.9b13.dist-info}/RECORD

@@ -1,4 +1,4 @@
-risk/__init__.py,sha256=lx2px2aUNVzyhWttIeSRddS0TyVt5tkNaoDp26k1OmE,113
+risk/__init__.py,sha256=bXkN8xIF7g0uIiSoCAXatSRkI_KRTbjWye4l_trCCfk,113
 risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
 risk/risk.py,sha256=MXu8T93NUgMDl3NaZDbm0j9c4KWwzx-kmp9Rd1ax0N4,23534
 risk/annotations/__init__.py,sha256=kXgadEXaCh0z8OyhOhTj7c3qXGmWgOhaSZ4gSzSb59U,147
@@ -8,9 +8,9 @@ risk/log/__init__.py,sha256=gy7C5L6D222AYUChq5lkc0LsCJ_QMQPaFiBJKbecdac,201
 risk/log/console.py,sha256=C52s3FgQ2e9kQWcXL8m7rs_pnKXt5Yy8PBHmQkOTiNo,4537
 risk/log/parameters.py,sha256=o4StqYCa0kt7_Ht4mKa1DwwvhGUwkC_dGBaiUIc0GB0,5683
 risk/neighborhoods/__init__.py,sha256=C-SD0G-9skSLjLFdAB6v6lAjO8la2v6Fqy63h2MY28k,186
-risk/neighborhoods/community.py,sha256=z8oZGBUZLriYBbT4-0uKDn8iM8SmN5dubrHb7zxcn4w,10431
+risk/neighborhoods/community.py,sha256=hsWr6sNW3lCZn9L2f8oYBVmIANnJpoAL9194fg6K1eQ,15408
 risk/neighborhoods/domains.py,sha256=t91xSpx9Ty9hSlhRq2_XwyPpBP7sjKhovcPPvkwWtf0,11398
-risk/neighborhoods/neighborhoods.py,sha256=D-t1v6EcmKn6B8uZK5X5tU9uOV0OfkKzvETGfZWRnic,23561
+risk/neighborhoods/neighborhoods.py,sha256=XB2Gd0xghKKBNkwp1H-1138NegTlAiyOqAkv_vaLEZM,21150
 risk/network/__init__.py,sha256=iEPeJdZfqp0toxtbElryB8jbz9_t_k4QQ3iDvKE8C_0,126
 risk/network/geometry.py,sha256=gFtYUj9j9aul4paKq_qSGJn39Nazxu_MXv8m-tYYtrk,6840
 risk/network/io.py,sha256=AWSbZGLZHtl72KSlafQlcYoG00YLSznG7UYDi_wDT7M,22958
@@ -32,8 +32,8 @@ risk/stats/stats.py,sha256=z8NrhiVj4BzJ250bVLfytpmfC7RzYu7mBuIZD_l0aCA,7222
 risk/stats/permutation/__init__.py,sha256=neJp7FENC-zg_CGOXqv-iIvz1r5XUKI9Ruxhmq7kDOI,105
 risk/stats/permutation/permutation.py,sha256=meBNSrbRa9P8WJ54n485l0H7VQJlMSfHqdN4aCKYCtQ,10105
 risk/stats/permutation/test_functions.py,sha256=lftOude6hee0pyR80HlBD32522JkDoN5hrKQ9VEbuoY,2345
-risk_network-0.0.9b11.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.9b11.dist-info/METADATA,sha256=38pUWpqTrjTbc5LQ1_JnRqOpXwgSS-J1wVHHBMTTQ6M,47552
-risk_network-0.0.9b11.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-risk_network-0.0.9b11.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.9b11.dist-info/RECORD,,
+risk_network-0.0.9b13.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.9b13.dist-info/METADATA,sha256=tbqUuKfdv5QjAprQruLMmTk5wzGWrwVqg528BeWcynQ,47552
+risk_network-0.0.9b13.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+risk_network-0.0.9b13.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.9b13.dist-info/RECORD,,