py2ls 0.1.8.6__py3-none-any.whl → 0.1.8.8__py3-none-any.whl

py2ls/plot.py

@@ -4,6 +4,9 @@ import pandas as pd
 from matplotlib.colors import to_rgba
 from scipy.stats import gaussian_kde
 
+import matplotlib
+import matplotlib.ticker as tck
+from cycler import cycler
 import logging
 
 # Suppress INFO messages from fontTools
@@ -18,25 +21,38 @@ def catplot(data, *args, **kwargs):
         data (array): data matrix
     """
 
-    def plot_bars(data, data_m, opt_b, xloc, ax):
+    def plot_bars(data, data_m, opt_b, xloc, ax, label=None):
         bar_positions = get_positions(
             xloc, 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)):
             color = to_rgba(opt_b["FaceColor"][i % len(opt_b["FaceColor"])])
-            ax.bar(
-                x,
-                y,
-                width=opt_b["x_width"],
-                color=color,
-                edgecolor=opt_b["EdgeColor"],
-                alpha=opt_b["FaceAlpha"],
-                linewidth=opt_b["LineWidth"],
-                hatch=opt_b["hatch"],
-            )
+            if label is not None and i < len(label):
+                ax.bar(
+                    x,
+                    y,
+                    width=opt_b["x_width"],
+                    color=color,
+                    edgecolor=opt_b["EdgeColor"],
+                    alpha=opt_b["FaceAlpha"],
+                    linewidth=opt_b["LineWidth"],
+                    hatch=opt_b["hatch"],
+                    label=label[i],
+                )
+            else:
+                ax.bar(
+                    x,
+                    y,
+                    width=opt_b["x_width"],
+                    color=color,
+                    edgecolor=opt_b["EdgeColor"],
+                    alpha=opt_b["FaceAlpha"],
+                    linewidth=opt_b["LineWidth"],
+                    hatch=opt_b["hatch"],
+                )
 
-    def plot_errors(data, data_m, opt_e, xloc, ax):
+    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]
         )
@@ -50,59 +66,110 @@ def catplot(data, *args, **kwargs):
         if not isinstance(opt_e["MarkerEdgeColor"], list):
             opt_e["MarkerEdgeColor"] = [opt_e["MarkerEdgeColor"]]
         for i, (x, y, err) in enumerate(zip(error_positions, data_m, errors)):
-            if opt_e["MarkerSize"] == "auto":
-                ax.errorbar(
-                    x,
-                    y,
-                    yerr=err,
-                    fmt=opt_e["Marker"],
-                    ecolor=opt_e["LineColor"],
-                    elinewidth=opt_e["LineWidth"],
-                    lw=opt_e["LineWidth"],
-                    ls=opt_e["LineStyle"],
-                    capsize=opt_e["CapSize"],
-                    capthick=opt_e["CapLineWidth"],
-                    mec=opt_e["MarkerEdgeColor"][i % len(opt_e["MarkerEdgeColor"])],
-                    mfc=opt_e["FaceColor"][i % len(opt_e["FaceColor"])],
-                    visible=opt_e["Visible"],
-                )
+            if label is not None and i < len(label):
+                if opt_e["MarkerSize"] == "auto":
+                    ax.errorbar(
+                        x,
+                        y,
+                        yerr=err,
+                        fmt=opt_e["Marker"],
+                        ecolor=opt_e["LineColor"],
+                        elinewidth=opt_e["LineWidth"],
+                        lw=opt_e["LineWidth"],
+                        ls=opt_e["LineStyle"],
+                        capsize=opt_e["CapSize"],
+                        capthick=opt_e["CapLineWidth"],
+                        mec=opt_e["MarkerEdgeColor"][i % len(opt_e["MarkerEdgeColor"])],
+                        mfc=opt_e["FaceColor"][i % len(opt_e["FaceColor"])],
+                        visible=opt_e["Visible"],
+                        label=label[i],
+                    )
+                else:
+                    ax.errorbar(
+                        x,
+                        y,
+                        yerr=err,
+                        fmt=opt_e["Marker"],
+                        ecolor=opt_e["LineColor"],
+                        elinewidth=opt_e["LineWidth"],
+                        lw=opt_e["LineWidth"],
+                        ls=opt_e["LineStyle"],
+                        capsize=opt_e["CapSize"],
+                        capthick=opt_e["CapLineWidth"],
+                        markersize=opt_e["MarkerSize"],
+                        mec=opt_e["MarkerEdgeColor"][i % len(opt_e["MarkerEdgeColor"])],
+                        mfc=opt_e["FaceColor"][i % len(opt_e["FaceColor"])],
+                        visible=opt_e["Visible"],
+                        label=label[i],
+                    )
             else:
-                ax.errorbar(
-                    x,
-                    y,
-                    yerr=err,
-                    fmt=opt_e["Marker"],
-                    ecolor=opt_e["LineColor"],
-                    elinewidth=opt_e["LineWidth"],
-                    lw=opt_e["LineWidth"],
-                    ls=opt_e["LineStyle"],
-                    capsize=opt_e["CapSize"],
-                    capthick=opt_e["CapLineWidth"],
-                    markersize=opt_e["MarkerSize"],
-                    mec=opt_e["MarkerEdgeColor"][i % len(opt_e["MarkerEdgeColor"])],
-                    mfc=opt_e["FaceColor"][i % len(opt_e["FaceColor"])],
-                    visible=opt_e["Visible"],
-                )
+                if opt_e["MarkerSize"] == "auto":
+                    ax.errorbar(
+                        x,
+                        y,
+                        yerr=err,
+                        fmt=opt_e["Marker"],
+                        ecolor=opt_e["LineColor"],
+                        elinewidth=opt_e["LineWidth"],
+                        lw=opt_e["LineWidth"],
+                        ls=opt_e["LineStyle"],
+                        capsize=opt_e["CapSize"],
+                        capthick=opt_e["CapLineWidth"],
+                        mec=opt_e["MarkerEdgeColor"][i % len(opt_e["MarkerEdgeColor"])],
+                        mfc=opt_e["FaceColor"][i % len(opt_e["FaceColor"])],
+                        visible=opt_e["Visible"],
+                    )
+                else:
+                    ax.errorbar(
+                        x,
+                        y,
+                        yerr=err,
+                        fmt=opt_e["Marker"],
+                        ecolor=opt_e["LineColor"],
+                        elinewidth=opt_e["LineWidth"],
+                        lw=opt_e["LineWidth"],
+                        ls=opt_e["LineStyle"],
+                        capsize=opt_e["CapSize"],
+                        capthick=opt_e["CapLineWidth"],
+                        markersize=opt_e["MarkerSize"],
+                        mec=opt_e["MarkerEdgeColor"][i % len(opt_e["MarkerEdgeColor"])],
+                        mfc=opt_e["FaceColor"][i % len(opt_e["FaceColor"])],
+                        visible=opt_e["Visible"],
+                    )
 
-    def plot_scatter(data, opt_s, xloc, ax):
+    def plot_scatter(data, opt_s, xloc, ax, label=None):
         scatter_positions = get_positions(
             xloc, 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"])])
-            ax.scatter(
-                x,
-                y,
-                color=color,
-                alpha=opt_s["FaceAlpha"],
-                edgecolor=opt_s["MarkerEdgeColor"],
-                s=opt_s["MarkerSize"],
-                marker=opt_s["Marker"],
-                linewidths=opt_s["LineWidth"],
-                cmap=opt_s["cmap"],
-            )
+            if label is not None and i < len(label):
+                ax.scatter(
+                    x,
+                    y,
+                    color=color,
+                    alpha=opt_s["FaceAlpha"],
+                    edgecolor=opt_s["MarkerEdgeColor"],
+                    s=opt_s["MarkerSize"],
+                    marker=opt_s["Marker"],
+                    linewidths=opt_s["LineWidth"],
+                    cmap=opt_s["cmap"],
+                    label=label[i],
+                )
+            else:
+                ax.scatter(
+                    x,
+                    y,
+                    color=color,
+                    alpha=opt_s["FaceAlpha"],
+                    edgecolor=opt_s["MarkerEdgeColor"],
+                    s=opt_s["MarkerSize"],
+                    marker=opt_s["Marker"],
+                    linewidths=opt_s["LineWidth"],
+                    cmap=opt_s["cmap"],
+                )
 
-    def plot_boxplot(data, bx_opt, xloc, ax):
+    def plot_boxplot(data, bx_opt, xloc, ax, label=None):
         if "l" in bx_opt["loc"]:
             X_bx = xloc - bx_opt["x_width"]
         elif "r" in bx_opt["loc"]:
@@ -162,6 +229,7 @@ def catplot(data, *args, **kwargs):
             showmeans=bx_opt["MeanLine"],
             meanprops=meanprops,
             widths=bx_opt["x_width"],
+            label=label,
         )
 
         if bx_opt["BoxLineWidth"] < 0.1:
@@ -175,19 +243,84 @@ 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):
+    def plot_violin(data, opt_v, xloc, ax, label=None):
         violin_positions = get_positions(
             xloc, opt_v["loc"], opt_v["x_width"], 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)]
-            if len(ys) > 1:
-                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"]
+            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],
+                        )
+                    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],
+                        )
+                    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],
+                        )
+                    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],
+                            )
+                        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],
+                            )
+                    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],
+                        )
+            else:
                 if "r" in opt_v["loc"].lower():
                     ax.fill_betweenx(
                         y_vals,
@@ -327,7 +460,7 @@ def catplot(data, *args, **kwargs):
         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).T
+        data = df2array(data=data, x=x, y=y, hue=hue)
         xticklabels = []
         if hue is not None:
             for i in df[x].unique().tolist():
@@ -337,10 +470,12 @@ def catplot(data, *args, **kwargs):
             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()
         else:
             for i in df[x].unique().tolist():
                 xticklabels.append(i)
             xticks = np.arange(1, len(xticklabels) + 1)
+            legend_hue = xticklabels
             default_x_width = 0.5
         # when the xticklabels are too long, rotate the labels a bit
 
@@ -362,6 +497,10 @@ def catplot(data, *args, **kwargs):
                 "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", {})
@@ -520,17 +659,47 @@ def catplot(data, *args, **kwargs):
     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"
+    else:
+        legend_which = None
+
     for layer in layers:
         if layer == "b" and opt["b"]["go"]:
-            plot_bars(data, data_m, opt["b"], xloc, ax)
+            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"]:
-            plot_errors(data, data_m, opt["e"], xloc, ax)
+            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"]:
-            plot_scatter(data, opt["s"], xloc, ax)
+            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"]:
-            plot_boxplot(data, opt["bx"], xloc, ax)
+            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"]:
-            plot_violin(data, opt["v"], xloc, ax)
+            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)
 
@@ -539,98 +708,6 @@ def catplot(data, *args, **kwargs):
     return ax
 
 
-# from py2ls.ips import get_color,figsets
-# opt={}
-# opt = {
-#     'export':{'path':get_cwd()},
-#     'c': get_color(5,cmap='jet',by='linspace'),  # Custom colors for 3 categories
-#     'b': {
-#         'go': 0,
-#         'x_width': 0.85,
-#         'FaceAlpha': 0.7,
-#         'EdgeColor':'none'
-#     },
-#     'e': {
-#         'loc':'r',
-#         'go': 1,
-#         'error': 'sem',
-#         'Marker':'d',
-#         'CapSize': 1,
-#         'LineWidth':1,
-#         'CapLineWidth':8,
-#         'LineStyle':'--',
-#         'MarkerSize':6,
-#         'LineColor':'k',
-#         'FaceColor':get_color(10),
-#         'MarkerEdgeColor':'none',
-#         'Visible':True
-#     },
-#     's': {
-#         'go': 1,
-#         'x_width':0.2,
-#         'loc':'random',
-#         'Marker': 'o',
-#         # 'MarkerSize': 20,
-#         'FaceAlpha': 1,
-#         'FaceColor':'k',
-#         'LineWidth':1
-
-#     },
-#     'bx':{
-#         'go':1,
-#         'FaceAlpha':0.8,
-#         'EdgeColor':'none',
-#         'loc':'c',
-#         'x_width':0.2,
-#         'WhiskerLineWidth':1,
-#         'MedianLineWidth':2,
-#         # 'MedianLineColor':'r',
-#         'OutlierMarker':'+',
-#         'OutlierColor':'r',
-#         'CapSize':.2,
-#         # 'Caps':False,
-#         # 'CapLineColor':'r',
-#         # 'CapLineWidth':8,
-#         # 'MeanLine':True,
-#         # 'FaceColor':['r','g','b','m','c']
-#         },
-#     'v':{
-#         'go':0,
-#         'loc':'r',
-#         'x_width':0.2,
-#         'FaceAlpha':0.51,
-#          },
-#     'l':{
-#         'go':1,
-#         'LineColor':'k'
-#         }
-# }
-# data1 = np.random.rand(10, 5)
-# data2 = np.random.rand(10, 5)
-# fig, axs=plt.subplots(1,2,figsize=(6,2.5))
-# catplot(data1, opt=opt,ax=axs[0])
-# catplot(data2, opt=opt,ax=axs[1])
-# figsets(sp=5,
-#         ax=axs[0],
-#         xticks=np.arange(1,6,1),
-#         xtickslabel=['glua1','glua2','a','b','c'],
-#         xlabel='proteins',
-#         xangle=90,
-#         yticks=np.arange(0,2,0.5),
-#         xlim=[0.75, 5.1],
-#         ticks=dict(pad=1,c='k'))
-
-# figsave("/Users/macjianfeng/Dropbox/Downloads/",'test.pdf')
-
-
-import numpy as np
-import matplotlib
-import matplotlib.pyplot as plt
-import matplotlib.ticker as tck
-import seaborn as sns
-from cycler import cycler
-
-
 def get_cmap():
     return plt.colormaps()
 
@@ -1450,30 +1527,49 @@ def padcat(*args, fill_value=np.nan, axis=1, order="row"):
         The value to use for padding the shorter lists (default is np.nan).
     axis : int, optional
         The axis along which to concatenate (0 for rows, 1 for columns, default is 1).
+    order : str, optional
+        The order for flattening when required: "row" or "column" (default is "row").
 
     Returns:
     np.ndarray
         A 2D array with the input arrays concatenated along the specified axis,
         padded with fill_value where necessary.
     """
