risk-network 0.0.3b0__tar.gz → 0.0.3b2__tar.gz

{risk_network-0.0.3b0 → risk_network-0.0.3b2}/MANIFEST.in

@@ -1,6 +1,5 @@
-# Include all Python and Cython source files
+# Include all Python source files
 recursive-include risk *.py
-recursive-include risk *.pyx
 
 # Include important project files in the distribution
 include README.md

{risk_network-0.0.3b0 → risk_network-0.0.3b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.3b0
+Version: 0.0.3b2
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>
@@ -694,13 +694,13 @@ Classifier: Development Status :: 4 - Beta
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cython
 Requires-Dist: ipywidgets
 Requires-Dist: markov_clustering
 Requires-Dist: matplotlib
 Requires-Dist: networkx
 Requires-Dist: nltk==3.8.1
 Requires-Dist: numpy
+Requires-Dist: openpyxl
 Requires-Dist: pandas
 Requires-Dist: python-louvain
 Requires-Dist: scikit-learn
@@ -709,15 +709,21 @@ Requires-Dist: statsmodels
 Requires-Dist: threadpoolctl
 Requires-Dist: tqdm
 
-# RISK
-
-<ins>Regional Inference of Significant Kinships</ins>
+<p align="center">
+  <img src="./docs/github/risk-logo-dark.png#gh-dark-mode-only" width="400" />
+  <img src="./docs/github/risk-logo-light.png#gh-light-mode-only" width="400" />
+</p>
 
-<p align="left">
-    <img src="./docs/github/risk-logo-dark.png#gh-dark-mode-only" width="40%" />
-    <img src="./docs/github/risk-logo-light.png#gh-light-mode-only" width="40%" />
+<p align="center">
+  <a href="https://pypi.python.org/pypi/risk-network"><img src="https://img.shields.io/pypi/v/risk-network.svg" alt="pypiv"></a>
+  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.7+-blue.svg" alt="Python 3.7+"></a>
+  <a href="https://raw.githubusercontent.com/irahorecka/chrono24/main/LICENSE"><img src="https://img.shields.io/badge/License-GPLv3-blue.svg" alt="License: GPL v3"></a>
 </p>
 
+## RISK
+
+#### Regional Inference of Significant Kinships
+
 RISK is a software tool for visualizing spatial relationships in networks. It aims to enhance network analysis by integrating advanced network annotation algorithms, such as Louvain and Markov Clustering, to identify key functional modules and pathways.
 
 ## Features

{risk_network-0.0.3b0 → risk_network-0.0.3b2}/README.md

@@ -1,12 +1,18 @@
-# RISK
-
-<ins>Regional Inference of Significant Kinships</ins>
+<p align="center">
+  <img src="./docs/github/risk-logo-dark.png#gh-dark-mode-only" width="400" />
+  <img src="./docs/github/risk-logo-light.png#gh-light-mode-only" width="400" />
+</p>
 
-<p align="left">
-    <img src="./docs/github/risk-logo-dark.png#gh-dark-mode-only" width="40%" />
-    <img src="./docs/github/risk-logo-light.png#gh-light-mode-only" width="40%" />
+<p align="center">
+  <a href="https://pypi.python.org/pypi/risk-network"><img src="https://img.shields.io/pypi/v/risk-network.svg" alt="pypiv"></a>
+  <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/python-3.7+-blue.svg" alt="Python 3.7+"></a>
+  <a href="https://raw.githubusercontent.com/irahorecka/chrono24/main/LICENSE"><img src="https://img.shields.io/badge/License-GPLv3-blue.svg" alt="License: GPL v3"></a>
 </p>
 
+## RISK
+
+#### Regional Inference of Significant Kinships
+
 RISK is a software tool for visualizing spatial relationships in networks. It aims to enhance network analysis by integrating advanced network annotation algorithms, such as Louvain and Markov Clustering, to identify key functional modules and pathways.
 
 ## Features

{risk_network-0.0.3b0 → risk_network-0.0.3b2}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools", "wheel", "Cython", "numpy"]
+requires = ["setuptools", "wheel", "numpy"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -26,13 +26,13 @@ classifiers = [
     "Development Status :: 4 - Beta",
 ]
 dependencies = [
-    "cython",
     "ipywidgets",
     "markov_clustering",
     "matplotlib",
     "networkx",
     "nltk==3.8.1",
     "numpy",
+    "openpyxl",
     "pandas",
     "python-louvain",
     "scikit-learn",

{risk_network-0.0.3b0 → risk_network-0.0.3b2}/risk/__init__.py

@@ -10,4 +10,4 @@ RISK: RISK Infers Spatial Kinship
 
 from risk.risk import RISK
 
-__version__ = "0.0.3-beta.0"
+__version__ = "0.0.3-beta.2"

{risk_network-0.0.3b0 → risk_network-0.0.3b2}/risk/annotations/annotations.py

@@ -139,15 +139,15 @@ def define_top_annotations(
                 size_connected_components <= max_cluster_size,
             )
         )
-        annotations_enrichment_matrix.loc[
-            attribute, "num connected components"
-        ] = num_connected_components
-        annotations_enrichment_matrix.at[
-            attribute, "size connected components"
-        ] = size_connected_components
-        annotations_enrichment_matrix.loc[
-            attribute, "num large connected components"
-        ] = num_large_connected_components
+        annotations_enrichment_matrix.loc[attribute, "num connected components"] = (
+            num_connected_components
+        )
+        annotations_enrichment_matrix.at[attribute, "size connected components"] = (
+            size_connected_components
+        )
+        annotations_enrichment_matrix.loc[attribute, "num large connected components"] = (
+            num_large_connected_components
+        )
 
     # Filter out attributes with more than one connected component
     annotations_enrichment_matrix.loc[

{risk_network-0.0.3b0 → risk_network-0.0.3b2}/risk/annotations/io.py

@@ -45,66 +45,70 @@ class AnnotationsIO:
         # Process the JSON data and return it in the context of the network
         return load_annotations(network, annotations_input)
 
-    def load_csv_annotation(
+    def load_excel_annotation(
         self,
         filepath: str,
         network: nx.Graph,
         label_colname: str = "label",
         nodes_colname: str = "nodes",
-        delimiter: str = ";",
+        sheet_name: str = "Sheet1",
+        nodes_delimiter: str = ";",
     ) -> Dict[str, Any]:
-        """Load annotations from a CSV file and convert them to a DataFrame.
+        """Load annotations from an Excel file and associate them with the network.
 
         Args:
-            filepath (str): Path to the CSV annotations file.
-            network (NetworkX graph): The network to which the annotations are related.
-            label_colname (str): Name of the column containing the labels.
-            nodes_colname (str): Name of the column containing the nodes.
-            delimiter (str): Delimiter used to parse the nodes column (default is ';').
+            filepath (str): Path to the Excel annotations file.
+            network (nx.Graph): The NetworkX graph to which the annotations are related.
+            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 ';').
 
         Returns:
-            pd.DataFrame: DataFrame containing the labels and parsed nodes.
+            Dict[str, Any]: A dictionary where each label is paired with its respective list of nodes,
+                            linked to the provided network.
         """
-        filetype = "CSV"
+        filetype = "Excel"
         params.log_annotations(filepath=filepath, filetype=filetype)
         _log_loading(filetype, filepath=filepath)
-        # Load the CSV file into a dictionary
-        annotations_input = _load_matrix_file(filepath, label_colname, nodes_colname, delimiter)
-        # Process and return the annotations in the context of the network
-        return load_annotations(network, annotations_input)
+        # Load the specified sheet from the Excel file
+        df = 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))
+        # Convert the DataFrame to a dictionary pairing labels with their corresponding nodes
+        label_node_dict = df.set_index(label_colname)[nodes_colname].to_dict()
+        return load_annotations(network, label_node_dict)
 
-    def load_excel_annotation(
+    def load_csv_annotation(
         self,
         filepath: str,
         network: nx.Graph,
         label_colname: str = "label",
         nodes_colname: str = "nodes",
-        sheet_name: str = "Sheet1",
-        delimiter: str = ";",
+        nodes_delimiter: str = ";",
     ) -> Dict[str, Any]:
-        """Load annotations from an Excel file and convert them to a dictionary.
+        """Load annotations from a CSV file and associate them with the network.
 
         Args:
-            filepath (str): Path to the Excel annotations file.
-            network (NetworkX graph): The network to which the annotations are related.
-            label_colname (str): Name of the column containing the labels.
-            nodes_colname (str): Name of the column containing the nodes.
-            sheet_name (str): The name of the Excel sheet to load (default is 'Sheet1').
-            delimiter (str): Delimiter used to parse the nodes column (default is ';').
+            filepath (str): Path to the CSV annotations file.
+            network (nx.Graph): The NetworkX graph to which the annotations are related.
+            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 ';').
 
         Returns:
-            dict: A dictionary where each label is paired with its respective list of nodes.
+            Dict[str, Any]: A dictionary where each label is paired with its respective list of nodes,
+                            linked to the provided network.
         """
-        filetype = "Excel"
+        filetype = "CSV"
         params.log_annotations(filepath=filepath, filetype=filetype)
         _log_loading(filetype, filepath=filepath)
-        # Load the specified sheet from the Excel file
-        df = pd.read_excel(filepath, sheet_name=sheet_name)
-        # Split the nodes column by the specified delimiter
-        df[nodes_colname] = df[nodes_colname].apply(lambda x: x.split(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()
-        return load_annotations(network, label_node_dict)
+        # Load the CSV file into a dictionary
+        annotations_input = _load_matrix_file(
+            filepath, label_colname, nodes_colname, delimiter=",", nodes_delimiter=nodes_delimiter
+        )
+        # Process and return the annotations in the context of the network
+        return load_annotations(network, annotations_input)
 
     def load_tsv_annotation(
         self,
@@ -112,47 +116,56 @@ class AnnotationsIO:
         network: nx.Graph,
         label_colname: str = "label",
         nodes_colname: str = "nodes",
+        nodes_delimiter: str = ";",
     ) -> Dict[str, Any]:
-        """Load annotations from a TSV file and convert them to a DataFrame.
+        """Load annotations from a TSV file and associate them with the network.
 
         Args:
             filepath (str): Path to the TSV annotations file.
-            network (NetworkX graph): The network to which the annotations are related.
-            label_colname (str): Name of the column containing the labels.
-            nodes_colname (str): Name of the column containing the nodes.
+            network (nx.Graph): The NetworkX graph to which the annotations are related.
+            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 ';').
 
         Returns:
-            pd.DataFrame: DataFrame containing the labels and parsed nodes.
+            Dict[str, Any]: A dictionary where each label is paired with its respective list of nodes,
+                            linked to the provided network.
         """
         filetype = "TSV"
         params.log_annotations(filepath=filepath, filetype=filetype)
         _log_loading(filetype, filepath=filepath)
-        # Load the TSV file with tab delimiter and convert to dictionary
+        # Load the TSV file into a dictionary
         annotations_input = _load_matrix_file(
-            filepath, label_colname, nodes_colname, delimiter="\t"
+            filepath, label_colname, nodes_colname, delimiter="\t", nodes_delimiter=nodes_delimiter
         )
         # Process and return the annotations in the context of the network
         return load_annotations(network, annotations_input)
 
 
 def _load_matrix_file(
-    filepath: str, label_colname: str, nodes_colname: str, delimiter: str = ";"
+    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.
-        nodes_colname (str): Name of the column containing the nodes.
-        delimiter (str): Delimiter used to parse the nodes column (default is ';').
+        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: A dictionary where each label is paired with its respective list of nodes.
+        Dict[str, Any]: A dictionary where each label is paired with its respective list of nodes.
     """
-    df = pd.read_csv(filepath)
-    # Split the nodes column by the delimiter
-    df[nodes_colname] = df[nodes_colname].apply(lambda x: x.split(delimiter))
-    # Create a dictionary pairing labels with their corresponding nodes
+    # Load the CSV or TSV file into a DataFrame
+    df = 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))
+    # Create a dictionary pairing labels with their corresponding list of nodes
     label_node_dict = df.set_index(label_colname)[nodes_colname].to_dict()
     return label_node_dict
 

risk_network-0.0.3b0/risk/neighborhoods/graph.py → risk_network-0.0.3b2/risk/neighborhoods/community.py

@@ -1,6 +1,6 @@
 """
-risk/neighborhoods/graph
-~~~~~~~~~~~~~~~~~~~~~~~~
+risk/neighborhoods/community
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import community as community_louvain

{risk_network-0.0.3b0 → risk_network-0.0.3b2}/risk/neighborhoods/neighborhoods.py

@@ -10,7 +10,7 @@ import networkx as nx
 import numpy as np
 from sklearn.exceptions import DataConversionWarning
 
-from risk.neighborhoods.graph import (
+from risk.neighborhoods.community import (
     calculate_dijkstra_neighborhoods,
     calculate_label_propagation_neighborhoods,
     calculate_louvain_neighborhoods,

{risk_network-0.0.3b0 → risk_network-0.0.3b2}/risk/network/io.py

@@ -317,10 +317,10 @@ class NetworkIO:
         print(f"Filetype: {filetype}")
         if filepath:
             print(f"Filepath: {filepath}")
-        print(f"Project to sphere: {self.compute_sphere}")
+        print(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
         if self.compute_sphere:
             print(f"Surface depth: {self.surface_depth}")
         print(f"Edge length threshold: {self.edge_length_threshold}")
-        print(f"Include edge weights: {self.include_edge_weight}")
+        print(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
         if self.include_edge_weight:
             print(f"Weight label: {self.weight_label}")

{risk_network-0.0.3b0 → risk_network-0.0.3b2}/risk/network/plot.py

@@ -45,21 +45,24 @@ class NetworkPlotter:
             outline_scale (float, optional): Outline scaling factor for the perimeter diameter. Defaults to 1.0.
         """
         self.network_graph = network_graph
-        self.ax = None  # Initialize the axis attribute
-        # Initialize the plot with the given parameters
-        self._initialize_plot(figsize, background_color, plot_outline, outline_color, outline_scale)
+        # Initialize the plot with the specified parameters
+        self.ax = self._initialize_plot(
+            network_graph, figsize, background_color, plot_outline, outline_color, outline_scale
+        )
 
     def _initialize_plot(
         self,
+        network_graph: NetworkGraph,
         figsize: tuple,
         background_color: str,
         plot_outline: bool,
         outline_color: str,
         outline_scale: float,
-    ) -> tuple:
+    ) -> plt.Axes:
         """Set up the plot with figure size, optional circle perimeter, and background color.
 
         Args:
+            network_graph (NetworkGraph): The network data and attributes to be visualized.
             figsize (tuple): Size of the figure in inches (width, height).
             background_color (str): Background color of the plot.
             plot_outline (bool): Whether to plot the network perimeter circle.
@@ -67,10 +70,10 @@ class NetworkPlotter:
             outline_scale (float): Outline scaling factor for the perimeter diameter.
 
         Returns:
-            tuple: The created matplotlib figure and axis.
+            plt.Axes: The axis object for the plot.
         """
         # Extract node coordinates from the network graph
-        node_coordinates = self.network_graph.node_coordinates
+        node_coordinates = network_graph.node_coordinates
         # Calculate the center and radius of the bounding box around the network
         center, radius = _calculate_bounding_box(node_coordinates)
         # Scale the radius by the outline_scale factor
@@ -107,9 +110,7 @@ class NetworkPlotter:
         ax.set_yticks([])
         ax.patch.set_visible(False)  # Hide the axis background
 
-        # Store the axis for further use and return the figure and axis
-        self.ax = ax
-        return fig, ax
+        return ax
 
     def plot_network(
         self,
@@ -436,7 +437,12 @@ class NetworkPlotter:
             arrow_color = self.get_annotated_contour_colors(color=arrow_color)
 
         # Calculate the center and radius of the network
-        domain_centroids = self._calculate_domain_centroids()
+        domain_centroids = {}
+        for domain, nodes in self.network_graph.domain_to_nodes.items():
+            if nodes:  # Skip if the domain has no nodes
+                domain_centroids[domain] = self._calculate_domain_centroid(nodes)
+
+        # Calculate the bounding box around the network
         center, radius = _calculate_bounding_box(
             self.network_graph.node_coordinates, radius_margin=perimeter_scale
         )
@@ -467,31 +473,26 @@ class NetworkPlotter:
                 arrowprops=dict(arrowstyle="->", color=arrow_color[idx], linewidth=arrow_linewidth),
             )
 
-    def _calculate_domain_centroids(self) -> Dict[Any, np.ndarray]:
-        """Calculate the most centrally located node within each domain based on the node positions.
+    def _calculate_domain_centroid(self, nodes: list) -> tuple:
+        """Calculate the most centrally located node in .
+
+        Args:
+            nodes (list): List of node labels to include in the subnetwork.
 
         Returns:
-            Dict[Any, np.ndarray]: A dictionary mapping each domain to its central node's coordinates.
+            tuple: A tuple containing the domain's central node coordinates.
         """
-        domain_central_nodes = {}
-        for domain, nodes in self.network_graph.domain_to_nodes.items():
-            if not nodes:  # Skip if the domain has no nodes
-                continue
-
-            # Extract positions of all nodes in the domain
-            node_positions = self.network_graph.node_coordinates[nodes, :]
-            # Calculate the pairwise distance matrix between all nodes in the domain
-            distances_matrix = np.linalg.norm(
-                node_positions[:, np.newaxis] - node_positions, axis=2
-            )
-            # Sum the distances for each node to all other nodes in the domain
-            sum_distances = np.sum(distances_matrix, axis=1)
-            # Identify the node with the smallest total distance to others (the centroid)
-            central_node_idx = np.argmin(sum_distances)
-            # Map the domain to the coordinates of its central node
-            domain_central_nodes[domain] = node_positions[central_node_idx]
-
-        return domain_central_nodes
+        # Extract positions of all nodes in the domain
+        node_positions = self.network_graph.node_coordinates[nodes, :]
+        # Calculate the pairwise distance matrix between all nodes in the domain
+        distances_matrix = np.linalg.norm(node_positions[:, np.newaxis] - node_positions, axis=2)
+        # Sum the distances for each node to all other nodes in the domain
+        sum_distances = np.sum(distances_matrix, axis=1)
+        # Identify the node with the smallest total distance to others (the centroid)
+        central_node_idx = np.argmin(sum_distances)
+        # Map the domain to the coordinates of its central node
+        domain_central_node = node_positions[central_node_idx]
+        return domain_central_node
 
     def get_annotated_node_colors(
         self, nonenriched_color: str = "white", random_seed: int = 888, **kwargs
@@ -604,16 +605,6 @@ class NetworkPlotter:
 
         return np.array(annotated_colors)
 
-    @staticmethod
-    def close(*args, **kwargs) -> None:
-        """Close the current plot.
-
-        Args:
-            *args: Positional arguments passed to `plt.close`.
-            **kwargs: Keyword arguments passed to `plt.close`.
-        """
-        plt.close(*args, **kwargs)
-
     @staticmethod
     def savefig(*args, **kwargs) -> None:
         """Save the current plot to a file.

{risk_network-0.0.3b0 → risk_network-0.0.3b2}/risk/risk.py

@@ -98,7 +98,6 @@ class RISK(NetworkIO, AnnotationsIO):
         score_metric: str = "sum",
         null_distribution: str = "network",
         num_permutations: int = 1000,
-        use_cython=True,
         random_seed: int = 888,
         max_workers: int = 1,
     ) -> Dict[str, Any]:
@@ -122,7 +121,6 @@ class RISK(NetworkIO, AnnotationsIO):
             score_metric=score_metric,
             null_distribution=null_distribution,
             num_permutations=num_permutations,
-            use_cython=use_cython,
             random_seed=random_seed,
             max_workers=max_workers,
         )
@@ -153,7 +151,6 @@ class RISK(NetworkIO, AnnotationsIO):
             score_metric=score_metric,
             null_distribution=null_distribution,
             num_permutations=num_permutations,
-            use_cython=use_cython,
             random_seed=random_seed,
             max_workers=max_workers,
         )
@@ -167,7 +164,6 @@ class RISK(NetworkIO, AnnotationsIO):
         neighborhoods: Dict[str, Any],
         tail: str = "right",  # OPTIONS: "right" (enrichment), "left" (depletion), "both"
         pval_cutoff: float = 0.01,  # OPTIONS: Any value between 0 to 1
-        apply_fdr: bool = False,
         fdr_cutoff: float = 0.9999,  # OPTIONS: Any value between 0 to 1
         impute_depth: int = 1,
         prune_threshold: float = 0.0,
@@ -185,7 +181,6 @@ class RISK(NetworkIO, AnnotationsIO):
             neighborhoods (dict): Neighborhood enrichment 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.
