py2ls 0.2.5.5__py3-none-any.whl → 0.2.5.7__py3-none-any.whl

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
+from typing import List, Optional, Union,Any
 
 from regex import X
 
@@ -169,6 +169,11 @@ def run_every(when: str = None, job=None, wait: int = 60):
 
     :param when: String specifying the interval, e.g. '2 minutes', '4 hours', '1 day'.
     :param job: The function to be scheduled.
+
+    # usage:
+        def job():
+            print("1 sec")
+        run_every(when="1 sec", job=job)
     """
     import schedule
     import time
@@ -201,19 +206,17 @@ def run_every(when: str = None, job=None, wait: int = 60):
     while True:
         schedule.run_pending()
         time.sleep(wait)  # in seconds
-    time.sleep(wait)  # in seconds
-
-
-# # usage:
-# def job():
-#     print("1 sec")
-# run_every(when="1 sec", job=job)
-
-
+    time.sleep(wait)  # in seconds 
 def run_at(when: str, job=None, wait: int = 60):
     """
     Schedules a job to run at an exact time of the day.
 
+    # Example usage:
+    def my_job():
+        print("Job executed at the exact time!")
+    # Schedule the job at 14:30 when day
+    run_at(when="1.30 pm", job=my_job)
+
     :param when: String specifying the time, e.g. '1:30 pm','1.30 am','14:30', '1:30 pm', '8:45 am'.
     :param job: The function to be scheduled.
     :param wait: The sleep interval between checks in seconds.
@@ -241,13 +244,10 @@ def run_at(when: str, job=None, wait: int = 60):
             f"Invalid time format: {when}. Use 'HH:MM' (24-hour) or 'H:MM AM/PM' format."
         )
         return
-
     print(f"Job scheduled to run at {scheduled_time}.")
-
     # Keep checking the current time
     while True:
         now = datetime.now()
-
         # Check if current time matches the scheduled time
         if (
             now.time().hour == scheduled_time.hour
@@ -259,14 +259,7 @@ def run_at(when: str, job=None, wait: int = 60):
             )  # Sleep for a minute to avoid running the job multiple times in the same minute
 
         time.sleep(wait)  # wait to avoid excessive CPU usage
-
-
-# # Example usage:
-# def my_job():
-#     print("Job executed at the exact time!")
-# # Schedule the job at 14:30 when day
-# run_at(when="1.30 pm", job=my_job)
-
+ 
 # ************* above section: run_when *************
 
 
@@ -344,12 +337,7 @@ def get_version(pkg):
     if isinstance(pkg, str):
         get_v(pkg)
     elif isinstance(pkg, list):
-        [get_v(pkg_) for pkg_ in pkg]
-
-
-# usage:
-# get_version(['pandas','numpy','py2ls'])
-
+        [get_v(pkg_) for pkg_ in pkg] 
 
 def rm_folder(folder_path, verbose=True):
     import shutil
@@ -387,32 +375,11 @@ def fremove(path, verbose=True):
     except Exception as e:
         if verbose:
             print(f"Failed to delete {path}. Reason: {e}")
-
-
-# def get_cwd(verbose: bool = True):
-#     """
-#     get_cwd: to get the current working directory
-#     Args:
-#         verbose (bool, optional): to show which function is use. Defaults to True.
-#     """
-#     try:
-#         script_dir = os.path.dirname(os.path.abspath(__file__))
-#         if verbose:
-#             print("os.path.dirname(os.path.abspath(__file__)):", script_dir)
-#     except NameError:
-#         # This works in an interactive environment (like a Jupyter notebook)
-#         script_dir = os.getcwd()
-#         if verbose:
-#             print("os.getcwd():", script_dir)
-#     return script_dir
-
-
+ 
 def get_cwd():
     from pathlib import Path
-
     # Get the current script's directory as a Path object
     current_directory = Path(__file__).resolve().parent
-
     return current_directory
 
 
@@ -530,12 +497,9 @@ def echo(*args, **kwargs):
 
 def chat(*args, **kwargs):
     return echo(*args, **kwargs)
-
-
 def ai(*args, **kwargs):
     return echo(*args, **kwargs)
 
-
 def detect_lang(text, output="lang", verbose=True):
     from langdetect import detect
 
@@ -565,10 +529,6 @@ def is_text(s):
     # no_special = not re.search(r'[^A-Za-z0-9\s]', s)
     return has_alpha and has_non_alpha
 
