risk-network 0.0.8b27__py3-none-any.whl → 0.0.9__py3-none-any.whl

risk/annotations/io.py

@@ -1,8 +1,6 @@
 """
 risk/annotations/io
 ~~~~~~~~~~~~~~~~~~~
-
-This file contains the code for the RISK class and command-line access.
 """
 
 import json
@@ -25,27 +23,32 @@ class AnnotationsIO:
     def __init__(self):
         pass
 
-    def load_json_annotation(self, network: nx.Graph, filepath: str) -> Dict[str, Any]:
+    def load_json_annotation(
+        self, network: nx.Graph, filepath: str, min_nodes_per_term: int = 2
+    ) -> Dict[str, Any]:
         """Load annotations from a JSON file and convert them to a DataFrame.
 
         Args:
             network (NetworkX graph): The network to which the annotations are related.
             filepath (str): Path to the JSON annotations file.
+            min_nodes_per_term (int, optional): The minimum number of network nodes required for each annotation
+                term to be included. Defaults to 2.
 
         Returns:
             Dict[str, Any]: A dictionary containing ordered nodes, ordered annotations, and the annotations matrix.
         """
         filetype = "JSON"
         # Log the loading of the JSON file
-        params.log_annotations(filepath=filepath, filetype=filetype)
+        params.log_annotations(
+            filetype=filetype, filepath=filepath, min_nodes_per_term=min_nodes_per_term
+        )
         _log_loading(filetype, filepath=filepath)
 
-        # Open and read the JSON file
-        with open(filepath, "r") as file:
+        # Load the JSON file into a dictionary
+        with open(filepath, "r", encoding="utf-8") as file:
             annotations_input = json.load(file)
 
-        # Load the annotations into the provided network
-        return load_annotations(network, annotations_input)
+        return load_annotations(network, annotations_input, min_nodes_per_term)
 
     def load_excel_annotation(
         self,
@@ -55,6 +58,7 @@ class AnnotationsIO:
         nodes_colname: str = "nodes",
         sheet_name: str = "Sheet1",
         nodes_delimiter: str = ";",
+        min_nodes_per_term: int = 2,
     ) -> Dict[str, Any]:
         """Load annotations from an Excel file and associate them with the network.
 
@@ -65,6 +69,8 @@ class AnnotationsIO:
             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').
             nodes_delimiter (str, optional): Delimiter used to separate multiple nodes within the nodes column (default is ';').
+            min_nodes_per_term (int, optional): The minimum number of network nodes required for each annotation
+                term to be included. Defaults to 2.
 
         Returns:
             Dict[str, Any]: A dictionary where each label is paired with its respective list of nodes,
@@ -72,18 +78,21 @@ class AnnotationsIO:
         """
         filetype = "Excel"
         # Log the loading of the Excel file
-        params.log_annotations(filepath=filepath, filetype=filetype)
+        params.log_annotations(
+            filetype=filetype, filepath=filepath, min_nodes_per_term=min_nodes_per_term
+        )
         _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()
+        annotations_input = annotation.set_index(label_colname)[nodes_colname].to_dict()
 
-        # Load the annotations into the provided network
-        return load_annotations(network, label_node_dict)
+        return load_annotations(network, annotations_input, min_nodes_per_term)
 
     def load_csv_annotation(
         self,
@@ -92,6 +101,7 @@ class AnnotationsIO:
         label_colname: str = "label",
         nodes_colname: str = "nodes",
         nodes_delimiter: str = ";",
+        min_nodes_per_term: int = 2,
     ) -> Dict[str, Any]:
         """Load annotations from a CSV file and associate them with the network.
 
@@ -101,6 +111,8 @@ class AnnotationsIO:
             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 ';').
+            min_nodes_per_term (int, optional): The minimum number of network nodes required for each annotation
+                term to be included. Defaults to 2.
 
         Returns:
             Dict[str, Any]: A dictionary where each label is paired with its respective list of nodes,
@@ -108,7 +120,9 @@ class AnnotationsIO:
         """
         filetype = "CSV"
         # Log the loading of the CSV file
-        params.log_annotations(filepath=filepath, filetype=filetype)
+        params.log_annotations(
+            filetype=filetype, filepath=filepath, min_nodes_per_term=min_nodes_per_term
+        )
         _log_loading(filetype, filepath=filepath)
 
         # Load the CSV file into a dictionary
@@ -116,8 +130,7 @@ class AnnotationsIO:
             filepath, label_colname, nodes_colname, delimiter=",", nodes_delimiter=nodes_delimiter
         )
 
-        # Load the annotations into the provided network
-        return load_annotations(network, annotations_input)
+        return load_annotations(network, annotations_input, min_nodes_per_term)
 
     def load_tsv_annotation(
         self,
@@ -126,6 +139,7 @@ class AnnotationsIO:
         label_colname: str = "label",
         nodes_colname: str = "nodes",
         nodes_delimiter: str = ";",
+        min_nodes_per_term: int = 2,
     ) -> Dict[str, Any]:
         """Load annotations from a TSV file and associate them with the network.
 
@@ -135,6 +149,8 @@ class AnnotationsIO:
             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 ';').
+            min_nodes_per_term (int, optional): The minimum number of network nodes required for each annotation
+                term to be included. Defaults to 2.
 
         Returns:
             Dict[str, Any]: A dictionary where each label is paired with its respective list of nodes,
@@ -142,7 +158,9 @@ class AnnotationsIO:
         """
         filetype = "TSV"
         # Log the loading of the TSV file
