py2ls 0.1.10.1__py3-none-any.whl → 0.1.10.3__py3-none-any.whl

py2ls/ips.py

@@ -9,6 +9,8 @@ from cycler import cycler
 from mpl_toolkits.mplot3d import Axes3D
 import seaborn as sns
 
+from sklearn.kernel_approximation import KERNEL_PARAMS
+from sympy import is_increasing
 import sys, os, shutil, re, yaml, json, subprocess
 import importlib.util
 import time
@@ -519,6 +521,23 @@ def str2num(s, *args, **kwargs):
 # print(str2num("12345.6789", " ", 2)) # Output: 12 345.68
 # print(str2num('111113.34555',3,',')) # Output: 111,113.346
 # print(str2num("123.55555 sec miniuets",3)) # Output: 1.3
+
+
+def text2num(text):
+    # extract the digital nums from a text
+    num = []
+    for s in ssplit(text, by="digital"):
+        try:
+            if float(s):
+                num.append(float(s))
+        except:
+            pass
+    if len(num) == 1:
+        return num[0]
+    else:
+        return num
+
+
 def num2str(num, *args, **kwargs):
     delimiter = kwargs.get("sep", None)
     round_digits = kwargs.get("round", None)
@@ -1328,8 +1347,28 @@ def fsave(
         df.to_csv(fpath, **kwargs)
 
     def save_xlsx(fpath, data, **kwargs):
-        df = pd.DataFrame(data)
-        df.to_excel(fpath, **kwargs)
+        format = kwargs.get("format", None)
+        if format:
+            kwargs.pop("format", None)
+            format_excel(df=data, filename=fpath, **kwargs)
+        else:
+            kwargs.pop("format", None)
+            kwargs.pop("usage", None)
+            kwargs.pop("cell", None)
+            kwargs.pop("width", None)
+            kwargs.pop("height", None)
+            kwargs.pop("width", None)
+            kwargs.pop("height_max", None)
+            kwargs.pop("merge", None)
+            kwargs.pop("shade", None)
+            kwargs.pop("comment", None)
+            kwargs.pop("link", None)
+            kwargs.pop("protect", None)
+            kwargs.pop("number_format", None)
+            kwargs.pop("conditional_format", None)
+            kwargs.pop("index_default", None)
+            df = pd.DataFrame(data)
+            df.to_excel(fpath, **kwargs)
 
     def save_ipynb(fpath, data, **kwargs):
         # Split the content by code fences to distinguish between code and markdown
@@ -1574,6 +1613,22 @@ def listdir(
     orient="list",
     output="df",  # 'list','dict','records','index','series'
 ):
+    if isinstance(kind, list):
+        f_ = []
+        for kind_ in kind:
+            f_tmp = listdir(
+                rootdir=rootdir,
+                kind=kind_,
+                sort_by=sort_by,
+                ascending=ascending,
+                contains=contains,
+                orient=orient,
+                output=output,
+            )
+            f_.append(f_tmp)
+        if f_:
+            return pd.concat(f_, ignore_index=True)
+
     if not kind.startswith("."):
         kind = "." + kind
 
@@ -2923,3 +2978,723 @@ def finfo(fpath):
         kind=data["kind"],
         extra_info=extra_info,
     )
