py2ls 0.2.4.41__py3-none-any.whl → 0.2.5.1__py3-none-any.whl

py2ls/ips.py

@@ -2411,7 +2411,25 @@ def is_df_abnormal(df: pd.DataFrame, verbose=False) -> bool:
     if verbose:
         print("\n".join(messages))
     return is_abnormal  # Data is abnormal
+def decrypt_excel(fpath, password):
+    # * needs a password?
+    import msoffcrypto  # pip install msoffcrypto-tool
+    from io import BytesIO
 
+    # Open the encrypted Excel file
+    with open(fpath, "rb") as f:
+        try:
+            office_file = msoffcrypto.OfficeFile(f)
+            office_file.load_key(password=password)  # Provide the password
+            decrypted = BytesIO()
+            office_file.decrypt(decrypted)
+        except:
+            office_file = msoffcrypto.OfficeFile(f)
+            office_file.load_key(password=depass(password))  # Provide the password
+            decrypted = BytesIO()
+            office_file.decrypt(decrypted)
+    decrypted.seek(0) # reset pointer to start
+    return decrypted
 
 def fload(fpath, kind=None, **kwargs):
     """
@@ -2749,48 +2767,64 @@ def fload(fpath, kind=None, **kwargs):
             display(df.head(2))
             print(f"shape: {df.shape}")
         return df
-
+ 
     def load_excel(fpath, **kwargs):
         engine = kwargs.get("engine", "openpyxl")
         verbose = kwargs.pop("verbose", False)
         password = kwargs.pop("password", None)
+        output = kwargs.pop("output", "DataFrame").lower()
+        sheet_name = kwargs.pop("sheet_name", None)
 
-        if not password:
-            if run_once_within(reverse=True):
-                use_pd("read_excel", verbose=verbose)
-            df = pd.read_excel(fpath, engine=engine, **kwargs)
+        def print_sheet_info(fpath):
             try:
                 meta = pd.ExcelFile(fpath)
                 print(f"n_sheet={len(meta.sheet_names)},\t'sheetname = 0 (default)':")
-                [print(f"{i}:\t{i_}") for i, i_ in enumerate(meta.sheet_names)]
-            except:
-                pass
-            return df
-        # * needs a password?
-        import msoffcrypto  # pip install msoffcrypto-tool
-        from io import BytesIO
+                [print(f"{i}:\t{name}") for i, name in enumerate(meta.sheet_names)]
+            except Exception as e:
+                if verbose:
+                    print(f"Error retrieving sheet info: {e}")
+        if output in ["dataframe", "df"]:
+            if not password:
+                if verbose:
+                    print("Reading Excel without password protection...")
+                df = pd.read_excel(fpath, engine=engine, sheet_name=sheet_name, **kwargs)
+                if verbose:
+                    print_sheet_info(fpath)
+                return df
+            # Handle password-protected DataFrame case
+            else:
+                if verbose:
+                    print("Decrypting and loading DataFrame...")
+                decrypted = decrypt_excel(fpath, password=password)
+                df = pd.read_excel(decrypted, engine=engine,sheet_name=sheet_name, **kwargs)
+                if verbose:
+                    print_sheet_info(fpath)
+                return df
+        # Handle cases for non-dataframe output
+        else:
+            from openpyxl import load_workbook
+            if verbose:
+                print("Returning worksheet (non-DataFrame output)...")
+            if password:
+                decrypted = decrypt_excel(fpath, password=password)
+                workbook = load_workbook(decrypted)
+            else:
+                workbook = load_workbook(fpath)
+
+            # If sheet_name is specified, keep only that sheet
+            if sheet_name:
+                if sheet_name in workbook.sheetnames:
+                    worksheet = workbook[sheet_name]
+                    # Remove all other sheets
+                    for sheet in workbook.sheetnames:
+                        if sheet != sheet_name:
+                            del workbook[sheet]
+                else:
+                    raise ValueError(f"Sheet '{sheet_name}' not found in the workbook.")
+            else:
+                worksheet = workbook.active  # Default to active sheet
 
-        # Open the encrypted Excel file
-        with open(fpath, "rb") as f:
-            try:
-                office_file = msoffcrypto.OfficeFile(f)
-                office_file.load_key(password=password)  # Provide the password
-                decrypted = BytesIO()
-                office_file.decrypt(decrypted)
-            except:
-                office_file = msoffcrypto.OfficeFile(f)
-                office_file.load_key(password=depass(password))  # Provide the password
-                decrypted = BytesIO()
-                office_file.decrypt(decrypted)
-        decrypted.seek(0)
-        df = pd.read_excel(decrypted, engine=engine, **kwargs)
-        try:
-            meta = pd.ExcelFile(fpath)
-            print(f"n_sheet={len(meta.sheet_names)},\t'sheetname = 0 (default)':")
-            [print(f"{i}:\t{i_}") for i, i_ in enumerate(meta.sheet_names)]
-        except:
-            pass
-        return df
+            return workbook
 
     def load_parquet(fpath, **kwargs):
         """
