py2ls 0.2.4.10.4__py3-none-any.whl → 0.2.4.10.6__py3-none-any.whl

py2ls/plot.py

@@ -1,21 +1,37 @@
 import numpy as np
-import pandas as pd  
+import pandas as pd
 import matplotlib.pyplot as plt
 import matplotlib
 import seaborn as sns
 import warnings
 import logging
 from typing import Union
-from .ips import isa, fsave, fload, mkdir, listdir, figsave, strcmp, unique, get_os, ssplit,flatten,plt_font,run_once_within
+from .ips import (
+    isa,
+    fsave,
+    fload,
+    mkdir,
+    listdir,
+    figsave,
+    strcmp,
+    unique,
+    get_os,
+    ssplit,
+    flatten,
+    plt_font,
+    run_once_within,
+)
 from .stats import *
 import os
+
 # Suppress INFO messages from fontTools
 logging.getLogger("fontTools").setLevel(logging.ERROR)
-logging.getLogger('matplotlib').setLevel(logging.ERROR)
+logging.getLogger("matplotlib").setLevel(logging.ERROR)
 
 warnings.simplefilter("ignore", category=pd.errors.SettingWithCopyWarning)
 warnings.filterwarnings("ignore", category=pd.errors.PerformanceWarning)
 
+
 def add_text(ax=None, height_offset=0.5, fmt=".1f", **kwargs):
     """Adds text annotations for various types of Seaborn and Matplotlib plots.
     Args:
@@ -449,7 +465,7 @@ def catplot(data, *args, **kwargs):
     """
     from matplotlib.colors import to_rgba
     import os
-    
+
     def plot_bars(data, data_m, opt_b, xloc, ax, label=None):
         if "l" in opt_b["loc"]:
             xloc_s = xloc - opt_b["x_dist"]
@@ -755,6 +771,7 @@ def catplot(data, *args, **kwargs):
                     )
             else:
                 from scipy.stats import gaussian_kde
+
                 kde = gaussian_kde(ys, bw_method=opt_v["BandWidth"])
                 min_val, max_val = ys.min(), ys.max()
                 y_vals = np.linspace(min_val, max_val, opt_v["NumPoints"])
@@ -1812,16 +1829,17 @@ def read_mplstyle(style_file):
     return style_dict
 
 
-def figsets(*args, **kwargs): 
+def figsets(*args, **kwargs):
     import matplotlib
     from cycler import cycler
+
     matplotlib.rc("text", usetex=False)
 
     fig = plt.gcf()
-    fontsize = kwargs.get("fontsize",11)
-    plt.rcParams["font.size"]=fontsize
-    fontname = kwargs.pop("fontname","Arial") 
-    fontname=plt_font(fontname) # 显示中文
+    fontsize = kwargs.get("fontsize", 11)
+    plt.rcParams["font.size"] = fontsize
+    fontname = kwargs.pop("fontname", "Arial")
+    fontname = plt_font(fontname)  # 显示中文
 
     sns_themes = ["white", "whitegrid", "dark", "darkgrid", "ticks"]
     sns_contexts = ["notebook", "talk", "poster"]  # now available "paper"
@@ -1851,18 +1869,21 @@ def figsets(*args, **kwargs):
         nonlocal fontsize, fontname
         if ("fo" in key) and (("size" in key) or ("sz" in key)):
             fontsize = value
-            plt.rcParams.update({"font.size": fontsize,
-                                "figure.titlesize":fontsize,
-                                "axes.titlesize":fontsize,
-                                "axes.labelsize": fontsize,
-                                "xtick.labelsize": fontsize,
-                                "ytick.labelsize": fontsize,
-                                "legend.fontsize": fontsize,
-                                "legend.title_fontsize":fontsize
-                                }) 
+            plt.rcParams.update(
+                {
+                    "font.size": fontsize,
+                    "figure.titlesize": fontsize,
+                    "axes.titlesize": fontsize,
+                    "axes.labelsize": fontsize,
+                    "xtick.labelsize": fontsize,
+                    "ytick.labelsize": fontsize,
+                    "legend.fontsize": fontsize,
+                    "legend.title_fontsize": fontsize,
+                }
+            )
 
             # Customize tick labels
-            ax.tick_params(axis='both', which='major', labelsize=fontsize)
+            ax.tick_params(axis="both", which="major", labelsize=fontsize)
             for label in ax.get_xticklabels() + ax.get_yticklabels():
                 label.set_fontname(fontname)
 
@@ -1910,15 +1931,15 @@ def figsets(*args, **kwargs):
             if ("x" in key.lower()) and (
                 "tic" not in key.lower() and "tk" not in key.lower()
             ):
-                ax.set_xlabel(value, fontname=fontname,fontsize=fontsize)
+                ax.set_xlabel(value, fontname=fontname, fontsize=fontsize)
             if ("y" in key.lower()) and (
                 "tic" not in key.lower() and "tk" not in key.lower()
             ):
-                ax.set_ylabel(value, fontname=fontname,fontsize=fontsize)
+                ax.set_ylabel(value, fontname=fontname, fontsize=fontsize)
             if ("z" in key.lower()) and (
                 "tic" not in key.lower() and "tk" not in key.lower()
             ):
-                ax.set_zlabel(value, fontname=fontname,fontsize=fontsize)
+                ax.set_zlabel(value, fontname=fontname, fontsize=fontsize)
         if key == "xlabel" and isinstance(value, dict):
             ax.set_xlabel(**value)
         if key == "ylabel" and isinstance(value, dict):
@@ -2110,6 +2131,7 @@ def figsets(*args, **kwargs):
 
         if "mi" in key.lower() and "tic" in key.lower():  # minor_ticks
             import matplotlib.ticker as tck
+
             if "x" in value.lower() or "x" in key.lower():
                 ax.xaxis.set_minor_locator(tck.AutoMinorLocator())  # ax.minorticks_on()
             if "y" in value.lower() or "y" in key.lower():
@@ -2162,9 +2184,9 @@ def figsets(*args, **kwargs):
                     ax.grid(visible=False)
         if "tit" in key.lower():
             if "sup" in key.lower():
-                plt.suptitle(value,fontname=fontname,fontsize=fontsize)
+                plt.suptitle(value, fontname=fontname, fontsize=fontsize)
             else:
-                ax.set_title(value,fontname=fontname,fontsize=fontsize)
+                ax.set_title(value, fontname=fontname, fontsize=fontsize)
         if key.lower() in ["spine", "adjust", "ad", "sp", "spi", "adj", "spines"]:
             if isinstance(value, bool) or (value in ["go", "do", "ja", "yes"]):
                 if value:
@@ -2185,9 +2207,14 @@ def figsets(*args, **kwargs):
                 legend = ax.get_legend()
                 if legend is not None:
                     legend.remove()
-        if any(['colorbar' in key.lower(),'cbar' in key.lower()]) and "loc" in key.lower():
+        if (
+            any(["colorbar" in key.lower(), "cbar" in key.lower()])
+            and "loc" in key.lower()
+        ):
             cbar = ax.collections[0].colorbar  # Access the colorbar from the plot
-            cbar.ax.set_position(value)  # [left, bottom, width, height] [0.475, 0.15, 0.04, 0.25]
+            cbar.ax.set_position(
+                value
+            )  # [left, bottom, width, height] [0.475, 0.15, 0.04, 0.25]
 
     for arg in args:
         if isinstance(arg, matplotlib.axes._axes.Axes):
@@ -2225,7 +2252,8 @@ def figsets(*args, **kwargs):
     if len(fig.get_axes()) > 1:
         plt.tight_layout()
 