-
-from typing import Any, Union
-
-
 def share(*args, strict=True, n_shared=2, verbose=True):
     """
     check the shared elelements in two list.
@@ -1097,7 +1057,365 @@ def imgcmp(
     else:
         raise ValueError("Invalid method. Use 'ssim', 'match', or 'knn'.")
 
+def fcmp(file1, file2, kind= None, verbose=True, **kwargs):
+    import pandas as pd
+    import os
+    from concurrent.futures import ThreadPoolExecutor
+    from datetime import datetime
+    import json
+
+    # --- Compare excel files ---
+    def cmp_excel(
+        file1,# base
+        file2,  # new
+        sheet_name=None,  # list or strings; default:"common" sheet
+        key_columns=None,
+        ignore_columns=None,
+        numeric_tolerance=0,
+        ignore_case=False,
+        detect_reordered_rows=False,
+        verbose=True,
+        **kwargs,
+    ):
+        """
+        Compare two Excel files and identify differences across specified sheets.
+
+        Parameters:
+        - file1 (Base/Reference): str, path to the first Excel file.
+        - file2: str, path to the second Excel file.
+        - sheet_name: list of str, specific sheets to compare (default: all common sheets).
+        - key_columns: list of str, columns to use as unique identifiers (default: None, compares all columns).
+        - ignore_columns: list of str, columns to exclude from comparison (default: None).
+        - numeric_tolerance: float, tolerance for numeric column differences (default: 0, exact match).
+        - ignore_case: bool, whether to ignore case differences (default: False).  # Changed here
+        - detect_reordered_rows: bool, whether to detect reordered rows (default: False).
+        - verbose: bool, whether to print progress messages (default: True).
+
+        Returns:
+        - dict, summary of differences for each sheet.
+        """
+        # Define output directory based on file1 basename
+        file1_basename = os.path.splitext(os.path.basename(file1))[0]
+        output_dir = f"CMP_{file1_basename}"
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+
+        # Load both files into a dictionary of DataFrames
+        xl1 = pd.ExcelFile(file1)
+        xl2 = pd.ExcelFile(file2)
+
+        # Get the sheets to compare
+        sheets1 = set(xl1.sheet_names)
+        sheets2 = set(xl2.sheet_names)
+        if sheet_name is None:
+            sheet_name = list(sheets1 & sheets2)  # Compare only common sheets
+        else:
+            sheet_name = [sheet for sheet in sheet_name if sheet in sheets1 and sheets2]
+
+        summary = {}
+        print(f"Reference file: '{os.path.basename(file1)}'")
+        def compare_sheet(sheet):
+            
+            if verbose:
+                print(f"Comparing sheet: {sheet}...")
+
+            # Read sheets as DataFrames
+            df1 = xl1.parse(sheet).fillna("NA")
+            df2 = xl2.parse(sheet).fillna("NA")
+
+            # Handle case insensitivity
+            if ignore_case:
+                df1.columns = [col.lower() for col in df1.columns]
+                df2.columns = [col.lower() for col in df2.columns]
+                df1 = df1.applymap(lambda x: x.lower() if isinstance(x, str) else x)
+                df2 = df2.applymap(lambda x: x.lower() if isinstance(x, str) else x)
+
+            # Drop ignored columns
+            if ignore_columns:
+                df1 = df1.drop(
+                    columns=[col for col in ignore_columns if col in df1.columns],
+                    errors="ignore",
+                )
+                df2 = df2.drop(
+                    columns=[col for col in ignore_columns if col in df2.columns],
+                    errors="ignore",
+                )
+
+            # Normalize column order for comparison
+            common_cols = df1.columns.intersection(df2.columns)
+            df1 = df1[common_cols]
+            df2 = df2[common_cols]
+
+            # Specify key columns for comparison
+            if key_columns:
+                df1 = df1.set_index(key_columns)
+                df2 = df2.set_index(key_columns)
+            # Identify added and deleted rows based on entire row comparison, not just index
+            added_rows = df2[~df2.apply(tuple, 1).isin(df1.apply(tuple, 1))]
+            deleted_rows = df1[~df1.apply(tuple, 1).isin(df2.apply(tuple, 1))]
+
+            # Detect reordered rows
+            reordered_rows = pd.DataFrame()
+            if detect_reordered_rows:
+                # Find rows that exist in both DataFrames but are in different positions
+                for idx in df1.index:
+                    if idx in df2.index:
+                        if not df1.loc[idx].equals(df2.loc[idx]):
+                            reordered_rows = reordered_rows.append(df1.loc[idx])
+
+            # Detect modified rows (in case of exact matches between the two files)
+            aligned_df1 = df1[df1.index.isin(df2.index)]
+            aligned_df2 = df2[df2.index.isin(df1.index)]
+
+            if numeric_tolerance > 0:
+                modified_rows = aligned_df1.compare(
+                    aligned_df2,
+                    keep_shape=False,
+                    keep_equal=False,
+                    result_names=["left", "right"],
+                ).pipe(
+                    lambda df: df[
+                        ~df.apply(
+                            lambda row: (
+                                abs(row["left"] - row["right"]) <= numeric_tolerance
+                                if pd.api.types.is_numeric_dtype(row["left"])
+                                else False
+                            ),
+                            axis=1,
+                        )
+                    ]
+                )
+            else:
+                modified_rows = aligned_df1.compare(
+                    aligned_df2, keep_shape=False, keep_equal=False
+                )
+
+            # Save differences to Excel files
+            sheet_dir = os.path.join(output_dir, sheet)
+            os.makedirs(sheet_dir, exist_ok=True)
+            added_path = os.path.join(sheet_dir, f"{sheet}_added.xlsx")
+            deleted_path = os.path.join(sheet_dir, f"{sheet}_deleted.xlsx")
+            modified_path = os.path.join(sheet_dir, f"{sheet}_modified.xlsx")
+            reordered_path = os.path.join(sheet_dir, f"{sheet}_reordered.xlsx")
+
+            if not added_rows.empty:
+                added_rows.to_excel(added_path)
+            if not deleted_rows.empty:
+                deleted_rows.to_excel(deleted_path)
+            if not modified_rows.empty:
+                modified_rows.to_excel(modified_path)
+            if not reordered_rows.empty:
+                reordered_rows.to_excel(reordered_path)
+
+            # Return the summary
+            return {
+                "added_rows": len(added_rows),
+                "deleted_rows": len(deleted_rows),
+                "modified_rows": len(modified_rows),
+                "reordered_rows": len(reordered_rows),
+                "added_file": added_path if not added_rows.empty else None,
+                "deleted_file": deleted_path if not deleted_rows.empty else None,
+                "modified_file": modified_path if not modified_rows.empty else None,
+                "reordered_file": reordered_path if not reordered_rows.empty else None,
+            }
+
+        # Use ThreadPoolExecutor for parallel processing
+        with ThreadPoolExecutor() as executor:
+            results = executor.map(compare_sheet, sheet_name)
+
+        # Collect results
+        summary = {sheet: result for sheet, result in zip(sheet_name, results)}
+
+        # Save JSON log
+        json_path = os.path.join(output_dir, "comparison_summary.json")
+        if os.path.exists(json_path):
+            with open(json_path, "r") as f:
+                existing_data = json.load(f)
+        else:
+            existing_data = {}
+
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        existing_data[timestamp] = summary
+        # Sort the existing data by the timestamp in descending order (latest first)
+        existing_data = dict(sorted(existing_data.items(), reverse=True))
+
+        with open(json_path, "w") as f:
+            json.dump(existing_data, f, indent=4)
+        if verbose:
+            print(f"Comparison complete. Results saved in '{output_dir}'")
+
+        return summary
+
+    # --- Compare CSV files ---
+    def cmp_csv(
+        file1,
+        file2,
+        ignore_case=False,
+        numeric_tolerance=0,
+        ignore_columns=None,
+        verbose=True,
+        **kwargs,
+    ):
+        import pandas as pd
+
+        # Load data and fill NaNs
+        df1 = pd.read_csv(file1).fillna("NA")
+        df2 = pd.read_csv(file2).fillna("NA")
+
+        # Standardize case if needed
+        if ignore_case:
+            df1.columns = df1.columns.str.lower()
+            df2.columns = df2.columns.str.lower()
+            df1 = df1.applymap(lambda x: x.lower() if isinstance(x, str) else x)
+            df2 = df2.applymap(lambda x: x.lower() if isinstance(x, str) else x)
+
+        # Drop ignored columns
+        if ignore_columns:
+            ignore_columns = [col.lower() if ignore_case else col for col in ignore_columns]
+            df1.drop(columns=[col for col in ignore_columns if col in df1.columns], errors="ignore", inplace=True)
+            df2.drop(columns=[col for col in ignore_columns if col in df2.columns], errors="ignore", inplace=True)
+
+        # Reset index to ensure alignment
+        df1.reset_index(drop=True, inplace=True)
+        df2.reset_index(drop=True, inplace=True)
+
+        # Align DataFrames by columns
+        df1, df2 = df1.align(df2, join="inner", axis=1)
+
+        # Compare rows
+        added_rows = df2[~df2.apply(tuple, axis=1).isin(df1.apply(tuple, axis=1))]
+        deleted_rows = df1[~df1.apply(tuple, axis=1).isin(df2.apply(tuple, axis=1))]
+
+        # Compare modified rows
+        if numeric_tolerance > 0:
+            def numeric_diff(row):
+                if pd.api.types.is_numeric_dtype(row["left"]):
+                    return abs(row["left"] - row["right"]) > numeric_tolerance
+                return row["left"] != row["right"]
+
+            modified_rows = df1.compare(df2, keep_shape=True, keep_equal=False)
+            modified_rows = modified_rows[modified_rows.apply(numeric_diff, axis=1)]
+        else:
+            modified_rows = df1.compare(df2, keep_shape=True, keep_equal=False)
+
+        # Return results
+        return {
+            "added_rows": len(added_rows),
+            "deleted_rows": len(deleted_rows),
+            "modified_rows": len(modified_rows),
+            "added_file": added_rows if not added_rows.empty else pd.DataFrame(),
+            "deleted_file": deleted_rows if not deleted_rows.empty else pd.DataFrame(),
+            "modified_file": modified_rows if not modified_rows.empty else pd.DataFrame(),
+        }
+
+    # --- Compare JSON files ---
+    def cmp_json(
+        file1, file2, ignore_case=False, numeric_tolerance=0, verbose=True, **kwargs
+    ):
+        import json
+
+        with open(file1, "r") as f1:
+            json1 = json.load(f1)
+        with open(file2, "r") as f2:
+            json2 = json.load(f2)
+
+        # Normalize case and compare JSONs
+        if ignore_case:
+
+            def normalize(obj):
+                if isinstance(obj, dict):
+                    return {k.lower(): normalize(v) for k, v in obj.items()}
+                elif isinstance(obj, list):
+                    return [normalize(item) for item in obj]
+                elif isinstance(obj, str):
+                    return obj.lower()
+                else:
+                    return obj
+
+            json1 = normalize(json1)
+            json2 = normalize(json2)
+
+        # Compare JSONs
+        def compare_json(obj1, obj2):
+            if isinstance(obj1, dict) and isinstance(obj2, dict):
+                added_keys = {k: obj2[k] for k in obj2 if k not in obj1}
+                deleted_keys = {k: obj1[k] for k in obj1 if k not in obj2}
+                modified_keys = {
+                    k: (obj1[k], obj2[k])
+                    for k in obj1
+                    if k in obj2 and obj1[k] != obj2[k]
+                }
+                return added_keys, deleted_keys, modified_keys
+
+            elif isinstance(obj1, list) and isinstance(obj2, list):
+                added_items = [item for item in obj2 if item not in obj1]
+                deleted_items = [item for item in obj1 if item not in obj2]
+                modified_items = [
+                    (item1, item2) for item1, item2 in zip(obj1, obj2) if item1 != item2
+                ]
+                return added_items, deleted_items, modified_items
+
+            else:
+                if obj1 != obj2:
+                    return obj1, obj2, None
+                else:
+                    return None, None, None
+
+        added, deleted, modified = compare_json(json1, json2)
 
+        return {"added_keys": added, "deleted_keys": deleted, "modified_keys": modified}
+
+    # --- Compare Text files ---
+    def cmp_txt(
+        file1, file2, ignore_case=False, numeric_tolerance=0, verbose=True, **kwargs
+    ):
+        def read_lines(file):
+            with open(file, "r") as f:
+                return f.readlines()
+
+        lines1 = read_lines(file1)
+        lines2 = read_lines(file2)
+
+        if ignore_case:
+            lines1 = [line.lower() for line in lines1]
+            lines2 = [line.lower() for line in lines2]
+
+        added_lines = [line for line in lines2 if line not in lines1]
+        deleted_lines = [line for line in lines1 if line not in lines2]
+
+        modified_lines = []
+        if numeric_tolerance > 0:
+            for line1, line2 in zip(lines1, lines2):
+                if abs(float(line1) - float(line2)) > numeric_tolerance:
+                    modified_lines.append((line1, line2))
+        else:
+            for line1, line2 in zip(lines1, lines2):
+                if line1 != line2:
+                    modified_lines.append((line1, line2))
+
+        return {
+            "added_lines": added_lines,
+            "deleted_lines": deleted_lines,
+            "modified_lines": modified_lines,
+        }
+
+    if kind is None:
+        kind = os.path.splitext(file1)[1].lower()[1:]
+    # Compare based on the file type
+    if kind == "xlsx":
+        return cmp_excel(file1=file1, file2=file2, verbose=verbose, **kwargs)
+
+    elif kind == "csv":
+        return cmp_csv(file1=file1, file2=file2, verbose=verbose, **kwargs)
+
+    elif kind == "json":
+        return cmp_json(file1=file1, file2=file2, verbose=verbose, **kwargs)
+
+    elif kind == "txt":
+        return cmp_txt(file1=file1, file2=file2, verbose=verbose, **kwargs)
+
+    else:
+        raise ValueError(f"Unsupported file type: {kind}")
 def cn2pinyin(
     cn_str: Union[str, list] = None,
     sep: str = " ",
@@ -1188,21 +1506,38 @@ def counter(list_, verbose=True):
 # print(f"Return a list of the n most common elements:\n{c.most_common()}")
 # print(f"Compute the sum of the counts:\n{c.total()}")
 
+def dict2df(dict_, fill=None, axis=0):
+    """
+    Convert a dictionary to a DataFrame with flexible axis and padding options.
+
+    Parameters:
+    - dict_: The dictionary to convert (keys are columns or index).
+    - fill: Value to fill in case of shorter lists.
+    - axis: Axis for DataFrame construction (0 for columns, 1 for rows).
+
+    Returns:
+    - DataFrame created from the dictionary.
+    """
+    for key, value in dict_.items():
+        if not isinstance(value, list):
+            dict_[key] = [value]
+            print(f"'{key}' is not a list. trying to convert it to 'list'")
 
-def dict2df(dict_, fill=None):
-    len_max = 0
+    # Get the maximum length of values
+    len_max = max(len(value) for value in dict_.values())
+
+    # Extend lists to match the length of the longest list
     for key, value in dict_.items():
-        # value部分需要是list
         if isinstance(value, list):
-            pass
-        # get the max_length
-        len_max = len(value) if len(value) > len_max else len_max
-        # 补齐长度
-    for key, value in dict_.items():
-        value.extend([fill] * (len_max - len(value)))
+            value.extend([fill] * (len_max - len(value)))  # Fill shorter lists
         dict_[key] = value
-    return pd.DataFrame.from_dict(dict_)
 
+    # If axis=0, the dictionary keys will be treated as column names
+    if axis == 0:
+        return pd.DataFrame(dict_)
+    # If axis=1, the dictionary keys will be treated as index names (rows)
+    else:
+        return pd.DataFrame(dict_).transpose()
 
 def text2audio(
     text,
@@ -1433,104 +1768,161 @@ def str2time(time_str, fmt="24"):
 # print(formatted_time2)  # Output: 14:30:45
 
 
-def str2date(date_str, fmt="%Y-%m-%d_%H:%M:%S"):
+def str2date(date_str, original_fmt=None, fmt="%Y-%m-%d"):
     """
