py2ls 0.1.9.4__py3-none-any.whl → 0.1.9.6__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, figsave
 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,20 +304,125 @@ 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)):
             ys = ys[~np.isnan(ys)]
-            kde = gaussian_kde(ys, bw_method=opt_v["BandWidth"])
-            min_val, max_val = ys.min(), ys.max()
-            y_vals = np.linspace(min_val, max_val, opt_v["NumPoints"])
-            kde_vals = kde(y_vals)
-            kde_vals = kde_vals / kde_vals.max() * opt_v["x_width"]
-            if label is not None and i < len(label):
-                if len(ys) > 1:
+            if np.all(ys == ys[0]):  # Check if data is constant
+                print(
+                    "Data is constant; KDE cannot be applied. Plotting a flat line instead."
+                )
+                if vertical:
+                    ax.plot(
+                        [x - opt_v["x_width"] / 2, x + opt_v["x_width"] / 2],
+                        [ys[0], ys[0]],
+                        color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
+                        lw=2,
+                        label=label[i] if label else None,
+                    )
+                else:
+                    ax.plot(
+                        [ys[0], ys[0]],
+                        [x - opt_v["x_width"] / 2, x + opt_v["x_width"] / 2],
+                        color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
+                        lw=2,
+                        label=label[i] if label else None,
+                    )
+            else:
+                kde = gaussian_kde(ys, bw_method=opt_v["BandWidth"])
+                min_val, max_val = ys.min(), ys.max()
+                y_vals = np.linspace(min_val, max_val, opt_v["NumPoints"])
+                kde_vals = kde(y_vals)
+                kde_vals = kde_vals / kde_vals.max() * opt_v["x_width"]
+                if label is not None and i < len(label):
+                    if len(ys) > 1:
+                        if "r" in opt_v["loc"].lower():
+                            ax.fill_betweenx(
+                                y_vals,
+                                x,
+                                x + kde_vals,
+                                color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
+                                alpha=opt_v["FaceAlpha"],
+                                edgecolor=opt_v["EdgeColor"],
+                                label=label[i],
+                                lw=opt_v["LineWidth"],
+                                hatch=opt_v["hatch"][i % len(opt_v["FaceColor"])],
+                            )
+                        elif (
+                            "l" in opt_v["loc"].lower()
+                            and not "f" in opt_v["loc"].lower()
+                        ):
+                            ax.fill_betweenx(
+                                y_vals,
+                                x - kde_vals,
+                                x,
+                                color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
+                                alpha=opt_v["FaceAlpha"],
+                                edgecolor=opt_v["EdgeColor"],
+                                label=label[i],
+                                lw=opt_v["LineWidth"],
+                                hatch=opt_v["hatch"][i % len(opt_v["FaceColor"])],
+                            )
+                        elif (
+                            "o" in opt_v["loc"].lower()
+                            or "both" in opt_v["loc"].lower()
+                        ):
+                            ax.fill_betweenx(
+                                y_vals,
+                                x - kde_vals,
+                                x + kde_vals,
+                                color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
+                                alpha=opt_v["FaceAlpha"],
+                                edgecolor=opt_v["EdgeColor"],
+                                label=label[i],
+                                lw=opt_v["LineWidth"],
+                                hatch=opt_v["hatch"][i % len(opt_v["FaceColor"])],
+                            )
+                        elif "i" in opt_v["loc"].lower():
+                            if i % 2 == 1:  # odd number
+                                ax.fill_betweenx(
+                                    y_vals,
+                                    x - kde_vals,
+                                    x,
+                                    color=opt_v["FaceColor"][
+                                        i % len(opt_v["FaceColor"])
+                                    ],
+                                    alpha=opt_v["FaceAlpha"],
+                                    edgecolor=opt_v["EdgeColor"],
+                                    label=label[i],
+                                    lw=opt_v["LineWidth"],
+                                    hatch=opt_v["hatch"][i % len(opt_v["FaceColor"])],
+                                )
+                            else:
+                                ax.fill_betweenx(
+                                    y_vals,
+                                    x,
+                                    x + kde_vals,
+                                    color=opt_v["FaceColor"][
+                                        i % len(opt_v["FaceColor"])
+                                    ],
+                                    alpha=opt_v["FaceAlpha"],
+                                    edgecolor=opt_v["EdgeColor"],
+                                    label=label[i],
+                                    lw=opt_v["LineWidth"],
+                                    hatch=opt_v["hatch"][i % len(opt_v["FaceColor"])],
+                                )
+                        elif "f" in opt_v["loc"].lower():
+                            ax.fill_betweenx(
+                                y_vals,
+                                x - kde_vals,
+                                x + kde_vals,
+                                color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
+                                alpha=opt_v["FaceAlpha"],
+                                edgecolor=opt_v["EdgeColor"],
+                                label=label[i],
+                                lw=opt_v["LineWidth"],
+                                hatch=opt_v["hatch"][i % len(opt_v["FaceColor"])],
+                            )
+                else:
                     if "r" in opt_v["loc"].lower():
                         ax.fill_betweenx(
                             y_vals,
@@ -280,7 +431,8 @@ def catplot(data, *args, **kwargs):
                             color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
                             alpha=opt_v["FaceAlpha"],
                             edgecolor=opt_v["EdgeColor"],
-                            label=label[i],
+                            lw=opt_v["LineWidth"],
+                            hatch=opt_v["hatch"][i % len(opt_v["FaceColor"])],
                         )
                     elif (
                         "l" in opt_v["loc"].lower() and not "f" in opt_v["loc"].lower()
@@ -292,7 +444,8 @@ def catplot(data, *args, **kwargs):
                             color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
                             alpha=opt_v["FaceAlpha"],
                             edgecolor=opt_v["EdgeColor"],
-                            label=label[i],
+                            lw=opt_v["LineWidth"],
+                            hatch=opt_v["hatch"][i % len(opt_v["FaceColor"])],
                         )
                     elif "o" in opt_v["loc"].lower() or "both" in opt_v["loc"].lower():
                         ax.fill_betweenx(
@@ -302,7 +455,8 @@ def catplot(data, *args, **kwargs):
                             color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
                             alpha=opt_v["FaceAlpha"],
                             edgecolor=opt_v["EdgeColor"],
-                            label=label[i],
+                            lw=opt_v["LineWidth"],
+                            hatch=opt_v["hatch"][i % len(opt_v["FaceColor"])],
                         )
                     elif "i" in opt_v["loc"].lower():
                         if i % 2 == 1:  # odd number
