py2ls 0.1.8.8__tar.gz → 0.1.9.0__tar.gz

{py2ls-0.1.8.8 → py2ls-0.1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py2ls
-Version: 0.1.8.8
+Version: 0.1.9.0
 Summary: py(thon)2(too)ls
 Author: Jianfeng
 Author-email: Jianfeng.Liu0413@gmail.com

{py2ls-0.1.8.8 → py2ls-0.1.9.0}/py2ls/ips.py

@@ -45,7 +45,8 @@ from langdetect import detect
 from duckduckgo_search import DDGS
 
 from . import netfinder
-from .plot import get_color
+
+# from .plot import get_color
 
 try:
     get_ipython().run_line_magic("load_ext", "autoreload")
@@ -1354,18 +1355,12 @@ def fsave(
 
     def save_json(fpath_fname, var_dict_or_df):
         with open(fpath_fname, "w") as f_json:
-            # Check if var_dict_or_df is a DataFrame
             if isinstance(var_dict_or_df, pd.DataFrame):
-                # Convert DataFrame to a list of dictionaries
                 var_dict_or_df = var_dict_or_df.to_dict(orient="dict")
-
-            # Check if var_dict_or_df is a dictionary
             if isinstance(var_dict_or_df, dict):
-                # Convert NumPy arrays to lists
                 for key, value in var_dict_or_df.items():
                     if isinstance(value, np.ndarray):
                         var_dict_or_df[key] = value.tolist()
-
             # Save the dictionary or list of dictionaries to a JSON file
             json.dump(var_dict_or_df, f_json, indent=4)
 

{py2ls-0.1.8.8 → py2ls-0.1.9.0}/py2ls/plot.py

@@ -8,6 +8,7 @@ import matplotlib
 import matplotlib.ticker as tck
 from cycler import cycler
 import logging
+from .ips import fsave
 
 # Suppress INFO messages from fontTools
 logging.getLogger("fontTools").setLevel(logging.WARNING)
@@ -16,7 +17,10 @@ logging.getLogger("fontTools").setLevel(logging.WARNING)
 def catplot(data, *args, **kwargs):
     """
     catplot(data, opt=None, ax=None)
-
+    The catplot function is designed to provide a flexible way to create various types of
+    categorical plots. It supports multiple plot layers such as bars, error bars, scatter
+    plots, box plots, violin plots, and lines. Each plot type is handled by its own internal
+    function, allowing for separation of concerns and modularity in the design.
     Args:
         data (array): data matrix
     """
@@ -57,7 +61,7 @@ def catplot(data, *args, **kwargs):
             xloc, opt_e["loc"], opt_e["x_width"], data.shape[0]
         )
         error_positions = np.nanmean(error_positions, axis=0)
-        errors = np.nanstd(data, 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))
 
@@ -212,6 +216,9 @@ def catplot(data, *args, **kwargs):
             color=bx_opt["MeanLineColor"],
             linewidth=bx_opt["MeanLineWidth"],
         )
+        # MeanLine or MedianLine only keep only one
+        if bx_opt["MeanLine"]:  # MeanLine has priority
+            bx_opt["MedianLine"] = False
         bxp = ax.boxplot(
             data,
             positions=X_bx,
@@ -231,6 +238,9 @@ def catplot(data, *args, **kwargs):
             widths=bx_opt["x_width"],
             label=label,
         )
+        if not bx_opt["MedianLine"]:
+            for median in bxp["medians"]:
+                median.set_visible(False)
 
         if bx_opt["BoxLineWidth"] < 0.1:
             bx_opt["EdgeColor"] = "none"
@@ -452,260 +462,277 @@ def catplot(data, *args, **kwargs):
         # custom_order = ['s', 'bx', 'e']
         # full_order = sort_catplot_layers(custom_order)
 
