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

py2ls/plot.py

@@ -3,12 +3,14 @@ import numpy as np
 import pandas as pd
 from matplotlib.colors import to_rgba
 from scipy.stats import gaussian_kde
-
+import seaborn as sns
 import matplotlib
 import matplotlib.ticker as tck
 from cycler import cycler
 import logging
-from .ips import fsave
+import os
+from .ips import fsave, fload, mkdir
+from .stats import *
 
 # Suppress INFO messages from fontTools
 logging.getLogger("fontTools").setLevel(logging.WARNING)
@@ -219,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,
@@ -475,31 +480,69 @@ def catplot(data, *args, **kwargs):
             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)
                 for i in df[x].unique().tolist():
-                    for j in df[hue].unique().tolist():
-                        xticklabels.append(i + "-" + j)
+                    xticklabels.append(i)
                 x_len = len(df[x].unique().tolist())
                 hue_len = len(df[hue].unique().tolist())
                 xticks = generate_xticks_with_gap(x_len, hue_len)
+                xticks_x_loc = generate_xticks_x_labels(x_len, hue_len)
                 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()
+                xticks_x_loc = np.arange(1, len(xticklabels) + 1).tolist()
                 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]) > 5 else 0
+            xangle = 30 if max([len(i) for i in xticklabels]) > 50 else 0
             if kw_figsets is not None:
                 kw_figsets = {
                     "ylabel": y,
                     # "xlabel": x,
-                    "xticks": xticks,
+                    "xticks": xticks_x_loc,  # xticks,
                     "xticklabels": xticklabels,
                     "xangle": xangle,
                     **kw_figsets,
@@ -508,7 +551,7 @@ def catplot(data, *args, **kwargs):
                 kw_figsets = {
                     "ylabel": y,
                     # "xlabel": x,
-                    "xticks": xticks,
+                    "xticks": xticks_x_loc,  # xticks,
                     "xticklabels": xticklabels,
                     "xangle": xangle,
                 }
@@ -521,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()
@@ -536,9 +595,9 @@ def catplot(data, *args, **kwargs):
         opt["loc"].setdefault("xloc", xticks)
 
         # export setting
-        opt.setdefault("export", {})
-        opt["export"].setdefault("path", None)
-        print(opt["export"])
+        opt.setdefault("style", {})
+        opt["style"].setdefault("export", None)
+        print(opt["style"])
 
         # opt.setdefault('layer', {})
         opt.setdefault("layer", ["b", "bx", "e", "v", "s", "l"])
@@ -572,7 +631,7 @@ def catplot(data, *args, **kwargs):
         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("x_width", default_x_width / 5)
         opt["e"].setdefault("cap_dir", "b")
 
         opt.setdefault("s", {})
@@ -581,7 +640,7 @@ def catplot(data, *args, **kwargs):
         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("x_width", default_x_width / 5)
         opt["s"].setdefault("Marker", "o")
         opt["s"].setdefault("MarkerSize", 15)
         opt["s"].setdefault("LineWidth", 0.8)
@@ -602,7 +661,7 @@ def catplot(data, *args, **kwargs):
         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("x_width", default_x_width / 5)
         opt["bx"].setdefault("ShowBaseLine", "off")
         opt["bx"].setdefault("Notch", False)
         opt["bx"].setdefault("Outliers", "on")
@@ -611,28 +670,29 @@ def catplot(data, *args, **kwargs):
         opt["bx"].setdefault("OutlierSize", 6)
         # opt['bx'].setdefault('PlotStyle', 'traditional')
         # opt['bx'].setdefault('FactorDirection', 'auto')
-        opt["bx"].setdefault("Whisker", 0.5)
+        opt["bx"].setdefault("LineWidth", 0.5)
+        opt["bx"].setdefault("Whisker", opt["bx"]["LineWidth"])
         opt["bx"].setdefault("Orientation", "vertical")
-        opt["bx"].setdefault("BoxLineWidth", 0.5)
+        opt["bx"].setdefault("BoxLineWidth", opt["bx"]["LineWidth"])
         opt["bx"].setdefault("FaceColor", "k")
         opt["bx"].setdefault("WhiskerLineStyle", "-")
         opt["bx"].setdefault("WhiskerLineColor", "k")
-        opt["bx"].setdefault("WhiskerLineWidth", 0.5)
+        opt["bx"].setdefault("WhiskerLineWidth", opt["bx"]["LineWidth"])
         opt["bx"].setdefault("Caps", True)
         opt["bx"].setdefault("CapLineColor", "k")
-        opt["bx"].setdefault("CapLineWidth", 0.5)
+        opt["bx"].setdefault("CapLineWidth", opt["bx"]["LineWidth"])
         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("MedianLineWidth", opt["bx"]["LineWidth"] * 4)
         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)
+        opt["bx"].setdefault("MeanLineWidth", opt["bx"]["LineWidth"] * 4)
 
         # Violin plot options
         opt.setdefault("v", {})
@@ -676,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":
@@ -711,9 +770,13 @@ def catplot(data, *args, **kwargs):
         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)
+
+        style_export = kwargs.get("style_export", None)
+        if style_export and (style_export != style_use):
+            dir_curr_script = os.path.dirname(os.path.abspath(__file__))
+            dir_style = dir_curr_script + "/data/styles/"
+            fsave(dir_style + style_export + ".json", opt)
+
         return ax, opt
     else:
         col_names = data[col].unique().tolist()
@@ -729,10 +792,13 @@ def catplot(data, *args, **kwargs):
             # 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])
+                _, opt = catplot(ax=ax, data=df_sub, **kwargs)
+                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
+        return axs, opt
 
 
 def get_cmap():
@@ -1510,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,
@@ -1700,3 +1597,26 @@ def generate_xticks_with_gap(x_len, hue_len):
     positive_array = concatenated_array[concatenated_array > 0].tolist()
 
     return positive_array
+
+
+def generate_xticks_x_labels(x_len, hue_len):
+    arrays = [
+        np.arange(1, hue_len + 1) + hue_len * (x_len - i) + (x_len - i)
+        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