py2ls 0.2.4.7__py3-none-any.whl → 0.2.4.9__py3-none-any.whl

py2ls/plot.py

@@ -1,25 +1,20 @@
-import matplotlib.pyplot as plt
 import numpy as np
-import pandas as pd
-from matplotlib.colors import to_rgba
-from scipy.stats import gaussian_kde
-import seaborn as sns
+import pandas as pd  
+import matplotlib.pyplot as plt
 import matplotlib
-import matplotlib.ticker as tck
-from cycler import cycler
+import seaborn as sns
+import warnings
 import logging
-import os
-import re
 from typing import Union
-from .ips import fsave, fload, mkdir, listdir, figsave, strcmp, unique, get_os, ssplit,flatten,plt_font
+from .ips import isa, fsave, fload, mkdir, listdir, figsave, strcmp, unique, get_os, ssplit,flatten,plt_font,run_once_within
 from .stats import *
-from .netfinder import get_soup, fetch
-
+import os
 # Suppress INFO messages from fontTools
 logging.getLogger("fontTools").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.
@@ -452,7 +447,9 @@ def catplot(data, *args, **kwargs):
     Args:
         data (array): data matrix
     """
-
+    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"]
@@ -757,6 +754,7 @@ def catplot(data, *args, **kwargs):
                         label=label[i] if label else None,
                     )
             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"])
@@ -1814,53 +1812,9 @@ def read_mplstyle(style_file):
     return style_dict
 
 
-def figsets(*args, **kwargs):
-    """
-    usage:
-        figsets(ax=axs[1],
-            ylim=[0, 10],
-            spine=2,
-            xticklabel=['wake','sleep'],
-            yticksdddd=np.arange(0,316,60),
-            labels_loc=['right','top'],
-            ticks=dict(
-            ax='x',
-            which='minor',
-            direction='out',
-            width=2,
-            length=2,
-            c_tick='m',
-            pad=5,
-            label_size=11),
-            grid=dict(which='minor',
-                    ax='x',
-                    alpha=.4,
-                    c='b',
-                    ls='-.',
-                    lw=0.75,
-                    ),
-            supertitleddddd=f'sleep druations\n(min)',
-            c_spine='r',
-            minor_ticks='xy',
-            style='paper',
-            box=['right','bottom'],
-            xrot=-45,
-            yangle=20,
-            font_sz = 12,
-            legend=dict(labels=['group_a','group_b'],
-                        loc='upper left',
-                        edgecolor='k',
-                        facecolor='r',
-                        title='title',
-                        fancybox=1,
-                        shadow=1,
-                        ncols=4,
-                        bbox_to_anchor=[-0.5,0.7],
-                        alignment='left')
-        )
-    """
+def figsets(*args, **kwargs): 
     import matplotlib
-
+    from cycler import cycler
     matplotlib.rc("text", usetex=False)
 
     fig = plt.gcf()
@@ -1897,7 +1851,16 @@ 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})
+            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)
             for label in ax.get_xticklabels() + ax.get_yticklabels():
@@ -2146,6 +2109,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():
@@ -2255,24 +2219,77 @@ def figsets(*args, **kwargs):
                 key = args[ip * 2].lower()
                 value = args[ip * 2 + 1]
                 set_step_2(ax, key, value)
-    colors = [
-        "#474747",
-        "#FF2C00",
-        "#0C5DA5",
-        "#845B97",
-        "#58BBCC",
-        "#FF9500",
-        "#D57DBE",
-    ]
+
+    colors = get_color(8)
     matplotlib.rcParams["axes.prop_cycle"] = cycler(color=colors)
     if len(fig.get_axes()) > 1:
         plt.tight_layout()
-        plt.gcf().align_labels()
 
+def split_legend(ax, n=2, loc=None, title=None, bbox=None,ncol=1, **kwargs):
+    """
+    split_legend(
+        ax,
+        n=2,
+        loc=["upper left", "lower right"],
+        labelcolor="k",
+        fontsize=6,
+    )
+    """
+    # 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 
+    # Create a list to hold each legend object
+    legends = []
+
+    # Default locations and titles if not specified
+    if loc is None:
+        loc = ['best'] * n
+    if title is None:
+        title = [None] * n
+    if bbox is None:
+        bbox = [None] * n
+
+    # Loop to create each split legend
+    for i in range(n):
+        # 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
 
-from cycler import cycler
-
+        # Subset handles and labels
+        part_handles = handles[start_idx:end_idx]
+        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)
+        
+        # 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
+        legends.append(legend)
+    return legends
 
+def get_colors(
+    n: int = 1,
+    cmap: str = "auto",
+    by: str = "start",
+    alpha: float = 1.0,
+    output: str = "hue",
+    *args,
+    **kwargs,
+):
+    return get_color(n,cmap,alpha,output,*args,**kwargs)
 def get_color(
     n: int = 1,
     cmap: str = "auto",
@@ -2282,6 +2299,7 @@ def get_color(
     *args,
     **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)]
@@ -2329,61 +2347,86 @@ 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']
+    # 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"]
     if cmap == "gray":
         cmap = "grey"
+    elif cmap=="20":
+        cmap=cmap_20
+    elif cmap=="28":
+        cmap=cmap_28
     # Determine color list based on cmap parameter
-    if "aut" in cmap:
-        if n == 1:
-            colorlist = ["#3A4453"]
-        elif n == 2:
-            colorlist = ["#3A4453", "#FBAF63"]
-        elif n == 3:
-            colorlist = ["#3A4453", "#FBAF63", "#299D8F"]
-        elif n == 4:
-            colorlist = ["#087cf7", "#FBAF63",  "#3C898A","#FF2C00"]
-        elif n == 5:
-            colorlist = ["#459AA9", "#B25E9D", "#4B8C3B","#EF8632","#FF2C00"]
-        elif n == 6:
-            colorlist = ["#459AA9", "#B25E9D", "#4B8C3B","#EF8632", "#24578E","#FF2C00"]
-        elif n==7:
-            colorlist = [ "#7F7F7F", "#459AA9", "#B25E9D", "#4B8C3B","#EF8632", "#24578E" "#FF2C00"] 
-        else:
-            colorlist = ['#FF7F0E','#2CA02C','#D62728','#9467BD','#E377C2','#7F7F7F','#7BB8CC','#06daf2']
-        
-        by = "start"
-    elif any(["cub" in cmap.lower(), "sns" in cmap.lower()]):
-        if kwargs:
-            colorlist = sns.cubehelix_palette(n, **kwargs)
-        else:
-            colorlist = sns.cubehelix_palette(
-                n, start=0.5, rot=-0.75, light=0.85, dark=0.15, as_cmap=False
+    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"]
+            elif n == 4:
+                colorlist = ["#FF2C00","#087cf7", "#FBAF63", "#3C898A"]
+            elif n == 5:
+                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 = ['#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 
+            else:
+                colorlist = cmap_28
+            by = "start"
+        elif any(["cub" in cmap.lower(), "sns" in cmap.lower()]):
+            if kwargs:
+                colorlist = sns.cubehelix_palette(n, **kwargs)
+            else:
+                colorlist = sns.cubehelix_palette(
+                    n, start=0.5, rot=-0.75, light=0.85, dark=0.15, as_cmap=False
+                )
+            colorlist = [matplotlib.colors.rgb2hex(color) for color in colorlist]
+        elif any(["hls" in cmap.lower(), "hsl" in cmap.lower()]):
+            if kwargs:
+                colorlist = sns.hls_palette(n, **kwargs)
+            else:
+                colorlist = sns.hls_palette(n)
+            colorlist = [matplotlib.colors.rgb2hex(color) for color in colorlist]
+        elif any(["col" in cmap.lower(), "pal" in cmap.lower()]):
+            palette, desat, as_cmap = None, None, False
+            if kwargs:
+                for k, v in kwargs.items():
+                    if "p" in k:
+                        palette = v
+                    elif "d" in k:
+                        desat = v
+                    elif "a" in k:
+                        as_cmap = v
+            colorlist = sns.color_palette(
+                palette=palette, n_colors=n, desat=desat, as_cmap=as_cmap
             )
-        colorlist = [matplotlib.colors.rgb2hex(color) for color in colorlist]
-    elif any(["hls" in cmap.lower(), "hsl" in cmap.lower()]):
-        if kwargs:
-            colorlist = sns.hls_palette(n, **kwargs)
+            colorlist = [matplotlib.colors.rgb2hex(color) for color in colorlist]
         else:
-            colorlist = sns.hls_palette(n)
-        colorlist = [matplotlib.colors.rgb2hex(color) for color in colorlist]
-    elif any(["col" in cmap.lower(), "pal" in cmap.lower()]):
-        palette, desat, as_cmap = None, None, False
-        if kwargs:
-            for k, v in kwargs.items():
-                if "p" in k:
-                    palette = v
-                elif "d" in k:
-                    desat = v
-                elif "a" in k:
-                    as_cmap = v
-        colorlist = sns.color_palette(
-            palette=palette, n_colors=n, desat=desat, as_cmap=as_cmap
-        )
-        colorlist = [matplotlib.colors.rgb2hex(color) for color in colorlist]
-    else:
-        if by == "start":
-            by = "linspace"
-        colorlist = cmap2hex(cmap)
+            if by == "start":
+                by = "linspace"
+            colorlist = cmap2hex(cmap)
+    elif isinstance(cmap, list):
+        colorlist=cmap
 
     # Determine method for generating color list
     if "st" in by.lower() or "be" in by.lower():
@@ -2403,35 +2446,15 @@ def get_color(
         return hue_list
     else:
         raise ValueError("Invalid output type. Choose 'rgb' or 'hue'.")
-
-    # # Example usage
-    # colors = get_color(n=5, cmap="viridis", by="linear", alpha=0.5,output='rgb')
-    # print(colors)
-
-
-""" 
-    # n = 7
-    # clist = get_color(n, cmap="auto", by="linspace")  # get_color(100)
-    # plt.figure(figsize=[8, 5], dpi=100)
-    # x = np.linspace(0, 2 * np.pi, 50) * 100
-    # y = np.sin(x)
-    # for i in range(1, n + 1):
-    #     plt.plot(x, y + i, c=clist[i - 1], lw=5, label=str(i))
-    # plt.legend()
-    # plt.ylim(-2, 20)
-    # figsets(plt.gca(), {"style": "whitegrid"}) """
-
-
-from scipy.signal import savgol_filter
-import numpy as np
-import matplotlib.pyplot as plt
-
+ 
 
 def stdshade(ax=None, *args, **kwargs):
     """
     usage:
     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", {})
@@ -2937,6 +2960,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
@@ -2963,7 +2987,7 @@ def plotxy(
     x=None,
     y=None,
     ax=None,
-    kind: Union[str, list] = None,  # Specify the kind of plot
+    kind: Union[str, list] = 'scatter',  # Specify the kind of plot
     verbose=False,
     **kwargs,
 ):
@@ -2986,34 +3010,30 @@ def plotxy(
     """
     # Check for valid plot kind
     # Default arguments for various plot types