-def split_legend(ax, n=2, loc=None, title=None, bbox=None,ncol=1, **kwargs):
+
+def split_legend(ax, n=2, loc=None, title=None, bbox=None, ncol=1, **kwargs):
     """
     split_legend(
         ax,
@@ -2238,15 +2266,15 @@ def split_legend(ax, n=2, loc=None, title=None, bbox=None,ncol=1, **kwargs):
     # Retrieve all lines and labels from the axis
     handles, labels = ax.get_legend_handles_labels()
     num_labels = len(labels)
-    
+
     # Calculate the number of labels per legend part
-    labels_per_part = (num_labels + n - 1) // n  # Round up 
+    labels_per_part = (num_labels + n - 1) // n  # Round up
     # Create a list to hold each legend object
     legends = []
 
     # Default locations and titles if not specified
     if loc is None:
-        loc = ['best'] * n
+        loc = ["best"] * n
     if title is None:
         title = [None] * n
     if bbox is None:
@@ -2257,7 +2285,7 @@ def split_legend(ax, n=2, loc=None, title=None, bbox=None,ncol=1, **kwargs):
         # Calculate the range of labels for this part
         start_idx = i * labels_per_part
         end_idx = min(start_idx + labels_per_part, num_labels)
-        
+
         # Skip if no labels in this range
         if start_idx >= end_idx:
             break
@@ -2267,19 +2295,24 @@ def split_legend(ax, n=2, loc=None, title=None, bbox=None,ncol=1, **kwargs):
         part_labels = labels[start_idx:end_idx]
 
         # Create the legend for this part
-        legend = ax.legend(handles=part_handles, 
-                           labels=part_labels,
-                           loc=loc[i], 
-                           title=title[i], 
-                           ncol=ncol, 
-                           bbox_to_anchor=bbox[i], 
-                           **kwargs)
-        
+        legend = ax.legend(
+            handles=part_handles,
+            labels=part_labels,
+            loc=loc[i],
+            title=title[i],
+            ncol=ncol,
+            bbox_to_anchor=bbox[i],
+            **kwargs,
+        )
+
         # Add the legend to the axis and save it to the list
-        ax.add_artist(legend) if i !=(n-1) else None # the lastone will be added automaticaly
+        (
+            ax.add_artist(legend) if i != (n - 1) else None
+        )  # the lastone will be added automaticaly
         legends.append(legend)
     return legends
 
+
 def get_colors(
     n: int = 1,
     cmap: str = "auto",
@@ -2289,7 +2322,9 @@ def get_colors(
     *args,
     **kwargs,
 ):
-    return get_color(n,cmap,alpha,output,*args,**kwargs)
+    return get_color(n, cmap, alpha, output, *args, **kwargs)
+
+
 def get_color(
     n: int = 1,
     cmap: str = "auto",
@@ -2300,6 +2335,7 @@ def get_color(
     **kwargs,
 ):
     from cycler import cycler
+
     def cmap2hex(cmap_name):
         cmap_ = matplotlib.pyplot.get_cmap(cmap_name)
         colors = [cmap_(i) for i in range(cmap_.N)]
@@ -2347,49 +2383,137 @@ def get_color(
             return "#{:02X}{:02X}{:02X}{:02X}".format(r, g, b, a)
         else:
             return "#{:02X}{:02X}{:02X}".format(r, g, b)
-        
+
     # sc.pl.palettes.default_20
-    cmap_20= ['#1f77b4','#ff7f0e','#279e68','#d62728','#aa40fc','#8c564b','#e377c2','#b5bd61',
-              '#17becf','#aec7e8','#ffbb78','#98df8a','#ff9896','#c5b0d5','#c49c94','#f7b6d2',
-              '#dbdb8d','#9edae5','#ad494a','#8c6d31']
+    cmap_20 = [
+        "#1f77b4",
+        "#ff7f0e",
+        "#279e68",
+        "#d62728",
+        "#aa40fc",
+        "#8c564b",
+        "#e377c2",
+        "#b5bd61",
+        "#17becf",
+        "#aec7e8",
+        "#ffbb78",
+        "#98df8a",
+        "#ff9896",
+        "#c5b0d5",
+        "#c49c94",
+        "#f7b6d2",
+        "#dbdb8d",
+        "#9edae5",
+        "#ad494a",
+        "#8c6d31",
+    ]
     # sc.pl.palettes.zeileis_28
-    cmap_28 = ["#023fa5","#7d87b9","#bec1d4","#d6bcc0","#bb7784","#8e063b","#4a6fe3","#8595e1",
-               "#b5bbe3","#e6afb9","#e07b91","#d33f6a","#11c638","#8dd593","#c6dec7","#ead3c6",
-               "#f0b98d","#ef9708","#0fcfc0","#9cded6","#d5eae7","#f3e1eb","#f6c4e1","#f79cd4",
-               "#7f7f7f","#c7c7c7","#1CE6FF","#336600"]
+    cmap_28 = [
+        "#023fa5",
+        "#7d87b9",
+        "#bec1d4",
+        "#d6bcc0",
+        "#bb7784",
+        "#8e063b",
+        "#4a6fe3",
+        "#8595e1",
+        "#b5bbe3",
+        "#e6afb9",
+        "#e07b91",
+        "#d33f6a",
+        "#11c638",
+        "#8dd593",
+        "#c6dec7",
+        "#ead3c6",
+        "#f0b98d",
+        "#ef9708",
+        "#0fcfc0",
+        "#9cded6",
+        "#d5eae7",
+        "#f3e1eb",
+        "#f6c4e1",
+        "#f79cd4",
+        "#7f7f7f",
+        "#c7c7c7",
+        "#1CE6FF",
+        "#336600",
+    ]
     if cmap == "gray":
         cmap = "grey"
-    elif cmap=="20":
-        cmap=cmap_20
-    elif cmap=="28":
-        cmap=cmap_28
+    elif cmap == "20":
+        cmap = cmap_20
+    elif cmap == "28":
+        cmap = cmap_28
     # Determine color list based on cmap parameter
-    if isinstance(cmap,str):
+    if isinstance(cmap, str):
         if "aut" in cmap:
             if n == 1:
                 colorlist = ["#3A4453"]
             elif n == 2:
                 colorlist = ["#3A4453", "#FF2C00"]
             elif n == 3:
-                colorlist = ["#66c2a5","#fc8d62","#8da0cb"]
+                colorlist = ["#66c2a5", "#fc8d62", "#8da0cb"]
             elif n == 4:
-                colorlist = ["#FF2C00","#087cf7", "#FBAF63", "#3C898A"]
+                colorlist = ["#FF2C00", "#087cf7", "#FBAF63", "#3C898A"]
             elif n == 5:
-                colorlist = ["#FF2C00","#459AA9", "#B25E9D", "#4B8C3B","#EF8632"]
+                colorlist = ["#FF2C00", "#459AA9", "#B25E9D", "#4B8C3B", "#EF8632"]
             elif n == 6:
-                colorlist = ["#FF2C00","#91bfdb", "#B25E9D", "#4B8C3B","#EF8632", "#24578E"]
-            elif n==7:
-                colorlist = ["#7F7F7F", "#459AA9", "#B25E9D", "#4B8C3B","#EF8632", "#24578E" "#FF2C00"] 
-            elif n==8:
+                colorlist = [
+                    "#FF2C00",
+                    "#91bfdb",
+                    "#B25E9D",
+                    "#4B8C3B",
+                    "#EF8632",
+                    "#24578E",
+                ]
+            elif n == 7:
+                colorlist = [
+                    "#7F7F7F",
+                    "#459AA9",
+                    "#B25E9D",
+                    "#4B8C3B",
+                    "#EF8632",
+                    "#24578E" "#FF2C00",
+                ]
+            elif n == 8:
                 # colorlist = ['#1f77b4','#ff7f0e','#367B7F','#51B34F','#d62728','#aa40fc','#e377c2','#17becf']
                 # colorlist = ["#367C7E","#51B34F","#881A11","#E9374C","#EF893C","#010072","#385DCB","#EA43E3"]
-                colorlist = ["#78BFDA","#D52E6F","#F7D648","#A52D28","#6B9F41","#E18330","#E18B9D","#3C88CC"]
-            elif n==9:
-                colorlist = ['#1f77b4','#ff7f0e','#367B7F','#ff9896','#d62728','#aa40fc','#e377c2','#51B34F','#17becf']
-            elif n==10:
-                colorlist = ['#1f77b4','#ff7f0e','#367B7F','#ff9896','#51B34F','#d62728''#aa40fc','#e377c2','#375FD2','#17becf']
-            elif 10<n<=20:
-                colorlist = cmap_20 
+                colorlist = [
+                    "#78BFDA",
+                    "#D52E6F",
+                    "#F7D648",
+                    "#A52D28",
+                    "#6B9F41",
+                    "#E18330",
+                    "#E18B9D",
+                    "#3C88CC",
+                ]
+            elif n == 9:
+                colorlist = [
+                    "#1f77b4",
+                    "#ff7f0e",
+                    "#367B7F",
+                    "#ff9896",
+                    "#d62728",
+                    "#aa40fc",
+                    "#e377c2",
+                    "#51B34F",
+                    "#17becf",
+                ]
+            elif n == 10:
+                colorlist = [
+                    "#1f77b4",
+                    "#ff7f0e",
+                    "#367B7F",
+                    "#ff9896",
+                    "#51B34F",
+                    "#d62728" "#aa40fc",
+                    "#e377c2",
+                    "#375FD2",
+                    "#17becf",
+                ]
+            elif 10 < n <= 20:
+                colorlist = cmap_20
             else:
                 colorlist = cmap_28
             by = "start"
@@ -2426,7 +2550,7 @@ def get_color(
                 by = "linspace"
             colorlist = cmap2hex(cmap)
     elif isinstance(cmap, list):
-        colorlist=cmap
+        colorlist = cmap
 
     # Determine method for generating color list
     if "st" in by.lower() or "be" in by.lower():
@@ -2446,7 +2570,7 @@ def get_color(
         return hue_list
     else:
         raise ValueError("Invalid output type. Choose 'rgb' or 'hue'.")
- 
+
 
 def stdshade(ax=None, *args, **kwargs):
     """