-    # figsets
-    kw_figsets = kwargs.get("figsets", None)
-    # check the data type
-    if isinstance(data, pd.DataFrame):
-        df = data.copy()
-        x = kwargs.get("x", None)
-        y = kwargs.get("y", None)
-        hue = kwargs.get("hue", None)
-        data = df2array(data=data, x=x, y=y, hue=hue)
-        xticklabels = []
-        if hue is not None:
-            for i in df[x].unique().tolist():
-                for j in df[hue].unique().tolist():
-                    xticklabels.append(i + "-" + j)
-            x_len = len(df[x].unique().tolist())
-            hue_len = len(df[hue].unique().tolist())
-            xticks = generate_xticks_with_gap(x_len, hue_len)
-            default_x_width = 0.85
-            legend_hue = df[hue].unique().tolist()
+    col = kwargs.get("col", None)
+    if not col:
+        # figsets
+        kw_figsets = kwargs.get("figsets", None)
+        # check the data type
+        if isinstance(data, pd.DataFrame):
+            df = data.copy()
+            x = kwargs.get("x", None)
+            y = kwargs.get("y", None)
+            hue = kwargs.get("hue", None)
+            data = df2array(data=data, x=x, y=y, hue=hue)
+            xticklabels = []
+            if hue is not None:
+                for i in df[x].unique().tolist():
+                    for j in df[hue].unique().tolist():
+                        xticklabels.append(i + "-" + j)
+                x_len = len(df[x].unique().tolist())
+                hue_len = len(df[hue].unique().tolist())
+                xticks = generate_xticks_with_gap(x_len, hue_len)
+                default_x_width = 0.85
+                legend_hue = df[hue].unique().tolist()
+                default_colors = get_color(hue_len)
+            else:
+                for i in df[x].unique().tolist():
+                    xticklabels.append(i)
+                xticks = np.arange(1, len(xticklabels) + 1).tolist()
+                legend_hue = xticklabels
+                default_colors = get_color(len(xticklabels))
+                default_x_width = 0.5
+
+            # when the xticklabels are too long, rotate the labels a bit
+
+            xangle = 30 if max([len(i) for i in xticklabels]) > 5 else 0
+            if kw_figsets is not None:
+                kw_figsets = {
+                    "ylabel": y,
+                    # "xlabel": x,
+                    "xticks": xticks,
+                    "xticklabels": xticklabels,
+                    "xangle": xangle,
+                    **kw_figsets,
+                }
+            else:
+                kw_figsets = {
+                    "ylabel": y,
+                    # "xlabel": x,
+                    "xticks": xticks,
+                    "xticklabels": xticklabels,
+                    "xangle": xangle,
+                }
         else:
-            for i in df[x].unique().tolist():
-                xticklabels.append(i)
-            xticks = np.arange(1, len(xticklabels) + 1)
-            legend_hue = xticklabels
+            xticks = np.arange(1, data.shape[1] + 1).tolist()
             default_x_width = 0.5
-        # when the xticklabels are too long, rotate the labels a bit
-
-        xangle = 30 if max([len(i) for i in xticklabels]) > 5 else 0
-        if kw_figsets is not None:
-            kw_figsets = {
-                "ylabel": y,
-                "xlabel": x,
-                "xticks": xticks,
-                "xticklabels": xticklabels,
-                "xangle": xangle,
-                **kw_figsets,
-            }
+            default_colors = get_color(len(xticks))
+            legend_hue = None
+            xangle = 0
+
+        # full_order
+        opt = kwargs.get("opt", {})
+        ax = kwargs.get("ax", None)
+        if "ax" not in locals() or ax is None:
+            ax = plt.gca()
+        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]])
+
+        opt.setdefault("loc", {})
+        opt["loc"].setdefault("go", 0)
+        opt["loc"].setdefault("xloc", xticks)
+
+        # export setting
+        opt.setdefault("export", {})
+        opt["export"].setdefault("path", None)
+        print(opt["export"])
+
+        # 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("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("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("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("LineJoin", "round")
+        opt["e"].setdefault("MarkerSize", "auto")
+        opt["e"].setdefault("FaceColor", opt["c"])
+        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", opt["b"]["x_width"] / 5)
+        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("cmap", None)
+        opt["s"].setdefault("FaceAlpha", 1)
+        opt["s"].setdefault("x_width", opt["b"]["x_width"] / 5)
+        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("LineStyle", "-")
+        opt["l"].setdefault("LineColor", "k")
+        opt["l"].setdefault("LineWidth", 0.5)
+        opt["l"].setdefault("LineAlpha", 0.5)
+
+        opt.setdefault("bx", {})
+        opt["bx"].setdefault("go", 0)
+        opt["bx"].setdefault("loc", "r")
+        opt["bx"].setdefault("FaceColor", opt["c"])
+        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", 0.2)
+        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("OutlierSize", 6)
+        # opt['bx'].setdefault('PlotStyle', 'traditional')
+        # opt['bx'].setdefault('FactorDirection', 'auto')
+        opt["bx"].setdefault("Whisker", 0.5)
+        opt["bx"].setdefault("Orientation", "vertical")
+        opt["bx"].setdefault("BoxLineWidth", 0.5)
+        opt["bx"].setdefault("FaceColor", "k")
+        opt["bx"].setdefault("WhiskerLineStyle", "-")
+        opt["bx"].setdefault("WhiskerLineColor", "k")
+        opt["bx"].setdefault("WhiskerLineWidth", 0.5)
+        opt["bx"].setdefault("Caps", True)
+        opt["bx"].setdefault("CapLineColor", "k")
+        opt["bx"].setdefault("CapLineWidth", 0.5)
+        opt["bx"].setdefault("CapSize", 0.2)
+        opt["bx"].setdefault("MedianLine", True)
+        opt["bx"].setdefault("MedianLineStyle", "-")
+        opt["bx"].setdefault("MedianStyle", "line")
+        opt["bx"].setdefault("MedianLineColor", "k")
+        opt["bx"].setdefault("MedianLineWidth", 2)
+        opt["bx"].setdefault("MedianLineTop", False)
+        opt["bx"].setdefault("MeanLine", False)
+        opt["bx"].setdefault("showmeans", opt["bx"]["MeanLine"])
+        opt["bx"].setdefault("MeanLineStyle", "-")
+        opt["bx"].setdefault("MeanLineColor", "w")
+        opt["bx"].setdefault("MeanLineWidth", 2)
+
+        # Violin plot options
+        opt.setdefault("v", {})
+        opt["v"].setdefault("go", 0)
+        opt["v"].setdefault("x_width", 0.3)
+        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("BandWidth", "scott")
+        opt["v"].setdefault("Function", "pdf")
+        opt["v"].setdefault("Kernel", "gau")
+        opt["v"].setdefault("NumPoints", 500)
+        opt["v"].setdefault("BoundaryCorrection", "reflection")
+
+        data_m = np.nanmean(data, axis=0)
+        nr, nc = data.shape
+
+        for key in kwargs.keys():
+            if key in opt:
+                if isinstance(kwargs[key], dict):
+                    opt[key].update(kwargs[key])
+                else:
+                    opt[key] = kwargs[key]
+        if isinstance(opt["loc"]["xloc"], list):
+            xloc = np.array(opt["loc"]["xloc"])
         else:
-            kw_figsets = {
-                "ylabel": y,
-                "xlabel": x,
-                "xticks": xticks,
-                "xticklabels": xticklabels,
-                "xangle": xangle,
-            }
-    else:
-        xticks = np.arange(1, data.shape[1] + 1)
-        default_x_width = 0.5
-        xangle = 0
-
-    # full_order
-    opt = kwargs.get("opt", {})
-    ax = kwargs.get("ax", None)
-    if "ax" not in locals() or ax is None:
-        ax = plt.gca()
+            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"
+        else:
+            legend_which = None
 
-    default_colors = (
-        np.array(
-            [
-                [0, 0, 0],
-                [234, 37, 46],
-                [0, 154, 222],
-                [175, 89, 186],
-                [255, 198, 37],
-                [242, 133, 34],
-            ]
-        )
-        / 255.0
-    )
+        for layer in layers:
+            if layer == "b" and opt["b"]["go"]:
+                if legend_which == "b":
+                    plot_bars(data, data_m, opt["b"], xloc, ax, label=legend_hue)
+                else:
+                    plot_bars(data, data_m, opt["b"], xloc, ax, label=None)
+            elif layer == "e" and opt["e"]["go"]:
+                if legend_which == "e":
+                    plot_errors(data, data_m, opt["e"], xloc, ax, label=legend_hue)
+                else:
+                    plot_errors(data, data_m, opt["e"], xloc, ax, label=None)
+            elif layer == "s" and opt["s"]["go"]:
+                if legend_which == "s":
+                    plot_scatter(data, opt["s"], xloc, ax, label=legend_hue)
+                else:
+                    plot_scatter(data, opt["s"], xloc, ax, label=None)
+            elif layer == "bx" and opt["bx"]["go"]:
+                if legend_which == "bx":
+                    plot_boxplot(data, opt["bx"], xloc, ax, label=legend_hue)
+                else:
+                    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)
+                else:
+                    plot_violin(data, opt["v"], xloc, ax, label=None)
+            elif all([layer == "l", opt["l"]["go"], opt["s"]["go"]]):
+                plot_lines(data, opt["l"], opt["s"], ax)
 
