py2ls 0.2.4.25__py3-none-any.whl → 0.2.4.26__py3-none-any.whl

py2ls/plot.py

@@ -20,7 +20,9 @@ from .ips import (
     flatten,
     plt_font,
     run_once_within,
-    df_format
+    df_format,
+    df_corr,
+    df_scaler
 )
 import scipy.stats as scipy_stats
 from .stats import *
@@ -142,20 +144,37 @@ def add_text(ax=None, height_offset=0.5, fmt=".1f", **kwargs):
                         **kwargs,
                     )
 
+def pval2str(p):
+    if p > 0.05:
+        txt = ""
+    elif 0.01 <= p <= 0.05:
+        txt = "*"
+    elif 0.001 <= p < 0.01:
+        txt = "**"
+    elif p < 0.001:
+        txt = "***"
+    return txt
 
 def heatmap(
     data,
     ax=None,
     kind="corr",  #'corr','direct','pivot'
+    method="pearson",# for correlation: ‘pearson’(default), ‘kendall’, ‘spearman’
     columns="all",  # pivot, default: coll numeric columns
+    style=0,# for correlation
     index=None,  # pivot
     values=None,  # pivot
+    fontsize=10, 
     tri="u",
     mask=True,
     k=1,
+    vmin=None,
+    vmax=None,
+    size_scale=500,
     annot=True,
     cmap="coolwarm",
     fmt=".2f",
+    show_indicator = True,# only for style==1
     cluster=False,
     inplace=False,
     figsize=(10, 8),
@@ -201,7 +220,7 @@ def heatmap(
         ax = plt.gca()
     # Select numeric columns or specific subset of columns
     if columns == "all":
-        df_numeric = data.select_dtypes(include=[float, int])
+        df_numeric = data.select_dtypes(include=[np.number])
     else:
         df_numeric = data[columns]
 
@@ -209,8 +228,10 @@ def heatmap(
     kind = strcmp(kind, kinds)[0]
     print(kind)
     if "corr" in kind:  # correlation
+        methods = ["pearson", "spearman", "kendall"]
+        method = strcmp(method, methods)[0]
         # Compute the correlation matrix
-        data4heatmap = df_numeric.corr()
+        data4heatmap = df_numeric.corr(method=method)
         # Generate mask for the upper triangle if mask is True
         if mask:
             if "u" in tri.lower():  # upper => np.tril
@@ -288,18 +309,76 @@ def heatmap(
                 df_col_cluster,
             )
         else:
-            # Create a standard heatmap
-            ax = sns.heatmap(
-                data4heatmap,
-                ax=ax,
-                mask=mask_array,
-                annot=annot,
-                cmap=cmap,
-                fmt=fmt,
-                **kwargs,  # Pass any additional arguments to sns.heatmap
-            )
-            # Return the Axes object for further customization if needed
-            return ax
+            if style==0:
+                # Create a standard heatmap
+                ax = sns.heatmap(
+                    data4heatmap,
+                    ax=ax,
+                    mask=mask_array,
+                    annot=annot,
+                    cmap=cmap,
+                    fmt=fmt,
+                    **kwargs,  # Pass any additional arguments to sns.heatmap
+                )
+                return ax
+            elif style==1:
+                if isinstance(cmap, str):
+                    cmap = plt.get_cmap(cmap)
+                norm = plt.Normalize(vmin=-1, vmax=1)
+                r_, p_ = df_corr(data4heatmap, method=method)
+                # size_r_norm=df_scaler(data=r_, method="minmax", vmin=-1,vmax=1)
+                # 初始化一个空的可绘制对象用于颜色条
+                scatter_handles = []
+                # 循环绘制气泡图和数值
+                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):  # 对角线左上部只显示气泡
+                            color = cmap(norm(r_.iloc[i, j]))  # 根据相关系数获取颜色
+                            scatter = ax.scatter(
+                                i, j, s=np.abs(r_.iloc[i, j])*size_scale, color=color, 
+                                # alpha=1,edgecolor=edgecolor,linewidth=linewidth,
+                                **kwargs
+                            )
+                            scatter_handles.append(scatter)  # 保存scatter对象用于颜色条
+                            # add *** indicators
+                            if show_indicator:
+                                ax.text(
+                                    i,
+                                    j,
+                                    pval2str(p_.iloc[i, j]),
+                                    ha="center",
+                                    va="center",
+                                    color="k",
+                                    fontsize=fontsize * 1.3,
+                                )
+                        elif (i > j) if "u" in tri.lower() else (j>i):  # 对角只显示数值
+                            color = cmap(norm(r_.iloc[i, j]))  # 数值的颜色同样基于相关系数
+                            ax.text(
+                                i,
+                                j,
+                                f"{r_.iloc[i, j]:{fmt}}",
+                                ha="center",
+                                va="center",
+                                color=color,
+                                fontsize=fontsize,
+                            )
+                        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]
+                        ) 
+                # 添加颜色条
+                sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+                sm.set_array([])  # 仅用于显示颜色条
+                plt.colorbar(sm, ax=ax, label="Correlation Coefficient")
+                return ax
     elif "dir" in kind:  # direct
         data4heatmap = df_numeric
     elif "pi" in kind:  # pivot
