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

{risk_network-0.0.3b0 → risk_network-0.0.3b1}/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.3b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.3b0
+Version: 0.0.3b1
 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.3b1}/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.3b1}/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.3b1}/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.1"

{risk_network-0.0.3b0 → risk_network-0.0.3b1}/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.3b1}/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.3b1/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.3b1}/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.3b1}/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.3b1}/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.3b1}/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.3b1/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

{risk_network-0.0.3b0 → risk_network-0.0.3b1}/risk/stats/stats.py

@@ -3,11 +3,14 @@ risk/stats/stats
 ~~~~~~~~~~~~~~~~
 """
 
-from multiprocessing import Pool, Lock
-from typing import Any, Callable, Union
+import sys
+from contextlib import contextmanager
+from multiprocessing import get_context, Lock
+from typing import Any, Callable, Generator, Union
 
 import numpy as np
 from statsmodels.stats.multitest import fdrcorrection
+from threadpoolctl import threadpool_limits
 
 
 def _is_notebook() -> bool:
@@ -35,23 +38,15 @@ else:
 
 
 from risk.stats.permutation import (
-    compute_neighborhood_score_by_sum_cython,
-    compute_neighborhood_score_by_stdev_cython,
-    compute_neighborhood_score_by_z_score_cython,
-    compute_neighborhood_score_by_sum_python,
-    compute_neighborhood_score_by_stdev_python,
-    compute_neighborhood_score_by_z_score_python,
+    compute_neighborhood_score_by_sum,
+    compute_neighborhood_score_by_stdev,
+    compute_neighborhood_score_by_z_score,
 )
 
-CYTHON_DISPATCH_PERMUTATION_TABLE = {
-    "sum": compute_neighborhood_score_by_sum_cython,
-    "stdev": compute_neighborhood_score_by_stdev_cython,
-    "z_score": compute_neighborhood_score_by_z_score_cython,
-}
-PYTHON_DISPATCH_PERMUTATION_TABLE = {
-    "sum": compute_neighborhood_score_by_sum_python,
-    "stdev": compute_neighborhood_score_by_stdev_python,
-    "z_score": compute_neighborhood_score_by_z_score_python,
+DISPATCH_PERMUTATION_TABLE = {
+    "sum": compute_neighborhood_score_by_sum,
+    "stdev": compute_neighborhood_score_by_stdev,
+    "z_score": compute_neighborhood_score_by_z_score,
 }
 
 
@@ -61,7 +56,6 @@ def compute_permutation(
     score_metric: str = "sum",
     null_distribution: str = "network",
     num_permutations: int = 1000,
-    use_cython: bool = True,
     random_seed: int = 888,
     max_workers: int = 1,
 ) -> dict:
@@ -74,7 +68,6 @@ def compute_permutation(
         null_distribution (str, optional): Type of null distribution ('network' or other). Defaults to "network".
         num_permutations (int, optional): Number of permutations to run. Defaults to 1000.
         random_seed (int, optional): Seed for random number generation. Defaults to 888.
-        use_cython (bool, optional): Whether to use Cython for computation. Defaults to True.
         max_workers (int, optional): Number of workers for multiprocessing. Defaults to 1.
 
     Returns:
@@ -83,11 +76,8 @@ def compute_permutation(
     # Ensure that the matrices are in the correct format and free of NaN values
     neighborhoods = neighborhoods.astype(np.float32)
     annotations = annotations.astype(np.float32)
-    # Retrieve the appropriate scoring function based on the metric and Cython usage
-    if use_cython:
-        neighborhood_score_func = CYTHON_DISPATCH_PERMUTATION_TABLE[score_metric]
-    else:
-        neighborhood_score_func = PYTHON_DISPATCH_PERMUTATION_TABLE[score_metric]
+    # Retrieve the appropriate neighborhood score function based on the metric
+    neighborhood_score_func = DISPATCH_PERMUTATION_TABLE[score_metric]
     # Run the permutation test to calculate depletion and enrichment counts
     counts_depletion, counts_enrichment = _run_permutation_test(
         neighborhoods=neighborhoods,
@@ -135,7 +125,7 @@ def _run_permutation_test(
     """
     # Set the random seed for reproducibility
     np.random.seed(random_seed)
-    # Determine indices based on null distribution type
+    # Determine the indices to use based on the null distribution type
     if null_distribution == "network":
         idxs = range(annotations.shape[0])
     else:
@@ -154,45 +144,29 @@ def _run_permutation_test(
     # Initialize count matrices for depletion and enrichment
     counts_depletion = np.zeros(observed_neighborhood_scores.shape)
     counts_enrichment = np.zeros(observed_neighborhood_scores.shape)
-    # Determine subset size for each worker
+    # Determine the number of permutations to run in each worker process
     subset_size = num_permutations // max_workers
     remainder = num_permutations % max_workers
 
-    if max_workers == 1:
-        # If single-threaded, run the permutation process directly
-        local_counts_depletion, local_counts_enrichment = _permutation_process_subset(
-            annotations,
-            np.array(idxs),
-            neighborhoods_matrix_obsv,
-            observed_neighborhood_scores,
-            neighborhood_score_func,
-            num_permutations,
-            0,
-            False,
-        )
-        counts_depletion = np.add(counts_depletion, local_counts_depletion)
-        counts_enrichment = np.add(counts_enrichment, local_counts_enrichment)
-    else:
-        # Prepare parameters for multiprocessing
-        params_list = [
-            (
-                annotations,
-                idxs,
-                neighborhoods_matrix_obsv,
-                observed_neighborhood_scores,
-                neighborhood_score_func,
-                subset_size + (1 if i < remainder else 0),
-                i,
-                True,
-            )
-            for i in range(max_workers)
-        ]
-
-        # Initialize a multiprocessing pool with a lock
-        lock = Lock()
-        with Pool(max_workers, initializer=_init, initargs=(lock,)) as pool:
+    # Use the spawn context for creating a new multiprocessing pool
+    ctx = get_context("spawn")
+    with ctx.Pool(max_workers, initializer=_init, initargs=(Lock(),)) as pool:
+        with threadpool_limits(limits=1, user_api="blas"):
+            params_list = [
+                (
+                    annotations,
+                    np.array(idxs),
+                    neighborhoods_matrix_obsv,
+                    observed_neighborhood_scores,
+                    neighborhood_score_func,
+                    subset_size + (1 if i < remainder else 0),
+                    i,
+                    max_workers,
+                    True,
+                )
+                for i in range(max_workers)
+            ]
             results = pool.starmap(_permutation_process_subset, params_list)
-            # Accumulate results from each worker
             for local_counts_depletion, local_counts_enrichment in results:
                 counts_depletion = np.add(counts_depletion, local_counts_depletion)
                 counts_enrichment = np.add(counts_enrichment, local_counts_enrichment)
@@ -208,6 +182,7 @@ def _permutation_process_subset(
     neighborhood_score_func: Callable,
     subset_size: int,
     worker_id: int,
+    max_workers: int,
     use_lock: bool,
 ) -> tuple:
     """Process a subset of permutations for the permutation test.
@@ -220,6 +195,7 @@ def _permutation_process_subset(
         neighborhood_score_func (Callable): Function to calculate neighborhood scores.
         subset_size (int): Number of permutations to run in this subset.
         worker_id (int): ID of the worker process.
+        max_workers (int): Number of worker processes.
         use_lock (bool): Whether to use a lock for multiprocessing synchronization.
 
     Returns:
@@ -229,52 +205,32 @@ def _permutation_process_subset(
     local_counts_depletion = np.zeros(observed_neighborhood_scores.shape)
     local_counts_enrichment = np.zeros(observed_neighborhood_scores.shape)
 
-    if _is_notebook():
-        # Hack to ensure progress bar displays correctly in Jupyter notebooks
-        print(" ", end="", flush=True)
-
     # Initialize progress bar for tracking permutation progress
-    text = f"Worker {worker_id + 1} Progress"
-    if use_lock:
-        with lock:
-            # Set mininterval to 0.1 to prevent rapid updates and improve performance
-            progress = tqdm(
-                total=subset_size, desc=text, position=worker_id, leave=False, mininterval=0.1
+    text = f"Worker {worker_id + 1} of {max_workers} progress"
+    leave = worker_id == max_workers - 1  # Only leave the progress bar for the last worker
+
+    with _tqdm_context(
+        total=subset_size, desc=text, position=0, leave=leave, use_lock=use_lock
+    ) as progress:
+        for _ in range(subset_size):
+            # Permute the annotation matrix
+            annotation_matrix_permut = annotation_matrix[np.random.permutation(idxs)]
+            # Calculate permuted neighborhood scores
+            with np.errstate(invalid="ignore", divide="ignore"):
+                permuted_neighborhood_scores = neighborhood_score_func(
+                    neighborhoods_matrix_obsv, annotation_matrix_permut
+                )
+            # Update local depletion and enrichment counts based on permuted scores
+            local_counts_depletion = np.add(
+                local_counts_depletion, permuted_neighborhood_scores <= observed_neighborhood_scores
             )
-    else:
-        progress = tqdm(
-            total=subset_size, desc=text, position=worker_id, leave=False, mininterval=0.1
-        )
-
-    for _ in range(subset_size):
-        # Permute the annotation matrix
-        annotation_matrix_permut = annotation_matrix[np.random.permutation(idxs)]
-        # Calculate permuted neighborhood scores
-        with np.errstate(invalid="ignore", divide="ignore"):
-            permuted_neighborhood_scores = neighborhood_score_func(
-                neighborhoods_matrix_obsv, annotation_matrix_permut
+            local_counts_enrichment = np.add(
+                local_counts_enrichment,
+                permuted_neighborhood_scores >= observed_neighborhood_scores,
             )
-        # Update local depletion and enrichment counts based on permuted scores
-        local_counts_depletion = np.add(
-            local_counts_depletion, permuted_neighborhood_scores <= observed_neighborhood_scores
-        )
-        local_counts_enrichment = np.add(
-            local_counts_enrichment, permuted_neighborhood_scores >= observed_neighborhood_scores
-        )
-        # Update progress bar
-        if use_lock:
-            with lock:
-                progress.update(1)
-        else:
+            # Update progress bar
             progress.update(1)
 
-    # Close the progress bar once processing is complete
-    if use_lock:
-        with lock:
-            progress.close()
-    else:
-        progress.close()
-
     return local_counts_depletion, local_counts_enrichment
 
 
@@ -288,12 +244,61 @@ def _init(lock_: Any) -> None:
     lock = lock_  # Assign the provided lock to a global variable
 
 
+@contextmanager
+def _tqdm_context(
+    total: int, desc: str, position: int, leave: bool = False, use_lock: bool = False
+) -> Generator:
+    """A context manager for a `tqdm` progress bar.
+
+    Args:
+        total (int): The total number of iterations for the progress bar.
+        desc (str): Description for the progress bar.
+        position (int): The position of the progress bar (useful for multiple bars).
+        leave (bool): Whether to leave the progress bar after completion.
+        use_lock (bool): Whether to use a lock for multiprocessing synchronization.
+
+    Yields:
+        tqdm: A `tqdm` progress bar object.
+    """
+    # Set default parameters for the progress bar
+    min_interval = 0.1
+    # Use a lock for multiprocessing synchronization if specified
+    if use_lock:
+        with lock:
+            # Create a progress bar with specified parameters and direct output to stderr
+            progress = tqdm(
+                total=total,
+                desc=desc,
+                position=position,
+                leave=leave,
+                mininterval=min_interval,
+                file=sys.stderr,
+            )
+            try:
+                yield progress  # Yield the progress bar to the calling context
+            finally:
+                progress.close()  # Ensure the progress bar is closed properly
+    else:
+        # Create a progress bar without using a lock
+        progress = tqdm(
+            total=total,
+            desc=desc,
+            position=position,
+            leave=leave,
+            mininterval=min_interval,
+            file=sys.stderr,
+        )
+        try:
+            yield progress  # Yield the progress bar to the calling context
+        finally:
+            progress.close()  # Ensure the progress bar is closed properly
+
+
 def calculate_significance_matrices(
     depletion_pvals: np.ndarray,
     enrichment_pvals: np.ndarray,
     tail: str = "right",
     pval_cutoff: float = 0.05,
-    apply_fdr: bool = False,
     fdr_cutoff: float = 0.05,
 ) -> dict:
     """Calculate significance matrices based on p-values and specified tail.
@@ -303,14 +308,13 @@ def calculate_significance_matrices(
         enrichment_pvals (np.ndarray): Matrix of enrichment p-values.
         tail (str, optional): The tail type for significance selection ('left', 'right', 'both'). Defaults to 'right'.
         pval_cutoff (float, optional): Cutoff for p-value significance. Defaults to 0.05.
-        apply_fdr (bool, optional): Whether to apply FDR correction. Defaults to False.
         fdr_cutoff (float, optional): Cutoff for FDR significance if applied. Defaults to 0.05.
 
     Returns:
         dict: Dictionary containing the enrichment matrix, binary significance matrix,
               and the matrix of significant enrichment values.
     """
-    if apply_fdr:
+    if fdr_cutoff < 1.0:
         # Apply FDR correction to depletion p-values
         depletion_qvals = np.apply_along_axis(fdrcorrection, 1, depletion_pvals)[:, 1, :]
         depletion_alpha_threshold_matrix = _compute_threshold_matrix(

{risk_network-0.0.3b0 → risk_network-0.0.3b1}/risk_network.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.3b0
+Version: 0.0.3b1
 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.3b1}/risk_network.egg-info/SOURCES.txt

@@ -13,8 +13,8 @@ risk/log/__init__.py
 risk/log/console.py
 risk/log/params.py
 risk/neighborhoods/__init__.py
+risk/neighborhoods/community.py
 risk/neighborhoods/domains.py
-risk/neighborhoods/graph.py
 risk/neighborhoods/neighborhoods.py
 risk/network/__init__.py
 risk/network/geometry.py
@@ -22,11 +22,8 @@ risk/network/graph.py
 risk/network/io.py
 risk/network/plot.py
 risk/stats/__init__.py
+risk/stats/permutation.py
 risk/stats/stats.py
-risk/stats/permutation/__init__.py
-risk/stats/permutation/_cython/permutation.pyx
-risk/stats/permutation/_cython/setup.py
-risk/stats/permutation/_python/permutation.py
 risk_network.egg-info/PKG-INFO
 risk_network.egg-info/SOURCES.txt
 risk_network.egg-info/dependency_links.txt

{risk_network-0.0.3b0 → risk_network-0.0.3b1}/risk_network.egg-info/requires.txt

@@ -1,10 +1,10 @@
-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.3b1}/setup.py

@@ -1,7 +1,5 @@
 import re
-from setuptools import setup, Extension, find_packages
-from Cython.Build import cythonize
-
+from setuptools import setup, find_packages
 import numpy
 
 
@@ -14,15 +12,6 @@ def find_version():
     raise RuntimeError("Unable to find version string.")
 
 
-# Cython extension modules
-extensions = [
-    Extension(
-        name="risk.stats.permutation._cython.permutation",
-        sources=["risk/stats/permutation/_cython/permutation.pyx"],
-        include_dirs=[numpy.get_include()],
-    ),
-]
-
 # Setup function
 setup(
     name="risk-network",
@@ -34,16 +23,15 @@ setup(
     long_description_content_type="text/markdown",
     license="GPL-3.0-or-later",
     packages=find_packages(),
-    ext_modules=cythonize(extensions),  # Compile Cython extensions
     include_package_data=True,
     install_requires=[
-        "cython",
-        "numpy",
         "ipywidgets",
         "markov_clustering",
         "matplotlib",
         "networkx",
         "nltk==3.8.1",
+        "numpy",
+        "openpyxl",
         "pandas",
         "python-louvain",
         "scikit-learn",

risk_network-0.0.3b0/risk/stats/permutation/__init__.py

@@ -1,15 +0,0 @@
-"""
-risk/stats/permutation
-~~~~~~~~~~~~~~~~~~~~~~
-"""
-
-from risk.stats.permutation._cython.permutation import (
-    compute_neighborhood_score_by_sum_cython,
-    compute_neighborhood_score_by_stdev_cython,
-    compute_neighborhood_score_by_z_score_cython,
-)
-from risk.stats.permutation._python.permutation import (
-    compute_neighborhood_score_by_sum_python,
-    compute_neighborhood_score_by_stdev_python,
-    compute_neighborhood_score_by_z_score_python,
-)

risk_network-0.0.3b0/risk/stats/permutation/_cython/permutation.pyx

@@ -1,82 +0,0 @@
-# cython: language_level=3
-import numpy as np
-cimport numpy as np
-cimport cython
-from threadpoolctl import threadpool_limits
-
-
-@cython.boundscheck(False)  # Disable bounds checking for entire function
-@cython.wraparound(False)   # Disable negative index wrapping for entire function
-def compute_neighborhood_score_by_sum_cython(
-    np.ndarray[np.float32_t, ndim=2] neighborhoods,
-    np.ndarray[np.float32_t, ndim=2] annotation_matrix,
-    ):
-    cdef np.float32_t[:, :] neighborhood_score
-    # Limit the number of threads used by np.dot
-    with threadpool_limits(limits=1, user_api='blas'):
-        neighborhood_score = np.dot(neighborhoods, annotation_matrix)
-    
-    return np.asarray(neighborhood_score)
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-def compute_neighborhood_score_by_stdev_cython(
-    np.ndarray[np.float32_t, ndim=2] neighborhoods,
-    np.ndarray[np.float32_t, ndim=2] annotation_matrix,
-    ):
-    cdef np.ndarray[np.float32_t, ndim=2] neighborhood_score
-    cdef np.ndarray[np.float32_t, ndim=2] EXX
-    # Perform dot product directly using the inputs with limited threads
-    with threadpool_limits(limits=1, user_api='blas'):
-        neighborhood_score = np.dot(neighborhoods, annotation_matrix)
-    
-    # Sum across rows for neighborhoods to get N, reshape for broadcasting
-    cdef np.ndarray[np.float32_t, ndim=1] N = np.sum(neighborhoods, axis=1)
-    cdef np.ndarray[np.float32_t, ndim=2] N_reshaped = N[:, None]
-    # Mean of the dot product
-    cdef np.ndarray[np.float32_t, ndim=2] M = neighborhood_score / N_reshaped
-    # Compute the mean of squares (EXX) with limited threads
-    with threadpool_limits(limits=1, user_api='blas'):
-        EXX = np.dot(neighborhoods, np.power(annotation_matrix, 2)) / N_reshaped
-    
-    # Variance computation
-    cdef np.ndarray[np.float32_t, ndim=2] variance = EXX - M**2
-    # Standard deviation computation
-    cdef np.ndarray[np.float32_t, ndim=2] stdev = np.sqrt(variance)
-    
-    return stdev
-
-
-@cython.boundscheck(False)
-@cython.wraparound(False)
-def compute_neighborhood_score_by_z_score_cython(
-    np.ndarray[np.float32_t, ndim=2] neighborhoods,
-    np.ndarray[np.float32_t, ndim=2] annotation_matrix,
-    ):
-    cdef np.ndarray[np.float32_t, ndim=2] neighborhood_score
-    cdef np.ndarray[np.float32_t, ndim=2] EXX
-    # Perform dot product directly using the inputs with limited threads
-    with threadpool_limits(limits=1, user_api='blas'):
-        neighborhood_score = np.dot(neighborhoods, annotation_matrix)
-    
-    # Sum across rows for neighborhoods to get N, reshape for broadcasting
-    cdef np.ndarray[np.float32_t, ndim=1] N = np.sum(neighborhoods, axis=1)
-    cdef np.ndarray[np.float32_t, ndim=2] N_reshaped = N[:, None]
-    # Mean of the dot product
-    cdef np.ndarray[np.float32_t, ndim=2] M = neighborhood_score / N_reshaped
-    # Compute the mean of squares (EXX) with limited threads
-    with threadpool_limits(limits=1, user_api='blas'):
-        EXX = np.dot(neighborhoods, np.power(annotation_matrix, 2)) / N_reshaped
-    
-    # Variance computation
-    cdef np.ndarray[np.float32_t, ndim=2] variance = EXX - M**2
-    # Standard deviation computation
-    cdef np.ndarray[np.float32_t, ndim=2] stdev = np.sqrt(variance)
-    # Z-score computation with error handling
-    with np.errstate(divide='ignore', invalid='ignore'):
-        neighborhood_score = np.divide(M, stdev)
-        # Handle divisions by zero or stdev == 0
-        neighborhood_score[np.isnan(neighborhood_score)] = 0  # Assuming requirement to reset NaN results to 0
-
-    return neighborhood_score

risk_network-0.0.3b0/risk/stats/permutation/_cython/setup.py

@@ -1,11 +0,0 @@
-"""
-risk/stats/permutation/_cython/setup
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-"""
-
-# setup.py
-from setuptools import setup
-from Cython.Build import cythonize
-import numpy as np
-
-setup(ext_modules=cythonize("permutation.pyx"), include_dirs=[np.get_include()])