-    # Convert all inputs to 1D NumPy arrays
+    # Set the order for processing
     if "ro" in order.lower():
-        order = "C"  # in row
+        order = "C"  # row-major order
     else:
-        order = "F"  # column
-    arrays = [np.asarray(arg).flatten(order=order) for arg in args]
+        order = "F"  # column-major order
+
+    # Process input arrays based on their dimensions
+    processed_arrays = []
+    for arg in args:
+        arr = np.asarray(arg)
+        if arr.ndim == 1:
+            processed_arrays.append(arr)  # Keep 1D arrays as is
+        elif arr.ndim == 2:
+            if axis == 0:
+                # If concatenating along rows, split 2D arrays into 1D arrays row-wise
+                processed_arrays.extend(arr)
+            elif axis == 1:
+                # If concatenating along columns, split 2D arrays into 1D arrays column-wise
+                processed_arrays.extend(arr.T)
+            else:
+                raise ValueError("axis must be 0 or 1")
+        else:
+            raise ValueError("Input arrays must be 1D or 2D")
 
     if axis == 0:
         # Concatenate along rows
-        max_len = max(arr.size for arr in arrays)
-        result = np.full((len(arrays), max_len), fill_value)
-        for i, arr in enumerate(arrays):
+        max_len = max(arr.size for arr in processed_arrays)
+        result = np.full((len(processed_arrays), max_len), fill_value)
+        for i, arr in enumerate(processed_arrays):
             result[i, : arr.size] = arr
     elif axis == 1:
         # Concatenate along columns