-    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]])
-
-    opt.setdefault("loc", {})
-    opt["loc"].setdefault("go", 0)
-    opt["loc"].setdefault("xloc", xticks)
-
-    # export setting
-    opt.setdefault("export", {})
-    opt["export"].setdefault("path", None)
-    print(opt["export"])
-
-    # 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("FaceAlpha", 0.65)
-    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("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("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("LineJoin", "round")
-    opt["e"].setdefault("MarkerSize", "auto")
-    opt["e"].setdefault("FaceColor", opt["c"])
-    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", opt["b"]["x_width"] / 5)
-    opt["e"].setdefault("cap_dir", "b")
-
-    opt.setdefault("s", {})
-    opt["s"].setdefault("go", 1)
-    opt["s"].setdefault("loc", "r")
-    opt["s"].setdefault("FaceColor", opt["c"])
-    opt["s"].setdefault("cmap", None)
-    opt["s"].setdefault("FaceAlpha", 1)
-    opt["s"].setdefault("x_width", opt["b"]["x_width"] / 5)
-    opt["s"].setdefault("Marker", "o")
-    opt["s"].setdefault("MarkerSize", 10)
-    opt["s"].setdefault("LineWidth", 0.5)
-    opt["s"].setdefault("MarkerEdgeColor", "k")
-
-    opt.setdefault("l", {})
-    opt["l"].setdefault("go", 1)
-    opt["l"].setdefault("LineStyle", "-")
-    opt["l"].setdefault("LineColor", "k")
-    opt["l"].setdefault("LineWidth", 0.5)
-    opt["l"].setdefault("LineAlpha", 0.5)
-
-    opt.setdefault("bx", {})
-    opt["bx"].setdefault("go", 0)
-    opt["bx"].setdefault("loc", "r")
-    opt["bx"].setdefault("FaceColor", opt["c"])
-    opt["bx"].setdefault("EdgeColor", "k")
-    opt["bx"].setdefault("FaceAlpha", 0.7)
-    opt["bx"].setdefault("EdgeAlpha", 1)
-    opt["bx"].setdefault("LineStyle", "-")
-    opt["bx"].setdefault("x_width", 0.2)
-    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("OutlierSize", 6)
-    # opt['bx'].setdefault('PlotStyle', 'traditional')
-    # opt['bx'].setdefault('FactorDirection', 'auto')
-    opt["bx"].setdefault("Whisker", 0.5)
-    opt["bx"].setdefault("Orientation", "vertical")
-    opt["bx"].setdefault("BoxLineWidth", 0.5)
-    opt["bx"].setdefault("FaceColor", "k")
-    opt["bx"].setdefault("WhiskerLineStyle", "-")
-    opt["bx"].setdefault("WhiskerLineColor", "k")
-    opt["bx"].setdefault("WhiskerLineWidth", 0.5)
-    opt["bx"].setdefault("Caps", True)
-    opt["bx"].setdefault("CapLineColor", "k")
-    opt["bx"].setdefault("CapLineWidth", 0.5)
-    opt["bx"].setdefault("CapSize", 0.2)
-    opt["bx"].setdefault("MedianLineStyle", "-")
-    opt["bx"].setdefault("MedianStyle", "line")
-    opt["bx"].setdefault("MedianLineColor", "k")
-    opt["bx"].setdefault("MedianLineWidth", 2)
-    opt["bx"].setdefault("MedianLineTop", False)
-    opt["bx"].setdefault("MeanLine", False)
-    opt["bx"].setdefault("showmeans", opt["bx"]["MeanLine"])
-    opt["bx"].setdefault("MeanLineStyle", "-")
-    opt["bx"].setdefault("MeanLineColor", "w")
-    opt["bx"].setdefault("MeanLineWidth", 2)
-
-    # Violin plot options
-    opt.setdefault("v", {})
-    opt["v"].setdefault("go", 0)
-    opt["v"].setdefault("x_width", 0.3)
-    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("BandWidth", "scott")
-    opt["v"].setdefault("Function", "pdf")
-    opt["v"].setdefault("Kernel", "gau")
-    opt["v"].setdefault("NumPoints", 500)
-    opt["v"].setdefault("BoundaryCorrection", "reflection")
-
-    data_m = np.nanmean(data, axis=0)
-    nr, nc = data.shape
-
-    for key in kwargs.keys():
-        if key in opt:
-            if isinstance(kwargs[key], dict):
-                opt[key].update(kwargs[key])
-            else:
-                opt[key] = kwargs[key]
-    if isinstance(opt["loc"]["xloc"], list):
-        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 kw_figsets is not None:
+            figsets(ax=ax, **kw_figsets)
+        show_legend = kwargs.get("show_legend", True)
+        if show_legend:
+            ax.legend()
+        export_style = kwargs.get("export_style", None)
+        if export_style:
+            fsave(export_style, opt)
+        return ax, opt
     else:
-        legend_which = None
-
-    for layer in layers:
-        if layer == "b" and opt["b"]["go"]:
-            if legend_which == "b":
-                plot_bars(data, data_m, opt["b"], xloc, ax, label=legend_hue)
-            else:
-                plot_bars(data, data_m, opt["b"], xloc, ax, label=None)
-        elif layer == "e" and opt["e"]["go"]:
-            if legend_which == "e":
-                plot_errors(data, data_m, opt["e"], xloc, ax, label=legend_hue)
-            else:
-                plot_errors(data, data_m, opt["e"], xloc, ax, label=None)
-        elif layer == "s" and opt["s"]["go"]:
-            if legend_which == "s":
-                plot_scatter(data, opt["s"], xloc, ax, label=legend_hue)
-            else:
-                plot_scatter(data, opt["s"], xloc, ax, label=None)
-        elif layer == "bx" and opt["bx"]["go"]:
-            if legend_which == "bx":
-                plot_boxplot(data, opt["bx"], xloc, ax, label=legend_hue)
-            else:
-                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)
-            else:
-                plot_violin(data, opt["v"], xloc, ax, label=None)
-        elif all([layer == "l", opt["l"]["go"], opt["s"]["go"]]):
-            plot_lines(data, opt["l"], opt["s"], ax)
-
-    if kw_figsets is not None:
-        figsets(ax=ax, **kw_figsets)
-    return ax
+        col_names = data[col].unique().tolist()
+        nrow, ncol = kwargs.get("subplots", [len(col_names), 1])
+        figsize = kwargs.get("figsize", [3 * ncol, 3 * nrow])
+        fig, axs = plt.subplots(nrow, ncol, figsize=figsize, squeeze=False)
+        axs = axs.flatten()
+        key2rm = ["data", "ax", "col", "subplots"]
+        for k2rm in key2rm:
+            if k2rm in kwargs:
+                del kwargs[k2rm]
+        for i, ax in enumerate(axs):
+            # ax = axs[i][0] if len(col_names) > 1 else axs[0]
+            if i < len(col_names):
+                df_sub = data.loc[data[col] == col_names[i]]
+                catplot(ax=ax, data=df_sub, **kwargs)
+                ax.set_title(col_names[i])
+        print(f"Axis layout shape: {axs.shape}")
+        return axs
 
 
 def get_cmap():
