py2ls 0.2.5.7__tar.gz → 0.2.5.9__tar.gz

{py2ls-0.2.5.7 → py2ls-0.2.5.9}/PKG-INFO

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

{py2ls-0.2.5.7 → py2ls-0.2.5.9}/py2ls/ips.py

@@ -3,7 +3,7 @@ import pandas as pd
 import sys
 import os
 from IPython.display import display
-from typing import List, Optional, Union,Any
+from typing import Dict,List, Optional, Union,Any
 
 from regex import X
 
@@ -5245,63 +5245,169 @@ def split_path(fpath):
     dir_ch = "".join(fpath.split(f_slash)[-1:])
     return dir_par, dir_ch
 
+from pathlib import Path
+import matplotlib.pyplot as plt
+from PIL import Image
+import numpy as np
+import cv2
 
-def figsave(*args, dpi=300):
-    import matplotlib.pyplot as plt
-    from PIL import Image
+def figsave(*args, dpi=300, **kwargs):
+    bbox_inches = kwargs.pop("bbox_inches", "tight")
+    pad_inches = kwargs.pop("pad_inches", 0)
+    facecolor = kwargs.pop("facecolor", "white")
+    edgecolor = kwargs.pop("edgecolor", "auto")
 
     dir_save = None
     fname = None
     img = None
-    f_slash = "/" if "mac" in get_os().lower() else "\\"
+
     for arg in args:
         if isinstance(arg, str):
-            if f_slash in arg:
-                dir_save = arg
+            path = Path(arg)
+            if path.suffix:  # Has file extension
+                fname = path.name
+                dir_save = path.parent
             else:
-                fname = arg
+                dir_save = path
         elif isinstance(arg, (Image.Image, np.ndarray)):
-            img = arg  # Store the PIL image if provided
+            img = arg  # Store PIL image or numpy array
 
-    if dir_save is None:
-        dir_save = "./"
+    # Set default save directory
+    dir_save = Path(dir_save) if dir_save else Path(".")
+    dir_save.mkdir(parents=True, exist_ok=True)
+
+    # Handle filename and extension
+    if fname is None:
+        fname = "figure"
+    fname = dir_save / fname
+    if fname.suffix == "":
+        fname = fname.with_suffix(".pdf")  # Default format
+
+    ftype = fname.suffix.lstrip(".").lower()
+
+    # Save figure based on file type
+    if ftype == "eps":
+        plt.savefig(fname, format="eps", bbox_inches=bbox_inches)
+        plt.savefig(fname.with_suffix(".pdf"), format="pdf", dpi=dpi,
+                    pad_inches=pad_inches, bbox_inches=bbox_inches,
+                    facecolor=facecolor, edgecolor=edgecolor)
+    elif ftype == "pdf":
+        plt.savefig(fname, format="pdf", dpi=dpi, pad_inches=pad_inches,
+                    bbox_inches=bbox_inches, facecolor=facecolor, edgecolor=edgecolor)
+    elif ftype in ["jpg", "jpeg", "png", "tiff", "tif"]:
+        if img is not None:  # If an image is provided
+            if isinstance(img, Image.Image):
+                img = img.convert("RGB") if img.mode == "RGBA" else img
+                img.save(fname, format=ftype.upper(), dpi=(dpi, dpi))
+            elif isinstance(img, np.ndarray):
+                if img.ndim == 2:
+                    Image.fromarray(img).save(fname, format=ftype.upper(), dpi=(dpi, dpi))
+                elif img.ndim == 3:
+                    if img.shape[2] == 3:
+                        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+                    elif img.shape[2] == 4:
+                        img = cv2.cvtColor(img, cv2.COLOR_BGRA2RGBA)
+                    Image.fromarray(img).save(fname, format=ftype.upper(), dpi=(dpi, dpi))
+                else:
+                    raise ValueError("Unexpected image dimensions.")
+        else:
+            plt.savefig(fname, format=ftype, dpi=dpi, pad_inches=pad_inches,
+                        bbox_inches=bbox_inches, facecolor=facecolor, edgecolor=edgecolor)
+    elif ftype == "ico":
+        if img is None:
+            plt.savefig(fname, dpi=dpi, pad_inches=pad_inches,
+                        bbox_inches=bbox_inches, facecolor=facecolor, edgecolor=edgecolor)
+            img = Image.open(fname)
+        img = img.convert("RGBA")
+        icon_sizes = [(32, 32), (64, 64), (128, 128), (256, 256)]
+        img.save(fname, format="ICO", sizes=icon_sizes)
+        print(f"Icon saved @: {fname} with sizes: {icon_sizes}")
+    else:
+        raise ValueError(f"Unsupported file format: {ftype}")
+
+    print(f"\nSaved @ {fname} (dpi={dpi})")
 