-        max_len = max(arr.size for arr in arrays)
-        result = np.full((max_len, len(arrays)), fill_value)
-        for i, arr in enumerate(arrays):
+        max_len = max(arr.size for arr in processed_arrays)
+        result = np.full((max_len, len(processed_arrays)), fill_value)
+        for i, arr in enumerate(processed_arrays):
             result[: arr.size, i] = arr
     else:
         raise ValueError("axis must be 0 or 1")
@@ -1481,49 +1577,77 @@ def padcat(*args, fill_value=np.nan, axis=1, order="row"):
     return result
 
 
-def sort_rows_move_nan(arr):
+# # Example usage:
+# a = [1, np.nan]
+# b = [1, 3, 4, np.nan, 2, np.nan]
+# c = [1, 2, 3, 4, 5, 6, 7, 8, 10]
+# d = padcat(a, b)
+# result1 = padcat(d, c)
+# result2 = padcat(a, b, c)
+# print("Result of padcat(d, c):\n", result1)
+# print("Result of padcat(a, b, c):\n", result2)
+
+
+def sort_rows_move_nan(arr, sort=False):
     # Handle edge cases where all values are NaN
     if np.all(np.isnan(arr)):
         return arr  # Return unchanged if the entire array is NaN
 
-    # Replace NaNs with a temporary large value for sorting
-    temp_value = (
-        np.nanmax(arr[np.isfinite(arr)]) + 1 if np.any(np.isfinite(arr)) else np.inf
-    )
-    arr_no_nan = np.where(np.isnan(arr), temp_value, arr)
-
-    # Sort each row
-    sorted_arr = np.sort(arr_no_nan, axis=1)
+    if sort:
+        # Replace NaNs with a temporary large value for sorting
+        temp_value = (
+            np.nanmax(arr[np.isfinite(arr)]) + 1 if np.any(np.isfinite(arr)) else np.inf
+        )
+        arr_no_nan = np.where(np.isnan(arr), temp_value, arr)
 