@@ -1356,14 +1383,16 @@ def stdshade(ax=None, *args, **kwargs):
         yMean = np.nanmean(y, axis=0)
     if paraStdSem == "sem":
         if smth > 1:
-            wings = savgol_filter(np.nanstd(y, axis=0) / np.sqrt(y.shape[0]), smth, 1)
+            wings = savgol_filter(
+                np.nanstd(y, axis=0, ddof=1) / np.sqrt(y.shape[0]), smth, 1
+            )
         else:
-            wings = np.nanstd(y, axis=0) / np.sqrt(y.shape[0])
+            wings = np.nanstd(y, axis=0, ddof=1) / np.sqrt(y.shape[0])
     elif paraStdSem == "std":
         if smth > 1:
-            wings = savgol_filter(np.nanstd(y, axis=0), smth, 1)
+            wings = savgol_filter(np.nanstd(y, axis=0, ddof=1), smth, 1)
         else:
-            wings = np.nanstd(y, axis=0)
+            wings = np.nanstd(y, axis=0, ddof=1)
 
     # fill_kws = kwargs.get('fill_kws', {})
     # line_kws = kwargs.get('line_kws', {})
@@ -1668,6 +1697,6 @@ def generate_xticks_with_gap(x_len, hue_len):
         for i in range(max(x_len, hue_len), 0, -1)  # i iterates from 3 to 1
     ]
     concatenated_array = np.concatenate(arrays)
-    positive_array = concatenated_array[concatenated_array > 0]
+    positive_array = concatenated_array[concatenated_array > 0].tolist()
 
     return positive_array

{py2ls-0.1.8.8 → py2ls-0.1.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "py2ls"
-version = "0.1.8.8"
+version = "0.1.9.0"
 description = "py(thon)2(too)ls"
 authors = ["Jianfeng <Jianfeng.Liu0413@gmail.com>"]
 readme = "README.md"