risk-network 0.0.12b0__py3-none-any.whl → 0.0.12b1__py3-none-any.whl

risk/annotations/nltk_setup.py

@@ -0,0 +1,86 @@
+"""
+risk/annotations/nltk_setup
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+"""
+
+import os
+import zipfile
+from typing import List, Tuple
+
+import nltk
+from nltk.data import find
+from nltk.data import 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

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

risk/log/console.py

@@ -0,0 +1,141 @@
+"""
+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

@@ -0,0 +1,171 @@
+"""
+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 log_header, logger
+
+# 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 self._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(self, 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: self._convert_ndarray_to_list(v) for k, v in d.items()}
+        if isinstance(d, list):
+            # Recursively process each item in the list
+            return [self._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

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