-    # Move NaNs to the end
-    result_arr = np.where(sorted_arr == temp_value, np.nan, sorted_arr)
+        # Sort each row
+        sorted_arr = np.sort(arr_no_nan, axis=1)
 
-    # Remove rows that contain only NaNs
+        # Move NaNs to the end
+        result_arr = np.where(sorted_arr == temp_value, np.nan, sorted_arr)
+    else:
+        result_rows = []
+        for row in arr:
+            # Separate non-NaN and NaN values
+            non_nan_values = row[~np.isnan(row)]
+            nan_count = np.isnan(row).sum()
+            # Create a new row with non-NaN values followed by NaNs
+            new_row = np.concatenate([non_nan_values, [np.nan] * nan_count])
+            result_rows.append(new_row)
+        # Convert the list of rows back into a 2D NumPy array
+        result_arr = np.array(result_rows)
+
+    # Remove rows/columns that contain only NaNs
     clean_arr = result_arr[~np.isnan(result_arr).all(axis=1)]
-
-    # Remove columns that contain only NaNs
     clean_arr_ = clean_arr[:, ~np.isnan(clean_arr).all(axis=0)]
 
     return clean_arr_
 
 
-def df2array(data: pd.DataFrame, x, y, hue=None):
+def df2array(data: pd.DataFrame, x, y, hue=None, sort=False):
     if hue is None:
         a = []