-    default_settings = fload(
-        "/Users/macjianfeng/Dropbox/github/python/py2ls/py2ls/data/usages_sns.json"
-    )
-    sns_info = pd.DataFrame(
-        fload(
-            "/Users/macjianfeng/Dropbox/github/python/py2ls/py2ls/data/sns_info.json",
-        )
-    )
+    from pathlib import Path
+    # Get the current script's directory as a Path object
+    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'))
+ 
     valid_kinds = list(default_settings.keys())
-    print(valid_kinds)
+    # print(valid_kinds)
     if kind is not None:
         if isinstance(kind, str):
             kind = [kind]
         kind = [strcmp(i, valid_kinds)[0] for i in kind]
     else:
         verbose = True
+
     if verbose:
         if kind is not None:
             for k in kind:
                 if k in valid_kinds:
-                    print(f"{k}:\n\t{default_settings[k]}")
-                    print(
-                        sns_info[sns_info["Functions"].str.contains(k)]
-                        .iloc[:, -1]
-                        .tolist()[0]
-                    )
-                    print()
-        usage_str = """plot_xy(data=ranked_genes,
+                    print(f"{k}:\n\t{default_settings[k]}") 
+        usage_str = """plotxy(data=ranked_genes,
         x="log2(fold_change)",
         y="-log10(p-value)",
         palette=get_color(3, cmap="coolwarm"),
@@ -3037,24 +3057,15 @@ def plotxy(
             kws_add_text = v_arg
             kwargs.pop(k_arg, None)
             break
-
+    zorder=0
     for k in kind:
+        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)
@@ -3073,7 +3084,6 @@ def plotxy(
         # (2) return axis
         if ax is None:
             ax = plt.gca()
-
         if k == "catplot":
             kws_cat = kwargs.pop("kws_cat", kwargs)
             g = catplot(data=data, x=x, y=y, ax=ax, **kws_cat)
@@ -3082,88 +3092,85 @@ 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_")}
             hue = kwargs.pop("hue", None)
-            palette = kws_scatter.pop(
-                "palette",
-                (
-                    sns.color_palette("tab20", data[hue].nunique())
-                    if hue is not None
-                    else sns.color_palette("tab20")
-                ),
-            )
+            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)
             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,
-                **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)
-            ax = sns.histplot(data=data, x=x, ax=ax, **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)
-            ax = sns.kdeplot(data=data, x=x, ax=ax, **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)
-            ax = sns.ecdfplot(data=data, x=x, ax=ax, **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)
-            print(kws_rug)
-            ax = sns.rugplot(data=data, x=x, ax=ax, **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_")}
             dodge = kws_strip.pop("dodge", True)
-            ax = sns.stripplot(data=data, x=x, y=y, ax=ax, 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)
-            ax = sns.swarmplot(data=data, x=x, y=y, ax=ax, **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)
-            ax = sns.boxplot(data=data, x=x, y=y, ax=ax, **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)
-            ax = sns.violinplot(data=data, x=x, y=y, ax=ax, **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)
-            ax = sns.boxenplot(data=data, x=x, y=y, ax=ax, **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)
-            ax = sns.pointplot(data=data, x=x, y=y, ax=ax, **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)
-            ax = sns.barplot(data=data, x=x, y=y, ax=ax, **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, **kws_count)
+            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)
-            ax = sns.regplot(data=data, x=x, y=y, ax=ax, **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)
-            ax = sns.residplot(data=data, x=x, y=y, lowess=True, 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)
-            ax = sns.lineplot(ax=ax, data=data, x=x, y=y, **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)
-        print(kws_add_text)
-        add_text(ax=ax, **kws_add_text) if kws_add_text else None
-        print(k, " ⤵ ")
-        print(default_settings[k])
-        print(
-            "=>\t",
-            sns_info[sns_info["Functions"].str.contains(k)].iloc[:, -1].tolist()[0],
-        )
-        print()
+        if kws_add_text:
+            add_text(ax=ax, **kws_add_text) if kws_add_text else None
+        if run_once_within(60):
+            print(f"\n{k}⤵ ")
+            print(default_settings[k])
+            # print("=>\t",sns_info[sns_info["Functions"].str.contains(k)].iloc[:, -1].tolist()[0],"\n")
     if "g" in locals():
         if ax is not None:
             return g, ax
