py2ls 0.1.9.3__py3-none-any.whl → 0.1.9.5__py3-none-any.whl

py2ls/plot.py

@@ -9,7 +9,8 @@ import matplotlib.ticker as tck
 from cycler import cycler
 import logging
 import os
-from .ips import fsave, fload, mkdir
+
+from .ips import fsave, fload, mkdir, listdir
 from .stats import *
 
 # Suppress INFO messages from fontTools
@@ -28,8 +29,25 @@ def catplot(data, *args, **kwargs):
     """
 
     def plot_bars(data, data_m, opt_b, xloc, ax, label=None):
+        if "l" in opt_b["loc"]:
+            xloc_s = xloc - opt_b["x_dist"]
+        elif "r" in opt_b["loc"]:
+            xloc_s = xloc + opt_b["x_dist"]
+        elif "i" in opt_b["loc"]:
+            xloc_s = xloc
+            xloc_s[:, 0] += opt_b["x_dist"]
+            xloc_s[:, -1] -= opt_b["x_dist"]
+        elif "o" in opt_b["loc"]:
+            xloc_s = xloc
+            xloc_s[:, 0] -= opt_b["x_dist"]
+            xloc_s[:, -1] += opt_b["x_dist"]
+        elif "c" in opt_b["loc"] or "m" in opt_b["loc"]:
+            xloc_s = xloc
+        else:
+            xloc_s = xloc
+
         bar_positions = get_positions(
-            xloc, opt_b["loc"], opt_b["x_width"], data.shape[0]
+            xloc_s, opt_b["loc"], opt_b["x_width"], data.shape[0]
         )
         bar_positions = np.nanmean(bar_positions, axis=0)
         for i, (x, y) in enumerate(zip(bar_positions, data_m)):
@@ -60,12 +78,22 @@ def catplot(data, *args, **kwargs):
 
     def plot_errors(data, data_m, opt_e, xloc, ax, label=None):
         error_positions = get_positions(
-            xloc, opt_e["loc"], opt_e["x_width"], data.shape[0]
+            xloc, opt_e["loc"], opt_e["x_dist"], data.shape[0]
         )
         error_positions = np.nanmean(error_positions, axis=0)
         errors = np.nanstd(data, axis=0, ddof=1)
         if opt_e["error"] == "sem":
             errors /= np.sqrt(np.sum(~np.isnan(data), axis=0))
+        if opt_e["LineStyle"] != "none":
+            # draw lines
+            ax.plot(
+                error_positions,
+                data_m,
+                color=opt_e["LineColor"],
+                linestyle=opt_e["LineStyle"],
+                linewidth=opt_e["LineWidth"],
+                alpha=opt_e["LineAlpha"],
+            )
 
         if not isinstance(opt_e["FaceColor"], list):
             opt_e["FaceColor"] = [opt_e["FaceColor"]]
@@ -144,8 +172,25 @@ def catplot(data, *args, **kwargs):
                     )
 
     def plot_scatter(data, opt_s, xloc, ax, label=None):
+        if "l" in opt_s["loc"]:
+            xloc_s = xloc - opt_s["x_dist"]
+        elif "r" in opt_s["loc"]:
+            xloc_s = xloc + opt_s["x_dist"]
+        elif "i" in opt_s["loc"]:
+            xloc_s = xloc
+            xloc_s[:, 0] += opt_s["x_dist"]
+            xloc_s[:, -1] -= opt_s["x_dist"]
+        elif "o" in opt_s["loc"]:
+            xloc_s = xloc
+            xloc_s[:, 0] -= opt_s["x_dist"]
+            xloc_s[:, -1] += opt_s["x_dist"]
+        elif "c" in opt_s["loc"] or "m" in opt_s["loc"]:
+            xloc_s = xloc
+        else:
+            xloc_s = xloc
+
         scatter_positions = get_positions(
-            xloc, opt_s["loc"], opt_s["x_width"], data.shape[0]
+            xloc_s, opt_s["loc"], opt_s["x_width"], data.shape[0]
         )
         for i, (x, y) in enumerate(zip(scatter_positions.T, data.T)):
             color = to_rgba(opt_s["FaceColor"][i % len(opt_s["FaceColor"])])
@@ -177,17 +222,17 @@ def catplot(data, *args, **kwargs):
 
     def plot_boxplot(data, bx_opt, xloc, ax, label=None):
         if "l" in bx_opt["loc"]:
-            X_bx = xloc - bx_opt["x_width"]
+            X_bx = xloc - bx_opt["x_dist"]
         elif "r" in bx_opt["loc"]:
-            X_bx = xloc + bx_opt["x_width"]
+            X_bx = xloc + bx_opt["x_dist"]
         elif "i" in bx_opt["loc"]:
             X_bx = xloc
-            X_bx[:, 0] += bx_opt["x_width"]
-            X_bx[:, -1] -= bx_opt["x_width"]
+            X_bx[:, 0] += bx_opt["x_dist"]
+            X_bx[:, -1] -= bx_opt["x_dist"]
         elif "o" in bx_opt["loc"]:
             X_bx = xloc
-            X_bx[:, 0] -= bx_opt["x_width"]
-            X_bx[:, -1] += bx_opt["x_width"]
+            X_bx[:, 0] -= bx_opt["x_dist"]
+            X_bx[:, -1] += bx_opt["x_dist"]
         elif "c" in bx_opt["loc"] or "m" in bx_opt["loc"]:
             X_bx = xloc
         else:
@@ -196,7 +241,8 @@ def catplot(data, *args, **kwargs):
         boxprops = dict(color=bx_opt["EdgeColor"], linewidth=bx_opt["BoxLineWidth"])
         flierprops = dict(
             marker=bx_opt["OutlierMarker"],
-            markerfacecolor=bx_opt["OutlierColor"],
+            markerfacecolor=bx_opt["OutlierFaceColor"],
+            markeredgecolor=bx_opt["OutlierEdgeColor"],
             markersize=bx_opt["OutlierSize"],
         )
         whiskerprops = dict(
@@ -258,9 +304,9 @@ def catplot(data, *args, **kwargs):
         if bx_opt["MedianLineTop"]:
             ax.set_children(ax.get_children()[::-1])  # move median line forward
 
-    def plot_violin(data, opt_v, xloc, ax, label=None):
+    def plot_violin(data, opt_v, xloc, ax, label=None, vertical=True):
         violin_positions = get_positions(
-            xloc, opt_v["loc"], opt_v["x_width"], data.shape[0]
+            xloc, opt_v["loc"], opt_v["x_dist"], data.shape[0]
         )
         violin_positions = np.nanmean(violin_positions, axis=0)
         for i, (x, ys) in enumerate(zip(violin_positions, data.T)):
@@ -392,9 +438,158 @@ def catplot(data, *args, **kwargs):
                         edgecolor=opt_v["EdgeColor"],
                     )
 
+    def plot_ridgeplot(data, x, y, opt_r, **kwargs_figsets):
+        # in the sns.FacetGrid class, the 'hue' argument is the one that is the one that will be represented by colors with 'palette'
+        if opt_r["column4color"] is None:
+            column4color = x
+        else:
+            column4color = opt_r["column4color"]
+
+        if opt_r["row_labels"] is None:
+            opt_r["row_labels"] = data[x].unique().tolist()
+
+        if isinstance(opt_r["FaceColor"], str):
+            opt_r["FaceColor"] = [opt_r["FaceColor"]]
+        if len(opt_r["FaceColor"]) == 1:
+            opt_r["FaceColor"] = np.tile(
+                opt_r["FaceColor"], [1, len(opt_r["row_labels"])]
+            )[0]
+        if len(opt_r["FaceColor"]) > len(opt_r["row_labels"]):
+            opt_r["FaceColor"] = opt_r["FaceColor"][: len(opt_r["row_labels"])]
+
+        g = sns.FacetGrid(
+            data=data,
+            row=x,
+            hue=column4color,
+            aspect=opt_r["aspect"],
+            height=opt_r["subplot_height"],
+            palette=opt_r["FaceColor"],
+        )
+
+        # kdeplot
+        g.map(
+            sns.kdeplot,
+            y,
+            bw_adjust=opt_r["bw_adjust"],
+            clip_on=opt_r["clip"],
+            fill=opt_r["fill"],
+            alpha=opt_r["FaceAlpha"],
+            linewidth=opt_r["EdgeLineWidth"],
+        )
+
+        # edge / line of kdeplot
+        if opt_r["EdgeColor"] is not None:
+            g.map(
+                sns.kdeplot,
+                y,
+                bw_adjust=opt_r["bw_adjust"],
+                clip_on=opt_r["clip"],
+                color=opt_r["EdgeColor"],
+                lw=opt_r["EdgeLineWidth"],
+            )
+        else:
+            g.map(
+                sns.kdeplot,
+                y,
+                bw_adjust=opt_r["bw_adjust"],
+                clip_on=opt_r["clip"],
+                color=opt_r["EdgeColor"],
+                lw=opt_r["EdgeLineWidth"],
+            )
+
+        # add a horizontal line
+        if opt_r["xLineColor"] is not None:
+            g.map(
+                plt.axhline,
+                y=0,
+                lw=opt_r["xLineWidth"],
+                clip_on=opt_r["clip"],
+                color=opt_r["xLineColor"],
+            )
+        else:
+            g.map(
+                plt.axhline,
+                y=0,
+                lw=opt_r["xLineWidth"],
+                clip_on=opt_r["clip"],
+            )
+
+        if isinstance(opt_r["color_row_label"], str):
+            opt_r["color_row_label"] = [opt_r["color_row_label"]]
+        if len(opt_r["color_row_label"]) == 1:
+            opt_r["color_row_label"] = np.tile(
+                opt_r["color_row_label"], [1, len(opt_r["row_labels"])]
+            )[0]
+
+        # loop over the FacetGrid figure axes (g.axes.flat)
+        for i, ax in enumerate(g.axes.flat):
+            if kwargs_figsets.get("xlim", False):
+                ax.set_xlim(kwargs_figsets.get("xlim", False))
+            if kwargs_figsets.get("xlim", False):
+                ax.set_ylim(kwargs_figsets.get("ylim", False))
+            if i == 0:
+                row_x = opt_r["row_label_loc_xscale"] * np.abs(
+                    np.diff(ax.get_xlim())
+                ) + np.min(ax.get_xlim())
+                row_y = opt_r["row_label_loc_yscale"] * np.abs(
+                    np.diff(ax.get_ylim())
+                ) + np.min(ax.get_ylim())
+                ax.set_title(kwargs_figsets.get("title", ""))
+            ax.text(
+                row_x,
+                row_y,
+                opt_r["row_labels"][i],
+                fontweight=opt_r["fontweight"],
+                fontsize=opt_r["fontsize"],
+                color=opt_r["color_row_label"][i],
+            )
+            figsets(**kwargs_figsets)
+
+        # we use matplotlib.Figure.subplots_adjust() function to get the subplots to overlap
+        g.fig.subplots_adjust(hspace=opt_r["subplot_hspace"])
+
+        # eventually we remove axes titles, yticks and spines
+        g.set_titles("")
+        g.set(yticks=[])
+        g.set(ylabel=opt_r["subplot_ylabel"])
+        # if kwargs_figsets:
+        #     g.set(**kwargs_figsets)
+        if kwargs_figsets.get("xlim", False):
+            g.set(xlim=kwargs_figsets.get("xlim", False))
+        g.despine(bottom=True, left=True)
+
+        plt.setp(
+            ax.get_xticklabels(),
+            fontsize=opt_r["fontsize"],
+            fontweight=opt_r["fontweight"],
+        )
+        # if opt_r["ylabel"] is None:
+        #     opt_r["ylabel"] = y
+        # plt.xlabel(
+        #     opt_r["ylabel"], fontweight=opt_r["fontweight"], fontsize=opt_r["fontsize"]
+        # )
+        return g, opt_r
+
     def plot_lines(data, opt_l, opt_s, ax):
+        if "l" in opt_s["loc"]:
+            xloc_s = xloc - opt_s["x_dist"]
+        elif "r" in opt_s["loc"]:
+            xloc_s = xloc + opt_s["x_dist"]
+        elif "i" in opt_s["loc"]:
+            xloc_s = xloc
+            xloc_s[:, 0] += opt_s["x_dist"]
+            xloc_s[:, -1] -= opt_s["x_dist"]
+        elif "o" in opt_s["loc"]:
+            xloc_s = xloc
+            xloc_s[:, 0] -= opt_s["x_dist"]
+            xloc_s[:, -1] += opt_s["x_dist"]
+        elif "c" in opt_s["loc"] or "m" in opt_s["loc"]:
+            xloc_s = xloc
+        else:
+            xloc_s = xloc
+
         scatter_positions = get_positions(
-            xloc, opt_s["loc"], opt_s["x_width"], data.shape[0]
+            xloc_s, opt_s["loc"], opt_s["x_width"], data.shape[0]
         )
         for incol in range(data.shape[1] - 1):
             for irow in range(data.shape[0]):
@@ -448,6 +643,8 @@ def catplot(data, *args, **kwargs):
         """
         sort layers
         """
+        if "r" in full_order:
+            return ["r"]
         # Ensure custom_order is a list of strings
         custom_order = [str(layer) for layer in custom_order]
         j = 1
@@ -468,11 +665,10 @@ def catplot(data, *args, **kwargs):
         # full_order = sort_catplot_layers(custom_order)
 
     ax = kwargs.get("ax", None)
-    if "ax" not in locals() or ax is None:
-        ax = plt.gca()
     col = kwargs.get("col", None)
+    report = kwargs.get("report", True)
+    vertical = kwargs.get("vertical", True)
     if not col:
-        # figsets
         kw_figsets = kwargs.get("figsets", None)
         # check the data type
         if isinstance(data, pd.DataFrame):
@@ -481,6 +677,7 @@ def catplot(data, *args, **kwargs):
             y = kwargs.get("y", None)
             hue = kwargs.get("hue", None)
             data = df2array(data=data, x=x, y=y, hue=hue)
+            y_max_loc = np.max(data, axis=0)
             xticklabels = []
             if hue is not None:
                 # for i in df[x].unique().tolist():
@@ -511,21 +708,16 @@ def catplot(data, *args, **kwargs):
                                     data=df[df[x] == i], dv=y, factor=hue, **stats_param
                                 )
                         elif bool(stats_param):
-                            res_tmp = FuncMultiCmpt(data=df, dv=y, factor=hue)
+                            res_tmp = FuncMultiCmpt(
+                                data=df[df[x] == i], dv=y, factor=hue
+                            )
                         else:
                             res_tmp = "did not work properly"
                         display_output(res_tmp)
-                        xloc_curr = hue_len * (ihue - 1)
-                        # add_asterisks(ax,res_tmp,xticks[xloc_curr:xloc_curr+hue_len],legend_hue)
-                        # res_tmp = [{"x": i, **res_tmp}]
-                        # print("here")
-                        # df_=pd.DataFrame([res_tmp])
-                        # display(df_['pval'][0].tolist()[0])
                         res = pd.concat(
-                            [res, pd.DataFrame([res_tmp])], ignore_index=True
+                            [res, pd.DataFrame([res_tmp])], ignore_index=True, axis=0
                         )
                     ihue += 1
-                display_output(res)
 
             else:
                 # ! stats info
@@ -540,9 +732,22 @@ def catplot(data, *args, **kwargs):
                 res = None
                 if x and stats_param:
                     if isinstance(stats_param, dict):
-                        res = FuncMultiCmpt(data=df, dv=y, factor=x, **stats_param)
+                        if len(xticklabels) > 2:
+                            res = FuncMultiCmpt(data=df, dv=y, factor=x, **stats_param)
+                        else:
+                            res = FuncCmpt(
+                                x1=df.loc[df[x] == xticklabels[0], y].tolist(),
+                                x2=df.loc[df[x] == xticklabels[1], y].tolist(),
+                                **stats_param,
+                            )
                     elif bool(stats_param):
-                        res = FuncMultiCmpt(data=df, dv=y, factor=x)
+                        if len(xticklabels) > 2:
+                            res = FuncMultiCmpt(data=df, dv=y, factor=x)
+                        else:
+                            res = FuncCmpt(
+                                x1=df.loc[df[x] == xticklabels[0], y].tolist(),
+                                x2=df.loc[df[x] == xticklabels[1], y].tolist(),
+                            )
                     else:
                         res = "did not work properly"
                 display_output(res)
@@ -567,11 +772,28 @@ def catplot(data, *args, **kwargs):
                     "xangle": xangle,
                 }
         else:
-            xticks = np.arange(1, data.shape[1] + 1).tolist()
+            if isinstance(data, np.ndarray):
+                df = array2df(data)
+                x = "group"
+                y = "value"
+            xticklabels = []
+            stats_param = kwargs.get("stats", False)
+            for i in df[x].unique().tolist():
+                xticklabels.append(i)
+            xticks = np.arange(1, len(xticklabels) + 1).tolist()
+            xticks_x_loc = np.arange(1, len(xticklabels) + 1).tolist()
+            legend_hue = xticklabels
+            default_colors = get_color(len(xticklabels))
             default_x_width = 0.5
-            default_colors = get_color(len(xticks))
-            legend_hue = None
-            xangle = 0
+            res = None
+            if x and stats_param:
+                if isinstance(stats_param, dict):
+                    res = FuncMultiCmpt(data=df, dv=y, factor=x, **stats_param)
+                elif bool(stats_param):
+                    res = FuncMultiCmpt(data=df, dv=y, factor=x)
+                else:
+                    res = "did not work properly"
+            display_output(res)
 
         # full_order
         opt = kwargs.get("opt", {})
@@ -582,22 +804,27 @@ def catplot(data, *args, **kwargs):
             if "style" in k and "exp" not in k:
                 style_use = v
                 break
-        if style_use:
+        if style_use is not None:
             try:
                 dir_curr_script = os.path.dirname(os.path.abspath(__file__))
                 dir_style = dir_curr_script + "/data/styles/"
-                style_load = fload(dir_style + style_use + ".json")
+                if isinstance(style_use, str):
+                    style_load = fload(dir_style + style_use + ".json")
+                else:
+                    style_load = fload(
+                        listdir(dir_style, "json").path.tolist()[style_use]
+                    )
                 style_load = remove_colors_in_dict(style_load)
                 opt.update(style_load)
             except:
-                print(f"cannot find the style'{style_name}'")
+                print(f"cannot find the style'{style_use}'")
 
-        opt.setdefault("c", default_colors)
-        # if len(opt["c"]) < data.shape[1]:
-        #     additional_colors = plt.cm.winter(
-        #         np.linspace(0, 1, data.shape[1] - len(opt["c"]))
-        #     )
-        #     opt["c"] = np.vstack([opt["c"], additional_colors[:, :3]])
+        color_custom = kwargs.get("c", default_colors)
+        if not isinstance(color_custom, list):
+            color_custom = list(color_custom)
+        # if len(color_custom) < data.shape[1]:
+        #     color_custom.extend(get_color(data.shape[1]-len(color_custom),cmap='tab20'))
+        opt.setdefault("c", color_custom)
 
         opt.setdefault("loc", {})
         opt["loc"].setdefault("go", 0)
@@ -605,58 +832,58 @@ def catplot(data, *args, **kwargs):
 
         # export setting
         opt.setdefault("style", {})
-        opt["style"].setdefault("export", None)
-        print(opt["style"])
-
-        # opt.setdefault('layer', {})
         opt.setdefault("layer", ["b", "bx", "e", "v", "s", "l"])
 
         opt.setdefault("b", {})
         opt["b"].setdefault("go", 1)
         opt["b"].setdefault("loc", "c")
-        opt["b"].setdefault("FaceColor", opt["c"])
+        opt["b"].setdefault("FaceColor", color_custom)
         opt["b"].setdefault("FaceAlpha", 1)
         opt["b"].setdefault("EdgeColor", "k")
         opt["b"].setdefault("EdgeAlpha", 1)
         opt["b"].setdefault("LineStyle", "-")
         opt["b"].setdefault("LineWidth", 0.8)
         opt["b"].setdefault("x_width", default_x_width)
+        opt["b"].setdefault("x_dist", opt["b"]["x_width"])
         opt["b"].setdefault("ShowBaseLine", "off")
         opt["b"].setdefault("hatch", None)
 
         opt.setdefault("e", {})
         opt["e"].setdefault("go", 1)
         opt["e"].setdefault("loc", "l")
-        opt["e"].setdefault("LineWidth", 1)
+        opt["e"].setdefault("LineWidth", 2)
         opt["e"].setdefault("CapLineWidth", 1)
         opt["e"].setdefault("CapSize", 2)
         opt["e"].setdefault("Marker", "none")
         opt["e"].setdefault("LineStyle", "none")
         opt["e"].setdefault("LineColor", "k")
+        opt["e"].setdefault("LineAlpha", 0.5)
         opt["e"].setdefault("LineJoin", "round")
         opt["e"].setdefault("MarkerSize", "auto")
-        opt["e"].setdefault("FaceColor", opt["c"])
+        opt["e"].setdefault("FaceColor", color_custom)
         opt["e"].setdefault("MarkerEdgeColor", "none")
         opt["e"].setdefault("Visible", True)
         opt["e"].setdefault("Orientation", "vertical")
         opt["e"].setdefault("error", "sem")
         opt["e"].setdefault("x_width", default_x_width / 5)
+        opt["e"].setdefault("x_dist", opt["e"]["x_width"])
         opt["e"].setdefault("cap_dir", "b")
 
         opt.setdefault("s", {})
         opt["s"].setdefault("go", 1)
         opt["s"].setdefault("loc", "r")
-        opt["s"].setdefault("FaceColor", "w")
+        opt["s"].setdefault("FaceColor", color_custom)
         opt["s"].setdefault("cmap", None)
         opt["s"].setdefault("FaceAlpha", 1)
-        opt["s"].setdefault("x_width", default_x_width / 5)
+        opt["s"].setdefault("x_width", default_x_width / 5 * 0.5)
+        opt["s"].setdefault("x_dist", opt["s"]["x_width"])
         opt["s"].setdefault("Marker", "o")
         opt["s"].setdefault("MarkerSize", 15)
         opt["s"].setdefault("LineWidth", 0.8)
         opt["s"].setdefault("MarkerEdgeColor", "k")
 
         opt.setdefault("l", {})
-        opt["l"].setdefault("go", 1)
+        opt["l"].setdefault("go", 0)
         opt["l"].setdefault("LineStyle", "-")
         opt["l"].setdefault("LineColor", "k")
         opt["l"].setdefault("LineWidth", 0.5)
@@ -665,17 +892,19 @@ def catplot(data, *args, **kwargs):
         opt.setdefault("bx", {})
         opt["bx"].setdefault("go", 0)
         opt["bx"].setdefault("loc", "r")
-        opt["bx"].setdefault("FaceColor", opt["c"])
+        opt["bx"].setdefault("FaceColor", color_custom)
         opt["bx"].setdefault("EdgeColor", "k")
         opt["bx"].setdefault("FaceAlpha", 0.85)
         opt["bx"].setdefault("EdgeAlpha", 1)
         opt["bx"].setdefault("LineStyle", "-")
         opt["bx"].setdefault("x_width", default_x_width / 5)
+        opt["bx"].setdefault("x_dist", opt["bx"]["x_width"])
         opt["bx"].setdefault("ShowBaseLine", "off")
         opt["bx"].setdefault("Notch", False)
         opt["bx"].setdefault("Outliers", "on")
         opt["bx"].setdefault("OutlierMarker", "+")
-        opt["bx"].setdefault("OutlierColor", "r")
+        opt["bx"].setdefault("OutlierFaceColor", "r")
+        opt["bx"].setdefault("OutlierEdgeColor", "k")
         opt["bx"].setdefault("OutlierSize", 6)
         # opt['bx'].setdefault('PlotStyle', 'traditional')
         # opt['bx'].setdefault('FactorDirection', 'auto')
@@ -707,16 +936,42 @@ def catplot(data, *args, **kwargs):
         opt.setdefault("v", {})
         opt["v"].setdefault("go", 0)
         opt["v"].setdefault("x_width", 0.3)
+        opt["v"].setdefault("x_dist", opt["v"]["x_width"])
         opt["v"].setdefault("loc", "r")
         opt["v"].setdefault("EdgeColor", "none")
-        opt["v"].setdefault("FaceColor", opt["c"])
-        opt["v"].setdefault("FaceAlpha", 0.3)
+        opt["v"].setdefault("FaceColor", color_custom)
+        opt["v"].setdefault("FaceAlpha", 1)
         opt["v"].setdefault("BandWidth", "scott")
         opt["v"].setdefault("Function", "pdf")
         opt["v"].setdefault("Kernel", "gau")
         opt["v"].setdefault("NumPoints", 500)
         opt["v"].setdefault("BoundaryCorrection", "reflection")
 
+        # ridgeplot
+        opt.setdefault("r", {})
+        opt["r"].setdefault("go", 0)
+        opt["r"].setdefault("bw_adjust", 1)
+        opt["r"].setdefault("clip", False)
+        opt["r"].setdefault("FaceColor", get_color(20))
+        opt["r"].setdefault("FaceAlpha", 1)
+        opt["r"].setdefault("EdgeLineWidth", 1.5)
+        opt["r"].setdefault("fill", True)
+        opt["r"].setdefault("EdgeColor", "none")
+        opt["r"].setdefault("xLineWidth", opt["r"]["EdgeLineWidth"] + 0.5)
+        opt["r"].setdefault("xLineColor", "none")
+        opt["r"].setdefault("aspect", 8)
+        opt["r"].setdefault("subplot_hspace", -0.3)  # overlap subplots
+        opt["r"].setdefault("subplot_height", 0.75)
+        opt["r"].setdefault("subplot_ylabel", "")
+        opt["r"].setdefault("column4color", None)
+        opt["r"].setdefault("row_labels", None)
+        opt["r"].setdefault("row_label_loc_xscale", 0.01)
+        opt["r"].setdefault("row_label_loc_yscale", 0.05)
+        opt["r"].setdefault("fontweight", plt.rcParams["font.weight"])
+        opt["r"].setdefault("fontsize", plt.rcParams["font.size"])
+        opt["r"].setdefault("color_row_label", "k")
+        opt["r"].setdefault("ylabel", None)
+
         data_m = np.nanmean(data, axis=0)
         nr, nc = data.shape
 
@@ -730,19 +985,25 @@ def catplot(data, *args, **kwargs):
             xloc = np.array(opt["loc"]["xloc"])
         else:
             xloc = opt["loc"]["xloc"]
-        layers = sort_catplot_layers(opt["layer"])
-
-        label_which = kwargs.get("label_which", "barplot")
-        if "b" in label_which:
-            legend_which = "b"
-        elif "s" in label_which:
-            legend_which = "s"
-        elif "bx" in label_which:
-            legend_which = "bx"
-        elif "e" in label_which:
-            legend_which = "e"
-        elif "v" in label_which:
-            legend_which = "v"
+        if opt["r"]["go"]:
+            layers = sort_catplot_layers(opt["layer"], "r")
+        else:
+            layers = sort_catplot_layers(opt["layer"])
+
+        if ("ax" not in locals() or ax is None) and not opt["r"]["go"]:
+            ax = plt.gca()
+        label = kwargs.get("label", "bar")
+        if label:
+            if "b" in label:
+                legend_which = "b"
+            elif "s" in label:
+                legend_which = "s"
+            elif "bx" in label:
+                legend_which = "bx"
+            elif "e" in label:
+                legend_which = "e"
+            elif "v" in label:
+                legend_which = "v"
         else:
             legend_which = None
         for layer in layers:
@@ -768,46 +1029,100 @@ def catplot(data, *args, **kwargs):
                     plot_boxplot(data, opt["bx"], xloc, ax, label=None)
             elif layer == "v" and opt["v"]["go"]:
                 if legend_which == "v":
-                    plot_violin(data, opt["v"], xloc, ax, label=legend_hue)
+                    plot_violin(
+                        data, opt["v"], xloc, ax, label=legend_hue, vertical=vertical
+                    )
                 else:
-                    plot_violin(data, opt["v"], xloc, ax, label=None)
+                    plot_violin(data, opt["v"], xloc, ax, vertical=vertical, label=None)
+            elif layer == "r" and opt["r"]["go"]:
+                kwargs_figsets = kwargs.get("figsets", None)
+                if x and y:
+                    if kwargs_figsets:
+                        plot_ridgeplot(df, x, y, opt["r"], **kwargs_figsets)
+                    else:
+                        plot_ridgeplot(df, x, y, opt["r"])
             elif all([layer == "l", opt["l"]["go"], opt["s"]["go"]]):
                 plot_lines(data, opt["l"], opt["s"], ax)
 
-        if kw_figsets is not None:
+        if kw_figsets is not None and not opt["r"]["go"]:
             figsets(ax=ax, **kw_figsets)
         show_legend = kwargs.get("show_legend", True)
-        if show_legend:
+        if show_legend and not opt["r"]["go"]:
             ax.legend()
-
         # ! add asterisks in the plot
         if stats_param:
-            if hue is None:
-                display(res)
-                add_asterisks(ax, res, xticks_x_loc, xticklabels)
-            else:  # hue is not None
-                ihue = 1
-                for i in df[x].unique().tolist():
-                    if hue and stats_param:
-                        if isinstance(stats_param, dict):
-                            if "factor" in stats_param.keys():
-                                res_tmp = FuncMultiCmpt(data=df, dv=y, **stats_param)
-                            else:
+            if len(xticklabels) >= 1:
+                if hue is None:
+                    add_asterisks(
+                        ax,
+                        res,
+                        xticks_x_loc,
+                        xticklabels,
+                        y_loc=np.max(data),
+                        report_go=report,
+                    )
+                else:  # hue is not None
+                    ihue = 1
+                    for i in df[x].unique().tolist():
+                        if stats_param:
+                            if isinstance(stats_param, dict):
+                                if "factor" in stats_param.keys():
+                                    res_tmp = FuncMultiCmpt(
+                                        data=df, dv=y, **stats_param
+                                    )
+                                else:
+                                    res_tmp = FuncMultiCmpt(
+                                        data=df[df[x] == i],
+                                        dv=y,
+                                        factor=hue,
+                                        **stats_param,
+                                    )
+                            elif bool(stats_param):
                                 res_tmp = FuncMultiCmpt(
-                                    data=df[df[x] == i], dv=y, factor=hue, **stats_param
+                                    data=df[df[x] == i], dv=y, factor=hue
                                 )
-                        elif bool(stats_param):
-                            res_tmp = FuncMultiCmpt(data=df, dv=y, factor=hue)
-                        else:
-                            res_tmp = "did not work properly"
-                        xloc_curr = hue_len * (ihue - 1)
-                        add_asterisks(
-                            ax,
-                            res_tmp,
-                            xticks[xloc_curr : xloc_curr + hue_len],
-                            legend_hue,
-                        )
-                    ihue += 1
+                            else:
+                                res_tmp = "did not work properly"
+                            xloc_curr = hue_len * (ihue - 1)
+
+                            add_asterisks(
+                                ax,
+                                res_tmp,
+                                xticks[xloc_curr : xloc_curr + hue_len],
+                                legend_hue,
+                                y_loc=np.max(data),
+                                report_go=report,
+                            )
+                        ihue += 1
+            else:  # 240814: still has some bugs
+                if isinstance(res, dict):
+                    tab_res = pd.DataFrame(res[1], index=[0])
+                    x1 = df.loc[df[x] == xticklabels[0], y].tolist()
+                    x2 = df.loc[df[x] == xticklabels[1], y].tolist()
+                    tab_res[f"{xticklabels[0]}(mean±sem)"] = [str_mean_sem(x1)]
+                    tab_res[f"{xticklabels[1]}(mean±sem)"] = [str_mean_sem(x2)]
+                    add_asterisks(
+                        ax,
+                        res[1],
+                        xticks_x_loc,
+                        xticklabels,
+                        y_loc=np.max([x1, x2]),
+                        report_go=report,
+                    )
+                elif isinstance(res, pd.DataFrame):
+                    display(res)
+                    print("still has some bugs")
+                    x1 = df.loc[df[x] == xticklabels[0], y].tolist()
+                    x2 = df.loc[df[x] == xticklabels[1], y].tolist()
+                    add_asterisks(
+                        ax,
+                        res,
+                        xticks_x_loc,
+                        xticklabels,
+                        y_loc=np.max([x1, x2]),
+                        report_go=report,
+                    )
+
         style_export = kwargs.get("style_export", None)
         if style_export and (style_export != style_use):
             dir_curr_script = os.path.dirname(os.path.abspath(__file__))
@@ -843,6 +1158,11 @@ def get_cmap():
 
 
 def read_mplstyle(style_file):
+    """
+    example usage:
+    style_file = "/ std-colors.mplstyle"
+    style_dict = read_mplstyle(style_file)
+    """
     # Load the style file
     plt.style.use(style_file)
 
@@ -857,11 +1177,6 @@ def read_mplstyle(style_file):
     return style_dict
 
 
-# #example usage:
-# style_file = "/ std-colors.mplstyle"
-# style_dict = read_mplstyle(style_file)
-
-
 def figsets(*args, **kwargs):
     """
     usage:
@@ -937,7 +1252,6 @@ def figsets(*args, **kwargs):
     def set_step_1(ax, key, value):
         if ("fo" in key) and (("size" in key) or ("sz" in key)):
             fontsize = value
-            print(fontsize)
             plt.rcParams.update({"font.size": fontsize})
         # style
         if "st" in key.lower() or "th" in key.lower():
@@ -1183,6 +1497,10 @@ def figsets(*args, **kwargs):
             if legend_kws:
                 # https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.legend.html
                 ax.legend(**legend_kws)
+            else:
+                legend = ax.get_legend()
+                if legend is not None:
+                    legend.remove()
 
     for arg in args:
         if isinstance(arg, matplotlib.axes._axes.Axes):
@@ -1238,6 +1556,8 @@ def get_color(
     by: str = "start",
     alpha: float = 1.0,
     output: str = "hue",
+    *args,
+    **kwargs,
 ):
     def cmap2hex(cmap_name):
         cmap_ = matplotlib.pyplot.get_cmap(cmap_name)
@@ -1287,6 +1607,8 @@ def get_color(
         else:
             return "#{:02X}{:02X}{:02X}".format(r, g, b)
 
+    if cmap == "gray":
+        cmap = "grey"
     # Determine color list based on cmap parameter
     if "aut" in cmap:
         colorlist = [
@@ -1298,7 +1620,38 @@ def get_color(
             "#FF9500",
             "#D57DBE",
         ]
+        by = "start"
+    elif any(["cub" in cmap.lower(), "sns" in cmap.lower()]):
+        if kwargs:
+            colorlist = sns.cubehelix_palette(n, **kwargs)
+        else:
+            colorlist = sns.cubehelix_palette(
+                n, start=0.5, rot=-0.75, light=0.85, dark=0.15, as_cmap=False
+            )
+        colorlist = [matplotlib.colors.rgb2hex(color) for color in colorlist]
+    elif any(["hls" in cmap.lower(), "hsl" in cmap.lower()]):
+        if kwargs:
+            colorlist = sns.hls_palette(n, **kwargs)
+        else:
+            colorlist = sns.hls_palette(n)
+        colorlist = [matplotlib.colors.rgb2hex(color) for color in colorlist]
+    elif any(["col" in cmap.lower(), "pal" in cmap.lower()]):
+        palette, desat, as_cmap = None, None, False
+        if kwargs:
+            for k, v in kwargs.items():
+                if "p" in k:
+                    palette = v
+                elif "d" in k:
+                    desat = v
+                elif "a" in k:
+                    as_cmap = v
+        colorlist = sns.color_palette(
+            palette=palette, n_colors=n, desat=desat, as_cmap=as_cmap
+        )
+        colorlist = [matplotlib.colors.rgb2hex(color) for color in colorlist]
     else:
+        if by == "start":
+            by = "linspace"
         colorlist = cmap2hex(cmap)
 
     # Determine method for generating color list
@@ -1660,30 +2013,112 @@ def remove_colors_in_dict(
 
 
 def add_asterisks(ax, res, xticks_x_loc, xticklabels, **kwargs_funcstars):
-    pval_groups = res["res_tab"]["PR(>F)"].tolist()[0]
-    # print(f"p=:{pval_groups}")
-    # print(f"xticks:{xticks}")
-    # print(f"xticks_x_loc:{xticks_x_loc}")
-    if pval_groups <= 0.05:
-        A_list = res["res_posthoc"]["A"].tolist()
-        B_list = res["res_posthoc"]["B"].tolist()
-        xticklabels_array = np.array(xticklabels)
-        yscal_ = 0.99
-        for A, B, P in zip(
-            res["res_posthoc"]["A"].tolist(),
-            res["res_posthoc"]["B"].tolist(),
-            res["res_posthoc"]["p-unc"].tolist(),
-        ):
-            index_A = np.where(xticklabels_array == A)[0][0]
-            index_B = np.where(xticklabels_array == B)[0][0]
-            print(index_A, A, index_B, B, P)
+    if len(xticklabels) > 2:
+        if isinstance(res, dict):
+            pval_groups = res["res_tab"]["p-unc"].tolist()[0]
+        else:
+            pval_groups = res["res_tab"]["PR(>F)"].tolist()[0]
+        report_go = kwargs_funcstars.get("report_go", False)
+        if pval_groups <= 0.05:
+            A_list = res["res_posthoc"]["A"].tolist()
+            B_list = res["res_posthoc"]["B"].tolist()
+            xticklabels_array = np.array(xticklabels)
+            yscal_ = 0.99
+            for A, B, P in zip(
+                res["res_posthoc"]["A"].tolist(),
+                res["res_posthoc"]["B"].tolist(),
+                res["res_posthoc"]["p-unc"].tolist(),
+            ):
+                index_A = np.where(xticklabels_array == A)[0][0]
+                index_B = np.where(xticklabels_array == B)[0][0]
+                FuncStars(
+                    ax=ax,
+                    x1=xticks_x_loc[index_A],
+                    x2=xticks_x_loc[index_B],
+                    pval=P,
+                    yscale=yscal_,
+                    **kwargs_funcstars,
+                )
+                if P <= 0.05:
+                    yscal_ -= 0.075
+        if report_go:
+            try:
+                if isinstance(res["APA"], list):
+                    APA_str = res["APA"][0]
+                else:
+                    APA_str = res["APA"]
+            except:
+                pass
+
             FuncStars(
                 ax=ax,
-                x1=xticks_x_loc[index_A],
-                x2=xticks_x_loc[index_B],
-                pval=P,
-                yscale=yscal_,
+                x1=(
+                    xticks_x_loc[0] - (xticks_x_loc[-1] - xticks_x_loc[0]) / 3
+                    if xticks_x_loc[0] > 1
+                    else xticks_x_loc[0]
+                ),
+                x2=(
+                    xticks_x_loc[0] - (xticks_x_loc[-1] - xticks_x_loc[0]) / 3
+                    if xticks_x_loc[0] > 1
+                    else xticks_x_loc[0]
+                ),
+                pval=None,
+                report_scale=np.random.uniform(0.7, 0.99),
+                report=APA_str,
+                fontsize_note=8,
+            )
+    else:
+        if isinstance(res, tuple):
+            res = res[1]
+            pval_groups = res["pval"]
+            FuncStars(
+                ax=ax,
+                x1=1,
+                x2=2,
+                pval=pval_groups,
+                **kwargs_funcstars,
+            )
+        else:
+            pval_groups = res["pval"]
+            FuncStars(
+                ax=ax,
+                x1=1,
+                x2=2,
+                pval=pval_groups,
                 **kwargs_funcstars,
             )
-            if P <= 0.05:
-                yscal_ -= 0.1
+
+
+def style_examples(
+    dir_save="/Users/macjianfeng/Dropbox/github/python/py2ls/.venv/lib/python3.12/site-packages/py2ls/data/styles/example",
+):
+    f = listdir(
+        "/Users/macjianfeng/Dropbox/github/python/py2ls/.venv/lib/python3.12/site-packages/py2ls/data/styles/",
+        kind=".json",
+    )
+    display(f.sample(2))
+    # def style_example(dir_save,)
+    # Sample data creation
+    np.random.seed(42)
+    categories = ["A", "B", "C", "D", "E"]
+    data = pd.DataFrame(
+        {
+            "value": np.concatenate(
+                [np.random.normal(loc, 0.4, 100) for loc in range(5)]
+            ),
+            "category": np.repeat(categories, 100),
+        }
+    )
+    for i in range(f.num[0]):
+        plt.figure()
+        _, _ = catplot(
+            data=data,
+            x="category",
+            y="value",
+            style=i,
+            figsets=dict(title=f"style{i+1} or style idx={i}"),
+        )
+        figsave(
+            dir_save,
+            f"{f.name[i]}.pdf",
+        )