@@ -2454,7 +2578,7 @@ def stdshade(ax=None, *args, **kwargs):
     plot.stdshade(data_array, c=clist[1], lw=2, ls="-.", alpha=0.2)
     """
     from scipy.signal import savgol_filter
-    
+
     # Separate kws_line and kws_fill if necessary
     kws_line = kwargs.pop("kws_line", {})
     kws_fill = kwargs.pop("kws_fill", {})
@@ -2724,37 +2848,47 @@ def adjust_spines(ax=None, spines=["left", "bottom"], distance=2):
 #     cax = fig.add_axes([l + w + pad, b, width, h])  # define cbar Axes
 #     return fig.colorbar(im, cax=cax, **kwargs)  # draw cbar
 
-def add_colorbar(im, 
-                 cmap="viridis", 
-                 vmin=-1,
-                 vmax=1,
-                 orientation='vertical', 
-                 width_ratio=0.05, 
-                 pad_ratio=0.02, 
-                 shrink=1.0, 
-                 **kwargs):
+
+def add_colorbar(
+    im,
+    cmap="viridis",
+    vmin=-1,
+    vmax=1,
+    orientation="vertical",
+    width_ratio=0.05,
+    pad_ratio=0.02,
+    shrink=1.0,
+    **kwargs,
+):
     import matplotlib as mpl
+
     if all([cmap, vmin, vmax]):
         norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
     else:
-        norm=False
+        norm = False
     sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
     sm.set_array([])
     l, b, w, h = im.axes.get_position().bounds  # position: left, bottom, width, height
-    if orientation == 'vertical':
+    if orientation == "vertical":
         width = width_ratio * w
         pad = pad_ratio * w
-        cax = im.figure.add_axes([l + w + pad, b, width, h * shrink])  # Right of the image
+        cax = im.figure.add_axes(
+            [l + w + pad, b, width, h * shrink]
+        )  # Right of the image
     else:
         height = width_ratio * h
         pad = pad_ratio * h
-        cax = im.figure.add_axes([l, b - height - pad, w * shrink, height])  # Below the image
-    cbar=im.figure.colorbar(sm, cax=cax, orientation=orientation, **kwargs)
-    return cbar 
+        cax = im.figure.add_axes(
+            [l, b - height - pad, w * shrink, height]
+        )  # Below the image
+    cbar = im.figure.colorbar(sm, cax=cax, orientation=orientation, **kwargs)
+    return cbar
+
 
 # Usage:
 # add_colorbar(im, width_ratio=0.03, pad_ratio=0.01, orientation='horizontal', label="PSD (dB)")
 
+
 def generate_xticks_with_gap(x_len, hue_len):
     """
     Generate a concatenated array based on x_len and hue_len,