-        params.log_annotations(filepath=filepath, filetype=filetype)
+        params.log_annotations(
+            filetype=filetype, filepath=filepath, min_nodes_per_term=min_nodes_per_term
+        )
         _log_loading(filetype, filepath=filepath)
 
         # Load the TSV file into a dictionary
@@ -150,15 +168,18 @@ class AnnotationsIO:
             filepath, label_colname, nodes_colname, delimiter="\t", nodes_delimiter=nodes_delimiter
         )
 
-        # Load the annotations into the provided network
-        return load_annotations(network, annotations_input)
+        return load_annotations(network, annotations_input, min_nodes_per_term)
 
-    def load_dict_annotation(self, network: nx.Graph, content: Dict[str, Any]) -> Dict[str, Any]:
+    def load_dict_annotation(
+        self, network: nx.Graph, content: Dict[str, Any], min_nodes_per_term: int = 2
+    ) -> Dict[str, Any]:
         """Load annotations from a provided dictionary and convert them to a dictionary annotation.
 
         Args:
             network (NetworkX graph): The network to which the annotations are related.
             content (Dict[str, Any]): The annotations dictionary to load.
+            min_nodes_per_term (int, optional): The minimum number of network nodes required for each annotation
+                term to be included. Defaults to 2.
 
         Returns:
             Dict[str, Any]: A dictionary containing ordered nodes, ordered annotations, and the annotations matrix.
@@ -174,13 +195,8 @@ class AnnotationsIO:
         params.log_annotations(filepath="In-memory dictionary", filetype=filetype)
         _log_loading(filetype, "In-memory dictionary")
 
-        # Load the annotations into the provided network
-        annotations_dict = load_annotations(network, content)
-        # Ensure the output is a dictionary
-        if not isinstance(annotations_dict, dict):
-            raise ValueError("Expected output to be a dictionary")
-
-        return annotations_dict
+        # Load the annotations as a dictionary from the provided dictionary
+        return load_annotations(network, content, min_nodes_per_term)
 
 
 def _load_matrix_file(
@@ -203,11 +219,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

@@ -3,7 +3,9 @@ risk/log
 ~~~~~~~~
 """
 
-from .console import logger, log_header, set_global_verbosity
-from .params import Params
+from risk.log.console import logger, log_header, set_global_verbosity
+from risk.log.parameters import Params
 
+# Initialize the global parameters logger
 params = Params()
+params.initialize()

risk/log/console.py

@@ -16,8 +16,10 @@ def in_jupyter():
         shell = get_ipython().__class__.__name__
         if shell == "ZMQInteractiveShell":  # Jupyter Notebook or QtConsole
             return True
-        elif shell == "TerminalInteractiveShell":  # Terminal running IPython
+        if shell == "TerminalInteractiveShell":  # Terminal running IPython
             return False
+
+        return False  # Other type (?)
     except NameError:
         return False  # Not in Jupyter
 

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.
 
@@ -116,7 +87,7 @@ class Params:
         # Load the parameter dictionary
         params = self.load()
         # Open the file in write mode
-        with open(filepath, "w", newline="") as csv_file:
+        with open(filepath, "w", encoding="utf-8", newline="") as csv_file:
             writer = csv.writer(csv_file)
             # Write the header
             writer.writerow(["parent_key", "child_key", "value"])
@@ -128,17 +99,19 @@ 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.
 
         Args:
             filepath (str): The path where the JSON file will be saved.
         """
-        with open(filepath, "w") as json_file:
+        with open(filepath, "w", encoding="utf-8") 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.
 
@@ -148,13 +121,15 @@ class Params:
         # Load the parameter dictionary
         params = self.load()
         # Open the file in write mode
-        with open(filepath, "w") as txt_file:
+        with open(filepath, "w", encoding="utf-8") as txt_file:
             for key, value in params.items():
                 # Write the key and its corresponding value
                 txt_file.write(f"{key}: {value}\n")
             # 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.
 
@@ -186,12 +161,12 @@ def _convert_ndarray_to_list(d: Dict[str, Any]) -> Dict[str, Any]:
     if isinstance(d, dict):
         # Recursively process each value in the dictionary
         return {k: _convert_ndarray_to_list(v) for k, v in d.items()}
-    elif isinstance(d, list):
+    if isinstance(d, list):
         # Recursively process each item in the list
         return [_convert_ndarray_to_list(v) for v in d]
-    elif isinstance(d, np.ndarray):
+    if isinstance(d, np.ndarray):
         # Convert numpy arrays to lists
         return d.tolist()
-    else:
-        # Return the value unchanged if it's not a dict, List, or ndarray
-        return d
+
+    # Return the value unchanged if it's not a dict, List, or ndarray
+    return d

risk/neighborhoods/__init__.py

@@ -3,8 +3,6 @@ risk/neighborhoods
 ~~~~~~~~~~~~~~~~~~
 """
 
-from .domains import define_domains, trim_domains_and_top_annotations
-from .neighborhoods import (
-    get_network_neighborhoods,
-    process_neighborhoods,
-)
+from risk.neighborhoods.domains import define_domains, trim_domains
+from risk.neighborhoods.api import NeighborhoodsAPI
+from risk.neighborhoods.neighborhoods import process_neighborhoods