-    Convert a date string into the specified format.
+    Convert a date string to the desired format and extract components if needed.
+    Usage:
+        str2date(x, fmt="%d.%m.%y",original_fmt="%d.%m.%y")
     Parameters:
-    - date_str (str): The date string to be converted.
-    - fmt (str): The format to convert the date to. Defaults to '%Y%m%d'.
+    - date_str (str): The input date string.
+    - original_fmt (str, optional): The original format of the date string. If not provided, it will be auto-detected.
+    - fmt (str): The desired format for the output date string. Defaults to '%Y-%m-%d'.
+
     Returns:
-    - str: The converted date string.
-    """
+    - dict: A dictionary containing the converted date string and its components (year, month, day).
+    
+    Raises:
+    - ValueError: If the date cannot be parsed.
+    """ 
     from dateutil import parser
-
     try:
-        date_obj = parser.parse(date_str)
-    except ValueError as e:
-        raise ValueError(f"Unable to parse date string: {date_str}. Error: {e}")
-    # Format the date object to the desired output format
-    formatted_date = date_obj.strftime(fmt)
-    return formatted_date
+        if not isinstance(date_str,str):
+            date_str=str(date_str) 
+        # Parse the date using the provided original format or auto-detect
+        if original_fmt:
+            try:
+                date_obj = datetime.strptime(date_str, original_fmt)
+            except Exception as e:
+                print(e)
+                date_obj=None
+        else:
+            try:
+                date_obj = parser.parse(date_str)
+            except Exception as e:
+                print(e)
+                date_obj=None
+        # Return formatted string if `fmt` is specified, otherwise return the datetime object
+        if date_obj is not None:
+            if fmt: 
+                date_obj=date_obj.strftime(fmt)
+        else:
+            date_obj=date_str
+        return date_obj
+
+    except (ValueError, TypeError) as e:
+        raise ValueError(f"Unable to process date string: '{date_str}'. Error: {e}")
 
 
 # str1=str2date(num2str(20240625),fmt="%a %d-%B-%Y")
 # print(str1)
 # str2=str2num(str2date(str1,fmt='%a %Y%m%d'))
 # print(str2)
+ 
+def str2num(
+    s: str,
+    *args,
+    sep: Optional[Union[str, List[str]]] = None,
+    round_digits: Optional[int] = None,
+    return_list: bool = True,
+    handle_text: bool = True
+) -> Union[float, int, List[Union[float, int]], None]:
+    """
+    # Examples
+        print(str2num("123"))                # Output: 123
+        print(str2num("123.456", 2))         # Output: 123.46
+        print(str2num("one hundred and twenty three"))  # Output: 123
+        print(str2num("seven million"))      # Output: 7000000
+        print(str2num('one thousand thirty one',','))  # Output: 1,031
+        print(str2num("12345.6789", ","))    # Output: 12,345.6789
+        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
+        print(str2num("every 3,300.55 hours and 5.045555 min", sep=",", round=1))
+        print(str2num("five hundred fourty one"), str2num(
+            "this is 5.9435 euros for 10.04499 killograme", round=3
+        )[0])
+    Convert a string containing numeric or textual data into an integer, float, or list of numbers.
 
+    Parameters:
+    - s (str): Input string containing a number or textual representation of a number.
+    - *args: Additional arguments for delimiter or rounding digits.
+    - sep (str or list): Delimiter(s) to remove from the string (e.g., ',' or ['.', ',']).
+    - round_digits (int): Number of decimal places to round the result to.
+    - return_list (bool): Whether to return a list of numbers if multiple are found.
+    - handle_text (bool): Whether to process textual numbers using the numerizer library.
 
-def str2num(s, *args, **kwargs):
+    Returns:
+    - Union[float, int, List[Union[float, int]], None]: Converted number(s) or None if conversion fails.
+    """
     import re
+    from numerizer import numerize
 
-    delimiter = kwargs.get("sep", None)
-    round_digits = kwargs.get("round", None)
-    if delimiter is not None:
-        s = s.replace(delimiter, "")
+    if not isinstance(s, str):
+        return None
+
+    # Merge args with explicit parameters
+    if sep is None:
+        sep = []
+    elif isinstance(sep, str):
+        sep = [sep]
     for arg in args:
-        if isinstance(arg, str) and delimiter is None:
-            delimiter = arg
+        if isinstance(arg, str):
+            sep.append(arg)
         elif isinstance(arg, int) and round_digits is None:
             round_digits = arg
-    try:
-        num = int(s)
-    except ValueError:
+
+    # Remove all specified delimiters
+    for delimiter in sep:
+        s = s.replace(delimiter, "")
+
+    # Attempt conversion
+    def try_convert(segment: str) -> Union[float, int, None]:
         try:
-            num = float(s)
+            return int(segment)
         except ValueError:
-            from numerizer import numerize
-
             try:
-                numerized = numerize(s)
-                num = int(numerized) if "." not in numerized else float(numerized)
-            except Exception as e:
-                # Attempt to handle multiple number segments
-                try:
-                    number_segments = re.findall(r"[-+]?\d*\.\d+|\d+", s)
-                    nums = []
-                    for segment in number_segments:
-                        nums.append(str2num(segment))
-                    if len(nums) == 1:
-                        num = nums[0]
-                    else:
-                        num = nums
-                except Exception as e:
-                    return None
+                return float(segment)
+            except ValueError:
+                return None
 
-    # Apply rounding if specified
-    if round_digits is not None:
-        if isinstance(num, list):
-            num = [round(i + 0.00000000001, round_digits) for i in num]
-        else:
-            num_adj = num + 0.00000000001  # Ensure precise rounding
-            num = round(num_adj, round_digits)
-    if round_digits == 0:
-        if isinstance(num, list):
-            num = [int(i) for i in num]
-        else:
-            num = int(num)
-    # if delimiter is not None:
-    #     num_str = f"{num:,}".replace(",", delimiter)
-    #     return num_str#s.replace(delimiter, "")
+    # Handle textual numbers
+    if handle_text:
+        try:
+            s = numerize(s)
+        except Exception:
+            pass
 
-    return num
+    # Extract numeric segments
+    number_segments = re.findall(r"[-+]?\d*\.\d+|\d+", s)
+    numbers = [try_convert(seg) for seg in number_segments if seg]
+    numbers = [num for num in numbers if num is not None]
 
+    if not numbers:
+        return None  # No valid numbers found
 
-# Examples
-# print(str2num("123"))                # Output: 123
-# print(str2num("123.456", 2))         # Output: 123.46
-# print(str2num("one hundred and twenty three"))  # Output: 123
-# print(str2num("seven million"))      # Output: 7000000
-# print(str2num('one thousand thirty one',','))  # Output: 1,031
-# print(str2num("12345.6789", ","))    # Output: 12,345.6789
-# 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
-# print(str2num("every 3,300.55 hours and 5.045555 min", sep=",", round=1))
-# print(str2num("five hundred fourty one"), str2num(
-#     "this is 5.9435 euros for 10.04499 killograme", round=3
-# )[0])
+    # Single or multiple numbers
+    if len(numbers) == 1 and not return_list:
+        result = numbers[0]
+    else:
+        result = (
+            numbers[0] if len(numbers) == 1 else numbers if return_list else numbers[0]
+        )
 
+    # Apply rounding if necessary
+    if round_digits is not None:
+        if isinstance(result, list):
+            result = [round(num + 1e-10, round_digits) for num in result]
+        else:
+            result = round(result + 1e-10, round_digits)
+
+        # Convert to int if rounding to 0 digits
+        if round_digits == 0:
+            if isinstance(result, list):
+                result = [int(num) for num in result]
+            else:
+                result = int(result)
 
+    return result 
 def num2str(num, *args, **kwargs):
     delimiter = kwargs.get("sep", None)
     round_digits = kwargs.get("round", None)
@@ -1706,6 +2098,68 @@ def cm2inch(*inch) -> list:
         return [i / 2.54 for i in inch]
 
 
+
+def sqlite2sql(db_path, sql_path):
+    """
+    Export an SQLite database to an SQL file, including schema and data for all tables.
+
+    :param db_path: Path to the SQLite .db file
+    :param output_file: Path to the output .sql file
+
+    # Usage
+        db_path = "your_database.db"  # Replace with the path to your SQLite database
+        sql_path = "output.sql"  # Replace with your desired output file name
+        export_sqlite_to_sql(db_path, sql_path)
+
+    """
+    import sqlite3
+    try:
+        # Connect to the SQLite database
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+
+        with open(sql_path, 'w') as f:
+            # Write a header for the SQL dump
+            f.write("-- SQLite Database Dump\n")
+            f.write(f"-- Source: {db_path}\n\n")
+            
+            # Retrieve all table names
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';")
+            tables = [row[0] for row in cursor.fetchall()]
+
+            for table in tables:
+                # Write the schema for the table
+                cursor.execute(f"SELECT sql FROM sqlite_master WHERE type='table' AND name='{table}';")
+                schema = cursor.fetchone()
+                if schema:
+                    f.write(f"{schema[0]};\n\n")
+                
+                # Write data for the table
+                cursor.execute(f"SELECT * FROM {table};")
+                rows = cursor.fetchall()
+                if rows:
+                    cursor.execute(f"PRAGMA table_info({table});")
+                    column_names = [info[1] for info in cursor.fetchall()]
+                    column_list = ', '.join(f'"{col}"' for col in column_names)
+
+                    for row in rows:
+                        values = ', '.join(f"'{str(val).replace('\'', '\'\'')}'" if val is not None else 'NULL' for val in row)
+                        f.write(f"INSERT INTO {table} ({column_list}) VALUES ({values});\n")
+                
+                f.write("\n")
+            
+            print(f"Database exported successfully to {sql_path}")
+    
+    except sqlite3.Error as e:
+        print(f"SQLite error: {e}")
+    except Exception as e:
+        print(f"Unexpected error: {e}")
+    finally:
+        # Ensure the connection is closed
+        if conn:
+            conn.close()
+
+
 def sreplace(*args, **kwargs):
     """
     sreplace(text, by=None, robust=True)
@@ -2194,6 +2648,12 @@ def unzip(dir_path, output_dir=None):
     Unzips or extracts various compressed file formats (.gz, .zip, .7z, .tar, .bz2, .xz, .rar).
     If the output directory already exists, it will be replaced.
 
+    # Example usage:
+    output_dir = unzip('data.tar.gz')
+    output_file = unzip('file.csv.gz')
+    output_dir_zip = unzip('archive.zip')
+    output_dir_7z = unzip('archive.7z')
+
     Parameters:
     dir_path (str): Path to the compressed file.
     output_dir (str): Directory where the extracted files will be saved.
@@ -2314,21 +2774,12 @@ def unzip(dir_path, output_dir=None):
     else:
         raise ValueError(f"Unsupported file format: {os.path.splitext(dir_path)[1]}")
 
-
-# Example usage:
-# output_dir = unzip('data.tar.gz')
-# output_file = unzip('file.csv.gz')
-# output_dir_zip = unzip('archive.zip')
-# output_dir_7z = unzip('archive.7z')
-
-
 def is_df_abnormal(df: pd.DataFrame, verbose=False) -> bool:
     """
     Usage
     is_abnormal = is_df_abnormal(df, verbose=1)
     True: abnormal
     False: normal
