risk-network 0.0.11__py3-none-any.whl → 0.0.12b0__py3-none-any.whl

risk/annotations/io.py

@@ -1,240 +0,0 @@
-"""
-risk/annotations/io
-~~~~~~~~~~~~~~~~~~~
-"""
-
-import json
-from typing import Any, Dict
-
-import networkx as nx
-import pandas as pd
-
-from risk.annotations.annotations import load_annotations
-from risk.log import params, logger, log_header
-
-
-class AnnotationsIO:
-    """Handles the loading and exporting of annotations in various file formats.
-
-    The AnnotationsIO class provides methods to load annotations from different file types (JSON, CSV, Excel, etc.)
-    and to export parameter data to various formats like JSON, CSV, and text files.
-    """
-
-    def __init__(self):
-        pass
-
-    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(
-            filetype=filetype, filepath=filepath, min_nodes_per_term=min_nodes_per_term
-        )
-        _log_loading(filetype, filepath=filepath)
-
-        # Load the JSON file into a dictionary
-        with open(filepath, "r", encoding="utf-8") as file:
-            annotations_input = json.load(file)
-
-        return load_annotations(network, annotations_input, min_nodes_per_term)
-
-    def load_excel_annotation(
-        self,
-        network: nx.Graph,
-        filepath: str,
-        label_colname: str = "label",
-        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.
-
-        Args:
-            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').
-            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,
-                            linked to the provided network.
-        """
-        filetype = "Excel"
-        # Log the loading of the Excel file
-        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
-        annotation = pd.read_excel(filepath, sheet_name=sheet_name)
-        # Split the nodes column by the specified 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
-        annotations_input = annotation.set_index(label_colname)[nodes_colname].to_dict()
-
-        return load_annotations(network, annotations_input, min_nodes_per_term)
-
-    def load_csv_annotation(
-        self,
-        network: nx.Graph,
-        filepath: str,
-        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.
-
-        Args:
-            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 ';').
-            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,
-                            linked to the provided network.
-        """
-        filetype = "CSV"
-        # Log the loading of the CSV file
-        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
-        annotations_input = _load_matrix_file(
-            filepath, label_colname, nodes_colname, delimiter=",", nodes_delimiter=nodes_delimiter
-        )
-
-        return load_annotations(network, annotations_input, min_nodes_per_term)
-
-    def load_tsv_annotation(
-        self,
-        network: nx.Graph,
-        filepath: str,
-        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.
-
-        Args:
-            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 ';').
-            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,
-                            linked to the provided network.
-        """
-        filetype = "TSV"
-        # Log the loading of the TSV file
-        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
-        annotations_input = _load_matrix_file(
-            filepath, label_colname, nodes_colname, delimiter="\t", nodes_delimiter=nodes_delimiter
-        )
-
-        return load_annotations(network, annotations_input, min_nodes_per_term)
-
-    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.
-        """
-        # Ensure the input content is a dictionary
-        if not isinstance(content, dict):
-            raise TypeError(
-                f"Expected 'content' to be a dictionary, but got {type(content).__name__} instead."
-            )
-
-        filetype = "Dictionary"
-        # Log the loading of the annotations from the dictionary
-        params.log_annotations(filepath="In-memory dictionary", filetype=filetype)
-        _log_loading(filetype, "In-memory dictionary")
-
-        # Load the annotations as a dictionary from the provided dictionary
-        return load_annotations(network, content, min_nodes_per_term)
-
-
-def _load_matrix_file(
-    filepath: str,
-    label_colname: str,
-    nodes_colname: str,
-    delimiter: str = ",",
-    nodes_delimiter: str = ";",
-) -> Dict[str, Any]:
-    """Load annotations from a CSV or TSV file and convert them to a dictionary.
-
-    Args:
-        filepath (str): Path to the annotation 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.
-        delimiter (str, optional): Delimiter used to separate columns in the file (default is ',').
-        nodes_delimiter (str, optional): Delimiter used to separate multiple nodes within the nodes column (default is ';').
-
-    Returns:
-        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
-    annotation = pd.read_csv(filepath, delimiter=delimiter)
-    # Split the nodes column by the nodes_delimiter to handle multiple nodes per label
-    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 = annotation.set_index(label_colname)[nodes_colname].to_dict()
-    return label_node_dict
-
-
-def _log_loading(filetype: str, filepath: str = "") -> None:
-    """Log information about the network file being loaded.
-
-    Args:
-        filetype (str): The type of the file being loaded (e.g., 'Cytoscape').
-        filepath (str, optional): The path to the file being loaded.
-    """
-    log_header("Loading annotations")
-    logger.debug(f"Filetype: {filetype}")
-    if filepath:
-        logger.debug(f"Filepath: {filepath}")

risk/annotations/nltk_setup.py

@@ -1,85 +0,0 @@
-"""
-risk/annotations/nltk_setup
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-"""
-
-import os
-import zipfile
-from typing import List, Tuple
-
-import nltk
-from nltk.data import find, path as nltk_data_path
-
-from risk.log import logger
-
-
-def setup_nltk_resources(required_resources: List[Tuple[str, str]] = None) -> None:
-    """Ensures all required NLTK resources are available and properly extracted.
-    Uses NLTK's default paths and mechanisms.
-
-    Args:
-        required_resources (List[Tuple[str, str]], optional): List of required resources
-            to download and extract. Each tuple should contain the resource path within
-            NLTK data and the package name. Defaults to None.
-    """
-    if required_resources is None:
-        required_resources = [
-            ("tokenizers/punkt", "punkt"),
-            ("tokenizers/punkt_tab", "punkt_tab"),
-            ("corpora/stopwords", "stopwords"),
-            ("corpora/wordnet", "wordnet"),
-        ]
-
-    # Process each resource
-    for resource_path, package_name in required_resources:
-        try:
-            # First try to find the resource - this is how NLTK checks if it's available
-            find(resource_path)
-        except LookupError:
-            # Resource not found, download it
-            logger.info(f"Downloading missing NLTK resource: {package_name}")
-            nltk.download(package_name, quiet=True)
-
-        # Even if find() succeeded, the resource might be a zip that failed to extract
-        # Check if we need to manually extract zips
-        verify_and_extract_if_needed(resource_path, package_name)
-
-
-def verify_and_extract_if_needed(resource_path: str, package_name: str) -> None:
-    """Verifies if the resource is properly extracted and extracts if needed. Respects
-    NLTK's directory structure where the extracted content should be in the same directory
-    as the zip file.
-
-    Args:
-        resource_path (str): Path to the resource within NLTK data.
-        package_name (str): Name of the NLTK package.
-    """
-    # Get the directory and base name from the resource path
-    path_parts = resource_path.split("/")
-    resource_type = path_parts[0]  # 'corpora', 'tokenizers', etc.
-    resource_name = path_parts[-1]  # 'wordnet', 'punkt', etc.
-
-    # Check all NLTK data directories
-    for base in nltk_data_path:
-        # For resource paths like 'corpora/wordnet', the zip file is at '~/nltk_data/corpora/wordnet.zip'
-        # and the extracted directory should be at '~/nltk_data/corpora/wordnet'
-        resource_dir = os.path.join(base, resource_type)
-        zip_path = os.path.join(resource_dir, f"{resource_name}.zip")
-        folder_path = os.path.join(resource_dir, resource_name)
-
-        # If zip exists but folder doesn't, extraction is needed
-        if os.path.exists(zip_path) and not os.path.exists(folder_path):
-            logger.info(f"Found unextracted zip for {package_name}, extracting...")
-            try:
-                with zipfile.ZipFile(zip_path, "r") as zf:
-                    # Extract files to the same directory where the zip file is located
-                    zf.extractall(path=resource_dir)
-
-                if os.path.exists(folder_path):
-                    logger.info(f"Successfully extracted {package_name}")
-                else:
-                    logger.warning(
-                        f"Extraction completed but resource directory not found for {package_name}"
-                    )
-            except Exception as e:
-                logger.error(f"Failed to extract {package_name}: {e}")

risk/log/__init__.py

@@ -1,11 +0,0 @@
-"""
-risk/log
-~~~~~~~~
-"""
-
-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

@@ -1,141 +0,0 @@
-"""
-risk/log/console
-~~~~~~~~~~~~~~~~
-"""
-
-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
-        if shell == "TerminalInteractiveShell":  # Terminal running IPython
-            return False
-
-        return False  # Other type (?)
-    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/log/parameters.py

@@ -1,172 +0,0 @@
-"""
-risk/log/parameters
-~~~~~~~~~~~~~~~~~~~
-"""
-
-import csv
-import json
-import warnings
-from datetime import datetime
-from typing import Any, Dict
-
-import numpy as np
-
-from risk.log.console import logger, log_header
-
-# Suppress all warnings - this is to resolve warnings from multiprocessing
-warnings.filterwarnings("ignore")
-
-
-class Params:
-    """Handles the storage and logging of various parameters for network analysis.
-
-    The Params class provides methods to log parameters related to different components of the analysis,
-    such as the network, annotations, neighborhoods, graph, and plotter settings. It also stores
-    the current datetime when the parameters were initialized.
-    """
-
-    def __init__(self):
-        """Initialize the Params object with default settings and current datetime."""
-        self.initialize()
-        self.datetime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-    def initialize(self) -> None:
-        """Initialize the parameter dictionaries for different components."""
-        self.network = {}
-        self.annotations = {}
-        self.neighborhoods = {}
-        self.graph = {}
-        self.plotter = {}
-
-    def log_network(self, **kwargs) -> None:
-        """Log network-related parameters.
-
-        Args:
-            **kwargs: Network parameters to log.
-        """
-        self.network = {**self.network, **kwargs}
-
-    def log_annotations(self, **kwargs) -> None:
-        """Log annotation-related parameters.
-
-        Args:
-            **kwargs: Annotation parameters to log.
-        """
-        self.annotations = {**self.annotations, **kwargs}
-
-    def log_neighborhoods(self, **kwargs) -> None:
-        """Log neighborhood-related parameters.
-
-        Args:
-            **kwargs: Neighborhood parameters to log.
-        """
-        self.neighborhoods = {**self.neighborhoods, **kwargs}
-
-    def log_graph(self, **kwargs) -> None:
-        """Log graph-related parameters.
-
-        Args:
-            **kwargs: Graph parameters to log.
-        """
-        self.graph = {**self.graph, **kwargs}
-
-    def log_plotter(self, **kwargs) -> None:
-        """Log plotter-related parameters.
-
-        Args:
-            **kwargs: Plotter parameters to log.
-        """
-        self.plotter = {**self.plotter, **kwargs}
-
-    def to_csv(self, filepath: str) -> None:
-        """Export the parameters to a CSV file.
-
-        Args:
-            filepath (str): The path where the CSV file will be saved.
-        """
-        # Load the parameter dictionary
-        params = self.load()
-        # Open the file in write mode
-        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"])
-            # Write the rows
-            for parent_key, parent_value in params.items():
-                if isinstance(parent_value, dict):
-                    for child_key, child_value in parent_value.items():
-                        writer.writerow([parent_key, child_key, child_value])
-                else:
-                    writer.writerow([parent_key, "", parent_value])
-
-        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", encoding="utf-8") as json_file:
-            json.dump(self.load(), json_file, indent=4)
-
-        logger.info(f"Parameters exported to JSON file: {filepath}")
-
-    def to_txt(self, filepath: str) -> None:
-        """Export the parameters to a text file.
-
-        Args:
-            filepath (str): The path where the text file will be saved.
-        """
-        # Load the parameter dictionary
-        params = self.load()
-        # Open the file in write mode
-        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.
-
-        Returns:
-            Dict[str, Any]: A dictionary containing the processed parameters.
-        """
-        log_header("Loading parameters")
-        return _convert_ndarray_to_list(
-            {
-                "annotations": self.annotations,
-                "datetime": self.datetime,
-                "graph": self.graph,
-                "neighborhoods": self.neighborhoods,
-                "network": self.network,
-                "plotter": self.plotter,
-            }
-        )
-
-
-def _convert_ndarray_to_list(d: Dict[str, Any]) -> Dict[str, Any]:
-    """Recursively convert all np.ndarray values in the dictionary to lists.
-
-    Args:
-        d (Dict[str, Any]): The dictionary to process.
-
-    Returns:
-        Dict[str, Any]: The processed dictionary with np.ndarray values converted to lists.
-    """
-    if isinstance(d, dict):
-        # Recursively process each value in the dictionary
-        return {k: _convert_ndarray_to_list(v) for k, v in d.items()}
-    if isinstance(d, list):
-        # Recursively process each item in the list
-        return [_convert_ndarray_to_list(v) for v in d]
-    if isinstance(d, np.ndarray):
-        # Convert numpy arrays to lists
-        return d.tolist()
-
-    # Return the value unchanged if it's not a dict, List, or ndarray
-    return d

risk/neighborhoods/__init__.py

@@ -1,8 +0,0 @@
-"""
-risk/neighborhoods
-~~~~~~~~~~~~~~~~~~
-"""
-
-from risk.neighborhoods.domains import define_domains, trim_domains
-from risk.neighborhoods.api import NeighborhoodsAPI
-from risk.neighborhoods.neighborhoods import process_neighborhoods