@@ -389,16 +468,53 @@ def heatmap(
         )
     else:
         # Create a standard heatmap
-        ax = sns.heatmap(
-            data4heatmap,
-            ax=ax,
-            annot=annot,
-            cmap=cmap,
-            fmt=fmt,
-            **kwargs,  # Pass any additional arguments to sns.heatmap
-        )
-        # Return the Axes object for further customization if needed
-        return ax
+        if style==0:
+            ax = sns.heatmap(
+                data4heatmap,
+                ax=ax,
+                annot=annot,
+                cmap=cmap,
+                fmt=fmt,
+                **kwargs,  # Pass any additional arguments to sns.heatmap
+            )
+            # Return the Axes object for further customization if needed
+            return ax            
+        elif style==1:
+            if isinstance(cmap, str):
+                cmap = plt.get_cmap(cmap)
+            if vmin is None:
+                vmin=np.min(data4heatmap)
+            if vmax is None:
+                vmax=np.max(data4heatmap)
+            norm = plt.Normalize(vmin=vmin, vmax=vmax)
+
+            # 初始化一个空的可绘制对象用于颜色条
+            scatter_handles = []
+            # 循环绘制气泡图和数值 
+            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_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]
+                    ) 
+            # 添加颜色条
+            sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+            sm.set_array([])  # 仅用于显示颜色条
+            plt.colorbar(sm, ax=ax, 
+                        #  label="Correlation Coefficient"
+                         )
+            return ax
 
 
 # !usage: py2ls.plot.heatmap()
@@ -3226,18 +3342,37 @@ def plotxy(
         # (1) return FcetGrid
         if k == "jointplot":
             kws_joint = kwargs.pop("kws_joint", kwargs)
-            stats=kwargs.pop("stats",True)
+            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
+                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
+                )
+            else:
+                kws_joint.pop("palette", palette)
+            stats=kwargs.pop("stats",None)
+            if stats:
+                stats=kws_joint.pop("stats",True)
             if stats:
                 r, p_value = scipy_stats.pearsonr(data[x], data[y])
-            g = sns.jointplot(data=data, x=x, y=y, **kws_joint)
-            g.ax_joint.annotate(
-                f"pearsonr = {r:.2f} p = {p_value:.3f}",
-                xy=(0.6, 0.98),
-                xycoords="axes fraction",
-                fontsize=12,
-                color="black",
-                ha="center",
-            )
+            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}",
+                    xy=(0.6, 0.98),
+                    xycoords="axes fraction",
+                    fontsize=12,
+                    color="black",
+                    ha="center",
+                )
         elif k == "lmplot":
             kws_lm = kwargs.pop("kws_lm", kwargs)
             stats = kwargs.pop("stats", True)  # Flag to calculate stats
@@ -3383,8 +3518,7 @@ def plotxy(
                                 xycoords="axes fraction",
                                 fontsize=12,
                                 color="black",
-                                ha="center",
-                            )
+                                ha="center")
 
         elif k == "catplot_sns":
             kws_cat = kwargs.pop("kws_cat", kwargs)
@@ -3392,7 +3526,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, **kws_dis)
+            g = sns.displot(data=data, x=x,y=y,  **kws_dis)
 
         # (2) return axis
         if ax is None:
@@ -3403,19 +3537,58 @@ def plotxy(
         elif k == "stdshade":
             kws_stdshade = kwargs.pop("kws_stdshade", kwargs)
             ax = stdshade(ax=ax, **kwargs)
+        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
+                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
+                )
+            alpha = kws_ellipse.pop("alpha", 0.1)
+            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)
+                data = data.sort_values(by="hue")
+            for key in ["palette", "alpha", "hue","hue_order"]:
+                kws_ellipse.pop(key, None) 
+            ax=ellipse(
+                ax=ax,
+                data=data,
+                x=x,
+                y=y,
+                hue=hue,
+                palette=palette,
+                alpha=alpha,
+                zorder=zorder,
+                **kws_ellipse,
+            )
         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)
+            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.pop(
-                "palette", get_color(data[hue].nunique()) if hue is not None else 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
+                )
             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)
+
             ax = sns.scatterplot(
                 ax=ax,
                 data=data,
@@ -3431,19 +3604,33 @@ def plotxy(
         elif k == "histplot":
             kws_hist = kwargs.pop("kws_hist", kwargs)
             kws_hist = {k: v for k, v in kws_hist.items() if not k.startswith("kws_")}
-            ax = sns.histplot(data=data, x=x, ax=ax, zorder=zorder, **kws_hist)
-        elif k == "kdeplot":
+            ax = sns.histplot(data=data, x=x, y=y, ax=ax, zorder=zorder, **kws_hist)
+        elif k == "kdeplot": 
             kws_kde = kwargs.pop("kws_kde", kwargs)
-            kws_kde = {k: v for k, v in kws_kde.items() if not k.startswith("kws_")}
-            ax = sns.kdeplot(data=data, x=x, ax=ax, zorder=zorder, **kws_kde)
+            kws_kde = {
+                k: v for k, v in kws_kde.items() if not k.startswith("kws_")
+            }
+            hue = kwargs.get("hue", None)
+            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
+                )
+            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)
         elif k == "ecdfplot":
             kws_ecdf = kwargs.pop("kws_ecdf", kwargs)
             kws_ecdf = {k: v for k, v in kws_ecdf.items() if not k.startswith("kws_")}
-            ax = sns.ecdfplot(data=data, x=x, ax=ax, zorder=zorder, **kws_ecdf)
+            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_")}
-            ax = sns.rugplot(data=data, x=x, ax=ax, zorder=zorder, **kws_rug)
+            ax = sns.rugplot(data=data, x=x, y=y, 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_")}
@@ -3516,7 +3703,8 @@ def plotxy(
         figsets(ax=ax, **kws_figsets)
         if kws_add_text:
             add_text(ax=ax, **kws_add_text) if kws_add_text else None
-        if run_once_within(10):
+    if run_once_within(10):
+        for k in kind_:
             print(f"\n{k}⤵ ")
             print(default_settings[k])
             # print("=>\t",sns_info[sns_info["Functions"].str.contains(k)].iloc[:, -1].tolist()[0],"\n")
@@ -3574,6 +3762,7 @@ def df_preprocessing_(data, kind, verbose=False):
             "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
         ],
     )[0]
 
@@ -3609,6 +3798,7 @@ def df_preprocessing_(data, kind, verbose=False):
         "violinplot",  # Can work with both formats depending on categorical vs continuous data
         "relplot",
         "pointplot",   # Works well with wide format
+        "ellipse",
     ]
 
     # Wide format (e.g., for heatmap and pairplot)