@@ -3019,12 +3053,12 @@ def fload(fpath, kind=None, **kwargs):
         return content
     elif kind == "xlsx":
         verbose = kwargs.pop("verbose", False)
-        content = load_excel(fpath, **kwargs)
-        (
-            display(content.head(3))
-            if isinstance(content, pd.DataFrame) and verbose
-            else None
-        )
+        content = load_excel(fpath, verbose=verbose,**kwargs)
+        # (
+        #     display(content.head(3))
+        #     if isinstance(content, pd.DataFrame) and verbose
+        #     else None
+        # )
         print(f"shape: {content.shape}") if isinstance(content, pd.DataFrame) else None
         return content
     elif kind == "mtx":
@@ -3382,25 +3416,11 @@ def fsave(
             use_pd("to_excel", verbose=verbose)
 
         if any(kwargs):
-            format_excel(df=data, filename=fpath, **kwargs)
+            format_excel(df=data, filename=fpath,sheet_name=sheet_name,password=password, **kwargs)
         else:
             # Remove non-relevant kwargs
-            irrelevant_keys = [
-                "format",
-                "usage",
-                "cell",
-                "width",
-                "height",
-                "height_max",
-                "merge",
-                "shade",
-                "comment",
-                "link",
-                "protect",
-                "number_format",
-                "conditional_format",
-                "index_default",
-            ]
+            irrelevant_keys=list(extract_kwargs(format_excel).keys())[4:]
+            
             for key in irrelevant_keys:
                 kwargs.pop(key, None)
 
@@ -6313,7 +6333,19 @@ def hex2argb(hex_color):
         "Invalid hex color format. Use RRGGBB, #RRGGBB, or aARRGGBB format."
     )
 
+def extract_kwargs(func):
+    import inspect
+
+    # Get the signature of the function
+    signature = inspect.signature(func)
+    # Extract parameters that are kwargs (parameters with default values or **kwargs)
+    kwargs = {
+        param.name: param.default
+        for param in signature.parameters.values()
+        if param.default is not inspect.Parameter.empty
+    }
 