-            apply_fdr (bool, optional): Whether to apply FDR correction. Defaults to False.
             fdr_cutoff (float, optional): FDR cutoff for significance. Defaults to 0.9999.
             impute_depth (int, optional): Depth for imputing neighbors. Defaults to 1.
             prune_threshold (float, optional): Distance threshold for pruning neighbors. Defaults to 0.0.
@@ -203,7 +198,6 @@ class RISK(NetworkIO, AnnotationsIO):
         params.log_graph(
             tail=tail,
             pval_cutoff=pval_cutoff,
-            apply_fdr=apply_fdr,
             fdr_cutoff=fdr_cutoff,
             impute_depth=impute_depth,
             prune_threshold=prune_threshold,
@@ -215,7 +209,7 @@ class RISK(NetworkIO, AnnotationsIO):
         )
 
         print(f"P-value cutoff: {pval_cutoff}")
-        print(f"FDR cutoff: {'N/A' if not apply_fdr else apply_fdr}")
+        print(f"FDR BH cutoff: {fdr_cutoff}")
         print(
             f"Significance tail: '{tail}' ({'enrichment' if tail == 'right' else 'depletion' if tail == 'left' else 'both'})"
         )
@@ -225,7 +219,6 @@ class RISK(NetworkIO, AnnotationsIO):
             neighborhoods["enrichment_pvals"],
             tail=tail,
             pval_cutoff=pval_cutoff,