@@ -4100,25 +4290,45 @@ def venn(
     """
     if ax is None:
         ax = plt.gca()
+    if isinstance(lists, dict):
+        labels = list(lists.keys())
+        lists = list(lists.values())
+    if isinstance(lists[0], set):
+        lists = [list(i) for i in lists]
     lists = [set(flatten(i, verbose=False)) for i in lists]
     # Function to apply text styles to labels
     if colors is None:
         colors = ["r", "b"] if len(lists) == 2 else ["r", "g", "b"]
     if labels is None:
-        labels = ["set1", "set2"] if len(lists) == 2 else ["set1", "set2", "set3"]
+        if len(lists) == 2:
+            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"]
     if edgecolor is None:
         edgecolor = colors
     colors = [desaturate_color(color, saturation) for color in colors]
-    # Check colors and auto-calculate overlaps
-    if len(lists) == 2:
+    universe = len(set.union(*lists))
 
-        def get_count_and_percentage(set_count, subset_count):
-            percent = subset_count / set_count if set_count > 0 else 0
-            return (
-                f"{subset_count}\n({fmt.format(percent)})"
-                if show_percentages
-                else f"{subset_count}"
-            )
+    # Check colors and auto-calculate overlaps
+    def get_count_and_percentage(set_count, subset_count):
+        percent = subset_count / set_count if set_count > 0 else 0
+        return (
+            f"{subset_count}\n({fmt.format(percent)})"
+            if show_percentages
+            else f"{subset_count}"
+        )
+    if fmt is not None:
+        if not fmt.startswith("{"):
+            fmt="{:" + fmt + "}"
+    if len(lists) == 2: 
 
         from matplotlib_venn import venn2, venn2_circles
 
@@ -4131,21 +4341,28 @@ def venn(
         set1, set2 = lists[0], lists[1]
         v.get_patch_by_id("10").set_color(colors[0])
         v.get_patch_by_id("01").set_color(colors[1])
-        v.get_patch_by_id("11").set_color(
-            get_color_overlap(colors[0], colors[1]) if colors else None
-        )
+        try:
+            v.get_patch_by_id("11").set_color(
+                get_color_overlap(colors[0], colors[1]) if colors else None
+            )
+        except Exception as e:
+            print(e)
         # v.get_label_by_id('10').set_text(len(set1 - set2))
         # v.get_label_by_id('01').set_text(len(set2 - set1))
         # v.get_label_by_id('11').set_text(len(set1 & set2))
+        
         v.get_label_by_id("10").set_text(
-            get_count_and_percentage(len(set1), len(set1 - set2))
+            get_count_and_percentage(universe, len(set1 - set2))
         )
         v.get_label_by_id("01").set_text(
-            get_count_and_percentage(len(set2), len(set2 - set1))
-        )
-        v.get_label_by_id("11").set_text(
-            get_count_and_percentage(len(set1 | set2), len(set1 & set2))
+            get_count_and_percentage(universe, len(set2 - set1))
         )
+        try:
+            v.get_label_by_id("11").set_text(
+                get_count_and_percentage(universe, len(set1 & set2))
+            )
+        except Exception as e:
+            print(e)
 
         if not isinstance(linewidth, list):
             linewidth = [linewidth]
@@ -4228,16 +4445,14 @@ def venn(
                     va=va,
                     shadow=shadow,
                 )
-
-    elif len(lists) == 3:
-
-        def get_label(set_count, subset_count):
-            percent = subset_count / set_count if set_count > 0 else 0
-            return (
-                f"{subset_count}\n({fmt.format(percent)})"
-                if show_percentages
-                else f"{subset_count}"
-            )
+        # Set transparency level
+        for patch in v.patches:
+            if patch:
+                patch.set_alpha(alpha)
+                if "none" in edgecolor or 0 in linewidth:
+                    patch.set_edgecolor("none")
+        return ax
+    elif len(lists) == 3: 
 
         from matplotlib_venn import venn3, venn3_circles
 
@@ -4253,36 +4468,34 @@ 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_patch_by_id("010").set_color(colors[1])
-        v.get_patch_by_id("001").set_color(colors[2])
-        v.get_patch_by_id("110").set_color(colorAB)
-        v.get_patch_by_id("101").set_color(colorAC)
-        v.get_patch_by_id("011").set_color(colorBC)
-        v.get_patch_by_id("111").set_color(colorABC)
-
-        # Correctly labeling subset sizes
-        # v.get_label_by_id('100').set_text(len(set1 - set2 - set3))
-        # v.get_label_by_id('010').set_text(len(set2 - set1 - set3))
-        # v.get_label_by_id('001').set_text(len(set3 - set1 - set2))
-        # v.get_label_by_id('110').set_text(len(set1 & set2 - set3))
-        # v.get_label_by_id('101').set_text(len(set1 & set3 - set2))
-        # v.get_label_by_id('011').set_text(len(set2 & set3 - set1))
-        # v.get_label_by_id('111').set_text(len(set1 & set2 & set3))
-        v.get_label_by_id("100").set_text(get_label(len(set1), len(set1 - set2 - set3)))
-        v.get_label_by_id("010").set_text(get_label(len(set2), len(set2 - set1 - set3)))
-        v.get_label_by_id("001").set_text(get_label(len(set3), len(set3 - set1 - set2)))
-        v.get_label_by_id("110").set_text(
-            get_label(len(set1 | set2), len(set1 & set2 - set3))
-        )
-        v.get_label_by_id("101").set_text(
-            get_label(len(set1 | set3), len(set1 & set3 - set2))
-        )
-        v.get_label_by_id("011").set_text(
-            get_label(len(set2 | set3), len(set2 & set3 - set1))
-        )
-        v.get_label_by_id("111").set_text(
-            get_label(len(set1 | set2 | set3), len(set1 & set2 & set3))
-        )
+        v.get_label_by_id("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)))
+        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)))
+        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)))
+        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)))
+        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)))
+        except Exception as e:
+            print(e)
 
         # Apply styles to set labels
         for i, text in enumerate(v.set_labels):
@@ -4387,16 +4600,34 @@ def venn(
             ax.add_patch(ellipse1)
             ax.add_patch(ellipse2)
             ax.add_patch(ellipse3)
+        # Set transparency level
+        for patch in v.patches:
+            if patch:
+                patch.set_alpha(alpha)
+                if "none" in edgecolor or 0 in linewidth:
+                    patch.set_edgecolor("none")
+        return ax
+
+        
+    dict_data = {}
+    for i_list, list_ in enumerate(lists):
+        dict_data[labels[i_list]]={*list_}
+
+    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) 
+
+        return ax
     else:
-        raise ValueError("只支持2或者3个list")
-
-    # Set transparency level
-    for patch in v.patches:
-        if patch:
-            patch.set_alpha(alpha)
-            if "none" in edgecolor or 0 in linewidth:
-                patch.set_edgecolor("none")
-    return ax
+        from venn import pseudovenn
+        cmap=kwargs.pop("cmap","plasma")
+        ax=pseudovenn(dict_data, cmap=cmap,ax=ax,**kwargs)
+
+        return ax
+
+
 
 
 #! subplots, support automatic extend new axis
@@ -4407,6 +4638,7 @@ def subplot(
     sharex=False,
     sharey=False,
     verbose=False,
+    fig=None,
     **kwargs,
 ):
     """
@@ -4435,8 +4667,8 @@ def subplot(
         )
 
     figsize_recommend = f"subplot({rows}, {cols}, figsize={figsize})"
-
-    fig = plt.figure(figsize=figsize, constrained_layout=True)
+    if fig is None:
+        fig = plt.figure(figsize=figsize, constrained_layout=True)
     grid_spec = GridSpec(rows, cols, figure=fig)
     occupied = set()
     row_first_axes = [None] * rows  # Track the first axis in each row (for sharey)
@@ -4502,7 +4734,7 @@ def radar(
     data: pd.DataFrame,
     columns=None,
     ylim=(0, 100),
-    facecolor=get_color(5),
+    facecolor=None,
     edgecolor="none",
     edge_linewidth=0.5,
     fontsize=10,
@@ -4701,7 +4933,7 @@ 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))):#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)
@@ -4740,9 +4972,9 @@ def radar(
         colors = facecolor
     else:
         colors = (
-            get_color(data.shape[0])
+            get_color(data.shape[1])
             if cmap is None
-            else plt.get_cmap(cmap)(np.linspace(0, 1, data.shape[0]))
+            else plt.get_cmap(cmap)(np.linspace(0, 1, data.shape[1]))
         )
 
     # Plot each row with straight lines
@@ -4840,7 +5072,8 @@ def pie(
     pctdistance=0.85,
     labeldistance=1.1,
     kws_wedge={},
-    kws_text={}, 
+    kws_text={},
+    kws_arrow={},
     center=(0, 0),
     radius=1,
     frame=False,
@@ -4850,6 +5083,8 @@ def pie(
     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_legend=True,
     legend_loc="upper right",
     bbox_to_anchor=[1.4, 1.1],
@@ -4859,7 +5094,7 @@ def pie(
     ax=None,
     **kwargs
 ): 
-
+    from adjustText import adjust_text
     if run_once_within(20,reverse=True) and verbose:
         usage_="""usage:
             pie(
@@ -4974,6 +5209,11 @@ def pie(
     # 选择部分数据
     df=data[columns]
 
+    if not isinstance(explode, list):
+        explode=[explode]
+    if explode == [None]:
+        explode=[0]
+
     if width is None:
         if df.shape[1]>1:
             width=1/(df.shape[1]+2)
@@ -5022,10 +5262,9 @@ def pie(
 
         if ax is None: 
             ax=plt.gca()
-        if explode is not None:
-            if len(explode)<len(labels_legend):
-                explode.extend([0]*(len(labels_legend)-len(explode)))
-
+        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}%%"
@@ -5073,19 +5312,37 @@ def pie(
         elif len(result) == 2:
             wedges, texts = result
             autotexts = None 
-        
-        # 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_
-                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
+        #! adjust_text
+        if autotexts or texts:
+            all_texts = []
+            if autotexts and show_value:
+                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), 
+                bbox=kws_bbox if kws_bbox else None,
+                expand=expand_label,
+                fontdict={
+                        "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_
+                    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
     # Customize the legend
     if show_legend:
         ax.legend(
@@ -5098,3 +5355,521 @@ def pie(
         ) 
     ax.set(aspect="equal")
     return ax
+
+def ellipse(
+    data,
+    x=None,
+    y=None,
+    hue=None,
+    n_std=1.5,
+    ax=None,
+    confidence=0.95,
+    annotate_center=False,
+    palette=None,
+    facecolor=None,
+    edgecolor=None,
+    label:bool=True,
+    **kwargs,
+):
+    """
+    Plot advanced ellipses representing covariance for different groups
+    # simulate data:
+                control = np.random.multivariate_normal([0, 0], [[1, 0.5], [0.5, 1]], size=50)
+                patient = np.random.multivariate_normal([2, 1], [[1, -0.3], [-0.3, 1]], size=50)
+                df = pd.DataFrame(
+                    {
+                        "Dim1": np.concatenate([control[:, 0], patient[:, 0]]),
+                        "Dim2": np.concatenate([control[:, 1], patient[:, 1]]),
+                        "Group": ["Control"] * 50 + ["Patient"] * 50,
+                    }
+                )
+                plotxy(
+                    data=df,
+                    x="Dim1",
+                    y="Dim2",
+                    hue="Group",
+                    kind_="scatter",
+                    palette=get_color(8),
+                )
+                ellipse(
+                    data=df,
+                    x="Dim1",
+                    y="Dim2",
+                    hue="Group",
+                    palette=get_color(8),
+                    alpha=0.1,
+                    lw=2,
+                )
+    Parameters:
+        data (DataFrame): Input DataFrame with columns for x, y, and hue.
+        x (str): Column name for x-axis values.
+        y (str): Column name for y-axis values.
+        hue (str, optional): Column name for group labels.
+        n_std (float): Number of standard deviations for the ellipse (overridden if confidence is provided).
+        ax (matplotlib.axes.Axes, optional): Matplotlib Axes object to plot on. Defaults to current Axes.
+        confidence (float, optional): Confidence level (e.g., 0.95 for 95% confidence interval).
+        annotate_center (bool): Whether to annotate the ellipse center (mean).
+        palette (dict or list, optional): A mapping of hues to colors or a list of colors.
+        **kwargs: Additional keyword arguments for the Ellipse patch.
+
+    Returns:
+        list: List of Ellipse objects added to the Axes.
+    """
+    from matplotlib.patches import Ellipse
+    import numpy as np
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+    import pandas as pd
+    from scipy.stats import chi2
+
+    if ax is None:
+        ax = plt.gca()
+
+    # Validate inputs
+    if x is None or y is None:
+        raise ValueError(
+            "Both `x` and `y` must be specified as column names in the DataFrame."
+        )
+    if not isinstance(data, pd.DataFrame):
+        raise ValueError("`data` must be a pandas DataFrame.")
+
+    # Prepare data for hue-based grouping
+    ellipses = []
+    if hue is not None:
+        groups = data[hue].unique()
+        colors = sns.color_palette(palette or "husl", len(groups))
+        color_map = dict(zip(groups, colors))
+    else:
+        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)
+    for group in groups:
+        group_data = data[data[hue] == group] if hue else data
+
+        # Extract x and y columns for the group
+        group_points = group_data[[x, y]].values
+
+        # Compute mean and covariance matrix
+        # # 标准化处理
+        # group_points = group_data[[x, y]].values
+        # group_points -= group_points.mean(axis=0)
+        # group_points /= group_points.std(axis=0)
+
+        cov = np.cov(group_points.T)
+        mean = np.mean(group_points, axis=0)
+
+        # Eigenvalues and eigenvectors
+        eigvals, eigvecs = np.linalg.eigh(cov)
+        order = eigvals.argsort()[::-1]
+        eigvals, eigvecs = eigvals[order], eigvecs[:, order]
+
+        # Rotation angle and ellipse dimensions
+        angle = np.degrees(np.arctan2(*eigvecs[:, 0][::-1]))
+        if confidence:
+            n_std = np.sqrt(chi2.ppf(confidence, df=2))  # Chi-square quantile
+        width, height = 2 * n_std * np.sqrt(eigvals)
+
+        # Create and style the ellipse
+        if facecolor is None:
+            facecolor_ = color_map[group]
+        if edgecolor is None:
+            edgecolor_ = color_map[group]
+        ellipse = Ellipse(
+            xy=mean,
+            width=width,
+            height=height,
+            angle=angle,
+            edgecolor=edgecolor_,
+            facecolor=(facecolor_, alpha), #facecolor_, # only work on facecolor
+            # alpha=alpha,
+            label=group if (hue and label) else None,
+            **kwargs,
+        )
+        ax.add_patch(ellipse)
+        ellipses.append(ellipse)
+
+        # Annotate center
+        if annotate_center:
+            ax.annotate(
+                f"Mean\n({mean[0]:.2f}, {mean[1]:.2f})",
+                xy=mean,
+                xycoords="data",
+                fontsize=10,
+                ha="center",
+                color=ellipse_color,
+                bbox=dict(
+                    boxstyle="round,pad=0.3",
+                    edgecolor="gray",
+                    facecolor="white",
+                    alpha=0.8,
+                ),
+            )
+
+    return ax
+
+def ppi(
+    interactions,
+    player1="preferredName_A",
+    player2="preferredName_B",
+    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
+    facecolor="skyblue",
+    cmap='coolwarm',
+    edgecolor="k",
+    edgelinewidth=1.5,
+    alpha=.5,
+    alphas=(0.1, 1.0),# min and max of alpha
+    marker="o",
+    node_hideticks=True,
+    linecolor="gray",
+    line_cmap='coolwarm',
+    linewidth=1.5,
+    linewidths=(0.5,5),# min and max of linewidth
+    linealpha=1.0,
+    linealphas=(0.1,1.0),# min and max of linealpha
+    linestyle="-",
+    line_arrowstyle='-',
+    fontsize=10,
+    fontcolor="k",
+    ha:str="center",
+    va:str="center",
+    figsize=(12, 10),
+    k_value=0.3,    
+    bgcolor="w",
+    dir_save="./ppi_network.html",
+    physics=True,
+    notebook=False,
+    scale=1,
+    ax=None,
+    **kwargs
+):
+    """
+    Plot a Protein-Protein Interaction (PPI) network with adjustable appearance.
+
+    ppi(
+        interactions_sort.iloc[:1000, :],
+        player1="player1",
+        player2="player2",
+        weight="count",
+        layout="spring",
+        n_layers=13,
+        fontsize=1,
+        n_rank=[5, 10, 20, 40, 80, 80, 80, 80, 80, 80, 80, 80],
+    )
+    """
+    from pyvis.network import Network
+    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="""
+        ppi(
+            interactions,
+            player1="preferredName_A",
+            player2="preferredName_B",
+            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
+            facecolor="skyblue",
+            cmap='coolwarm',
+            edgecolor="k",
+            edgelinewidth=1.5,
+            alpha=.5,
+            alphas=(0.1, 1.0),# min and max of alpha
+            marker="o",
+            node_hideticks=True,
+            linecolor="gray",
+            line_cmap='coolwarm',
+            linewidth=1.5,
+            linewidths=(0.5,5),# min and max of linewidth
+            linealpha=1.0,
+            linealphas=(0.1,1.0),# min and max of linealpha
+            linestyle="-",
+            line_arrowstyle='-',
+            fontsize=10,
+            fontcolor="k",
+            ha:str="center",
+            va:str="center",
+            figsize=(12, 10),
+            k_value=0.3,    
+            bgcolor="w",
+            dir_save="./ppi_network.html",
+            physics=True,
+            notebook=False,
+            scale=1,
+            ax=None,
+            **kwargs
+        ):
+        """
+        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.")
+    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 = {}
+    for k_arg, v_arg in kwargs.items():
+        if "figset" in k_arg:
+            kws_figsets = v_arg
+            kwargs.pop(k_arg, None)
+            break
+
+    # Create a NetworkX graph from the interaction data
+    G = nx.Graph()
+    for _, row in interactions.iterrows():
+        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'):
+        print("facecolor: based on degrees")
+        facecolor = [colormap(norm(deg)) for deg in degrees.values()]  # Use colormap
+    num_nodes = G.number_of_nodes()
+    #* size
+    # Set properties based on degrees
+    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:
+        # 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)
+                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
+    # * facealpha
+    if isinstance(alpha, list):
+        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)
+                    for ea in alpha
+                ]
+            else:
+                # If all alpha values are the same, set them to the average of min and max
+                alpha = [(min_alphas + max_alphas) / 2] * len(alpha)
+        else:
+            # Default to a full opacity if no edges are provided
+            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
+
+    for i, node in enumerate(G.nodes()):
+        net.add_node(
+            node,
+            label=node,
+            size=size[i],
+            color=facecolor[i],
+            alpha=alpha[i],
+            font={"size": fontsize, "color": fontcolor},
+        )
+    print(f'nodes number: {i+1}')
+
+    for edge in G.edges(data=True):
+        net.add_edge(
+            edge[0],
+            edge[1],
+            weight=edge[2]["weight"],
+            color=edgecolor,
+            width=edgelinewidth * edge[2]["weight"],
+        )
+
+    layouts = [
+        "spring",
+        "circular",
+        "kamada_kawai",
+        "random",
+        "shell",
+        "planar",
+        "spiral",
+        "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)
+    elif layout == "circular":
+        pos = nx.circular_layout(G)
+    elif layout == "kamada_kawai":
+        pos = nx.kamada_kawai_layout(G)
+    elif layout == "spectral":
+        pos = nx.spectral_layout(G)
+    elif layout == "random":
+        pos = nx.random_layout(G)
+    elif layout == "shell":
+        pos = nx.shell_layout(G)
+    elif layout == "planar":
+        if nx.check_planarity(G)[0]:
+            pos = nx.planar_layout(G)
+        else:
+            print("Graph is not planar; switching to spring layout.")
+            pos = nx.spring_layout(G, k=k_value)
+    elif layout == "spiral":
+        pos = nx.spiral_layout(G)
+    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
+        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])]
+            else:
+                # 随机打乱剩余节点的顺序
+                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
+
+            # Arrange nodes in a circle for the current rank
+            for i, (node, degree) in enumerate(rank_nodes):
+                angle = (i / len(rank_nodes)) * 2 * np.pi  # Distribute around circle
+                pos[node] = (radius * np.cos(angle), radius * np.sin(angle))
+
+    else:
+        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():
+        net.get_node(node)["x"] = x * scale
+        net.get_node(node)["y"] = y * scale
+
+    # If ax is None, use plt.gca()
+    if ax is None:
+        fig, ax = plt.subplots(1,1,figsize=figsize) 
+    
+    # Draw nodes, edges, and labels with customization options
+    nx.draw_networkx_nodes(
+        G,
+        pos,
+        ax=ax,
+        node_size=size,
+        node_color=facecolor,
+        linewidths=edgelinewidth,
+        edgecolors=edgecolor,
+        alpha=alpha,
+        hide_ticks=node_hideticks,
+        node_shape=marker
+    )
+
+    #* 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)))
+        # Normalize linewidth if it is a list
+        if isinstance(linewidth, list):
+            min_linewidth, max_linewidth = min(linewidth), max(linewidth)
+            vmin, vmax = linewidths  # Use linewidths tuple for min and max values
+            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)
+                    for lw in linewidth
+                ]
+            else:
+                # If all values are the same, set them to a default of the midpoint
+                linewidth = [(vmin + vmax) / 2] * len(linewidth)
+        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):  
+        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)
+        linecolor = [colormap(norm(weight)) for weight in weights]
+    else:
+        linecolor = [linecolor] * G.number_of_edges()
+
+    # * 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)))
+        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)
+                    for ea in linealpha
+                ]
+            else:
+                linealpha = [(min_alpha + max_alpha) / 2] * len(linealpha)
+        else:
+            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, 
+        width=linewidth,
+        style=linestyle,
+        arrowstyle=line_arrowstyle, 
+        alpha=linealpha
+    )
+ 
+    nx.draw_networkx_labels(
+        G, pos, ax=ax, font_size=fontsize, font_color=fontcolor,horizontalalignment=ha,verticalalignment=va
+    )
+    figsets(ax=ax,**kws_figsets)
+    ax.axis("off")
+    if dir_save:
+        if not os.path.basename(dir_save):
+            dir_save="_.html"
+        net.write_html(dir_save)
+        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