@@ -313,7 +467,8 @@ def catplot(data, *args, **kwargs):
                                 color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
                                 alpha=opt_v["FaceAlpha"],
                                 edgecolor=opt_v["EdgeColor"],
-                                label=label[i],
+                                lw=opt_v["LineWidth"],
+                                hatch=opt_v["hatch"][i % len(opt_v["FaceColor"])],
                             )
                         else:
                             ax.fill_betweenx(
@@ -323,7 +478,8 @@ def catplot(data, *args, **kwargs):
                                 color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
                                 alpha=opt_v["FaceAlpha"],
                                 edgecolor=opt_v["EdgeColor"],
-                                label=label[i],
+                                lw=opt_v["LineWidth"],
+                                hatch=opt_v["hatch"][i % len(opt_v["FaceColor"])],
                             )
                     elif "f" in opt_v["loc"].lower():
                         ax.fill_betweenx(
@@ -333,68 +489,162 @@ def catplot(data, *args, **kwargs):
                             color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
                             alpha=opt_v["FaceAlpha"],
                             edgecolor=opt_v["EdgeColor"],
-                            label=label[i],
+                            lw=opt_v["LineWidth"],
+                            hatch=opt_v["hatch"][i % len(opt_v["FaceColor"])],
                         )
-            else:
-                if "r" in opt_v["loc"].lower():
-                    ax.fill_betweenx(
-                        y_vals,
-                        x,
-                        x + kde_vals,
-                        color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
-                        alpha=opt_v["FaceAlpha"],
-                        edgecolor=opt_v["EdgeColor"],
-                    )
-                elif "l" in opt_v["loc"].lower() and not "f" in opt_v["loc"].lower():
-                    ax.fill_betweenx(
-                        y_vals,
-                        x - kde_vals,
-                        x,
-                        color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
-                        alpha=opt_v["FaceAlpha"],
-                        edgecolor=opt_v["EdgeColor"],
-                    )
-                elif "o" in opt_v["loc"].lower() or "both" in opt_v["loc"].lower():
-                    ax.fill_betweenx(
-                        y_vals,
-                        x - kde_vals,
-                        x + kde_vals,
-                        color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
-                        alpha=opt_v["FaceAlpha"],
-                        edgecolor=opt_v["EdgeColor"],
-                    )
-                elif "i" in opt_v["loc"].lower():
-                    if i % 2 == 1:  # odd number
-                        ax.fill_betweenx(
-                            y_vals,
-                            x - kde_vals,
-                            x,
-                            color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
-                            alpha=opt_v["FaceAlpha"],
-                            edgecolor=opt_v["EdgeColor"],
-                        )
-                    else:
-                        ax.fill_betweenx(
-                            y_vals,
-                            x,
-                            x + kde_vals,
-                            color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
-                            alpha=opt_v["FaceAlpha"],
-                            edgecolor=opt_v["EdgeColor"],
-                        )
-                elif "f" in opt_v["loc"].lower():
-                    ax.fill_betweenx(
-                        y_vals,
-                        x - kde_vals,
-                        x + kde_vals,
-                        color=opt_v["FaceColor"][i % len(opt_v["FaceColor"])],
-                        alpha=opt_v["FaceAlpha"],
-                        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 +698,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
@@ -469,10 +721,9 @@ def catplot(data, *args, **kwargs):
 
     ax = kwargs.get("ax", None)
     col = kwargs.get("col", None)
+    report = kwargs.get("report", True)
+    vertical = kwargs.get("vertical", True)
     if not col:
-        if "ax" not in locals() or ax is None:
-            ax = plt.gca()
-
         kw_figsets = kwargs.get("figsets", None)
         # check the data type
         if isinstance(data, pd.DataFrame):
@@ -608,15 +859,20 @@ 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}'")
 
         color_custom = kwargs.get("c", default_colors)
         if not isinstance(color_custom, list):