-    # dir_save=dir_save+f_slash if not dir_save.endswith(f_slash) else dir_save
-    dir_par = f_slash.join(dir_save.split(f_slash)[:-1])
-    dir_ch = "".join(dir_save.split(f_slash)[-1:])
-    if not dir_par.endswith(f_slash):
-        dir_par += f_slash
+def figsave(*args, dpi=300, **kwargs):
+    """
+    Save a Matplotlib figure or image file in various formats.
+
+    This function automatically determines whether to save a Matplotlib figure 
+    or an image (PIL or NumPy array) and handles different file formats, including:
+    - PDF, EPS, PNG, JPG, TIFF, ICO, EMF
+
+    Parameters:
+    -----------
+    *args : str, PIL.Image, np.ndarray
+        - File path (directory and/or filename) to save the figure.
+        - If an image is provided (PIL or NumPy), it will be saved accordingly.
+    
+    dpi : int, optional (default=300)
+        - Resolution (dots per inch) for saved figures.
+    
+    **kwargs : dict
+        - Additional keyword arguments for `matplotlib.pyplot.savefig()`, including:
+            - bbox_inches (str, default="tight"): Bounding box for figure.
+            - pad_inches (float, default=0): Padding around figure.
+            - facecolor (str, default="white"): Background color.
+            - edgecolor (str, default="auto"): Edge color.
+
+    Supported Formats:
+    ------------------
+    - Vector: `pdf`, `eps`, `emf`
+    - Raster: `png`, `jpg`, `jpeg`, `tiff`, `tif`, `ico`
+    
+    Example Usage:
+    --------------
+    >>> figsave("output_plot.pdf")
+    >>> figsave("figs/plot.png", dpi=600)
+    >>> figsave("./results/figure", format="pdf")
+    >>> figsave("icons/logo.ico", image)  # Save an image file as an icon
+
+    Returns:
+    --------
+    None
+    """
+    import matplotlib.pyplot as plt
+    from PIL import Image
+    from pathlib import Path
+    
+    bbox_inches=kwargs.pop("bbox_inches","tight")
+    pad_inches=kwargs.pop("pad_inches",0)
+    facecolor=kwargs.pop("facecolor",'white')
+    edgecolor=kwargs.pop("edgecolor",'auto')
+    
+    dir_save = None
+    fname = None
+    img = None
+    for arg in args:
+        if isinstance(arg, str):
+            path = Path(arg)
+            if path.suffix:  # Has file extension
+                fname = path.name
+                dir_save = path.parent
+            else:
+                dir_save = path
+        elif isinstance(arg, (Image.Image, np.ndarray)):
+            img = arg  # Store PIL image or numpy array
 
+    dir_save = Path(dir_save) if dir_save else Path(".")
+    dir_save.mkdir(parents=True, exist_ok=True)
+    # Handle filename and extension
     if fname is None:
-        fname = dir_ch
-    mkdir(dir_par)
-    ftype = fname.split(".")[-1]
-    if len(fname.split(".")) == 1:
-        ftype = "nofmt"
-        fname = dir_par + fname + "." + ftype
+        fname = dir_save
     else:
-        fname = dir_par + fname
+        fname = dir_save / fname
+    if fname.suffix == "":
+        fname = fname.with_suffix(".pdf")  # Default format
+
+    ftype = fname.suffix.lstrip(".").lower()
 
     # Save figure based on file type