-
     """
     if not isinstance(df, pd.DataFrame):
         if verbose:
@@ -3405,29 +3856,47 @@ def fsave(
         df = pd.DataFrame(data)
         df.to_csv(fpath, **kwargs_valid)
 
-    def save_xlsx(fpath, data, password=None, **kwargs):
+    def save_xlsx(fpath, data, password=None,apply_format=None, **kwargs):
         import msoffcrypto
         from io import BytesIO
+        import openpyxl
+        import pandas.io.formats.style
 
         verbose = kwargs.pop("verbose", False)
         sheet_name = kwargs.pop("sheet_name", "Sheet1")
-
+        engine = kwargs.pop("engine", "xlsxwriter")
+        mode = kwargs.pop("mode","a")
+        if_sheet_exists = strcmp(kwargs.get("if_sheet_exists","new"),['error', 'new', 'replace', 'overlay'])[0]
+        kwargs.pop("if_sheet_exists",None)
         if run_once_within(reverse=True):
             use_pd("to_excel", verbose=verbose)
-
-        if any(kwargs):
-            format_excel(df=data, filename=fpath,sheet_name=sheet_name,password=password, **kwargs)
+ 
+        if apply_format is None:
+            kwargs_format=list(extract_kwargs(format_excel).keys())[4:]
+            apply_format=True if any([i in kwargs_format for i in kwargs]) else False
+            print(f"apply format: {apply_format}")
+        if apply_format or any([
+                isinstance(data, openpyxl.worksheet.worksheet.Worksheet), 
+                isinstance(data, openpyxl.workbook.workbook.Workbook),
+                isinstance(data, pd.io.formats.style.Styler)
+             ]):
+            format_excel(df=data, 
+                         filename=fpath,
+                         sheet_name=sheet_name,
+                         password=password,
+                         if_sheet_exists=if_sheet_exists,
+                         mode=mode, 
+                         engine=engine,
+                         verbose=verbose,
+                         **kwargs)
         else:
             # Remove non-relevant kwargs
             irrelevant_keys=list(extract_kwargs(format_excel).keys())[4:]
-            
-            for key in irrelevant_keys:
-                kwargs.pop(key, None)
-
+            [kwargs.pop(key, None) for key in irrelevant_keys]
             df = pd.DataFrame(data)
-
             # Write to Excel without password first
             temp_file = BytesIO()
+            
             df.to_excel(
                 temp_file,
                 sheet_name=sheet_name,
@@ -3435,26 +3904,22 @@ def fsave(
                 engine="xlsxwriter",
                 **kwargs,
             )
-
             # If a password is provided, encrypt the file
             if password:
                 temp_file.seek(0)
-                office_file = msoffcrypto.OfficeFile(temp_file)
-                office_file.load_key(password=password)  # Provide the password
-
-                # Encrypt and save the file
+                office_file = msoffcrypto.OfficeFile(temp_file) 
                 with open(fpath, "wb") as encrypted_file:
-                    office_file.encrypt(encrypted_file)
-            else:
-                # Save the file without encryption if no password is provided
+                    office_file.encrypt(outfile=encrypted_file,password=password)
+            else: # Save the file without encryption if no password is provided
                 try:
                     # Use ExcelWriter with append mode if the file exists
-                    with pd.ExcelWriter(
-                        fpath, engine="openpyxl", mode="a", if_sheet_exists="new"
-                    ) as writer:
-                        df.to_excel(
-                            writer, sheet_name=sheet_name, index=False, **kwargs
-                        )
+                    engine="openpyxl" if mode=="a" else "xlsxwriter"
+                    if mode=="a":
+                        with pd.ExcelWriter(fpath, engine=engine, mode=mode,if_sheet_exists=if_sheet_exists) as writer:
+                            df.to_excel(writer, sheet_name=sheet_name, index=False, **kwargs)
+                    else:
+                        with pd.ExcelWriter(fpath, engine=engine, mode=mode) as writer:
+                            df.to_excel(writer, sheet_name=sheet_name, index=False, **kwargs)
                 except FileNotFoundError:
                     # If file doesn't exist, create a new one
                     df.to_excel(fpath, sheet_name=sheet_name, index=False, **kwargs)
@@ -3478,15 +3943,9 @@ def fsave(
         nb["cells"] = cells
         # Write the notebook to a file
         with open(fpath, "w", encoding="utf-8") as ipynb_file:
-            nbformat.write(nb, ipynb_file)
-
-    # def save_json(fpath, data, **kwargs):
-    #     with open(fpath, "w") as file:
-    #         json.dump(data, file, **kwargs)
-
+            nbformat.write(nb, ipynb_file) 
     def save_json(fpath_fname, var_dict_or_df):
         import json
-
         def _convert_js(data):
             if isinstance(data, pd.DataFrame):
                 return data.to_dict(orient="list")
@@ -3497,15 +3956,9 @@ def fsave(
             return data
 
         serializable_data = _convert_js(var_dict_or_df)
-
         # Save the serializable data to the JSON file
         with open(fpath_fname, "w") as f_json:
-            json.dump(serializable_data, f_json, indent=4)
-
-    # # Example usage:
-    # sets = {"title": "mse_path_ MSE"}
-    # jsonsave("/.json", sets)
-    # # setss = jsonload("/.json")
+            json.dump(serializable_data, f_json, indent=4) 
 
     def save_yaml(fpath, data, **kwargs):
         import yaml
@@ -4579,10 +5032,11 @@ def copy(src, dst, overwrite=False, verbose=True):
                     dst.unlink()
                 else:
                     dst = dst.with_name(
-                        f"{dst.stem}_{datetime.now().strftime('_%H%M%S')}{dst.suffix}"
+                        f"{dst.stem}_{datetime.now().strftime('%y%m%d_%H%M%S')}{dst.suffix}"
                     )
             shutil.copy(src, dst)
             print(f"\n Done! copy to {dst}\n") if verbose else None
+            return dst
         else:
             dst = dst / src.name
             if dst.exists():
@@ -4590,14 +5044,33 @@ def copy(src, dst, overwrite=False, verbose=True):
                     shutil.rmtree(dst)  # Remove existing directory
                 else:
                     dst = dst.with_name(
-                        f"{dst.stem}_{datetime.now().strftime('%H%M%S')}"
+                        f"{dst.stem}_{datetime.now().strftime('%y%m%d%H%M%S')}"
                     )
             shutil.copytree(src, dst)
             print(f"\n Done! copy to {dst}\n") if verbose else None
+            return dst
 
     except Exception as e:
         logging.error(f"Failed {e}")
-
+def local_path(fpath,station=r"Q:\\IM\\AGLengerke\\Jeff\\# testing\\temp\\"):
+    """copy file to a specific folder first, to aviod file conflict""" 
+    try:
+        f=listdir(station) 
+        if listdir(station ,verbose=False).loc[0,"num"]>=10:
+            for fpath_ in f['path']:
+                if os.path.basename(fpath)[:5] in fpath_:
+                    if fpath== fpath_:
+                        pass
+                    else:
+                        delete(fpath_)
+    except:
+        pass
+    try:
+        new_path=copy(fpath, station)
+    except Exception as e:
+        print(f"Path did not update because: Error:{e}")
+        new_path=fpath
+    return new_path
 
 def cut(src, dst, overwrite=False):
     return move(src=src, dst=dst, overwrite=overwrite)
@@ -6347,29 +6820,152 @@ def extract_kwargs(func):
 
     return kwargs
 def format_excel(
-    df=None,
-    filename=None,
-    sheet_name=0,
-    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"},
+    df: pd.DataFrame=None,
+    filename:str=None,
+    sheet_name:Union[str, int]=0,
+    insert_img:dict=None,# {"A1":img_path}
+    usage:bool=False,
+    text_color:Union[dict,bool]=False, # dict: set the text color
+    bg_color:Union[dict,bool]=False, # dict: set the back_ground color
+    cell:Union[dict, list]=None,  # dict: or list for multiple locs setting:
+    width:Union[bool, dict]=None,  # dict
+    width_factor:int=2,# calculated with plus this factor
+    height:Union[bool, dict]=None,  # dict e.g., {2: 50, 3: 25},  keys are columns
+    height_max:int=25,
+    merge:tuple=None,  # tuple e.g.,  (slice(0, 1), slice(1, 3)),
+    shade:Union[dict, list]=None,  # dict
+    comment:Union[dict, list]=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"}
+    link:Union[dict, list]=None,  # dict e.g., {(2, 2): "https://example.com"},
+    protect:dict=None,  # dict
+    number_format:dict=None,  # dict: e.g., {1:"0.00", 2:"#,##0",3:"0%",4:"$#,##0.00"}
     data_validation=None,  # dict
     apply_filter:bool=True, # add filter 
     freeze :str= False,#"A2",
-    conditional_format=None,  # dict
-    verbose=True,
+    conditional_format:dict=None,  # dict
+    verbose:bool=False,
     **kwargs,
 ):
+    """
+    Parameters:
+        df : pandas.DataFrame, optional
+            DataFrame to be written to the Excel file.
+        filename : str, optional
+            Path to the output Excel file.
+        sheet_name : str or int, default 0
+            Name or index of the sheet where data will be written.
+        insert_img : dict, optional
+            Dictionary specifying image insert locations, e.g., {"A1": "path/to/image.png"}.
+        usage : bool, default False
+            If True, display usage examples.
+        cell : dict or list, optional
+            Specifies cell formatting options.
+        width : dict, optional
+            Dictionary specifying column widths, e.g., {1: 20, 2: 30}.
+        width_factor : int, default 2
+            Additional factor to adjust column width dynamically.
+        height : dict, optional
+            Dictionary specifying row heights, e.g., {2: 50, 3: 25}.
+        height_max : int, default 25
+            Maximum row height allowed.
+        merge : tuple, optional
+            Specifies cell merging, e.g., (slice(0, 1), slice(1, 3)).
+        shade : dict, optional
+            Dictionary defining cell shading/styling.
+        comment : dict, optional
+            Dictionary adding comments, e.g., {(2, 4): "This is a comment"}.
+        comment_always_visible : bool, default True
+            Whether comments should always be visible.
+        link : dict, optional
+            Dictionary specifying hyperlinks, e.g., {(2, 2): "https://example.com"}.
+        protect : dict, optional
+            Dictionary defining cell protection settings.
+        number_format : dict, optional
+            Dictionary specifying number formats, e.g., {1: "0.00", 2: "#,##0"}.
+        data_validation : dict, optional
+            Dictionary setting data validation rules.
+        apply_filter : bool, default True
+            Whether to apply filters to the header row.
+        freeze : str, optional
+            Cell reference (e.g., "A2") to freeze rows/columns.
+        conditional_format : dict, optional
+            Dictionary defining conditional formatting rules.
+        verbose : bool, default False
+            Whether to print detailed execution logs.
+        **kwargs : dict
+            Additional parameters for advanced customization. 
+    """
+
+    usage_str="""
+        Formats an Excel file with various styling options.
+        Usage:
+        fsave(
+                dir_save,
+                fload(dir_save, output="bit", sheet_name=sheet_name),
+                sheet_name=sheet_name,
+                if_sheet_exists="overlay",
+                mode="a",
+                width_factor=0,
+                height={1: 50},
+                cell=[
+                    {
+                        (slice(0, 1), slice(0, df_exists.shape[1])): {
+                            "fill": {
+                                "start_color": "61AFEF",  # Starting color
+                                "end_color": "61AFEF",  # Ending color (useful for gradients)
+                                "fill_type": "solid",  # Fill type (solid, gradient, etc.)
+                            },
+                            "font": {
+                                "name": "Arial",  # Font name
+                                "size": 11,  # Font size
+                                "bold": True,  # Bold text
+                                "italic": False,  # Italic text
+                                # "underline": "single",  # Underline (single, double)
+                                "color": "#000000",  # Font color
+                            },
+                            "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
+                            },
+                        }
+                    },
+                    {
+                        (
+                            slice(0, df_exists.shape[0]),
+                            slice(0, df_exists.shape[1]),
+                        ): {
+                            "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
+                            },
+                        }
+                    },
+                    {
+                        (slice(0, df_exists.shape[0]), slice(2, 3)): {
+                            "alignment": {
+                                "horizontal": "left",  # Horizontal alignment (left, center, right)
+                            },
+                        }
+                    },
+                    {
+                        (slice(0, df_exists.shape[0]), slice(7, 8)): {
+                            "alignment": {
+                                "horizontal": "left",  # Horizontal alignment (left, center, right)
+                            },
+                        }
+                    },
+                ],
+                password=False,  # depass("ogB3B7y3xR9iuH4QIQbyy6VXG14I0A8DlsTxyiGqg1U="),
+            )
+            """
+    if verbose:
+        print(usage_str)
     import pandas as pd
     from datetime import datetime
     import openpyxl
@@ -6394,7 +6990,91 @@ def format_excel(
             if end_col_letter
             else f"{start_col_letter}{start_row}"
         )
+    def apply_color_to_worksheet(ws=None, sheet_name=None, conditions=None, cell_idx=None,where="text"):
+        """
+        Apply text color formatting to a specific cell range in an openpyxl workbook based on conditions.
 
