risk-network 0.0.6b10__tar.gz → 0.0.7__tar.gz

{risk_network-0.0.6b10 → risk_network-0.0.7}/PKG-INFO

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

{risk_network-0.0.6b10 → risk_network-0.0.7}/risk/__init__.py

@@ -7,4 +7,4 @@ RISK: RISK Infers Spatial Kinships
 
 from risk.risk import RISK
 
-__version__ = "0.0.6-beta.10"
+__version__ = "0.0.7"

{risk_network-0.0.6b10 → risk_network-0.0.7}/risk/annotations/annotations.py

@@ -4,7 +4,7 @@ risk/annotations/annotations
 """
 
 from collections import Counter
-from itertools import compress, permutations
+from itertools import compress
 from typing import Any, Dict, List, Set
 
 import networkx as nx
@@ -39,7 +39,7 @@ def load_annotations(network: nx.Graph, annotations_input: Dict[str, Any]) -> Di
         annotations_input (dict): A dictionary with annotations.
 
     Returns:
-        dict: A dictionary containing ordered nodes, ordered annotations, and the annotations matrix.
+        dict: A dictionary containing ordered nodes, ordered annotations, and the binary annotations matrix.
     """
     # Flatten the dictionary to a list of tuples for easier DataFrame creation
     flattened_annotations = [
@@ -66,7 +66,8 @@ def load_annotations(network: nx.Graph, annotations_input: Dict[str, Any]) -> Di
     # Extract ordered nodes and annotations
     ordered_nodes = tuple(annotations_pivot.index)
     ordered_annotations = tuple(annotations_pivot.columns)
-    annotations_pivot_numpy = annotations_pivot.fillna(0).to_numpy()
+    # Convert the annotations_pivot matrix to a numpy array and ensure it's binary
+    annotations_pivot_numpy = (annotations_pivot.fillna(0).to_numpy() > 0).astype(int)
 
     return {
         "ordered_nodes": ordered_nodes,
@@ -132,34 +133,39 @@ def define_top_annotations(
             nx.connected_components(enriched_network), key=len, reverse=True
         )
         size_connected_components = np.array([len(c) for c in connected_components])
+
+        # Filter the size of connected components by min_cluster_size and max_cluster_size
+        filtered_size_connected_components = size_connected_components[
+            (size_connected_components >= min_cluster_size)
+            & (size_connected_components <= max_cluster_size)
+        ]
+        # Calculate the number of connected components and large connected components
         num_connected_components = len(connected_components)
-        num_large_connected_components = np.sum(
-            np.logical_and(
-                size_connected_components >= min_cluster_size,
-                size_connected_components <= max_cluster_size,
-            )
-        )
+        num_large_connected_components = len(filtered_size_connected_components)
+
+        # Assign the number of connected components
         annotations_enrichment_matrix.loc[attribute, "num connected components"] = (
             num_connected_components
         )
-        annotations_enrichment_matrix.at[attribute, "size connected components"] = (
-            size_connected_components
-        )
+        # Filter out attributes with more than one connected component
+        annotations_enrichment_matrix.loc[
+            annotations_enrichment_matrix["num connected components"] > 1, "top attributes"
+        ] = False
+        # Assign the number of large connected components
         annotations_enrichment_matrix.loc[attribute, "num large connected components"] = (
             num_large_connected_components
         )
-
-    # Filter out attributes with more than one connected component
-    annotations_enrichment_matrix.loc[
-        annotations_enrichment_matrix["num connected components"] > 1, "top attributes"
-    ] = False
+        # Assign the size of connected components, ensuring it is always a list
+        annotations_enrichment_matrix.at[attribute, "size connected components"] = (
+            filtered_size_connected_components.tolist()
+        )
 
     return annotations_enrichment_matrix
 
 
 def get_description(words_column: pd.Series) -> str:
-    """Process input Series to identify and return the top N frequent, significant words,
-    filtering based on stopwords and similarity (Jaccard index).
+    """Process input Series to identify and return the top frequent, significant words,
+    filtering based on stopwords and gracefully handling numerical strings.
 
     Args:
         words_column (pd.Series): A pandas Series containing strings to process.
@@ -167,19 +173,29 @@ def get_description(words_column: pd.Series) -> str:
     Returns:
         str: A coherent description formed from the most frequent and significant words.
     """
-    # Define stopwords
-    stop_words = set(stopwords.words("english"))
-    # Tokenize the concatenated string and filter out stopwords and non-alphabetic words
+    # Concatenate all rows into a single string and tokenize into words
+    all_words = words_column.str.cat(sep=" ")
+    tokens = word_tokenize(all_words)
+
+    # Separate numeric tokens
+    numeric_tokens = [token for token in tokens if token.replace(".", "", 1).isdigit()]
+    # If there's only one unique numeric value, return it directly as a string
+    unique_numeric_values = set(numeric_tokens)
+    if len(unique_numeric_values) == 1:
+        return f"{list(unique_numeric_values)[0]}"
+
+    # Ensure that all values in 'words' are strings and include both alphabetic and numeric tokens
     words = [
-        (
+        str(
             word.lower() if word.istitle() else word
-        )  # Lowercase all words except proper nouns (e.g., RNA, mRNA)
-        for word in word_tokenize(words_column.str.cat(sep=" "))
-        if word.isalpha() and word.lower() not in stop_words
+        )  # Convert to string and lowercase all words except proper nouns (e.g., RNA, mRNA)
+        for word in tokens
+        if word.isalpha()
+        or word.replace(".", "", 1).isdigit()  # Keep alphabetic words and numeric strings
     ]
-    # Simplify the word list to remove similar words based on the Jaccard index and generate coherent description
-    simplified_words = _simplify_word_list(words, threshold=0.90)
-    description = _generate_coherent_description(simplified_words)
+    # Generate a coherent description from the processed words
+    description = _generate_coherent_description(words)
+
     return description
 
 
@@ -237,25 +253,28 @@ def _calculate_jaccard_index(set1: Set[Any], set2: Set[Any]) -> float:
 
 
 def _generate_coherent_description(words: List[str]) -> str:
-    """Generate a coherent description from a list of words.
+    """Generate a coherent description from a list of words or numerical string values.
+    If there is only one unique entry, return it directly.
 
     Args:
-        words (list of str): A list of words from which to generate the description.
+        words (list): A list of words or numerical string values.
 
     Returns:
         str: A coherent description formed by arranging the words in a logical sequence.
     """
-    # Count the frequency of each word
+    # If there are no words, return a keyword indicating no data is available
+    if not words:
+        return "N/A"
+
+    # If there's only one unique word, return it directly
+    unique_words = set(words)
+    if len(unique_words) == 1:
+        return list(unique_words)[0]
+
+    # Count the frequency of each word and sort them by frequency
     word_counts = Counter(words)
-    # Get the most common words
     most_common_words = [word for word, _ in word_counts.most_common()]
-    # Filter out common stopwords
-    stop_words = set(stopwords.words("english"))
-    filtered_words = [word for word in most_common_words if word.lower() not in stop_words]
-    # Generate permutations of the filtered words to find a logical order
-    perm = permutations(filtered_words)
-    # Assume the first permutation as the logical sequence (since they're all equally likely without additional context)
-    logical_sequence = next(perm)
-    # Join the words to form a coherent description
-    description = " ".join(logical_sequence)
+    # Join the most common words to form a coherent description based on frequency
+    description = " ".join(most_common_words)
+
     return description

{risk_network-0.0.6b10 → risk_network-0.0.7}/risk/annotations/io.py

@@ -12,7 +12,7 @@ import networkx as nx
 import pandas as pd
 
 from risk.annotations.annotations import load_annotations
-from risk.log import params, print_header
+from risk.log import params, logger, log_header
 
 
 class AnnotationsIO:
@@ -25,12 +25,12 @@ class AnnotationsIO:
     def __init__(self):
         pass
 
-    def load_json_annotation(self, filepath: str, network: nx.Graph) -> Dict[str, Any]:
+    def load_json_annotation(self, network: nx.Graph, filepath: str) -> Dict[str, Any]:
         """Load annotations from a JSON file and convert them to a DataFrame.
 
         Args:
-            filepath (str): Path to the JSON annotations file.
             network (NetworkX graph): The network to which the annotations are related.
+            filepath (str): Path to the JSON annotations file.
 
         Returns:
             dict: A dictionary containing ordered nodes, ordered annotations, and the annotations matrix.
@@ -49,8 +49,8 @@ class AnnotationsIO:
 
     def load_excel_annotation(
         self,
-        filepath: str,
         network: nx.Graph,
+        filepath: str,
         label_colname: str = "label",
         nodes_colname: str = "nodes",
         sheet_name: str = "Sheet1",
@@ -59,8 +59,8 @@ class AnnotationsIO:
         """Load annotations from an Excel file and associate them with the network.
 
         Args:
-            filepath (str): Path to the Excel annotations file.
             network (nx.Graph): The NetworkX graph to which the annotations are related.
+            filepath (str): Path to the Excel annotations file.
             label_colname (str): Name of the column containing the labels (e.g., GO terms).
             nodes_colname (str): Name of the column containing the nodes associated with each label.
             sheet_name (str, optional): The name of the Excel sheet to load (default is 'Sheet1').
@@ -87,8 +87,8 @@ class AnnotationsIO:
 
     def load_csv_annotation(
         self,
-        filepath: str,
         network: nx.Graph,
+        filepath: str,
         label_colname: str = "label",
         nodes_colname: str = "nodes",
         nodes_delimiter: str = ";",
@@ -96,8 +96,8 @@ class AnnotationsIO:
         """Load annotations from a CSV file and associate them with the network.
 
         Args:
-            filepath (str): Path to the CSV annotations file.
             network (nx.Graph): The NetworkX graph to which the annotations are related.
+            filepath (str): Path to the CSV annotations file.
             label_colname (str): Name of the column containing the labels (e.g., GO terms).
             nodes_colname (str): Name of the column containing the nodes associated with each label.
             nodes_delimiter (str, optional): Delimiter used to separate multiple nodes within the nodes column (default is ';').
@@ -121,8 +121,8 @@ class AnnotationsIO:
 
     def load_tsv_annotation(
         self,
-        filepath: str,
         network: nx.Graph,
+        filepath: str,
         label_colname: str = "label",
         nodes_colname: str = "nodes",
         nodes_delimiter: str = ";",
@@ -130,8 +130,8 @@ class AnnotationsIO:
         """Load annotations from a TSV file and associate them with the network.
 
         Args:
-            filepath (str): Path to the TSV annotations file.
             network (nx.Graph): The NetworkX graph to which the annotations are related.
+            filepath (str): Path to the TSV annotations file.
             label_colname (str): Name of the column containing the labels (e.g., GO terms).
             nodes_colname (str): Name of the column containing the nodes associated with each label.
             nodes_delimiter (str, optional): Delimiter used to separate multiple nodes within the nodes column (default is ';').
@@ -153,12 +153,12 @@ class AnnotationsIO:
         # Load the annotations into the provided network
         return load_annotations(network, annotations_input)
 
-    def load_dict_annotation(self, content: Dict[str, Any], network: nx.Graph) -> Dict[str, Any]:
+    def load_dict_annotation(self, network: nx.Graph, content: Dict[str, Any]) -> Dict[str, Any]:
         """Load annotations from a provided dictionary and convert them to a dictionary annotation.
 
         Args:
-            content (dict): The annotations dictionary to load.
             network (NetworkX graph): The network to which the annotations are related.
+            content (dict): The annotations dictionary to load.
 
         Returns:
             dict: A dictionary containing ordered nodes, ordered annotations, and the annotations matrix.
@@ -218,7 +218,7 @@ def _log_loading(filetype: str, filepath: str = "") -> None:
         filetype (str): The type of the file being loaded (e.g., 'Cytoscape').
         filepath (str, optional): The path to the file being loaded.
     """
-    print_header("Loading annotations")
-    print(f"Filetype: {filetype}")
+    log_header("Loading annotations")
+    logger.debug(f"Filetype: {filetype}")
     if filepath:
-        print(f"Filepath: {filepath}")
+        logger.debug(f"Filepath: {filepath}")

{risk_network-0.0.6b10 → risk_network-0.0.7}/risk/log/__init__.py

@@ -3,7 +3,7 @@ risk/log
 ~~~~~~~~
 """
 
-from .console import print_header
+from .config import logger, log_header, set_global_verbosity
 from .params import Params
 
 params = Params()

risk_network-0.0.7/risk/log/config.py

@@ -0,0 +1,139 @@
+"""
+risk/log/config
+~~~~~~~~~~~~~~~
+"""
+
+import logging
+
+
+def in_jupyter():
+    """Check if the code is running in a Jupyter notebook environment.
+
+    Returns:
+        bool: True if running in a Jupyter notebook or QtConsole, False otherwise.
+    """
+    try:
+        shell = get_ipython().__class__.__name__
+        if shell == "ZMQInteractiveShell":  # Jupyter Notebook or QtConsole
+            return True
+        elif shell == "TerminalInteractiveShell":  # Terminal running IPython
+            return False
+    except NameError:
+        return False  # Not in Jupyter
+
+
+# Define the MockLogger class to replicate logging behavior with print statements in Jupyter
+class MockLogger:
+    """MockLogger: A lightweight logger replacement using print statements in Jupyter.
+
+    The MockLogger class replicates the behavior of a standard logger using print statements
+    to display messages. This is primarily used in a Jupyter environment to show outputs
+    directly in the notebook. The class supports logging levels such as `info`, `debug`,
+    `warning`, and `error`, while the `verbose` attribute controls whether to display non-error messages.
+    """
+
+    def __init__(self, verbose: bool = True):
+        """Initialize the MockLogger with verbosity settings.
+
+        Args:
+            verbose (bool): If True, display all log messages (info, debug, warning).
+                If False, only display error messages. Defaults to True.
+        """
+        self.verbose = verbose
+
+    def info(self, message: str) -> None:
+        """Display an informational message.
+
+        Args:
+            message (str): The informational message to be printed.
+        """
+        if self.verbose:
+            print(message)
+
+    def debug(self, message: str) -> None:
+        """Display a debug message.
+
+        Args:
+            message (str): The debug message to be printed.
+        """
+        if self.verbose:
+            print(message)
+
+    def warning(self, message: str) -> None:
+        """Display a warning message.
+
+        Args:
+            message (str): The warning message to be printed.
+        """
+        print(message)
+
+    def error(self, message: str) -> None:
+        """Display an error message.
+
+        Args:
+            message (str): The error message to be printed.
+        """
+        print(message)
+
+    def setLevel(self, level: int) -> None:
+        """Adjust verbosity based on the logging level.
+
+        Args:
+            level (int): Logging level to control message display.
+                - logging.DEBUG sets verbose to True (show all messages).
+                - logging.WARNING sets verbose to False (show only warning, error, and critical messages).
+        """
+        if level == logging.DEBUG:
+            self.verbose = True  # Show all messages
+        elif level == logging.WARNING:
+            self.verbose = False  # Suppress all except warning, error, and critical messages
+
+
+# Set up logger based on environment
+if not in_jupyter():
+    # Set up logger normally for .py files or terminal environments
+    logger = logging.getLogger("risk_logger")
+    logger.setLevel(logging.DEBUG)
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.DEBUG)
+    console_handler.setFormatter(logging.Formatter("%(message)s"))
+
+    if not logger.hasHandlers():
+        logger.addHandler(console_handler)
+else:
+    # If in Jupyter, use the MockLogger
+    logger = MockLogger()
+
+
+def set_global_verbosity(verbose):
+    """Set the global verbosity level for the logger.
+
+    Args:
+        verbose (bool): Whether to display all log messages (True) or only error messages (False).
+
+    Returns:
+        None
+    """
+    if not isinstance(logger, MockLogger):
+        # For the regular logger, adjust logging levels
+        if verbose:
+            logger.setLevel(logging.DEBUG)  # Show all messages
+            console_handler.setLevel(logging.DEBUG)
+        else:
+            logger.setLevel(logging.WARNING)  # Show only warning, error, and critical messages
+            console_handler.setLevel(logging.WARNING)
+    else:
+        # For the MockLogger, set verbosity directly
+        logger.setLevel(logging.DEBUG if verbose else logging.WARNING)
+
+
+def log_header(input_string: str) -> None:
+    """Log the input string as a header with a line of dashes above and below it.
+
+    Args:
+        input_string (str): The string to be printed as a header.
+    """
+    border = "-" * len(input_string)
+    logger.info(border)
+    logger.info(input_string)
+    logger.info(border)

{risk_network-0.0.6b10 → risk_network-0.0.7}/risk/log/params.py

@@ -12,7 +12,7 @@ from typing import Any, Dict
 
 import numpy as np
 
-from .console import print_header
+from .config import logger, log_header
 
 # Suppress all warnings - this is to resolve warnings from multiprocessing
 warnings.filterwarnings("ignore")
@@ -35,11 +35,11 @@ def _safe_param_export(func):
             filepath = (
                 kwargs.get("filepath") or args[1]
             )  # Assuming filepath is always the second argument
-            print(f"Parameters successfully exported to filepath: {filepath}")
+            logger.info(f"Parameters successfully exported to filepath: {filepath}")
             return result
         except Exception as e:
             filepath = kwargs.get("filepath") or args[1]
-            print(f"An error occurred while exporting parameters to {filepath}: {e}")
+            logger.error(f"An error occurred while exporting parameters to {filepath}: {e}")
             return None
 
     return wrapper
@@ -161,7 +161,7 @@ class Params:
         Returns:
             dict: A dictionary containing the processed parameters.
         """
-        print_header("Loading parameters")
+        log_header("Loading parameters")
         return _convert_ndarray_to_list(
             {
                 "annotations": self.annotations,

{risk_network-0.0.6b10 → risk_network-0.0.7}/risk/neighborhoods/community.py

@@ -7,32 +7,29 @@ import community as community_louvain
 import networkx as nx
 import numpy as np
 import markov_clustering as mc
-from networkx.algorithms.community import asyn_lpa_communities
+from networkx.algorithms.community import asyn_lpa_communities, greedy_modularity_communities
 
 
-def calculate_dijkstra_neighborhoods(network: nx.Graph) -> np.ndarray:
-    """Calculate neighborhoods using Dijkstra's shortest path distances.
+def calculate_greedy_modularity_neighborhoods(network: nx.Graph) -> np.ndarray:
+    """Calculate neighborhoods using the Greedy Modularity method.
 
     Args:
-        network (nx.Graph): The network graph.
+        network (nx.Graph): The network graph to analyze for community structure.
 
     Returns:
-        np.ndarray: Neighborhood matrix based on Dijkstra's distances.
+        np.ndarray: A binary neighborhood matrix where nodes in the same community have 1, and others have 0.
     """
-    # Compute Dijkstra's distance for all pairs of nodes in the network
-    all_dijkstra_paths = dict(nx.all_pairs_dijkstra_path_length(network, weight="length"))
+    # Detect communities using the Greedy Modularity method
+    communities = greedy_modularity_communities(network)
+    # Create a mapping from node to community
+    community_dict = {node: idx for idx, community in enumerate(communities) for node in community}
+    # Create a binary neighborhood matrix
     neighborhoods = np.zeros((network.number_of_nodes(), network.number_of_nodes()), dtype=int)
-
-    # Populate the neighborhoods matrix based on Dijkstra's distances
-    for source, targets in all_dijkstra_paths.items():
-        max_length = max(targets.values()) if targets else 1  # Handle cases with no targets
-        for target, length in targets.items():
-            if np.isnan(length):
-                neighborhoods[source, target] = max_length  # Use max distance for NaN
-            elif length == 0:
-                neighborhoods[source, target] = 1  # Assign 1 for zero-length paths (self-loops)
-            else:
-                neighborhoods[source, target] = 1 / length  # Inverse of the distance
+    node_index = {node: i for i, node in enumerate(network.nodes())}
+    for node_i, community_i in community_dict.items():
+        for node_j, community_j in community_dict.items():
+            if community_i == community_j:
+                neighborhoods[node_index[node_i], node_index[node_j]] = 1
 
     return neighborhoods
 
@@ -44,21 +41,19 @@ def calculate_label_propagation_neighborhoods(network: nx.Graph) -> np.ndarray:
         network (nx.Graph): The network graph.
 
     Returns:
-        np.ndarray: Neighborhood matrix based on Label Propagation.
+        np.ndarray: Binary neighborhood matrix on Label Propagation.
     """
     # Apply Label Propagation
     communities = nx.algorithms.community.label_propagation.label_propagation_communities(network)
-
     # Create a mapping from node to community
     community_dict = {}
     for community_id, community in enumerate(communities):
         for node in community:
             community_dict[node] = community_id
 
-    # Create a neighborhood matrix
+    # Create a binary neighborhood matrix
     num_nodes = network.number_of_nodes()
     neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-
     # Assign neighborhoods based on community labels
     for node_i, community_i in community_dict.items():
         for node_j, community_j in community_dict.items():
@@ -79,14 +74,14 @@ def calculate_louvain_neighborhoods(
         random_seed (int, optional): Random seed for reproducibility. Defaults to 888.
 
     Returns:
-        np.ndarray: Neighborhood matrix based on the Louvain method.
+        np.ndarray: Binary neighborhood matrix on the Louvain method.
     """
     # Apply Louvain method to partition the network
     partition = community_louvain.best_partition(
         network, resolution=resolution, random_state=random_seed
     )
+    # Create a binary neighborhood matrix
     neighborhoods = np.zeros((network.number_of_nodes(), network.number_of_nodes()), dtype=int)
-
     # Assign neighborhoods based on community partitions
     for node_i, community_i in partition.items():
         for node_j, community_j in partition.items():
@@ -103,7 +98,7 @@ def calculate_markov_clustering_neighborhoods(network: nx.Graph) -> np.ndarray:
         network (nx.Graph): The network graph.
 
     Returns:
-        np.ndarray: Neighborhood matrix based on Markov Clustering.
+        np.ndarray: Binary neighborhood matrix on Markov Clustering.
     """
     # Convert the graph to an adjacency matrix
     adjacency_matrix = nx.to_numpy_array(network)
@@ -111,17 +106,15 @@ def calculate_markov_clustering_neighborhoods(network: nx.Graph) -> np.ndarray:
     result = mc.run_mcl(adjacency_matrix)  # Run MCL with default parameters
     # Get clusters
     clusters = mc.get_clusters(result)
-
     # Create a community label for each node
     community_dict = {}
     for community_id, community in enumerate(clusters):
         for node in community:
             community_dict[node] = community_id
 
-    # Create a neighborhood matrix
+    # Create a binary neighborhood matrix
     num_nodes = network.number_of_nodes()
     neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-
     # Assign neighborhoods based on community labels
     for node_i, community_i in community_dict.items():
         for node_j, community_j in community_dict.items():
@@ -138,21 +131,19 @@ def calculate_spinglass_neighborhoods(network: nx.Graph) -> np.ndarray:
         network (nx.Graph): The network graph.
 
     Returns:
-        np.ndarray: Neighborhood matrix based on Spin Glass communities.
+        np.ndarray: Binary neighborhood matrix on Spin Glass communities.
     """
     # Use the asynchronous label propagation algorithm as a proxy for Spin Glass
     communities = asyn_lpa_communities(network)
-
     # Create a community label for each node
     community_dict = {}
     for community_id, community in enumerate(communities):
         for node in community:
             community_dict[node] = community_id
 
-    # Create a neighborhood matrix
+    # Create a binary neighborhood matrix
     num_nodes = network.number_of_nodes()
     neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-
     # Assign neighborhoods based on community labels
     for node_i, community_i in community_dict.items():
         for node_j, community_j in community_dict.items():
@@ -169,21 +160,19 @@ def calculate_walktrap_neighborhoods(network: nx.Graph) -> np.ndarray:
         network (nx.Graph): The network graph.
 
     Returns:
-        np.ndarray: Neighborhood matrix based on Walktrap communities.
+        np.ndarray: Binary neighborhood matrix on Walktrap communities.
     """
     # Use the asynchronous label propagation algorithm as a proxy for Walktrap
     communities = asyn_lpa_communities(network)
-
     # Create a community label for each node
     community_dict = {}
     for community_id, community in enumerate(communities):
         for node in community:
             community_dict[node] = community_id
 
-    # Create a neighborhood matrix
+    # Create a binary neighborhood matrix
     num_nodes = network.number_of_nodes()
     neighborhoods = np.zeros((num_nodes, num_nodes), dtype=int)
-
     # Assign neighborhoods based on community labels
     for node_i, community_i in community_dict.items():
         for node_j, community_j in community_dict.items():