-    if ftype.lower() == "eps":
-        plt.savefig(fname, format="eps", bbox_inches="tight")
-        plt.savefig(
-            fname.replace(".eps", ".pdf"),
-            format="pdf",
-            bbox_inches="tight",
-            dpi=dpi,
-            pad_inches=0,
-        )
-    elif ftype.lower() == "nofmt":  # default: both "tif" and "pdf"
-        fname_corr = fname.replace("nofmt", "pdf")
-        plt.savefig(
-            fname_corr, format="pdf", bbox_inches="tight", dpi=dpi, pad_inches=0
-        )
-        fname = fname.replace("nofmt", "tif")
-        plt.savefig(fname, format="tiff", dpi=dpi, bbox_inches="tight", pad_inches=0)
-        print(f"default saving filetype: both 'tif' and 'pdf")
-    elif ftype.lower() == "pdf":
-        plt.savefig(fname, format="pdf", bbox_inches="tight", dpi=dpi, pad_inches=0)
+    if ftype == "eps":
+        plt.savefig(fname, format="eps", bbox_inches=bbox_inches)
+        plt.savefig(fname.with_suffix(".pdf"), format="pdf", dpi=dpi,
+                    pad_inches=pad_inches, bbox_inches=bbox_inches,
+                    facecolor=facecolor, edgecolor=edgecolor) 
     elif ftype.lower() in ["jpg", "jpeg", "png", "tiff", "tif"]:
         if img is not None:  # If a PIL image is provided
             if isinstance(img, Image.Image):
@@ -5310,63 +5416,46 @@ def figsave(*args, dpi=300):
                 img.save(fname, format=ftype.upper(), dpi=(dpi, dpi))
             elif isinstance(img, np.ndarray):
                 import cv2
-
-                # Check the shape of the image to determine color mode
                 if img.ndim == 2:
                     # Grayscale image
-                    Image.fromarray(img).save(
-                        fname, format=ftype.upper(), dpi=(dpi, dpi)
-                    )
+                    Image.fromarray(img).save(fname, format=ftype.upper(), dpi=(dpi, dpi))
                 elif img.ndim == 3:
                     if img.shape[2] == 3:
                         # RGB image
                         img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-                        Image.fromarray(img).save(
-                            fname, format=ftype.upper(), dpi=(dpi, dpi)
-                        )
+                        Image.fromarray(img).save(fname, format=ftype.upper(), dpi=(dpi, dpi))
                     elif img.shape[2] == 4:
                         # RGBA image
-                        img = cv2.cvtColor(
-                            img, cv2.COLOR_BGRA2RGBA
-                        )  # Convert BGRA to RGBA
-                        Image.fromarray(img).save(
-                            fname, format=ftype.upper(), dpi=(dpi, dpi)
-                        )
+                        img = cv2.cvtColor(img, cv2.COLOR_BGRA2RGBA)  # Convert BGRA to RGBA
+                        Image.fromarray(img).save(fname, format=ftype.upper(), dpi=(dpi, dpi))
                     else:
-                        raise ValueError(
-                            "Unexpected number of channels in the image array."
-                        )
+                        raise ValueError("Unexpected number of channels in the image array.")
                 else:
-                    raise ValueError(
-                        "Image array has an unexpected number of dimensions."
-                    )
+                    raise ValueError("Image array has an unexpected number of dimensions.")
         else:
-            plt.savefig(
-                fname,
-                format=ftype.lower(),
-                dpi=dpi,
-                bbox_inches="tight",
-                transparent=True,
-                pad_inches=0,
-            )
-    elif ftype.lower() == "emf":
-        plt.savefig(fname, format="emf", dpi=dpi, bbox_inches="tight", pad_inches=0)
-    elif ftype.lower() == "fig":
-        plt.savefig(fname, format="pdf", bbox_inches="tight", dpi=dpi, pad_inches=0)
-
+            plt.savefig(fname,format=ftype.lower(),dpi=dpi,pad_inches=pad_inches,bbox_inches=bbox_inches,facecolor=facecolor,edgecolor=edgecolor)
+    elif ftype.lower() in ["emf","pdf","fig"]:
+        plt.savefig(fname,format=ftype.lower(),dpi=dpi,pad_inches=pad_inches,bbox_inches=bbox_inches,facecolor=facecolor,edgecolor=edgecolor)
     elif ftype.lower() == "ico":
         # Ensure the image is in a format that can be saved as an icon (e.g., 32x32, 64x64, etc.)
         if img is None:  # If no image is provided, use the matplotlib figure
