risk-network 0.0.9b1__py3-none-any.whl → 0.0.9b2__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.1"
+__version__ = "0.0.9-beta.2"

risk/annotations/io.py

@@ -76,11 +76,13 @@ class AnnotationsIO:
         _log_loading(filetype, filepath=filepath)
 
         # Load the specified sheet from the Excel file
-        df = pd.read_excel(filepath, sheet_name=sheet_name)
+        annotation = pd.read_excel(filepath, sheet_name=sheet_name)
         # Split the nodes column by the specified nodes_delimiter
-        df[nodes_colname] = df[nodes_colname].apply(lambda x: x.split(nodes_delimiter))
+        annotation[nodes_colname] = annotation[nodes_colname].apply(
+            lambda x: x.split(nodes_delimiter)
+        )
         # Convert the DataFrame to a dictionary pairing labels with their corresponding nodes
-        label_node_dict = df.set_index(label_colname)[nodes_colname].to_dict()
+        label_node_dict = annotation.set_index(label_colname)[nodes_colname].to_dict()
 
         # Load the annotations into the provided network
         return load_annotations(network, label_node_dict)
@@ -203,11 +205,11 @@ def _load_matrix_file(
         Dict[str, Any]: A dictionary where each label is paired with its respective list of nodes.
     """
     # Load the CSV or TSV file into a DataFrame
-    df = pd.read_csv(filepath, delimiter=delimiter)
+    annotation = pd.read_csv(filepath, delimiter=delimiter)
     # Split the nodes column by the nodes_delimiter to handle multiple nodes per label
-    df[nodes_colname] = df[nodes_colname].apply(lambda x: x.split(nodes_delimiter))
+    annotation[nodes_colname] = annotation[nodes_colname].apply(lambda x: x.split(nodes_delimiter))
     # Create a dictionary pairing labels with their corresponding list of nodes
-    label_node_dict = df.set_index(label_colname)[nodes_colname].to_dict()
+    label_node_dict = annotation.set_index(label_colname)[nodes_colname].to_dict()
     return label_node_dict
 
 

risk/log/__init__.py

@@ -4,6 +4,8 @@ risk/log
 """
 
 from .console import logger, log_header, set_global_verbosity
-from .params import Params
+from .parameters import Params
 
+# Initialize the global parameters logger
 params = Params()
+params.initialize()

risk/log/{params.py → parameters.py}

@@ -1,50 +1,22 @@
 """
-risk/log/params
-~~~~~~~~~~~~~~~
+risk/log/parameters
+~~~~~~~~~~~~~~~~~~~
 """
 
 import csv
 import json
 import warnings
 from datetime import datetime
-from functools import wraps
 from typing import Any, Dict
 
 import numpy as np
 
-from .console import logger, log_header
+from risk.log.console import logger, log_header
 
 # Suppress all warnings - this is to resolve warnings from multiprocessing
 warnings.filterwarnings("ignore")
 
 
-def _safe_param_export(func):
-    """A decorator to wrap parameter export functions in a try-except block for safe execution.
-
-    Args:
-        func (function): The function to be wrapped.
-
-    Returns:
-        function: The wrapped function with error handling.
-    """
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        try:
-            result = func(*args, **kwargs)
-            filepath = (
-                kwargs.get("filepath") or args[1]
-            )  # Assuming filepath is always the second argument
-            logger.info(f"Parameters successfully exported to filepath: {filepath}")
-            return result
-        except Exception as e:
-            filepath = kwargs.get("filepath") or args[1]
-            logger.error(f"An error occurred while exporting parameters to {filepath}: {e}")
-            return None
-
-    return wrapper
-
-
 class Params:
     """Handles the storage and logging of various parameters for network analysis.
 
@@ -106,7 +78,6 @@ class Params:
         """
         self.plotter = {**self.plotter, **kwargs}
 
-    @_safe_param_export
     def to_csv(self, filepath: str) -> None:
         """Export the parameters to a CSV file.
 
@@ -128,7 +99,8 @@ class Params:
                 else:
                     writer.writerow([parent_key, "", parent_value])
 
-    @_safe_param_export
+        logger.info(f"Parameters exported to CSV file: {filepath}")
+
     def to_json(self, filepath: str) -> None:
         """Export the parameters to a JSON file.
 
@@ -138,7 +110,8 @@ class Params:
         with open(filepath, "w") as json_file:
             json.dump(self.load(), json_file, indent=4)
 
-    @_safe_param_export
+        logger.info(f"Parameters exported to JSON file: {filepath}")
+
     def to_txt(self, filepath: str) -> None:
         """Export the parameters to a text file.
 
@@ -155,6 +128,8 @@ class Params:
             # Add a blank line after each entry
             txt_file.write("\n")
 
+        logger.info(f"Parameters exported to text file: {filepath}")
+
     def load(self) -> Dict[str, Any]:
         """Load and process various parameters, converting any np.ndarray values to lists.
 

risk/neighborhoods/domains.py

@@ -101,7 +101,7 @@ def trim_domains_and_top_annotations(
         max_cluster_size (int, optional): Maximum size of a cluster to be retained. Defaults to 1000.
 
     Returns:
-        Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]: A tuple containing:
+        Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
             - Trimmed annotations (pd.DataFrame)
             - Trimmed domains (pd.DataFrame)
             - A DataFrame with domain labels (pd.DataFrame)
@@ -177,7 +177,7 @@ def _optimize_silhouette_across_linkage_and_metrics(
         linkage_metric (str): Linkage metric for clustering.
 
     Returns:
-        Tuple[str, str, float]: A tuple containing:
+        Tuple[str, str, float]:
             - Best linkage method (str)
             - Best linkage metric (str)
             - Best threshold (float)
@@ -231,7 +231,7 @@ def _find_best_silhouette_score(
         resolution (float, optional): Desired resolution for the best threshold. Defaults to 0.001.
 
     Returns:
-        Tuple[float, float]: A tuple containing:
+        Tuple[float, float]:
             - Best threshold (float): The threshold that yields the best silhouette score.
             - Best silhouette score (float): The highest silhouette score achieved.
     """

risk/neighborhoods/neighborhoods.py

@@ -233,7 +233,7 @@ def _impute_neighbors(
         max_depth (int): Maximum depth of nodes to traverse for imputing values.
 
     Returns:
-        tuple: A tuple containing:
+        Tuple[np.ndarray, np.ndarray, np.ndarray]:
             - np.ndarray: The imputed significance matrix.
             - np.ndarray: The imputed alpha threshold matrix.
             - np.ndarray: The significant significance matrix with non-significant entries set to zero.
@@ -269,7 +269,7 @@ def _impute_neighbors_with_similarity(
         max_depth (int): Maximum depth of nodes to traverse for imputing values.
 
     Returns:
-        Tuple[np.ndarray, np.ndarray]: A tuple containing:
+        Tuple[np.ndarray, np.ndarray]:
             - The imputed significance matrix.
             - The imputed alpha threshold matrix.
     """
@@ -397,7 +397,7 @@ def _prune_neighbors(
         distance_threshold (float): Rank threshold (0 to 1) to determine outliers.
 
     Returns:
-        tuple: A tuple containing:
+        Tuple[np.ndarray, np.ndarray, np.ndarray]:
             - np.ndarray: The updated significance matrix with outliers set to zero.
             - np.ndarray: The updated alpha threshold matrix with outliers set to zero.
             - np.ndarray: The significant significance matrix, where non-significant entries are set to zero.

risk/network/graph/__init__.py

@@ -0,0 +1,6 @@
+"""
+risk/network/graph
+~~~~~~~~~~~~~~~~~~
+"""
+
+from .network import NetworkGraph

risk/network/{graph.py → graph/network.py}

@@ -1,6 +1,6 @@
 """
-risk/network/graph
-~~~~~~~~~~~~~~~~~~
+risk/network/graph/network
+~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from collections import defaultdict
@@ -10,6 +10,8 @@ import networkx as nx
 import numpy as np
 import pandas as pd
 
+from risk.network.graph.summary import Summary
+
 
 class NetworkGraph:
     """A class to represent a network graph and process its nodes and edges.
@@ -23,6 +25,8 @@ class NetworkGraph:
     def __init__(
         self,
         network: nx.Graph,
+        annotations: Dict[str, Any],
+        neighborhoods: Dict[str, Any],
         top_annotations: pd.DataFrame,
         domains: pd.DataFrame,
         trimmed_domains: pd.DataFrame,
@@ -33,12 +37,15 @@ class NetworkGraph:
 
         Args:
             network (nx.Graph): The network graph.
+            annotations (Dict[str, Any]): The annotations associated with the network.
+            neighborhoods (Dict[str, Any]): Neighborhood significance data.
             top_annotations (pd.DataFrame): DataFrame containing annotations data for the network nodes.
             domains (pd.DataFrame): DataFrame containing domain data for the network nodes.
             trimmed_domains (pd.DataFrame): DataFrame containing trimmed domain data for the network nodes.
             node_label_to_node_id_map (Dict[str, Any]): A dictionary mapping node labels to their corresponding IDs.
             node_significance_sums (np.ndarray): Array containing the significant sums for the nodes.
         """
+        # Initialize self.network downstream of the other attributes
         self.top_annotations = top_annotations
         self.domain_id_to_node_ids_map = self._create_domain_id_to_node_ids_map(domains)
         self.domains = domains
@@ -58,12 +65,16 @@ class NetworkGraph:
             zip(node_label_to_node_id_map.keys(), node_significance_sums)
         )
         self.node_label_to_node_id_map = node_label_to_node_id_map
+
         # NOTE: Below this point, instance attributes (i.e., self) will be used!
         self.domain_id_to_node_labels_map = self._create_domain_id_to_node_labels_map()
         # Unfold the network's 3D coordinates to 2D and extract node coordinates
         self.network = _unfold_sphere_to_plane(network)
         self.node_coordinates = _extract_node_coordinates(self.network)
 
+        # NOTE: Only after the above attributes are initialized, we can create the summary
+        self.summary = Summary(annotations, neighborhoods, self)
+
     @staticmethod
     def _create_domain_id_to_node_ids_map(domains: pd.DataFrame) -> Dict[int, Any]:
         """Create a mapping from domains to the list of node IDs belonging to each domain.

risk/network/graph/summary.py

@@ -0,0 +1,239 @@
+"""
+risk/network/graph/summary
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+import warnings
+from functools import lru_cache
+from typing import Any, Dict, Tuple, Union
+
+import numpy as np
+import pandas as pd
+from statsmodels.stats.multitest import fdrcorrection
+
+from risk.log.console import logger, log_header
+
+
+# Suppress all warnings - this is to resolve warnings from multiprocessing
+warnings.filterwarnings("ignore")
+
+
+class Summary:
+    """Handles the processing, storage, and export of network analysis results.
+
+    The Results class provides methods to process significance and depletion data, compute
+    FDR-corrected q-values, and structure information on domains and annotations into a
+    DataFrame. It also offers functionality to export the processed data in CSV, JSON,
+    and text formats for analysis and reporting.
+    """
+
+    def __init__(
+        self,
+        annotations: Dict[str, Any],
+        neighborhoods: Dict[str, Any],
+        graph,  # Avoid type hinting NetworkGraph to avoid circular import
+    ):
+        """Initialize the Results object with analysis components.
+
+        Args:
+            annotations (Dict[str, Any]): Annotation data, including ordered annotations and matrix of associations.
+            neighborhoods (Dict[str, Any]): Neighborhood data containing p-values for significance and depletion analysis.
+            graph (NetworkGraph): Graph object representing domain-to-node and node-to-label mappings.
+        """
+        self.annotations = annotations
+        self.neighborhoods = neighborhoods
+        self.graph = graph
+
+    def to_csv(self, filepath: str) -> None:
+        """Export significance results to a CSV file.
+
+        Args:
+            filepath (str): The path where the CSV file will be saved.
+        """
+        # Load results and export directly to CSV
+        results = self.load()
+        results.to_csv(filepath, index=False)
+        logger.info(f"Results summary exported to CSV file: {filepath}")
+
+    def to_json(self, filepath: str) -> None:
+        """Export significance results to a JSON file.
+
+        Args:
+            filepath (str): The path where the JSON file will be saved.
+        """
+        # Load results and export directly to JSON
+        results = self.load()
+        results.to_json(filepath, orient="records", indent=4)
+        logger.info(f"Results summary exported to JSON file: {filepath}")
+
+    def to_txt(self, filepath: str) -> None:
+        """Export significance results to a text file.
+
+        Args:
+            filepath (str): The path where the text file will be saved.
+        """
+        # Load results and export directly to text file
+        results = self.load()
+        with open(filepath, "w") as txt_file:
+            txt_file.write(results.to_string(index=False))
+
+        logger.info(f"Results summary exported to text file: {filepath}")
+
+    @lru_cache(maxsize=None)
+    def load(self) -> pd.DataFrame:
+        """Load and process domain and annotation data into a DataFrame with significance metrics.
+
+        Args:
+            graph (Any): Graph object containing domain-to-node and node-to-label mappings.
+            annotations (Dict[str, Any]): Annotation details, including ordered annotations and matrix.
+
+        Returns:
+            pd.DataFrame: Processed DataFrame containing significance scores, p-values, q-values,
+                and annotation member information.
+        """
+        log_header("Loading parameters")
+        # Calculate significance and depletion q-values from p-value matrices in `annotations`
+        enrichment_pvals = self.neighborhoods["enrichment_pvals"]
+        depletion_pvals = self.neighborhoods["depletion_pvals"]
+        enrichment_qvals = self._calculate_qvalues(enrichment_pvals)
+        depletion_qvals = self._calculate_qvalues(depletion_pvals)
+
+        # Initialize DataFrame with domain and annotation details
+        results = pd.DataFrame(
+            [
+                {"Domain ID": domain_id, "Annotation": desc, "Summed Significance Score": score}
+                for domain_id, info in self.graph.domain_id_to_domain_info_map.items()
+                for desc, score in zip(info["full_descriptions"], info["significance_scores"])
+            ]
+        )
+        # Sort by Domain ID and Summed Significance Score
+        results = results.sort_values(
+            by=["Domain ID", "Summed Significance Score"], ascending=[True, False]
+        ).reset_index(drop=True)
+
+        # Add minimum p-values and q-values to DataFrame
+        results[
+            [
+                "Enrichment P-value",
+                "Enrichment Q-value",
+                "Depletion P-value",
+                "Depletion Q-value",
+            ]
+        ] = results.apply(
+            lambda row: self._get_significance_values(
+                row["Domain ID"],
+                row["Annotation"],
+                enrichment_pvals,
+                depletion_pvals,
+                enrichment_qvals,
+                depletion_qvals,
+            ),
+            axis=1,
+            result_type="expand",
+        )
+        # Add annotation members and their counts
+        results["Annotation Members"] = results["Annotation"].apply(
+            lambda desc: self._get_annotation_members(desc)
+        )
+        results["Annotation Member Count"] = results["Annotation Members"].apply(
+            lambda x: len(x.split(";")) if x else 0
+        )
+
+        # Reorder columns and drop rows with NaN values
+        results = (
+            results[
+                [
+                    "Domain ID",
+                    "Annotation",
+                    "Annotation Members",
+                    "Annotation Member Count",
+                    "Summed Significance Score",
+                    "Enrichment P-value",
+                    "Enrichment Q-value",
+                    "Depletion P-value",
+                    "Depletion Q-value",
+                ]
+            ]
+            .dropna()
+            .reset_index(drop=True)
+        )
+
+        return results
+
+    @staticmethod
+    def _calculate_qvalues(pvals: np.ndarray) -> np.ndarray:
+        """Calculate q-values (FDR) for each row of a p-value matrix.
+
+        Args:
+            pvals (np.ndarray): 2D array of p-values.
+
+        Returns:
+            np.ndarray: 2D array of q-values, with FDR correction applied row-wise.
+        """
+        return np.apply_along_axis(lambda row: fdrcorrection(row)[1], 1, pvals)
+
+    def _get_significance_values(
+        self,
+        domain_id: int,
+        description: str,
+        enrichment_pvals: np.ndarray,
+        depletion_pvals: np.ndarray,
+        enrichment_qvals: np.ndarray,
+        depletion_qvals: np.ndarray,
+    ) -> Tuple[Union[float, None], Union[float, None], Union[float, None], Union[float, None]]:
+        """Retrieve the most significant p-values and q-values (FDR) for a given annotation.
+
+        Args:
+            domain_id (int): The domain ID associated with the annotation.
+            description (str): The annotation description.
+            enrichment_pvals (np.ndarray): Matrix of significance p-values.
+            depletion_pvals (np.ndarray): Matrix of depletion p-values.
+            enrichment_qvals (np.ndarray): Matrix of significance q-values.
+            depletion_qvals (np.ndarray): Matrix of depletion q-values.
+
+        Returns:
+            Tuple[Union[float, None], Union[float, None], Union[float, None], Union[float, None]]:
+                Minimum significance p-value, significance q-value, depletion p-value, depletion q-value.
+        """
+        try:
+            annotation_idx = self.annotations["ordered_annotations"].index(description)
+        except ValueError:
+            return None, None, None, None  # Description not found
+
+        node_indices = self.graph.domain_id_to_node_ids_map.get(domain_id, [])
+        if not node_indices:
+            return None, None, None, None  # No associated nodes
+
+        sig_p = enrichment_pvals[node_indices, annotation_idx]
+        dep_p = depletion_pvals[node_indices, annotation_idx]
+        sig_q = enrichment_qvals[node_indices, annotation_idx]
+        dep_q = depletion_qvals[node_indices, annotation_idx]
+
+        return (
+            np.min(sig_p) if sig_p.size > 0 else None,
+            np.min(sig_q) if sig_q.size > 0 else None,
+            np.min(dep_p) if dep_p.size > 0 else None,
+            np.min(dep_q) if dep_q.size > 0 else None,
+        )
+
+    def _get_annotation_members(self, description: str) -> str:
+        """Retrieve node labels associated with a given annotation description.
+
+        Args:
+            description (str): The annotation description.
+
+        Returns:
+            str: ';'-separated string of node labels that are associated with the annotation.
+        """
+        try:
+            annotation_idx = self.annotations["ordered_annotations"].index(description)
+        except ValueError:
+            return ""  # Description not found
+
+        nodes_present = np.where(self.annotations["matrix"][:, annotation_idx] == 1)[0]
+        node_labels = sorted(
+            self.graph.node_id_to_node_label_map[node_id]
+            for node_id in nodes_present
+            if node_id in self.graph.node_id_to_node_label_map
+        )
+        return ";".join(node_labels)

risk/network/io.py

@@ -165,12 +165,12 @@ class NetworkIO:
         filepath: str,
         source_label: str = "source",
         target_label: str = "target",
+        view_name: str = "",
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
         min_edges_per_node: int = 0,
         include_edge_weight: bool = True,
         weight_label: str = "weight",
-        view_name: str = "",
     ) -> nx.Graph:
         """Load a network from a Cytoscape file.
 
@@ -178,7 +178,7 @@ class NetworkIO:
             filepath (str): Path to the Cytoscape file.
             source_label (str, optional): Source node label. Defaults to "source".
             target_label (str, optional): Target node label. Defaults to "target".
-            view_name (str, optional): Specific view name to load. Defaults to None.
+            view_name (str, optional): Specific view name to load. Defaults to "".
             compute_sphere (bool, optional): Whether to map nodes to a sphere. Defaults to True.
             surface_depth (float, optional): Surface depth for the sphere. Defaults to 0.0.
             min_edges_per_node (int, optional): Minimum number of edges per node. Defaults to 0.
@@ -215,7 +215,7 @@ class NetworkIO:
             filepath (str): Path to the Cytoscape file.
             source_label (str, optional): Source node label. Defaults to "source".
             target_label (str, optional): Target node label. Defaults to "target".
-            view_name (str, optional): Specific view name to load. Defaults to None.
+            view_name (str, optional): Specific view name to load. Defaults to "".
 
         Returns:
             nx.Graph: Loaded and processed network.

risk/risk.py

@@ -42,19 +42,10 @@ class RISK(NetworkIO, AnnotationsIO):
         """
         # Set global verbosity for logging
         set_global_verbosity(verbose)
-        # Initialize and log network parameters
-        params.initialize()
+        # Provide public access to the logged network parameters
+        self.params = params
         super().__init__()
 
-    @property
-    def params(self) -> params:
-        """Access the logged network parameters.
-
-        Returns:
-            Params: An instance of the Params class with logged parameters and methods to access or update them.
-        """
-        return params
-
     def load_neighborhoods_by_hypergeom(
         self,
         network: nx.Graph,
@@ -274,7 +265,7 @@ class RISK(NetworkIO, AnnotationsIO):
 
         Args:
             network (nx.Graph): The network graph.
-            annotations (pd.DataFrame): DataFrame containing annotation data for the network.
+            annotations (Dict[str, Any]): The annotations associated with the network.
             neighborhoods (Dict[str, Any]): Neighborhood significance data.
             tail (str, optional): Type of significance tail ("right", "left", "both"). Defaults to "right".
             pval_cutoff (float, optional): p-value cutoff for significance. Defaults to 0.01.
@@ -368,6 +359,8 @@ class RISK(NetworkIO, AnnotationsIO):
         # Return the fully initialized NetworkGraph object
         return NetworkGraph(
             network=network,
+            annotations=annotations,
+            neighborhoods=neighborhoods,
             top_annotations=top_annotations,
             domains=domains,
             trimmed_domains=trimmed_domains,

{risk_network-0.0.9b1.dist-info → risk_network-0.0.9b2.dist-info}/METADATA

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

{risk_network-0.0.9b1.dist-info → risk_network-0.0.9b2.dist-info}/RECORD

@@ -1,21 +1,22 @@
-risk/__init__.py,sha256=7yr2460_NPFOQzQdsQIZ9NxTv-tlleTl5DPCHWKAOvg,112
+risk/__init__.py,sha256=ICwmPcHgPSGMULpN30hPbaL4pu5GlN6TVBB5aduUyVM,112
 risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
-risk/risk.py,sha256=HVH8zXQuTWuckswsaqm7uM8u34FL4SYa_082Fjvp6xQ,23790
+risk/risk.py,sha256=De1vn8Xc-TKz6aTL0bvJI-SVrIqU3k0IWAbKc7dde1c,23618
 risk/annotations/__init__.py,sha256=kXgadEXaCh0z8OyhOhTj7c3qXGmWgOhaSZ4gSzSb59U,147
 risk/annotations/annotations.py,sha256=m3WeCdE1a2undpSl_Q2I17drD95r2McKtpzhiiSdxHY,13143
-risk/annotations/io.py,sha256=powWzeimVdE0WCwlBCXyu5otMyZZHQujC0DS3m5DC0c,9505
-risk/log/__init__.py,sha256=xKeU9uK1AnVk7Yt9GTp-E-dn7Ealow2igEXZZnQRa2c,135
+risk/annotations/io.py,sha256=eOkPD9G6KzkhGRc_ZW2McxQ8665o-H3uDG8bmKlzQ80,9591
+risk/log/__init__.py,sha256=gy7C5L6D222AYUChq5lkc0LsCJ_QMQPaFiBJKbecdac,201
 risk/log/console.py,sha256=C52s3FgQ2e9kQWcXL8m7rs_pnKXt5Yy8PBHmQkOTiNo,4537
-risk/log/enrichment.py,sha256=blDqaUo5KtHn0VxkvxuAIBbwlsTrdFeQxfOyOfvUmZE,346
-risk/log/params.py,sha256=qSTktJ3OazldTzgtDGZkh0s30vu5kiXPkiNGLdSFDvg,6416
+risk/log/parameters.py,sha256=o4StqYCa0kt7_Ht4mKa1DwwvhGUwkC_dGBaiUIc0GB0,5683
 risk/neighborhoods/__init__.py,sha256=tKKEg4lsbqFukpgYlUGxU_v_9FOqK7V0uvM9T2QzoL0,206
 risk/neighborhoods/community.py,sha256=MAgIblbuisEPwVU6mFZd4Yd9NUKlaHK99suw51r1Is0,7065
-risk/neighborhoods/domains.py,sha256=_Womb95Ik8i4gfnx9zpLGXyZ4dyZmqTk2XlsC6qSeTI,11722
-risk/neighborhoods/neighborhoods.py,sha256=KDT3zelogaioNH0HrtZrel_RQAphHCxnj3jv_XYX0sI,22229
+risk/neighborhoods/domains.py,sha256=cMp2McuaSxRp7lQvzjgZnlt5dzxwyj6HAWKyT9u2sng,11662
+risk/neighborhoods/neighborhoods.py,sha256=0TAP-xi4hgtnrK0cKQPHQHq9IVGHOMF1wYEcx6tsxRA,22241
 risk/network/__init__.py,sha256=iEPeJdZfqp0toxtbElryB8jbz9_t_k4QQ3iDvKE8C_0,126
 risk/network/geometry.py,sha256=gFtYUj9j9aul4paKq_qSGJn39Nazxu_MXv8m-tYYtrk,6840
-risk/network/graph.py,sha256=S9f8zBPBubfqBDTZJr4Fb9Ne-SPIWBdyMU4VRDtVoM4,9662
-risk/network/io.py,sha256=-NJ9Tg1s-DxhlDbwQGO4o87rbMqO4-BzShgnIgFoRRE,22962
+risk/network/io.py,sha256=AWSbZGLZHtl72KSlafQlcYoG00YLSznG7UYDi_wDT7M,22958
+risk/network/graph/__init__.py,sha256=H0YEiwqZ02LBTkH4blPwUjQ-DOUnhaTTNHM0BcXii6U,81
+risk/network/graph/network.py,sha256=4tDtQExFo9U1smaaxf-CaoxHOY99aagM2G11ap_DKbY,10192
+risk/network/graph/summary.py,sha256=zxkI9VyrYN5y41jlqLOIcDX0fF4wt24khtr6to36_uc,9239
 risk/network/plot/__init__.py,sha256=MfmaXJgAZJgXZ2wrhK8pXwzETlcMaLChhWXKAozniAo,98
 risk/network/plot/canvas.py,sha256=TlCpNtvoceizAumNr9I02JcBrBO6FiAFAa2ZC0bx3SU,13356
 risk/network/plot/contour.py,sha256=2ZVOlduo4Y4yIpXDJMIKO-v7eULcJ2QacQyOc7pUAxE,15267
@@ -31,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.9b1.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.9b1.dist-info/METADATA,sha256=3c5uAqoFdzK2gIz7kl1FYYE2uEZLv0LEeQ6_Fad3QgQ,47497
-risk_network-0.0.9b1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-risk_network-0.0.9b1.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.9b1.dist-info/RECORD,,
+risk_network-0.0.9b2.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.9b2.dist-info/METADATA,sha256=ccV7eOOwXIFCkiyfNIvCwLkTNQed1DuOmwXL84Nx2dY,47497
+risk_network-0.0.9b2.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+risk_network-0.0.9b2.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.9b2.dist-info/RECORD,,

risk/log/enrichment.py

@@ -1,18 +0,0 @@
-"""
-risk/log/enrichment
-~~~~~~~~~~~~~~~~~~~
-"""
-
-import csv
-import json
-import warnings
-from datetime import datetime
-from functools import wraps
-from typing import Any, Dict
-
-import numpy as np
-
-from .console import logger, log_header
-
-# Suppress all warnings - this is to resolve warnings from multiprocessing
-warnings.filterwarnings("ignore")