@@ -3815,4 +3822,275 @@ def venn(
             patch.set_alpha(alpha)
             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):
+    """
+    nexttile = subplot(
+        8,
+        2,
+        figsize=(8, 9),
+        sharey=True,
+        sharex=True,
+    )
+
+    for i in range(8):
+        ax = nexttile()
+        x = np.linspace(0, 10, 100) + i
+        ax.plot(x, np.sin(x + i) + i, label=f"Plot {i + 1}")
+        ax.legend()
+        ax.set_title(f"Tile {i + 1}")
+        ax.set_ylabel(f"Tile {i + 1}")
+        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()")
+    fig = plt.figure(figsize=figsize)
+    grid_spec = GridSpec(rows, cols, figure=fig)
+    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)
+
+    def expand_ax():
+        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 
+        for row in range(rows):
+            for col in range(cols):
+                if all(
+                    (row + r, col + c) not in occupied
+                    for r in range(rowspan)
+                    for c in range(colspan)
+                ):
+                    break
+            else:
+                continue 
+            break
+        else: 
+            expand_ax()
+            return nexttile(rowspan=rowspan, colspan=colspan, **kwargs)
+
+        sharex_ax,sharey_ax = None, None
+
+        if sharex: 
+            sharex_ax = col_first_axes[col]
+
+        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
+        ) 
+        if row_first_axes[row] is None:
+            row_first_axes[row] = ax
+        if col_first_axes[col] is None:
+            col_first_axes[col] = ax 
+        for r in range(row, row + rowspan):
+            for c in range(col, col + colspan):
+                occupied.add((r, c))
+
+        return ax
+
+    return nexttile
+
+
+#! radar chart
+def radar(
+    data: pd.DataFrame, 
+    ylim=(0,100),
+    color=get_color(5),
+    fontsize=10,
+    fontcolor='k',
+    size=6,
+    linewidth=1,
+    linestyle="-",
+    alpha=0.5,
+    marker="o",
+    edgecolor='none',
+    edge_linewidth=0,
+    bg_color="0.8",
+    bg_alpha=None,
+    grid_interval_ratio=0.2,
+    title="Radar Chart",
+    cmap=None,
+    legend_loc="upper right",
+    legend_fontsize=10,
+    grid_color="gray",
+    grid_alpha=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,
+    ax=None,
+    sp=2,
+    **kwargs
+):
+    """
+    Example DATA: 
+        df = pd.DataFrame(
+        data=[
+            [80, 80, 80, 80, 80, 80, 80],
+            [90, 20, 95, 95, 30, 30, 80],
+            [60, 90, 20, 20, 100, 90, 50],
+        ],
+        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).
+        - color: The color(s) for the plot. Can be a single color or a list of colors.
+        - fontsize (int): Font size for the angular labels (x-axis).
+        - fontcolor (str): Color for the angular labels.
+        - size (int): The size of the markers for each data point.
+        - linewidth (int): Line width for the plot lines.
+        - linestyle (str): Line style for the plot lines.
+        - alpha (float): The transparency level for the filled area.
+        - marker (str): The marker style for the data points.
+        - edgecolor (str): The color for the marker edges.
+        - edge_linewidth (int): Line width for the marker edges.
+        - bg_color (str): Background color for the radar chart.
+        - grid_interval_ratio (float): Determines the intervals for the grid lines as a fraction of the y-limit.
+        - title (str): The title of the radar chart.
+        - cmap (str): The colormap to use if `color` is a list.
+        - legend_loc (str): The location of the legend.
+        - legend_fontsize (int): Font size for the legend.
+        - grid_color (str): Color for the grid lines.
+        - grid_alpha (float): Transparency of the grid lines.
+        - grid_linestyle (str): Style of the grid lines.
+        - grid_linewidth (int): Line width of the grid lines.
+        - circular (bool): If True, use circular grid lines. If False, use spider-style grid lines (straight lines).
+        - tick_fontsize (int): Font size for the radial (y-axis) labels.
+        - tick_fontcolor (str): Font color for the radial (y-axis) labels.
+        - tick_loc (float or None): The location of the radial tick labels (between 0 and 1). If None, it is automatically calculated.
+        - turning (float or None): Rotation of the radar chart. If None, it is not applied.
+        - ax (matplotlib.axes.Axes or None): The axis on which to plot the radar chart. If None, a new axis will be created.
+        - sp (int): Padding for the ticks from the plot area.
+        - **kwargs: Additional arguments for customization.
+    """
+    if circular:
+        from matplotlib.colors import to_rgba
+    kws_figsets = {}
+    for k_arg, v_arg in kwargs.items():
+        if "figset" in k_arg:
+            kws_figsets = v_arg
+            kwargs.pop(k_arg, None)
+            break
+    categories = list(data.columns)
+    num_vars = len(categories)
+
+    # Set up angle for each category on radar chart
+    angles = np.linspace(0, 2 * np.pi, num_vars, endpoint=False).tolist()
+    angles += angles[:1]  # Complete the loop to ensure straight-line connections
+
+    # If no axis is provided, create a new one
+    if ax is None:
+        fig, ax = plt.subplots(figsize=(6, 6), subplot_kw=dict(polar=True))
+
+    # 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')
+    # Set up the radar chart with straight-line connections
+    ax.set_theta_offset(np.pi / 2)
+    ax.set_theta_direction(-1)
+
+    # Draw one axis per variable and add labels
+    ax.set_xticks(angles[:-1])
+    ax.set_xticklabels(categories)
+
+    # 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) 
+        ax.spines["polar"].set_linewidth(grid_linewidth)
+        ax.spines["polar"].set_linestyle('-')
+        ax.spines["polar"].set_alpha(grid_alpha)
+        ax.spines["polar"].set_capstyle('round')
+        ax.spines["polar"].set_joinstyle('round')
+
+    else:
+        #* 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): 
+            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
+            )
+        # 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
+
+    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
+    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
+    # colors
+    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()
+        values += values[:1]  # Close the loop
+        ax.plot(
+            angles,
+            values,
+            color=colors[i],
+            linewidth=linewidth,
+            linestyle=linestyle,
+            label=index,
+            clip_on=False
+        )
+        ax.fill(angles, values, color=colors[i], alpha=alpha)
+
+    ax.set_ylim(ylim)
+    # Add markers for each data point
+    for i, row in enumerate(data.values):
+        ax.plot(
+            angles,
+            list(row) + [row[0]],  # Close the loop for markers
+            color=colors[i],
+            marker=marker,
+            markersize=size,
+            markeredgecolor=edgecolor,
+            markeredgewidth = edge_linewidth, zorder=10,clip_on=False
+        )
+    # ax.tick_params(axis='y', labelleft=False, left=False)
+    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