+        Parameters:
+        ws : worrksheet
+            The openpyxl workbook object to style.
+        sheet_name : str
+            The name of the sheet to style.
+        conditions : dict
+            Dictionary defining conditions for text coloring.
+        cell_idx : tuple, optional
+            A tuple of slices defining the selected row and column range (only for DataFrame).
+
+        Returns:
+        openpyxl.workbook.workbook.Workbook
+            The workbook with applied formatting.
+        """ 
+        def evaluate_condition(value, condition):
+            """Evaluate the condition dynamically."""
+            try:
+                if "x" in condition and re.search(r"[<>=!]=*", condition):
+                    expr = condition.replace("x", str(value))
+                else:
+                    expr = condition
+                return eval(expr)
+            except Exception as e:
+                # print(f"Error evaluating condition {condition} for value {value}: {e}")
+                return False
+
+        def apply_condition_to_cell_text_color(cell, value):
+            """Apply color to a cell if it matches any condition."""
+            for condition, color in conditions.items():
+                if evaluate_condition(value, condition):
+                    # Apply color to font
+                    cell.font = openpyxl.styles.Font(
+                        color=openpyxl.styles.Color(rgb=hex2argb(color))
+                    )
+                    return
+        def apply_condition_to_cell_bg_color(cell, value):
+            """Apply background color to a cell if it matches any condition."""
+            for condition, color in conditions.items():
+                if evaluate_condition(value, condition):
+                    if not isinstance(color,list):
+                        color=[color]
+                    if len(color)==1:
+                        cell.fill = PatternFill(
+                            start_color=hex2argb(color[0]),
+                            end_color=hex2argb(color[0]),
+                            fill_type="solid"
+                        )
+                    elif len(color)==2:
+                        cell.fill = PatternFill(
+                            start_color=hex2argb(color[0]),
+                            end_color=hex2argb(color[1]),
+                            fill_type="solid"
+                        )
+                    return
+        if isinstance(cell_idx, tuple):
+            # If cell_idx is provided, select a range based on the slice
+            row_slice, col_slice = cell_idx
+            rows = list(
+                ws.iter_rows(
+                    min_row=row_slice.start + 1,
+                    max_row=row_slice.stop,
+                    min_col=col_slice.start + 1,
+                    max_col=col_slice.stop,
+                )
+            )
+            for row in rows:
+                for cell in row:
+                    if where=="text":
+                        apply_condition_to_cell_text_color(cell, cell.value)
+                    elif where=="bg":
+                        apply_condition_to_cell_bg_color(cell, cell.value)
+        else:
+            # If no cell_idx is provided, apply to all cells
+            for row in ws.iter_rows():
+                for cell in row:
+                    if where=="text":
+                        apply_condition_to_cell_text_color(cell, cell.value)
+                    elif where=="bg":
+                        apply_condition_to_cell_bg_color(cell,cell.value)
+        return ws
+    
     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
@@ -6405,7 +7085,7 @@ def format_excel(
                 font_color = "000000"
                 font_name = "Arial"
                 font_underline = "none"
-                font_size = 14
+                font_size = 11
                 font_bold = False
                 font_strike = False
                 font_italic = False
@@ -6742,6 +7422,8 @@ def format_excel(
             counter += 1
             unique_name = f"{sheet_name}_{counter}"
         return unique_name
+
+
     # if it is already worksheet format
     if isinstance(df, pd.DataFrame):
         pass
@@ -6763,55 +7445,56 @@ def format_excel(
     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]
+    mode = strcmp(kwargs.get("mode", "a"), ["a", "w","auto"])[0]
+    print(f'mode="{mode}"')
     kwargs.pop("mode", None)
     engine = strcmp(kwargs.get("engine", "openpyxl"), ["xlsxwriter", "openpyxl"])[0]
+    # corr engine
+    engine="openpyxl" if mode=="a" else "xlsxwriter" 
+    print(f'engine="{engine}"')
+    if_sheet_exists=kwargs.get("if_sheet_exists","replace")
     # 通常是不需要保存index的
     index = kwargs.get("index", False)
-    kwargs.pop("index", None)
     # header
     header=kwargs.pop("header",False)
-
+    password = kwargs.pop("password", None)  # Use kwargs if provided
+    
+    kwargs.pop("password", None)
+    kwargs.pop("header", None)
+    kwargs.pop("index", None)
+    kwargs.pop("if_sheet_exists", None)
     if isinstance(df, openpyxl.workbook.workbook.Workbook):
+        """打开Sheet_name指定的表格，如果该表不存在，则创建一个新的或从现有文件中加载数据"""
         wb=df
         try:
             ws = wb.worksheets[sheet_name]
         except Exception as e:
-            print(e)
+            print(f'mode="{mode}"')
             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:
+                with pd.ExcelWriter(filename, mode="a", engine=engine, if_sheet_exists=if_sheet_exists) as writer:
                     for ws in df.worksheets:  # Iterate through worksheets in the input workbook
                         ws_df = pd.DataFrame(ws.values)
-                        ws_df.to_excel(writer, 
-                                       sheet_name=sheet_name_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:
+                        ws_df.to_excel(writer,
+                                    sheet_name=sheet_name,
+                                    index=index,
+                                    header=header,
+                                    **kwargs) 
+                # 重新打开刚更新过的数据
+                wb = load_workbook(filename) 
+                if sheet_name in wb.sheetnames:
+                    ws = wb[sheet_name]
+                    if not sheet_name==sheet_name:
                         wb.remove(wb[sheet_name])
                 else:
-                    raise KeyError(f"Worksheet {sheet_name_corr} does not exist.") 
+                    raise KeyError(f"Worksheet {sheet_name} 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}"
-            )
+        if not os.path.exists(filename) or mode=="w": # or overwrite 
             with pd.ExcelWriter(filename, mode="w", engine=engine) as writer:
-                df.to_excel(writer, sheet_name=sheet_name_corr, index=index, header=header,**kwargs)
+                df.to_excel(writer, sheet_name=sheet_name, index=index, header=header,**kwargs)
             wb = load_workbook(filename)
             if isinstance(sheet_name, str):
                 ws = wb[sheet_name]
@@ -6821,15 +7504,75 @@ def format_excel(
                 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)
+            with pd.ExcelWriter(filename, mode="a", engine=engine, if_sheet_exists=if_sheet_exists) as writer:
+                df.to_excel(writer, sheet_name=sheet_name, index=index, header=header,**kwargs)
             wb = load_workbook(filename)
-            if sheet_name_corr in wb.sheetnames:
-                ws = wb[sheet_name_corr]
+            if sheet_name in wb.sheetnames:
+                ws = wb[sheet_name]
             else:
-                raise KeyError(f"Worksheet {sheet_name_corr} does not exist.") 
-
+                raise KeyError(f"Worksheet {sheet_name} does not exist.") 
+    # ! Apply Text color
+    if text_color:
+        if verbose:
+            text_color_str="""
+            text_color=[
+                {
+                    (slice(1, 2), slice(0, 3)): {
+                        "x>20": "#DD0531",  # Numbers > 20 → red
+                        "x<=8": "#35B20C",  # Numbers ≤ 10 → blue
+                        "'x'!='available'": "#0510DD",  # 'available' → green
+                        "10<x<=30": "#EAB107",  # 10 < value ≤ 30 → orange
+                        "10<=x<30": "#C615BE",  # 10 ≤ value < 30 → purple
+                    }
+                },
+                {
+                    (slice(3, df.shape[0] + 1), slice(0, 3)): {
+                        "x>20": "#DD0531",  # Numbers > 20 → red
+                        "x<=10": "#35B20C",  # Numbers ≤ 10 → blue
+                        "'x'!='available'": "#0510DD",  # 'available' → green
+                        "10<x<=30": "#EAB107",  # 10 < value ≤ 30 → orange
+                        "10<=x<30": "#C615BE",  # 10 ≤ value < 30 → purple
+                    }
+                },
+            ],
+            """
+            print(text_color_str)
+        if not isinstance(text_color, list):
+            text_color=[text_color]
+        for text_color_ in text_color:
+            for indices, dict_text_conditions in text_color_.items():
+                ws = apply_color_to_worksheet(ws, sheet_name=sheet_name, conditions=dict_text_conditions, cell_idx=indices,where="text")
+    # ! Apply Text color
+    if bg_color:
+        if verbose:
+            bg_color_str="""
+            bg_color=[
+                {
+                    (slice(1, 2), slice(0, 3)): {
+                        "x>20": ["#DD0531","#35B20C"],  # Numbers > 20 → red
+                        "x<=8": "#35B20C",  # Numbers ≤ 10 → blue
+                        "'x'!='available'": "#0510DD",  # 'available' → green
+                        "10<x<=30": "#EAB107",  # 10 < value ≤ 30 → orange
+                        "10<=x<30": "#C615BE",  # 10 ≤ value < 30 → purple
+                    }
+                },
+                {
+                    (slice(3, df.shape[0] + 1), slice(0, 3)): {
+                        "x>20": "#DD0531",  # Numbers > 20 → red
+                        "x<=10": "#35B20C",  # Numbers ≤ 10 → blue
+                        "'x'!='available'": "#0510DD",  # 'available' → green
+                        "10<x<=30": "#EAB107",  # 10 < value ≤ 30 → orange
+                        "10<=x<30": "#C615BE",  # 10 ≤ value < 30 → purple
+                    }
+                },
+            ],
+            """
+            print(bg_color_str)
+        if not isinstance(bg_color, list):
+            bg_color=[bg_color]
+        for bg_color_ in bg_color:
+            for indices, dict_text_conditions in bg_color_.items():
+                ws = apply_color_to_worksheet(ws, sheet_name=sheet_name, conditions=dict_text_conditions, cell_idx=indices,where="bg")
     # !Apply cell formatting
     if cell:
         if not isinstance(cell, list):
@@ -6838,6 +7581,7 @@ def format_excel(
             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=[
                     {
@@ -6918,14 +7662,16 @@ def format_excel(
             print(number_format_temp)
     
     if freeze:
+        if isinstance(freeze,bool):
+            freeze='A2'
         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
+            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
@@ -6949,7 +7695,11 @@ def format_excel(
             ws.auto_filter.ref = filter_range
             if freeze:
                 ws.freeze_panes = freeze  # Freeze everything above and to the left of A2
-    # !widths
+    # !widths 
+    if isinstance(width,bool):
+        width=None if width else False
+    if isinstance(height,bool):
+        height=None if height else False
     if width is None:  # automatic adust width
         for col in ws.columns:
             max_length = 0
@@ -6971,6 +7721,8 @@ def format_excel(
                     pass
             adjusted_width = max_length + width_factor  # You can adjust the padding value as needed
             ws.column_dimensions[column].width = adjusted_width
+    elif isinstance(width,bool):
+        pass
     else:
         for col_idx, width_ in width.items():
             col_letter = get_column_letter(col_idx)
@@ -6989,6 +7741,8 @@ def format_excel(
                         estimated_height += 5 * (max_line_length // 20)
                     max_height = max(max_height, estimated_height)
             ws.row_dimensions[row[0].row].height = max_height
+    elif isinstance(height,bool) and not height:
+        pass
     else:
         for row, height_ in height.items():
             ws.row_dimensions[row].height = height_
@@ -7073,7 +7827,6 @@ def format_excel(
                   )
     # !Protect sheet with a password
     # Fetch the password
-    password = kwargs.pop("password", None)  # Use kwargs if provided
 
     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:
@@ -7111,39 +7864,71 @@ def format_excel(
                 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"))
+                        if verbose:
+                            color_scale_tmp="""
+                                    conditional_format={
+                                        (slice(1, df.shape[0] + 1), slice(1, 2)):
+                                            {
+                                                "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(color_scale_tmp)
+                        color_scale = rule["color_scale"] 
 
                         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,
+                            start_value=color_scale.get("start_value",None),
+                            start_color=hex2argb(color_scale.get("start_color", "#74ADE9")),
+                            mid_type=color_scale.get("mid_type","percentile"),
+                            mid_value=color_scale.get("mid_value",None),
+                            mid_color=hex2argb(color_scale.get("mid_color", "FFFFFF")),
                             end_type=color_scale.get("end_type", "max"),
-                            end_value=color_scale.get("end_value"),
-                            end_color=end_color,
+                            end_value=color_scale.get("end_value",None),
+                            end_color=hex2argb(color_scale.get("end_color", "#B62833")),
                         )
                         ws.conditional_formatting.add(cell_range, color_scale_rule)
                     # Handle data bar
                     if "data_bar" in rule:
+                        if verbose:
+                            data_bar_tmp="""
+                                    conditional_format={
+                                        (slice(1, df.shape[0] + 1), slice(1, 2)):
+                                            {
+                                                "data_bar": {
+                                                    "start_type": "min",
+                                                    "start_value": None,
+                                                    "end_type": "max",
+                                                    "end_value": None,
+                                                    "color": "F6C9CE",
+                                                    "show_value": True,
+                                                }
+                                            }}
+                            """
+                            print(data_bar_tmp)
                         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"),
+                            start_value=data_bar.get("start_value",None),
                             end_type=data_bar.get("end_type", "max"),
-                            end_value=data_bar.get("end_value"),
+                            end_value=data_bar.get("end_value",None),
                             color=bar_color,
                             showValue=data_bar.get("show_value", True),
                         )
                         ws.conditional_formatting.add(cell_range, data_bar_rule)
 