@@ -631,7 +887,6 @@ def catplot(data, *args, **kwargs):
 
         # export setting
         opt.setdefault("style", {})
-        opt["style"].setdefault("export", None)
         opt.setdefault("layer", ["b", "bx", "e", "v", "s", "l"])
 
         opt.setdefault("b", {})
@@ -644,18 +899,20 @@ def catplot(data, *args, **kwargs):
         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", color_custom)
@@ -664,22 +921,24 @@ def catplot(data, *args, **kwargs):
         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)
@@ -694,11 +953,13 @@ def catplot(data, *args, **kwargs):
         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')
@@ -730,16 +991,44 @@ 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("LineWidth", 0.5)
         opt["v"].setdefault("FaceColor", color_custom)
-        opt["v"].setdefault("FaceAlpha", 0.3)
+        opt["v"].setdefault("FaceAlpha", 1)
         opt["v"].setdefault("BandWidth", "scott")
         opt["v"].setdefault("Function", "pdf")
         opt["v"].setdefault("Kernel", "gau")
+        opt["v"].setdefault("hatch", None)
         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
 
@@ -753,8 +1042,13 @@ def catplot(data, *args, **kwargs):
             xloc = np.array(opt["loc"]["xloc"])
         else:
             xloc = opt["loc"]["xloc"]
-        layers = sort_catplot_layers(opt["layer"])
+        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:
@@ -792,23 +1086,37 @@ 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 len(xticklabels) >= 1:
                 if hue is None:
                     add_asterisks(
-                        ax, res, xticks_x_loc, xticklabels, y_loc=np.max(data)
+                        ax,
+                        res,
+                        xticks_x_loc,
+                        xticklabels,
+                        y_loc=np.max(data),
+                        report_go=report,
                     )
                 else:  # hue is not None
                     ihue = 1
@@ -840,6 +1148,7 @@ def catplot(data, *args, **kwargs):
                                 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
@@ -850,7 +1159,12 @@ def catplot(data, *args, **kwargs):
                     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])
+                        ax,
+                        res[1],
+                        xticks_x_loc,
+                        xticklabels,
+                        y_loc=np.max([x1, x2]),
+                        report_go=report,
                     )
                 elif isinstance(res, pd.DataFrame):
                     display(res)
@@ -858,7 +1172,12 @@ def catplot(data, *args, **kwargs):
                     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])
+                        ax,
+                        res,
+                        xticks_x_loc,
+                        xticklabels,
+                        y_loc=np.max([x1, x2]),
+                        report_go=report,
                     )
 
         style_export = kwargs.get("style_export", None)
@@ -1294,6 +1613,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)
@@ -1343,6 +1664,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 = [
@@ -1354,7 +1677,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
@@ -1721,6 +2075,7 @@ def add_asterisks(ax, res, xticks_x_loc, xticklabels, **kwargs_funcstars):
             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()
@@ -1743,6 +2098,32 @@ def add_asterisks(ax, res, xticks_x_loc, xticklabels, **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[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]
@@ -1763,3 +2144,38 @@ def add_asterisks(ax, res, xticks_x_loc, xticklabels, **kwargs_funcstars):
                 pval=pval_groups,
                 **kwargs_funcstars,
             )
+
+
+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",
+        )