py2ls 0.2.5.8__tar.gz → 0.2.5.10__tar.gz

{py2ls-0.2.5.8 → py2ls-0.2.5.10}/PKG-INFO

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

{py2ls-0.2.5.8 → py2ls-0.2.5.10}/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
 
@@ -3589,6 +3589,7 @@ def fload(fpath, kind=None, **kwargs):
 
         # https://github.com/eyurtsev/fcsparser
         meta, data = fcsparser.parse(fpath, reformat_meta=True)
+        print("meta, data = fload(*.fcs)")
         return meta, data
 
     elif kind == "mplstyle":
@@ -5245,63 +5246,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
 
-    # 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
+    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})")
+
+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 +5417,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):
@@ -8022,21 +8112,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)
 
@@ -8230,7 +8319,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,
@@ -10208,11 +10379,19 @@ def get_df_format(data, threshold_unique=0.5, verbose=False):
     from sklearn.cluster import AgglomerativeClustering
     from sklearn.preprocessing import StandardScaler
 
-    long_score = 0
-    wide_score = 0
-
+    long_score,wide_score,fs = 0,0,500
     n_rows, n_cols = data.shape
-
+    # -----to reduce memory, only check 500 rows/columns----
+    if n_rows > fs:
+        if verbose:
+            print(f"Sampling {fs} rows from {n_rows} rows.")
+        data = data.sample(n=fs, random_state=1)
+    if n_cols > fs:
+        if verbose:
+            print(f"Using first {fs} columns out of {n_cols} columns.")
+        data = data.iloc[:, :fs]
+    n_rows, n_cols = data.shape
+    
     # Step 1: Row-Column Ratio Heuristic
     if n_rows > 3 * n_cols:
         long_score += 2
@@ -12520,3 +12699,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,
+    )