+    return kwargs
 def format_excel(
     df=None,
     filename=None,
@@ -6321,21 +6353,26 @@ def format_excel(
     usage=False,
     cell=None,  # dict: or list for multiple locs setting:
     width=None,  # dict
+    width_factor=2,# calculated with plus this factor
     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"},
+    comment_always_visible:bool=True,# always display 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
-    apply_filter=True, # add filter 
+    apply_filter:bool=True, # add filter 
+    freeze :str= False,#"A2",
     conditional_format=None,  # dict
+    verbose=True,
     **kwargs,
 ):
     import pandas as pd
     from datetime import datetime
+    import openpyxl
     from openpyxl import load_workbook
     from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
     from openpyxl.utils import get_column_letter
@@ -6695,35 +6732,114 @@ def format_excel(
                     cell_.alignment = cell_alignment
                 if border:
                     cell_.border = border
-
-    if not isinstance(df, pd.DataFrame):
+    def generate_unique_sheet_name(wb, sheet_name):
+        """Generate a unique sheet name if the given name already exists in the workbook."""
+        if sheet_name not in wb.sheetnames:
+            return sheet_name
+        counter = 1
+        unique_name = f"{sheet_name}_{counter}"
+        while unique_name in wb.sheetnames:
+            counter += 1
+            unique_name = f"{sheet_name}_{counter}"
+        return unique_name
+    # if it is already worksheet format
+    if isinstance(df, pd.DataFrame):
+        pass
+    elif isinstance(df, openpyxl.worksheet.worksheet.Worksheet) or isinstance(df, openpyxl.workbook.workbook.Workbook):
+        pass
+    elif df is None:
+        if any(filename):
+            df = fload(filename, output="bit")
+    else:
         try:
             print(f"is loading file {os.path.basename(df)}")
             df = fload(df)
-        except:
+        except Exception as e:
+            print(e)
             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)
+    
+    kwargs.pop("format", None)  # 更好地跟fsave结合使用
+    kwargs.pop("sheet_name", 0)  # 更好地跟df.to_excel结合使用
+    # 只有openpyxl才支持 append
+    mode = strcmp(kwargs.get("mode", "auto"), ["a", "w","auto"])[0]
+    kwargs.pop("mode", None)
+    engine = strcmp(kwargs.get("engine", "openpyxl"), ["xlsxwriter", "openpyxl"])[0]
+    # 通常是不需要保存index的
+    index = kwargs.get("index", False)
+    kwargs.pop("index", None)
+    # header
+    header=kwargs.pop("header",False)
 
+    if isinstance(df, openpyxl.workbook.workbook.Workbook):
+        wb=df
+        try:
+            ws = wb.worksheets[sheet_name]
+        except Exception as e:
+            print(e)
+            if not os.path.exists(filename) or mode=="w":
+                ws=wb.active
+                ws.title = sheet_name
+            else:# file exists
+                wb = load_workbook(filename)
+                # check the shtname and get the new sheet_name
+                sheet_name_corr=generate_unique_sheet_name(wb, sheet_name)
+                
+                # Save the workbook with the new sheet name
+                with pd.ExcelWriter(filename, mode="a", engine=engine, if_sheet_exists="new") 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_corr, 
+                                       index=index,
+                                       header=header,
+                                       **kwargs) 
+                wb = load_workbook(filename)
+                print(sheet_name,sheet_name_corr)
+                print(wb.sheetnames)
+                if sheet_name_corr in wb.sheetnames:
+                    ws = wb[sheet_name_corr]
+                    if not sheet_name==sheet_name_corr:
+                        wb.remove(wb[sheet_name])
+                else:
+                    raise KeyError(f"Worksheet {sheet_name_corr} does not exist.") 
+    else:
+        if not os.path.exists(filename) or mode=="w": # or overwrite
+            # save file
+            sheet_name_corr = (
+                sheet_name if isinstance(sheet_name, str) else f"Sheet_{sheet_name}"
+            )
+            with pd.ExcelWriter(filename, mode="w", engine=engine) as writer:
+                df.to_excel(writer, sheet_name=sheet_name_corr, index=index, header=header,**kwargs)
+            wb = load_workbook(filename)
+            if isinstance(sheet_name, str):
+                ws = wb[sheet_name]
+            elif isinstance(sheet_name, int):
+                ws = wb.worksheets[sheet_name]
+            else:
+                ws = wb.worksheets[sheet_name]  # the index of worksheets
+        else:# file exists
+            wb = load_workbook(filename)
+            sheet_name_corr = generate_unique_sheet_name(wb, sheet_name) 
+            with pd.ExcelWriter(filename, mode="a", engine=engine, if_sheet_exists="new") as writer:
+                df.to_excel(writer, sheet_name=sheet_name_corr, index=index, header=header,**kwargs)
+            wb = load_workbook(filename)
+            if sheet_name_corr in wb.sheetnames:
+                ws = wb[sheet_name_corr]
+            else:
+                raise KeyError(f"Worksheet {sheet_name_corr} does not exist.") 
 
