py2ls 0.2.4.32__py3-none-any.whl → 0.2.4.33__py3-none-any.whl

py2ls/plot.py

@@ -22,7 +22,7 @@ from .ips import (
     run_once_within,
     get_df_format,
     df_corr,
-    df_scaler
+    df_scaler,
 )
 import scipy.stats as scipy_stats
 from .stats import *
@@ -144,6 +144,7 @@ def add_text(ax=None, height_offset=0.5, fmt=".1f", **kwargs):
                         **kwargs,
                     )
 
+
 def pval2str(p):
     if p > 0.05:
         txt = ""
@@ -155,16 +156,17 @@ def pval2str(p):
         txt = "***"
     return txt
 
+
 def heatmap(
     data,
     ax=None,
     kind="corr",  #'corr','direct','pivot'
-    method="pearson",# for correlation: ‘pearson’(default), ‘kendall’, ‘spearman’
+    method="pearson",  # for correlation: ‘pearson’(default), ‘kendall’, ‘spearman’
     columns="all",  # pivot, default: coll numeric columns
-    style=0,# for correlation
+    style=0,  # for correlation
     index=None,  # pivot
     values=None,  # pivot
-    fontsize=10, 
+    fontsize=10,
     tri="u",
     mask=True,
     k=1,
@@ -174,7 +176,7 @@ def heatmap(
     annot=True,
     cmap="coolwarm",
     fmt=".2f",
-    show_indicator = True,# only for style==1
+    show_indicator=True,  # only for style==1
     cluster=False,
     inplace=False,
     figsize=(10, 8),
@@ -309,7 +311,7 @@ def heatmap(
                 df_col_cluster,
             )
         else:
-            if style==0:
+            if style == 0:
                 # Create a standard heatmap
                 ax = sns.heatmap(
                     data4heatmap,
@@ -321,7 +323,7 @@ def heatmap(
                     **kwargs,  # Pass any additional arguments to sns.heatmap
                 )
                 return ax
-            elif style==1:
+            elif style == 1:
                 if isinstance(cmap, str):
                     cmap = plt.get_cmap(cmap)
                 norm = plt.Normalize(vmin=-1, vmax=1)
@@ -332,12 +334,17 @@ def heatmap(
                 # 循环绘制气泡图和数值
                 for i in range(len(r_.columns)):
                     for j in range(len(r_.columns)):
-                        if (i < j) if "u" in tri.lower() else (j<i):  # 对角线左上部只显示气泡
+                        if (
+                            (i < j) if "u" in tri.lower() else (j < i)
+                        ):  # 对角线左上部只显示气泡
                             color = cmap(norm(r_.iloc[i, j]))  # 根据相关系数获取颜色
                             scatter = ax.scatter(
-                                i, j, s=np.abs(r_.iloc[i, j])*size_scale, color=color, 
+                                i,
+                                j,
+                                s=np.abs(r_.iloc[i, j]) * size_scale,
+                                color=color,
                                 # alpha=1,edgecolor=edgecolor,linewidth=linewidth,
-                                **kwargs
+                                **kwargs,
                             )
                             scatter_handles.append(scatter)  # 保存scatter对象用于颜色条
                             # add *** indicators
@@ -351,8 +358,12 @@ def heatmap(
                                     color="k",
                                     fontsize=fontsize * 1.3,
                                 )
-                        elif (i > j) if "u" in tri.lower() else (j>i):  # 对角只显示数值
-                            color = cmap(norm(r_.iloc[i, j]))  # 数值的颜色同样基于相关系数
+                        elif (
+                            (i > j) if "u" in tri.lower() else (j > i)
+                        ):  # 对角只显示数值
+                            color = cmap(
+                                norm(r_.iloc[i, j])
+                            )  # 数值的颜色同样基于相关系数
                             ax.text(
                                 i,
                                 j,
@@ -365,15 +376,16 @@ def heatmap(
                         else:  # 对角线部分，显示空白
                             ax.scatter(i, j, s=1, color="white")
                 # 设置坐标轴标签
-                figsets(xticks=range(len(r_.columns)),
-                        xticklabels=r_.columns, 
-                        xangle=90,
-                        fontsize=fontsize,
-                        yticks=range(len(r_.columns)),
-                        yticklabels=r_.columns,
-                        xlim=[-0.5,len(r_.columns)-0.5],
-                        ylim=[-0.5,len(r_.columns)-0.5]
-                        ) 
+                figsets(
+                    xticks=range(len(r_.columns)),
+                    xticklabels=r_.columns,
+                    xangle=90,
+                    fontsize=fontsize,
+                    yticks=range(len(r_.columns)),
+                    yticklabels=r_.columns,
+                    xlim=[-0.5, len(r_.columns) - 0.5],
+                    ylim=[-0.5, len(r_.columns) - 0.5],
+                )
                 # 添加颜色条
                 sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
                 sm.set_array([])  # 仅用于显示颜色条
@@ -468,7 +480,7 @@ def heatmap(
         )
     else:
         # Create a standard heatmap
-        if style==0:
+        if style == 0:
             ax = sns.heatmap(
                 data4heatmap,
                 ax=ax,
@@ -478,42 +490,51 @@ def heatmap(
                 **kwargs,  # Pass any additional arguments to sns.heatmap
             )
             # Return the Axes object for further customization if needed
-            return ax            
-        elif style==1:
+            return ax
+        elif style == 1:
             if isinstance(cmap, str):
                 cmap = plt.get_cmap(cmap)
             if vmin is None:
-                vmin=np.min(data4heatmap)
+                vmin = np.min(data4heatmap)
             if vmax is None:
-                vmax=np.max(data4heatmap)
+                vmax = np.max(data4heatmap)
             norm = plt.Normalize(vmin=vmin, vmax=vmax)
 
             # 初始化一个空的可绘制对象用于颜色条
             scatter_handles = []
-            # 循环绘制气泡图和数值 
-            print(len(data4heatmap.index),len(data4heatmap.columns))
+            # 循环绘制气泡图和数值
+            print(len(data4heatmap.index), len(data4heatmap.columns))
             for i in range(len(data4heatmap.index)):
                 for j in range(len(data4heatmap.columns)):
                     color = cmap(norm(data4heatmap.iloc[i, j]))  # 根据相关系数获取颜色
-                    scatter = ax.scatter(j,i, s=np.abs(data4heatmap.iloc[i, j])*size_scale, color=color, **kwargs)
+                    scatter = ax.scatter(
+                        j,
+                        i,
+                        s=np.abs(data4heatmap.iloc[i, j]) * size_scale,
+                        color=color,
+                        **kwargs,
+                    )
                     scatter_handles.append(scatter)  # 保存scatter对象用于颜色条
 
             # 设置坐标轴标签
-            figsets(xticks=range(len(data4heatmap.columns)),
-                    xticklabels=data4heatmap.columns, 
-                    xangle=90,
-                    fontsize=fontsize,
-                    yticks=range(len(data4heatmap.index)),
-                    yticklabels=data4heatmap.index,
-                    xlim=[-0.5,len(data4heatmap.columns)-0.5],
-                    ylim=[-0.5,len(data4heatmap.index)-0.5]
-                    ) 
+            figsets(
+                xticks=range(len(data4heatmap.columns)),
+                xticklabels=data4heatmap.columns,
+                xangle=90,
+                fontsize=fontsize,
+                yticks=range(len(data4heatmap.index)),
+                yticklabels=data4heatmap.index,
+                xlim=[-0.5, len(data4heatmap.columns) - 0.5],
+                ylim=[-0.5, len(data4heatmap.index) - 0.5],
+            )
             # 添加颜色条
             sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
             sm.set_array([])  # 仅用于显示颜色条
-            plt.colorbar(sm, ax=ax, 
-                        #  label="Correlation Coefficient"
-                         )
+            plt.colorbar(
+                sm,
+                ax=ax,
+                #  label="Correlation Coefficient"
+            )
             return ax
 
 
@@ -854,9 +875,11 @@ def catplot(data, *args, **kwargs):
         else:
             bx_opt["EdgeColor"] = bx_opt["EdgeColor"]
         if not isinstance(bx_opt["FaceColor"], list):
-            bx_opt["FaceColor"]=[bx_opt["FaceColor"]]
-        if len(bxp["boxes"])!= len(bx_opt["FaceColor"]) and (len(bx_opt["FaceColor"])==1):
-            bx_opt["FaceColor"]=bx_opt["FaceColor"] *len(bxp["boxes"]) 
+            bx_opt["FaceColor"] = [bx_opt["FaceColor"]]
+        if len(bxp["boxes"]) != len(bx_opt["FaceColor"]) and (
+            len(bx_opt["FaceColor"]) == 1
+        ):
+            bx_opt["FaceColor"] = bx_opt["FaceColor"] * len(bxp["boxes"])
         for patch, color in zip(bxp["boxes"], bx_opt["FaceColor"]):
             patch.set_facecolor(to_rgba(color, bx_opt["FaceAlpha"]))
 
@@ -2439,7 +2462,15 @@ def split_legend(ax, n=2, loc=None, title=None, bbox=None, ncol=1, **kwargs):
     return legends
 
 
-def get_colors(n: int = 1,cmap: str = "auto",by: str = "start",alpha: float = 1.0,output: str = "hue",*args,**kwargs):
+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=n, cmap=cmap, alpha=alpha, output=output, *args, **kwargs)
 
 
@@ -3317,9 +3348,9 @@ def plotxy(
     for k in kind_:
         # preprocess data
         try:
-            data=df_preprocessing_(data, kind=k)
-            if 'variable' in data.columns and 'value' in data.columns:
-                x,y='variable','value' 
+            data = df_preprocessing_(data, kind=k)
+            if "variable" in data.columns and "value" in data.columns:
+                x, y = "variable", "value"
         except Exception as e:
             print(e)
         zorder += 1
@@ -3342,28 +3373,31 @@ def plotxy(
         # (1) return FcetGrid
         if k == "jointplot":
             kws_joint = kwargs.pop("kws_joint", kwargs)
-            kws_joint = {
-                k: v for k, v in kws_joint.items() if not k.startswith("kws_")
-            }
+            kws_joint = {k: v for k, v in kws_joint.items() if not k.startswith("kws_")}
             hue = kwargs.get("hue", None)
-            if isinstance(kws_joint, dict) or hue is None:  # Check if kws_ellipse is a dictionary
+            if (
+                isinstance(kws_joint, dict) or hue is None
+            ):  # Check if kws_ellipse is a dictionary
                 kws_joint.pop("hue", None)  # Safely remove 'hue' if it exists
 
             palette = kwargs.get("palette", None)
             if palette is None:
                 palette = kws_joint.pop(
-                    "palette", get_color(data[hue].nunique()) if hue is not None else None
+                    "palette",
+                    get_color(data[hue].nunique()) if hue is not None else None,
                 )
             else:
                 kws_joint.pop("palette", palette)
-            stats=kwargs.pop("stats",None)
+            stats = kwargs.pop("stats", None)
             if stats:
-                stats=kws_joint.pop("stats",True)
+                stats = kws_joint.pop("stats", True)
             if stats:
                 r, p_value = scipy_stats.pearsonr(data[x], data[y])
-            for key in ["palette", "alpha", "hue","stats"]:
-                kws_joint.pop(key, None) 
-            g = sns.jointplot(data=data, x=x, y=y,hue=hue,palette=palette, **kws_joint)
+            for key in ["palette", "alpha", "hue", "stats"]:
+                kws_joint.pop(key, None)
+            g = sns.jointplot(
+                data=data, x=x, y=y, hue=hue, palette=palette, **kws_joint
+            )
             if stats:
                 g.ax_joint.annotate(
                     f"pearsonr = {r:.2f} p = {p_value:.3f}",
@@ -3391,41 +3425,64 @@ def plotxy(
                 # If no hue, col, or row, calculate stats for the entire dataset
                 if all([hue is None, col is None, row is None]):
                     r, p_value = scipy_stats.pearsonr(data[x], data[y])
-                    stats_per_facet[(None, None)] = (r, p_value)  # Store stats for the entire dataset
+                    stats_per_facet[(None, None)] = (
+                        r,
+                        p_value,
+                    )  # Store stats for the entire dataset
 
-                else: 
+                else:
                     if hue is None and (col is not None or row is not None):
                         for ax in g.axes.flat:
                             facet_name = ax.get_title()
-                            if '=' in facet_name:
+                            if "=" in facet_name:
                                 # Assume facet_name is like 'Column = Value'
-                                facet_column_name = facet_name.split('=')[0].strip()  # Column name before '='
-                                facet_value_str = facet_name.split('=')[1].strip()  # Facet value after '='
-                                
+                                facet_column_name = facet_name.split("=")[
+                                    0
+                                ].strip()  # Column name before '='
+                                facet_value_str = facet_name.split("=")[
+                                    1
+                                ].strip()  # Facet value after '='
+
                                 # Try converting facet_value to match the data type of the DataFrame column
                                 facet_column_dtype = data[facet_column_name].dtype
-                                if facet_column_dtype == 'int' or facet_column_dtype == 'float':
-                                    facet_value = pd.to_numeric(facet_value_str, errors='coerce')  # Convert to numeric
+                                if (
+                                    facet_column_dtype == "int"
+                                    or facet_column_dtype == "float"
+                                ):
+                                    facet_value = pd.to_numeric(
+                                        facet_value_str, errors="coerce"
+                                    )  # Convert to numeric
                                 else:
                                     facet_value = facet_value_str  # Treat as a string if not numeric
                             else:
-                                facet_column_name = facet_name.split('=')[0].strip()  # Column name before '='
-                                facet_value=facet_name.split('=')[1].strip() 
+                                facet_column_name = facet_name.split("=")[
+                                    0
+                                ].strip()  # Column name before '='
+                                facet_value = facet_name.split("=")[1].strip()
                             facet_data = data[data[facet_column_name] == facet_value]
                             if not facet_data.empty:
-                                r, p_value = scipy_stats.pearsonr(facet_data[x], facet_data[y])
+                                r, p_value = scipy_stats.pearsonr(
+                                    facet_data[x], facet_data[y]
+                                )
                                 stats_per_facet[facet_name] = (r, p_value)
                             else:
-                                stats_per_facet[facet_name] = (None, None)  # Handle empty facets
+                                stats_per_facet[facet_name] = (
+                                    None,
+                                    None,
+                                )  # Handle empty facets
 
             # Annotate the stats on the plot
             for ax in g.axes.flat:
                 if stats:
                     # Adjust the position for each facet to avoid overlap
-                    idx=1
-                    shift_factor = 0.02 * idx  # Adjust this factor as needed to prevent overlap
-                    y_position = 0.98 - shift_factor  # Dynamic vertical shift for each facet
-                    
+                    idx = 1
+                    shift_factor = (
+                        0.02 * idx
+                    )  # Adjust this factor as needed to prevent overlap
+                    y_position = (
+                        0.98 - shift_factor
+                    )  # Dynamic vertical shift for each facet
+
                     if all([hue is None, col is None, row is None]):
                         # Use stats for the entire dataset if no hue, col, or row
                         r, p_value = stats_per_facet.get((None, None), (None, None))
@@ -3448,15 +3505,21 @@ def plotxy(
                                 ha="center",
                             )
                     elif hue is not None:
-                        if (col is None and row is None): 
-                            hue_categories = sorted(flatten(data[hue],verbose=0))
-                            idx=1
+                        if col is None and row is None:
+                            hue_categories = sorted(flatten(data[hue], verbose=0))
+                            idx = 1
                             for category in hue_categories:
                                 subset_data = data[data[hue] == category]
-                                r, p_value = scipy_stats.pearsonr(subset_data[x], subset_data[y])
+                                r, p_value = scipy_stats.pearsonr(
+                                    subset_data[x], subset_data[y]
+                                )
                                 stats_per_hue[category] = (r, p_value)
-                                shift_factor = 0.05 * idx  # Adjust this factor as needed to prevent overlap
-                                y_position = 0.98 - shift_factor  # Dynamic vertical shift for each facet
+                                shift_factor = (
+                                    0.05 * idx
+                                )  # Adjust this factor as needed to prevent overlap
+                                y_position = (
+                                    0.98 - shift_factor
+                                )  # Dynamic vertical shift for each facet
                                 ax.annotate(
                                     f"{category}: pearsonr = {r:.2f} p = {p_value:.3f}",
                                     xy=(0.6, y_position),
@@ -3465,31 +3528,49 @@ def plotxy(
                                     color="black",
                                     ha="center",
                                 )
-                                idx+=1
+                                idx += 1
                         else:
                             for ax in g.axes.flat:
                                 facet_name = ax.get_title()
-                                if '=' in facet_name:
+                                if "=" in facet_name:
                                     # Assume facet_name is like 'Column = Value'
-                                    facet_column_name = facet_name.split('=')[0].strip()  # Column name before '='
-                                    facet_value_str = facet_name.split('=')[1].strip()  # Facet value after '='
-                                    
+                                    facet_column_name = facet_name.split("=")[
+                                        0
+                                    ].strip()  # Column name before '='
+                                    facet_value_str = facet_name.split("=")[
+                                        1
+                                    ].strip()  # Facet value after '='
+
                                     # Try converting facet_value to match the data type of the DataFrame column
                                     facet_column_dtype = data[facet_column_name].dtype
-                                    if facet_column_dtype == 'int' or facet_column_dtype == 'float':
-                                        facet_value = pd.to_numeric(facet_value_str, errors='coerce')  # Convert to numeric
+                                    if (
+                                        facet_column_dtype == "int"
+                                        or facet_column_dtype == "float"
+                                    ):
+                                        facet_value = pd.to_numeric(
+                                            facet_value_str, errors="coerce"
+                                        )  # Convert to numeric
                                     else:
                                         facet_value = facet_value_str  # Treat as a string if not numeric
                                 else:
-                                    facet_column_name = facet_name.split('=')[0].strip()  # Column name before '='
-                                    facet_value=facet_name.split('=')[1].strip() 
-                                facet_data = data[data[facet_column_name] == facet_value]
+                                    facet_column_name = facet_name.split("=")[
+                                        0
+                                    ].strip()  # Column name before '='
+                                    facet_value = facet_name.split("=")[1].strip()
+                                facet_data = data[
+                                    data[facet_column_name] == facet_value
+                                ]
                                 if not facet_data.empty:
-                                    r, p_value = scipy_stats.pearsonr(facet_data[x], facet_data[y])
+                                    r, p_value = scipy_stats.pearsonr(
+                                        facet_data[x], facet_data[y]
+                                    )
                                     stats_per_facet[facet_name] = (r, p_value)
                                 else:
-                                    stats_per_facet[facet_name] = (None, None)  # Handle empty facets
- 
+                                    stats_per_facet[facet_name] = (
+                                        None,
+                                        None,
+                                    )  # Handle empty facets
+
                                 ax.annotate(
                                     f"pearsonr = {r:.2f} p = {p_value:.3f}",
                                     xy=(0.6, y_position),
@@ -3497,7 +3578,7 @@ def plotxy(
                                     fontsize=12,
                                     color="black",
                                     ha="center",
-                                ) 
+                                )
                     elif hue is None and (col is not None or row is not None):
                         # Annotate stats for each facet
                         facet_name = ax.get_title()
@@ -3518,7 +3599,8 @@ def plotxy(
                                 xycoords="axes fraction",
                                 fontsize=12,
                                 color="black",
-                                ha="center")
+                                ha="center",
+                            )
 
         elif k == "catplot_sns":
             kws_cat = kwargs.pop("kws_cat", kwargs)
@@ -3526,7 +3608,7 @@ def plotxy(
         elif k == "displot":
             kws_dis = kwargs.pop("kws_dis", kwargs)
             # displot creates a new figure and returns a FacetGrid
-            g = sns.displot(data=data, x=x,y=y,  **kws_dis)
+            g = sns.displot(data=data, x=x, y=y, **kws_dis)
 
         # (2) return axis
         if ax is None:
@@ -3537,30 +3619,35 @@ def plotxy(
         elif k == "stdshade":
             kws_stdshade = kwargs.pop("kws_stdshade", kwargs)
             ax = stdshade(ax=ax, **kwargs)
-        elif k=="ellipse":
+        elif k == "ellipse":
             kws_ellipse = kwargs.pop("kws_ellipse", kwargs)
             kws_ellipse = {
                 k: v for k, v in kws_ellipse.items() if not k.startswith("kws_")
             }
             hue = kwargs.get("hue", None)
-            if isinstance(kws_ellipse, dict) or hue is None:  # Check if kws_ellipse is a dictionary
+            if (
+                isinstance(kws_ellipse, dict) or hue is None
+            ):  # Check if kws_ellipse is a dictionary
                 kws_ellipse.pop("hue", None)  # Safely remove 'hue' if it exists
 
             palette = kwargs.get("palette", None)
             if palette is None:
                 palette = kws_ellipse.pop(
-                    "palette", get_color(data[hue].nunique()) if hue is not None else None
+                    "palette",
+                    get_color(data[hue].nunique()) if hue is not None else None,
                 )
             alpha = kws_ellipse.pop("alpha", 0.1)
-            hue_order = kwargs.get("hue_order",None)
+            hue_order = kwargs.get("hue_order", None)
             if hue_order is None:
-                hue_order = kws_ellipse.get("hue_order",None)
-            if hue_order: 
-                data["hue"] = pd.Categorical(data[hue], categories=hue_order, ordered=True)
+                hue_order = kws_ellipse.get("hue_order", None)
+            if hue_order:
+                data["hue"] = pd.Categorical(
+                    data[hue], categories=hue_order, ordered=True
+                )
                 data = data.sort_values(by="hue")
-            for key in ["palette", "alpha", "hue","hue_order"]:
-                kws_ellipse.pop(key, None) 
-            ax=ellipse(
+            for key in ["palette", "alpha", "hue", "hue_order"]:
+                kws_ellipse.pop(key, None)
+            ax = ellipse(
                 ax=ax,
                 data=data,
                 x=x,
@@ -3579,13 +3666,14 @@ def plotxy(
             hue = kwargs.get("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.get("palette",None)
+            palette = kws_scatter.get("palette", None)
             if palette is None:
                 palette = kws_scatter.pop(
-                    "palette", get_color(data[hue].nunique()) if hue is not None else None
+                    "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)                       
+            alpha = kws_scatter.pop("alpha", 0.7)
             for key in ["s", "palette", "alpha", "hue"]:
                 kws_scatter.pop(key, None)
 
@@ -3605,28 +3693,39 @@ def plotxy(
             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, y=y, ax=ax, zorder=zorder, **kws_hist)
-        elif k == "kdeplot": 
+        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_")
-            }
+            kws_kde = {k: v for k, v in kws_kde.items() if not k.startswith("kws_")}
             hue = kwargs.get("hue", None)
-            if isinstance(kws_kde, dict) or hue is None:  # Check if kws_kde is a dictionary
+            if (
+                isinstance(kws_kde, dict) or hue is None
+            ):  # Check if kws_kde is a dictionary
                 kws_kde.pop("hue", None)  # Safely remove 'hue' if it exists
 
             palette = kwargs.get("palette", None)
             if palette is None:
                 palette = kws_kde.pop(
-                    "palette", get_color(data[hue].nunique()) if hue is not None else None
+                    "palette",
+                    get_color(data[hue].nunique()) if hue is not None else None,
                 )
             alpha = kws_kde.pop("alpha", 0.05)
             for key in ["palette", "alpha", "hue"]:
-                kws_kde.pop(key, None) 
-            ax = sns.kdeplot(data=data, x=x, y=y, palette=palette,hue=hue, ax=ax,alpha=alpha, zorder=zorder, **kws_kde)
+                kws_kde.pop(key, None)
+            ax = sns.kdeplot(
+                data=data,
+                x=x,
+                y=y,
+                palette=palette,
+                hue=hue,
+                ax=ax,
+                alpha=alpha,
+                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,y=y,  ax=ax, zorder=zorder, **kws_ecdf)
+            ax = sns.ecdfplot(data=data, x=x, y=y, 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_")}
@@ -3635,7 +3734,9 @@ def plotxy(
             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, 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_")}
@@ -3672,21 +3773,21 @@ def plotxy(
             kws_reg = kwargs.pop("kws_reg", kwargs)
             kws_reg = {k: v for k, v in kws_reg.items() if not k.startswith("kws_")}
             stats = kwargs.pop("stats", True)  # Flag to calculate stats
-    
+
             # Compute Pearson correlation if stats is True
             if stats:
                 r, p_value = scipy_stats.pearsonr(data[x], data[y])
-            ax = sns.regplot(data=data, x=x, y=y, ax=ax,   **kws_reg)
-            
+            ax = sns.regplot(data=data, x=x, y=y, ax=ax, **kws_reg)
+
             # Annotate the Pearson correlation and p-value
             ax.annotate(
-                    f"pearsonr = {r:.2f} p = {p_value:.3f}",
-                    xy=(0.6, 0.98),
-                    xycoords="axes fraction",
-                    fontsize=12,
-                    color="black",
-                    ha="center",
-                )
+                f"pearsonr = {r:.2f} p = {p_value:.3f}",
+                xy=(0.6, 0.98),
+                xycoords="axes fraction",
+                fontsize=12,
+                color="black",
+                ha="center",
+            )
         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_")}
@@ -3711,6 +3812,7 @@ def plotxy(
             return g, ax
     return ax
 
+
 def df_preprocessing_(data, kind, verbose=False):
     """
     Automatically formats data for various seaborn plot types.
@@ -3733,10 +3835,10 @@ def df_preprocessing_(data, kind, verbose=False):
             "heatmap",
             "pairplot",
             "jointplot",  # Typically requires wide format for axis variables
-            "facetgrid",   # Used for creating small multiples (can work with wide format)
-            "barplot",     # Can be used with wide format
-            "pointplot",   # Works well with wide format
-            "pivot_table", # Works with wide format (aggregated data)
+            "facetgrid",  # Used for creating small multiples (can work with wide format)
+            "barplot",  # Can be used with wide format
+            "pointplot",  # Works well with wide format
+            "pivot_table",  # Works with wide format (aggregated data)
             "boxplot",
             "violinplot",
             "stripplot",
@@ -3745,23 +3847,23 @@ def df_preprocessing_(data, kind, verbose=False):
             "lineplot",
             "scatterplot",
             "relplot",
-            "barplot",     # Can also work with long format (aggregated data in long form)
-            "boxenplot",   # Similar to boxplot, works with long format
-            "countplot",   # Works best with long format (categorical data)
-            "heatmap",     # Can work with long format after reshaping
-            "lineplot",    # Can work with long format (time series, continuous)
-            "histplot",    # Can be used with both wide and long formats
-            "kdeplot",     # Works with both wide and long formats
-            "ecdfplot",    # Works with both formats
-            "scatterplot", # Can work with both formats depending on data structure
-            "lineplot",    # Can work with both wide and long formats
-            "area plot",   # Can work with both formats, useful for stacked areas
+            "barplot",  # Can also work with long format (aggregated data in long form)
+            "boxenplot",  # Similar to boxplot, works with long format
+            "countplot",  # Works best with long format (categorical data)
+            "heatmap",  # Can work with long format after reshaping
+            "lineplot",  # Can work with long format (time series, continuous)
+            "histplot",  # Can be used with both wide and long formats
+            "kdeplot",  # Works with both wide and long formats
+            "ecdfplot",  # Works with both formats
+            "scatterplot",  # Can work with both formats depending on data structure
+            "lineplot",  # Can work with both wide and long formats
+            "area plot",  # Can work with both formats, useful for stacked areas
             "violinplot",  # Can work with both formats depending on categorical vs continuous data
-            "ellipse",# ellipse plot, default confidence=0.95
+            "ellipse",  # ellipse plot, default confidence=0.95
         ],
     )[0]
 
-    wide_kinds = [ 
+    wide_kinds = [
         "pairplot",
     ]
 
@@ -3773,26 +3875,26 @@ def df_preprocessing_(data, kind, verbose=False):
     # Flexible kinds: distribution plots can use either format
     flexible_kinds = [
         "jointplot",  # Typically requires wide format for axis variables
-        "lineplot",    # Can work with long format (time series, continuous)
+        "lineplot",  # Can work with long format (time series, continuous)
         "lineplot",
         "scatterplot",
-        "barplot",     # Can also work with long format (aggregated data in long form)
-        "boxenplot",   # Similar to boxplot, works with long format
-        "countplot",   # Works best with long format (categorical data)
+        "barplot",  # Can also work with long format (aggregated data in long form)
+        "boxenplot",  # Similar to boxplot, works with long format
+        "countplot",  # Works best with long format (categorical data)
         "regplot",
         "violinplot",
         "stripplot",
         "swarmplot",
         "boxplot",
-        "histplot",    # Can be used with both wide and long formats
-        "kdeplot",     # Works with both wide and long formats
-        "ecdfplot",    # Works with both formats
-        "scatterplot", # Can work with both formats depending on data structure
-        "lineplot",    # Can work with both wide and long formats
-        "area plot",   # Can work with both formats, useful for stacked areas
+        "histplot",  # Can be used with both wide and long formats
+        "kdeplot",  # Works with both wide and long formats
+        "ecdfplot",  # Works with both formats
+        "scatterplot",  # Can work with both formats depending on data structure
+        "lineplot",  # Can work with both wide and long formats
+        "area plot",  # Can work with both formats, useful for stacked areas
         "violinplot",  # Can work with both formats depending on categorical vs continuous data
         "relplot",
-        "pointplot",   # Works well with wide format
+        "pointplot",  # Works well with wide format
         "ellipse",
     ]
 
@@ -4296,17 +4398,17 @@ def venn(
         colors = ["r", "b"] if len(lists) == 2 else ["r", "g", "b"]
     if labels is None:
         if len(lists) == 2:
-            labels = ["set1", "set2"] 
-        elif len(lists) == 3: 
+            labels = ["set1", "set2"]
+        elif len(lists) == 3:
             labels = ["set1", "set2", "set3"]
-        elif len(lists) == 4: 
-            labels = ["set1", "set2", "set3","set4"]
-        elif len(lists) == 5: 
-            labels = ["set1", "set2", "set3","set4","set55"]
-        elif len(lists) == 6: 
-            labels = ["set1", "set2", "set3","set4","set5","set6"]
-        elif len(lists) == 7: 
-            labels = ["set1", "set2", "set3","set4","set5","set6","set7"]
+        elif len(lists) == 4:
+            labels = ["set1", "set2", "set3", "set4"]
+        elif len(lists) == 5:
+            labels = ["set1", "set2", "set3", "set4", "set55"]
+        elif len(lists) == 6:
+            labels = ["set1", "set2", "set3", "set4", "set5", "set6"]
+        elif len(lists) == 7:
+            labels = ["set1", "set2", "set3", "set4", "set5", "set6", "set7"]
     if edgecolor is None:
         edgecolor = colors
     colors = [desaturate_color(color, saturation) for color in colors]
@@ -4320,10 +4422,11 @@ def venn(
             if show_percentages
             else f"{subset_count}"
         )
+
     if fmt is not None:
         if not fmt.startswith("{"):
-            fmt="{:" + fmt + "}"
-    if len(lists) == 2: 
+            fmt = "{:" + fmt + "}"
+    if len(lists) == 2:
 
         from matplotlib_venn import venn2, venn2_circles
 
@@ -4345,7 +4448,7 @@ def venn(
         # 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(universe, len(set1 - set2))
         )
@@ -4447,7 +4550,7 @@ def venn(
                 if "none" in edgecolor or 0 in linewidth:
                     patch.set_edgecolor("none")
         return ax
-    elif len(lists) == 3: 
+    elif len(lists) == 3:
 
         from matplotlib_venn import venn3, venn3_circles
 
@@ -4463,32 +4566,46 @@ def venn(
         # 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_label_by_id("100").set_text(get_count_and_percentage(universe, len(set1 - set2 - set3)))
+        v.get_label_by_id("100").set_text(
+            get_count_and_percentage(universe, len(set1 - set2 - set3))
+        )
         v.get_patch_by_id("010").set_color(colors[1])
-        v.get_label_by_id("010").set_text(get_count_and_percentage(universe, len(set2 - set1 - set3)))
+        v.get_label_by_id("010").set_text(
+            get_count_and_percentage(universe, len(set2 - set1 - set3))
+        )
         try:
             v.get_patch_by_id("001").set_color(colors[2])
-            v.get_label_by_id("001").set_text(get_count_and_percentage(universe, len(set3 - set1 - set2)))
+            v.get_label_by_id("001").set_text(
+                get_count_and_percentage(universe, len(set3 - set1 - set2))
+            )
         except Exception as e:
             print(e)
         try:
             v.get_patch_by_id("110").set_color(colorAB)
-            v.get_label_by_id("110").set_text(get_count_and_percentage(universe, len(set1 & set2 - set3)))
+            v.get_label_by_id("110").set_text(
+                get_count_and_percentage(universe, len(set1 & set2 - set3))
+            )
         except Exception as e:
             print(e)
         try:
             v.get_patch_by_id("101").set_color(colorAC)
-            v.get_label_by_id("101").set_text(get_count_and_percentage(universe, len(set1 & set3 - set2)))
+            v.get_label_by_id("101").set_text(
+                get_count_and_percentage(universe, len(set1 & set3 - set2))
+            )
         except Exception as e:
             print(e)
         try:
             v.get_patch_by_id("011").set_color(colorBC)
-            v.get_label_by_id("011").set_text(get_count_and_percentage(universe, len(set2 & set3 - set1)))
+            v.get_label_by_id("011").set_text(
+                get_count_and_percentage(universe, len(set2 & set3 - set1))
+            )
         except Exception as e:
             print(e)
         try:
             v.get_patch_by_id("111").set_color(colorABC)
-            v.get_label_by_id("111").set_text(get_count_and_percentage(universe, len(set1 & set2 & set3)))
+            v.get_label_by_id("111").set_text(
+                get_count_and_percentage(universe, len(set1 & set2 & set3))
+            )
         except Exception as e:
             print(e)
 
@@ -4603,26 +4720,24 @@ def venn(
                     patch.set_edgecolor("none")
         return ax
 
-        
     dict_data = {}
     for i_list, list_ in enumerate(lists):
-        dict_data[labels[i_list]]={*list_}
+        dict_data[labels[i_list]] = {*list_}
 
-    if 3<len(lists)<6:        
+    if 3 < len(lists) < 6:
         from venn import venn as vn
 
-        legend_loc=kwargs.pop("legend_loc", "upper right") 
-        ax=vn(dict_data,ax=ax,legend_loc=legend_loc,**kwargs) 
+        legend_loc = kwargs.pop("legend_loc", "upper right")
+        ax = vn(dict_data, ax=ax, legend_loc=legend_loc, **kwargs)
 
         return ax
     else:
         from venn import pseudovenn
-        cmap=kwargs.pop("cmap","plasma")
-        ax=pseudovenn(dict_data, cmap=cmap,ax=ax,**kwargs)
-
-        return ax
 
+        cmap = kwargs.pop("cmap", "plasma")
+        ax = pseudovenn(dict_data, cmap=cmap, ax=ax, **kwargs)
 
+        return ax
 
 
 #! subplots, support automatic extend new axis
@@ -4670,7 +4785,7 @@ def subplot(
     col_first_axes = [None] * cols  # Track the first axis in each column (for sharex)
 
     def expand_ax():
-        nonlocal rows, grid_spec,cols,row_first_axes,fig,figsize,figsize_recommend
+        nonlocal rows, grid_spec, cols, row_first_axes, fig, figsize, figsize_recommend
         # fig_height = fig.get_figheight()
         # subplot_height = fig_height / rows
         rows += 1  # Expands by adding a row
@@ -4678,10 +4793,11 @@ def subplot(
         fig.set_size_inches(figsize)
         grid_spec = GridSpec(rows, cols, figure=fig)
         row_first_axes.append(None)
-        figsize_recommend=f"Warning: 建议设置 subplot({rows}, {cols})"
+        figsize_recommend = f"Warning: 建议设置 subplot({rows}, {cols})"
         print(figsize_recommend)
+
     def nexttile(rowspan=1, colspan=1, **kwargs):
-        nonlocal rows, cols, occupied, grid_spec,fig,figsize_recommend
+        nonlocal rows, cols, occupied, grid_spec, fig, figsize_recommend
         for row in range(rows):
             for col in range(cols):
                 if all(
@@ -4693,7 +4809,7 @@ def subplot(
             else:
                 continue
             break
-        
+
         else:
             expand_ax()
             return nexttile(rowspan=rowspan, colspan=colspan, **kwargs)
@@ -4715,12 +4831,13 @@ def subplot(
             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
 
 
@@ -4743,7 +4860,7 @@ def radar(
     bg_color="0.8",
     bg_alpha=None,
     grid_interval_ratio=0.2,
-    show_value=False,# show text for each value
+    show_value=False,  # show text for each value
     cmap=None,
     legend_loc="upper right",
     legend_fontsize=10,
@@ -4777,9 +4894,9 @@ def radar(
                 index=["HP", "MP", "ATK", "DEF", "SP.ATK", "SP.DEF", "SPD"],
                 columns=["Hero", "Warrior", "Wizard"],
             )
-        usage 1: 
+        usage 1:
             radar(data=df)
-        usage 2: 
+        usage 2:
             radar(data=df["Wizard"])
         usage 3:
             radar(data=df, columns="Wizard")
@@ -4819,8 +4936,8 @@ def radar(
         - sp (int): Padding for the ticks from the plot area.
         - **kwargs: Additional arguments for customization.
     """
-    if run_once_within(20,reverse=True) and verbose:
-        usage_="""usage:
+    if run_once_within(20, reverse=True) and verbose:
+        usage_ = """usage:
         radar(
             data: pd.DataFrame, #The data to plot. Each column corresponds to a variable, and each row represents a data point.
             ylim=(0, 100),# ylim (tuple): The limits of the radial axis (y-axis). Default is (0, 100).
@@ -4864,20 +4981,20 @@ def radar(
             kws_figsets = v_arg
             kwargs.pop(k_arg, None)
             break
-    if axis==1:
-        data=data.T
+    if axis == 1:
+        data = data.T
     if isinstance(data, dict):
         data = pd.DataFrame(pd.Series(data))
     if ~isinstance(data, pd.DataFrame):
-        data=pd.DataFrame(data)
+        data = pd.DataFrame(data)
     if isinstance(data, pd.DataFrame):
-        data=data.select_dtypes(include=np.number)
-    if isinstance(columns,str):
-        columns=[columns]
+        data = data.select_dtypes(include=np.number)
+    if isinstance(columns, str):
+        columns = [columns]
     if columns is None:
         columns = list(data.columns)
-    data=data[columns]
-    categories = list(data.index) 
+    data = data[columns]
+    categories = list(data.index)
     num_vars = len(categories)
 
     # Set y-axis limits and grid intervals
@@ -4928,7 +5045,9 @@ def radar(
     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-vmin)/ ((vmax-vmin)*grid_interval_ratio))+1):#int(vmax * grid_interval_ratio) + 1): 
+        for i in range(
+            1, int((vmax - vmin) / ((vmax - vmin) * grid_interval_ratio)) + 1
+        ):  # int(vmax * grid_interval_ratio) + 1):
             ax.plot(
                 angles + [angles[0]],  # Closing the loop
                 [i * vmax * grid_interval_ratio] * (num_vars + 1)
@@ -4962,8 +5081,8 @@ def radar(
     ax.tick_params(axis="y", pad=sp)  # move spines outward
     # colors
     if facecolor is not None:
-        if not isinstance(facecolor,list):
-            facecolor=[facecolor]
+        if not isinstance(facecolor, list):
+            facecolor = [facecolor]
         colors = facecolor
     else:
         colors = (
@@ -4987,44 +5106,44 @@ def radar(
         )
         ax.fill(angles, values, color=colors[i], alpha=alpha)
         # Add text labels for each value at each angle
-        labeled_points = set() #这样同一个点就不会标多次了
+        labeled_points = set()  # 这样同一个点就不会标多次了
         if show_value:
             for angle, value in zip(angles, values):
                 if (angle, value) not in labeled_points:
                     # offset_radius = value * value_offset
                     lim_ = np.max(values)
-                    sep_in = lim_/5
-                    sep_low=sep_in*2
-                    sep_med=sep_in*3
-                    sep_hig=sep_in*4
-                    sep_out=lim_*5
-                    if value<sep_in:
+                    sep_in = lim_ / 5
+                    sep_low = sep_in * 2
+                    sep_med = sep_in * 3
+                    sep_hig = sep_in * 4
+                    sep_out = lim_ * 5
+                    if value < sep_in:
                         offset_radius = value * 0.7
-                    elif value<sep_low:
+                    elif value < sep_low:
                         offset_radius = value * 0.8
-                    elif sep_low<=value<sep_med:
+                    elif sep_low <= value < sep_med:
                         offset_radius = value * 0.85
-                    elif sep_med<=value<sep_hig:
+                    elif sep_med <= value < sep_hig:
                         offset_radius = value * 0.9
-                    elif sep_hig<=value<sep_out:
+                    elif sep_hig <= value < sep_out:
                         offset_radius = value * 0.93
                     else:
                         offset_radius = value * 0.98
                     ax.text(
-                        angle, 
+                        angle,
                         offset_radius,
-                        f"{value:{fmt}}", 
-                        ha="center", 
-                        va="center", 
-                        fontsize=fontsize, 
+                        f"{value:{fmt}}",
+                        ha="center",
+                        va="center",
+                        fontsize=fontsize,
                         color=fontcolor,
-                        zorder=11
+                        zorder=11,
                     )
                     labeled_points.add((angle, value))
 
     ax.set_ylim(ylim)
     # Add markers for each data point
-    for i,  (col, val) in enumerate(data.items()):
+    for i, (col, val) in enumerate(data.items()):
         ax.plot(
             angles,
             list(val) + [val[0]],  # Close the loop for markers
@@ -5055,15 +5174,15 @@ def radar(
 
 
 def pie(
-    data:pd.Series,
-    columns:list = None,
+    data: pd.Series,
+    columns: list = None,
     facecolor=None,
     explode=[0.1],
     startangle=90,
     shadow=True,
     fontcolor="k",
-    fmt=".2f", 
-    width=None,# the center blank
+    fmt=".2f",
+    width=None,  # the center blank
     pctdistance=0.85,
     labeldistance=1.1,
     kws_wedge={},
@@ -5077,9 +5196,9 @@ def pie(
     edgewidth=1,
     cmap=None,
     show_value=False,
-    show_label=True,# False: only show the outer layer, if it is None, not show
-    expand_label=(1.2,1.2),
-    kws_bbox={},#dict(facecolor="none", alpha=0.5, edgecolor="black", boxstyle="round,pad=0.3"),  # '{}' to hide
+    show_label=True,  # False: only show the outer layer, if it is None, not show
+    expand_label=(1.2, 1.2),
+    kws_bbox={},  # dict(facecolor="none", alpha=0.5, edgecolor="black", boxstyle="round,pad=0.3"),  # '{}' to hide
     show_legend=True,
     legend_loc="upper right",
     bbox_to_anchor=[1.4, 1.1],
@@ -5087,11 +5206,12 @@ def pie(
     rotation_correction=0,
     verbose=True,
     ax=None,
-    **kwargs
-): 
+    **kwargs,
+):
     from adjustText import adjust_text
-    if run_once_within(20,reverse=True) and verbose:
-        usage_="""usage:
+
+    if run_once_within(20, reverse=True) and verbose:
+        usage_ = """usage:
             pie(
             data:pd.Series,
             columns:list = None,
@@ -5190,45 +5310,45 @@ def pie(
     if isinstance(data, dict):
         data = pd.DataFrame(pd.Series(data))
     if ~isinstance(data, pd.DataFrame):
-        data=pd.DataFrame(data)
+        data = pd.DataFrame(data)
 
     if isinstance(data, pd.DataFrame):
-        data=data.select_dtypes(include=np.number)
-    if isinstance(columns,str):
-        columns=[columns]
+        data = data.select_dtypes(include=np.number)
+    if isinstance(columns, str):
+        columns = [columns]
     if columns is None:
         columns = list(data.columns)
     # data=data[columns]
     # columns = list(data.columns)
     # print(columns)
     # 选择部分数据
-    df=data[columns]
+    df = data[columns]
 
     if not isinstance(explode, list):
-        explode=[explode]
+        explode = [explode]
     if explode == [None]:
-        explode=[0]
+        explode = [0]
 
     if width is None:
-        if df.shape[1]>1:
-            width=1/(df.shape[1]+2)
+        if df.shape[1] > 1:
+            width = 1 / (df.shape[1] + 2)
         else:
-            width=1
-    if isinstance(width,(float,int)):
-        width=[width]
-    if len(width)<df.shape[1]:
-        width=width*df.shape[1]
-    if isinstance(radius,(float,int)):
-        radius=[radius]
-    radius_tile=[1]*df.shape[1]
-    radius=radius_tile.copy()
-    for i in range(1,df.shape[1]):
-        radius[i]=radius_tile[i]-np.sum(width[:i])
+            width = 1
+    if isinstance(width, (float, int)):
+        width = [width]
+    if len(width) < df.shape[1]:
+        width = width * df.shape[1]
+    if isinstance(radius, (float, int)):
+        radius = [radius]
+    radius_tile = [1] * df.shape[1]
+    radius = radius_tile.copy()
+    for i in range(1, df.shape[1]):
+        radius[i] = radius_tile[i] - np.sum(width[:i])
 
     # colors
     if facecolor is not None:
-        if not isinstance(facecolor,list):
-            facecolor=[facecolor]
+        if not isinstance(facecolor, list):
+            facecolor = [facecolor]
         colors = facecolor
     else:
         colors = (
@@ -5239,38 +5359,38 @@ def pie(
     # to check if facecolor is nested list or not
     is_nested = True if any(isinstance(i, list) for i in colors) else False
     inested = 0
-    for column_,width_,radius_ in zip(columns, width,radius):
-        if column_!=columns[0]:
+    for column_, width_, radius_ in zip(columns, width, radius):
+        if column_ != columns[0]:
             labels = data.index if show_label else None
         else:
             labels = data.index if show_label is not None else None
         data = df[column_]
-        labels_legend=data.index
+        labels_legend = data.index
         sizes = data.values
-        
+
         # Set wedge and text properties if none are provided
         kws_wedge = kws_wedge or {"edgecolor": edgecolor, "linewidth": edgewidth}
-        kws_wedge.update({"width":width_})
-        fontcolor=kws_text.get("color",fontcolor)
-        fontsize=kws_text.get("fontsize",fontsize)
+        kws_wedge.update({"width": width_})
+        fontcolor = kws_text.get("color", fontcolor)
+        fontsize = kws_text.get("fontsize", fontsize)
         kws_text.update({"color": fontcolor, "fontsize": fontsize})
 
-        if ax is None: 
-            ax=plt.gca()
-        if len(explode)<len(labels_legend):
-            explode.extend([0]*(len(labels_legend)-len(explode)))
+        if ax is None:
+            ax = plt.gca()
+        if len(explode) < len(labels_legend):
+            explode.extend([0] * (len(labels_legend) - len(explode)))
         print(explode)
         if fmt:
             if not fmt.startswith("%"):
-                autopct =f"%{fmt}%%"
+                autopct = f"%{fmt}%%"
         else:
-            autopct=None
+            autopct = None
 
         if show_value is None:
             result = ax.pie(
                 sizes,
                 labels=labels,
-                autopct= None,
+                autopct=None,
                 startangle=startangle + rotation_correction,
                 explode=explode,
                 colors=colors[inested] if is_nested else colors,
@@ -5282,7 +5402,7 @@ def pie(
                 center=center,
                 radius=radius_,
                 frame=frame,
-                **kwargs
+                **kwargs,
             )
         else:
             result = ax.pie(
@@ -5292,7 +5412,7 @@ def pie(
                 startangle=startangle + rotation_correction,
                 explode=explode,
                 colors=colors[inested] if is_nested else colors,
-                shadow=shadow,#shadow,
+                shadow=shadow,  # shadow,
                 pctdistance=pctdistance,
                 labeldistance=labeldistance,
                 wedgeprops=kws_wedge,
@@ -5300,13 +5420,13 @@ def pie(
                 center=center,
                 radius=radius_,
                 frame=frame,
-                **kwargs
+                **kwargs,
             )
         if len(result) == 3:
             wedges, texts, autotexts = result
         elif len(result) == 2:
             wedges, texts = result
-            autotexts = None 
+            autotexts = None
         #! adjust_text
         if autotexts or texts:
             all_texts = []
@@ -5314,30 +5434,38 @@ def pie(
                 all_texts.extend(autotexts)
             if texts and show_label:
                 all_texts.extend(texts)
-                
+
             adjust_text(
                 all_texts,
                 ax=ax,
-                arrowprops=kws_arrow,#dict(arrowstyle="-", color="gray", lw=0.5), 
+                arrowprops=kws_arrow,  # dict(arrowstyle="-", color="gray", lw=0.5),
                 bbox=kws_bbox if kws_bbox else None,
                 expand=expand_label,
                 fontdict={
-                        "fontsize": fontsize,
-                        "color": fontcolor,
-                    },
+                    "fontsize": fontsize,
+                    "color": fontcolor,
+                },
             )
             # Show exact values on wedges if show_value is True
             if show_value:
                 for i, (wedge, txt) in enumerate(zip(wedges, texts)):
                     angle = (wedge.theta2 - wedge.theta1) / 2 + wedge.theta1
-                    x = np.cos(np.radians(angle)) * (pctdistance ) * radius_
-                    y = np.sin(np.radians(angle)) * (pctdistance ) * radius_
+                    x = np.cos(np.radians(angle)) * (pctdistance) * radius_
+                    y = np.sin(np.radians(angle)) * (pctdistance) * radius_
                     if not fmt.startswith("{"):
                         value_text = f"{sizes[i]:{fmt}}"
                     else:
-                        value_text = fmt.format(sizes[i]) 
-                    ax.text(x, y, value_text, ha="center", va="center", fontsize=fontsize,color=fontcolor)
-            inested+=1
+                        value_text = fmt.format(sizes[i])
+                    ax.text(
+                        x,
+                        y,
+                        value_text,
+                        ha="center",
+                        va="center",
+                        fontsize=fontsize,
+                        color=fontcolor,
+                    )
+            inested += 1
     # Customize the legend
     if show_legend:
         ax.legend(
@@ -5347,10 +5475,11 @@ def pie(
             bbox_to_anchor=bbox_to_anchor,
             fontsize=legend_fontsize,
             title_fontsize=legend_fontsize,
-        ) 
+        )
     ax.set(aspect="equal")
     return ax
 
+
 def ellipse(
     data,
     x=None,
@@ -5363,7 +5492,7 @@ def ellipse(
     palette=None,
     facecolor=None,
     edgecolor=None,
-    label:bool=True,
+    label: bool = True,
     **kwargs,
 ):
     """
@@ -5438,8 +5567,8 @@ def ellipse(
         groups = [None]
         color_map = {None: kwargs.get("edgecolor", "blue")}
     alpha = kwargs.pop("alpha", 0.2)
-    edgecolor=kwargs.pop("edgecolor", None)
-    facecolor=kwargs.pop("facecolor", None)
+    edgecolor = kwargs.pop("edgecolor", None)
+    facecolor = kwargs.pop("facecolor", None)
     for group in groups:
         group_data = data[data[hue] == group] if hue else data
 
@@ -5477,7 +5606,7 @@ def ellipse(
             height=height,
             angle=angle,
             edgecolor=edgecolor_,
-            facecolor=(facecolor_, alpha), #facecolor_, # only work on facecolor
+            facecolor=(facecolor_, alpha),  # facecolor_, # only work on facecolor
             # alpha=alpha,
             label=group if (hue and label) else None,
             **kwargs,
@@ -5504,6 +5633,7 @@ def ellipse(
 
     return ax
 
+
 def ppi(
     interactions,
     player1="preferredName_A",
@@ -5511,39 +5641,39 @@ def ppi(
     weight="score",
     n_layers=None,  # Number of concentric layers
     n_rank=[5, 10],  # Nodes in each rank for the concentric layout
-    dist_node = 10,  # Distance between each rank of circles
-    layout="degree", 
-    size=None,#700,
-    sizes=(50,500),# min and max of size
+    dist_node=10,  # Distance between each rank of circles
+    layout="degree",
+    size=None,  # 700,
+    sizes=(50, 500),  # min and max of size
     facecolor="skyblue",
-    cmap='coolwarm',
+    cmap="coolwarm",
     edgecolor="k",
     edgelinewidth=1.5,
-    alpha=.5,
-    alphas=(0.1, 1.0),# min and max of alpha
+    alpha=0.5,
+    alphas=(0.1, 1.0),  # min and max of alpha
     marker="o",
     node_hideticks=True,
     linecolor="gray",
-    line_cmap='coolwarm',
+    line_cmap="coolwarm",
     linewidth=1.5,
-    linewidths=(0.5,5),# min and max of linewidth
+    linewidths=(0.5, 5),  # min and max of linewidth
     linealpha=1.0,
-    linealphas=(0.1,1.0),# min and max of linealpha
+    linealphas=(0.1, 1.0),  # min and max of linealpha
     linestyle="-",
-    line_arrowstyle='-',
+    line_arrowstyle="-",
     fontsize=10,
     fontcolor="k",
-    ha:str="center",
-    va:str="center",
+    ha: str = "center",
+    va: str = "center",
     figsize=(12, 10),
-    k_value=0.3,    
+    k_value=0.3,
     bgcolor="w",
     dir_save="./ppi_network.html",
     physics=True,
     notebook=False,
     scale=1,
     ax=None,
-    **kwargs
+    **kwargs,
 ):
     """
     Plot a Protein-Protein Interaction (PPI) network with adjustable appearance.
@@ -5560,14 +5690,14 @@ def ppi(
     )
     """
     from pyvis.network import Network
-    import networkx as nx 
+    import networkx as nx
     from IPython.display import IFrame
     from matplotlib.colors import Normalize
     from matplotlib import cm
     from . import ips
 
     if run_once_within():
-        usage_str="""
+        usage_str = """
         ppi(
             interactions,
             player1="preferredName_A",
@@ -5611,17 +5741,19 @@ def ppi(
         ):
         """
         print(usage_str)
-    
+
     # Check for required columns in the DataFrame
     for col in [player1, player2, weight]:
         if col not in interactions.columns:
-            raise ValueError(f"Column '{col}' is missing from the interactions DataFrame.")
+            raise ValueError(
+                f"Column '{col}' is missing from the interactions DataFrame."
+            )
     interactions.sort_values(by=[weight], inplace=True)
     # Initialize Pyvis network
     net = Network(height="750px", width="100%", bgcolor=bgcolor, font_color=fontcolor)
     net.force_atlas_2based(
         gravity=-50, central_gravity=0.01, spring_length=100, spring_strength=0.1
-    ) 
+    )
     net.toggle_physics(physics)
 
     kws_figsets = {}
@@ -5637,47 +5769,62 @@ def ppi(
         G.add_edge(row[player1], row[player2], weight=row[weight])
     # G = nx.from_pandas_edgelist(interactions, source=player1, target=player2, edge_attr=weight)
 
-
     # Calculate node degrees
     degrees = dict(G.degree())
     norm = Normalize(vmin=min(degrees.values()), vmax=max(degrees.values()))
     colormap = cm.get_cmap(cmap)  # Get the 'coolwarm' colormap
 
-    if not ips.isa(facecolor, 'color'):
+    if not ips.isa(facecolor, "color"):
         print("facecolor: based on degrees")
         facecolor = [colormap(norm(deg)) for deg in degrees.values()]  # Use colormap
     num_nodes = G.number_of_nodes()
-    #* size
+    # * size
     # Set properties based on degrees
-    if not isinstance(size, (int,float,list)):
+    if not isinstance(size, (int, float, list)):
         print("size: based on degrees")
         size = [deg * 50 for deg in degrees.values()]  # Scale sizes
-    size = (size[:num_nodes] if len(size) > num_nodes else size) if isinstance(size, list) else [size] * num_nodes
-    if isinstance(size, list) and len(ips.flatten(size,verbose=False))!=1:
+    size = (
+        (size[:num_nodes] if len(size) > num_nodes else size)
+        if isinstance(size, list)
+        else [size] * num_nodes
+    )
+    if isinstance(size, list) and len(ips.flatten(size, verbose=False)) != 1:
         # Normalize sizes
         min_size, max_size = sizes  # Use sizes tuple for min and max values
         min_degree, max_degree = min(size), max(size)
         if max_degree > min_degree:  # Avoid division by zero
             size = [
-                min_size + (max_size - min_size) * (sz - min_degree) / (max_degree - min_degree)
+                min_size
+                + (max_size - min_size) * (sz - min_degree) / (max_degree - min_degree)
                 for sz in size
             ]
         else:
             # If all values are the same, set them to a default of the midpoint
             size = [(min_size + max_size) / 2] * len(size)
 
-    #* facecolor
-    facecolor = (facecolor[:num_nodes] if len(facecolor) > num_nodes else facecolor) if isinstance(facecolor, list) else [facecolor] * num_nodes
+    # * facecolor
+    facecolor = (
+        (facecolor[:num_nodes] if len(facecolor) > num_nodes else facecolor)
+        if isinstance(facecolor, list)
+        else [facecolor] * num_nodes
+    )
     # * facealpha
     if isinstance(alpha, list):
-        alpha = (alpha[:num_nodes] if len(alpha) > num_nodes else alpha + [alpha[-1]] * (num_nodes - len(alpha)))
+        alpha = (
+            alpha[:num_nodes]
+            if len(alpha) > num_nodes
+            else alpha + [alpha[-1]] * (num_nodes - len(alpha))
+        )
         min_alphas, max_alphas = alphas  # Use alphas tuple for min and max values
         if len(alpha) > 0:
             # Normalize alpha based on the specified min and max
             min_alpha, max_alpha = min(alpha), max(alpha)
             if max_alpha > min_alpha:  # Avoid division by zero
                 alpha = [
-                    min_alphas + (max_alphas - min_alphas) * (ea - min_alpha) / (max_alpha - min_alpha)
+                    min_alphas
+                    + (max_alphas - min_alphas)
+                    * (ea - min_alpha)
+                    / (max_alpha - min_alpha)
                     for ea in alpha
                 ]
             else:
@@ -5685,7 +5832,7 @@ def ppi(
                 alpha = [(min_alphas + max_alphas) / 2] * len(alpha)
         else:
             # Default to a full opacity if no edges are provided
-            alpha = [1.0] * num_nodes  
+            alpha = [1.0] * num_nodes
     else:
         # If alpha is a single value, convert it to a list and normalize it
         alpha = [alpha] * num_nodes  # Adjust based on alphas
@@ -5699,7 +5846,7 @@ def ppi(
             alpha=alpha[i],
             font={"size": fontsize, "color": fontcolor},
         )
-    print(f'nodes number: {i+1}')
+    print(f"nodes number: {i+1}")
 
     for edge in G.edges(data=True):
         net.add_edge(
@@ -5718,11 +5865,11 @@ def ppi(
         "shell",
         "planar",
         "spiral",
-        "degree"
+        "degree",
     ]
     layout = ips.strcmp(layout, layouts)[0]
     print(f"layout:{layout}, or select one in {layouts}")
-    
+
     # Choose layout
     if layout == "spring":
         pos = nx.spring_layout(G, k=k_value)
@@ -5744,24 +5891,26 @@ def ppi(
             pos = nx.spring_layout(G, k=k_value)
     elif layout == "spiral":
         pos = nx.spiral_layout(G)
-    elif layout=='degree':
+    elif layout == "degree":
         # Calculate node degrees and sort nodes by degree
         degrees = dict(G.degree())
         sorted_nodes = sorted(degrees.items(), key=lambda x: x[1], reverse=True)
         norm = Normalize(vmin=min(degrees.values()), vmax=max(degrees.values()))
         colormap = cm.get_cmap(cmap)
-        
+
         # Create positions for concentric circles based on n_layers and n_rank
         pos = {}
-        n_layers=len(n_rank)+1 if n_layers is None else n_layers
+        n_layers = len(n_rank) + 1 if n_layers is None else n_layers
         for rank_index in range(n_layers):
             if rank_index < len(n_rank):
                 nodes_per_rank = n_rank[rank_index]
-                rank_nodes = sorted_nodes[sum(n_rank[:rank_index]): sum(n_rank[:rank_index + 1])]
+                rank_nodes = sorted_nodes[
+                    sum(n_rank[:rank_index]) : sum(n_rank[: rank_index + 1])
+                ]
             else:
                 # 随机打乱剩余节点的顺序
-                remaining_nodes = sorted_nodes[sum(n_rank[:rank_index]):]
-                random_indices = np.random.permutation(len(remaining_nodes)) 
+                remaining_nodes = sorted_nodes[sum(n_rank[:rank_index]) :]
+                random_indices = np.random.permutation(len(remaining_nodes))
                 rank_nodes = [remaining_nodes[i] for i in random_indices]
 
             radius = (rank_index + 1) * dist_node  # Radius for this rank
@@ -5772,7 +5921,9 @@ def ppi(
                 pos[node] = (radius * np.cos(angle), radius * np.sin(angle))
 
     else:
-        print(f"Unknown layout '{layout}', defaulting to 'spring',or可以用这些: {layouts}")
+        print(
+            f"Unknown layout '{layout}', defaulting to 'spring',or可以用这些: {layouts}"
+        )
         pos = nx.spring_layout(G, k=k_value)
 
     for node, (x, y) in pos.items():
@@ -5781,8 +5932,8 @@ def ppi(
 
     # If ax is None, use plt.gca()
     if ax is None:
-        fig, ax = plt.subplots(1,1,figsize=figsize) 
-    
+        fig, ax = plt.subplots(1, 1, figsize=figsize)
+
     # Draw nodes, edges, and labels with customization options
     nx.draw_networkx_nodes(
         G,
@@ -5794,14 +5945,18 @@ def ppi(
         edgecolors=edgecolor,
         alpha=alpha,
         hide_ticks=node_hideticks,
-        node_shape=marker
+        node_shape=marker,
     )
 
-    #* linewidth
+    # * linewidth
     if not isinstance(linewidth, list):
         linewidth = [linewidth] * G.number_of_edges()
     else:
-        linewidth = (linewidth[:G.number_of_edges()] if len(linewidth) > G.number_of_edges() else linewidth + [linewidth[-1]] * (G.number_of_edges() - len(linewidth)))
+        linewidth = (
+            linewidth[: G.number_of_edges()]
+            if len(linewidth) > G.number_of_edges()
+            else linewidth + [linewidth[-1]] * (G.number_of_edges() - len(linewidth))
+        )
         # Normalize linewidth if it is a list
         if isinstance(linewidth, list):
             min_linewidth, max_linewidth = min(linewidth), max(linewidth)
@@ -5809,7 +5964,10 @@ def ppi(
             if max_linewidth > min_linewidth:  # Avoid division by zero
                 # Scale between vmin and vmax
                 linewidth = [
-                    vmin + (vmax - vmin) * (lw - min_linewidth) / (max_linewidth - min_linewidth)
+                    vmin
+                    + (vmax - vmin)
+                    * (lw - min_linewidth)
+                    / (max_linewidth - min_linewidth)
                     for lw in linewidth
                 ]
             else:
@@ -5818,8 +5976,8 @@ def ppi(
         else:
             # If linewidth is a single value, convert it to a list of that value
             linewidth = [linewidth] * G.number_of_edges()
-    #* linecolor 
-    if not isinstance(linecolor, str):  
+    # * linecolor
+    if not isinstance(linecolor, str):
         weights = [G[u][v]["weight"] for u, v in G.edges()]
         norm = Normalize(vmin=min(weights), vmax=max(weights))
         colormap = cm.get_cmap(line_cmap)
@@ -5829,45 +5987,58 @@ def ppi(
 
     # * linealpha
     if isinstance(linealpha, list):
-        linealpha = (linealpha[:G.number_of_edges()] if len(linealpha) > G.number_of_edges() else linealpha + [linealpha[-1]] * (G.number_of_edges() - len(linealpha)))
+        linealpha = (
+            linealpha[: G.number_of_edges()]
+            if len(linealpha) > G.number_of_edges()
+            else linealpha + [linealpha[-1]] * (G.number_of_edges() - len(linealpha))
+        )
         min_alpha, max_alpha = linealphas  # Use linealphas tuple for min and max values
         if len(linealpha) > 0:
             min_linealpha, max_linealpha = min(linealpha), max(linealpha)
             if max_linealpha > min_linealpha:  # Avoid division by zero
                 linealpha = [
-                    min_alpha + (max_alpha - min_alpha) * (ea - min_linealpha) / (max_linealpha - min_linealpha)
+                    min_alpha
+                    + (max_alpha - min_alpha)
+                    * (ea - min_linealpha)
+                    / (max_linealpha - min_linealpha)
                     for ea in linealpha
                 ]
             else:
                 linealpha = [(min_alpha + max_alpha) / 2] * len(linealpha)
         else:
-            linealpha = [1.0] * G.number_of_edges() # 如果设置有误,则将它设置成1.0
+            linealpha = [1.0] * G.number_of_edges()  # 如果设置有误,则将它设置成1.0
     else:
         linealpha = [linealpha] * G.number_of_edges()  # Convert to list if single value
     nx.draw_networkx_edges(
-        G, 
-        pos, 
-        ax=ax, 
-        edge_color=linecolor, 
+        G,
+        pos,
+        ax=ax,
+        edge_color=linecolor,
         width=linewidth,
         style=linestyle,
-        arrowstyle=line_arrowstyle, 
-        alpha=linealpha
+        arrowstyle=line_arrowstyle,
+        alpha=linealpha,
     )
- 
+
     nx.draw_networkx_labels(
-        G, pos, ax=ax, font_size=fontsize, font_color=fontcolor,horizontalalignment=ha,verticalalignment=va
+        G,
+        pos,
+        ax=ax,
+        font_size=fontsize,
+        font_color=fontcolor,
+        horizontalalignment=ha,
+        verticalalignment=va,
     )
-    figsets(ax=ax,**kws_figsets)
+    figsets(ax=ax, **kws_figsets)
     ax.axis("off")
     if dir_save:
         if not os.path.basename(dir_save):
-            dir_save="_.html"
+            dir_save = "_.html"
         net.write_html(dir_save)
-        nx.write_graphml(G, dir_save.replace(".html",".graphml"))  # Export to GraphML
+        nx.write_graphml(G, dir_save.replace(".html", ".graphml"))  # Export to GraphML
         print(f"could be edited in Cytoscape \n{dir_save.replace(".html",".graphml")}")
-        ips.figsave(dir_save.replace(".html",".pdf"))
-    return G,ax
+        ips.figsave(dir_save.replace(".html", ".pdf"))
+    return G, ax
 
 
 def plot_map(
@@ -5886,6 +6057,7 @@ def plot_map(
     save_path=None,  # Path to save the map in offline mode
     pydeck_map=False,  # Whether to use pydeck for rendering (True for pydeck)
     pydeck_style="mapbox://styles/mapbox/streets-v11",  # Map style for pydeck
+    verbose=True,  # show usage
     **kwargs,  # Additional arguments for Folium Map
 ):
     """
@@ -5899,19 +6071,88 @@ def plot_map(
     df_tiles = pd.DataFrame({"tiles": tiles_support})
     fsave("....tiles.csv",df_tiles)
     """
+    config_markers = """from folium import Icon
+    # https://github.com/lennardv2/Leaflet.awesome-markers?tab=readme-ov-file
+    markers = [
+        {
+            "location": [loc[0], loc[1]],
+            "popup": "Center City",
+            "tooltip": "Philadelphia",
+            "icon": Icon(color="red", icon="flag"),
+        },
+        {
+            "location": [loc[0], loc[1] + 0.05],
+            "popup": "Rittenhouse Square",
+            "tooltip": "A lovely park",
+            "icon": Icon(
+                color="purple", icon="flag", prefix="fa"
+            ),  # Purple marker with "star" icon (Font Awesome)
+        },
+    ]"""
+    config_overlay = """
+    from folium import Circle
+
+    circle = Circle(
+        location=loc,
+        radius=300,  # In meters
+        color="#EB686C",
+        fill=True,
+        fill_opacity=0.2,
+    )
+    markers = [
+        {
+            "location": [loc[0], loc[1]],
+            "popup": "Center City",
+            "tooltip": "Philadelphia",
+        },
+        {
+            "location": [loc[0], loc[1] + 0.05],
+            "popup": "Rittenhouse Square",
+            "tooltip": "A lovely park",
+        },
+    ]
+    plot_map(loc, overlays=[circle], zoom_start=14)
+    """
+    config_plugin = """
+    from folium.plugins import HeatMap
+    heat_data = [
+        [48.54440975, 9.060237673391708, 1],
+        [48.5421456, 9.057464182487431, 1],
+        [48.54539175, 9.059915422200906, 1],
+    ]
+    heatmap = HeatMap(
+        heat_data,
+        radius=5,  # Increase the radius of each point
+        blur=5,  # Adjust the blurring effect
+        min_opacity=0.4,  # Make the heatmap semi-transparent
+        max_zoom=16,  # Zoom level at which points appear
+        gradient={  # Define a custom gradient
+            0.2: "blue",
+            0.4: "lime",
+            0.6: "yellow",
+            1.0: "#A34B00",
+        },
+    )
+
+    plot_map(loc, plugins=[heatmap])
+    """
     from pathlib import Path
 
     # Get the current script's directory as a Path object
     current_directory = Path(__file__).resolve().parent
     if not "tiles_support" in locals():
-        tiles_support = fload(current_directory / "data" / "tiles.csv", verbose=0).iloc[:, 1].tolist()
-    tiles=strcmp(tiles, tiles_support)[0]
+        tiles_support = (
+            fload(current_directory / "data" / "tiles.csv", verbose=0)
+            .iloc[:, 1]
+            .tolist()
+        )
+    tiles = strcmp(tiles, tiles_support)[0]
     import folium
     import streamlit as st
     import pydeck as pdk
     from streamlit_folium import st_folium
     from folium.plugins import HeatMap
-    
+
     if pydeck_map:
         view = pdk.ViewState(
             latitude=location[0],
@@ -5920,7 +6161,6 @@ def plot_map(
             pitch=0,
         )
 
-        # Example Layer (can be replaced by your custom layers)
         layer = pdk.Layer(
             "ScatterplotLayer",
             data=[{"lat": location[0], "lon": location[1]}],
@@ -5929,20 +6169,16 @@ def plot_map(
             get_radius=1000,
         )
 
-        # Create the deck
         deck = pdk.Deck(
             layers=[layer],
             initial_view_state=view,
             map_style=pydeck_style,
         )
-
-        # Render map in Streamlit
         st.pydeck_chart(deck)
 
         return deck  # Return the pydeck map
 
     else:
-        # Initialize the base map (Folium)
         m = folium.Map(
             location=location,
             zoom_start=zoom_start,
@@ -5950,39 +6186,39 @@ def plot_map(
             scrollWheelZoom=scroll_wheel_zoom,
             **kwargs,
         )
-
-        # Add markers
         if markers:
+            if verbose:
+                print(config_markers)
             for marker in markers:
                 folium.Marker(
                     location=marker.get("location"),
                     popup=marker.get("popup"),
                     tooltip=marker.get("tooltip"),
-                    icon=marker.get("icon", folium.Icon()),  # Default icon if none specified
+                    icon=marker.get(
+                        "icon", folium.Icon()
+                    ),  # Default icon if none specified
                 ).add_to(m)
 
-        # Add overlays
         if overlays:
+            if verbose:
+                print(config_overlay)
             for overlay in overlays:
                 overlay.add_to(m)
 
-        # Add custom layers
         if custom_layers:
             for layer in custom_layers:
                 layer.add_to(m)
 
-        # Add plugins
         if plugins:
+            if verbose:
+                print(config_plugin)
             for plugin in plugins:
                 plugin.add_to(m)
 
-        # Fit map bounds
         if fit_bounds:
             m.fit_bounds(fit_bounds)
 
-        # Handle rendering based on output
         if output == "streamlit":
-            # Render the map in Streamlit
             st_data = st_folium(m, width=map_width, height=map_height)
             return st_data
         elif output == "offline":