-            img = plt.figure()
-            img.savefig(fname, dpi=dpi, format="png", bbox_inches="tight")
+            img = plt.figure() 
+            print(fname)
+            img.savefig(fname, 
+                        format="png",
+                        dpi=dpi,
+                        pad_inches=pad_inches,
+                        bbox_inches=bbox_inches,
+                        facecolor=facecolor,
+                        edgecolor=edgecolor )
             img = Image.open(fname)  # Load the saved figure image
 
         # Resize the image to typical icon sizes and save it as .ico
         icon_sizes = [(32, 32), (64, 64), (128, 128), (256, 256)]
-        img = img.convert("RGBA")  # Ensure it has an alpha channel for transparency
+        img = img.convert("RGBA") 
         img.save(fname, format="ICO", sizes=icon_sizes)
         print(f"Icon saved @: {fname} with sizes: {icon_sizes}")
-    print(f"\nSaved @: dpi={dpi}\n{fname}")
+    print(f"\n✅ Saved @: dpi={dpi}\n{fname}")
 
 
 def is_str_color(s):
@@ -6772,39 +6861,39 @@ def finfo(fpath):
 
 
 # ! format excel file
-def hex2argb(hex_color):
-    """
-        Convert a hex color code to aARGB format required by openpyxl.
 
-        :param hex_color: A hex color code in the format #RRGGBB, RRGGBB, or aARRGGBB.
-        :return: A hex color code in the format aARRGGBB.
 
-    # Example usage
-    print(hex_to_argb("FFFF00"))  # Outputs: FFFFFF00
-    print(hex_to_argb("#DF4245"))  # Outputs: FFFFFF00
-    print(hex_to_argb("FF00FF00"))  # Outputs: FF00FF00 (already in aARGB format)
+def hex2argb(color):
     """
-    # Remove the hash if present
-    if hex_color.startswith("#"):
-        hex_color = hex_color[1:]
+    Convert a color name or hex code to aARGB format required by openpyxl.
 
-    # Check if it's already in aARGB format (8 characters)
-    if len(hex_color) == 8:
-        return hex_color
+    :param color: A color in the format: 'blue', '#RRGGBB', 'RRGGBB', 'aARRGGBB'
+    :return: A hex color code in the format aARRGGBB.
 
-    # Otherwise, assume it's in RRGGBB format and prepend FF for opaque
-    if len(hex_color) == 6:
-        return f"FF{hex_color}"
-    if len(hex_color) == 7:
-        return f"F{hex_color}"
-    else:
-        if len(hex_color) > 8:
-            return hex_color[-9:]
-        else:
-            return "F" * (9 - len(hex_color)) + hex_color
-    raise ValueError(
-        "Invalid hex color format. Use RRGGBB, #RRGGBB, or aARRGGBB format."
-    )
+    Example:
+        print(hex2argb("blue"))      # Output: FF0000FF
+        print(hex2argb("FFFF00"))    # Output: FFFFFF00
+        print(hex2argb("#DF4245"))   # Output: FFDf4245
+        print(hex2argb("FF00FF00"))  # Output: FF00FF00 (already in aARGB format)
+    """
+    import matplotlib.colors as mcolors
+    import re
+    color = color.lower().replace(" ", "") # 'light blue'
+    # Convert color name (e.g., "blue") to hex
+    if color.lower() in mcolors.CSS4_COLORS:
+        color = mcolors.CSS4_COLORS[color.lower()].lstrip("#")
+    color = color.lstrip("#").upper()# Remove '#' if present
+    
+    # Validate hex format
+    if not re.fullmatch(r"[A-F0-9]{6,8}", color):
+        raise ValueError(f"格式错误❌: {color}, 应该使用 RRGGBB, #RRGGBB, or aARRGGBB format.")
+
+    # If already in aARRGGBB format (8 chars), return as is
+    if len(color) == 8:
+        return color
+    
+    # If in RRGGBB format, add FF (full opacity) as alpha
+    return f"FF{color}"
 
 def extract_kwargs(func):
     import inspect
@@ -6975,7 +7064,7 @@ def format_excel(
     from openpyxl.worksheet.datavalidation import DataValidation
     from openpyxl.comments import Comment
     from openpyxl.formatting.rule import ColorScaleRule, DataBarRule, IconSetRule,IconSet
-
+    from openpyxl.utils import get_column_letter
     def convert_indices_to_range(row_slice, col_slice):
         """Convert numerical row and column slices to Excel-style range strings."""
         start_row = row_slice.start + 1
@@ -7000,9 +7089,17 @@ def format_excel(
         sheet_name : str
             The name of the sheet to style.
         conditions : dict
-            Dictionary defining conditions for text coloring.
+            Dictionary defining conditions for text or background coloring.
+                Example:
+                {
+                    ">10": "#FF0000",           # Red if value is greater than 10
+                    "contains:Error": "#FFFF00", # Yellow if text contains 'Error'
+                    "startswith:Warn": "#FFA500" # Orange if text starts with 'Warn'
+                }
         cell_idx : tuple, optional
             A tuple of slices defining the selected row and column range (only for DataFrame).
+        where : str, default="text"
+            "text" -> Apply color to text, "bg" -> Apply color to background.
 
         Returns:
         openpyxl.workbook.workbook.Workbook
@@ -7010,14 +7107,24 @@ def format_excel(
         """ 
         def evaluate_condition(value, condition):
             """Evaluate the condition dynamically."""