-                    # Handle icon set
+                    # Handle icon setse
                     if "icon_set" in rule:
                         icon_set = rule["icon_set"]
                         icon_set_rule = IconSet(
@@ -7152,6 +7937,34 @@ def format_excel(
                             reverse=icon_set.get("reverse", False)            # Corrected
                         )
                         ws.conditional_formatting.add(cell_range, icon_set_rule)
+                    # Handle text-based conditions
+                    if "text_color" in rule: # not work
+                        from openpyxl.styles.differential import DifferentialStyle
+                        from openpyxl.formatting.rule import Rule
+                        from openpyxl.styles import PatternFill
+
+                        # Extract the fill properties from the rule
+                        fill = rule.get("fill", {})
+                        start_color = fill.get("start_color", "FFFFFF")  # Default to white if not specified
+                        end_color = fill.get("end_color", "FFFFFF")  # Default to white if not specified
+                        fill_type = fill.get("fill_type", "solid")  # Default to solid fill if not specified
+
+                        # Extract the text condition or default to a space if 'text' is not provided
+                        text = rule.get("text", " ")  
+
+                        # Create the DifferentialStyle using the extracted fill settings
+                        dxf = DifferentialStyle(
+                            fill=PatternFill(start_color=start_color, end_color=end_color, fill_type=fill_type)
+                        )
+                        
+                        # Create the text rule based on the text condition
+                        text_rule = Rule(
+                            type="containsText",  # The type of condition
+                            operator=rule.get("operator", "equal"),  # Default operator is "equal"
+                            text=text,
+                            dxf=dxf,  # Apply the fill color from DifferentialStyle
+                        )
+                        ws.conditional_formatting.add(cell_range, text_rule)
         if verbose:
             conditional_format_temp="""
                     conditional_format={
@@ -7183,10 +7996,49 @@ def format_excel(
                         }
             """
             print(conditional_format_temp)
+    if insert_img:
+        if not isinstance(insert_img, dict):
+            raise ValueError(f'insert_img 需要dict格式: e.g., insert_img={"A1":"example.png"}')
+        try:
+            from openpyxl import drawing
+            from PIL import Image
+            import PIL
+            for img_cell, img_data in insert_img.items():
+                img_width = img_height = None
+                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)
+                    elif "image" in img_data:
+                        pil_img = 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_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
+                elif isinstance(img_data, (PIL.Image.Image,PIL.PngImagePlugin.PngImageFile)):
+                    pil_img = img_data  # Direct PIL Image object
+                elif isinstance(img_data, np.ndarray):
+                    pil_img = Image.fromarray(img_data)  # Convert NumPy array to PIL Image
+                elif pil_img:
+                    img_ = drawing.image.Image(pil_img)
+
+                # Set width and height if provided
+                if img_width is not None:
+                    img_.width = img_width
+                if img_height is not None:
+                    img_.height = img_height
+                ws.add_image(img_, img_cell) 
+                print(f"✅ at {img_cell} inserted image:  {os.path.basename(img_path)}")
 