-            format_excel(
-                df,
-                filename="example.xlsx",
-                sheet_name="Sheet1",
-                cell=[
+    # !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)
+        if verbose:
+            cell_tmp="""cell=[
                     {
                         (slice(0, 1), slice(0, len(df.columns))): {
                             "font": {
@@ -6754,180 +6870,64 @@ def format_excel(
                                 "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
+                    },{}]"""
+            print(cell_tmp)
+    # !Apply cell shading
+    if shade:
+        if not isinstance(shade, list):
+            shade = [shade]
+        for shade_ in 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
+        if verbose:
+            shade_temp="""shade={        
+                        (slice(1, 4), slice(1, 3)): {
+                        "bg_color": "#63C187",  # 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结合使用
-    kwargs.pop("sheet_name", None)  # 更好地跟df.to_excel结合使用
-    sheet_name_corr = (
-        sheet_name if isinstance(sheet_name, str) else f"Sheet_{sheet_name}"
-    )
-
-    # 只有openpyxl才支持 append
-    mode = strcmp(kwargs.get("mode", "w"), ["a", "w"])[0]
-    kwargs.pop("mode", None)
-    engine = strcmp(kwargs.get("engine", "openpyxl"), ["xlsxwriter", "openpyxl"])[0]
-    # 通常是不需要保存index的
-    index = kwargs.get("index", False)
-    kwargs.pop("index", None)
-    # save file
-    with pd.ExcelWriter(filename, mode=mode, engine=engine) as writer:
-        df.to_excel(writer, sheet_name=sheet_name_corr, index=index, **kwargs)
-
-    wb = load_workbook(filename)
-    if isinstance(sheet_name, str):
-        ws = wb[sheet_name]
-    elif isinstance(sheet_name, int):
-        ws = wb.worksheets[sheet_name]
-    else:
-        ws = wb.worksheets[sheet_name]  # the index of worksheets
-
-    # !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
-
+                    }}"""
+            print(shade_temp)
     # !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
+        if not isinstance(number_format, list):
+            number_format = [number_format]
+        for number_format_ in 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
+        if verbose:
+            number_format_temp="""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
+                            }""" 
+            print(number_format_temp)
     
+    if freeze:
+        ws.freeze_panes = freeze  # Freeze everything above and to the left of A2
     if apply_filter:
         if isinstance(apply_filter, bool):
             # Default: Apply filter to the entire first row (header)
             filter_range = f"A1:{get_column_letter(ws.max_column)}1"
             ws.auto_filter.ref = filter_range
-            
+        if not freeze:
+            ws.freeze_panes = "A2"  # Freeze everything above and to the left of A2
         elif isinstance(apply_filter, tuple):
             row_slice, col_slice = apply_filter
-            
             # Extract the start and end indices for rows and columns
             start_row, end_row = row_slice.start, row_slice.stop
             start_col_idx, end_col_idx = col_slice.start, col_slice.stop
@@ -6947,20 +6947,30 @@ def format_excel(
 
             # Apply the filter
             ws.auto_filter.ref = filter_range
+            if freeze:
+                ws.freeze_panes = freeze  # Freeze everything above and to the left of A2
     # !widths
     if width is None:  # automatic adust width
         for col in ws.columns:
             max_length = 0
-            column = col[0].column_letter  # Get the column letter
+            """column = col[0].column_letter  # Get the column letter"""
+                    # Check the first cell in the column to get the column letter
+            cell_first = col[0]
+
+            # Check if the cell is part of a merged range
+            if not any(cell_first.coordinate in range_ for range_ in ws.merged_cells.ranges):
+                column = get_column_letter(cell_first.column)  # Get the column letter from the first cell
+            else:
+                # Skip the column if the first cell is merged
+                continue
             for cell_ in col:
                 try:
                     if cell_.value:
                         max_length = max(max_length, len(str(cell_.value)))
                 except Exception:
                     pass
-            adjusted_width = max_length + 2  # You can adjust the padding value as needed
+            adjusted_width = max_length + width_factor  # You can adjust the padding value as needed
             ws.column_dimensions[column].width = adjusted_width
-
     else:
         for col_idx, width_ in width.items():
             col_letter = get_column_letter(col_idx)
@@ -7010,11 +7020,28 @@ def format_excel(
         if not isinstance(comment, list):
             comment = [comment]
         for comment_ in comment:
+            if not isinstance(comment_, dict):
+                raise TypeError("Each item in the `comments` list must be a dictionary.")
+        
             for (row, col), comment_str in comment_.items():
-                ws.cell(row=row + 1, column=col + 1).comment = Comment(
-                    comment_str, "Author"
-                )
-
+                if not isinstance(row, int) or not isinstance(col, int):
+                    raise ValueError("Row and column indices must be integers.")
+                if not isinstance(comment_str, str):
+                    raise ValueError("Comment text must be a string.")
+
+                comment_curr = Comment(comment_str, "Author")
+                comment_curr.visible = comment_always_visible
+                # if comment_always_visible:
+                #     comment_curr.width = 200  # Adjust width
+                #     comment_curr.height = 100  # Adjust height
+                ws.cell(row=row + 1, column=col + 1).comment = comment_curr
+        if verbose:
+            comment_tmp="""comment=[
+                        {(0, 0): "This is a comment for A1"},
+                        {(1, 1): "This is a comment for B2"},
+                        {(2, 2): "This is a comment for C3"},
+                    ]"""
+            print(comment_tmp)
     # !Add link
     if link:
         if not isinstance(link, list):
@@ -7022,7 +7049,8 @@ def format_excel(
         for link_ in link:
             for (row, col), link_str in link_.items():
                 ws.cell(row=row + 1, column=col + 1).hyperlink = link_str
-
+        if verbose:
+            print('link={(2, 2): "https://example.com"}')
     # !Apply data validation
     if data_validation:
         for indices, validation in data_validation.items():
@@ -7030,70 +7058,131 @@ def format_excel(
             dv = DataValidation(**validation)
             ws.add_data_validation(dv)
             dv.add(cell_range)
-
+        if verbose:
+            print("""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.",
+                        }
+                    }"""
+                  )
     # !Protect sheet with a password
-    if protect:
-        ws.protection.password = protect.get("password", False)
+    # Fetch the password
+    password = kwargs.pop("password", None)  # Use kwargs if provided
+    print(password)
+    if all([password is not None, any([protect, isinstance(password, (str, list, tuple)) and any(password)])]):  # Check if protection options are provided
+        if protect is None:
+            protect={}
+        password = password or protect.get("password")  # Default to 'protect' password if not set
+        if password:  # Apply password protection if provided
+            ws.protection.password = password
+        ws.protection.sheet = protect.get("sheet", bool(password))
         ws.protection.objects = protect.get("objects", True)
-        ws.protection.sheet = protect.get("sheet", True)
-        ws.protection.scenarios = protect.get("scenarios", True)
+        # Formatting options
+        ws.protection.scenarios = protect.get("scenarios", False)
         ws.protection.formatCells = protect.get("formatCells", False)
         ws.protection.formatColumns = protect.get("formatColumns", False)
         ws.protection.formatRows = protect.get("formatRows", False)
+        # Insert and delete options
         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)
+        # Select locked or unlocked cells
+        ws.protection.selectLockedCells = protect.get("selectLockedCells", False)
+        ws.protection.selectUnlockedCells = protect.get("selectUnlockedCells", False)
+
 
     # !conditional formatting
     if conditional_format:
-        for indices, rules in conditional_format.items():
-            cell_range = convert_indices_to_range(*indices)
-            for rule in rules:
-                # Handle color scale
-                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)
-                # Handle data bar
-                if "data_bar" in rule:
-                    data_bar = rule["data_bar"]
-                    bar_color = hex2argb(data_bar.get("color", "638EC6"))
-
-                    data_bar_rule = DataBarRule(
-                        start_type=data_bar.get("start_type", "min"),
-                        start_value=data_bar.get("start_value"),
-                        end_type=data_bar.get("end_type", "max"),
-                        end_value=data_bar.get("end_value"),
-                        color=bar_color,
-                        showValue=data_bar.get("show_value", True),
-                    )
-                    ws.conditional_formatting.add(cell_range, data_bar_rule)
-
-                # Handle icon set
-                if "icon_set" in rule:
-                    icon_set = rule["icon_set"]
-                    icon_set_rule = IconSet(
-                        iconSet=icon_set.get("iconSet", "3TrafficLights1"),  # Corrected
-                        showValue=icon_set.get("show_value", True),        # Corrected
-                        reverse=icon_set.get("reverse", False)            # Corrected
-                    )
-                    ws.conditional_formatting.add(cell_range, icon_set_rule)
-
+        if not isinstance(conditional_format, list):
+            conditional_format = [conditional_format]
+        print(f"conditional_format dict setting: 'color_scale', 'data_bar' and 'icon_set[not-ready]'")
+        for conditional_format_ in conditional_format:
+            for indices, rules in conditional_format_.items():
+                cell_range = convert_indices_to_range(*indices)
+                if not isinstance(rules, list):
+                    rules=[rules]
+                for rule in rules:
+                    # Handle color scale
+                    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)
+                    # Handle data bar
+                    if "data_bar" in rule:
+                        data_bar = rule["data_bar"]
+                        bar_color = hex2argb(data_bar.get("color", "638EC6"))
+
+                        data_bar_rule = DataBarRule(
+                            start_type=data_bar.get("start_type", "min"),
+                            start_value=data_bar.get("start_value"),
+                            end_type=data_bar.get("end_type", "max"),
+                            end_value=data_bar.get("end_value"),
+                            color=bar_color,
+                            showValue=data_bar.get("show_value", True),
+                        )
+                        ws.conditional_formatting.add(cell_range, data_bar_rule)
+
+                    # Handle icon set
+                    if "icon_set" in rule:
+                        icon_set = rule["icon_set"]
+                        icon_set_rule = IconSet(
+                            iconSet=icon_set.get("iconSet", "3TrafficLights1"),  # Corrected
+                            showValue=icon_set.get("show_value", True),        # Corrected
+                            reverse=icon_set.get("reverse", False)            # Corrected
+                        )
+                        ws.conditional_formatting.add(cell_range, icon_set_rule)
+        if verbose:
+            conditional_format_temp="""
+                    conditional_format={
+                            (slice(1, 3), slice(1, 4)): [
+                                {
+                                    "data_bar": {
+                                        "start_type": "min",
+                                        "start_value": 100,
+                                        "end_type": "max",
+                                        "end_value": None,
+                                        "color": "F6C9CE",
+                                        "show_value": True,
+                                    }
+                                },
+                                {
+                                    "color_scale": {
+                                        "start_type": "min",
+                                        "start_value": 0,
+                                        "start_color": "#74ADE9",
+                                        "mid_type": "percentile",
+                                        "mid_value": 50,
+                                        "mid_color": "74ADE9",
+                                        "end_type": "max",
+                                        "end_value": 100,
+                                        "end_color": "#B62833",
+                                    }
+                                },
+                            ]
+                        }
+            """
+            print(conditional_format_temp)
 
     # Save the workbook
     wb.save(filename)

{py2ls-0.2.4.41.dist-info → py2ls-0.2.5.1.dist-info}/METADATA

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

{py2ls-0.2.4.41.dist-info → py2ls-0.2.5.1.dist-info}/RECORD

@@ -243,7 +243,7 @@ py2ls/export_requirements.py,sha256=x2WgUF0jYKz9GfA1MVKN-MdsM-oQ8yUeC6Ua8oCymio,
 py2ls/fetch_update.py,sha256=9LXj661GpCEFII2wx_99aINYctDiHni6DOruDs_fdt8,4752
 py2ls/freqanalysis.py,sha256=F4218VSPbgL5tnngh6xNCYuNnfR-F_QjECUUxrPYZss,32594
 py2ls/ich2ls.py,sha256=3E9R8oVpyYZXH5PiIQgT3CN5NxLe4Dwtm2LwaeacE6I,21381
-py2ls/ips.py,sha256=0TSkiUeDnskSJq_kFZcVqP7TC_OqKScibIYMV8CdK3I,427412
+py2ls/ips.py,sha256=feg70WFrLxtO-nx7Zvc62Snk4XHvCFdpdJk6J5K5f5k,432563
 py2ls/ml2ls.py,sha256=I-JFPdikgEtfQjhv5gBz-QSeorpTJI_Pda_JwkTioBY,209732
 py2ls/mol.py,sha256=AZnHzarIk_MjueKdChqn1V6e4tUle3X1NnHSFA6n3Nw,10645
 py2ls/netfinder.py,sha256=OhqD3S9PuwweL2013D-q4GNP1WvJjuYfZzq5BZgGddE,68980
@@ -255,6 +255,6 @@ py2ls/sleep_events_detectors.py,sha256=bQA3HJqv5qnYKJJEIhCyhlDtkXQfIzqksnD0YRXso
 py2ls/stats.py,sha256=qBn2rJmNa_QLLUqjwYqXUlGzqmW94sgA1bxJU2FC3r0,39175
 py2ls/translator.py,sha256=77Tp_GjmiiwFbEIJD_q3VYpQ43XL9ZeJo6Mhl44mvh8,34284
 py2ls/wb_detector.py,sha256=7y6TmBUj9exCZeIgBAJ_9hwuhkDh1x_-yg4dvNY1_GQ,6284
-py2ls-0.2.4.41.dist-info/METADATA,sha256=GUlpSQFP_zxyWdEtxXOhxeOMvcYGi5Vj9Ik4Py44O_A,20441
-py2ls-0.2.4.41.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-py2ls-0.2.4.41.dist-info/RECORD,,
+py2ls-0.2.5.1.dist-info/METADATA,sha256=rhiKgjEDp6x6mkBonb6xGelg00roAhr7NaeZYCfmhuM,20440
+py2ls-0.2.5.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+py2ls-0.2.5.1.dist-info/RECORD,,