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

risk/network/plotter/network.py

@@ -94,10 +94,10 @@ class Network:
         # Draw the nodes of the graph
         nx.draw_networkx_nodes(
             self.graph.network,
-            pos=node_coordinates,
+            pos=node_coordinates.tolist(),
             node_size=node_size,
             node_shape=node_shape,
-            node_color=node_color_rgba,
+            node_color=node_color_rgba.tolist(),
             edgecolors=node_edgecolor_rgba,
             linewidths=node_edgewidth,
             ax=self.ax,
@@ -105,9 +105,9 @@ class Network:
         # Draw the edges of the graph
         nx.draw_networkx_edges(
             self.graph.network,
-            pos=node_coordinates,
+            pos=node_coordinates.tolist(),
             width=edge_width,
-            edge_color=edge_color_rgba,
+            edge_color=edge_color_rgba.tolist(),
             ax=self.ax,
         )
 
@@ -181,7 +181,7 @@ class Network:
             nodelist=node_ids,
             node_size=node_size,
             node_shape=node_shape,
-            node_color=node_color_rgba,
+            node_color=node_color_rgba.tolist(),
             edgecolors=node_edgecolor_rgba,
             linewidths=node_edgewidth,
             ax=self.ax,
@@ -192,7 +192,7 @@ class Network:
             subgraph,
             pos=node_coordinates,
             width=edge_width,
-            edge_color=edge_color_rgba,
+            edge_color=edge_color_rgba.tolist(),
             ax=self.ax,
         )
 

risk/network/plotter/plotter.py