+        except Exception as e:
+            print(e)
+            
     # Save the workbook
     wb.save(filename)
-    print(f"Formatted Excel file saved as:\n{filename}")
 
 
 def preview(var):
@@ -7511,9 +8363,11 @@ def df_astype(
     columns: Optional[Union[str, List[str]]] = None,
     astype: str = None,  # "datetime",
     skip_row: Union[str, list] = None,
+    original_fmt:str=None,
     fmt: Optional[str] = None,
     inplace: bool = False,
     errors: str = "coerce",  # Can be "ignore", "raise", or "coerce"
+    verbose:bool=True,
     **kwargs,
 ) -> Optional[pd.DataFrame]:
     """
@@ -7585,13 +8439,21 @@ def df_astype(
     # correct the astype input
     if isinstance(astype, str):
         astype = strcmp(astype, astypes)[0]
-        print(f"converting as type: {astype}")
+        print(f"converting as type: {astype}") 
     elif isinstance(astype, dict):
         for col, dtype in astype.items():
             dtype = "date" if dtype == "day" else dtype
-            data["col"] = data["col"].adtype(strcmp(dtype, astypes)[0])
+            target_dtype = strcmp(dtype, astypes)[0]
+            try:
+                if target_dtype == "datetime":
+                    data[col] = pd.to_datetime(data[col], format=original_fmt, errors=errors)
+                elif target_dtype == "timedelta":
+                    data[col] = pd.to_timedelta(data[col], errors=errors)
+                else:
+                    data[col] = data[col].astype(target_dtype)
+            except Exception as e:
+                print(f"Error converting column '{col}' to {target_dtype}: {e}")
         return data if not inplace else None
-
     # Ensure columns is a list
     if isinstance(columns, str):
         columns = [columns]
@@ -7613,9 +8475,17 @@ def df_astype(
                 kwargs.pop("errors", None)
                 # convert it as type: datetime
                 if isinstance(column, int):
-                    data.iloc[:, column] = pd.to_datetime(
-                        data.iloc[:, column], format=fmt, errors=errors, **kwargs
-                    )
+                    data.iloc[:, column] = pd.to_datetime(data.iloc[:, column], format=original_fmt, errors=errors, **kwargs) if original_fmt is not None else pd.to_datetime(data[column], errors=errors, **kwargs)
+
+                    try:
+                        if fmt is not None:
+                            # data[column] = data[column].apply(lambda x: f"{x:{fmt}}")
+                            data[column] = data[column].apply(
+                                lambda x: x.strftime(fmt) if pd.notnull(x) else None
+                            )
+                    except Exception as e:
+                        print(f"设置格式的时候有误: {e}")
+
                     # further convert:
                     if astype == "time":
                         data.iloc[:, column] = data.iloc[:, column].dt.time
@@ -7636,11 +8506,20 @@ def df_astype(
                 else:
                     data[column] = (
                         pd.to_datetime(
-                            data[column], format=fmt, errors=errors, **kwargs
+                            data[column], format=original_fmt, errors=errors, **kwargs
                         )
-                        if fmt
+                        if original_fmt is not None
                         else pd.to_datetime(data[column], errors=errors, **kwargs)
                     )
+
+                    try:
+                        if fmt is not None:
+                            # data[column] = data[column].apply(lambda x: f"{x:{fmt}}")
+                            data[column] = data[column].apply(
+                                lambda x: x.strftime(fmt) if pd.notnull(x) else None
+                            )
+                    except Exception as e:
+                        print(f"设置格式的时候有误: {e}")
                     # further convert:
                     if astype == "time":
                         data[column] = data[column].dt.time
@@ -7677,16 +8556,12 @@ def df_astype(
                 else:
                     data[column] = data[column].astype(astype)
                 # print(f"Successfully converted '{column}' to {astype}.")
-            # format
-            try:
-                if fmt is not None:
-                    data[column] = data[column].apply(lambda x: f"{x:{fmt}}")
-            except Exception as e:
-                print(f"设置格式的时候有误: {e}")
+
         except Exception as e:
             print(f"Error converting '{column}' to {astype}: {e}")
     try:
-        display(data.info()[:10])
+        if verbose:
+            display(data.info()[:10])
     except:
         pass
     return data
@@ -9867,6 +10742,7 @@ def df_qc(
     res_qc["dtype_counts"] = data.dtypes.value_counts()
 
     # Distribution Analysis (mean, median, mode, std dev, IQR for numeric columns)
+    
     distribution_stats = data.select_dtypes(include=[np.number]).describe().T
     iqr = data.select_dtypes(include=[np.number]).apply(
         lambda x: x.quantile(0.75) - x.quantile(0.25)