-            apply_fdr=apply_fdr,
             fdr_cutoff=fdr_cutoff,
         )
 

{risk_network-0.0.3b0/risk/stats/permutation/_python → risk_network-0.0.3b2/risk/stats}/permutation.py

@@ -1,12 +1,15 @@
 """
-risk/stats/permutation/_python/permutation
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/stats/permutation
+~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import numpy as np
 
+# Note: Cython optimizations provided minimal performance benefits.
+# The final version with Cython is archived in the `cython_permutation` branch.
 
-def compute_neighborhood_score_by_sum_python(
+
+def compute_neighborhood_score_by_sum(
     neighborhoods_matrix: np.ndarray, annotation_matrix: np.ndarray
 ) -> np.ndarray:
     """Compute the sum of attribute values for each neighborhood.
@@ -18,12 +21,12 @@ def compute_neighborhood_score_by_sum_python(
     Returns:
         np.ndarray: Sum of attribute values for each neighborhood.
     """
-    # Directly compute the dot product to get the sum of attribute values in each neighborhood
+    # Calculate the neighborhood score as the dot product of neighborhoods and annotations
     neighborhood_score = np.dot(neighborhoods_matrix, annotation_matrix)
     return neighborhood_score
 
 
-def compute_neighborhood_score_by_stdev_python(
+def compute_neighborhood_score_by_stdev(
     neighborhoods_matrix: np.ndarray, annotation_matrix: np.ndarray
 ) -> np.ndarray:
     """Compute the standard deviation of neighborhood scores.
@@ -37,21 +40,20 @@ def compute_neighborhood_score_by_stdev_python(
     """
     # Calculate the neighborhood score as the dot product of neighborhoods and annotations
     neighborhood_score = np.dot(neighborhoods_matrix, annotation_matrix)
-    # Calculate the number of elements in each neighborhood and reshape for broadcasting
+    # Calculate the number of elements in each neighborhood
     N = np.sum(neighborhoods_matrix, axis=1)
-    N_reshaped = N[:, None]
     # Compute the mean of the neighborhood scores
-    M = neighborhood_score / N_reshaped
-    # Compute the mean of squares (EXX) for annotation values
-    EXX = np.dot(neighborhoods_matrix, np.power(annotation_matrix, 2)) / N_reshaped
+    M = neighborhood_score / N[:, None]
+    # Compute the mean of squares (EXX) directly using squared annotation matrix
+    EXX = np.dot(neighborhoods_matrix, annotation_matrix**2) / N[:, None]
     # Calculate variance as EXX - M^2
-    variance = EXX - np.power(M, 2)
+    variance = EXX - M**2
     # Compute the standard deviation as the square root of the variance
     stdev = np.sqrt(variance)
     return stdev
 
 
-def compute_neighborhood_score_by_z_score_python(
+def compute_neighborhood_score_by_z_score(
     neighborhoods_matrix: np.ndarray, annotation_matrix: np.ndarray
 ) -> np.ndarray:
     """Compute Z-scores for neighborhood scores.
@@ -66,18 +68,21 @@ def compute_neighborhood_score_by_z_score_python(
     # Calculate the neighborhood score as the dot product of neighborhoods and annotations
     neighborhood_score = np.dot(neighborhoods_matrix, annotation_matrix)
     # Calculate the number of elements in each neighborhood
-    N = np.dot(neighborhoods_matrix, np.ones(annotation_matrix.shape))
+    N = np.dot(
+        neighborhoods_matrix, np.ones(annotation_matrix.shape[1], dtype=annotation_matrix.dtype)
+    )
     # Compute the mean of the neighborhood scores
     M = neighborhood_score / N
-    # Compute the mean of squares (EXX) and the squared mean (EEX)
-    EXX = np.dot(neighborhoods_matrix, np.power(annotation_matrix, 2)) / N
-    EEX = np.power(M, 2)
+    # Compute the mean of squares (EXX)
+    EXX = np.dot(neighborhoods_matrix, annotation_matrix**2) / N
     # Calculate the standard deviation for each neighborhood
-    std = np.sqrt(EXX - EEX)
+    variance = EXX - M**2
+    std = np.sqrt(variance)
     # Calculate Z-scores, handling cases where std is 0 or N is less than 3
     with np.errstate(divide="ignore", invalid="ignore"):
-        z_scores = np.divide(M, std)
-        z_scores[std == 0] = np.nan  # Handle division by zero
-        z_scores[N < 3] = np.nan  # Apply threshold for minimum number of elements
+        z_scores = M / std
+        z_scores[(std == 0) | (N < 3)] = (
+            np.nan
+        )  # Handle division by zero and apply minimum threshold
 
     return z_scores