+
+
+# ! format excel file
+import pandas as pd
+from datetime import datetime
+from openpyxl import load_workbook
+from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+from openpyxl.utils import get_column_letter
+from openpyxl.worksheet.datavalidation import DataValidation
+from openpyxl.comments import Comment
+from openpyxl.formatting.rule import ColorScaleRule
+
+
+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)
+    """
+    # Remove the hash if present
+    if hex_color.startswith("#"):
+        hex_color = hex_color[1:]
+
+    # Check if it's already in aARGB format (8 characters)
+    if len(hex_color) == 8:
+        return hex_color
+
+    # Otherwise, assume it's in RRGGBB format and prepend FF for opaque
+    if len(hex_color) == 6:
+        return f"FF{hex_color}"
+
+    raise ValueError(
+        "Invalid hex color format. Use RRGGBB, #RRGGBB, or aARRGGBB format."
+    )
+
+
+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
+    end_row = row_slice.stop if row_slice.stop is not None else None
+    start_col = col_slice.start + 1
+    end_col = col_slice.stop if col_slice.stop is not None else None
+
+    start_col_letter = get_column_letter(start_col)
+    end_col_letter = get_column_letter(end_col) if end_col else None
+    return (
+        f"{start_col_letter}{start_row}:{end_col_letter}{end_row}"
+        if end_col_letter
+        else f"{start_col_letter}{start_row}"
+    )
+
+
+def apply_format(ws, cell, cell_range):
+    """Apply cell formatting to a specified range."""
+    cell_font, cell_fill, cell_alignment, border = None, None, None, None
+    kws_cell = ["font", "fill", "alignment", "border"]
+    for K, _ in cell.items():
+        if strcmp(K, kws_cell)[0] == "font":
+            #! font
+            font_color = "000000"
+            font_name = "Arial"
+            font_underline = "none"
+            font_size = 14
+            font_bold = False
+            font_strike = False
+            font_italic = False
+            kws_font = [
+                "name",
+                "size",
+                "bold",
+                "underline",
+                "color",
+                "strike",
+                "italic",
+            ]
+            for k_, v_ in cell.get(K, {}).items():
+                if strcmp(k_, kws_font)[0] == "name":
+                    font_name = v_
+                elif strcmp(k_, kws_font)[0] == "size":
+                    font_size = v_
+                elif strcmp(k_, kws_font)[0] == "bold":
+                    font_bold = v_
+                elif strcmp(k_, kws_font)[0] == "underline":
+                    font_underline = strcmp(v_, ["none", "single", "double"])[0]
+                elif strcmp(k_, kws_font)[0] == "color":
+                    font_color = hex2argb(v_)
+                elif strcmp(k_, kws_font)[0] == "strike":
+                    font_strike = v_
+                elif strcmp(k_, kws_font)[0] == "italic":
+                    font_italic = v_
+
+            cell_font = Font(
+                name=font_name,
+                size=font_size,
+                bold=font_bold,
+                italic=font_italic,
+                underline=font_underline,
+                strike=font_strike,
+                color=font_color,
+            )
+
+        if strcmp(K, kws_cell)[0] == "fill":
+            #! fill
+            kws_fill = ["start_color", "end_color", "fill_type", "color"]
+            kws_fill_type = [
+                "darkVertical",
+                "lightDown",
+                "lightGrid",
+                "solid",
+                "darkDown",
+                "lightGray",
+                "lightUp",
+                "gray0625",
+                "lightVertical",
+                "lightHorizontal",
+                "darkHorizontal",
+                "gray125",
+                "darkUp",
+                "mediumGray",
+                "darkTrellis",
+                "darkGray",
+                "lightTrellis",
+                "darkGrid",
+            ]
+            start_color, end_color, fill_type = "FFFFFF", "FFFFFF", "solid"  # default
+            for k, v in cell.get(K, {}).items():
+                if strcmp(k, kws_fill)[0] == "color":
+                    start_color, end_color = hex2argb(v), hex2argb(v)
+                    break
+            for k, v in cell.get(K, {}).items():
+                if strcmp(k, kws_fill)[0] == "start_color":
+                    start_color = hex2argb(v)
+                elif strcmp(k, kws_fill)[0] == "end_color":
+                    end_color = hex2argb(v)
+                elif strcmp(k, kws_fill)[0] == "fill_type":
+                    fill_type = strcmp(v, kws_fill_type)[0]
+            cell_fill = PatternFill(
+                start_color=start_color,
+                end_color=end_color,
+                fill_type=fill_type,
+            )
+
+        if strcmp(K, kws_cell)[0] == "alignment":
+            #! alignment
+            # default
+            align_horizontal = "general"
+            align_vertical = "center"
+            align_rot = 0
+            align_wrap = False
+            align_shrink = False
+            align_indent = 0
+            kws_align = [
+                "horizontal",
+                "ha",
+                "vertical",
+                "va",
+                "text_rotation",
+                "rotat",
+                "rot",
+                "wrap_text",
+                "wrap",
+                "shrink_to_fit",
+                "shrink",
+                "indent",
+            ]
+            for k, v in cell.get(K, {}).items():
+                if strcmp(k, kws_align)[0] in ["horizontal", "ha"]:
+                    align_horizontal = strcmp(
+                        v, ["general", "left", "right", "center"]
+                    )[0]
+                elif strcmp(k, kws_align)[0] in ["vertical", "va"]:
+                    align_vertical = strcmp(v, ["top", "center", "bottom"])[0]
+                elif strcmp(k, kws_align)[0] in ["text_rotation", "rotat", "rot"]:
+                    align_rot = v
+                elif strcmp(k, kws_align)[0] in ["wrap_text", "wrap"]:
+                    align_wrap = v
+                elif strcmp(k, kws_align)[0] in [
+                    "shrink_to_fit",
+                    "shrink",
+                    "wrap_text",
+                    "wrap",
+                ]:
+                    align_shrink = v
+                elif strcmp(k, kws_align)[0] in ["indent"]:
+                    align_indent = v
+            cell_alignment = Alignment(
+                horizontal=align_horizontal,
+                vertical=align_vertical,
+                text_rotation=align_rot,
+                wrap_text=align_wrap,
+                shrink_to_fit=align_shrink,
+                indent=align_indent,
+            )
+
+        if strcmp(K, kws_cell)[0] == "border":
+            #! border
+            kws_border = [
+                "color_left",
+                "color_l",
+                "color_right",
+                "color_r",
+                "color_top",
+                "color_t",
+                "color_bottom",
+                "color_b",
+                "color_diagonal",
+                "color_d",
+                "color_outline",
+                "color_o",
+                "color_vertical",
+                "color_v",
+                "color_horizontal",
+                "color_h",
+                "color",
+                "style_left",
+                "style_l",
+                "style_right",
+                "style_r",
+                "style_top",
+                "style_t",
+                "style_bottom",
+                "style_b",
+                "style_diagonal",
+                "style_d",
+                "style_outline",
+                "style_o",
+                "style_vertical",
+                "style_v",
+                "style_horizontal",
+                "style_h",
+                "style",
+            ]
+            # * border color
+            border_color_l, border_color_r, border_color_t, border_color_b = (
+                "FF000000",
+                "FF000000",
+                "FF000000",
+                "FF000000",
+            )
+            border_color_d, border_color_o, border_color_v, border_color_h = (
+                "FF000000",
+                "FF000000",
+                "FF000000",
+                "FF000000",
+            )
+            # get colors config
+            for k, v in cell.get(K, {}).items():
+                if strcmp(k, kws_border)[0] in ["color"]:
+                    border_color_all = hex2argb(v)
+                    # 如果设置了color,表示其它的所有的都设置成为一样的
+                    # 然后再才开始自己定义其它的color
+                    border_color_l, border_color_r, border_color_t, border_color_b = (
+                        border_color_all,
+                        border_color_all,
+                        border_color_all,
+                        border_color_all,
+                    )
+                    border_color_d, border_color_o, border_color_v, border_color_h = (
+                        border_color_all,
+                        border_color_all,
+                        border_color_all,
+                        border_color_all,
+                    )
+                elif strcmp(k, kws_border)[0] in ["color_left", "color_l"]:
+                    border_color_l = hex2argb(v)
+                elif strcmp(k, kws_border)[0] in ["color_right", "color_r"]:
+                    border_color_r = hex2argb(v)
+                elif strcmp(k, kws_border)[0] in ["color_top", "color_t"]:
+                    border_color_t = hex2argb(v)
+                elif strcmp(k, kws_border)[0] in ["color_bottom", "color_b"]:
+                    border_color_b = hex2argb(v)
+                elif strcmp(k, kws_border)[0] in ["color_diagonal", "color_d"]:
+                    border_color_d = hex2argb(v)
+                elif strcmp(k, kws_border)[0] in ["color_outline", "color_o"]:
+                    border_color_o = hex2argb(v)
+                elif strcmp(k, kws_border)[0] in ["color_vertical", "color_v"]:
+                    border_color_v = hex2argb(v)
+                elif strcmp(k, kws_border)[0] in ["color_horizontal", "color_h"]:
+                    border_color_h = hex2argb(v)
+            # *border style
+            border_styles = [
+                "thin",
+                "medium",
+                "thick",
+                "dotted",
+                "dashed",
+                "hair",
+                "mediumDashed",
+                "dashDot",
+                "dashDotDot",
+                "slantDashDot",
+                "none",
+            ]
+            border_style_l, border_style_r, border_style_t, border_style_b = (
+                None,
+                None,
+                None,
+                None,
+            )
+            border_style_d, border_style_o, border_style_v, border_style_h = (
+                None,
+                None,
+                None,
+                None,
+            )
+            # get styles config
+            for k, v in cell.get(K, {}).items():
+                # if not "style" in k:
+                #     break
+                if strcmp(k, kws_border)[0] in ["style"]:
+                    border_style_all = strcmp(v, border_styles)[0]
+                    # 如果设置了style,表示其它的所有的都设置成为一样的
+                    # 然后再才开始自己定义其它的style
+                    border_style_l, border_style_r, border_style_t, border_style_b = (
+                        border_style_all,
+                        border_style_all,
+                        border_style_all,
+                        border_style_all,
+                    )
+                    border_style_d, border_style_o, border_style_v, border_style_h = (
+                        border_style_all,
+                        border_style_all,
+                        border_style_all,
+                        border_style_all,
+                    )
+                elif strcmp(k, kws_border)[0] in ["style_left", "style_l"]:
+                    border_style_l = strcmp(v, border_styles)[0]
+                elif strcmp(k, kws_border)[0] in ["style_right", "style_r"]:
+                    border_style_r = strcmp(v, border_styles)[0]
+                elif strcmp(k, kws_border)[0] in ["style_top", "style_t"]:
+                    border_style_t = strcmp(v, border_styles)[0]
+                elif strcmp(k, kws_border)[0] in ["style_bottom", "style_b"]:
+                    border_style_b = strcmp(v, border_styles)[0]
+                elif strcmp(k, kws_border)[0] in ["style_diagonal", "style_d"]:
+                    border_style_d = strcmp(v, border_styles)[0]
+                elif strcmp(k, kws_border)[0] in ["style_outline", "style_o"]:
+                    border_style_o = strcmp(v, border_styles)[0]
+                elif strcmp(k, kws_border)[0] in ["style_vertical", "style_v"]:
+                    border_style_v = strcmp(v, border_styles)[0]
+                elif strcmp(k, kws_border)[0] in ["style_horizontal", "style_h"]:
+                    border_style_h = strcmp(v, border_styles)[0]
+            # * apply border config
+            border = Border(
+                left=Side(border_style=border_style_l, color=border_color_l),
+                right=Side(border_style=border_style_r, color=border_color_r),
+                top=Side(border_style=border_style_t, color=border_color_t),
+                bottom=Side(border_style=border_style_b, color=border_color_b),
+                diagonal=Side(border_style=border_style_d, color=border_color_d),
+                diagonal_direction=0,
+                outline=Side(border_style=border_style_o, color=border_color_o),
+                vertical=Side(border_style=border_style_v, color=border_color_v),
+                horizontal=Side(border_style=border_style_h, color=border_color_h),
+            )
+
+    #! final apply configs
+    for row in ws[cell_range]:
+        for cell_ in row:
+            if cell_font:
+                cell_.font = cell_font
+            if cell_fill:
+                cell_.fill = cell_fill
+            if cell_alignment:
+                cell_.alignment = cell_alignment
+            if border:
+                cell_.border = border
+
+
+def format_excel(
+    df=None,
+    filename=None,
+    sheet_name=0,
+    usage=False,
+    cell=None,  # dict: or list for multiple locs setting:
+    width=None,  # dict
+    height=None,  # dict e.g., {2: 50, 3: 25},  keys are columns
+    height_max=25,
+    merge=None,  # tuple e.g.,  (slice(0, 1), slice(1, 3)),
+    shade=None,  # dict
+    comment=None,  # dict e.g., {(2, 4): "This is a comment"},
+    link=None,  # dict e.g., {(2, 2): "https://example.com"},
+    protect=None,  # dict
+    number_format=None,  # dict: e.g., {1:"0.00", 2:"#,##0",3:"0%",4:"$#,##0.00"}
+    data_validation=None,  # dict
+    conditional_format=None,  # dict
+    index_default=False,
+    **kwargs,
+):
+    if not isinstance(df, pd.DataFrame):
+        try:
+            print(f"is loading file {os.path.basename(df)}")
+            df = fload(df)
+        except:
+            print(f"check the fpath:{df}")
+    if filename is None:
+        filename = str(datetime.now().strftime("%y%m%d_%H.xlsx"))
+    # !show usage:
+    func_xample = """
+# Example usage
+data = {
+    "Header 1": [10, 2000000, 30],
+    "Header 2": [
+        40000,
+        '"start_color": "4F81BD", "end_color","start_color": "a1cd1e","start_color": "4F81BD", "end_color","start_color": "a1cd1e"',
+        60,
+    ],
+    "Header 3": [70, 80, 90],
+}
+df = pd.DataFrame(data)
+
+
+format_excel(
+    df,
+    filename="example.xlsx",
+    sheet_name="Sheet1",
+    cell=[
+        {
+            (slice(0, 1), slice(0, len(df.columns))): {
+                "font": {
+                    "name": "Calibri",  # Font name
+                    "size": 14,  # Font size
+                    "bold": True,  # Bold text
+                    "italic": False,  # Italic text
+                    "underline": "single",  # Underline (single, double)
+                    "color": "#FFFFFF",  # Font color
+                },
+                "fill": {
+                    "start_color": "a1cd1e",  # Starting color
+                    "end_color": "4F81BD",  # Ending color (useful for gradients)
+                    "fill_type": "solid",  # Fill type (solid, gradient, etc.)
+                },
+                "alignment": {
+                    "horizontal": "center",  # Horizontal alignment (left, center, right)
+                    "vertical": "center",  # Vertical alignment (top, center, bottom)
+                    "wrap_text": True,  # Wrap text in the cell
+                    "shrink_to_fit": True,  # Shrink text to fit within cell
+                    "text_rotation": 0,  # Text rotation angle
+                },
+                "border": {
+                    "left": "thin",
+                    "right": "thin",
+                    "top": "thin",
+                    "bottom": "thin",
+                    "color": "000000",  # Border color
+                },
+            }
+        },
+        {
+            (slice(0, 3), slice(1, 3)): {
+                "font": {
+                    "name": "Arial",  # Font name
+                    "size": 12,  # Font size
+                    "bold": False,  # Bold text
+                    "italic": True,  # Italic text
+                    "underline": None,  # No underline
+                    "color": "#000000",  # Font color
+                },
+                "fill": {
+                    "start_color": "#c61313",  # Background color
+                    "end_color": "#490606",  # End color
+                    "fill_type": "solid",  # Fill type
+                },
+                "alignment": {
+                    "horizontal": "left",  # Horizontal alignment
+                    "vertical": "top",  # Vertical alignment
+                    "wrap_text": True,  # Enable text wrapping
+                    "shrink_to_fit": False,  # Disable shrink to fit
+                    "indent": 1,  # Indentation level
+                    "text_rotation": 0,  # Text rotation angle
+                },
+                "border": {
+                    "left": "thin",  # Left border style
+                    "right": "thin",  # Right border style
+                    "top": "thin",  # Top border style
+                    "bottom": "thin",  # Bottom border style
+                    "color": "000000",  # Border color
+                },
+            }
+            # * border settings
+            # "thin": Thin border line
+            # "medium": Medium border line
+            # "thick": Thick border line
+            # "dotted": Dotted border line
+            # "dashed": Dashed border line
+            # "hair": Hairline border (very thin)
+            # "mediumDashed": Medium dashed border line
+            # "dashDot": Dash-dot border line
+            # "dashDotDot": Dash-dot-dot border line
+            # "slantDashDot": Slant dash-dot border line
+        },
+    ],
+    width={2: 30},  # when it is None, it will automatic adjust width
+    height={2: 50, 3: 25},  # keys are columns
+    merge=(slice(0, 1), slice(1, 3)),
+    shade={
+        (slice(1, 4), slice(1, 3)): {
+            "bg_color": "FFFF00",  # Background color
+            "pattern_type": "solid",  # Fill pattern (e.g., solid, darkGrid, lightGrid)
+            "fg_color": "#0000FF",  # Foreground color, used in patterns
+            "end_color": "0000FF",  # End color, useful for gradients
+            "fill_type": "solid",  # Type of fill (solid, gradient, etc.)
+        }
+    },
+    comment={(2, 4): "This is a comment"},
+    link={(2, 2): "https://example.com"},
+    protect={
+        "password": "123",  # Password for sheet protection
+        "sheet": False,  # True,  # Protect the sheet
+        "objects": False,  # True,  # Protect objects
+        "scenarios": False,  # True,  # Protect scenarios
+        "formatCells": False,  # Disable formatting cells
+        "formatColumns": False,  # Disable formatting columns
+        "formatRows": False,  # Disable formatting rows
+        "insertColumns": False,  # Disable inserting columns
+        "insertRows": False,  # Disable inserting rows
+        "deleteColumns": False,  # Disable deleting columns
+        "deleteRows": False,  # Disable deleting rows
+    },
+    number_format={
+        1: "0.00",  # Two decimal places for column index 1
+        2: "#,##0",  # Thousands separator
+        3: "0%",  # Percentage format
+        4: "$#,##0.00",  # Currency format
+    },
+    data_validation={
+        (slice(1, 2), slice(2, 10)): {
+            "type": "list",
+            "formula1": '"Option1,Option2,Option3"',  # List of options
+            "allow_blank": True,
+            "showDropDown": True,
+            "showErrorMessage": True,
+            "errorTitle": "Invalid input",
+            "error": "Please select a valid option.",
+        }
+    },
+    conditional_format={
+        (slice(1, 2), slice(2, 10)): [
+            {
+                "color_scale": {
+                    "start_type": "min",  # Type of start point (min, max, percent)
+                    "start_color": "#FF0000",  # Starting color
+                    "end_type": "max",  # End type (min, max, percent)
+                    "end_color": "00FF00",  # Ending color
+                    "mid_type": "percentile",  # Midpoint type (optional)
+                    "mid_value": 50,  # Midpoint value (optional)
+                    "mid_color": "FFFF00",  # Midpoint color (optional)
+                }
+            }
+        ]
+    },
+)
+            """
+    if usage:
+        print(func_xample)
+        return None
+    kwargs.pop("format", None)  # 更好地跟fsave结合使用
+
+    # Save DataFrame to Excel file
+    if not index_default:
+        df.to_excel(filename, index=False, **kwargs)
+    else:
+        df.to_excel(filename, **kwargs)
+
+    wb = load_workbook(filename)
+    ws = wb.worksheets[sheet_name]
+
+    # !Apply cell formatting
+    if cell:
+        if not isinstance(cell, list):
+            cell = [cell]
+        for cell_ in cell:
+            for indices, format_options in cell_.items():
+                cell_range = convert_indices_to_range(*indices)
+                apply_format(ws, format_options, cell_range)
+
+    # !Apply cell shading
+    if shade:
+        for indices, shading in shade.items():
+            cell_range = convert_indices_to_range(*indices)
+            fill = PatternFill(
+                start_color=hex2argb(shading.get("bg_color", "FFFFFF")),
+                end_color=hex2argb(shading.get("end_color", "FFFFFF")),
+                fill_type=shading.get("fill_type", "solid"),
+                patternType=shading.get("pattern_type", "solid"),
+                fgColor=hex2argb(shading.get("fg_color", "0000FF")),
+            )
+            for row in ws[cell_range]:
+                for cell in row:
+                    cell.fill = fill
+
+    # !number formatting
+    if number_format:
+        for col_idx, fmt in number_format.items():
+            col_letter = get_column_letter(col_idx)
+            for cell in ws[col_letter][1:]:  # Skip the header
+                cell.number_format = fmt
+
+    # !widths
+    if width is None:  # automatic adust width
+        for col in ws.columns:
+            len_ = [len(str(cell.value)) for cell in col if cell.value]
+            if len_:
+                # scaling_factor = 1.2
+                max_length = max(len_)  # * scaling_factor
+                ws.column_dimensions[get_column_letter(col[0].column)].width = (
+                    max_length
+                )
+    else:
+        for col_idx, width_ in width.items():
+            col_letter = get_column_letter(col_idx)
+            ws.column_dimensions[col_letter].width = width_
+
+    # !heights
+    if height is None:  # automatic adust height
+        for row in ws.iter_rows(min_row=1, max_row=ws.max_row):
+            max_height = height_max
+            for cell in row:
+                if cell.value:
+                    lines = str(cell.value).split("\n")
+                    max_line_length = max(len(line) for line in lines)
+                    estimated_height = 15 * len(lines)
+                    if max_line_length > 20:
+                        estimated_height += 5 * (max_line_length // 20)
+                    max_height = max(max_height, estimated_height)
+            ws.row_dimensions[row[0].row].height = max_height
+    else:
+        for row, height_ in height.items():
+            ws.row_dimensions[row].height = height_
+
+    # !Merge cells using slice indices
+    if merge:
+        if isinstance(merge, tuple):
+            merge = [merge]
+        for indices in merge:
+            # Ensure indices are slice objects
+            if len(indices) == 2:
+                row_slice, col_slice = indices
+                merge_range = convert_indices_to_range(row_slice, col_slice)
+                ws.merge_cells(merge_range)
+            elif len(indices) == 4:
+                start_row, start_col, end_row, end_col = indices
+                # Convert column numbers to letters (e.g., 1 -> 'A')
+                start_cell = f"{get_column_letter(start_col)}{start_row}"
+                end_cell = f"{get_column_letter(end_col)}{end_row}"
+                merge_range = f"{start_cell}:{end_cell}"
+                ws.merge_cells(merge_range)
+            else:
+                raise ValueError(
+                    f"两种方式: 1. format: (start_row, start_col, end_row, end_col), 2. format: (slice(0, 3), slice(1, 2))"
+                )
+
+    # !Add comment
+    if comment:
+        if not isinstance(comment, list):
+            comment = [comment]
+        for comment_ in comment:
+            for (row, col), comment_str in comment_.items():
+                ws.cell(row=row, column=col).comment = Comment(comment_str, "Author")
+
+    # !Add link
+    if link:
+        if not isinstance(link, list):
+            link = [link]
+        for link_ in link:
+            for (row, col), link_str in link_.items():
+                ws.cell(row=row, column=col).hyperlink = link_str
+
+    # !Apply data validation
+    if data_validation:
+        for indices, validation in data_validation.items():
+            cell_range = convert_indices_to_range(*indices)
+            dv = DataValidation(**validation)
+            ws.add_data_validation(dv)
+            dv.add(cell_range)
+
+    # !Protect sheet with a password
+    if protect:
+        ws.protection.password = protect.get("password", False)
+        ws.protection.objects = protect.get("objects", True)
+        ws.protection.sheet = protect.get("sheet", True)
+        ws.protection.scenarios = protect.get("scenarios", True)
+        ws.protection.formatCells = protect.get("formatCells", False)
+        ws.protection.formatColumns = protect.get("formatColumns", False)
+        ws.protection.formatRows = protect.get("formatRows", False)
+        ws.protection.insertColumns = protect.get("insertColumns", True)
+        ws.protection.insertRows = protect.get("insertRows", True)
+        ws.protection.deleteColumns = protect.get("deleteColumns", True)
+        ws.protection.deleteRows = protect.get("deleteRows", True)
+
+    # !conditional formatting
+    if conditional_format:
+        for indices, rules in conditional_format.items():
+            cell_range = convert_indices_to_range(*indices)
+            for rule in rules:
+                if "color_scale" in rule:
+                    color_scale = rule["color_scale"]
+                    start_color = hex2argb(color_scale.get("start_color", "FFFFFF"))
+                    mid_color = hex2argb(color_scale.get("mid_color", "FFFFFF"))
+                    end_color = hex2argb(color_scale.get("end_color", "FFFFFF"))
+
+                    color_scale_rule = ColorScaleRule(
+                        start_type=color_scale.get("start_type", "min"),
+                        start_value=color_scale.get("start_value"),
+                        start_color=start_color,
+                        mid_type=color_scale.get("mid_type"),
+                        mid_value=color_scale.get("mid_value"),
+                        mid_color=mid_color,
+                        end_type=color_scale.get("end_type", "max"),
+                        end_value=color_scale.get("end_value"),
+                        end_color=end_color,
+                    )
+                    ws.conditional_formatting.add(cell_range, color_scale_rule)
+    # Save the workbook
+    wb.save(filename)
+    print(f"Formatted Excel file saved as:\n{filename}")