@@ -2884,6 +3018,7 @@ def style_examples(
     f = listdir(
         "/Users/macjianfeng/Dropbox/github/python/py2ls/.venv/lib/python3.12/site-packages/py2ls/data/styles/",
         kind=".json",
+        verbose=False,
     )
     display(f.sample(2))
     # def style_example(dir_save,)
@@ -2961,6 +3096,7 @@ def thumbnail(dir_img_list: list, figsize=(10, 10), dpi=100, show=False, verbose
 
 def get_params_from_func_usage(function_signature):
     import re
+
     # Regular expression to match parameter names, ignoring '*' and '**kwargs'
     keys_pattern = r"(?<!\*\*)\b(\w+)="
     # Find all matches
@@ -2987,7 +3123,7 @@ def plotxy(
     x=None,
     y=None,
     ax=None,
-    kind: Union[str, list] = 'scatter',  # Specify the kind of plot
+    kind: Union[str, list] = "scatter",  # Specify the kind of plot
     verbose=False,
     **kwargs,
 ):
@@ -3011,14 +3147,15 @@ def plotxy(
     # Check for valid plot kind
     # Default arguments for various plot types
     from pathlib import Path
+
     # Get the current script's directory as a Path object
-    current_directory = Path(__file__).resolve().parent 
+    current_directory = Path(__file__).resolve().parent
+
+    if not "default_settings" in locals():
+        default_settings = fload(current_directory / "data" / "usages_sns.json")
+    if not "sns_info" in locals():
+        sns_info = pd.DataFrame(fload(current_directory / "data" / "sns_info.json"))
 
-    if not 'default_settings' in locals():
-        default_settings = fload(current_directory / 'data' / 'usages_sns.json')
-    if not 'sns_info' in locals():
-        sns_info = pd.DataFrame(fload(current_directory / 'data' / 'sns_info.json'))
- 
     valid_kinds = list(default_settings.keys())
     # print(valid_kinds)
     if kind is not None:
@@ -3032,7 +3169,7 @@ def plotxy(
         if kind is not None:
             for k in kind:
                 if k in valid_kinds:
-                    print(f"{k}:\n\t{default_settings[k]}") 
+                    print(f"{k}:\n\t{default_settings[k]}")
         usage_str = """plotxy(data=ranked_genes,
         x="log2(fold_change)",
         y="-log10(p-value)",
@@ -3057,15 +3194,25 @@ def plotxy(
             kws_add_text = v_arg
             kwargs.pop(k_arg, None)
             break
-    zorder=0
+    zorder = 0
     for k in kind:
-        zorder+=1
+        zorder += 1
         # indicate 'col' features
         col = kwargs.get("col", None)
-        sns_with_col = ["catplot","histplot","relplot","lmplot","pairplot","displot","kdeplot"]
+        sns_with_col = [
+            "catplot",
+            "histplot",
+            "relplot",
+            "lmplot",
+            "pairplot",
+            "displot",
+            "kdeplot",
+        ]
         if col is not None:
             if not k in sns_with_col:
-                print(f"tips:\n'{k}' has no 'col' param, you could try with {sns_with_col}")
+                print(
+                    f"tips:\n'{k}' has no 'col' param, you could try with {sns_with_col}"
+                )
         # (1) return FcetGrid
         if k == "jointplot":
             kws_joint = kwargs.pop("kws_joint", kwargs)
@@ -3092,77 +3239,98 @@ def plotxy(
             ax = stdshade(ax=ax, **kwargs)
         elif k == "scatterplot":
             kws_scatter = kwargs.pop("kws_scatter", kwargs)
-            kws_scatter={k: v for k, v in kws_scatter.items() if not k.startswith("kws_")}
+            kws_scatter = {
+                k: v for k, v in kws_scatter.items() if not k.startswith("kws_")
+            }
             hue = kwargs.pop("hue", None)
             if isinstance(kws_scatter, dict):  # Check if kws_scatter is a dictionary
                 kws_scatter.pop("hue", None)  # Safely remove 'hue' if it exists
-            palette = kws_scatter.pop("palette",get_color(data[hue].nunique()) if hue is not None else None)
+            palette = kws_scatter.pop(
+                "palette", get_color(data[hue].nunique()) if hue is not None else None
+            )
             s = kws_scatter.pop("s", 10)
             alpha = kws_scatter.pop("alpha", 0.7)
-            ax = sns.scatterplot(ax=ax,data=data,x=x,y=y,hue=hue,palette=palette,s=s,alpha=alpha,zorder=zorder,**kws_scatter)
+            ax = sns.scatterplot(
+                ax=ax,
+                data=data,
+                x=x,
+                y=y,
+                hue=hue,
+                palette=palette,
+                s=s,
+                alpha=alpha,
+                zorder=zorder,
+                **kws_scatter,
+            )
         elif k == "histplot":
             kws_hist = kwargs.pop("kws_hist", kwargs)
-            kws_hist={k: v for k, v in kws_hist.items() if not k.startswith("kws_")}
-            ax = sns.histplot(data=data, x=x, ax=ax,zorder=zorder, **kws_hist)
+            kws_hist = {k: v for k, v in kws_hist.items() if not k.startswith("kws_")}
+            ax = sns.histplot(data=data, x=x, ax=ax, zorder=zorder, **kws_hist)
         elif k == "kdeplot":
             kws_kde = kwargs.pop("kws_kde", kwargs)
-            kws_kde={k: v for k, v in kws_kde.items() if not k.startswith("kws_")}
-            ax = sns.kdeplot(data=data, x=x, ax=ax,zorder=zorder, **kws_kde)
+            kws_kde = {k: v for k, v in kws_kde.items() if not k.startswith("kws_")}
+            ax = sns.kdeplot(data=data, x=x, ax=ax, zorder=zorder, **kws_kde)
         elif k == "ecdfplot":
             kws_ecdf = kwargs.pop("kws_ecdf", kwargs)
-            kws_ecdf={k: v for k, v in kws_ecdf.items() if not k.startswith("kws_")}
-            ax = sns.ecdfplot(data=data, x=x, ax=ax,zorder=zorder, **kws_ecdf)
+            kws_ecdf = {k: v for k, v in kws_ecdf.items() if not k.startswith("kws_")}
+            ax = sns.ecdfplot(data=data, x=x, ax=ax, zorder=zorder, **kws_ecdf)
         elif k == "rugplot":
             kws_rug = kwargs.pop("kws_rug", kwargs)
-            kws_rug={k: v for k, v in kws_rug.items() if not k.startswith("kws_")}
-            ax = sns.rugplot(data=data, x=x, ax=ax,zorder=zorder, **kws_rug)
+            kws_rug = {k: v for k, v in kws_rug.items() if not k.startswith("kws_")}
+            ax = sns.rugplot(data=data, x=x, ax=ax, zorder=zorder, **kws_rug)
         elif k == "stripplot":
             kws_strip = kwargs.pop("kws_strip", kwargs)
-            kws_strip={k: v for k, v in kws_strip.items() if not k.startswith("kws_")}
+            kws_strip = {k: v for k, v in kws_strip.items() if not k.startswith("kws_")}
             dodge = kws_strip.pop("dodge", True)
-            ax = sns.stripplot(data=data, x=x, y=y, ax=ax,zorder=zorder, dodge=dodge, **kws_strip)
+            ax = sns.stripplot(
+                data=data, x=x, y=y, ax=ax, zorder=zorder, dodge=dodge, **kws_strip
+            )
         elif k == "swarmplot":
             kws_swarm = kwargs.pop("kws_swarm", kwargs)
-            kws_swarm={k: v for k, v in kws_swarm.items() if not k.startswith("kws_")}
-            ax = sns.swarmplot(data=data, x=x, y=y, ax=ax,zorder=zorder, **kws_swarm)
+            kws_swarm = {k: v for k, v in kws_swarm.items() if not k.startswith("kws_")}
+            ax = sns.swarmplot(data=data, x=x, y=y, ax=ax, zorder=zorder, **kws_swarm)
         elif k == "boxplot":
             kws_box = kwargs.pop("kws_box", kwargs)
-            kws_box={k: v for k, v in kws_box.items() if not k.startswith("kws_")}
-            ax = sns.boxplot(data=data, x=x, y=y, ax=ax,zorder=zorder, **kws_box)
+            kws_box = {k: v for k, v in kws_box.items() if not k.startswith("kws_")}
+            ax = sns.boxplot(data=data, x=x, y=y, ax=ax, zorder=zorder, **kws_box)
         elif k == "violinplot":
             kws_violin = kwargs.pop("kws_violin", kwargs)
-            kws_violin={k: v for k, v in kws_violin.items() if not k.startswith("kws_")}
-            ax = sns.violinplot(data=data, x=x, y=y, ax=ax,zorder=zorder, **kws_violin)
+            kws_violin = {
+                k: v for k, v in kws_violin.items() if not k.startswith("kws_")
+            }
+            ax = sns.violinplot(data=data, x=x, y=y, ax=ax, zorder=zorder, **kws_violin)
         elif k == "boxenplot":
             kws_boxen = kwargs.pop("kws_boxen", kwargs)
-            kws_boxen={k: v for k, v in kws_boxen.items() if not k.startswith("kws_")}
-            ax = sns.boxenplot(data=data, x=x, y=y, ax=ax,zorder=zorder, **kws_boxen)
+            kws_boxen = {k: v for k, v in kws_boxen.items() if not k.startswith("kws_")}
+            ax = sns.boxenplot(data=data, x=x, y=y, ax=ax, zorder=zorder, **kws_boxen)
         elif k == "pointplot":
             kws_point = kwargs.pop("kws_point", kwargs)
-            kws_point={k: v for k, v in kws_point.items() if not k.startswith("kws_")}
-            ax = sns.pointplot(data=data, x=x, y=y, ax=ax,zorder=zorder, **kws_point)
+            kws_point = {k: v for k, v in kws_point.items() if not k.startswith("kws_")}
+            ax = sns.pointplot(data=data, x=x, y=y, ax=ax, zorder=zorder, **kws_point)
         elif k == "barplot":
             kws_bar = kwargs.pop("kws_bar", kwargs)
-            kws_bar={k: v for k, v in kws_bar.items() if not k.startswith("kws_")}
-            ax = sns.barplot(data=data, x=x, y=y, ax=ax,zorder=zorder, **kws_bar)
+            kws_bar = {k: v for k, v in kws_bar.items() if not k.startswith("kws_")}
+            ax = sns.barplot(data=data, x=x, y=y, ax=ax, zorder=zorder, **kws_bar)
         elif k == "countplot":
             kws_count = kwargs.pop("kws_count", kwargs)
-            kws_count={k: v for k, v in kws_count.items() if not k.startswith("kws_")}
-            if not kws_count.get("hue",None):
-                kws_count.pop("palette",None) 
-            ax = sns.countplot(data=data, x=x,y=y, ax=ax,zorder=zorder, **kws_count)
+            kws_count = {k: v for k, v in kws_count.items() if not k.startswith("kws_")}
+            if not kws_count.get("hue", None):
+                kws_count.pop("palette", None)
+            ax = sns.countplot(data=data, x=x, y=y, ax=ax, zorder=zorder, **kws_count)
         elif k == "regplot":
             kws_reg = kwargs.pop("kws_reg", kwargs)
-            kws_reg={k: v for k, v in kws_reg.items() if not k.startswith("kws_")}
-            ax = sns.regplot(data=data, x=x, y=y, ax=ax,zorder=zorder, **kws_reg)
+            kws_reg = {k: v for k, v in kws_reg.items() if not k.startswith("kws_")}
+            ax = sns.regplot(data=data, x=x, y=y, ax=ax, zorder=zorder, **kws_reg)
         elif k == "residplot":
             kws_resid = kwargs.pop("kws_resid", kwargs)
-            kws_resid={k: v for k, v in kws_resid.items() if not k.startswith("kws_")}
-            ax = sns.residplot(data=data, x=x, y=y, lowess=True,zorder=zorder, ax=ax, **kws_resid)
+            kws_resid = {k: v for k, v in kws_resid.items() if not k.startswith("kws_")}
+            ax = sns.residplot(
+                data=data, x=x, y=y, lowess=True, zorder=zorder, ax=ax, **kws_resid
+            )
         elif k == "lineplot":
             kws_line = kwargs.pop("kws_line", kwargs)
-            kws_line={k: v for k, v in kws_line.items() if not k.startswith("kws_")}
-            ax = sns.lineplot(ax=ax, data=data, x=x, y=y,zorder=zorder, **kws_line)
+            kws_line = {k: v for k, v in kws_line.items() if not k.startswith("kws_")}
+            ax = sns.lineplot(ax=ax, data=data, x=x, y=y, zorder=zorder, **kws_line)
 
         figsets(ax=ax, **kws_figsets)
         if kws_add_text:
@@ -3176,20 +3344,22 @@ def plotxy(
             return g, ax
     return ax
 
+
 def norm_cmap(data, cmap="coolwarm", min_max=[0, 1]):
     norm_ = plt.Normalize(min_max[0], min_max[1])
     colormap = plt.get_cmap(cmap)
     return colormap(norm_(data))
 
+
 def volcano(
-    data:pd.DataFrame,
-    x:str,
-    y:str,
-    gene_col:str=None,
-    top_genes=[5, 5], # [down-regulated, up-regulated]
-    thr_x=np.log2(1.5), # default: 0.585
+    data: pd.DataFrame,
+    x: str,
+    y: str,
+    gene_col: str = None,
+    top_genes=[5, 5],  # [down-regulated, up-regulated]
+    thr_x=np.log2(1.5),  # default: 0.585
     thr_y=-np.log10(0.05),
-    sort_xy="x", #'y', 'xy'
+    sort_xy="x",  #'y', 'xy'
     colors=("#00BFFF", "#9d9a9a", "#FF3030"),
     s=20,
     fill=True,  # plot filled scatter
@@ -3201,11 +3371,10 @@ def volcano(
     ax=None,
     verbose=False,
     kws_text=dict(fontsize=10, color="k"),
-    kws_bbox=dict(facecolor='none', 
-                  alpha=0.5, 
-                  edgecolor='black',
-                  boxstyle='round,pad=0.3'),# '{}' to hide
-    kws_arrow=dict(color="k", lw=0.5),# '{}' to hide
+    kws_bbox=dict(
+        facecolor="none", alpha=0.5, edgecolor="black", boxstyle="round,pad=0.3"
+    ),  # '{}' to hide
+    kws_arrow=dict(color="k", lw=0.5),  # '{}' to hide
     **kwargs,
 ):
     """
@@ -3275,39 +3444,35 @@ def volcano(
             kws_figsets = v_arg
             kwargs.pop(k_arg, None)
             break
-    
-    data=data.copy()
+
+    data = data.copy()
     # filter nan
     data = data.dropna(subset=[x, y])  # Drop rows with NaN in x or y
-    data.loc[:,"color"] = np.where(
+    data.loc[:, "color"] = np.where(
         (data[x] > thr_x) & (data[y] > thr_y),
         colors[2],
-        np.where((data[x] < -thr_x) & (data[y] > thr_y), 
-                 colors[0], 
-                 colors[1]),
+        np.where((data[x] < -thr_x) & (data[y] > thr_y), colors[0], colors[1]),
     )
-    top_genes=[top_genes, top_genes] if isinstance(top_genes,int) else top_genes
-    
+    top_genes = [top_genes, top_genes] if isinstance(top_genes, int) else top_genes
+
     # could custom how to select the top genes, x: x has priority
-    sort_by_x_y=[x,y] if sort_xy=="x" else [y,x]
-    ascending_up=[True, True] if sort_xy=="x" else [False, True]
-    ascending_down=[False, True] if sort_xy=="x" else [False, False]
-
-    down_reg_genes = data[
-        (data["color"] == colors[0]) & 
-        (data[x].abs() > thr_x) & 
-        (data[y] > thr_y)
-    ].sort_values(by=sort_by_x_y, ascending=ascending_up).head(top_genes[0])
-    up_reg_genes = data[
-        (data["color"] == colors[2]) & 
-        (data[x].abs() > thr_x) & 
-        (data[y] > thr_y)
-    ].sort_values(by=sort_by_x_y, ascending=ascending_down).head(top_genes[1])
+    sort_by_x_y = [x, y] if sort_xy == "x" else [y, x]
+    ascending_up = [True, True] if sort_xy == "x" else [False, True]
+    ascending_down = [False, True] if sort_xy == "x" else [False, False]
+
+    down_reg_genes = (
+        data[(data["color"] == colors[0]) & (data[x].abs() > thr_x) & (data[y] > thr_y)]
+        .sort_values(by=sort_by_x_y, ascending=ascending_up)
+        .head(top_genes[0])
+    )
+    up_reg_genes = (
+        data[(data["color"] == colors[2]) & (data[x].abs() > thr_x) & (data[y] > thr_y)]
+        .sort_values(by=sort_by_x_y, ascending=ascending_down)
+        .head(top_genes[1])
+    )
     sele_gene = pd.concat([down_reg_genes, up_reg_genes])
-    
-    palette = {colors[0]: colors[0], 
-               colors[1]: colors[1], 
-               colors[2]: colors[2]}
+
+    palette = {colors[0]: colors[0], colors[1]: colors[1], colors[2]: colors[2]}
     # Plot setup
     if ax is None:
         ax = plt.gca()
@@ -3337,9 +3502,9 @@ def volcano(
     )
 
     # Add threshold lines for x and y axes
-    ax.axhline(y=thr_y, color="black", linestyle="--",lw=1)
-    ax.axvline(x=-thr_x, color="black", linestyle="--",lw=1)
-    ax.axvline(x=thr_x, color="black", linestyle="--",lw=1)
+    ax.axhline(y=thr_y, color="black", linestyle="--", lw=1)
+    ax.axvline(x=-thr_x, color="black", linestyle="--", lw=1)
+    ax.axvline(x=thr_x, color="black", linestyle="--", lw=1)
 
     # Add gene labels for selected significant points
     if gene_col:
@@ -3349,19 +3514,28 @@ def volcano(
         textcolor = kws_text.pop("color", "k")
         fontsize = kws_text.pop("fontsize", 10)
         arrowstyles = [
-            "->","<-","<->","<|-","-|>","<|-|>",
-            "-","-[","-[",
-            "fancy","simple","wedge",
+            "->",
+            "<-",
+            "<->",
+            "<|-",
+            "-|>",
+            "<|-|>",
+            "-",
+            "-[",
+            "-[",
+            "fancy",
+            "simple",
+            "wedge",
         ]
         arrowstyle = kws_arrow.pop("style", "<|-")
-        arrowstyle = strcmp(arrowstyle, arrowstyles,scorer='strict')[0]
-        expand=kws_arrow.pop("expand",(1.05,1.1))
+        arrowstyle = strcmp(arrowstyle, arrowstyles, scorer="strict")[0]
+        expand = kws_arrow.pop("expand", (1.05, 1.1))
         arrowcolor = kws_arrow.pop("color", "0.4")
         arrowlinewidth = kws_arrow.pop("lw", 0.75)
         shrinkA = kws_arrow.pop("shrinkA", 0)
         shrinkB = kws_arrow.pop("shrinkB", 0)
         mutation_scale = kws_arrow.pop("head", 10)
-        arrow_fill=kws_arrow.pop("fill", False)
+        arrow_fill = kws_arrow.pop("fill", False)
         for i in range(sele_gene.shape[0]):
             if isinstance(textcolor, list):  # be consistant with dots's color
                 textcolor = colors[0] if sele_gene[x].iloc[i] > 0 else colors[1]
@@ -3382,7 +3556,7 @@ def volcano(
         adjust_text(
             texts,
             expand=expand,
-            min_arrow_len=5, 
+            min_arrow_len=5,
             ax=ax,
             arrowprops=dict(
                 arrowstyle=arrowstyle,
@@ -3393,7 +3567,7 @@ def volcano(
                 shrinkB=shrinkB,
                 mutation_scale=mutation_scale,
                 **kws_arrow,
-            )
+            ),
         )
 
     figsets(**kws_figsets)
@@ -3499,6 +3673,7 @@ def desaturate_color(color, saturation_factor=0.5):
     """Reduce the saturation of a color by a given factor (between 0 and 1)."""
     import matplotlib.colors as mcolors
     import colorsys
+
     # Convert the color to RGB
     rgb = mcolors.to_rgb(color)
     # Convert RGB to HLS (Hue, Lightness, Saturation)
@@ -3508,8 +3683,19 @@ def desaturate_color(color, saturation_factor=0.5):
     # Convert back to RGB
     return colorsys.hls_to_rgb(h, l, s)
 
-def textsets(text, fontname='Arial', fontsize=11, fontweight="normal", fontstyle="normal", 
-             fontcolor='k', backgroundcolor=None, shadow=False, ha="center", va="center"):
+
+def textsets(
+    text,
+    fontname="Arial",
+    fontsize=11,
+    fontweight="normal",
+    fontstyle="normal",
+    fontcolor="k",
+    backgroundcolor=None,
+    shadow=False,
+    ha="center",
+    va="center",
+):
     if text:  # Ensure text exists
         if fontname:
             text.set_fontname(plt_font(fontname))
@@ -3522,26 +3708,28 @@ def textsets(text, fontname='Arial', fontsize=11, fontweight="normal", fontstyle
         if fontcolor:
             text.set_color(fontcolor)
         if backgroundcolor:
-            text.set_backgroundcolor(backgroundcolor) 
+            text.set_backgroundcolor(backgroundcolor)
         text.set_horizontalalignment(ha)
-        text.set_verticalalignment(va) 
+        text.set_verticalalignment(va)
         if shadow:
-            text.set_path_effects([
-                matplotlib.patheffects.withStroke(linewidth=3, foreground="gray")
-            ])
+            text.set_path_effects(
+                [matplotlib.patheffects.withStroke(linewidth=3, foreground="gray")]
+            )
+
+
 def venn(
-    lists:list,
-    labels:list=None,
+    lists: list,
+    labels: list = None,
     ax=None,
     colors=None,
     edgecolor=None,
     alpha=0.5,
-    saturation=.75,
-    linewidth=0, # default no edge
+    saturation=0.75,
+    linewidth=0,  # default no edge
     linestyle="-",
-    fontname='Arial',
+    fontname="Arial",
     fontsize=10,
-    fontcolor='k',
+    fontcolor="k",
     fontweight="normal",
     fontstyle="normal",
     ha="center",
@@ -3550,18 +3738,18 @@ def venn(
     subset_fontsize=10,
     subset_fontweight="normal",
     subset_fontstyle="normal",
-    subset_fontcolor='k',
+    subset_fontcolor="k",
     backgroundcolor=None,
     custom_texts=None,
-    show_percentages=True,   # display percentage
+    show_percentages=True,  # display percentage
     fmt="{:.1%}",
     ellipse_shape=False,  # 椭圆形
-    ellipse_scale=[1.5, 1],  #not perfect, 椭圆形的形状
-    **kwargs
+    ellipse_scale=[1.5, 1],  # not perfect, 椭圆形的形状
+    **kwargs,
 ):
     """
     Advanced Venn diagram plotting function with extensive customization options.
-    Usage: 
+    Usage:
         # Define the two sets
         set1 = [1, 2, 3, 4, 5]
         set2 = [4, 5, 6, 7, 8]
@@ -3612,56 +3800,70 @@ def venn(
     """
     if ax is None:
         ax = plt.gca()
-    lists=[set(flatten(i, verbose=False)) for i in lists]
+    lists = [set(flatten(i, verbose=False)) for i in lists]
     # Function to apply text styles to labels
     if colors is None:
-        colors=["r","b"] if len(lists)==2 else ["r","g","b"]
+        colors = ["r", "b"] if len(lists) == 2 else ["r", "g", "b"]
     if labels is None:
-        labels=["set1","set2"] if len(lists)==2 else ["set1","set2","set3"]
+        labels = ["set1", "set2"] if len(lists) == 2 else ["set1", "set2", "set3"]
     if edgecolor is None:
-        edgecolor=colors
+        edgecolor = colors
     colors = [desaturate_color(color, saturation) for color in colors]
     # Check colors and auto-calculate overlaps
     if len(lists) == 2:
+
         def get_count_and_percentage(set_count, subset_count):
             percent = subset_count / set_count if set_count > 0 else 0
-            return f"{subset_count}\n({fmt.format(percent)})" if show_percentages else f"{subset_count}"
+            return (
+                f"{subset_count}\n({fmt.format(percent)})"
+                if show_percentages
+                else f"{subset_count}"
+            )
 
         from matplotlib_venn import venn2, venn2_circles
+
         # Auto-calculate overlap color for 2-set Venn diagram
         overlap_color = get_color_overlap(colors[0], colors[1]) if colors else None
-        
+
         # Draw the venn diagram
         v = venn2(subsets=lists, set_labels=labels, ax=ax, **kwargs)
         venn_circles = venn2_circles(subsets=lists, ax=ax)
-        set1,set2=lists[0],lists[1]
-        v.get_patch_by_id('10').set_color(colors[0])
-        v.get_patch_by_id('01').set_color(colors[1])
-        v.get_patch_by_id('11').set_color(get_color_overlap(colors[0], colors[1]) if colors else None)
+        set1, set2 = lists[0], lists[1]
+        v.get_patch_by_id("10").set_color(colors[0])
+        v.get_patch_by_id("01").set_color(colors[1])
+        v.get_patch_by_id("11").set_color(
+            get_color_overlap(colors[0], colors[1]) if colors else None
+        )
         # v.get_label_by_id('10').set_text(len(set1 - set2))
         # v.get_label_by_id('01').set_text(len(set2 - set1))
         # v.get_label_by_id('11').set_text(len(set1 & set2))
-        v.get_label_by_id('10').set_text(get_count_and_percentage(len(set1), len(set1 - set2)))
-        v.get_label_by_id('01').set_text(get_count_and_percentage(len(set2), len(set2 - set1)))
-        v.get_label_by_id('11').set_text(get_count_and_percentage(len(set1 | set2), len(set1 & set2)))
-
+        v.get_label_by_id("10").set_text(
+            get_count_and_percentage(len(set1), len(set1 - set2))
+        )
+        v.get_label_by_id("01").set_text(
+            get_count_and_percentage(len(set2), len(set2 - set1))
+        )
+        v.get_label_by_id("11").set_text(
+            get_count_and_percentage(len(set1 | set2), len(set1 & set2))
+        )
 
-        if not isinstance(linewidth,list):
-            linewidth=[linewidth]
-        if isinstance(linestyle,str):
-            linestyle=[linestyle]
+        if not isinstance(linewidth, list):
+            linewidth = [linewidth]
+        if isinstance(linestyle, str):
+            linestyle = [linestyle]
         if not isinstance(edgecolor, list):
-            edgecolor=[edgecolor]
-        linewidth=linewidth*2 if len(linewidth)==1 else linewidth
-        linestyle=linestyle*2 if len(linestyle)==1 else linestyle
-        edgecolor=edgecolor*2 if len(edgecolor)==1 else edgecolor 
+            edgecolor = [edgecolor]
+        linewidth = linewidth * 2 if len(linewidth) == 1 else linewidth
+        linestyle = linestyle * 2 if len(linestyle) == 1 else linestyle
+        edgecolor = edgecolor * 2 if len(edgecolor) == 1 else edgecolor
         for i in range(2):
             venn_circles[i].set_lw(linewidth[i])
             venn_circles[i].set_ls(linestyle[i])
             venn_circles[i].set_edgecolor(edgecolor[i])
         # 椭圆
         if ellipse_shape:
-            import matplotlib.patches as patches 
+            import matplotlib.patches as patches
+
             for patch in v.patches:
                 patch.set_visible(False)  # Hide original patches if using ellipses
             center1 = v.get_circle_center(0)
@@ -3672,9 +3874,13 @@ def venn(
                 height=ellipse_scale[1],
                 edgecolor=edgecolor[0] if edgecolor else colors[0],
                 facecolor=colors[0],
-                lw=linewidth if isinstance(linewidth, (int, float)) else 1.0,  # Ensure lw is a number
+                lw=(
+                    linewidth if isinstance(linewidth, (int, float)) else 1.0
+                ),  # Ensure lw is a number
                 ls=linestyle[0],
-                alpha=alpha if isinstance(alpha, (int, float)) else 0.5  # Ensure alpha is a number
+                alpha=(
+                    alpha if isinstance(alpha, (int, float)) else 0.5
+                ),  # Ensure alpha is a number
             )
             ellipse2 = patches.Ellipse(
                 (center2.x, center2.y),
@@ -3682,48 +3888,78 @@ def venn(
                 height=ellipse_scale[1],
                 edgecolor=edgecolor[1] if edgecolor else colors[1],
                 facecolor=colors[1],
-                lw=linewidth if isinstance(linewidth, (int, float)) else 1.0,  # Ensure lw is a number
+                lw=(
+                    linewidth if isinstance(linewidth, (int, float)) else 1.0
+                ),  # Ensure lw is a number
                 ls=linestyle[0],
-                alpha=alpha if isinstance(alpha, (int, float)) else 0.5  # Ensure alpha is a number
+                alpha=(
+                    alpha if isinstance(alpha, (int, float)) else 0.5
+                ),  # Ensure alpha is a number
             )
             ax.add_patch(ellipse1)
             ax.add_patch(ellipse2)
         # Apply styles to set labels
         for i, text in enumerate(v.set_labels):
-            textsets(text, fontname=fontname, fontsize=fontsize, fontweight=fontweight, fontstyle=fontstyle,
-                     fontcolor=fontcolor,ha=ha,va=va,shadow=shadow)
+            textsets(
+                text,
+                fontname=fontname,
+                fontsize=fontsize,
+                fontweight=fontweight,
+                fontstyle=fontstyle,
+                fontcolor=fontcolor,
+                ha=ha,
+                va=va,
+                shadow=shadow,
+            )
 
         # Apply styles to subset labels
         for i, text in enumerate(v.subset_labels):
             if text:  # Ensure text exists
                 if custom_texts:  # Custom text handling
-                    text.set_text(custom_texts[i]) 
-                textsets(text, fontname=fontname, fontsize=subset_fontsize, fontweight=subset_fontweight, fontstyle=subset_fontstyle,
-                     fontcolor=subset_fontcolor,ha=ha,va=va,shadow=shadow)
+                    text.set_text(custom_texts[i])
+                textsets(
+                    text,
+                    fontname=fontname,
+                    fontsize=subset_fontsize,
+                    fontweight=subset_fontweight,
+                    fontstyle=subset_fontstyle,
+                    fontcolor=subset_fontcolor,
+                    ha=ha,
+                    va=va,
+                    shadow=shadow,
+                )
 
     elif len(lists) == 3:
+
         def get_label(set_count, subset_count):
             percent = subset_count / set_count if set_count > 0 else 0
-            return f"{subset_count}\n({fmt.format(percent)})" if show_percentages else f"{subset_count}"
-        
+            return (
+                f"{subset_count}\n({fmt.format(percent)})"
+                if show_percentages
+                else f"{subset_count}"
+            )
+
         from matplotlib_venn import venn3, venn3_circles
+
         # Auto-calculate overlap colors for 3-set Venn diagram
         colorAB = get_color_overlap(colors[0], colors[1]) if colors else None
         colorAC = get_color_overlap(colors[0], colors[2]) if colors else None
         colorBC = get_color_overlap(colors[1], colors[2]) if colors else None
-        colorABC = get_color_overlap(colors[0], colors[1], colors[2]) if colors else None
-        set1,set2,set3=lists[0],lists[1],lists[2]
+        colorABC = (
+            get_color_overlap(colors[0], colors[1], colors[2]) if colors else None
+        )
+        set1, set2, set3 = lists[0], lists[1], lists[2]
 
         # Draw the venn diagram
-        v = venn3(subsets=lists, set_labels=labels, ax=ax,**kwargs) 
-        v.get_patch_by_id('100').set_color(colors[0])
-        v.get_patch_by_id('010').set_color(colors[1])
-        v.get_patch_by_id('001').set_color(colors[2]) 
-        v.get_patch_by_id('110').set_color(colorAB)
-        v.get_patch_by_id('101').set_color(colorAC)
-        v.get_patch_by_id('011').set_color(colorBC)
-        v.get_patch_by_id('111').set_color(colorABC)
-        
+        v = venn3(subsets=lists, set_labels=labels, ax=ax, **kwargs)
+        v.get_patch_by_id("100").set_color(colors[0])
+        v.get_patch_by_id("010").set_color(colors[1])
+        v.get_patch_by_id("001").set_color(colors[2])
+        v.get_patch_by_id("110").set_color(colorAB)
+        v.get_patch_by_id("101").set_color(colorAC)
+        v.get_patch_by_id("011").set_color(colorBC)
+        v.get_patch_by_id("111").set_color(colorABC)
+
         # Correctly labeling subset sizes
         # v.get_label_by_id('100').set_text(len(set1 - set2 - set3))
         # v.get_label_by_id('010').set_text(len(set2 - set1 - set3))
@@ -3732,63 +3968,93 @@ def venn(
         # v.get_label_by_id('101').set_text(len(set1 & set3 - set2))
         # v.get_label_by_id('011').set_text(len(set2 & set3 - set1))
         # v.get_label_by_id('111').set_text(len(set1 & set2 & set3))
-        v.get_label_by_id('100').set_text(get_label(len(set1), len(set1 - set2 - set3)))
-        v.get_label_by_id('010').set_text(get_label(len(set2), len(set2 - set1 - set3)))
-        v.get_label_by_id('001').set_text(get_label(len(set3), len(set3 - set1 - set2)))
-        v.get_label_by_id('110').set_text(get_label(len(set1 | set2), len(set1 & set2 - set3)))
-        v.get_label_by_id('101').set_text(get_label(len(set1 | set3), len(set1 & set3 - set2)))
-        v.get_label_by_id('011').set_text(get_label(len(set2 | set3), len(set2 & set3 - set1)))
-        v.get_label_by_id('111').set_text(get_label(len(set1 | set2 | set3), len(set1 & set2 & set3)))
-
+        v.get_label_by_id("100").set_text(get_label(len(set1), len(set1 - set2 - set3)))
+        v.get_label_by_id("010").set_text(get_label(len(set2), len(set2 - set1 - set3)))
+        v.get_label_by_id("001").set_text(get_label(len(set3), len(set3 - set1 - set2)))
+        v.get_label_by_id("110").set_text(
+            get_label(len(set1 | set2), len(set1 & set2 - set3))
+        )
+        v.get_label_by_id("101").set_text(
+            get_label(len(set1 | set3), len(set1 & set3 - set2))
+        )
+        v.get_label_by_id("011").set_text(
+            get_label(len(set2 | set3), len(set2 & set3 - set1))
+        )
+        v.get_label_by_id("111").set_text(
+            get_label(len(set1 | set2 | set3), len(set1 & set2 & set3))
+        )
 
         # Apply styles to set labels
         for i, text in enumerate(v.set_labels):
-            textsets(text, fontname=fontname, fontsize=fontsize, fontweight=fontweight, fontstyle=fontstyle,
-                     fontcolor=fontcolor,ha=ha,va=va,shadow=shadow)
+            textsets(
+                text,
+                fontname=fontname,
+                fontsize=fontsize,
+                fontweight=fontweight,
+                fontstyle=fontstyle,
+                fontcolor=fontcolor,
+                ha=ha,
+                va=va,
+                shadow=shadow,
+            )
 
         # Apply styles to subset labels
         for i, text in enumerate(v.subset_labels):
             if text:  # Ensure text exists
                 if custom_texts:  # Custom text handling
                     text.set_text(custom_texts[i])
-                textsets(text, fontname=fontname, fontsize=subset_fontsize, fontweight=subset_fontweight, fontstyle=subset_fontstyle,
-                     fontcolor=subset_fontcolor,ha=ha,va=va,shadow=shadow)
+                textsets(
+                    text,
+                    fontname=fontname,
+                    fontsize=subset_fontsize,
+                    fontweight=subset_fontweight,
+                    fontstyle=subset_fontstyle,
+                    fontcolor=subset_fontcolor,
+                    ha=ha,
+                    va=va,
+                    shadow=shadow,
+                )
 
         venn_circles = venn3_circles(subsets=lists, ax=ax)
-        if not isinstance(linewidth,list):
-            linewidth=[linewidth]
-        if isinstance(linestyle,str):
-            linestyle=[linestyle]
+        if not isinstance(linewidth, list):
+            linewidth = [linewidth]
+        if isinstance(linestyle, str):
+            linestyle = [linestyle]
         if not isinstance(edgecolor, list):
-            edgecolor=[edgecolor]
-        linewidth=linewidth*3 if len(linewidth)==1 else linewidth
-        linestyle=linestyle*3 if len(linestyle)==1 else linestyle
-        edgecolor=edgecolor*3 if len(edgecolor)==1 else edgecolor
+            edgecolor = [edgecolor]
+        linewidth = linewidth * 3 if len(linewidth) == 1 else linewidth
+        linestyle = linestyle * 3 if len(linestyle) == 1 else linestyle
+        edgecolor = edgecolor * 3 if len(edgecolor) == 1 else edgecolor
 
         # edgecolor=[to_rgba(i) for i in edgecolor]
 
-        for i in range(3): 
+        for i in range(3):
             venn_circles[i].set_lw(linewidth[i])
-            venn_circles[i].set_ls(linestyle[i]) 
-            venn_circles[i].set_edgecolor(edgecolor[i]) 
+            venn_circles[i].set_ls(linestyle[i])
+            venn_circles[i].set_edgecolor(edgecolor[i])
 
-        #椭圆形
+        # 椭圆形
         if ellipse_shape:
-            import matplotlib.patches as patches 
+            import matplotlib.patches as patches
+
             for patch in v.patches:
                 patch.set_visible(False)  # Hide original patches if using ellipses
             center1 = v.get_circle_center(0)
             center2 = v.get_circle_center(1)
-            center3 = v.get_circle_center(2) 
+            center3 = v.get_circle_center(2)
             ellipse1 = patches.Ellipse(
                 (center1.x, center1.y),
                 width=ellipse_scale[0],
                 height=ellipse_scale[1],
                 edgecolor=edgecolor[0] if edgecolor else colors[0],
                 facecolor=colors[0],
-                lw=linewidth if isinstance(linewidth, (int, float)) else 1.0,  # Ensure lw is a number
+                lw=(
+                    linewidth if isinstance(linewidth, (int, float)) else 1.0
+                ),  # Ensure lw is a number
                 ls=linestyle[0],
-                alpha=alpha if isinstance(alpha, (int, float)) else 0.5  # Ensure alpha is a number
+                alpha=(
+                    alpha if isinstance(alpha, (int, float)) else 0.5
+                ),  # Ensure alpha is a number
             )
             ellipse2 = patches.Ellipse(
                 (center2.x, center2.y),
@@ -3796,9 +4062,13 @@ def venn(
                 height=ellipse_scale[1],
                 edgecolor=edgecolor[1] if edgecolor else colors[1],
                 facecolor=colors[1],
-                lw=linewidth if isinstance(linewidth, (int, float)) else 1.0,  # Ensure lw is a number
+                lw=(
+                    linewidth if isinstance(linewidth, (int, float)) else 1.0
+                ),  # Ensure lw is a number
                 ls=linestyle[0],
-                alpha=alpha if isinstance(alpha, (int, float)) else 0.5  # Ensure alpha is a number
+                alpha=(
+                    alpha if isinstance(alpha, (int, float)) else 0.5
+                ),  # Ensure alpha is a number
             )
             ellipse3 = patches.Ellipse(
                 (center3.x, center3.y),
@@ -3806,9 +4076,13 @@ def venn(
                 height=ellipse_scale[1],
                 edgecolor=edgecolor[1] if edgecolor else colors[1],
                 facecolor=colors[1],
-                lw=linewidth if isinstance(linewidth, (int, float)) else 1.0,  # Ensure lw is a number
+                lw=(
+                    linewidth if isinstance(linewidth, (int, float)) else 1.0
+                ),  # Ensure lw is a number
                 ls=linestyle[0],
-                alpha=alpha if isinstance(alpha, (int, float)) else 0.5  # Ensure alpha is a number
+                alpha=(
+                    alpha if isinstance(alpha, (int, float)) else 0.5
+                ),  # Ensure alpha is a number
             )
             ax.add_patch(ellipse1)
             ax.add_patch(ellipse2)
@@ -3820,17 +4094,20 @@ def venn(
     for patch in v.patches:
         if patch:
             patch.set_alpha(alpha)
-            if 'none' in edgecolor or 0 in linewidth:
+            if "none" in edgecolor or 0 in linewidth:
                 patch.set_edgecolor("none")
     return ax
 
+
 #! subplots, support automatic extend new axis
-def subplot(rows:int=2, 
-            cols:int=2, 
-            figsize:Union[tuple,list]=[8, 8], 
-            sharex=False, 
-            sharey=False, 
-            **kwargs):
+def subplot(
+    rows: int = 2,
+    cols: int = 2,
+    figsize: Union[tuple, list] = [8, 8],
+    sharex=False,
+    sharey=False,
+    **kwargs,
+):
     """
     nexttile = subplot(
         8,
@@ -3850,11 +4127,14 @@ def subplot(rows:int=2,
         ax.set_xlabel(f"Tile {i + 1}")
     """
     from matplotlib.gridspec import GridSpec
+
     if run_once_within():
-        print(f"usage:\n\tnexttile = subplot(2, 2, figsize=(5, 5), sharex=True, sharey=True)\n\tax = nexttile()")
+        print(
+            f"usage:\n\tnexttile = subplot(2, 2, figsize=(5, 5), sharex=True, sharey=True)\n\tax = nexttile()"
+        )
     fig = plt.figure(figsize=figsize)
     grid_spec = GridSpec(rows, cols, figure=fig)
-    occupied = set() 
+    occupied = set()
     row_first_axes = [None] * rows  # Track the first axis in each row (for sharey)
     col_first_axes = [None] * cols  # Track the first axis in each column (for sharex)
 
@@ -3862,8 +4142,9 @@ def subplot(rows:int=2,
         nonlocal rows, grid_spec
         rows += 1  # Expands by adding a row
         grid_spec = GridSpec(rows, cols, figure=fig)
+
     def nexttile(rowspan=1, colspan=1, **kwargs):
-        nonlocal rows, cols, occupied, grid_spec 
+        nonlocal rows, cols, occupied, grid_spec
         for row in range(rows):
             for col in range(cols):
                 if all(
@@ -3873,29 +4154,29 @@ def subplot(rows:int=2,
                 ):
                     break
             else:
-                continue 
+                continue
             break
-        else: 
+        else:
             expand_ax()
             return nexttile(rowspan=rowspan, colspan=colspan, **kwargs)
 
-        sharex_ax,sharey_ax = None, None
+        sharex_ax, sharey_ax = None, None
 
-        if sharex: 
+        if sharex:
             sharex_ax = col_first_axes[col]
 
-        if sharey: 
-            sharey_ax = row_first_axes[row] 
+        if sharey:
+            sharey_ax = row_first_axes[row]
         ax = fig.add_subplot(
             grid_spec[row : row + rowspan, col : col + colspan],
             sharex=sharex_ax,
             sharey=sharey_ax,
-            **kwargs
-        ) 
+            **kwargs,
+        )
         if row_first_axes[row] is None:
             row_first_axes[row] = ax
         if col_first_axes[col] is None:
-            col_first_axes[col] = ax 
+            col_first_axes[col] = ax
         for r in range(row, row + rowspan):
             for c in range(col, col + colspan):
                 occupied.add((r, c))
@@ -3907,17 +4188,17 @@ def subplot(rows:int=2,
 
 #! radar chart
 def radar(
-    data: pd.DataFrame, 
-    ylim=(0,100),
+    data: pd.DataFrame,
+    ylim=(0, 100),
     color=get_color(5),
     fontsize=10,
-    fontcolor='k',
+    fontcolor="k",
     size=6,
     linewidth=1,
     linestyle="-",
     alpha=0.5,
     marker="o",
-    edgecolor='none',
+    edgecolor="none",
     edge_linewidth=0,
     bg_color="0.8",
     bg_alpha=None,
@@ -3928,18 +4209,19 @@ def radar(
     legend_fontsize=10,
     grid_color="gray",
     grid_alpha=0.5,
-    grid_linestyle="--",grid_linewidth=0.5,
+    grid_linestyle="--",
+    grid_linewidth=0.5,
     circular: bool = False,
     tick_fontsize=None,
     tick_fontcolor="0.65",
-    tick_loc = None,# label position
-    turning = None,
+    tick_loc=None,  # label position
+    turning=None,
     ax=None,
     sp=2,
-    **kwargs
+    **kwargs,
 ):
     """
-    Example DATA: 
+    Example DATA:
         df = pd.DataFrame(
         data=[
             [80, 80, 80, 80, 80, 80, 80],
@@ -3948,7 +4230,7 @@ def radar(
         ],
         index=["Hero", "Warrior", "Wizard"],
         columns=["HP", "MP", "ATK", "DEF", "SP.ATK", "SP.DEF", "SPD"])
-    
+
     Parameters:
         - data (pd.DataFrame): The data to plot. Each column corresponds to a variable, and each row represents a data point.
         - ylim (tuple): The limits of the radial axis (y-axis). Default is (0, 100).
@@ -4002,8 +4284,12 @@ def radar(
 
     # bg_color
     if bg_alpha is None:
-        bg_alpha=alpha
-    ax.set_facecolor(to_rgba(bg_color,alpha=bg_alpha)) if circular else ax.set_facecolor('none')
+        bg_alpha = alpha
+    (
+        ax.set_facecolor(to_rgba(bg_color, alpha=bg_alpha))
+        if circular
+        else ax.set_facecolor("none")
+    )
     # Set up the radar chart with straight-line connections
     ax.set_theta_offset(np.pi / 2)
     ax.set_theta_direction(-1)
@@ -4012,53 +4298,68 @@ def radar(
     ax.set_xticks(angles[:-1])
     ax.set_xticklabels(categories)
 
-    # Set y-axis limits and grid intervals 
+    # Set y-axis limits and grid intervals
     vmin, vmax = ylim
-    if circular: 
-        #* cicular style
-        ax.yaxis.set_ticks(np.arange(vmin, vmax+1, vmax * grid_interval_ratio))
-        ax.grid(axis='both',
-                color=grid_color, 
-                linestyle=grid_linestyle, 
-                alpha=grid_alpha,
-                linewidth=grid_linewidth,
-                dash_capstyle='round',
-                dash_joinstyle='round',
-                )
-        ax.spines["polar"].set_color(grid_color) 
+    if circular:
+        # * cicular style
+        ax.yaxis.set_ticks(np.arange(vmin, vmax + 1, vmax * grid_interval_ratio))
+        ax.grid(
+            axis="both",
+            color=grid_color,
+            linestyle=grid_linestyle,
+            alpha=grid_alpha,
+            linewidth=grid_linewidth,
+            dash_capstyle="round",
+            dash_joinstyle="round",
+        )
+        ax.spines["polar"].set_color(grid_color)
         ax.spines["polar"].set_linewidth(grid_linewidth)
-        ax.spines["polar"].set_linestyle('-')
+        ax.spines["polar"].set_linestyle("-")
         ax.spines["polar"].set_alpha(grid_alpha)
-        ax.spines["polar"].set_capstyle('round')
-        ax.spines["polar"].set_joinstyle('round')
+        ax.spines["polar"].set_capstyle("round")
+        ax.spines["polar"].set_joinstyle("round")
 
     else:
-        #* spider style: spider-style grid (straight lines, not circles)
+        # * spider style: spider-style grid (straight lines, not circles)
         # Create the spider-style grid (straight lines, not circles)
-        for i in range(1, int(vmax * grid_interval_ratio) + 1): 
+        for i in range(1, int(vmax * grid_interval_ratio) + 1):
             ax.plot(
                 angles + [angles[0]],  # Closing the loop
-                [i * vmax * grid_interval_ratio] * (num_vars+1) + [i * vmax * grid_interval_ratio], 
-                color=grid_color, linestyle=grid_linestyle, alpha=grid_alpha,linewidth=grid_linewidth
+                [i * vmax * grid_interval_ratio] * (num_vars + 1)
+                + [i * vmax * grid_interval_ratio],
+                color=grid_color,
+                linestyle=grid_linestyle,
+                alpha=grid_alpha,
+                linewidth=grid_linewidth,
             )
-        # set bg_color 
-        ax.fill(angles, [vmax]*(data.shape[1]+1), color=bg_color, alpha=bg_alpha)
+        # set bg_color
+        ax.fill(angles, [vmax] * (data.shape[1] + 1), color=bg_color, alpha=bg_alpha)
         ax.yaxis.grid(False)
     # Move radial labels away from plotted line
     if tick_loc is None:
-        tick_loc  = np.mean([angles[0],angles[1]])/(2*np.pi)*360 if circular else 0
+        tick_loc = (
+            np.mean([angles[0], angles[1]]) / (2 * np.pi) * 360 if circular else 0
+        )
 
     ax.set_rlabel_position(tick_loc)
     ax.set_theta_offset(turning) if turning is not None else None
-    ax.tick_params(axis='x', labelsize=fontsize, colors=fontcolor)  # Optional: for angular labels
-    tick_fontsize = fontsize-2 if fontsize is None else tick_fontsize
-    ax.tick_params(axis='y', labelsize=tick_fontsize, colors=tick_fontcolor)  # For radial labels
+    ax.tick_params(
+        axis="x", labelsize=fontsize, colors=fontcolor
+    )  # Optional: for angular labels
+    tick_fontsize = fontsize - 2 if fontsize is None else tick_fontsize
+    ax.tick_params(
+        axis="y", labelsize=tick_fontsize, colors=tick_fontcolor
+    )  # For radial labels
     if not circular:
-        ax.spines['polar'].set_visible(False)
-    ax.tick_params(axis='x', pad=sp) # move spines outward
-    ax.tick_params(axis='y', pad=sp) # move spines outward
+        ax.spines["polar"].set_visible(False)
+    ax.tick_params(axis="x", pad=sp)  # move spines outward
+    ax.tick_params(axis="y", pad=sp)  # move spines outward
     # colors
-    colors = get_color(data.shape[0]) if cmap is None else plt.get_cmap(cmap)(np.linspace(0, 1, data.shape[0]))
+    colors = (
+        get_color(data.shape[0])
+        if cmap is None
+        else plt.get_cmap(cmap)(np.linspace(0, 1, data.shape[0]))
+    )
     # Plot each row with straight lines
     for i, (index, row) in enumerate(data.iterrows()):
         values = row.tolist()
@@ -4070,7 +4371,7 @@ def radar(
             linewidth=linewidth,
             linestyle=linestyle,
             label=index,
-            clip_on=False
+            clip_on=False,
         )
         ax.fill(angles, values, color=colors[i], alpha=alpha)
 
@@ -4084,13 +4385,23 @@ def radar(
             marker=marker,
             markersize=size,
             markeredgecolor=edgecolor,
-            markeredgewidth = edge_linewidth, zorder=10,clip_on=False
+            markeredgewidth=edge_linewidth,
+            zorder=10,
+            clip_on=False,
         )
     # ax.tick_params(axis='y', labelleft=False, left=False)
-    if 'legend' in kws_figsets:
+    if "legend" in kws_figsets:
         figsets(ax=ax, **kws_figsets)
     else:
-        
-        figsets(ax=ax,legend=dict(loc=legend_loc,fontsize=legend_fontsize,
-                                  bbox_to_anchor=[1.1,1.4],ncols=2),**kws_figsets)
-    return ax
+
+        figsets(
+            ax=ax,
+            legend=dict(
+                loc=legend_loc,
+                fontsize=legend_fontsize,
+                bbox_to_anchor=[1.1, 1.4],
+                ncols=2,
+            ),
+            **kws_figsets,
+        )
+    return ax