py2ls 0.1.9.1__py3-none-any.whl → 0.1.9.2__py3-none-any.whl

py2ls/plot.py

@@ -10,6 +10,7 @@ from cycler import cycler
 import logging
 import os
 from .ips import fsave, fload, mkdir
+from .stats import *
 
 # Suppress INFO messages from fontTools
 logging.getLogger("fontTools").setLevel(logging.WARNING)
@@ -220,8 +221,11 @@ def catplot(data, *args, **kwargs):
         # MeanLine or MedianLine only keep only one
         if bx_opt["MeanLine"]:  # MeanLine has priority
             bx_opt["MedianLine"] = False
+        # rm NaNs
+        cleaned_data = [data[~np.isnan(data[:, i]), i] for i in range(data.shape[1])]
+
         bxp = ax.boxplot(
-            data,
+            cleaned_data,
             positions=X_bx,
             notch=bx_opt["Notch"],
             patch_artist=True,
@@ -488,7 +492,33 @@ def catplot(data, *args, **kwargs):
                 default_x_width = 0.85
                 legend_hue = df[hue].unique().tolist()
                 default_colors = get_color(hue_len)
+
+                # ! stats info
+                stats_param = kwargs.get("stats", False)
+                res = pd.DataFrame()  # Initialize an empty DataFrame to store results
+                for i in df[x].unique().tolist():
+                    print(i)
+                    if hue and stats_param:
+                        if isinstance(stats_param, dict):
+                            if "factor" in stats_param.keys():
+                                res_tmp = FuncMultiCmpt(data=df, dv=y, **stats_param)
+                            else:
+                                res_tmp = FuncMultiCmpt(
+                                    data=df[df[x] == i], dv=y, factor=hue, **stats_param
+                                )
+                        elif bool(stats_param):
+                            res_tmp = FuncMultiCmpt(data=df, dv=y, factor=hue)
+                        else:
+                            res_tmp = "did not work properly"
+                        display_output(res_tmp)
+                        res_tmp = [{"x": i, **res_tmp}]
+                        res = pd.concat(
+                            [res, pd.DataFrame([res_tmp])], ignore_index=True
+                        )
+                display_output(res)
             else:
+                # ! stats info
+                stats_param = kwargs.get("stats", False)
                 for i in df[x].unique().tolist():
                     xticklabels.append(i)
                 xticks = np.arange(1, len(xticklabels) + 1).tolist()
@@ -496,9 +526,17 @@ def catplot(data, *args, **kwargs):
                 legend_hue = xticklabels
                 default_colors = get_color(len(xticklabels))
                 default_x_width = 0.5
+                res = None
+                if x and stats_param:
+                    if isinstance(stats_param, dict):
+                        res = FuncMultiCmpt(data=df, dv=y, factor=x, **stats_param)
+                    elif bool(stats_param):
+                        res = FuncMultiCmpt(data=df, dv=y, factor=x)
+                    else:
+                        res = "did not work properly"
+                display_output(res)
 
             # when the xticklabels are too long, rotate the labels a bit
-
             xangle = 30 if max([len(i) for i in xticklabels]) > 50 else 0
             if kw_figsets is not None:
                 kw_figsets = {
@@ -526,6 +564,22 @@ def catplot(data, *args, **kwargs):
 
         # full_order
         opt = kwargs.get("opt", {})
+
+        # load style:
+        style_use = None
+        for k, v in kwargs.items():
+            if "style" in k and "exp" not in k:
+                style_use = v
+                break
+        if style_use:
+            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")
+                style_load = remove_colors_in_dict(style_load)
+                opt.update(style_load)
+            except:
+                print(f"cannot find the style'{style_name}'")
         ax = kwargs.get("ax", None)
         if "ax" not in locals() or ax is None:
             ax = plt.gca()
@@ -654,16 +708,6 @@ def catplot(data, *args, **kwargs):
         opt["v"].setdefault("NumPoints", 500)
         opt["v"].setdefault("BoundaryCorrection", "reflection")
 
-        # load style:
-        style_use = kwargs.get("style_use", None)
-        if style_use:
-            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")
-                opt.update(style_load)
-            except:
-                print(f"cannot find the style'{style_name}'")
         data_m = np.nanmean(data, axis=0)
         nr, nc = data.shape
 
@@ -692,7 +736,6 @@ def catplot(data, *args, **kwargs):
             legend_which = "v"
         else:
             legend_which = None
-
         for layer in layers:
             if layer == "b" and opt["b"]["go"]:
                 if legend_which == "b":
@@ -721,8 +764,7 @@ def catplot(data, *args, **kwargs):
                     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)
-            else:
-                print("layers run some problems")
+
         if kw_figsets is not None:
             figsets(ax=ax, **kw_figsets)
         show_legend = kwargs.get("show_legend", True)
@@ -734,6 +776,7 @@ def catplot(data, *args, **kwargs):
             dir_curr_script = os.path.dirname(os.path.abspath(__file__))
             dir_style = dir_curr_script + "/data/styles/"
             fsave(dir_style + style_export + ".json", opt)
+
         return ax, opt
     else:
         col_names = data[col].unique().tolist()
@@ -750,7 +793,10 @@ def catplot(data, *args, **kwargs):
             if i < len(col_names):
                 df_sub = data.loc[data[col] == col_names[i]]
                 _, opt = catplot(ax=ax, data=df_sub, **kwargs)
-                ax.set_title(col_names[i])
+                ax.set_title(f"{col}={col_names[i]}")
+                x_label = kwargs.get("x", None)
+                if x_label:
+                    ax.set_xlabel(x_label)
         print(f"Axis layout shape: {axs.shape}")
         return axs, opt
 
@@ -1530,175 +1576,6 @@ def add_colorbar(im, width=None, pad=None, **kwargs):
     return fig.colorbar(im, cax=cax, **kwargs)  # draw cbar
 
 
-# def padcat(*args, fill_value=np.nan, axis=1):
-#     """
-#     Concatenate vectors with padding.
-
-#     Parameters:
-#     *args : variable number of list or 1D arrays
-#         Input arrays to concatenate.
-#     fill_value : scalar, optional
-#         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 0).
-
-#     Returns:
-#     np.ndarray
-#         A 2D array with the input arrays concatenated along the specified axis, padded with fill_value where necessary.
-#     """
-#     if axis == 0:
-#         # Concatenate along rows
-#         max_len = max(len(lst) for lst in args)
-#         result = np.full((len(args), max_len), fill_value)
-#         for i, lst in enumerate(args):
-#             result[i, : len(lst)] = lst
-#     elif axis == 1:
-#         # Concatenate along columns
-#         max_len = max(len(lst) for lst in args)
-#         result = np.full((max_len, len(args)), fill_value)
-#         for i, lst in enumerate(args):
-#             result[: len(lst), i] = lst
-#     else:
-#         raise ValueError("axis must be 0 or 1")
-
-#     return result
-import numpy as np
-
-
-def padcat(*args, fill_value=np.nan, axis=1, order="row"):
-    """
-    Concatenate vectors with padding.
-
-    Parameters:
-    *args : variable number of list or 1D arrays
-        Input arrays to concatenate.
-    fill_value : scalar, optional
-        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.
-    """
-    # Set the order for processing
-    if "ro" in order.lower():
-        order = "C"  # row-major order
-    else:
-        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 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 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")
-
-    return result
-
-
-# # 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
-
-    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)
-
-        # Sort each row
-        sorted_arr = np.sort(arr_no_nan, axis=1)
-
-        # 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)]
-    clean_arr_ = clean_arr[:, ~np.isnan(clean_arr).all(axis=0)]
-
-    return clean_arr_
-
-
-def df2array(data: pd.DataFrame, x, y, hue=None, sort=False):
-    if hue is None:
-        a = []
-        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).T
-    else:
-        a = []
-        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).T
-
-
 def generate_xticks_with_gap(x_len, hue_len):
     """
     Generate a concatenated array based on x_len and hue_len,
@@ -1728,3 +1605,18 @@ def generate_xticks_x_labels(x_len, hue_len):
         for i in range(max(x_len, hue_len), 0, -1)  # i iterates from 3 to 1
     ]
     return [np.mean(i) for i in arrays if np.mean(i) > 0]
+
+
+def remove_colors_in_dict(
+    data: dict, sections_to_remove_facecolor=["b", "e", "s", "bx", "v"]
+):
+    # Remove "FaceColor" from specified sections
+    for section in sections_to_remove_facecolor:
+        if section in data and ("FaceColor" in data[section]):
+            del data[section]["FaceColor"]
+
+    if "c" in data:
+        del data["c"]
+    if "loc" in data:
+        del data["loc"]
+    return data