pythonflex 0.1.6__py3-none-any.whl → 0.2__py3-none-any.whl

pythonflex/__init__.py

@@ -2,7 +2,7 @@
 from .logging_config import log
 from .utils import dsave, dload
 from .preprocessing import get_example_data_path, load_datasets,  get_common_genes, filter_matrix_by_genes, load_gold_standard, filter_duplicate_terms
-from .analysis import initialize, pra, pra_percomplex, fast_corr, perform_corr, is_symmetric, binary, has_mirror_of_first_pair, convert_full_to_half_matrix, drop_mirror_pairs, quick_sort, complex_contributions, save_results_to_csv
+from .analysis import initialize, pra, pra_percomplex, fast_corr, perform_corr, is_symmetric, binary, has_mirror_of_first_pair, convert_full_to_half_matrix, drop_mirror_pairs, quick_sort, complex_contributions, save_results_to_csv, update_matploblib_config
 from .plotting import (
     adjust_text_positions, plot_precision_recall_curve, plot_percomplex_scatter,
     plot_percomplex_scatter_bysize, plot_complex_contributions, plot_significant_complexes, plot_auc_scores
@@ -14,5 +14,5 @@ __all__ = [ "log", "get_example_data_path", "fast_corr",
     "perform_corr", "is_symmetric", "binary", "has_mirror_of_first_pair", "convert_full_to_half_matrix",
     "drop_mirror_pairs", "quick_sort", "complex_contributions", "adjust_text_positions", "plot_precision_recall_curve",
     "plot_percomplex_scatter", "plot_percomplex_scatter_bysize", "plot_complex_contributions",
-    "plot_significant_complexes", "plot_auc_scores", "save_results_to_csv"
+    "plot_significant_complexes", "plot_auc_scores", "save_results_to_csv", "update_matploblib_config"
 ]

pythonflex/analysis.py

@@ -23,7 +23,7 @@ from .logging_config import log
 from .preprocessing import filter_matrix_by_genes
 from .utils import dsave, dload, _sanitize
 
-
+import matplotlib as mpl
 
 def deep_update(source, overrides):
     """Recursively update the source dict with the overrides."""
@@ -40,7 +40,7 @@ def initialize(config={}):
 
     default_config = {
         "min_genes_in_complex": 3,
-        "min_genes_per_complex_analysis": 3,
+        "min_genes_per_complex_analysis": 2,
         "output_folder": "output",
         "gold_standard": "CORUM",
         "color_map": "RdYlBu",
@@ -48,7 +48,7 @@ def initialize(config={}):
         "plotting": {
             "save_plot": True,
             "show_plot": True,
-            "output_type": "png",
+            "output_type": "pdf",
         },
         "preprocessing": {
             "normalize": False,
@@ -95,31 +95,105 @@ def initialize(config={}):
 
 
 
-def update_matploblib_config(config={}):
-    log.progress("Updating matplotlib settings.")
-    plt.rcParams.update({
-        "font.family": "DejaVu Sans",        # ← change if you prefer Arial, etc.
-        "mathtext.fontset": "dejavusans",
-        'font.size': 7,                # General font size
-        'axes.titlesize': 10,          # Title size
-        'axes.labelsize': 7,           # Axis labels (xlabel/ylabel)
-        'legend.fontsize': 7,          # Legend text
-        'xtick.labelsize': 6,          # X-axis tick labels
-        'ytick.labelsize': 6,          # Y-axis tick labels
-        'lines.linewidth': 1.5,        # Line width for plots
-        'figure.dpi': 300,             # Figure resolution
-        'figure.figsize': (8, 6),      # Default figure size
-        'grid.linestyle': '--',        # Grid line style
-        'grid.linewidth': 0.5,         # Grid line width
-        'grid.alpha': 0.2,             # Grid transparency
-        'axes.spines.right': False,    # Hide right spine
-        'axes.spines.top': False,      # Hide top spine
-        'image.cmap': config['color_map'],        # Default colormap
-        'axes.edgecolor': 'black',                # Axis edge color
-        'axes.facecolor': 'none',                 # Transparent axes background
-        'text.usetex': False                # Ensure LaTeX is off
+
+
+def update_matploblib_config(config=None, font_family="Arial", layout="single"):
+    """
+    Configure matplotlib settings optimized for Nature journal figures:
+      - 7 pt fonts (labels, ticks, legend), 9 pt titles
+      - Thin spines (0.5 pt), ticks out (left/bottom only), no minor ticks
+      - No grid, clean minimalist look
+      - Colorblind-friendly Tableau 10 color cycle
+      - Illustrator-safe PDF export (Type 42)
+      - Figure sizes: "single" (~89 mm), "double" (~183 mm), or custom (width, height) in inches
+    
+    Args:
+        config (dict, optional): Configuration dict (e.g., {'color_map': 'RdYlBu'}).
+        font_family (str): Preferred font (e.g., 'Arial', falls back to 'Helvetica').
+        layout (str or tuple): 'single' (~89 mm), 'double' (~183 mm), or (width, height) in inches.
+    """
+    if config is None:
+        config = {}
+    # Fallback if chosen font missing
+    try:
+        from matplotlib.font_manager import findfont, FontProperties
+        findfont(FontProperties(family=font_family))
+    except Exception:
+        font_family = "Helvetica"  # Nature prefers Helvetica if Arial unavailable
+        print(f"Warning: '{font_family}' not found, falling back to 'Helvetica'.")
+    
+    # Figure size presets (Nature: single ≈ 89 mm, double ≈ 183 mm at 25.4 mm/inch)
+    if isinstance(layout, tuple):
+        fig_w, fig_h = layout
+    else:
+        if layout == "double":
+            fig_w = 7.2  # ~183 mm
+            fig_h = 5.4  # Adjusted aspect
+        else:  # "single"
+            fig_w = 4.0  # Increased from 3.5" for more space (~102 mm)
+            fig_h = 3.0  # Increased from 2.6" for better aspect (~76 mm)
+    # Colorblind-friendly cycle (Tableau 10 adapted)
+    cb_cycle = [
+        "#4E79A7", "#F28E2B", "#E15759", "#76B7B2", "#59A14F",
+        "#EDC948", "#B07AA1", "#FF9DA7", "#9C755F", "#BAB0AC"
+    ]
+    mpl.rcParams.update({
+        # --- Text & Fonts ---
+        "text.usetex": False,  # Avoid LaTeX
+        "font.family": [font_family],  # Explicit font
+        "mathtext.fontset": "dejavusans",  # Disable mathtext
+        "mathtext.default": "regular",  # Plain text
+        "axes.unicode_minus": True,  # Proper minus signs
+        # --- Sizes (7 pt baseline, adjusted for space) ---
+        "font.size": 7,  # Reduced from 8 pt
+        "axes.titlesize": 9,  # Reduced from 10 pt
+        "axes.labelsize": 7,
+        "legend.fontsize": 7,
+        "xtick.labelsize": 7,
+        "ytick.labelsize": 7,
+        # --- Lines & Markers ---
+        "lines.linewidth": 1.5,  # Kept for data visibility
+        "lines.markersize": 4.0,
+        "patch.linewidth": 0.5,
+        "errorbar.capsize": 2,
+        # --- Axes, Spines, Ticks ---
+        "axes.linewidth": 0.5,
+        "axes.edgecolor": "black",
+        "axes.facecolor": "none",
+        "axes.titlepad": 3.0,
+        "axes.labelpad": 2.0,
+        "axes.prop_cycle": mpl.cycler(color=cb_cycle),
+        "xtick.direction": "out",
+        "ytick.direction": "out",
+        "xtick.major.size": 2.5,
+        "ytick.major.size": 2.5,
+        "xtick.minor.visible": False,
+        "ytick.minor.visible": False,
+        "xtick.major.width": 0.5,
+        "ytick.major.width": 0.5,
+        "xtick.top": False,
+        "ytick.right": False,
+        # --- Grid ---
+        "axes.grid": False,
+        # --- Legend ---
+        "legend.frameon": False,
+        "legend.handlelength": 1.6,  # Slightly adjusted
+        "legend.handletextpad": 0.4,
+        "legend.borderaxespad": 0.3,
+        "legend.loc": "best",  # Dynamic placement to avoid overlap
+        # --- Figure & Save ---
+        "figure.dpi": 600,
+        "figure.figsize": (fig_w, fig_h),
+        "savefig.dpi": 600,
+        "savefig.bbox": "tight",
+        "savefig.pad_inches": 0.1,  # Increased for spacing
+        "savefig.transparent": False,  # White background
+        # --- PDF/SVG Export ---
+        "pdf.fonttype": 42,
+        "ps.fonttype": 42,
+        "pdf.use14corefonts": False,
+        "svg.fonttype": "none",
     })
-    log.done("Matplotlib settings updated.")
 
 
 

pythonflex/examples/basic_usage.py

@@ -22,7 +22,6 @@ inputs = {
 
 
 #%%
-
 default_config = {
     "min_genes_in_complex": 0,
     "min_genes_per_complex_analysis": 3,
@@ -32,7 +31,7 @@ default_config = {
     "jaccard": True,
     "plotting": {
         "save_plot": True,
-        "output_type": "PNG",
+        "output_type": "pdf",
     },
     "preprocessing": {
         "fill_na": True,
@@ -48,7 +47,6 @@ default_config = {
 flex.initialize(default_config)
 
 # Load datasets and gold standard terms
-
 data, _ = flex.load_datasets(inputs)
 terms, genes_in_terms = flex.load_gold_standard()
 
@@ -59,6 +57,7 @@ for name, dataset in data.items():
     pra = flex.pra(name, dataset, is_corr=False)
     fpc = flex.pra_percomplex(name, dataset, is_corr=False) 
     cc = flex.complex_contributions(name)
+    
 
 
 #%%

pythonflex/examples/test.py

@@ -0,0 +1,104 @@
+#%%
+import pythonflex as flex
+import os
+
+# # Define specific cell line types you're interested in
+DATA_DIR = "C:/Users/yd/Desktop/projects/_datasets/depmap/25Q2/subset/"
+
+# Specific cell lines of interest with "_cell_lines" suffix removed
+cell_line_files = [
+    "soft_tissue_cell_lines.csv",
+    "skin_cell_lines.csv", 
+    # "lung_cell_lines.csv",
+    # "head_and_neck_cell_lines.csv",
+    # "esophagus_stomach_cell_lines.csv",
+]
+
+inputs = {}
+
+# Create inputs dict with shortened names (removing "_cell_lines" suffix)
+for filename in cell_line_files:
+    # Remove .csv extension and _cell_lines suffix
+    key = filename.replace("_cell_lines.csv", "")
+    full_path = os.path.join(DATA_DIR, filename)
+    
+    inputs[key] = {
+        "path": full_path,
+        "sort": "high"
+    }
+
+inputs['depmap'] = {
+    "path": "C:/Users/yd/Desktop/projects/_datasets/depmap/25Q2/gene_effect.csv",
+    "sort": "high"
+}
+
+# Print the resulting inputs dictionary
+print("Configured inputs:")
+for key, value in inputs.items():
+    print(f"  {key}: {value['path']}")
+
+
+
+default_config = {
+    "min_genes_in_complex": 2,
+    "min_genes_per_complex_analysis": 2,
+    "output_folder": "25q2_min_genes_2",
+    "gold_standard": "CORUM",
+    "color_map": "RdYlBu",
+    "jaccard": True,
+    "plotting": {
+        "save_plot": True,
+        "output_type": "pdf",
+    },
+    "preprocessing": {
+        "fill_na": True,
+        "normalize": False,
+    },
+    "corr_function": "numpy",
+    "logging": {  
+        "visible_levels": ["DONE","STARTED"]  # "PROGRESS", "STARTED", ,"INFO","WARNING"
+    }
+}
+
+# Initialize logger, config, and output folder
+flex.initialize(default_config)
+
+# Load datasets and gold standard terms
+data, _ = flex.load_datasets(inputs)
+terms, genes_in_terms = flex.load_gold_standard()
+
+
+#%%
+# Run analysis
+for name, dataset in data.items():
+    pra = flex.pra(name, dataset, is_corr=False)
+    fpc = flex.pra_percomplex(name, dataset, is_corr=False) 
+    cc = flex.complex_contributions(name)
+    
+
+
+#%%
+# Generate plots
+flex.plot_auc_scores()
+flex.plot_precision_recall_curve()
+flex.plot_percomplex_scatter()
+flex.plot_percomplex_scatter_bysize()
+flex.plot_significant_complexes()
+flex.plot_complex_contributions()
+
+
+#%%
+# Save results to CSV
+flex.save_results_to_csv()
+
+
+
+
+
+
+
+
+
+#%%
+
+

pythonflex/plotting.py

@@ -8,302 +8,458 @@ import pandas as pd
 import matplotlib.pyplot as plt
 from matplotlib import patches
 from matplotlib.cm import get_cmap
-from IPython.display import set_matplotlib_formats
+from matplotlib.ticker import NullFormatter, NullLocator
+
+# Completely disable LaTeX and clear all font cache/references
+import matplotlib as mpl
+import matplotlib.font_manager as fm
+
+# Disable LaTeX rendering completely
+mpl.rcParams['text.usetex'] = False
+
+
+# Reset all font-related parameters to system defaults
+mpl.rcParams['font.family'] = 'sans-serif'
+mpl.rcParams['font.serif'] = ['DejaVu Serif', 'Times New Roman', 'Bitstream Vera Serif', 'serif']
+mpl.rcParams['font.sans-serif'] = ['DejaVu Sans', 'Arial', 'Bitstream Vera Sans', 'sans-serif']
+mpl.rcParams['font.cursive'] = ['Apple Chancery', 'Textile', 'Zapf Chancery', 'Sand', 'Script MT', 'Felipa', 'cursive']
+mpl.rcParams['font.fantasy'] = ['Comic Sans MS', 'Chicago', 'Charcoal', 'Impact', 'Western', 'Humor Sans', 'fantasy']
+mpl.rcParams['font.monospace'] = ['DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Computer Modern Typewriter', 'Andale Mono', 'Nimbus Mono L', 'Courier New', 'Courier', 'Fixed', 'Terminal', 'monospace']
+
+# Remove any LaTeX-specific math font settings
+mpl.rcParams['mathtext.fontset'] = 'dejavusans'
+mpl.rcParams['mathtext.default'] = 'regular'
+
+# Force font manager to rebuild with system fonts only
+try:
+    fm.fontManager.__init__()
+except:
+    pass
+
 
 # Local modules
 from .utils import dload  
 from .logging_config import log
 
-# Configuration
-set_matplotlib_formats('svg', 'pdf')
 
 
 
 
-def plot_precision_recall_curve():
+def plot_precision_recall_curve(line_width=2.0, hide_minor_ticks=True):
     pra = dload("pra")
     config = dload("config")
     plot_config = config["plotting"]
 
-    # Create figure using rcParams defaults (figsize and dpi are already set)
     fig, ax = plt.subplots()
     ax.set_xscale("log")
 
-    # Color map from rcParams (no need to get from config again)
-    cmap = get_cmap()  # Uses rcParams['image.cmap'] by default
+    # optionally hide minor ticks on the log axis
+    if hide_minor_ticks:
+        ax.xaxis.set_minor_locator(NullLocator())
+        ax.xaxis.set_minor_formatter(NullFormatter())
+
+    cmap = get_cmap()
     num_colors = len(pra) if isinstance(pra, dict) else 1
     colors = [cmap(float(i) / max(num_colors - 1, 1)) for i in range(num_colors)]
 
     if isinstance(pra, dict):
         for (key, val), color in zip(pra.items(), colors):
             val = val[val.tp > 10]
-            ax.plot(val.tp, val.precision, c=color, label=key, linewidth=2, alpha=0.8)
+            ax.plot(val.tp, val.precision, c=color, label=key, linewidth=line_width, alpha=0.9)
     else:
         pra = pra[pra.tp > 10]
-        ax.plot(pra.tp, pra.precision, c="black", label="Precision Recall Curve", linewidth=2, alpha=0.8)
+        ax.plot(pra.tp, pra.precision, c="black", label="Precision Recall Curve", linewidth=line_width, alpha=0.9)
 
-    # Labels and title (sizes handled by rcParams)
     ax.set(title="Precision-Recall Performance of Datasets",
            xlabel="Number of True Positives (TP)",
            ylabel="Precision")
-    ax.legend(loc="upper right", frameon=True)
-
-    # Fix Y-axis to always go from 0 to 1
+    ax.legend(loc="upper right", frameon=False)
     ax.set_ylim(0, 1)
 
-    # Grid and spines (styles handled by rcParams)
-    ax.grid(True)  # Style comes from rcParams
-    # Spines visibility handled by rcParams ('axes.spines.right' and 'axes.spines.top')
+    # Nature style: no grid, open top/right spines
+    ax.grid(False)
+    ax.spines['top'].set_visible(False)
+    ax.spines['right'].set_visible(False)
 
-    # Save handling (output config still needed)
     if plot_config["save_plot"]:
         output_type = plot_config["output_type"]
         output_path = Path(config["output_folder"]) / f"precision_recall_curve.{output_type}"
-        fig.savefig(output_path, bbox_inches="tight", format=output_type)  # dpi comes from rcParams
+        fig.savefig(output_path, bbox_inches="tight", format=output_type)
 
     if plot_config.get("show_plot", True):
         plt.show()
-    
     plt.close(fig)
 
 
 
-def plot_percomplex_scatter(n_top=10):
+def plot_percomplex_scatter(n_top=10, sig_color='#B71A2A', nonsig_color='#DBDDDD', label_color='black', border_color='black', border_width=1.0):
     config = dload("config")
     plot_config = config["plotting"]
     rdict = dload("pra_percomplex")
 
-    # Ensure there are at least two datasets to compare
     if len(rdict) < 2:
         print("Skipping plot: At least two datasets are required for per-complex scatter plot.")
         return
-    
+
     column_pairs = list(combinations(rdict.keys(), 2))
     df = pd.DataFrame()
-    
-    # Data loading
+
     for i, (key, val) in enumerate(rdict.items()):
         val = val.rename(columns={"auc_score": key})
         if i == 0:
-            df = val.copy().drop(columns=["Genes", "Length", "used_genes"])
+            df = val.copy().drop(columns=["Genes", "Length", "used_genes"], errors="ignore")
         else:
             df = pd.concat([df, val[key]], axis=1)
-    
-    # Plotting
+
     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
-        
-        # Figure created with rcParams defaults
+        significant_indices = extreme_indices_0.union(extreme_indices_1)
+
+        bg_df  = df.drop(index=significant_indices)
+        sig_df = df.loc[significant_indices]
+
         fig, ax = plt.subplots()
+
+        # 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
+        )
+
+        # Label only significant with adaptive spacing
+        coords = sorted(
+            [(sig_df.loc[idx, pair[0]], sig_df.loc[idx, pair[1]], idx) for idx in sig_df.index],
+            key=lambda c: (-c[1], -c[0])
+        )
         
-        # Base scatter plot (keep color overrides)
-        sizes = df['n_used_genes'] * 8
-        ax.scatter(df[pair[0]], df[pair[1]], 
-                 edgecolors="black", 
-                 marker='o', 
-                 s=sizes, 
-                 linewidth=0.7, 
-                 zorder=1)
+        # Calculate proper parameters for normalized coordinate system (0-1 range)
+        max_y = 1.0  # Normalized plots use 0-1 range
+        scale_factor = 1.0  # Standard scaling for normalized plots
+        min_distance = 0.05  # Appropriate spacing for 0-1 range
         
-        # Highlight significant points
-        significant_indices = extreme_indices_0.union(extreme_indices_1)
-        sig_sizes = df.loc[significant_indices, 'n_used_genes'] * 8
-        ax.scatter(df.loc[significant_indices, pair[0]],
-                 df.loc[significant_indices, pair[1]],
-                 facecolors='black', 
-                 edgecolors='black', 
-                 s=sig_sizes, 
-                 linewidth=0.1, 
-                 zorder=2)
-
-        all_points = list(zip(df[pair[0]], df[pair[1]]))
-        coords = sorted([(df.loc[idx, pair[0]], df.loc[idx, pair[1]], idx) 
-                       for idx in significant_indices], key=lambda c: (-c[1], -c[0]))
+        adjusted_coords = adjust_text_positions(
+            coords, sig_sizes,
+            min_distance=min_distance,
+            max_y=max_y,
+            scale_factor=scale_factor
+        )
         
-        adjusted_coords = adjust_text_positions(coords, sig_sizes)
-
-        # Draw vertical lines and right-aligned text
         for x, adj_y, idx in adjusted_coords:
             y = df.loc[idx, pair[1]]
-            ax.plot([x, x], [y, adj_y], 
-                   color='black', 
-                   linewidth=0.7, 
-                   alpha=0.3,
-                   zorder=3)
-            
-            ax.text(x, adj_y + 0.005,
-                   df.loc[idx, 'Name'][:20] + '.',
-                   fontsize=6, 
-                   ha='left', 
-                   va='bottom', 
-                   linespacing=1.5,
-                   zorder=4,
-                   bbox=dict(facecolor="white", alpha=0.8, edgecolor="none", pad=1.5)
-                   )
-
-        # Reference line and labels
-        ax.plot([0, 1], [0, 1], 
-              linestyle='-', 
-              color='lightgray', 
-              alpha=0.4,
-              zorder=0)
-        
-        # Add padding to axes for better visibility of points near edges
-        padding = 0.02  # Small offset (adjust as needed, e.g., 0.05 for more space)
+            ax.plot([x, x], [y, adj_y], color=label_color, linewidth=0.6, alpha=0.3, zorder=3)
+            ax.text(
+                x, adj_y + 0.005,
+                df.loc[idx, 'Name'][:15] + '..',
+                fontsize=4, ha='left', va='bottom', color=label_color,
+                linespacing=1.5, zorder=4,
+                #bbox=dict(facecolor="white", alpha=0.65, edgecolor="white", pad=1.2)
+            )
+
+        # Diagonal & axes cosmetics
+        ax.plot([0, 1], [0, 1], linestyle='-', color='lightgray', alpha=0.4, linewidth=0.5, zorder=1)
+        padding = 0.02
         ax.set_xlim(-padding, 1 + padding)
         ax.set_ylim(-padding, 1 + padding)
-        
-        # Labels use rcParams sizes automatically
         ax.set_xlabel(f"{pair[0]} PR-AUC score")
         ax.set_ylabel(f"{pair[1]} PR-AUC score")
         ax.set_title(f"{pair[0]} vs {pair[1]} - Comparison of complex performance")
-        
+
+        # Nature style: no grid, open top/right spines
+        ax.grid(False)
+        ax.spines['top'].set_visible(False)
+        ax.spines['right'].set_visible(False)
+
         plt.tight_layout()
-        
-        # Save handling
+
         if plot_config["save_plot"]:
             output_type = plot_config["output_type"]
             output_path = Path(config["output_folder"]) / f"percomplex_scatter_{pair[0]}_vs_{pair[1]}.{output_type}"
             fig.savefig(output_path, bbox_inches="tight", format=output_type)
-        
+
         if plot_config.get("show_plot", True):
             plt.show()
-        
+
         plt.close(fig)
 
 
 
+def smart_direction_assignment(point_y, y_max, min_safe_distance=20.0):
+    """Determine the best direction for label placement based on Y position."""
+    lower_threshold = y_max / 3
+    upper_threshold = 2 * y_max / 3
+    
+    if point_y < lower_threshold:
+        return "up_only"
+    elif point_y > upper_threshold:
+        return "prefer_down"
+    else:
+        return "both_directions"
 
 
+def group_points_by_y_proximity(coords, y_tolerance=5.0):
+    """Group points that have similar Y values (within tolerance)."""
+    groups = []
+    remaining_coords = coords.copy()
+    
+    while remaining_coords:
+        # Start a new group with the first remaining point
+        seed_point = remaining_coords.pop(0)
+        current_group = [seed_point]
+        seed_y = seed_point[1]
+        
+        # Find all points within Y tolerance of the seed point
+        i = 0
+        while i < len(remaining_coords):
+            if abs(remaining_coords[i][1] - seed_y) <= y_tolerance:
+                current_group.append(remaining_coords.pop(i))
+            else:
+                i += 1
+                
+        groups.append(current_group)
+    
+    return groups
 
 
 def adjust_text_positions(coords, sizes, min_distance=0.08, max_y=1.0, scale_factor=1.0):
+    """Enhanced text positioning with adaptive spacing for dense clusters."""
     adjusted = []
-    text_height = 0.04 * scale_factor  # Scaled text height
-
-    for (x, y, idx) in coords:
-        base_offset = np.sqrt(sizes.loc[idx]) * 0.04 * scale_factor if idx in sizes else 0.04 * scale_factor
-        adj_y = y + base_offset  # Move text upwards (scaled)
-        safety = 0
-
-        # Ensure text stays within plot area
-        max_possible_y = max_y - text_height
-
-        while safety < 20:
-            conflict = False
-            # Check against existing labels
-            for (ax, aay, _) in adjusted:
-                if abs(x - ax) < 0.01 and abs(adj_y - aay) < min_distance:
-                    conflict = True
-                    break
-
-            if conflict:
-                adj_y += (0.03 + (base_offset * 0.1))  # Move further upwards (base_offset already scaled)
-                safety += 1
-
-                # If we're going beyond plot area, stop
-                if adj_y > max_possible_y:
-                    adj_y = max_possible_y
-                    break
+    
+    # Fix scaling issues - use data coordinates, not pixel scaling
+    if max_y > 10:  # For gene count plots (large Y values)
+        text_height = max_y * 0.02  # 2% of Y range
+        min_safe_distance = max_y * 0.05  # 5% of Y range  
+        y_tolerance = max_y * 0.02  # 2% of Y range for grouping
+    else:  # For normalized plots (Y values 0-1)
+        text_height = 0.04 * scale_factor
+        min_safe_distance = 20 * scale_factor
+        y_tolerance = 5 * scale_factor
+    
+    # Group points by Y proximity
+    groups = group_points_by_y_proximity(coords, y_tolerance)
+    
+    for group in groups:
+        group_size = len(group)
+        
+        # Calculate adaptive spacing based on cluster density
+        density_multiplier = calculate_density_multiplier(group_size)
+        
+        if group_size == 1:
+            # Single point - use original logic but with direction awareness
+            x, y, idx = group[0]
+            direction = smart_direction_assignment(y, max_y, min_safe_distance)
+            
+            # Use reasonable base offset relative to Y range
+            if max_y > 10:  # Gene count plots
+                base_offset = max(3, max_y * 0.03)  # 3% of Y range, minimum 3 units
+            else:  # Normalized plots  
+                base_offset = np.sqrt(sizes.loc[idx]) * 0.04 * scale_factor if idx in sizes else 0.04 * scale_factor
+            
+            if direction == "up_only" or direction == "both_directions":
+                adj_y = y + base_offset
+            elif direction == "prefer_down" and y - base_offset > min_safe_distance:
+                adj_y = y - base_offset
             else:
-                # Clamp final position
-                adj_y = min(adj_y, max_possible_y)
+                adj_y = y + base_offset
+                
+            # Ensure within bounds with proper limits
+            adj_y = max(min_safe_distance, min(adj_y, max_y - text_height))
+            
+            # Additional safety check to prevent extreme values
+            if adj_y < 0 or adj_y > max_y * 1.2:  # Allow 20% overflow for safety
+                adj_y = y + base_offset  # Fallback to simple offset
+            
+            adjusted.append((x, adj_y, idx))
+            
+        else:
+            # Multiple points with similar Y - use adaptive distribution
+            group.sort(key=lambda p: p[0])  # Sort by X coordinate
+            
+            # Determine available directions for this Y level
+            group_y = group[0][1]  # All have similar Y, use first as representative
+            direction = smart_direction_assignment(group_y, max_y, min_safe_distance)
+            
+            # Calculate adaptive spacing and base offset
+            adaptive_spacing = calculate_adaptive_spacing(
+                group_size, min_distance, text_height, max_y, density_multiplier
+            )
+            adaptive_base_offset = calculate_adaptive_base_offset(
+                group_size, max_y, scale_factor, density_multiplier
+            )
+            
+            for i, (x, y, idx) in enumerate(group):
+                if direction == "up_only":
+                    # Stack all labels upward with adaptive spacing
+                    adj_y = y + adaptive_base_offset + (i * adaptive_spacing)
+                    
+                elif direction == "prefer_down":
+                    # Alternate down and up with adaptive spacing
+                    if i % 2 == 0 and y - adaptive_base_offset - (i//2 * adaptive_spacing) > min_safe_distance:
+                        # Even indices go down
+                        adj_y = y - adaptive_base_offset - (i//2 * adaptive_spacing)
+                    else:
+                        # Odd indices or insufficient space below - go up
+                        up_level = (i//2) if i % 2 == 0 else ((i+1)//2)
+                        adj_y = y + adaptive_base_offset + (up_level * adaptive_spacing)
+                        
+                else:  # both_directions
+                    # Alternate up and down with adaptive spacing
+                    if i % 2 == 0:
+                        # Even indices go up
+                        adj_y = y + adaptive_base_offset + (i//2 * adaptive_spacing)
+                    else:
+                        # Odd indices go down (if safe)
+                        potential_down = y - adaptive_base_offset - ((i+1)//2 * adaptive_spacing)
+                        if potential_down > min_safe_distance:
+                            adj_y = potential_down
+                        else:
+                            # Not safe to go down, stack upward instead
+                            adj_y = y + adaptive_base_offset + (i//2 * adaptive_spacing)
+                
+                # Final bounds check with stricter limits
+                adj_y = max(min_safe_distance, min(adj_y, max_y - text_height))
+                
+                # Additional safety check to prevent extreme values
+                if adj_y < 0 or adj_y > max_y * 1.2:  # Allow 20% overflow for safety
+                    adj_y = y + adaptive_base_offset  # Fallback to simple offset
+                
                 adjusted.append((x, adj_y, idx))
-                break
-
+    
     return adjusted
 
 
+def calculate_density_multiplier(group_size):
+    """Calculate multiplier for spacing based on cluster density."""
+    if group_size <= 3:
+        return 1.0
+    elif group_size <= 6:
+        return 1.3
+    elif group_size <= 10:
+        return 1.6
+    elif group_size <= 15:
+        return 2.0
+    elif group_size <= 20:
+        return 2.5
+    else:  # 20+ points
+        return 3.0 + (group_size - 20) * 0.1  # Progressive scaling for very dense clusters
+
+
+def calculate_adaptive_spacing(group_size, min_distance, text_height, max_y, density_multiplier):
+    """Calculate adaptive vertical spacing between labels based on cluster density."""
+    base_spacing = max(min_distance, text_height * 1.5)
+    
+    # Scale spacing based on density and coordinate system
+    if max_y > 10:  # Gene count plots
+        adaptive_spacing = base_spacing * density_multiplier * (max_y / 100.0)
+        # Ensure minimum readable spacing for dense clusters
+        adaptive_spacing = max(adaptive_spacing, max_y * 0.03)
+    else:  # Normalized plots
+        adaptive_spacing = base_spacing * density_multiplier
+        # Ensure minimum readable spacing
+        adaptive_spacing = max(adaptive_spacing, 0.05)
+    
+    return adaptive_spacing
+
+
+def calculate_adaptive_base_offset(group_size, max_y, scale_factor, density_multiplier):
+    """Calculate adaptive base offset (connector line height) based on cluster density."""
+    if max_y > 10:  # Gene count plots
+        base_offset = max(3, max_y * 0.03)
+        # Increase connector line height for dense clusters
+        adaptive_offset = base_offset * density_multiplier
+        # Cap to reasonable maximum
+        adaptive_offset = min(adaptive_offset, max_y * 0.15)
+    else:  # Normalized plots
+        base_offset = 0.04 * scale_factor
+        # Increase connector line height for dense clusters
+        adaptive_offset = base_offset * density_multiplier
+        # Cap to reasonable maximum
+        adaptive_offset = min(adaptive_offset, 0.2)
+    
+    return adaptive_offset
+
 
-def plot_percomplex_scatter_bysize():
+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):
     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_10, rest = sorted_pc.head(10), sorted_pc.iloc[10:]
-        
-        # Create figure using rcParams defaults
+        top_labels, rest = sorted_pc.head(n_labels), sorted_pc.iloc[n_labels:]
+
         fig, ax = plt.subplots()
-        
-        # Base scatter plot (simple swap of X/Y data)
+
+        # Background (REST): filled dots with black borders, not rasterized
         ax.scatter(
-            rest.auc_score, rest.n_used_genes,  # auc_score on X, n_used_genes on Y
-            edgecolors="black",
-            linewidth=0.5, 
-            s=rest.n_used_genes * 10, 
-            label="Other Complexes"
+            rest.auc_score, rest.n_used_genes,
+            facecolors=nonsig_color, edgecolors=border_color,
+            linewidth=border_width, s=rest.n_used_genes * 10,
+            alpha=1.0, label="Other Complexes",
+            zorder=0
         )
-        
-        # Top 10 scatter plot (simple swap of X/Y data)
+
+        # Top N: filled dots with black borders
         ax.scatter(
-            top_10.auc_score, top_10.n_used_genes,  # auc_score on X, n_used_genes on Y
-            facecolors='black', 
-            edgecolors='black',
-            linewidth=0.5, 
-            s=top_10.n_used_genes * 10, 
-            label="Top 10 AUC Scores"
+            top_labels.auc_score, top_labels.n_used_genes,
+            facecolors=sig_color, edgecolors=border_color,
+            linewidth=border_width, s=top_labels.n_used_genes * 10,
+            label=f"Top {n_labels} AUC Scores", alpha=1.0, zorder=2
         )
 
-
-        # Text annotation handling (swapped coords: auc on X, size on Y)
-        coords = [(row.auc_score, row.n_used_genes, idx) for idx, row in top_10.iterrows()]
-        sizes = top_10.n_used_genes * 10
+        # Labels with corrected scaling
+        coords = [(row.auc_score, row.n_used_genes, idx) for idx, row in top_labels.iterrows()]
+        sizes = top_labels.n_used_genes * 10
+        max_y = sorted_pc.n_used_genes.max() + 50
         
-        # Dynamically set max_y and scale_factor to make lines visible/long like original
-        max_y = sorted_pc.n_used_genes.max() + 50  # Larger buffer (increase to +100 if lines still short)
-        scale_factor = max_y / 1.0  # Scale offsets for visibility on new range
-        adjusted_coords = adjust_text_positions(
-            coords, sizes, 
-            min_distance=0.08 * scale_factor,
-            max_y=max_y,
-            scale_factor=scale_factor  # New param to make lengths visible
-        )
+        # Fix scaling issue - use reasonable scale factor
+        scale_factor = min(max_y / 100.0, 3.0)  # Cap scale factor to prevent extreme positioning
         
-        for x, adj_y, idx in adjusted_coords:
-            y = top_10.loc[idx, "n_used_genes"]  # Pull from n_used_genes (now Y)
-            ax.plot([x, x], [y, adj_y], 
-                   color='black', 
-                   linewidth=0.7, 
-                   alpha=0.3,
-                   zorder=3)
-            
-            # Dynamic alignment: left if x < 0.5 (extends right), right if x >= 0.5 (extends left)
-            if x < 0.5:
-                ha = 'left'
-                text_x = x + 0.01  # Small rightward offset to avoid line overlap
-            else:
-                ha = 'right'
-                text_x = x - 0.01  # Small leftward offset to avoid line overlap
-            
-            ax.text(text_x, adj_y + (0.005 * scale_factor), 
-                   top_10.loc[idx, 'Name'][:20] + '.', 
-                   fontsize=6, 
-                   ha=ha, 
-                   va='bottom', 
-                   linespacing=1.5,
-                   zorder=4,
-                   bbox=dict(facecolor="white", alpha=0.8, edgecolor="none", pad=1.5))
-
-        # Axis configuration (integer ticks now on Y)
-        ax.yaxis.get_major_locator().set_params(integer=True)
-        ax.set_xlabel("PR-AUC score")  # Swapped label
-        ax.set_ylabel("Number of genes in the complex")  # Swapped label
+        adjusted = adjust_text_positions(
+            coords, sizes,
+            min_distance=max(5.0, max_y * 0.02),  # Use reasonable spacing relative to Y range
+            max_y=max_y, 
+            scale_factor=scale_factor
+        )
+        for x, adj_y, idx in adjusted:
+            y = top_labels.loc[idx, "n_used_genes"]
+            ax.plot([x, x], [y, adj_y], color=label_color, linewidth=0.5, alpha=0.3, zorder=3)
+            ha = 'left' if x < 0.5 else 'right'
+            text_x = x + 0.01 if x < 0.5 else x - 0.01
+            ax.text(
+                text_x, adj_y + (0.005 * scale_factor),
+                top_labels.loc[idx, 'Name'][:15] + '..',
+                fontsize=4, ha=ha, va='bottom', color=label_color, linespacing=1.5, zorder=4,
+                bbox=dict(facecolor="white", alpha=0.65, edgecolor="white", pad=1.5)
+            )
+
+        # Set y-axis to show integer values only
+        from matplotlib.ticker import MaxNLocator
+        ax.yaxis.set_major_locator(MaxNLocator(integer=True))
+        ax.set_xlabel("PR-AUC score")
+        ax.set_ylabel("Number of genes in the complex")
         ax.set_title(f"{key} - Complex performance: PR-AUC score vs complex size")
-        ax.grid(False)
-
-        # Fixed limits (X fixed to 0-1 for AUC, Y with buffer for lines/labels)
-        ax.set_xlim(0, 1.0)
-        ax.set_ylim(0, max_y)
 
-        # Adjust subplot margins to give extra space on right for labels (without extending axis; optional)
-        plt.subplots_adjust(right=0.8)  # Adjust to 0.7 or remove if not needed
+        # No ruler + open spines
+        ax.grid(visible=False, which='both', axis='both')
+        ax.set_xlim(0, 1.0); ax.set_ylim(0, max_y)
+        ax.spines['top'].set_visible(False)
+        ax.spines['right'].set_visible(False)
 
+        plt.subplots_adjust(right=0.8)
         plt.tight_layout()
 
-        # Save handling (dpi comes from rcParams)
         if plot_config["save_plot"]:
             output_type = plot_config["output_type"]
             output_path = Path(config["output_folder"]) / f"percomplex_scatter_by_complexsize_{key}.{output_type}"
@@ -311,20 +467,28 @@ def plot_percomplex_scatter_bysize():
 
         if plot_config.get("show_plot", True):
             plt.show()
-        
         plt.close(fig)
 
 
 
-def plot_complex_contributions(min_pairs=10, min_precision_cutoff=0.5, num_complex_to_show=10, y_lim=None, fig_title=None, fig_labs=['Fraction of TP', 'Precision']):
+def plot_complex_contributions(
+    min_pairs=10,
+    min_precision_cutoff=0.5,
+    num_complex_to_show=10,
+    y_lim=None,
+    fig_title=None,
+    fig_labs=['Fraction of TP', 'Precision'],
+    legend_rows=3,   # <— NEW: rows for legend layout (try 3 or 4)
+):
     config = dload("config")
     plot_config = config["plotting"]
     plot_data_dict = dload("complex_contributions")
+
     for key, plot_data in plot_data_dict.items():
         s = plot_data.set_index('Name').sum()
         find_last_precision = s[s > min_pairs].index[-1]
-        last_prec_value = float(find_last_precision.split('_')[1])  # Parse the float value
-        
+        last_prec_value = float(find_last_precision.split('_')[1])
+
         plot_data = plot_data.drop_duplicates(subset='Name')
         cont_stepwise_anno = plot_data['Name']
         cont_stepwise_mat = plot_data.drop(columns=['Name'])
@@ -340,117 +504,117 @@ def plot_complex_contributions(min_pairs=10, min_precision_cutoff=0.5, num_compl
         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
+            log.info("No values above 'min.precision.cutoff'"); return False
         if sum(ind_for_mean) == 1:
-            log.info("Only one value above 'min.precision.cutoff', unable to calculate meaningful contribution structure")
-            return False
-        # Select top complexes
+            log.info("Only one value above 'min.precision.cutoff'"); return False
+
         a = x_df.loc[:, ind_for_mean].mean(axis=1).sort_values()[-num_complex_to_show:]
         subset = x_df.loc[a.index, :]
-        # Use the RdYlBu colormap for the top 10 points
-        cmap = plt.get_cmap()  # Get default from rcParams
+
+        cmap = plt.get_cmap()
         colors = cmap(np.linspace(0, 1, num_complex_to_show))
-        colors = np.vstack(([0.5, 0.5, 0.5, 1.0], colors))
+        colors = np.vstack(([0.5, 0.5, 0.5, 1.0], colors))  # 'others' + top K
         others = pd.DataFrame(1 - subset.sum(axis=0), columns=['others']).T
         merged = pd.concat([others, subset], ignore_index=False)
-        x = merged.to_numpy()
-        x1 = np.zeros_like(x)
-        x2 = np.zeros_like(x)
-        for i in range(x.shape[0]):
+        X = merged.to_numpy()
+        x1 = np.zeros_like(X); x2 = np.zeros_like(X)
+        for i in range(X.shape[0]):
             if i == 0:
-                x2[i, :] = x[0, :]
+                x2[i, :] = X[0, :]
             elif i == 1:
-                x1[i, :] = x[0, :]
+                x1[i, :] = X[0, :]
             else:
-                x1[i, :] = x[:i, :].sum(axis=0)
+                x1[i, :] = X[:i, :].sum(axis=0)
             if i > 0:
-                x2[i, :] = x[:i + 1, :].sum(axis=0)
-
+                x2[i, :] = X[:i + 1, :].sum(axis=0)
 
-        # FORCE recalculation of y_lim - ignore any passed parameter
-        padding = 0.02  # Small padding to avoid clipping (adjust as needed, e.g., 0.05 for more space)
+        padding = 0.02
         lower = max(0, min(y) - padding)
-        upper = last_prec_value + padding  # Use the actual last precision value instead of 1.0
+        upper = last_prec_value + padding
         y_lim = (lower, upper)
-        
-        
-        fig, ax = plt.subplots(2, 1, gridspec_kw={'height_ratios': [5, 1]})
+
+        # Give legend a bit more room
+        fig, ax = plt.subplots(2, 1, gridspec_kw={'height_ratios': [5, 1.8]})
         ax[0].set_xlim(0, 1)
-        ax[0].set_ylim(*y_lim)  # Use dynamic ylim
+        ax[0].set_ylim(*y_lim)
         ax[0].set_xlabel(fig_labs[0])
         ax[0].set_ylabel(fig_labs[1])
         ax[0].set_title(fig_title if fig_title else f"{key} - Contribution of complexes")
-        for i in range(x.shape[0]):
+        for i in range(X.shape[0]):
             ax[0].fill_betweenx(y, x1[i, :], x2[i, :], color=colors[i], edgecolor='white')
 
-        # Legend handling (keep custom settings)
-        legend_labels = [f'{label[:20]}.' for label in merged.index]
-        patches_list = [patches.Patch(color=colors[i], label=legend_labels[i]) for i in range(len(legend_labels))]
+        # Legend: multi-row, constrained to width
+        def _short(s, n=14): return (s[:n-1] + '…') if len(s) > n else s
+        labels  = [_short(lbl) for lbl in merged.index]
+        handles = [patches.Patch(color=colors[i], label=labels[i]) for i in range(len(labels))]
         ax[1].axis('off')
-        ax[1].legend(handles=patches_list, loc='center', ncol=3, frameon=False, title="Complexes")
+        n_items = len(handles)
+        ncols   = int(np.ceil(n_items / max(1, legend_rows)))  # spread across rows
+        ax[1].legend(
+            handles=handles,
+            loc='center',
+            ncol=ncols,
+            frameon=False,
+            title="Complexes",
+            fontsize=6, title_fontsize=6,
+            handlelength=0.9, handletextpad=0.25,
+            borderaxespad=0.0,
+            labelspacing=0.25, columnspacing=0.6,
+            mode='expand'
+        )
+
         plt.tight_layout()
 
-        # Save handling (remove explicit dpi)
         if plot_config["save_plot"]:
-            output_type = plot_config["output_type"]
-            output_folder = Path(config["output_folder"])
-            output_path = output_folder / f"complex_contributions_{key}.{output_type}"
+            output_type  = plot_config["output_type"]
+            output_folder= Path(config["output_folder"])
+            output_path  = output_folder / f"complex_contributions_{key}.{output_type}"
             fig.savefig(output_path, bbox_inches="tight", format=output_type)
 
         if plot_config.get("show_plot", True):
             plt.show()
-        
         plt.close(fig)
 
 
+
 def plot_significant_complexes():
     config = dload("config")
     plot_config = config["plotting"]
     pra_percomplex = dload("pra_percomplex")
 
-    # Define thresholds and prepare data
     thresholds = [0.1, 0.2, 0.3, 0.4, 0.5]
     datasets = list(pra_percomplex.keys())
     num_datasets = len(datasets)
 
-    # Create a DataFrame to store results
     df = pd.DataFrame(index=thresholds)
     for key, complex_data in pra_percomplex.items():
         df[key] = [complex_data.query(f'auc_score >= {t}').shape[0] for t in thresholds]
 
-    # Create figure
     fig, ax = plt.subplots()
 
-    # Use colormap from rcParams
     cmap = plt.get_cmap()
     colors = [cmap(i / (num_datasets + 1)) for i in range(1, num_datasets + 1)]
 
-    # Plot bars
-    bar_width = 0.8 / num_datasets  # Dynamic width based on dataset count
+    bar_width = 0.8 / num_datasets
     for i, dataset in enumerate(datasets):
         x = np.arange(len(thresholds)) + i * bar_width
         ax.bar(x, df[dataset], width=bar_width, color=colors[i], edgecolor='black', label=dataset)
 
-    # Customize x-axis labels
     ax.set_xticks(np.arange(len(thresholds)) + (num_datasets - 1) * bar_width / 2)
-    ax.set_xticklabels(thresholds, rotation=0, ha='center')
+    ax.set_xticklabels([str(t) for t in thresholds], rotation=0, ha='center')
 
-    # Set title and axis labels (handled by rcParams)
     ax.set_title("Number of significant complexes above PR-AUC thresholds")
     ax.set_xlabel("PR-AUC score thresholds")
     ax.set_ylabel("Number of complexes")
 
-    # Add grid (already handled by rcParams, but ensured)
-    ax.grid(axis='y')
+    # Nature style: no grid; open top/right spines
+    ax.grid(False)
+    for spine in ('right', 'top'):
+        ax.spines[spine].set_visible(False)
 
-    # Add legend
-    ax.legend(loc='upper right')
-
-    # Adjust layout
+    ax.legend(loc='upper right', frameon=False)
     plt.tight_layout()
 
-    # Save figure if required
     if plot_config["save_plot"]:
         output_type = plot_config["output_type"]
         output_folder = Path(config["output_folder"])
@@ -459,7 +623,7 @@ def plot_significant_complexes():
 
     if plot_config.get("show_plot", True):
         plt.show()
-    
+
     plt.close(fig)
     return df
 
@@ -470,34 +634,30 @@ def plot_auc_scores():
     plot_config = config["plotting"]
     pra_dict = dload("pr_auc")
 
-
     sorted_items = sorted(pra_dict.items(), key=lambda x: x[1], reverse=True)
     datasets = [k for k, _ in sorted_items]
     auc_scores = [v for _, v in sorted_items]
 
-    # Create figure and axis
     fig, ax = plt.subplots()
 
-    # Use colormap from rcParams
     cmap = plt.get_cmap()
     num_datasets = len(datasets)
     colors = [cmap(i / (num_datasets + 1)) for i in range(1, num_datasets + 1)]
 
-    # Plot bars
     ax.bar(datasets, auc_scores, color=colors, edgecolor="black")
 
-    # Set y-axis limits dynamically
     ax.set_ylim(0, max(auc_scores) + 0.01)
-
-    # Set title and labels
     ax.set_title("AUC scores for the datasets")
     ax.set_ylabel("AUC score")
     plt.xticks(rotation=45, ha="right")
 
-    # Add grid (already handled by rcParams)
-    ax.grid(axis='y')
+    # Hard-disable any grid/ruler
+    ax.grid(visible=False, which='both', axis='both')
+    ax.set_axisbelow(False)  # make sure nothing faint is drawn beneath
+    # Open spines
+    ax.spines['top'].set_visible(False)
+    ax.spines['right'].set_visible(False)
 
-    # Save the figure if required
     if plot_config["save_plot"]:
         output_type = plot_config["output_type"]
         output_folder = Path(config["output_folder"])
@@ -507,6 +667,6 @@ def plot_auc_scores():
 
     if plot_config.get("show_plot", True):
         plt.show()
-    
+
     plt.close(fig)
     return pra_dict

{pythonflex-0.1.6.dist-info → pythonflex-0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonflex
-Version: 0.1.6
+Version: 0.2
 Summary: pythonFLEX is a benchmarking toolkit for evaluating CRISPR screen results against biological gold standards. The toolkit computes gene-level and complex-level performance metrics, helping researchers systematically assess the biological relevance and resolution of their CRISPR screening data.
 Author-email: Yasir Demirtaş <tyasird@hotmail.com>
 Requires-Python: >=3.9

{pythonflex-0.1.6.dist-info → pythonflex-0.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
-pythonflex/__init__.py,sha256=rz-8y-zEJQR3ThbhlIUV0N1q7Z-4UNHpHbOglXFp52c,1292
-pythonflex/analysis.py,sha256=-_FPrV9fImfU5edncdPhotgpANkIEO-4LJclL_sG6_g,54513
+pythonflex/__init__.py,sha256=rW_MdM0ijaN9HAzFL-P7oVfLRJRGq0M83Izfmdr_s64,1346
+pythonflex/analysis.py,sha256=cGUZKb5swJ7h1f6PJcIg4AW-BulY2ETGjJul9cg3u-k,57217
 pythonflex/logging_config.py,sha256=iqRKK18zvtfV_-bYHWrXtSZywiUtYxoHkw0ZnVORQBQ,2015
-pythonflex/plotting.py,sha256=eW0coNDFv5LFAE8xg-kWUJynzTPzd5ieWW05KC54LkE,19615
+pythonflex/plotting.py,sha256=ywUa95UxUaxtkaWGffrCcaQWw1WCF17GF6nF8KgWhc0,27429
 pythonflex/preprocessing.py,sha256=oIGPdmETuBQh4mdsIOWB5DOmYndp9S-sW8r7h_ek0Zo,8583
 pythonflex/utils.py,sha256=nyVlGu5OXpz5YPj48hXueL5ja88sQ2PUiJ76c4USg4A,3886
 pythonflex/data/dataset/liver_cell_lines_500_genes.csv,sha256=qfKsqPjL41Y1GuxxAhc-MfaNO0mX6Qju_SeynKSpEiM,238639
@@ -13,9 +13,10 @@ pythonflex/data/gold_standard/PATHWAY.parquet,sha256=bFRDe3PQ_TFc7B1uZuynwOGcgxE
 pythonflex/data/gold_standard/corum.csv,sha256=2rZeyr2Ghm7f-gFxCZnhPtxI2jxRoiZMUEH2EJwAgsI,208889
 pythonflex/data/gold_standard/gobp.csv,sha256=TO9yfx9mO8WkXvWfSB-pFId9T8xYfqdZpshAXC0Fyj8,1739167
 pythonflex/data/gold_standard/pathway.csv,sha256=J3HKVLUZ_Oxucmn_14ieYp3Wr2lcKtp0nIl4_8_K2Yc,489424
-pythonflex/examples/basic_usage.py,sha256=xDXzBH0xZqljLXRD5BAdf4a3X9Q3BbgAG0S6-fJy0No,1917
+pythonflex/examples/basic_usage.py,sha256=4Kv3OdiyBruq30Ppwx2xYx1ioEtl8jeAg6mAJxzA6Go,1919
 pythonflex/examples/dataset_filtering.py,sha256=56ZXgsbUNaHoGjX8QdQZ74CjUXDi-qdzfeMhmP1WHAA,978
-pythonflex-0.1.6.dist-info/METADATA,sha256=JAJlViRvsO9TbuYN0P7t_bEQ8Hh8u_H28-Z55TrLA1k,3928
-pythonflex-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pythonflex-0.1.6.dist-info/entry_points.txt,sha256=37liK1baI_CRVDivpjsn8JDClL9_YeTTuSMAZ3Ty7oE,47
-pythonflex-0.1.6.dist-info/RECORD,,
+pythonflex/examples/test.py,sha256=B8-JE5AU7be5loSr6Qv2rOviXXe1NRCYpaEGfGjaow0,2388
+pythonflex-0.2.dist-info/METADATA,sha256=8URwIkDildA8Hh-WvsGwIywP2ssMCrp1-Z2zIdYckRM,3926
+pythonflex-0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pythonflex-0.2.dist-info/entry_points.txt,sha256=37liK1baI_CRVDivpjsn8JDClL9_YeTTuSMAZ3Ty7oE,47
+pythonflex-0.2.dist-info/RECORD,,