+            if not isinstance(conditions, dict):
+                raise ValueError(f"condition必须是dict格式:e.g., {'x>=20':'#DD0531', 'startswith:Available':'#DD0531'}")
             try:
                 if "x" in condition and re.search(r"[<>=!]=*", condition):
                     expr = condition.replace("x", str(value))
+                    return eval(expr)
+                elif condition.startswith("startswith:") or condition.startswith("startwith:"):
+                    return value.startswith(condition.split(":", 1)[1])
+                elif condition.startswith("endswith:") or condition.startswith("endwith:"):
+                    return value.endswith(condition.split(":", 1)[1])
+                elif condition.startswith("contains:") or condition.startswith("contain:") or condition.startswith("include:"):
+                    return condition.split(":", 1)[1] in value
+                elif condition.startswith("matches:") or condition.startswith("match:"):
+                    return re.search(condition.split(":", 1)[1], value) is not None 
                 else:
                     expr = condition
-                return eval(expr)
-            except Exception as e:
-                # print(f"Error evaluating condition {condition} for value {value}: {e}")
+                return False
+            except Exception as e: 
                 return False
 
         def apply_condition_to_cell_text_color(cell, value):
@@ -7446,12 +7553,12 @@ def format_excel(
     kwargs.pop("sheet_name", 0)  # 更好地跟df.to_excel结合使用
     # 只有openpyxl才支持 append
     mode = strcmp(kwargs.get("mode", "a"), ["a", "w","auto"])[0]
-    print(f'mode="{mode}"')
+    # print(f'mode="{mode}"')
     kwargs.pop("mode", None)
     engine = strcmp(kwargs.get("engine", "openpyxl"), ["xlsxwriter", "openpyxl"])[0]
     # corr engine
     engine="openpyxl" if mode=="a" else "xlsxwriter" 
-    print(f'engine="{engine}"')
+    # print(f'engine="{engine}"')
     if_sheet_exists=kwargs.get("if_sheet_exists","replace")
     # 通常是不需要保存index的
     index = kwargs.get("index", False)
@@ -7478,11 +7585,7 @@ def format_excel(
                 with pd.ExcelWriter(filename, mode="a", engine=engine, if_sheet_exists=if_sheet_exists) as writer:
                     for ws in df.worksheets:  # Iterate through worksheets in the input workbook
                         ws_df = pd.DataFrame(ws.values)
-                        ws_df.to_excel(writer,
-                                    sheet_name=sheet_name,
-                                    index=index,
-                                    header=header,
-                                    **kwargs) 
+                        ws_df.to_excel(writer,sheet_name=sheet_name,index=index,header=header,**kwargs) 
                 # 重新打开刚更新过的数据
                 wb = load_workbook(filename) 
                 if sheet_name in wb.sheetnames:
@@ -8008,21 +8111,20 @@ def format_excel(
                 pil_img=img_path = None
                 if isinstance(img_data, dict):
                     if "path" in img_data:
-                        img_path = img_data["path"]  # File path
-                        img_ = drawing.image.Image(img_path)
+                        img_ = drawing.image.Image(img_data["path"])# File path
                     elif "image" in img_data:
-                        pil_img = img_data["image"]  # PIL Image object
+                        img_ = drawing.image.Image(img_data["image"])# PIL Image object
                     elif "array" in img_data:
-                        pil_img = Image.fromarray(img_data["array"])  # Convert NumPy array to PIL Image
+                        img_ = drawing.image.Image(Image.fromarray(img_data["array"]))# Convert NumPy array to PIL Image
 
                     img_width = img_data.get("width", None)
                     img_height = img_data.get("height", None)
                 elif isinstance(img_data, str):
-                    img_path = img_data  # Direct file path
+                    img_ = drawing.image.Image(img_data)# Direct file path
                 elif isinstance(img_data, (PIL.Image.Image,PIL.PngImagePlugin.PngImageFile)):
-                    pil_img = img_data  # Direct PIL Image object
+                    img_ = drawing.image.Image(img_data)# Direct PIL Image object
                 elif isinstance(img_data, np.ndarray):
-                    pil_img = Image.fromarray(img_data)  # Convert NumPy array to PIL Image
+                    img_ = drawing.image.Image(Image.fromarray(img_data))# Convert NumPy array to PIL Image
                 elif pil_img:
                     img_ = drawing.image.Image(pil_img)
 
@@ -8216,7 +8318,89 @@ def _df_outlier(
 
     return processed_data
 
+def df_group(
+    data: pd.DataFrame,
+    columns: Union[str, list, None] = None,
+    by: str = None,
+    param: Dict[str, Any] = None,
+    sep: Union[str, list] = [", ",","],
+    dropna: bool = True,
+    unique: bool = False,
+    astype: type = str,
+    merge: List[str] = None,
+    merge_symbo_column:str=' & ',
+    merge_symbo_cell:str='[]',# ["{}","()","[]"]
+) -> pd.DataFrame:
+    """
+    Groups a dataframe based on a specified column and applies aggregation functions dynamically.
+    
+    Parameters:
+    data (pd.DataFrame): The dataframe to be grouped.
+    columns (Union[str, list, None]): Columns to select; if None, all columns are selected.
+    by (str): The column name to group by.
+    param (dict): A dictionary specifying aggregation rules.
+    sep (Union[str, list]): Separator for concatenated values. when sep is a list, then sep[0] used for general, sep[1] used in the merging
+    dropna (bool): Whether to drop NaN values before aggregation.
+    unique (bool): Whether to apply uniqueness before concatenation.
+    astype (type): Data type to cast values before aggregation.
+    merge (List[str]): List of columns to merge into a single paired column.
+    merge_symbo_column:str: indicate in the columns, default ("&")
+    merge_symbo_cell:str=default: '{}' or can select from ["{}","()","[]"]
+
+    Usage:
+    data = pd.DataFrame({
+                        "Cage Tag": [1, 1, 2, 2, 3],
+                        "Physical Tag": ["A1", "A2", "B1", "B2", "C1"],
+                        "Sex": ["M", "F", "M", "M", "F"],
+                        "Date of Birth": ["2021-06-01", "2021-06-02", "2021-07-01", "2021-07-02", "2021-08-01"],
+                        "Age": [34, 35, 30, 31, 29],
+                        "State": ["Mating", "Resting", "Mating", "Resting", "Mating"],
+                        "Owner": ["Dr. Smith", "Dr. Smith", "Dr. Brown", "Dr. Brown", "Dr. Lee"],
+                        })
+    display(data)
+    result = df_group(data, 
+                    #   columns=["Sex", "Date of Birth", "Age", "State"], 
+                    by="Cage Tag", 
+                    merge=["Age", "State"], 
+                    merge_symbo_column="|",
+                    #   astype=str
+                    # sep=[',',    '_'],
+                    merge_symbo_cell=None
+                    )  
+    result
+
+    
+    """
+    if param is None:
+        param = {}
+    if columns is None:
+        columns = data.columns.tolist()
+    elif isinstance(columns, str):
+        columns = [columns]
+    if not isinstance(sep, list):
+        sep = [sep]
+    sep.extend(sep) if len(sep)==1 else None
 
+    # Merge specified columns into a single column
+    if merge:
+        merge_col_name = merge_symbo_column.join(merge)
+        # data[merge_col_name] = data[merge].apply(lambda row: tuple(map(astype, row.dropna() if dropna else row)), axis=1)
+        if merge_symbo_cell is None: 
+            data[merge_col_name] = data[merge].apply(lambda row: f"{sep[1].join(map(astype, row.dropna()))}" if dropna else f"{sep[1].join(map(astype, row))}", axis=1)
+        elif len(merge_symbo_cell)==2:
+            data[merge_col_name] = data[merge].apply(lambda row: f"{merge_symbo_cell[0]}{sep[1].join(map(astype, row.dropna()))}{merge_symbo_cell[1]}" if dropna else f"{merge_symbo_cell[0]}{sep[1].join(map(astype, row))}{merge_symbo_cell[1]}", axis=1)
+        else:
+            data[merge_col_name] = data[merge].apply(lambda row: f"[{sep[1].join(map(astype, row.dropna()))}]" if dropna else f"[{sep[1].join(map(astype, row))}]", axis=1)
+        columns.append(merge_col_name)
+        
+    default_aggregations = {
+        col: (lambda x: sep[0].join(map(astype, x.dropna().unique() if unique else x.dropna())) if dropna else sep[0].join(map(astype, x.unique() if unique else x)))
+        for col in columns if col != by and (merge is None or col not in merge)
+    } 
+    aggregation_rules = {**default_aggregations, **param}
+    
+    grouped_df = data.groupby(by).agg(aggregation_rules).reset_index() 
+    return grouped_df
 def df_outlier(
     data,
     columns=None,
@@ -12506,3 +12690,83 @@ def py2installer(
             raise
 
     print("\nPackaging complete. Check the output directory for the executable.")
+
+
+def set_theme(
+    context="paper",
+    style="whitegrid",
+    palette="deep",
+    font="sans-serif",
+    font_scale=1.0,
+    color_codes=True,
+    grid_alpha=0.5,
+    grid_linewidth=0.8,
+    grid_linestyle="--",
+    tick_direction="out",
+    # tick_length=4,
+    spine_visibility=False,
+    # figsize=(8, 6),
+    # linewidth=2,
+    dpi=100,
+    rc=None,
+):
+    """
+    to configure Seaborn theme with maximum flexibility.
+
+    # Example Usage
+    set_sns_theme(font_scale=1.2, grid_alpha=0.8, tick_direction="in", dpi=150)
+
+        Parameters:
+        - context: Plotting context ('notebook', 'paper', 'talk', 'poster')
+        - style: Style of the plot ('darkgrid', 'whitegrid', 'dark', 'white', 'ticks')
+        - palette: Color palette (string or list of colors)
+        - font: Font family ('sans-serif', 'serif', etc.)
+        - font_scale: Scaling factor for fonts
+        - color_codes: Boolean, whether to use seaborn color codes
+        - grid_alpha: Opacity of the grid lines
+        - grid_linewidth: Thickness of grid lines
+        - grid_linestyle: Style of grid lines ('-', '--', '-.', ':')
+        - tick_direction: Direction of ticks ('in', 'out', 'inout')
+        - tick_length: Length of ticks
+        - spine_visibility: Whether to show plot spines (True/False)
+        - figsize: Default figure size as tuple (width, height)
+        - linewidth: Default line width for plots
+        - dpi: Resolution of the figure
+        - rc: Dictionary of additional rc settings
+    """
+    import seaborn as sns
+    import matplotlib.pyplot as plt
+
+    # Define additional rc parameters for fine-tuning
+    rc_params = {
+        # "axes.grid": True,
+        "grid.alpha": grid_alpha,
+        "grid.linewidth": grid_linewidth,
+        "grid.linestyle": grid_linestyle,
+        "xtick.direction": tick_direction,
+        "ytick.direction": tick_direction,
+        # "xtick.major.size": tick_length,
+        # "ytick.major.size": tick_length,
+        # "axes.linewidth": linewidth,
+        # "figure.figsize": figsize,
+        "figure.dpi": dpi,
+        "axes.spines.top": spine_visibility,
+        "axes.spines.right": spine_visibility,
+        "axes.spines.bottom": spine_visibility,
+        "axes.spines.left": spine_visibility,
+    }
+
+    # Merge user-provided rc settings
+    if rc:
+        rc_params.update(rc)
+
+    # Apply the theme settings
+    sns.set_theme(
+        context=context,
+        style=style,
+        palette=palette,
+        font=font,
+        font_scale=font_scale,
+        color_codes=color_codes,
+        rc=rc_params,
+    )

{py2ls-0.2.5.7 → py2ls-0.2.5.9}/pyproject.toml

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