@@ -29,7 +29,7 @@ class Plotter(Canvas, Network, Contour, Labels):
     def __init__(
         self,
         graph: Graph,
-        figsize: Tuple = (10, 10),
+        figsize: Union[List, Tuple, np.ndarray] = (10, 10),
         background_color: Union[str, List, Tuple, np.ndarray] = "white",
         background_alpha: Union[float, None] = 1.0,
         pad: float = 0.3,
@@ -38,7 +38,7 @@ class Plotter(Canvas, Network, Contour, Labels):
 
         Args:
             graph (Graph): The network data and attributes to be visualized.
-            figsize (Tuple, optional): Size of the figure in inches (width, height). Defaults to (10, 10).
+            figsize (List, Tuple, np.ndarray, optional): Size of the figure in inches (width, height). Defaults to (10, 10).
             background_color (str, List, Tuple, np.ndarray, optional): Background color of the plot. Defaults to "white".
             background_alpha (float, None, optional): Transparency level of the background color. If provided, it overrides
                 any existing alpha values found in background_color. Defaults to 1.0.
@@ -58,7 +58,7 @@ class Plotter(Canvas, Network, Contour, Labels):
     def _initialize_plot(
         self,
         graph: Graph,
-        figsize: Tuple,
+        figsize: Union[List, Tuple, np.ndarray],
         background_color: Union[str, List, Tuple, np.ndarray],
         background_alpha: Union[float, None],
         pad: float,
@@ -67,7 +67,7 @@ class Plotter(Canvas, Network, Contour, Labels):
 
         Args:
             graph (Graph): The network data and attributes to be visualized.
-            figsize (Tuple): Size of the figure in inches (width, height).
+            figsize (List, Tuple, np.ndarray, optional): Size of the figure in inches (width, height). Defaults to (10, 10).
             background_color (str, List, Tuple, or np.ndarray): Background color of the plot. Can be a single color or an array of colors.
             background_alpha (float, None, optional): Transparency level of the background color. If provided, it overrides any existing
                 alpha values found in `background_color`.
@@ -93,8 +93,8 @@ class Plotter(Canvas, Network, Contour, Labels):
         fig, ax = plt.subplots(figsize=figsize)
         fig.tight_layout()  # Adjust subplot parameters to give specified padding
         # Set axis limits based on the calculated bounding box and radius
-        ax.set_xlim([center[0] - radius - pad, center[0] + radius + pad])
-        ax.set_ylim([center[1] - radius - pad, center[1] + radius + pad])
+        ax.set_xlim((float(center[0] - radius - pad), float(center[0] + radius + pad)))
+        ax.set_ylim((float(center[1] - radius - pad), float(center[1] + radius + pad)))
         ax.set_aspect("equal")  # Ensure the aspect ratio is equal
 
         # Set the background color of the plot
@@ -114,8 +114,7 @@ class Plotter(Canvas, Network, Contour, Labels):
 
         return ax
 
-    @staticmethod
-    def savefig(*args, pad_inches: float = 0.5, dpi: int = 100, **kwargs) -> None:
+    def savefig(self, *args, pad_inches: float = 0.5, dpi: int = 100, **kwargs) -> None:
         """Save the current plot to a file with additional export options.
 
         Args:
@@ -132,8 +131,7 @@ class Plotter(Canvas, Network, Contour, Labels):
         # Call plt.savefig with combined arguments
         plt.savefig(*args, **kwargs)
 
-    @staticmethod
-    def show(*args, **kwargs) -> None:
+    def show(self, *args, **kwargs) -> None:
         """Display the current plot.
 
         Args:

risk/network/plotter/utils/colors.py

@@ -23,8 +23,8 @@ def get_annotated_domain_colors(
     scale_factor: float = 1.0,
     ids_to_colors: Union[Dict[int, Any], None] = None,
     random_seed: int = 888,
-) -> np.ndarray:
-    """Get colors for the domains based on node annotations, or use a specified color.
+) -> List[Tuple]:
+    """Get colors for the domains based on node annotation, or use a specified color.
 
     Args:
         graph (Graph): The network data and attributes to be visualized.
@@ -41,7 +41,7 @@ def get_annotated_domain_colors(
         random_seed (int, optional): Seed for random number generation to ensure reproducibility. Defaults to 888.
 
     Returns:
-        np.ndarray: Array of RGBA colors for each domain.
+        List[Tuple]: List of RGBA colors for each domain, based on significance or the specified color.
     """
     # Generate domain colors based on the significance data
     node_colors = get_domain_colors(
@@ -61,10 +61,12 @@ def get_annotated_domain_colors(
         if len(node_ids) > 1:
             # For multi-node domains, choose the brightest color based on RGB sum
             domain_colors = np.array([node_colors[node] for node in node_ids])
-            color = domain_colors[np.argmax(domain_colors[:, :3].sum(axis=1))]  # Sum the RGB values
+            color = tuple(
+                domain_colors[np.argmax(domain_colors[:, :3].sum(axis=1))]
+            )  # Sum the RGB values
         else:
             # Single-node domains default to white (RGBA)
-            color = np.array([1.0, 1.0, 1.0, 1.0])
+            color = tuple([1.0, 1.0, 1.0, 1.0])
 
         annotated_colors.append(color)
 
@@ -202,7 +204,7 @@ def _get_composite_node_colors(
             significances = node_info["significances"]  # List of significance values
             # Filter domains and significances to keep only those with corresponding colors in domain_ids_to_colors
             filtered_domains_significances = [
-                (domain_id, significance)
+                (domain_id, float(significance))
                 for domain_id, significance in zip(domains, significances)
                 if domain_id in domain_ids_to_colors
             ]
@@ -216,7 +218,9 @@ def _get_composite_node_colors(
             colors = [domain_ids_to_colors[domain_id] for domain_id in filtered_domains]
             # Blend the colors using the given gamma (default is 2.2 if None)
             gamma = blend_gamma if blend_gamma is not None else 2.2
-            composite_color = _blend_colors_perceptually(colors, filtered_significances, gamma)
+            composite_color = _blend_colors_perceptually(
+                colors, list(filtered_significances), gamma
+            )
             # Assign the composite color to the node
             composite_colors[node] = composite_color
 
@@ -246,7 +250,7 @@ def _get_colors(
     if color:
         # If a single color is specified, apply it to all domains
         rgba = to_rgba(color, num_repeats=num_domains)
-        return rgba
+        return list(rgba)
 
     # Load colormap and generate a large, maximally separated set of colors
     colormap = matplotlib.colormaps.get_cmap(cmap)
@@ -356,6 +360,9 @@ def to_rgba(
 
     Returns:
         np.ndarray: Array of RGBA colors repeated `num_repeats` times, if applicable.
+
+    Raises:
+        ValueError: If the provided color format is invalid or cannot be converted to RGBA.
     """
 
     def convert_to_rgba(c: Union[str, List, Tuple, np.ndarray]) -> np.ndarray:

risk/network/plotter/utils/layout.py

@@ -11,7 +11,7 @@ import numpy as np
 
 def calculate_bounding_box(
     node_coordinates: np.ndarray, radius_margin: float = 1.05
-) -> Tuple[np.ndarray, float]:
+) -> Tuple[Tuple, float]:
     """Calculate the bounding box of the network based on node coordinates.
 
     Args:
@@ -19,13 +19,13 @@ def calculate_bounding_box(
         radius_margin (float, optional): Margin factor to apply to the bounding box radius. Defaults to 1.05.
 
     Returns:
-        tuple: Center of the bounding box and the radius (adjusted by the radius margin).
+        Tuple[Tuple, float]: Center (x, y) and radius of the bounding box.
     """
     # Find minimum and maximum x, y coordinates
     x_min, y_min = np.min(node_coordinates, axis=0)
     x_max, y_max = np.max(node_coordinates, axis=0)
     # Calculate the center of the bounding box
-    center = np.array([(x_min + x_max) / 2, (y_min + y_max) / 2])
+    center = ((x_min + x_max) / 2, (y_min + y_max) / 2)
     # Calculate the radius of the bounding box, adjusted by the margin
     radius = max(x_max - x_min, y_max - y_min) / 2 * radius_margin
     return center, radius

risk/risk.py

@@ -3,15 +3,15 @@ risk/risk
 ~~~~~~~~~
 """
 
-from risk.annotations import AnnotationsIO
+from risk.annotation.io import AnnotationIO
 from risk.log import params, set_global_verbosity
-from risk.neighborhoods import NeighborhoodsAPI
-from risk.network import NetworkIO
-from risk.network.graph import GraphAPI
-from risk.network.plotter import PlotterAPI
+from risk.neighborhoods.api import NeighborhoodsAPI
+from risk.network.graph.api import GraphAPI
+from risk.network.io import NetworkIO
+from risk.network.plotter.api import PlotterAPI
 
 
-class RISK(NetworkIO, AnnotationsIO, NeighborhoodsAPI, GraphAPI, PlotterAPI):
+class RISK(NetworkIO, AnnotationIO, NeighborhoodsAPI, GraphAPI, PlotterAPI):
     """RISK: A class for network analysis and visualization.
 
     The RISK class integrates functionalities for loading networks, processing annotations,

risk_network-0.0.12.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: risk-network
+Version: 0.0.12
+Summary: A Python package for biological network analysis
+Author-email: Ira Horecka <ira89@icloud.com>
+License: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/riskportal/network
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ipywidgets
+Requires-Dist: leidenalg
+Requires-Dist: markov_clustering
+Requires-Dist: matplotlib
+Requires-Dist: networkx
+Requires-Dist: nltk
+Requires-Dist: numpy
+Requires-Dist: openpyxl
+Requires-Dist: pandas
+Requires-Dist: python-igraph
+Requires-Dist: python-louvain
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: statsmodels
+Requires-Dist: threadpoolctl
+Requires-Dist: tqdm
+Dynamic: license-file
+
+# RISK Network
+
+<p align="center">
+  <img src="https://i.imgur.com/8TleEJs.png" width="50%" />
+</p>
+
+<br>
+
+![Python](https://img.shields.io/badge/python-3.8%2B-yellow)
+[![pypiv](https://img.shields.io/pypi/v/risk-network.svg)](https://pypi.python.org/pypi/risk-network)
+![License](https://img.shields.io/badge/license-GPLv3-purple)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.xxxxxxx.svg)](https://doi.org/10.5281/zenodo.xxxxxxx)
+![Downloads](https://img.shields.io/pypi/dm/risk-network)
+![Tests](https://github.com/riskportal/network/actions/workflows/ci.yml/badge.svg)
+
+**RISK** (Regional Inference of Significant Kinships) is a next-generation tool for biological network annotation and visualization. RISK integrates community detection-based clustering, rigorous statistical enrichment analysis, and a modular framework to uncover biologically meaningful relationships and generate high-resolution visualizations. RISK supports diverse data formats and is optimized for large-scale network analysis, making it a valuable resource for researchers in systems biology and beyond.
+
+## Documentation and Tutorial
+
+Full documentation is available at:
+
+- **Docs:** [https://riskportal.github.io/network-tutorial](https://riskportal.github.io/network-tutorial)  
+- **Tutorial Jupyter Notebook Repository:** [https://github.com/riskportal/network-tutorial](https://github.com/riskportal/network-tutorial)
+
+## Installation
+
+RISK is compatible with Python 3.8 or later and runs on all major operating systems. To install the latest version of RISK, run:
+
+```bash
+pip install risk-network --upgrade
+```
+
+## Features
+
+- **Comprehensive Network Analysis**: Analyze biological networks (e.g., protein–protein interaction and genetic interaction networks) as well as non-biological networks.
+- **Advanced Clustering Algorithms**: Supports Louvain, Leiden, Markov Clustering, Greedy Modularity, Label Propagation, Spinglass, and Walktrap for identifying structured network regions.
+- **Flexible Visualization**: Produce customizable, high-resolution network visualizations with kernel density estimate overlays, adjustable node and edge attributes, and export options in SVG, PNG, and PDF formats.
+- **Efficient Data Handling**: Supports multiple input/output formats, including JSON, CSV, TSV, Excel, Cytoscape, and GPickle.
+- **Statistical Analysis**: Assess functional enrichment using hypergeometric, permutation (network-aware), binomial, chi-squared, Poisson, and z-score tests, ensuring statistical adaptability across datasets.
+- **Cross-Domain Applicability**: Suitable for network analysis across biological and non-biological domains, including social and communication networks.
+
+## Example Usage
+
+We applied RISK to a *Saccharomyces cerevisiae* protein–protein interaction network from Michaelis et al. (2023), filtering for proteins with six or more interactions to emphasize core functional relationships. RISK identified compact, statistically enriched clusters corresponding to biological processes such as ribosomal assembly and mitochondrial organization.
+
+[![Figure 1](https://i.imgur.com/lJHJrJr.jpeg)](https://i.imgur.com/lJHJrJr.jpeg)
+
+This figure highlights RISK’s capability to detect both established and novel functional modules within the yeast interactome.
+
+## Citation
+
+If you use RISK in your research, please cite:
+
+**Horecka et al.**, "RISK: a next-generation tool for biological network annotation and visualization", **Bioinformatics**, 2025. DOI: [10.1234/zenodo.xxxxxxx](https://doi.org/10.1234/zenodo.xxxxxxx)
+
+## Software Architecture and Implementation
+
+RISK features a streamlined, modular architecture designed to meet diverse research needs. RISK’s modular design enables users to run individual components—such as clustering, statistical testing, or visualization—independently or in combination, depending on the analysis workflow. It includes dedicated modules for:
+
+- **Data I/O**: Supports JSON, CSV, TSV, Excel, Cytoscape, and GPickle formats.
+- **Clustering**: Supports multiple clustering methods, including Louvain, Leiden, Markov Clustering, Greedy Modularity, Label Propagation, Spinglass, and Walktrap. Provides flexible distance metrics tailored to network structure.
+- **Statistical Analysis**: Provides a suite of tests for overrepresentation analysis of annotations.
+- **Visualization**: Offers customizable, high-resolution output in multiple formats, including SVG, PNG, and PDF.
+- **Configuration Management**: Centralized parameters in risk.params ensure reproducibility and easy tuning for large-scale analyses.
+
+## Performance and Efficiency
+
+Benchmarking results demonstrate that RISK efficiently scales to networks exceeding hundreds of thousands of edges, maintaining low execution times and optimal memory usage across statistical tests.
+
+## Contributing
+
+We welcome contributions from the community:
+
+- [Issues Tracker](https://github.com/riskportal/network/issues)
+- [Source Code](https://github.com/riskportal/network/tree/main/risk)
+
+## Support
+
+If you encounter issues or have suggestions for new features, please use the [Issues Tracker](https://github.com/riskportal/network/issues) on GitHub.
+
+## License
+
+RISK is open source under the [GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html).

risk_network-0.0.12.dist-info/RECORD

@@ -0,0 +1,40 @@
+risk/__init__.py,sha256=-5Lvlnij5rJO1Sh2goXIrvMz_vJ6BhKt65-zF7EbeQU,120
+risk/risk.py,sha256=Wjuxob5bI70Tpz9t71i05g94AQ3qXEMjfEcm5IV9HSY,1118
+risk/annotation/__init__.py,sha256=1EbGo41ClQb5ESTtitjOhrZhaLzzwr5aT-RYDX8w-h4,185
+risk/annotation/annotation.py,sha256=OE859FpVnp69hDi1cN_CQqeiG0SrJ2ZCuIdQKzY-gt0,14675
+risk/annotation/io.py,sha256=iffCXePQuMluytYQDg5tbu34g9ZsCUq1H4j-z-W25lE,10695
+risk/annotation/nltk_setup.py,sha256=14B6L56_dwIgAOC9Rl4dNd4-b-aEngUCoJP9L9kEilU,3572
+risk/log/__init__.py,sha256=en-hKzuFtQWos4oZd8PxJ9u9Pe5bdihiqH9-qk_5ppw,217
+risk/log/console.py,sha256=PgjyEvyhYLUSHXPUKEqOmxsDsfrjPICIgqo_cAHq0N8,4575
+risk/log/parameters.py,sha256=FnP-kdg0Kip0SyxFEn7su7BG51FbMtTfm3Rk96cnCoc,5801
+risk/neighborhoods/__init__.py,sha256=CNS0VNbh_IdxldXjDkPqeTrxgY4hqi_Tc_MTADW_tzQ,182
+risk/neighborhoods/api.py,sha256=TXbjbHfQDi2eZeD9086BBsUjhDiJq2BNEYALiGs_rPc,23299
+risk/neighborhoods/community.py,sha256=0YdTh6wgMLiGMdtlaD7Vu_uxOVoZ9vDBjxbkglkrTV8,17808
+risk/neighborhoods/domains.py,sha256=9cWcGYGALcYruvAjWKztnEZlnYyT6DSoAPP6VsgA2wQ,14601
+risk/neighborhoods/neighborhoods.py,sha256=ykJu2d0Z6gRCOAMyBtpWpxXQ2Dei4nOv7w3XN0LpiX8,21672
+risk/neighborhoods/stats/__init__.py,sha256=1evLEAa7trCWj2DapCV4vW_f0zsyKHqTsn4--E_fDPg,306
+risk/neighborhoods/stats/tests.py,sha256=Z14H8G2qHzM5AOhKqp4YfCOL_wp3QwzUzfeGQJOqTTU,12060
+risk/neighborhoods/stats/permutation/__init__.py,sha256=V-uLSoi4SIPKjSRl7rhcDR4HJ4tquAn3QxNTXH9KzK8,169
+risk/neighborhoods/stats/permutation/permutation.py,sha256=k9-Yw-1wWBqeD9cGcTh_d2ypqN-HzoJrcCEAR5-BK0o,10673
+risk/neighborhoods/stats/permutation/test_functions.py,sha256=Wuop4WDY3foGeKp-hMGc2Gdqf85s-x9BDXGB8ifp0oE,3147
+risk/network/__init__.py,sha256=C9GisdyJM7fizwUIipy1vC4lbry9ceqLn1iBcW0-mZg,34
+risk/network/io.py,sha256=1JViOU1YY0DgRP-dK-n-Tkj2ZrpVJJm4vq-5mzvK7kM,27856
+risk/network/graph/__init__.py,sha256=iG6IlE8xtAyF6_NuCBUpsJrjrjd1vsXO1Ajsr0K8EA0,46
+risk/network/graph/api.py,sha256=gXheVl1xw7vFDHOOQdRxCFwVy4ajEJ1dk4GQxm13sCI,8528
+risk/network/graph/graph.py,sha256=jPNJea9JiLKedGFvSKmZ5Kf2R9go0HJkZ4wYNJwZRJI,12410
+risk/network/graph/stats.py,sha256=xITodchaF8Pgngynil_GM9IeMBtxuraPX-Gjp6WBEMY,7338
+risk/network/graph/summary.py,sha256=UZvZk5w2BZ5zs8IDfr-YYYBr2eM1wmXh0FKp_p9UdB4,10260
+risk/network/plotter/__init__.py,sha256=9kdeONe8NaJvJ5FO7eOdZiobqL4CeR7q2MghG4z6Kt8,50
+risk/network/plotter/api.py,sha256=GFP0n_0-tSdCZQd6cuaH3w55953sXCR02nwyJhAEqK4,1789
+risk/network/plotter/canvas.py,sha256=i8i-ARLCNsHkAW3W_E63PpbEjmQLJplpqK6mSivgz4k,13610
+risk/network/plotter/contour.py,sha256=TJA4C9G07iFBBSuSCYGZJ6NZfXGWH8zVw0LC2eqU3JA,15540
+risk/network/plotter/labels.py,sha256=89Ege5NkfFMZJXw_mF-rhtIPa4-S8UKtYSkj8ty_VeQ,46805
+risk/network/plotter/network.py,sha256=c9rPQ5mjil0sxVQnprRaKMAUqT6PZmKiATWz0m-TvQU,14185
+risk/network/plotter/plotter.py,sha256=WZcOrBW3vBQ_aLwv8c8pXJO8ZlyswHHHfEsiLxzEYaI,6121
+risk/network/plotter/utils/colors.py,sha256=xZt4877ORTQqySiMh-tUGe0sXvhLbXO04iGNeBDkbbw,19144
+risk/network/plotter/utils/layout.py,sha256=Lty16T-Q-oWwo9fXqm-nnS_dMS3BMhuFt4SFqxFC3Ng,3610
+risk_network-0.0.12.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.12.dist-info/METADATA,sha256=pbVTDf2xW6i7C9XYpJgk7YituPyoC5KDjMcvyb3J3bs,6665
+risk_network-0.0.12.dist-info/WHEEL,sha256=ooBFpIzZCPdw3uqIQsOo4qqbA4ZRPxHnOH7peeONza0,91
+risk_network-0.0.12.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.12.dist-info/RECORD,,

{risk_network-0.0.11.dist-info → risk_network-0.0.12.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (80.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

risk/annotations/__init__.py

@@ -1,7 +0,0 @@
-"""
-risk/annotations
-~~~~~~~~~~~~~~~~
-"""
-
-from risk.annotations.annotations import define_top_annotations, get_weighted_description
-from risk.annotations.io import AnnotationsIO

risk/network/geometry.py

@@ -1,150 +0,0 @@
-"""
-risk/network/geometry
-~~~~~~~~~~~~~~~~~~~~~
-"""
-
-import networkx as nx
-import numpy as np
-
-
-def assign_edge_lengths(
-    G: nx.Graph,
-    compute_sphere: bool = True,
-    surface_depth: float = 0.0,
-) -> nx.Graph:
-    """Assign edge lengths in the graph, optionally mapping nodes to a sphere.
-
-    Args:
-        G (nx.Graph): The input graph.
-        compute_sphere (bool): Whether to map nodes to a sphere. Defaults to True.
-        surface_depth (float): The surface depth for mapping to a sphere. Defaults to 0.0.
-
-    Returns:
-        nx.Graph: The graph with applied edge lengths.
-    """
-
-    def compute_distance_vectorized(coords, is_sphere):
-        """Compute distances between pairs of coordinates."""
-        u_coords, v_coords = coords[:, 0, :], coords[:, 1, :]
-        if is_sphere:
-            u_coords /= np.linalg.norm(u_coords, axis=1, keepdims=True)
-            v_coords /= np.linalg.norm(v_coords, axis=1, keepdims=True)
-            dot_products = np.einsum("ij,ij->i", u_coords, v_coords)
-            return np.arccos(np.clip(dot_products, -1.0, 1.0))
-        return np.linalg.norm(u_coords - v_coords, axis=1)
-
-    # Normalize graph coordinates
-    _normalize_graph_coordinates(G)
-
-    # Map nodes to sphere and adjust depth if required
-    if compute_sphere:
-        _map_to_sphere(G)
-        G_depth = _create_depth(G, surface_depth=surface_depth)
-    else:
-        G_depth = G
-
-    # Precompute edge coordinate arrays and compute distances in bulk
-    edge_data = np.array(
-        [
-            [
-                np.array(
-                    [G_depth.nodes[u]["x"], G_depth.nodes[u]["y"], G_depth.nodes[u].get("z", 0)]
-                ),
-                np.array(
-                    [G_depth.nodes[v]["x"], G_depth.nodes[v]["y"], G_depth.nodes[v].get("z", 0)]
-                ),
-            ]
-            for u, v in G_depth.edges
-        ]
-    )
-    # Compute distances
-    distances = compute_distance_vectorized(edge_data, compute_sphere)
-    # Assign distances back to the graph
-    for (u, v), distance in zip(G_depth.edges, distances):
-        G.edges[u, v]["length"] = distance
-
-    return G
-
-
-def _map_to_sphere(G: nx.Graph) -> None:
-    """Map the x and y coordinates of graph nodes onto a 3D sphere.
-
-    Args:
-        G (nx.Graph): The input graph with nodes having 'x' and 'y' coordinates.
-    """
-    # Extract x, y coordinates as a NumPy array
-    nodes = list(G.nodes)
-    xy_coords = np.array([[G.nodes[node]["x"], G.nodes[node]["y"]] for node in nodes])
-    # Normalize coordinates between [0, 1]
-    min_vals = xy_coords.min(axis=0)
-    max_vals = xy_coords.max(axis=0)
-    normalized_xy = (xy_coords - min_vals) / (max_vals - min_vals)
-    # Convert normalized coordinates to spherical coordinates
-    theta = normalized_xy[:, 0] * np.pi * 2
-    phi = normalized_xy[:, 1] * np.pi
-    # Compute 3D Cartesian coordinates
-    x = np.sin(phi) * np.cos(theta)
-    y = np.sin(phi) * np.sin(theta)
-    z = np.cos(phi)
-    # Assign coordinates back to graph nodes in bulk
-    xyz_coords = {node: {"x": x[i], "y": y[i], "z": z[i]} for i, node in enumerate(nodes)}
-    nx.set_node_attributes(G, xyz_coords)
-
-
-def _normalize_graph_coordinates(G: nx.Graph) -> None:
-    """Normalize the x and y coordinates of the nodes in the graph to the [0, 1] range.
-
-    Args:
-        G (nx.Graph): The input graph with nodes having 'x' and 'y' coordinates.
-    """
-    # Extract x, y coordinates from the graph nodes
-    xy_coords = np.array([[G.nodes[node]["x"], G.nodes[node]["y"]] for node in G.nodes()])
-    # Calculate min and max values for x and y
-    min_vals = np.min(xy_coords, axis=0)
-    max_vals = np.max(xy_coords, axis=0)
-    # Normalize the coordinates to [0, 1]
-    normalized_xy = (xy_coords - min_vals) / (max_vals - min_vals)
-    # Update the node coordinates with the normalized values
-    for i, node in enumerate(G.nodes()):
-        G.nodes[node]["x"], G.nodes[node]["y"] = normalized_xy[i]
-
-
-def _create_depth(G: nx.Graph, surface_depth: float = 0.0) -> nx.Graph:
-    """Adjust the 'z' attribute of each node based on the subcluster strengths and normalized surface depth.
-
-    Args:
-        G (nx.Graph): The input graph.
-        surface_depth (float): The maximum surface depth to apply for the strongest subcluster.
-
-    Returns:
-        nx.Graph: The graph with adjusted 'z' attribute for each node.
-    """
-    if surface_depth >= 1.0:
-        surface_depth -= 1e-6  # Cap the surface depth to prevent a value of 1.0
-
-    # Compute subclusters as connected components
-    connected_components = list(nx.connected_components(G))
-    subcluster_strengths = {}
-    max_strength = 0
-    # Precompute strengths and track the maximum strength
-    for component in connected_components:
-        size = len(component)
-        max_strength = max(max_strength, size)
-        for node in component:
-            subcluster_strengths[node] = size
-
-    # Avoid repeated lookups and computations by pre-fetching node data
-    nodes = list(G.nodes(data=True))
-    node_updates = {}
-    for node, attrs in nodes:
-        strength = subcluster_strengths[node]
-        normalized_surface_depth = (strength / max_strength) * surface_depth
-        x, y, z = attrs["x"], attrs["y"], attrs["z"]
-        norm = np.sqrt(x**2 + y**2 + z**2)
-        adjusted_z = z - (z / norm) * normalized_surface_depth
-        node_updates[node] = {"z": adjusted_z}
-
-    # Batch update node attributes
-    nx.set_node_attributes(G, node_updates)
-
-    return G

risk/stats/__init__.py

@@ -1,15 +0,0 @@
-"""
-risk/stats
-~~~~~~~~~~
-"""
-
-from risk.stats.permutation import compute_permutation_test
-from risk.stats.stat_tests import (
-    compute_binom_test,
-    compute_chi2_test,
-    compute_hypergeom_test,
-    compute_poisson_test,
-    compute_zscore_test,
-)
-
-from risk.stats.significance import calculate_significance_matrices

risk/stats/permutation/__init__.py

@@ -1,6 +0,0 @@
-"""
-risk/stats/permutation
-~~~~~~~~~~~~~~~~~~~~~~
-"""
-
-from risk.stats.permutation.permutation import compute_permutation_test