-        cat_x = data[x].unique().tolist()
+        if sort:
+            np.sort(data[x].unique().tolist()).tolist()
+        else:
+            cat_x = data[x].unique().tolist()
         for i, x_ in enumerate(cat_x):
             new_ = data.loc[data[x] == x_, y].to_list()
             a = padcat(a, new_, axis=0)
-        return sort_rows_move_nan(a.reshape(2**i, -1))
+        return sort_rows_move_nan(a).T
     else:
         a = []
-        cat_x = data[x].unique().tolist()
-        cat_hue = data[hue].unique().tolist()
+        if sort:
+            cat_x = np.sort(data[x].unique().tolist()).tolist()
+            cat_hue = np.sort(data[hue].unique().tolist()).tolist()
+        else:
+            cat_x = data[x].unique().tolist()
+            cat_hue = data[hue].unique().tolist()
         for i, x_ in enumerate(cat_x):
             for j, hue_ in enumerate(cat_hue):
                 new_ = data.loc[(data[x] == x_) & (data[hue] == hue_), y].to_list()
                 a = padcat(a, new_, axis=0)
-        return sort_rows_move_nan(a.reshape(2 ** ((i + 1) * (j + 1)), -1))
+        return sort_rows_move_nan(a).T
 
 
 def generate_xticks_with_gap(x_len, hue_len):

