pythonflex 0.3.3__tar.gz → 0.4__tar.gz

pythonflex-0.3.3/src/pythonflex/plotting.py → pythonflex-0.4/.codex_backups/plotting.py.20260601-121332.bak

@@ -9,6 +9,7 @@ import pandas as pd
 import matplotlib.pyplot as plt
 from matplotlib import patches
 from matplotlib.cm import get_cmap
+from matplotlib.lines import Line2D
 from matplotlib.ticker import NullFormatter, NullLocator
 
 # Completely disable LaTeX and clear all font cache/references
@@ -33,7 +34,7 @@ mpl.rcParams['mathtext.default'] = 'regular'
 # Force font manager to rebuild with system fonts only
 try:
     fm.fontManager.__init__()
-except:
+except Exception:
     pass
 
 # Local modules
@@ -279,13 +280,27 @@ def plot_all_runs_pra(pra_list, mean_df=None, line_width=2.0, hide_minor_ticks=T
         plt.show()
     plt.close(fig)
 
-def plot_percomplex_scatter(n_top=10, sig_color='#B71A2A', nonsig_color='#DBDDDD', label_color='black', border_color='black', border_width=1.0, show_text_background=True):
-    config = dload("config")
-    plot_config = config["plotting"]
-    rdict = dload("pra_percomplex")
+def plot_percomplex_scatter(
+    n_top=10,
+    sig_color='black',
+    nonsig_color='none',
+    label_color='black',
+    border_color='black',
+    border_width=1.0,
+    nonsig_border_color="#7F7F7F",
+    nonsig_border_width=0.5,
+    show_text_background=True,
+):
+    config = dload("config")
+    plot_config = config["plotting"]
+    rdict = dload("pra_percomplex")
+    input_colors = dload("input", "colors")
+    input_colors = {_sanitize(k): v for k, v in input_colors.items()} if input_colors else {}
 
     if len(rdict) < 2:
-        print("Skipping plot: At least two datasets are required for per-complex scatter plot.")
+        log.warning(
+            "Skipping plot: at least two datasets are required for per-complex scatter plot."
+        )
         return
 
     column_pairs = list(combinations(rdict.keys(), 2))
@@ -299,32 +314,61 @@ def plot_percomplex_scatter(n_top=10, sig_color='#B71A2A', nonsig_color='#DBDDDD
             df = pd.concat([df, val[key]], axis=1)
 
     for pair in column_pairs:
-        extreme_indices_0 = df[pair[0]].sort_values(ascending=False).head(n_top).index
-        extreme_indices_1 = df[pair[1]].sort_values(ascending=False).head(n_top).index
-        significant_indices = extreme_indices_0.union(extreme_indices_1)
-
-        bg_df  = df.drop(index=significant_indices)
-        sig_df = df.loc[significant_indices]
-
-        # Create square figure
-        fig, ax = plt.subplots(figsize=(6, 6))
-
-        # Background cloud (filled dots with black borders, not rasterized)
-        bg_sizes = (bg_df['n_used_genes'] if 'n_used_genes' in bg_df else pd.Series(1, index=bg_df.index)) * 5
-        ax.scatter(
-            bg_df[pair[0]], bg_df[pair[1]],
-            facecolors=nonsig_color, edgecolors=border_color,
-            s=bg_sizes, linewidth=border_width, alpha=1.0,
-            zorder=0
-        )
-
-        # Significant points (filled dots with black borders)
-        sig_sizes = (sig_df['n_used_genes'] if 'n_used_genes' in sig_df else pd.Series(1, index=sig_df.index)) * 8
-        ax.scatter(
-            sig_df[pair[0]], sig_df[pair[1]],
-            facecolors=sig_color, edgecolors=border_color,
-            s=sig_sizes, linewidth=border_width, zorder=2
-        )
+        extreme_indices_0 = df[pair[0]].sort_values(ascending=False).head(n_top).index
+        extreme_indices_1 = df[pair[1]].sort_values(ascending=False).head(n_top).index
+        significant_indices = extreme_indices_0.union(extreme_indices_1)
+        significant_in_both = extreme_indices_0.intersection(extreme_indices_1)
+        significant_pair0_only = extreme_indices_0.difference(extreme_indices_1)
+        significant_pair1_only = extreme_indices_1.difference(extreme_indices_0)
+
+        bg_df  = df.drop(index=significant_indices)
+        sig_df = df.loc[significant_indices]
+        sig_sizes = (
+            sig_df['n_used_genes']
+            if 'n_used_genes' in sig_df
+            else pd.Series(1, index=sig_df.index)
+        ) * 8
+
+        # Create square figure
+        fig, ax = plt.subplots(figsize=(6, 6))
+
+        # Background cloud: non-significant complexes are open circles.
+        bg_sizes = (bg_df['n_used_genes'] if 'n_used_genes' in bg_df else pd.Series(1, index=bg_df.index)) * 5
+        ax.scatter(
+            bg_df[pair[0]], bg_df[pair[1]],
+            facecolors="none", edgecolors=nonsig_border_color,
+            s=bg_sizes, linewidth=nonsig_border_width, alpha=0.8,
+            zorder=0
+        )
+
+        def scatter_significant(indices, color, zorder=2):
+            if len(indices) == 0:
+                return
+            point_df = df.loc[indices]
+            point_sizes = (
+                point_df['n_used_genes']
+                if 'n_used_genes' in point_df
+                else pd.Series(1, index=point_df.index)
+            ) * 8
+            ax.scatter(
+                point_df[pair[0]], point_df[pair[1]],
+                facecolors=color, edgecolors=color,
+                s=point_sizes, linewidth=border_width, zorder=zorder
+            )
+
+        # Dataset-specific significant complexes use the dataset input color.
+        scatter_significant(
+            significant_pair0_only,
+            input_colors.get(_sanitize(pair[0]), sig_color),
+            zorder=2,
+        )
+        scatter_significant(
+            significant_pair1_only,
+            input_colors.get(_sanitize(pair[1]), sig_color),
+            zorder=2,
+        )
+        # Complexes significant in both datasets stay black to avoid ambiguous color mixing.
+        scatter_significant(significant_in_both, "black", zorder=3)
 
         # Improved label positioning with adaptive spacing
         coords = sorted(
@@ -894,16 +938,28 @@ def position_cluster_labels(cluster, cluster_id, max_y, effective_max_y, label_c
                     clip_on=True, bbox=bbox_props
                 )
 
-def plot_percomplex_scatter_bysize(n_labels=10, n_top=10, sig_color='#B71A2A', nonsig_color='#DBDDDD', 
-                                   label_color='black', border_color='black', border_width=1.0, 
-                                   show_text_background=True):
-    config = dload("config")
-    plot_config = config["plotting"]
-    rdict = dload("pra_percomplex")
-
-    for key, per_complex in rdict.items():
-        sorted_pc = per_complex.sort_values(by="auc_score", ascending=False, na_position="last")
-        top_labels, rest = sorted_pc.head(n_labels), sorted_pc.iloc[n_labels:]
+def plot_percomplex_scatter_bysize(
+    n_labels=10,
+    n_top=10,
+    sig_color='black',
+    nonsig_color='none',
+    label_color='black',
+    border_color='black',
+    border_width=1.0,
+    nonsig_border_color="#7F7F7F",
+    nonsig_border_width=0.5,
+    show_text_background=True,
+):
+    config = dload("config")
+    plot_config = config["plotting"]
+    rdict = dload("pra_percomplex")
+    input_colors = dload("input", "colors")
+    input_colors = {_sanitize(k): v for k, v in input_colors.items()} if input_colors else {}
+
+    for key, per_complex in rdict.items():
+        dataset_color = input_colors.get(_sanitize(key), sig_color)
+        sorted_pc = per_complex.sort_values(by="auc_score", ascending=False, na_position="last")
+        top_labels, rest = sorted_pc.head(n_labels), sorted_pc.iloc[n_labels:]
 
         # Calculate data range for appropriate figure sizing
         max_genes = sorted_pc.n_used_genes.max()
@@ -914,22 +970,22 @@ def plot_percomplex_scatter_bysize(n_labels=10, n_top=10, sig_color='#B71A2A', n
         fig_height = min(max(4, aspect_ratio), 8)  # Between 4-8 inches
         fig, ax = plt.subplots(figsize=(6, fig_height))
 
-        # Background (REST): filled dots with black borders, not rasterized
-        ax.scatter(
-            rest.auc_score, rest.n_used_genes,
-            facecolors=nonsig_color, edgecolors=border_color,
-            linewidth=border_width, s=rest.n_used_genes * 5,
-            alpha=1.0, label="Other Complexes",
-            zorder=0
-        )
-
-        # Top N: filled dots with black borders
-        ax.scatter(
-            top_labels.auc_score, top_labels.n_used_genes,
-            facecolors=sig_color, edgecolors=border_color,
-            linewidth=border_width, s=top_labels.n_used_genes * 8,
-            label=f"Top {n_labels} AUC Scores", alpha=1.0, zorder=2
-        )
+        # Background: non-significant complexes are open circles.
+        ax.scatter(
+            rest.auc_score, rest.n_used_genes,
+            facecolors="none", edgecolors=nonsig_border_color,
+            linewidth=nonsig_border_width, s=rest.n_used_genes * 5,
+            alpha=0.8, label="Other Complexes",
+            zorder=0
+        )
+
+        # Top N/significant complexes are filled black circles.
+        ax.scatter(
+            top_labels.auc_score, top_labels.n_used_genes,
+            facecolors=dataset_color, edgecolors=dataset_color,
+            linewidth=border_width, s=top_labels.n_used_genes * 8,
+            label=f"Top {n_labels} AUC Scores", alpha=1.0, zorder=2
+        )
 
         # Enhanced anti-overlap labeling system
         coords = [(row.auc_score, row.n_used_genes, idx) for idx, row in top_labels.iterrows()]
@@ -1010,6 +1066,7 @@ def plot_complex_contributions(
         tmp = np.tile(x, (mx, 1))
         x = cont_stepwise_mat.values / tmp
         x_df = pd.DataFrame(x, index=cont_stepwise_anno, columns=cont_stepwise_mat.columns)
+
         ind_for_mean = y >= (last_prec_value - min_precision_cutoff)
         if sum(ind_for_mean) == 0:
             log.info("No values above 'min.precision.cutoff'"); return False
@@ -1094,15 +1151,23 @@ def plot_significant_complexes():
         input_colors = {_sanitize(k): v for k, v in input_colors.items()}
 
     thresholds = [0.1, 0.2, 0.3, 0.4, 0.5]
+    if not isinstance(pra_percomplex, dict) or not pra_percomplex:
+        log.warning("No per-complex PRA data found. Run pra_percomplex() first.")
+        return pd.DataFrame(index=thresholds)
+
     datasets = list(pra_percomplex.keys())
     num_datasets = len(datasets)
 
+    if num_datasets == 0:
+        return pd.DataFrame(index=thresholds)
+
     df = pd.DataFrame(index=thresholds)
     for key, complex_data in pra_percomplex.items():
         if "corrected_auc_score" in complex_data.columns:
             score_col = "corrected_auc_score"
         else:
             score_col = "auc_score"
+
         df[key] = [complex_data.query(f'{score_col} >= {t}').shape[0] for t in thresholds]
 
     fig, ax = plt.subplots()
@@ -1221,15 +1286,20 @@ def plot_auc_scores():
     return pra_dict
 
 
-def plot_mpr_complexes_auc_scores(filter_key: str = "all"):
+def plot_mpr_complex_auc_scores(variant: str = "unfiltered", save=None, outname=None):
     """Plot AUC scores for the mPR complexes curve (Fig 1F-style).
 
     Requires `mpr_prepare()` to have been run for each dataset.
 
     Parameters
     ----------
-    filter_key : str
-        One of: "all", "no_mtRibo_ETCI", "no_small_highAUPRC".
+    variant : str
+        One of: "unfiltered", "without_mt_ribo_etci",
+        "without_small_high_auprc".
+    save : bool, optional
+        Whether to save the figure. If None, uses config["plotting"]["save_plot"].
+    outname : str, optional
+        Output filename. If None, auto-generated.
 
     Returns
     -------
@@ -1250,12 +1320,14 @@ def plot_mpr_complexes_auc_scores(filter_key: str = "all"):
         )
         return pd.Series(dtype=float)
 
+    variant_key = _normalize_mpr_variant(variant)
+
     # Build Series: dataset -> auc
     auc_by_dataset = {}
     for dataset, per_filter in mpr_auc_dict.items():
         if not isinstance(per_filter, dict):
             continue
-        val = per_filter.get(filter_key)
+        val = per_filter.get(variant_key)
         if val is None:
             continue
         try:
@@ -1265,7 +1337,8 @@ def plot_mpr_complexes_auc_scores(filter_key: str = "all"):
 
     if not auc_by_dataset:
         log.warning(
-            f"No mPR complexes AUC scores found for filter '{filter_key}'. Available filters: {list(FILTER_STYLES.keys())}"
+            f"No mPR complex AUC scores found for variant '{variant}'. "
+            f"Available variants: {list(PUBLIC_MPR_VARIANTS.keys())}"
         )
         return pd.Series(dtype=float)
 
@@ -1308,11 +1381,16 @@ def plot_mpr_complexes_auc_scores(filter_key: str = "all"):
     ax.spines["top"].set_visible(False)
     ax.spines["right"].set_visible(False)
 
-    if plot_config.get("save_plot", False):
+    should_save = plot_config.get("save_plot", False) if save is None else bool(save)
+    if should_save:
         output_type = plot_config.get("output_type", "pdf")
         output_folder = Path(config["output_folder"])
         output_folder.mkdir(parents=True, exist_ok=True)
-        output_path = output_folder / f"mpr_complexes_auc_{filter_key}.{output_type}"
+        if outname is None:
+            outname = f"mpr_complexes_auc_{variant_key}.{output_type}"
+        output_path = Path(outname)
+        if len(output_path.parts) == 1:
+            output_path = output_folder / outname
         plt.savefig(output_path, bbox_inches="tight", format=output_type)
 
     if plot_config.get("show_plot", True):
@@ -1321,6 +1399,13 @@ def plot_mpr_complexes_auc_scores(filter_key: str = "all"):
     plt.close(fig)
     return s
 
+
+def plot_mpr_complexes_auc_scores(filter_key: str = "all"):
+    """Backward-compatible wrapper for plot_mpr_complex_auc_scores()."""
+    return plot_mpr_complex_auc_scores(
+        variant=_legacy_filter_to_variant(filter_key, default="unfiltered")
+    )
+
 # -----------------------------------------------------------------------------
 # mPR plots (Fig. 1E and Fig. 1F)
 # -----------------------------------------------------------------------------
@@ -1475,26 +1560,6 @@ def plot_mpr_tp(name, ax=None, save=True, outname=None):
 
     return ax
 
-"""
-Multi-dataset mPR plotting functions.
-
-Usage:
-    from pythonflex.plotting import plot_mpr_tp_multi, plot_mpr_complexes_multi
-    
-    # Plot multiple datasets
-    plot_mpr_tp_multi(["19Q2", "19Q4", "20Q1"])
-    plot_mpr_complexes_multi(["19Q2", "19Q4", "20Q1"])
-"""
-
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-from matplotlib.lines import Line2D
-from pathlib import Path
-
-from .utils import dload
-from .logging_config import log
-
 # Default color palette (colorblind-friendly)
 DEFAULT_COLORS = [
     "#4E79A7",  # blue
@@ -1509,40 +1574,101 @@ DEFAULT_COLORS = [
     "#BAB0AC",  # gray
 ]
 
-# Filter line styles
-FILTER_STYLES = {
+# Public mPR variant names map to the internal keys stored by mpr_prepare().
+PUBLIC_MPR_VARIANTS = {
+    "unfiltered": "all",
+    "without_mt_ribo_etci": "no_mtRibo_ETCI",
+    "without_small_high_auprc": "no_small_highAUPRC",
+}
+INTERNAL_MPR_VARIANTS = {v: k for k, v in PUBLIC_MPR_VARIANTS.items()}
+
+# mPR variant line styles keyed by internal storage names.
+MPR_VARIANT_STYLES = {
     "all": {"linestyle": "-", "label": "all data"},
     "no_mtRibo_ETCI": {"linestyle": "--", "label": "no mtRibo, ETC I"},
     "no_small_highAUPRC": {"linestyle": "dotted", "label": "no small, high AUPRC"},
 }
 
+# Compatibility alias for users who imported this internal constant.
+FILTER_STYLES = MPR_VARIANT_STYLES
+
+
+def _normalize_mpr_variant(variant):
+    """Return the internal mPR variant key for one public variant name."""
+    if variant in PUBLIC_MPR_VARIANTS:
+        return PUBLIC_MPR_VARIANTS[variant]
+    if variant in MPR_VARIANT_STYLES:
+        if variant == "all":
+            return PUBLIC_MPR_VARIANTS["unfiltered"]
+        return variant
+    raise ValueError(
+        "Unknown mPR variant "
+        f"{variant!r}. Use one of {list(PUBLIC_MPR_VARIANTS.keys())}."
+    )
 
-def _normalize_show_filters(show_filters):
-    """Normalize show_filters to an ordered tuple of filter keys.
 
-    Common footgun: passing a single string (e.g. "no_mtRibo_ETCI") is iterable,
-    which would otherwise be treated as a sequence of characters.
-    """
+def _normalize_mpr_variants(variants):
+    """Normalize public mPR variant names to internal storage keys."""
+    if variants is None:
+        raw_variants = ("all",)
+    elif isinstance(variants, str):
+        raw_variants = (variants,)
+    else:
+        try:
+            raw_variants = tuple(variants)
+        except TypeError:
+            raw_variants = (variants,)
+
+    out = []
+    for variant in raw_variants:
+        if variant == "all":
+            out.extend(PUBLIC_MPR_VARIANTS.values())
+        else:
+            out.append(_normalize_mpr_variant(variant))
+
+    # Preserve user order while removing duplicates.
+    return tuple(dict.fromkeys(out))
+
+
+def _legacy_filter_to_variant(filter_key, default=None):
+    """Map old filter-key names to public variant names."""
+    if filter_key is None:
+        return default if default is not None else "all"
+    mapping = {
+        "all": "unfiltered",
+        "no_mtRibo_ETCI": "without_mt_ribo_etci",
+        "no_small_highAUPRC": "without_small_high_auprc",
+    }
+    return mapping.get(filter_key, filter_key)
+
+
+def _legacy_filters_to_variants(show_filters):
+    """Map old show_filters values to public variant names."""
     if show_filters is None:
-        return tuple(FILTER_STYLES.keys())
+        return "all"
     if isinstance(show_filters, str):
-        return (show_filters,)
+        return _legacy_filter_to_variant(show_filters)
     try:
-        return tuple(show_filters)
+        return tuple(_legacy_filter_to_variant(item) for item in show_filters)
     except TypeError:
-        return (show_filters,)
+        return (_legacy_filter_to_variant(show_filters),)
 
-def plot_mpr_tp_multi(
+
+def _normalize_show_filters(show_filters):
+    """Backward-compatible normalizer for old internal filter keys."""
+    return _normalize_mpr_variants(_legacy_filters_to_variants(show_filters))
+
+def plot_mpr_true_positive_curve(
     dataset_names=None,
     colors=None,
     ax=None,
     save=True,
     outname=None,
     linewidth=1.8,
-    show_filters=("all", "no_mtRibo_ETCI", "no_small_highAUPRC"),
+    variants="unfiltered",
 ):
     """
-    Plot TP vs precision curves for multiple datasets.
+    Plot mPR true-positive vs precision curves for multiple datasets.
     
     Can auto-detect datasets or use provided dataset names.
     Each dataset gets one color, each filter type gets one line style.
@@ -1562,8 +1688,9 @@ def plot_mpr_tp_multi(
         Output filename. If None, auto-generated.
     linewidth : float
         Line width for all curves
-    show_filters : tuple of str
-        Which filters to show. Default is all three.
+    variants : str or iterable of str
+        Which mPR variants to show. Use "unfiltered",
+        "without_mt_ribo_etci", "without_small_high_auprc", or "all".
     
     Returns
     -------
@@ -1573,7 +1700,7 @@ def plot_mpr_tp_multi(
     plot_config = config["plotting"]
     input_colors = dload("input", "colors")
 
-    show_filters = _normalize_show_filters(show_filters)
+    variant_keys = _normalize_mpr_variants(variants)
     
     # Sanitize color keys
     if input_colors:
@@ -1641,13 +1768,13 @@ def plot_mpr_tp_multi(
         tp_curves = mpr["tp_curves"]
         color = colors[i % len(colors)]
         
-        for filter_key in show_filters:
-            if filter_key not in tp_curves:
+        for variant_key in variant_keys:
+            if variant_key not in tp_curves:
                 continue
             
-            data = tp_curves[filter_key]
+            data = tp_curves[variant_key]
             if not isinstance(data, dict) or "tp" not in data or "precision" not in data:
-                log.warning(f"Invalid tp_curves data structure for '{name}' filter '{filter_key}', skipping.")
+                log.warning(f"Invalid tp_curves data structure for '{name}' variant '{variant_key}', skipping.")
                 continue
                 
             tp = np.asarray(data["tp"], dtype=float)
@@ -1661,7 +1788,7 @@ def plot_mpr_tp_multi(
             prec_plot = prec[mask]
             xmax = max(xmax, float(tp_plot.max()))
             
-            style = FILTER_STYLES.get(filter_key, {})
+            style = MPR_VARIANT_STYLES.get(variant_key, {})
             ax.plot(
                 tp_plot, 
                 prec_plot, 
@@ -1694,7 +1821,7 @@ def plot_mpr_tp_multi(
     ax.spines['right'].set_visible(False)
     
     # Create vertically stacked legends
-    _add_vertical_legend(ax, dataset_names, colors, show_filters, linewidth)
+    _add_vertical_legend(ax, dataset_names, colors, variant_keys, linewidth)
     
     # Save
     if save:
@@ -1713,7 +1840,8 @@ def plot_mpr_tp_multi(
     
     return ax
 
-def plot_mpr_complexes_multi(
+
+def plot_mpr_tp_multi(
     dataset_names=None,
     colors=None,
     ax=None,
@@ -1721,11 +1849,31 @@ def plot_mpr_complexes_multi(
     outname=None,
     linewidth=1.8,
     show_filters=("all", "no_mtRibo_ETCI", "no_small_highAUPRC"),
+):
+    """Backward-compatible wrapper for plot_mpr_true_positive_curve()."""
+    return plot_mpr_true_positive_curve(
+        dataset_names=dataset_names,
+        colors=colors,
+        ax=ax,
+        save=save,
+        outname=outname,
+        linewidth=linewidth,
+        variants=_legacy_filters_to_variants(show_filters),
+    )
+
+def plot_mpr_complex_coverage_curve(
+    dataset_names=None,
+    colors=None,
+    ax=None,
+    save=True,
+    outname=None,
+    linewidth=1.8,
+    variants="unfiltered",
     show_markers="auto",
     marker_size=20,
 ):
     """
-    Plot module-level PR (#complexes vs precision) for multiple datasets.
+    Plot mPR complex-coverage vs precision curves for multiple datasets.
     
     Can auto-detect datasets or use provided dataset names.
     Each dataset gets one color, each filter type gets one line style.
@@ -1745,8 +1893,9 @@ def plot_mpr_complexes_multi(
         Output filename. If None, auto-generated.
     linewidth : float
         Line width for all curves
-    show_filters : tuple of str
-        Which filters to show. Default is all three.
+    variants : str or iterable of str
+        Which mPR variants to show. Use "unfiltered",
+        "without_mt_ribo_etci", "without_small_high_auprc", or "all".
     show_markers : bool or "auto"
         If True, draw markers on curves to make short curves visible.
         If "auto" (default), markers are drawn only for curves with <= 10 points.
@@ -1761,7 +1910,7 @@ def plot_mpr_complexes_multi(
     plot_config = config["plotting"]
     input_colors = dload("input", "colors")
 
-    show_filters = _normalize_show_filters(show_filters)
+    variant_keys = _normalize_mpr_variants(variants)
     
     # Sanitize color keys
     if input_colors:
@@ -1812,32 +1961,61 @@ def plot_mpr_complexes_multi(
     else:
         fig = ax.figure
     
-    # Plot each dataset
+    # First pass: determine max coverage across all datasets/filters for adaptive x-axis
+    max_cov_global = 0
+    _mpr_cache = {}
     for i, name in enumerate(dataset_names):
         mpr = dload("mpr", name)
+        _mpr_cache[name] = mpr
+        if mpr is not None:
+            for variant_key in variant_keys:
+                arr = mpr["coverage_curves"].get(variant_key)
+                if arr is not None:
+                    max_cov_global = max(max_cov_global, float(np.asarray(arr).max()))
+
+    # Build adaptive x-axis limits and ticks
+    import math
+    if max_cov_global <= 200:
+        # Original fixed range — keeps CORUM plots identical to before
+        x_max_plot = 200
+        tick_positions = [1, 2, 20, 200]
+        tick_labels = ["0", "2", "20", "200"]
+    else:
+        # Round up to the next power of 10 so the max bar has breathing room
+        x_max_plot = 10 ** math.ceil(math.log10(max_cov_global + 1))
+        tick_positions = [1, 2]
+        v = 10
+        while v <= x_max_plot:
+            tick_positions.append(v)
+            v *= 10
+        tick_labels = ["0"] + [str(t) for t in tick_positions[1:]]
+
+    # Plot each dataset
+    for i, name in enumerate(dataset_names):
+        mpr = _mpr_cache[name]
         if mpr is None:
             log.warning(f"mPR data for '{name}' not found, skipping.")
             continue
-        
+
         precision_cutoffs = np.asarray(mpr["precision_cutoffs"], dtype=float)
         coverage = mpr["coverage_curves"]
         color = colors[i % len(colors)]
-        
-        for filter_key in show_filters:
-            if filter_key not in coverage:
+
+        for variant_key in variant_keys:
+            if variant_key not in coverage:
                 continue
-            
-            cov = np.asarray(coverage[filter_key], dtype=float)
-            
-            # Keep only positive coverage up to 200 complexes
-            mask = (cov > 0) & (cov <= 200)
+
+            cov = np.asarray(coverage[variant_key], dtype=float)
+
+            # Keep only positive coverage within the visible x range
+            mask = (cov > 0) & (cov <= x_max_plot)
             if not mask.any():
                 continue
-            
+
             cov_plot = cov[mask]
             prec_plot = precision_cutoffs[mask]
-            
-            style = FILTER_STYLES.get(filter_key, {})
+
+            style = MPR_VARIANT_STYLES.get(variant_key, {})
 
             # Decide marker visibility
             if show_markers == "auto":
@@ -1858,17 +2036,15 @@ def plot_mpr_complexes_multi(
                     marker=("o" if use_markers else None),
                     markersize=(3 if use_markers else None),
                 )
-    
+
     # Configure axes
     ax.set_xscale("log")
-    ax.set_xlim(1, 200)
+    ax.set_xlim(1, x_max_plot)
     ax.set_xlabel("# complexes")
     ax.set_ylabel("Precision")
     ax.set_ylim(0.0, 1.05)
-    
-    # Custom x-ticks
-    tick_positions = [1, 2, 20, 200]
-    tick_labels = ["0", "2", "20", "200"]
+
+    # Adaptive x-ticks
     ax.set_xticks(tick_positions)
     ax.set_xticklabels(tick_labels)
     
@@ -1877,7 +2053,7 @@ def plot_mpr_complexes_multi(
     ax.spines['right'].set_visible(False)
     
     # Create vertically stacked legends
-    _add_vertical_legend(ax, dataset_names, colors, show_filters, linewidth)
+    _add_vertical_legend(ax, dataset_names, colors, variant_keys, linewidth)
     
     # Save
     if save:
@@ -1896,11 +2072,71 @@ def plot_mpr_complexes_multi(
     
     return ax
 
-def _add_vertical_legend(ax, dataset_names, colors, show_filters, linewidth):
+
+def plot_mpr_complexes_multi(
+    dataset_names=None,
+    colors=None,
+    ax=None,
+    save=True,
+    outname=None,
+    linewidth=1.8,
+    show_filters=("all", "no_mtRibo_ETCI", "no_small_highAUPRC"),
+    show_markers="auto",
+    marker_size=20,
+):
+    """Backward-compatible wrapper for plot_mpr_complex_coverage_curve()."""
+    return plot_mpr_complex_coverage_curve(
+        dataset_names=dataset_names,
+        colors=colors,
+        ax=ax,
+        save=save,
+        outname=outname,
+        linewidth=linewidth,
+        variants=_legacy_filters_to_variants(show_filters),
+        show_markers=show_markers,
+        marker_size=marker_size,
+    )
+
+
+def plot_mpr_summary(
+    dataset_names=None,
+    colors=None,
+    variants="unfiltered",
+    save=True,
+    linewidth=1.8,
+    show_markers="auto",
+    marker_size=20,
+    auc_variant=None,
+):
+    """Generate the standard mPR summary plots and return complex AUC scores."""
+    plot_mpr_true_positive_curve(
+        dataset_names=dataset_names,
+        colors=colors,
+        save=save,
+        linewidth=linewidth,
+        variants=variants,
+    )
+    plot_mpr_complex_coverage_curve(
+        dataset_names=dataset_names,
+        colors=colors,
+        save=save,
+        linewidth=linewidth,
+        variants=variants,
+        show_markers=show_markers,
+        marker_size=marker_size,
+    )
+
+    if auc_variant is None:
+        variant_keys = _normalize_mpr_variants(variants)
+        auc_variant = INTERNAL_MPR_VARIANTS.get(variant_keys[0], "unfiltered")
+
+    return plot_mpr_complex_auc_scores(variant=auc_variant, save=save)
+
+def _add_vertical_legend(ax, dataset_names, colors, variant_keys, linewidth):
     """
-    Add vertically stacked legends: Dataset on top, Filter below.
+    Add vertically stacked legends: Dataset on top, mPR variant below.
     """
-    show_filters = _normalize_show_filters(show_filters)
+    variant_keys = _normalize_show_filters(variant_keys)
     # Legend 1: Datasets (colors) - solid lines
     dataset_handles = []
     for i, name in enumerate(dataset_names):
@@ -1908,19 +2144,19 @@ def _add_vertical_legend(ax, dataset_names, colors, show_filters, linewidth):
         handle = Line2D([0], [0], color=color, linewidth=linewidth, linestyle="-")
         dataset_handles.append(handle)
     
-    # Legend 2: Filters (line styles) - black lines
-    filter_handles = []
-    filter_labels = []
-    for filter_key in show_filters:
-        style = FILTER_STYLES.get(filter_key, {})
+    # Legend 2: mPR variants (line styles) - black lines
+    variant_handles = []
+    variant_labels = []
+    for variant_key in variant_keys:
+        style = MPR_VARIANT_STYLES.get(variant_key, {})
         handle = Line2D(
             [0], [0], 
             color="black", 
             linewidth=linewidth, 
             linestyle=style.get("linestyle", "-")
         )
-        filter_handles.append(handle)
-        filter_labels.append(style.get("label", filter_key))
+        variant_handles.append(handle)
+        variant_labels.append(style.get("label", variant_key))
     
     # Position legends vertically with proper alignment
     # Dataset legend on upper right
@@ -1938,19 +2174,19 @@ def _add_vertical_legend(ax, dataset_names, colors, show_filters, linewidth):
     
     # Filter legend below the dataset legend, aligned properly without title
     legend2 = ax.legend(
-        filter_handles,
-        filter_labels,
+        variant_handles,
+        variant_labels,
         loc="upper left",
         frameon=False,
         fontsize=7,
         bbox_to_anchor=(1.05, 1.0 - len(dataset_names) * 0.06 - 0.1)
     )
 
-def _add_dual_legend(ax, dataset_names, colors, show_filters, linewidth):
+def _add_dual_legend(ax, dataset_names, colors, variant_keys, linewidth):
     """
-    Add two legends: one for datasets (colors), one for filters (line styles).
+    Add two legends: one for datasets (colors), one for mPR variants (line styles).
     """
-    show_filters = _normalize_show_filters(show_filters)
+    variant_keys = _normalize_show_filters(variant_keys)
     # Legend 1: Datasets (colors) - solid lines
     dataset_handles = []
     for i, name in enumerate(dataset_names):
@@ -1958,19 +2194,19 @@ def _add_dual_legend(ax, dataset_names, colors, show_filters, linewidth):
         handle = Line2D([0], [0], color=color, linewidth=linewidth, linestyle="-")
         dataset_handles.append(handle)
     
-    # Legend 2: Filters (line styles) - black lines
-    filter_handles = []
-    filter_labels = []
-    for filter_key in show_filters:
-        style = FILTER_STYLES.get(filter_key, {})
+    # Legend 2: mPR variants (line styles) - black lines
+    variant_handles = []
+    variant_labels = []
+    for variant_key in variant_keys:
+        style = MPR_VARIANT_STYLES.get(variant_key, {})
         handle = Line2D(
             [0], [0], 
             color="black", 
             linewidth=linewidth, 
             linestyle=style.get("linestyle", "-")
         )
-        filter_handles.append(handle)
-        filter_labels.append(style.get("label", filter_key))
+        variant_handles.append(handle)
+        variant_labels.append(style.get("label", variant_key))
     
     # Position legends
     # Dataset legend on upper right
@@ -1987,19 +2223,12 @@ def _add_dual_legend(ax, dataset_names, colors, show_filters, linewidth):
     
     # Filter legend on lower left or right depending on plot type
     legend2 = ax.legend(
-        filter_handles,
-        filter_labels,
+        variant_handles,
+        variant_labels,
         loc="lower left",
         frameon=False,
-        title="Filter",
+        title="Variant",
         fontsize=7,
         title_fontsize=8,
     )
 
-# ============================================================================
-# Single dataset functions are now obsolete
-# ============================================================================
-
-# Note: The original single dataset functions plot_mpr_tp() and plot_mpr_complexes()
-# have been replaced by the multi functions that now auto-detect available datasets.
-# Use plot_mpr_tp_multi() and plot_mpr_complexes_multi() instead.