risk-network 0.0.16b0__py3-none-any.whl → 0.0.16b2__py3-none-any.whl

risk/{_neighborhoods/_domains.py → cluster/label.py}

@@ -1,6 +1,6 @@
 """
-risk/_neighborhoods/_domains
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/cluster/label
+~~~~~~~~~~~~~~~~~~
 """
 
 from itertools import product
@@ -13,9 +13,9 @@ from scipy.cluster.hierarchy import fcluster, linkage
 from sklearn.metrics import silhouette_score
 from tqdm import tqdm
 
-from risk._annotation import get_weighted_description
+from risk.annotation import get_weighted_description
 
-from .._log import logger
+from ..log import logger
 
 # Define constants for clustering
 # fmt: off
@@ -30,7 +30,7 @@ LINKAGE_METRICS = {
 
 def define_domains(
     top_annotation: pd.DataFrame,
-    significant_neighborhoods_significance: np.ndarray,
+    significant_clusters_significance: np.ndarray,
     linkage_criterion: str,
     linkage_method: str,
     linkage_metric: str,
@@ -42,7 +42,7 @@ def define_domains(
 
     Args:
         top_annotation (pd.DataFrame): DataFrame of top annotations data for the network nodes.
-        significant_neighborhoods_significance (np.ndarray): The binary significance matrix below alpha.
+        significant_clusters_significance (np.ndarray): The binary significance matrix below alpha.
         linkage_criterion (str): The clustering criterion for defining groups. Choose "off" to disable clustering.
         linkage_method (str): The linkage method for clustering. Choose "auto" to optimize.
         linkage_metric (str): The linkage metric for clustering. Choose "auto" to optimize.
@@ -66,11 +66,11 @@ def define_domains(
         top_annotation["domain"] = range(1, n_rows + 1)
     else:
         # Transpose the matrix to cluster annotations
-        m = significant_neighborhoods_significance[:, top_annotation["significant_annotation"]].T
+        m = significant_clusters_significance[:, top_annotation["significant_annotation"]].T
         # Safeguard the matrix by replacing NaN, Inf, and -Inf values
         m = _safeguard_matrix(m)
         try:
-            # Optimize silhouette score across different linkage methods and distance metrics
+            # Optimize silhouette score across different linkage methods and metrics
             (
                 best_linkage,
                 best_metric,
@@ -99,7 +99,7 @@ def define_domains(
 
     # Create DataFrames to store domain information
     node_to_significance = pd.DataFrame(
-        data=significant_neighborhoods_significance,
+        data=significant_clusters_significance,
         columns=[top_annotation.index.values, top_annotation["domain"]],
     )
     node_to_domain = node_to_significance.T.groupby(level="domain").sum().T
@@ -152,9 +152,9 @@ def trim_domains(
     top_annotation["domain"] = top_annotation["domain"].replace(to_remove, invalid_domain_id)
     domains.loc[domains["primary_domain"].isin(to_remove), ["primary_domain"]] = invalid_domain_id
 
-    # Normalize "num significant neighborhoods" by percentile for each domain and scale to 0-10
+    # Normalize "num significant clusters" by percentile for each domain and scale to 0-10
     top_annotation["normalized_value"] = top_annotation.groupby("domain")[
-        "significant_neighborhood_significance_sums"
+        "significant_cluster_significance_sums"
     ].transform(lambda x: (x.rank(pct=True) * 10).apply(np.ceil).astype(int))
     # Modify the lambda function to pass both full_terms and significant_significance_score
     top_annotation["combined_terms"] = top_annotation.apply(
@@ -245,6 +245,12 @@ def _safeguard_matrix(matrix: np.ndarray) -> np.ndarray:
     Returns:
         np.ndarray: Safeguarded data matrix.
     """
+    # Safety guard: handle empty or invalid matrices
+    if matrix.size == 0 or not np.isfinite(matrix).any():
+        logger.warning(
+            "Input matrix is empty or contains no finite values. Returning a zero matrix of same shape."
+        )
+        return np.zeros(matrix.shape, dtype=float)
     # Replace NaN with column mean
     nan_replacement = np.nanmean(matrix, axis=0)
     matrix = np.where(np.isnan(matrix), nan_replacement, matrix)
@@ -267,7 +273,7 @@ def _optimize_silhouette_across_linkage_and_metrics(
     linkage_threshold: Union[str, float],
 ) -> Tuple[str, str, float]:
     """
-    Optimize silhouette score across different linkage methods and distance metrics.
+    Optimize silhouette score across different linkage methods and metrics.
 
     Args:
         m (np.ndarray): Data matrix.

risk/{_log → log}/__init__.py

@@ -3,8 +3,8 @@ risk/_log
 ~~~~~~~~~
 """
 
-from ._console import log_header, logger, set_global_verbosity
-from ._parameters import Params
+from .console import log_header, logger, set_global_verbosity
+from .parameters import Params
 
 # Initialize the global parameters logger
 params = Params()

risk/{_log/_console.py → log/console.py}

@@ -1,6 +1,6 @@
 """
-risk/_log/_console
-~~~~~~~~~~~~~~~~~~
+risk/log/console
+~~~~~~~~~~~~~~~~
 """
 
 import logging

risk/{_log/_parameters.py → log/parameters.py}

@@ -1,6 +1,6 @@
 """
-risk/_log/_parameters
-~~~~~~~~~~~~~~~~~~~~~
+risk/log/parameters
+~~~~~~~~~~~~~~~~~~~
 """
 
 import csv
@@ -11,7 +11,7 @@ from typing import Any, Dict
 
 import numpy as np
 
-from ._console import log_header, logger
+from .console import log_header, logger
 
 # Suppress all warnings - this is to resolve warnings from multiprocessing
 warnings.filterwarnings("ignore")
@@ -22,7 +22,7 @@ class Params:
     Handles the storage and logging of various parameters for network analysis.
 
     The Params class provides methods to log parameters related to different components of the analysis,
-    such as the network, annotation, neighborhoods, graph, and plotter settings. It also stores
+    such as the network, annotation, clusters, graph, and plotter settings. It also stores
     the current datetime when the parameters were initialized.
     """
 
@@ -35,7 +35,8 @@ class Params:
         """Initialize the parameter dictionaries for different components."""
         self.network = {}
         self.annotation = {}
-        self.neighborhoods = {}
+        self.clusters = {}
+        self.stats = {}
         self.graph = {}
         self.plotter = {}
 
@@ -57,14 +58,23 @@ class Params:
         """
         self.annotation = {**self.annotation, **kwargs}
 
-    def log_neighborhoods(self, **kwargs) -> None:
+    def log_clusters(self, **kwargs) -> None:
         """
-        Log neighborhood-related parameters.
+        Log cluster-related parameters.
 
         Args:
-            **kwargs: Neighborhood parameters to log.
+            **kwargs: Cluster parameters to log.
         """
-        self.neighborhoods = {**self.neighborhoods, **kwargs}
+        self.clusters = {**self.clusters, **kwargs}
+
+    def log_stats(self, **kwargs) -> None:
+        """
+        Log statistical test-related parameters.
+
+        Args:
+            **kwargs: Statistical test parameters to log.
+        """
+        self.stats = {**self.stats, **kwargs}
 
     def log_graph(self, **kwargs) -> None:
         """
@@ -152,7 +162,7 @@ class Params:
                 "annotation": self.annotation,
                 "datetime": self.datetime,
                 "graph": self.graph,
-                "neighborhoods": self.neighborhoods,
+                "clusters": self.clusters,
                 "network": self.network,
                 "plotter": self.plotter,
             }

risk/network/__init__.py

@@ -0,0 +1,8 @@
+"""
+risk/_network
+~~~~~~~~~~~~~
+"""
+
+from .graph import GraphAPI
+from .io import NetworkAPI
+from .plotter import PlotterAPI

risk/network/graph/__init__.py

@@ -0,0 +1,7 @@
+"""
+risk/network/graph
+~~~~~~~~~~~~~~~~~~
+"""
+
+from .api import GraphAPI
+from .graph import Graph

risk/{_network/_graph → network/graph}/_stats.py

@@ -1,6 +1,6 @@
 """
-risk/_network/_graph/_stats
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/graph/_stats
+~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import Any, Dict, Union

risk/{_network/_graph → network/graph}/_summary.py

@@ -1,6 +1,6 @@
 """
-risk/_network/_graph/_summary
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/graph/_summary
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import Any, Dict, Tuple, Union
@@ -9,35 +9,35 @@ import numpy as np
 import pandas as pd
 from statsmodels.stats.multitest import fdrcorrection
 
-from ..._log import log_header, logger
+from ...log import log_header, logger
 
 
 class Summary:
     """
     Handles the processing, storage, and export of network analysis results.
 
-    The Results class provides methods to process significance and depletion data, compute
-    FDR-corrected q-values, and structure information on domains and annotations into a
-    DataFrame. It also offers functionality to export the processed data in CSV, JSON,
-    and text formats for analysis and reporting.
+    The Summary class provides methods to process significance and depletion data,
+    compute FDR-corrected q-values, and structure information on domains and
+    annotations into a DataFrame. It also offers functionality to export the
+    processed data in CSV, JSON, and text formats for analysis and reporting.
     """
 
     def __init__(
         self,
         annotation: Dict[str, Any],
-        neighborhoods: Dict[str, Any],
+        stats_results: Dict[str, Any],
         graph,  # Avoid type hinting Graph to prevent circular imports
     ):
         """
-        Initialize the Results object with analysis components.
+        Initialize the Summary object with analysis components.
 
         Args:
             annotation (Dict[str, Any]): Annotation data, including ordered annotations and matrix of associations.
-            neighborhoods (Dict[str, Any]): Neighborhood data containing p-values for significance and depletion analysis.
+            stats_results (Dict[str, Any]): Cluster data containing p-values for significance and depletion analysis.
             graph (Graph): Graph object representing domain-to-node and node-to-label mappings.
         """
         self.annotation = annotation
-        self.neighborhoods = neighborhoods
+        self.stats_results = stats_results
         self.graph = graph
 
     def to_csv(self, filepath: str) -> None:
@@ -88,8 +88,8 @@ class Summary:
         """
         log_header("Loading analysis summary")
         # Calculate significance and depletion q-values from p-value matrices in annotation
-        enrichment_pvals = self.neighborhoods["enrichment_pvals"]
-        depletion_pvals = self.neighborhoods["depletion_pvals"]
+        enrichment_pvals = self.stats_results["enrichment_pvals"]
+        depletion_pvals = self.stats_results["depletion_pvals"]
         enrichment_qvals = self._calculate_qvalues(enrichment_pvals)
         depletion_qvals = self._calculate_qvalues(depletion_pvals)
 

risk/{_network/_graph/_api.py → network/graph/api.py}

@@ -1,6 +1,6 @@
 """
-risk/_network/_graph/_api
-~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/graph/api
+~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import copy
@@ -9,14 +9,14 @@ from typing import Any, Dict, Union
 import networkx as nx
 import pandas as pd
 
-from ..._annotation import define_top_annotation
-from ..._log import log_header, logger, params
-from ..._neighborhoods import (
+from ...annotation import define_top_annotation
+from ...log import log_header, logger, params
+from ...cluster import (
     define_domains,
-    process_neighborhoods,
+    process_significant_clusters,
     trim_domains,
 )
-from ._graph import Graph
+from .graph import Graph
 from ._stats import calculate_significance_matrices
 
 
@@ -24,14 +24,14 @@ class GraphAPI:
     """
     Handles the loading of network graphs and associated data.
 
-    The GraphAPI class provides methods to load and process network graphs, annotations, and neighborhoods.
+    The GraphAPI class provides methods to load and process network graphs, annotations, and cluster results.
     """
 
     def load_graph(
         self,
         network: nx.Graph,
         annotation: Dict[str, Any],
-        neighborhoods: Dict[str, Any],
+        stats_results: Dict[str, Any],
         tail: str = "right",
         pval_cutoff: float = 0.01,
         fdr_cutoff: float = 0.9999,
@@ -50,7 +50,7 @@ class GraphAPI:
         Args:
             network (nx.Graph): The network graph.
             annotation (Dict[str, Any]): The annotation associated with the network.
-            neighborhoods (Dict[str, Any]): Neighborhood significance data.
+            stats_results (Dict[str, Any]): Cluster significance 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.
             fdr_cutoff (float, optional): FDR cutoff for significance. Defaults to 0.9999.
@@ -62,14 +62,14 @@ class GraphAPI:
                 Defaults to "yule".
             linkage_threshold (float, str, optional): Threshold for clustering. Choose "auto" to optimize.
                 Defaults to 0.2.
-            min_cluster_size (int, optional): Minimum size for clusters. Defaults to 5.
-            max_cluster_size (int, optional): Maximum size for clusters. Defaults to 1000.
+            min_cluster_size (int, optional): Minimum size for significant clusters. Defaults to 5.
+            max_cluster_size (int, optional): Maximum size for significant clusters. Defaults to 1000.
 
         Returns:
             Graph: A fully initialized and processed Graph object.
         """
         # Log the parameters and display headers
-        log_header("Finding significant neighborhoods")
+        log_header("Finding significant clusters")
         params.log_graph(
             tail=tail,
             pval_cutoff=pval_cutoff,
@@ -92,20 +92,20 @@ class GraphAPI:
         logger.debug(
             f"Significance tail: '{tail}' ({'enrichment' if tail == 'right' else 'depletion' if tail == 'left' else 'both'})"
         )
-        # Calculate significant neighborhoods based on the provided parameters
-        significant_neighborhoods = calculate_significance_matrices(
-            neighborhoods["depletion_pvals"],
-            neighborhoods["enrichment_pvals"],
+        # Calculate significant clusters based on the provided parameters
+        significant_clusters = calculate_significance_matrices(
+            stats_results["depletion_pvals"],
+            stats_results["enrichment_pvals"],
             tail=tail,
             pval_cutoff=pval_cutoff,
             fdr_cutoff=fdr_cutoff,
         )
 
-        log_header("Processing neighborhoods")
-        # Process neighborhoods by imputing and pruning based on the given settings
-        processed_neighborhoods = process_neighborhoods(
+        log_header("Processing significant clusters")
+        # Process significant clusters by imputing and pruning based on the given settings
+        processed_clusters = process_significant_clusters(
             network=network,
-            neighborhoods=significant_neighborhoods,
+            significant_clusters=significant_clusters,
             impute_depth=impute_depth,
             prune_threshold=prune_threshold,
         )
@@ -113,24 +113,22 @@ class GraphAPI:
         log_header("Finding top annotations")
         logger.debug(f"Min cluster size: {min_cluster_size}")
         logger.debug(f"Max cluster size: {max_cluster_size}")
-        # Define top annotations based on processed neighborhoods
+        # Define top annotations based on processed significant clusters
         top_annotation = self._define_top_annotation(
             network=network,
             annotation=annotation,
-            neighborhoods=processed_neighborhoods,
+            processed_clusters=processed_clusters,
             min_cluster_size=min_cluster_size,
             max_cluster_size=max_cluster_size,
         )
 
-        log_header("Optimizing distance threshold for domains")
-        # Extract the significant significance matrix from the neighborhoods data
-        significant_neighborhoods_significance = processed_neighborhoods[
-            "significant_significance_matrix"
-        ]
+        log_header("Grouping clusters into domains")
+        # Extract the significant significance matrix from the processed_clusters data
+        significant_clusters_significance = processed_clusters["significant_significance_matrix"]
         # Define domains in the network using the specified clustering settings
         domains = define_domains(
             top_annotation=top_annotation,
-            significant_neighborhoods_significance=significant_neighborhoods_significance,
+            significant_clusters_significance=significant_clusters_significance,
             linkage_criterion=linkage_criterion,
             linkage_method=linkage_method,
             linkage_metric=linkage_metric,
@@ -147,13 +145,13 @@ class GraphAPI:
         # Prepare node mapping and significance sums for the final Graph object
         ordered_nodes = annotation["ordered_nodes"]
         node_label_to_id = dict(zip(ordered_nodes, range(len(ordered_nodes))))
-        node_significance_sums = processed_neighborhoods["node_significance_sums"]
+        node_significance_sums = processed_clusters["node_significance_sums"]
 
         # Return the fully initialized Graph object
         return Graph(
             network=network,
             annotation=annotation,
-            neighborhoods=neighborhoods,
+            stats_results=stats_results,
             domains=domains,
             trimmed_domains=trimmed_domains,
             node_label_to_node_id_map=node_label_to_id,
@@ -164,7 +162,7 @@ class GraphAPI:
         self,
         network: nx.Graph,
         annotation: Dict[str, Any],
-        neighborhoods: Dict[str, Any],
+        processed_clusters: Dict[str, Any],
         min_cluster_size: int = 5,
         max_cluster_size: int = 1000,
     ) -> pd.DataFrame:
@@ -174,25 +172,25 @@ class GraphAPI:
         Args:
             network (nx.Graph): The network graph.
             annotation (Dict[str, Any]): Annotation data for the network.
-            neighborhoods (Dict[str, Any]): Neighborhood significance data.
+            processed_clusters (Dict[str, Any]): Processed cluster significance data.
             min_cluster_size (int, optional): Minimum size for clusters. Defaults to 5.
             max_cluster_size (int, optional): Maximum size for clusters. Defaults to 1000.
 
         Returns:
-            Dict[str, Any]: Top annotations identified within the network.
+            pd.DataFrame: Top annotations identified within the network.
         """
-        # Extract necessary data from annotation and neighborhoods
+        # Extract necessary data from annotation and processed_clusters
         ordered_annotation = annotation["ordered_annotation"]
-        neighborhood_significance_sums = neighborhoods["neighborhood_significance_counts"]
-        significant_significance_matrix = neighborhoods["significant_significance_matrix"]
-        significant_binary_significance_matrix = neighborhoods[
+        cluster_significance_sums = processed_clusters["cluster_significance_counts"]
+        significant_significance_matrix = processed_clusters["significant_significance_matrix"]
+        significant_binary_significance_matrix = processed_clusters[
             "significant_binary_significance_matrix"
         ]
         # Call external function to define top annotations
         return define_top_annotation(
             network=network,
             ordered_annotation_labels=ordered_annotation,
-            neighborhood_significance_sums=neighborhood_significance_sums,
+            cluster_significance_sums=cluster_significance_sums,
             significant_significance_matrix=significant_significance_matrix,
             significant_binary_significance_matrix=significant_binary_significance_matrix,
             min_cluster_size=min_cluster_size,

risk/{_network/_graph/_graph.py → network/graph/graph.py}

@@ -1,6 +1,6 @@
 """
-risk/_network/_graph/_graph
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/graph/graph
+~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from collections import defaultdict
@@ -27,7 +27,7 @@ class Graph:
         self,
         network: nx.Graph,
         annotation: Dict[str, Any],
-        neighborhoods: Dict[str, Any],
+        stats_results: Dict[str, Any],
         domains: pd.DataFrame,
         trimmed_domains: pd.DataFrame,
         node_label_to_node_id_map: Dict[str, Any],
@@ -40,7 +40,7 @@ class Graph:
         Args:
             network (nx.Graph): The network graph.
             annotation (Dict[str, Any]): The annotation associated with the network.
-            neighborhoods (Dict[str, Any]): Neighborhood significance data.
+            stats_results (Dict[str, Any]): Cluster significance data.
             domains (pd.DataFrame): DataFrame containing domain data for the network nodes.
             trimmed_domains (pd.DataFrame): DataFrame containing trimmed domain data for the network nodes.
             node_label_to_node_id_map (Dict[str, Any]): A dictionary mapping node labels to their corresponding IDs.
@@ -72,7 +72,7 @@ class Graph:
         self.node_coordinates = self._extract_node_coordinates(self.network)
 
         # NOTE: Only after the above attributes are initialized, we can create the summary
-        self.summary = Summary(annotation, neighborhoods, self)
+        self.summary = Summary(annotation, stats_results, self)
 
     def pop(self, domain_id: int) -> List[str]:
         """

risk/{_network/_io.py → network/io.py}

@@ -1,6 +1,6 @@
 """
-risk/_network/_io
-~~~~~~~~~~~~~~~~~
+risk/network/io
+~~~~~~~~~~~~~~~
 """
 
 import copy
@@ -15,7 +15,7 @@ import networkx as nx
 import numpy as np
 import pandas as pd
 
-from .._log import log_header, logger, params
+from ..log import log_header, logger, params
 
 
 class NetworkAPI:
@@ -370,7 +370,7 @@ class NetworkIO:
         self._log_loading_network(filetype, filepath=filepath)
 
         # Load the Cytoscape JSON file
-        with open(filepath, "r") as f:
+        with open(filepath, "r", encoding="utf-8") as f:
             cyjs_data = json.load(f)
 
         # Create a graph
@@ -603,6 +603,11 @@ class NetworkIO:
         distances = compute_distance_vectorized(edge_data, compute_sphere)
         # Assign Euclidean or spherical distances to edges
         for (u, v), distance in zip(G.edges, distances):
+            if not np.isfinite(distance) or distance <= 0:
+                logger.warning(
+                    f"Edge ({u},{v}) has invalid or non-positive length ({distance}); replaced with minimal fallback 1e-12."
+                )
+                distance = 1e-12
             G.edges[u, v]["length"] = distance
 
     def _map_to_sphere(self, G: nx.Graph) -> None:

risk/network/plotter/__init__.py

@@ -0,0 +1,6 @@
+"""
+risk/network/plotter
+~~~~~~~~~~~~~~~~~~~~
+"""
+
+from .api import PlotterAPI

risk/{_network/_plotter → network/plotter}/_canvas.py

@@ -1,6 +1,6 @@
 """
-risk/_network/_plotter/_canvas
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/_canvas
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import List, Tuple, Union
@@ -8,10 +8,10 @@ from typing import List, Tuple, Union
 import matplotlib.pyplot as plt
 import numpy as np
 
-from ..._log import params
-from .._graph import Graph
-from ._utils._colors import to_rgba
-from ._utils._layout import calculate_bounding_box
+from ...log import params
+from ..graph import Graph
+from ._utils.colors import to_rgba
+from ._utils.layout import calculate_bounding_box
 
 
 class Canvas:

risk/{_network/_plotter → network/plotter}/_contour.py

@@ -1,6 +1,6 @@
 """
-risk/_network/_plotter/_contour
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/_contour
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 from typing import Any, Dict, List, Tuple, Union
@@ -11,8 +11,8 @@ from scipy import linalg
 from scipy.ndimage import label
 from scipy.stats import gaussian_kde
 
-from ..._log import logger, params
-from .._graph import Graph
+from ...log import logger, params
+from ..graph import Graph
 from ._utils import get_annotated_domain_colors, to_rgba
 
 

risk/{_network/_plotter → network/plotter}/_labels.py

@@ -1,6 +1,6 @@
 """
-risk/_network/_plotter/_labels
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+risk/network/plotter/_labels
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 """
 
 import copy
@@ -10,8 +10,8 @@ import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 
-from ..._log import params
-from .._graph import Graph
+from ...log import params
+from ..graph import Graph
 from ._utils import calculate_bounding_box, get_annotated_domain_colors, to_rgba
 
 TERM_DELIMITER = "::::"  # String used to separate multiple domain terms when constructing composite domain labels
@@ -275,12 +275,12 @@ class Labels:
             fontsize (int, optional): Font size for the label. Defaults to 10.
             fontcolor (str, List, Tuple, or np.ndarray, optional): Color of the label text. Defaults to "black".
             fontalpha (float, None, optional): Transparency level for the font color. If provided, it overrides any existing alpha values found
-                in fontalpha. Defaults to 1.0.
+                in fontcolor. Defaults to 1.0.
             arrow_linewidth (float, optional): Line width of the arrow pointing to the centroid. Defaults to 1.
             arrow_style (str, optional): Style of the arrows pointing to the centroid. Defaults to "->".
             arrow_color (str, List, Tuple, or np.ndarray, optional): Color of the arrow. Defaults to "black".
             arrow_alpha (float, None, optional): Transparency level for the arrow color. If provided, it overrides any existing alpha values
-                found in arrow_alpha. Defaults to 1.0.
+                found in arrow_color. Defaults to 1.0.
             arrow_base_shrink (float, optional): Distance between the text and the base of the arrow. Defaults to 0.0.
             arrow_tip_shrink (float, optional): Distance between the arrow tip and the centroid. Defaults to 0.0.