{py2ls-0.1.8.6.dist-info → py2ls-0.1.8.8.dist-info}/METADATA

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

{py2ls-0.1.8.6.dist-info → py2ls-0.1.8.8.dist-info}/RECORD

@@ -136,12 +136,12 @@ py2ls/export_requirements.py,sha256=x2WgUF0jYKz9GfA1MVKN-MdsM-oQ8yUeC6Ua8oCymio,
 py2ls/freqanalysis.py,sha256=F4218VSPbgL5tnngh6xNCYuNnfR-F_QjECUUxrPYZss,32594
 py2ls/ips.py,sha256=6eNvNwaCDj2jyjter7VPL9oEGB2jS4ge9mSgiIrvZfo,100788
 py2ls/netfinder.py,sha256=OMStrwMAASf1ajlyEfseoaEygo7G5WKBAFRE0LY15Lw,49477
-py2ls/plot.py,sha256=drlrWMUseSqkaTQHeTygypn39SUiovYuvThLQZ1Df_Y,55682
+py2ls/plot.py,sha256=E6cV26ixVa8HFYTsTvaEtc-CgLYvaA7OhPg6S0eBZ2M,62740
 py2ls/setuptools-70.1.0-py3-none-any.whl,sha256=2bi3cUVal8ip86s0SOvgspteEF8SKLukECi-EWmFomc,882588
 py2ls/sleep_events_detectors.py,sha256=bQA3HJqv5qnYKJJEIhCyhlDtkXQfIzqksnD0YRXso68,52145
 py2ls/stats.py,sha256=Wd9yCKQ_61QD29WMEgMuEcreFxF91NmlPW65iWT2B5w,39041
 py2ls/translator.py,sha256=bc5FB-wqC4TtQz9gyCP1mE38HqNRJ_pmuRIgKnAlMzM,30581
 py2ls/wb_detector.py,sha256=7y6TmBUj9exCZeIgBAJ_9hwuhkDh1x_-yg4dvNY1_GQ,6284
-py2ls-0.1.8.6.dist-info/METADATA,sha256=CCDGfjYmrUoLuYqvwidE8OkCBWs-EvCa5tviSzKVOjs,20017
-py2ls-0.1.8.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-py2ls-0.1.8.6.dist-info/RECORD,,
+py2ls-0.1.8.8.dist-info/METADATA,sha256=tnUzLUWK94WS_DVJ1Jxcn_fRFrQRktuceHW0WMRfS5g,20017
+py2ls-0.1.8.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+py2ls-0.1.8.8.dist-info/RECORD,,