py2ls 0.1.8.0__py3-none-any.whl → 0.1.8.2__py3-none-any.whl

py2ls/ips.py

@@ -4,23 +4,23 @@ import pandas as pd
 import json
 import matplotlib
 import matplotlib.pyplot as plt
-import matplotlib.ticker as tck 
+import matplotlib.ticker as tck
 from cycler import cycler
 from mpl_toolkits.mplot3d import Axes3D
 import seaborn as sns
 
-import sys, os,shutil,re, yaml,json,subprocess
+import sys, os, shutil, re, yaml, json, subprocess
 import importlib.util
 import time
 from dateutil import parser
 from datetime import datetime
 
-from PIL import Image,ImageEnhance, ImageOps,ImageFilter
-from rembg import remove,new_session
+from PIL import Image, ImageEnhance, ImageOps, ImageFilter
+from rembg import remove, new_session
 
 import docx
-from fpdf import FPDF 
-from lxml import etree 
+from fpdf import FPDF
+from lxml import etree
 from docx import Document
 from PyPDF2 import PdfReader
 from pptx import Presentation
@@ -40,24 +40,27 @@ from tqdm import tqdm
 import mimetypes
 from pprint import pp
 from collections import Counter
-from fuzzywuzzy import fuzz,process
+from fuzzywuzzy import fuzz, process
 from langdetect import detect
 from duckduckgo_search import DDGS
 
-from py2ls import netfinder
+from . import netfinder
+from .plot import get_color
 
 try:
-    get_ipython().run_line_magic('load_ext', 'autoreload')
-    get_ipython().run_line_magic('autoreload', '2')
+    get_ipython().run_line_magic("load_ext", "autoreload")
+    get_ipython().run_line_magic("autoreload", "2")
 except NameError:
     pass
 
+
 def is_package_installed(package_name):
     """Check if a package is installed."""
     package_spec = importlib.util.find_spec(package_name)
     return package_spec is not None
-        
-def upgrade(module='py2ls'):
+
+
+def upgrade(module="py2ls"):
     # try:
     #     pkg_resources.get_distribution(module)
     # except pkg_resources.DistributionNotFound:
@@ -68,37 +71,45 @@ def upgrade(module='py2ls'):
         except subprocess.CalledProcessError as e:
             print(f"An error occurred while installing {module}: {e}")
     try:
-        subprocess.check_call([sys.executable, "-m", "pip", "install", "--upgrade", module])
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", "--upgrade", module]
+        )
     except subprocess.CalledProcessError as e:
         print(f"An error occurred while upgrading py2ls: {e}")
 
 
-dir_save='/Users/macjianfeng/Dropbox/Downloads/'
+dir_save = "/Users/macjianfeng/Dropbox/Downloads/"
 
 
 def get_version(pkg):
     import importlib.metadata
+
     def get_v(pkg_name):
         try:
             version = importlib.metadata.version(pkg_name)
             print(f"version {pkg_name} == {version}")
         except importlib.metadata.PackageNotFoundError:
             print(f"Package '{pkg_name}' not found")
-    if isinstance(pkg,str):
+
+    if isinstance(pkg, str):
         get_v(pkg)
-    elif isinstance(pkg,list):
+    elif isinstance(pkg, list):
         [get_v(pkg_) for pkg_ in pkg]
-# usage: 
+
+
+# usage:
 # get_version(['pandas','numpy','py2ls'])
-        
+
+
 def rm_folder(folder_path, verbose=True):
     try:
         shutil.rmtree(folder_path)
         if verbose:
-            print(f'Successfully deleted {folder_path}')
+            print(f"Successfully deleted {folder_path}")
     except Exception as e:
         if verbose:
-            print(f'Failed to delete {folder_path}. Reason: {e}')
+            print(f"Failed to delete {folder_path}. Reason: {e}")
+
 
 def fremove(path, verbose=True):
     """
@@ -111,20 +122,20 @@ def fremove(path, verbose=True):
         if os.path.isdir(path):
             shutil.rmtree(path)
             if verbose:
-                print(f'Successfully deleted folder {path}')
+                print(f"Successfully deleted folder {path}")
         elif os.path.isfile(path):
             os.remove(path)
             if verbose:
-                print(f'Successfully deleted file {path}')
+                print(f"Successfully deleted file {path}")
         else:
             if verbose:
-                print(f'Path {path} does not exist')
+                print(f"Path {path} does not exist")
     except Exception as e:
         if verbose:
-            print(f'Failed to delete {path}. Reason: {e}')
+            print(f"Failed to delete {path}. Reason: {e}")
 
 
-def get_cwd(verbose:bool = True):
+def get_cwd(verbose: bool = True):
     """
     get_cwd: to get the current working directory
     Args:
@@ -138,26 +149,39 @@ def get_cwd(verbose:bool = True):
         # This works in an interactive environment (like a Jupyter notebook)
         script_dir = os.getcwd()
         if verbose:
-            print("os.getcwd():", script_dir) 
+            print("os.getcwd():", script_dir)
     return script_dir
 
-def search(query, limit=5, kind='text', output='df',verbose=False,download=True, dir_save=dir_save):
+
+def search(
+    query,
+    limit=5,
+    kind="text",
+    output="df",
+    verbose=False,
+    download=True,
+    dir_save=dir_save,
+):
     from duckduckgo_search import DDGS
-    if 'te' in kind.lower():
+
+    if "te" in kind.lower():
         results = DDGS().text(query, max_results=limit)
-        res=pd.DataFrame(results)
-        res.rename(columns={"href":"links"},inplace=True)
+        res = pd.DataFrame(results)
+        res.rename(columns={"href": "links"}, inplace=True)
     if verbose:
         print(f'searching "{query}": got the results below\n{res}')
     if download:
         try:
-            netfinder.downloader(url=res.links.tolist(), dir_save=dir_save, verbose=verbose)
+            netfinder.downloader(
+                url=res.links.tolist(), dir_save=dir_save, verbose=verbose
+            )
         except:
             if verbose:
                 print(f"failed link")
     return res
 
-def echo(*args,**kwargs):
+
+def echo(*args, **kwargs):
     """
     query, model="gpt", verbose=True, log=True, dir_save=dir_save
     a ai chat tool
@@ -172,12 +196,12 @@ def echo(*args,**kwargs):
         str: the answer from ai
     """
     global dir_save
-    
-    query=None
-    model=kwargs.get('model', 'gpt')
-    verbose=kwargs.get('verbose', True)
-    log=kwargs.get('log', True)
-    dir_save=kwargs.get('dir_save', dir_save)
+
+    query = None
+    model = kwargs.get("model", "gpt")
+    verbose = kwargs.get("verbose", True)
+    log = kwargs.get("log", True)
+    dir_save = kwargs.get("dir_save", dir_save)
     for arg in args:
         if isinstance(arg, str):
             if os.path.isdir(arg):
@@ -191,15 +215,17 @@ def echo(*args,**kwargs):
         elif isinstance(arg, dict):
             verbose = arg.get("verbose", verbose)
             log = arg.get("log", log)
+
     def is_in_any(str_candi_short, str_full, ignore_case=True):
         if isinstance(str_candi_short, str):
-            str_candi_short=[str_candi_short]
-        res_bool=[]
+            str_candi_short = [str_candi_short]
+        res_bool = []
         if ignore_case:
-            [res_bool.append(i in str_full.lower())  for i in str_candi_short ]
+            [res_bool.append(i in str_full.lower()) for i in str_candi_short]
         else:
-            [res_bool.append(i in str_full)  for i in str_candi_short ]
+            [res_bool.append(i in str_full) for i in str_candi_short]
         return any(res_bool)
+
     def valid_mod_name(str_fly):
         if is_in_any(str_fly, "claude-3-haiku"):
             return "claude-3-haiku"
@@ -210,49 +236,56 @@ def echo(*args,**kwargs):
         elif is_in_any(str_fly, "mixtral-8x7b"):
             return "mixtral-8x7b"
         else:
-            print(f"not support your model{model}, supported models: 'claude','gpt(default)', 'llama','mixtral'")
-            return "gpt-3.5" # default model
+            print(
+                f"not support your model{model}, supported models: 'claude','gpt(default)', 'llama','mixtral'"
+            )
+            return "gpt-3.5"  # default model
+
     model_valid = valid_mod_name(model)
-    res=DDGS().chat(query, model=model_valid)
+    res = DDGS().chat(query, model=model_valid)
     if verbose:
         pp(res)
     if log:
-        dt_str=datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d_%H:%M:%S')
+        dt_str = datetime.fromtimestamp(time.time()).strftime("%Y-%m-%d_%H:%M:%S")
         res_ = f"\n\n####Q:{query}\n\n#####Ans:{dt_str}\n\n>{res}\n"
         if bool(os.path.basename(dir_save)):
             fpath = dir_save
         else:
             os.makedirs(dir_save, exist_ok=True)
             fpath = os.path.join(dir_save, f"log_ai.md")
-        fupdate(fpath=fpath,content=res_)
+        fupdate(fpath=fpath, content=res_)
         print(f"log file:{fpath}")
     return res
 
+
 def chat(*args, **kwargs):
     return echo(*args, **kwargs)
 
+
 def ai(*args, **kwargs):
     return echo(*args, **kwargs)
 
-def detect_lang(text, output='lang',verbose=True):
-    dir_curr_script=os.path.dirname(os.path.abspath(__file__))
-    dir_lang_code=dir_curr_script+"/data/lang_code_iso639.json"
-    print(dir_curr_script,os.getcwd(),dir_lang_code)
-    lang_code_iso639=fload(dir_lang_code)
-    l_lang,l_code = [],[]
-    [[l_lang.append(v),l_code.append(k)] for v,k in lang_code_iso639.items()]
+
+def detect_lang(text, output="lang", verbose=True):
+    dir_curr_script = os.path.dirname(os.path.abspath(__file__))
+    dir_lang_code = dir_curr_script + "/data/lang_code_iso639.json"
+    print(dir_curr_script, os.getcwd(), dir_lang_code)
+    lang_code_iso639 = fload(dir_lang_code)
+    l_lang, l_code = [], []
+    [[l_lang.append(v), l_code.append(k)] for v, k in lang_code_iso639.items()]
     try:
         if is_text(text):
-            code_detect=detect(text)
-            if 'c' in output.lower(): # return code
-                return l_code[strcmp(code_detect,l_code, verbose=verbose)[1]]
+            code_detect = detect(text)
+            if "c" in output.lower():  # return code
+                return l_code[strcmp(code_detect, l_code, verbose=verbose)[1]]
             else:
-                return l_lang[strcmp(code_detect,l_code, verbose=verbose)[1]]
+                return l_lang[strcmp(code_detect, l_code, verbose=verbose)[1]]
         else:
             print(f"{text} is not supported")
-            return 'no'
+            return "no"
     except:
-        return 'no'
+        return "no"
+
 
 def is_text(s):
     has_alpha = any(char.isalpha() for char in s)
@@ -260,7 +293,8 @@ def is_text(s):
     # no_special = not re.search(r'[^A-Za-z0-9\s]', s)
     return has_alpha and has_non_alpha
 
-def strcmp(search_term, candidates, ignore_case=True, verbose=True, scorer='WR'):
+
+def strcmp(search_term, candidates, ignore_case=True, verbose=True, scorer="WR"):
     """
     Compares a search term with a list of candidate strings and finds the best match based on similarity score.
 
@@ -273,21 +307,23 @@ def strcmp(search_term, candidates, ignore_case=True, verbose=True, scorer='WR')
     Returns:
     tuple: A tuple containing the best match and its index in the candidates list.
     """
+
     def to_lower(s, ignore_case=True):
-        #Converts a string or list of strings to lowercase if ignore_case is True.
+        # Converts a string or list of strings to lowercase if ignore_case is True.
         if ignore_case:
             if isinstance(s, str):
                 return s.lower()
             elif isinstance(s, list):
                 return [elem.lower() for elem in s]
         return s
-    str1_,str2_ = to_lower(search_term, ignore_case),to_lower(candidates, ignore_case)
+
+    str1_, str2_ = to_lower(search_term, ignore_case), to_lower(candidates, ignore_case)
     if isinstance(str2_, list):
-        if 'part' in scorer.lower():
+        if "part" in scorer.lower():
             similarity_scores = [fuzz.partial_ratio(str1_, word) for word in str2_]
-        elif 'W' in scorer.lower():
+        elif "W" in scorer.lower():
             similarity_scores = [fuzz.WRatio(str1_, word) for word in str2_]
-        elif 'Ratio' in scorer.lower():
+        elif "Ratio" in scorer.lower():
             similarity_scores = [fuzz.Ratio(str1_, word) for word in str2_]
         else:
             similarity_scores = [fuzz.WRatio(str1_, word) for word in str2_]
@@ -295,11 +331,11 @@ def strcmp(search_term, candidates, ignore_case=True, verbose=True, scorer='WR')
         best_match_score = similarity_scores[best_match_index]
     else:
         best_match_index = 0
-        if 'part' in scorer.lower():
+        if "part" in scorer.lower():
             best_match_score = fuzz.partial_ratio(str1_, str2_)
-        elif 'W' in scorer.lower():
+        elif "W" in scorer.lower():
             best_match_score = fuzz.WRatio(str1_, str2_)
-        elif 'Ratio' in scorer.lower():
+        elif "Ratio" in scorer.lower():
             best_match_score = fuzz.Ratio(str1_, str2_)
         else:
             best_match_score = fuzz.WRatio(str1_, str2_)
@@ -309,11 +345,13 @@ def strcmp(search_term, candidates, ignore_case=True, verbose=True, scorer='WR')
         print(f"建议: {best_match}")
     return candidates[best_match_index], best_match_index
 
+
 # Example usaged
 # str1 = "plos biology"
 # str2 = ['PLoS Computational Biology', 'PLOS BIOLOGY']
 # best_match, idx = strcmp(str1, str2, ignore_case=1)
 
+
 def counter(list_, verbose=True):
     c = Counter(list_)
     # Print the name counts
@@ -321,14 +359,15 @@ def counter(list_, verbose=True):
         if verbose:
             print(f"{item}: {count}")
     return c
+
+
 # usage:
 # print(f"Return an iterator over elements repeating each as many times as its count:\n{sorted(c.elements())}")
 # 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 str2time(time_str, fmt='24'):
+def str2time(time_str, fmt="24"):
     """
     Convert a time string into the specified format.
     Parameters:
@@ -342,42 +381,47 @@ def str2time(time_str, fmt='24'):
         %p represents AM or PM.
     - str: The converted time string.
     """
+
     def time_len_corr(time_str):
-        time_str_= ssplit(time_str,by=[':'," ","digital_num"]) if ':' in time_str else None
-        time_str_split=[]
-        [time_str_split.append(i) for i in time_str_ if is_num(i)] 
+        time_str_ = (
+            ssplit(time_str, by=[":", " ", "digital_num"]) if ":" in time_str else None
+        )
+        time_str_split = []
+        [time_str_split.append(i) for i in time_str_ if is_num(i)]
         if time_str_split:
-            if len(time_str_split)==2:
-                H,M=time_str_split
-                time_str_full=H+":"+M+":00"
-            elif len(time_str_split)==3:
-                H,M,S=time_str_split
-                time_str_full=H+":"+M+":"+S
+            if len(time_str_split) == 2:
+                H, M = time_str_split
+                time_str_full = H + ":" + M + ":00"
+            elif len(time_str_split) == 3:
+                H, M, S = time_str_split
+                time_str_full = H + ":" + M + ":" + S
         else:
-            time_str_full=time_str_
-        if 'am' in time_str.lower():
-            time_str_full+=" AM" 
-        elif "pm"in time_str.lower():
-            time_str_full +=" PM"  
+            time_str_full = time_str_
+        if "am" in time_str.lower():
+            time_str_full += " AM"
+        elif "pm" in time_str.lower():
+            time_str_full += " PM"
         return time_str_full
-    if '12' in fmt:
+
+    if "12" in fmt:
         fmt = "%I:%M:%S %p"
-    elif '24' in fmt:
+    elif "24" in fmt:
         fmt = "%H:%M:%S"
 
     try:
         # Try to parse the time string assuming it could be in 24-hour or 12-hour format
-        time_obj = datetime.strptime(time_len_corr(time_str), '%H:%M:%S')
+        time_obj = datetime.strptime(time_len_corr(time_str), "%H:%M:%S")
     except ValueError:
         try:
-            time_obj = datetime.strptime(time_len_corr(time_str), '%I:%M:%S %p')
+            time_obj = datetime.strptime(time_len_corr(time_str), "%I:%M:%S %p")
         except ValueError as e:
             raise ValueError(f"Unable to parse time string: {time_str}. Error: {e}")
-    
+
     # Format the time object to the desired output format
     formatted_time = time_obj.strftime(fmt)
     return formatted_time
 
+
 # # Example usage:
 # time_str1 = "14:30:45"
 # time_str2 = "02:30:45 PM"
@@ -388,7 +432,8 @@ def str2time(time_str, fmt='24'):
 # print(formatted_time1)  # Output: 02:30:45 PM
 # print(formatted_time2)  # Output: 14:30:45
 
-def str2date(date_str, fmt='%Y-%m-%d_%H:%M:%S'):
+
+def str2date(date_str, fmt="%Y-%m-%d_%H:%M:%S"):
     """
     Convert a date string into the specified format.
     Parameters:
@@ -404,11 +449,14 @@ def str2date(date_str, fmt='%Y-%m-%d_%H:%M:%S'):
     # Format the date object to the desired output format
     formatted_date = date_obj.strftime(fmt)
     return formatted_date
+
+
 # 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, *args):
     delimiter = None
     round_digits = None
@@ -425,11 +473,11 @@ def str2num(s, *args):
         except ValueError:
             try:
                 numerized = numerize(s)
-                num = int(numerized) if '.' not in numerized else float(numerized)
+                num = int(numerized) if "." not in numerized else float(numerized)
             except Exception as e:
                 # Attempt to handle multiple number segments
                 try:
-                    number_segments = ssplit(s,by='number_strings')
+                    number_segments = ssplit(s, by="number_strings")
                     nums = []
                     for segment in number_segments:
                         try:
@@ -439,7 +487,9 @@ def str2num(s, *args):
                     if len(nums) == 1:
                         num = nums[0]
                     else:
-                        raise ValueError("Multiple number segments found, cannot determine single numeric value")
+                        raise ValueError(
+                            "Multiple number segments found, cannot determine single numeric value"
+                        )
                 except Exception as e:
                     raise ValueError(f"Cannot convert {s} to a number: {e}")
 
@@ -454,6 +504,8 @@ def str2num(s, *args):
         return num_str
 
     return num
+
+
 # Examples
 # print(str2num("123"))                # Output: 123
 # print(str2num("123.456", 2))         # Output: 123.46
@@ -495,13 +547,15 @@ def num2str(num, *args):
             num_str = "{:,}".format(int(num_str_parts[0]))
 
     return num_str
+
+
 # Examples
 # print(num2str(123),type(num2str(123)))                # Output: "123"
 # print(num2str(123.456, 2),type(num2str(123.456, 2)))         # Output: "123.46"
 # print(num2str(7000.125, 2),type(num2str(7000.125, 2)))        # Output: "7000.13"
 # print(num2str(12345.6789, ","),type(num2str(12345.6789, ",")))    # Output: "12,345.6789"
 # print(num2str(7000.00, ","),type(num2str(7000.00, ",")))       # Output: "7,000.00"
-def sreplace(*args,**kwargs):
+def sreplace(*args, **kwargs):
     """
     sreplace(text, by=None, robust=True)
     Replace specified substrings in the input text with provided replacements.
@@ -515,19 +569,19 @@ def sreplace(*args,**kwargs):
         str: The text after replacements have been made.
     """
     text = None
-    by = kwargs.get('by', None)
-    robust = kwargs.get('robust', True)
-    
+    by = kwargs.get("by", None)
+    robust = kwargs.get("robust", True)
+
     for arg in args:
-        if isinstance(arg,str):
-            text=arg
-        elif isinstance(arg,dict):
-            by=arg
-        elif isinstance(arg,bool):
-            robust=arg
+        if isinstance(arg, str):
+            text = arg
+        elif isinstance(arg, dict):
+            by = arg
+        elif isinstance(arg, bool):
+            robust = arg
         else:
             Error(f"{type(arg)} is not supported")
-    
+
     # Default replacements for newline and tab characters
     default_replacements = {
         "\a": "",
@@ -558,47 +612,76 @@ def sreplace(*args,**kwargs):
     for k, v in by.items():
         text = text.replace(k, v)
     return text
+
+
 # usage:
 # sreplace(text, by=dict(old_str='new_str'), robust=True)
 
-def paper_size(paper_type_str='a4'):
-    df=pd.DataFrame({'a0':[841,1189],'a1':[594,841],'a2':[420,594],'a3':[297,420],'a4':[210,297],'a5':[148,210],'a6':[105,148],'a7':[74,105],
-                     'b0':[1028,1456],'b1':[707,1000],'b2':[514,728],'b3':[364,514],'b4':[257,364],'b5':[182,257],'b6':[128,182],
-                     'letter': [215.9, 279.4],'legal':[215.9, 355.6],'business card':[85.6, 53.98],
-                     'photo china passport':[33,48],'passport single':[125,88],'visa':[105,74],'sim':[25,15]})
+
+def paper_size(paper_type_str="a4"):
+    df = pd.DataFrame(
+        {
+            "a0": [841, 1189],
+            "a1": [594, 841],
+            "a2": [420, 594],
+            "a3": [297, 420],
+            "a4": [210, 297],
+            "a5": [148, 210],
+            "a6": [105, 148],
+            "a7": [74, 105],
+            "b0": [1028, 1456],
+            "b1": [707, 1000],
+            "b2": [514, 728],
+            "b3": [364, 514],
+            "b4": [257, 364],
+            "b5": [182, 257],
+            "b6": [128, 182],
+            "letter": [215.9, 279.4],
+            "legal": [215.9, 355.6],
+            "business card": [85.6, 53.98],
+            "photo china passport": [33, 48],
+            "passport single": [125, 88],
+            "visa": [105, 74],
+            "sim": [25, 15],
+        }
+    )
     for name in df.columns:
         if paper_type_str in name.lower():
-            paper_type=name
+            paper_type = name
     if not paper_type:
-        paper_type='a4' # default
+        paper_type = "a4"  # default
     return df[paper_type].tolist()
 
+
 def docx2pdf(dir_docx, dir_pdf=None):
     if dir_pdf:
-        convert(dir_docx,dir_pdf)
+        convert(dir_docx, dir_pdf)
     else:
         convert(dir_docx)
 
-def img2pdf(dir_img, kind="jpeg",page=None, dir_save=None, page_size="a4", dpi=300):
+
+def img2pdf(dir_img, kind="jpeg", page=None, dir_save=None, page_size="a4", dpi=300):
     def mm_to_point(size):
-        return (image2pdf.mm_to_pt(size[0]),image2pdf.mm_to_pt(size[1]))
+        return (image2pdf.mm_to_pt(size[0]), image2pdf.mm_to_pt(size[1]))
+
     def set_dpi(x):
-        dpix=dpiy=x
+        dpix = dpiy = x
         return image2pdf.get_fixed_dpi_layout_fun((dpix, dpiy))
+
     if not kind.startswith("."):
-        kind="."+kind
+        kind = "." + kind
     if dir_save is None:
-        dir_save = dir_img.replace(kind,'.pdf')
-    imgs = [] 
+        dir_save = dir_img.replace(kind, ".pdf")
+    imgs = []
     if os.path.isdir(dir_img):
         if not dir_save.endswith(".pdf"):
-            dir_save+="#merged_img2pdf.pdf"
+            dir_save += "#merged_img2pdf.pdf"
         if page is None:
-            select_range = listdir(dir_img,kind=kind).fpath
+            select_range = listdir(dir_img, kind=kind).fpath
         else:
-            if not isinstance(page, (np.ndarray,list,range)):
-                page=[page]
-            select_range = listdir(dir_img,kind=kind)['fpath'][page]
+            if not isinstance(page, (np.ndarray, list, range)):
+                page = [page]
+            select_range = listdir(dir_img, kind=kind)["fpath"][page]
         for fname in select_range:
             if not fname.endswith(kind):
                 continue
@@ -607,24 +690,27 @@ def img2pdf(dir_img, kind="jpeg",page=None, dir_save=None, page_size="a4", dpi=3
                 continue
             imgs.append(path)
     else:
-        imgs=[os.path.isdir(dir_img),dir_img]
+        imgs = [os.path.isdir(dir_img), dir_img]
 
     if page_size:
-        if isinstance(page_size,str):
-            pdf_in_mm=mm_to_point(paper_size(page_size))
+        if isinstance(page_size, str):
+            pdf_in_mm = mm_to_point(paper_size(page_size))
         else:
             print("default: page_size = (210,297)")
-            pdf_in_mm=mm_to_point(page_size)
+            pdf_in_mm = mm_to_point(page_size)
             print(f"page size was set to {page_size}")
-        p_size= image2pdf.get_layout_fun(pdf_in_mm)
+        p_size = image2pdf.get_layout_fun(pdf_in_mm)
     else:
         p_size = set_dpi(dpi)
-    with open(dir_save,"wb") as f:
+    with open(dir_save, "wb") as f:
         f.write(image2pdf.convert(imgs, layout_fun=p_size))
+
+
 # usage:
 # dir_img="/Users/macjianfeng/Dropbox/00-Personal/2015-History/2012-2015_兰州大学/120901-大学课件/生物统计学 陆卫/复习题/"
 # img2pdf(dir_img,kind='tif', page=range(3,7,2))
 
+
 def pdf2ppt(dir_pdf, dir_ppt):
     prs = Presentation()
 
@@ -639,21 +725,26 @@ def pdf2ppt(dir_pdf, dir_ppt):
             text = page.extract_text()
 
             # Add a slide for each page's content
-            slide_layout = prs.slide_layouts[5]  # Use slide layout that suits your needs
+            slide_layout = prs.slide_layouts[
+                5
+            ]  # Use slide layout that suits your needs
             slide = prs.slides.add_slide(slide_layout)
             slide.shapes.title.text = f"Page {page_num + 1}"
-            slide.shapes.add_textbox(Inches(1), Inches(1.5), Inches(8), Inches(5)).text = text
+            slide.shapes.add_textbox(
+                Inches(1), Inches(1.5), Inches(8), Inches(5)
+            ).text = text
 
     # Save the PowerPoint presentation
     prs.save(dir_ppt)
     print(f"Conversion from {dir_pdf} to {dir_ppt} complete.")
 
 
-def ssplit(text, by="space", verbose=False,strict=False, **kws):
+def ssplit(text, by="space", verbose=False, strict=False, **kws):
     if isinstance(text, list):
-        nested_list= [ssplit(i,by=by,verbose=verbose,**kws) for i in text]
+        nested_list = [ssplit(i, by=by, verbose=verbose, **kws) for i in text]
         flat_list = [item for sublist in nested_list for item in sublist]
         return flat_list
+
     def split_by_word_length(text, length):
         return [word for word in text.split() if len(word) == length]
 
@@ -677,10 +768,10 @@ def ssplit(text, by="space", verbose=False,strict=False, **kws):
         return split_text
 
     def split_by_regex_lookahead(text, pattern):
-        return re.split(f'(?<={pattern})', text)
-    
+        return re.split(f"(?<={pattern})", text)
+
     def split_by_regex_end(text, pattern):
-        return re.split(f'(?={pattern})', text)
+        return re.split(f"(?={pattern})", text)
 
     # def split_by_sentence_endings(text):
     #     return re.split(r"(?<=[.!?])", text)
@@ -688,24 +779,27 @@ def ssplit(text, by="space", verbose=False,strict=False, **kws):
         # return re.split(r"([^\x00-\x7F\w\s,.!?:\"'()\-]+)", text)
         # return re.split(r"[^\x00-\x7F]+", text)
         return re.split(r"([^\x00-\x7F]+)", text)
+
     def split_by_consecutive_non_alphanumeric(text):
         return re.split(r"\W+", text)
 
     def split_by_fixed_length_chunks(text, length):
         return [text[i : i + length] for i in range(0, len(text), length)]
-    def split_by_sent_num(text,n=10):
+
+    def split_by_sent_num(text, n=10):
         # split text into sentences
-        text_split_by_sent=sent_tokenize(text)
-        cut_loc_array=np.arange(0,len(text_split_by_sent),n)
-        if cut_loc_array[-1]!=len(text_split_by_sent):
-            cut_loc=np.append(cut_loc_array,len(text_split_by_sent))
+        text_split_by_sent = sent_tokenize(text)
+        cut_loc_array = np.arange(0, len(text_split_by_sent), n)
+        if cut_loc_array[-1] != len(text_split_by_sent):
+            cut_loc = np.append(cut_loc_array, len(text_split_by_sent))
         else:
             cut_loc = cut_loc_array
         # get text in section (e.g., every 10 sentences)
-        text_section=[]
-        for i,j in pairwise(cut_loc):
+        text_section = []
+        for i, j in pairwise(cut_loc):
             text_section.append(text_split_by_sent[i:j])
         return text_section
+
     def split_general(text, by, verbose=False, ignore_case=False):
         if ignore_case:
             if verbose:
@@ -717,8 +811,10 @@ def ssplit(text, by="space", verbose=False,strict=False, **kws):
             if verbose:
                 print(f"used {by} to split, ignore_case=False")
             return text.split(by)
+
     def reg_split(text, pattern):
         return re.split(pattern, text)
+
     if ("sp" in by or "white" in by) and not strict:
         if verbose:
             print(f"splited by space")
@@ -735,14 +831,20 @@ def ssplit(text, by="space", verbose=False,strict=False, **kws):
         if verbose:
             print(f"split_by_multiple_delimiters: ['|','&']")
         return split_by_multiple_delimiters(text, by)
-    elif all([("digi" in by or "num" in by),not 'sent' in by, not 'str' in by]) and not strict:
+    elif (
+        all([("digi" in by or "num" in by), not "sent" in by, not "str" in by])
+        and not strict
+    ):
         if verbose:
             print(f"splited by digital (numbers)")
         return re.split(r"(\d+)", text)
-    elif all([("digi" in by or "num" in by), 'str' in by]) and not strict:
+    elif all([("digi" in by or "num" in by), "str" in by]) and not strict:
         if verbose:
             print(f"Splitting by (number strings)")
-        pattern = re.compile(r'\b((?:one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety|hundred|thousand|million|billion|trillion|and|[\d,]+(?:\.\d+)?)(?:[-\s]?(?:one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety|hundred|thousand|million|billion|trillion|and|[\d,]+(?:\.\d+)?))*)\b', re.IGNORECASE)
+        pattern = re.compile(
+            r"\b((?:one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety|hundred|thousand|million|billion|trillion|and|[\d,]+(?:\.\d+)?)(?:[-\s]?(?:one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety|hundred|thousand|million|billion|trillion|and|[\d,]+(?:\.\d+)?))*)\b",
+            re.IGNORECASE,
+        )
         return re.split(pattern, text)
     elif ("pun" in by) and not strict:
         if verbose:
@@ -760,12 +862,12 @@ def ssplit(text, by="space", verbose=False,strict=False, **kws):
         if verbose:
             print(f"splited by word")
         return word_tokenize(text)
-    elif ("sen" in by and not 'num' in by) and not strict:
+    elif ("sen" in by and not "num" in by) and not strict:
         if verbose:
             print(f"splited by sentence")
         return sent_tokenize(text)
-    elif ('sen' in by and 'num' in by) and not strict:
-        return split_by_sent_num(text,**kws)
+    elif ("sen" in by and "num" in by) and not strict:
+        return split_by_sent_num(text, **kws)
     elif ("cha" in by) and not strict:
         if verbose:
             print(f"splited by chracters")
@@ -803,32 +905,32 @@ def ssplit(text, by="space", verbose=False,strict=False, **kws):
         if verbose:
             print(f"splited by customed, re; => {by}")
         return reg_split(text, **kws)
-    elif ('lang' in by or 'eng' in by) and not strict:
+    elif ("lang" in by or "eng" in by) and not strict:
         return split_non_ascii(text)
     else:
         return split_general(text, by, verbose=verbose, **kws)
 
 
-def pdf2img(dir_pdf, dir_save=None, page=None, kind="png",verbose=True, **kws):
+def pdf2img(dir_pdf, dir_save=None, page=None, kind="png", verbose=True, **kws):
     df_dir_img_single_page = pd.DataFrame()
     dir_single_page = []
     if verbose:
         pp(pdfinfo_from_path(dir_pdf))
     if isinstance(page, tuple) and page:
         page = list(page)
-    if isinstance(page,int):
-        page=[page]
+    if isinstance(page, int):
+        page = [page]
     if page is None:
         page = [pdfinfo_from_path(dir_pdf)["Pages"]]
-    if len(page)==1 and page != pdfinfo_from_path(dir_pdf)["Pages"]:
-        page=[page[0], page[0]]
+    if len(page) == 1 and page != pdfinfo_from_path(dir_pdf)["Pages"]:
+        page = [page[0], page[0]]
     else:
-        page=[1, page[0]]
+        page = [1, page[0]]
     pages = convert_from_path(dir_pdf, first_page=page[0], last_page=page[1], **kws)
     if dir_save is None:
         dir_save = newfolder(dirname(dir_pdf), basename(dir_pdf).split(".")[0] + "_img")
     for i, page in enumerate(pages):
-        if verbose: 
+        if verbose:
             print(f"processing page: {i+1}")
         if i < 9:
             dir_img_each_page = dir_save + f"page_0{i+1}.png"
@@ -839,6 +941,7 @@ def pdf2img(dir_pdf, dir_save=None, page=None, kind="png",verbose=True, **kws):
     df_dir_img_single_page["fpath"] = dir_single_page
     return df_dir_img_single_page
 
+
 # dir_pdf = "/Users/macjianfeng/Dropbox/github/python/240308_Python Data Science Handbook.pdf"
 # df_page = pdf2img(dir_pdf, page=[1, 5],dpi=300)
 def get_encoding(fpath, alternative_encodings=None, verbose=False):
@@ -855,14 +958,37 @@ def get_encoding(fpath, alternative_encodings=None, verbose=False):
     """
     if alternative_encodings is None:
         alternative_encodings = [
-            'utf-8', 'latin1', 'windows-1252', 'iso-8859-1',
-            'iso-8859-2', 'iso-8859-3', 'iso-8859-4', 'iso-8859-5',
-            'iso-8859-6', 'iso-8859-7', 'iso-8859-8', 'iso-8859-9',
-            'windows-1250', 'windows-1251', 'windows-1253', 'windows-1254',
-            'windows-1255', 'windows-1256', 'windows-1257', 'windows-1258',
-            'big5', 'gb18030', 'shift_jis', 'euc_jp', 'koi8_r',
-            'mac_roman', 'mac_central_europe', 'mac_greek', 'mac_cyrillic',
-            'mac_arabic', 'mac_hebrew'
+            "utf-8",
+            "latin1",
+            "windows-1252",
+            "iso-8859-1",
+            "iso-8859-2",
+            "iso-8859-3",
+            "iso-8859-4",
+            "iso-8859-5",
+            "iso-8859-6",
+            "iso-8859-7",
+            "iso-8859-8",
+            "iso-8859-9",
+            "windows-1250",
+            "windows-1251",
+            "windows-1253",
+            "windows-1254",
+            "windows-1255",
+            "windows-1256",
+            "windows-1257",
+            "windows-1258",
+            "big5",
+            "gb18030",
+            "shift_jis",
+            "euc_jp",
+            "koi8_r",
+            "mac_roman",
+            "mac_central_europe",
+            "mac_greek",
+            "mac_cyrillic",
+            "mac_arabic",
+            "mac_hebrew",
         ]
 
     if not os.path.isfile(fpath):
@@ -870,7 +996,7 @@ def get_encoding(fpath, alternative_encodings=None, verbose=False):
 
     for enc in alternative_encodings:
         try:
-            with open(fpath, mode='r', encoding=enc) as file:
+            with open(fpath, mode="r", encoding=enc) as file:
                 file.read()  # Try to read the file
             if verbose:
                 print(f"Successfully detected encoding: {enc}")
@@ -895,6 +1021,7 @@ def fload(fpath, kind=None, **kwargs):
     Returns:
         content: The content loaded from the file.
     """
+
     def load_txt_md(fpath):
         with open(fpath, "r") as file:
             content = file.read()
@@ -920,7 +1047,7 @@ def fload(fpath, kind=None, **kwargs):
         root = tree.getroot()
         return etree.tostring(root, pretty_print=True).decode()
 
-    def load_csv(fpath, engine='pyarrow',**kwargs):
+    def load_csv(fpath, engine="pyarrow", **kwargs):
         print(f"engine={engine}")
         df = pd.read_csv(fpath, engine=engine, **kwargs)
         return df
@@ -928,35 +1055,36 @@ def fload(fpath, kind=None, **kwargs):
     def load_xlsx(fpath, **kwargs):
         df = pd.read_excel(fpath, **kwargs)
         return df
-    def load_ipynb(fpath,**kwargs):
-        as_version=kwargs.get("as_version",4)
+
+    def load_ipynb(fpath, **kwargs):
+        as_version = kwargs.get("as_version", 4)
         with open(fpath, "r") as file:
             nb = nbformat.read(file, as_version=as_version)
             md_exporter = MarkdownExporter()
             md_body, _ = md_exporter.from_notebook_node(nb)
         return md_body
-    
-    def load_pdf(fpath, page='all', verbose=False, **kwargs):
+
+    def load_pdf(fpath, page="all", verbose=False, **kwargs):
         """
-            Parameters:
-            fpath: The path to the PDF file to be loaded.
-            page (optional): 
-                Specifies which page or pages to extract text from. By default, it's set to "all", which means text from all 
-                pages will be returned. It can also be an integer to specify a single page number or a list of integers to 
-                specify multiple pages.
-            verbose (optional): 
-                If True, prints the total number of pages processed.
-            Functionality:
-            It initializes an empty dictionary text_dict to store page numbers as keys and their corresponding text as values.
-            It iterates through each page of the PDF file using a for loop.
-            For each page, it extracts the text using PyPDF2's extract_text() method and stores it in text_dict with the page number incremented by 1 as the key.
-            If the page parameter is an integer, it converts it into a list containing that single page number to ensure consistency in handling.
-            If the page parameter is a NumPy array, it converts it to a list using the tolist() method to ensure compatibility with list operations.
-            If verbose is True, it prints the total number of pages processed.
-            If page is a list, it combines the text of the specified pages into a single string combined_text and returns it.
-            If page is set to "all", it returns the entire text_dict containing text of all pages.
-            If page is an integer, it returns the text of the specified page number.
-            If the specified page is not found, it returns the string "Page is not found".
+        Parameters:
+        fpath: The path to the PDF file to be loaded.
+        page (optional):
+            Specifies which page or pages to extract text from. By default, it's set to "all", which means text from all
+            pages will be returned. It can also be an integer to specify a single page number or a list of integers to
+            specify multiple pages.
+        verbose (optional):
+            If True, prints the total number of pages processed.
+        Functionality:
+        It initializes an empty dictionary text_dict to store page numbers as keys and their corresponding text as values.
+        It iterates through each page of the PDF file using a for loop.
+        For each page, it extracts the text using PyPDF2's extract_text() method and stores it in text_dict with the page number incremented by 1 as the key.
+        If the page parameter is an integer, it converts it into a list containing that single page number to ensure consistency in handling.
+        If the page parameter is a NumPy array, it converts it to a list using the tolist() method to ensure compatibility with list operations.
+        If verbose is True, it prints the total number of pages processed.
+        If page is a list, it combines the text of the specified pages into a single string combined_text and returns it.
+        If page is set to "all", it returns the entire text_dict containing text of all pages.
+        If page is an integer, it returns the text of the specified page number.
+        If the specified page is not found, it returns the string "Page is not found".
         """
         text_dict = {}
         with open(fpath, "rb") as file:
@@ -989,18 +1117,52 @@ def fload(fpath, kind=None, **kwargs):
     def load_docx(fpath):
         doc = Document(fpath)
         content = [para.text for para in doc.paragraphs]
-        return content 
+        return content
 
     if kind is None:
         _, kind = os.path.splitext(fpath)
         kind = kind.lower()
 
-    kind = kind.lstrip('.').lower()
-    img_types=[ 'bmp','eps', 'gif', 'icns', 'ico', 'im', 'jpg','jpeg', 'jpeg2000','msp', 'pcx', 'png', 'ppm', 'sgi', 'spider', 'tga','tiff','webp',"json"]
-    doc_types = ["docx", "txt", "md", "html", "json", "yaml", "xml", "csv", "xlsx", "pdf","ipynb"]
+    kind = kind.lstrip(".").lower()
+    img_types = [
+        "bmp",
+        "eps",
+        "gif",
+        "icns",
+        "ico",
+        "im",
+        "jpg",
+        "jpeg",
+        "jpeg2000",
+        "msp",
+        "pcx",
+        "png",
+        "ppm",
+        "sgi",
+        "spider",
+        "tga",
+        "tiff",
+        "webp",
+        "json",
+    ]
+    doc_types = [
+        "docx",
+        "txt",
+        "md",
+        "html",
+        "json",
+        "yaml",
+        "xml",
+        "csv",
+        "xlsx",
+        "pdf",
+        "ipynb",
+    ]
     supported_types = [*doc_types, *img_types]
     if kind not in supported_types:
-        raise ValueError(f"Error:\n{kind} is not in the supported list {supported_types}")
+        raise ValueError(
+            f"Error:\n{kind} is not in the supported list {supported_types}"
+        )
     if kind == "docx":
         return load_docx(fpath)
     elif kind == "txt" or kind == "md":
@@ -1024,9 +1186,12 @@ def fload(fpath, kind=None, **kwargs):
         return load_pdf(fpath, **kwargs)
     elif kind.lower() in img_types:
         print(f'Image ".{kind}" is loaded.')
-        return load_img(fpath) 
+        return load_img(fpath)
     else:
-        raise ValueError(f"Error:\n{kind} is not in the supported list {supported_types}")
+        raise ValueError(
+            f"Error:\n{kind} is not in the supported list {supported_types}"
+        )
+
 
 # Example usage
 # txt_content = fload('sample.txt')
@@ -1039,6 +1204,7 @@ def fload(fpath, kind=None, **kwargs):
 # xlsx_content = fload('sample.xlsx')
 # docx_content = fload('sample.docx')
 
+
 def fupdate(fpath, content=None):
     """
     Update a file by adding new content at the top and moving the old content to the bottom.
@@ -1055,34 +1221,37 @@ def fupdate(fpath, content=None):
     """
     content = content or ""
     if os.path.exists(fpath):
-        with open(fpath, 'r') as file:
+        with open(fpath, "r") as file:
             old_content = file.read()
     else:
-        old_content = '' 
-        
-    with open(fpath, 'w') as file:
+        old_content = ""
+
+    with open(fpath, "w") as file:
         file.write(content)
         file.write(old_content)
+
+
 def fappend(fpath, content=None):
     """
     append new content at the end.
     """
     content = content or ""
     if os.path.exists(fpath):
-        with open(fpath, 'r') as file:
+        with open(fpath, "r") as file:
             old_content = file.read()
     else:
-        old_content = '' 
-        
-    with open(fpath, 'w') as file:
+        old_content = ""
+
+    with open(fpath, "w") as file:
         file.write(old_content)
         file.write(content)
-        
+
+
 def fsave(
     fpath,
     content,
-    mode='w',
-    how ='overwrite',
+    mode="w",
+    how="overwrite",
     kind=None,
     font_name="Times",
     font_size=10,
@@ -1102,16 +1271,16 @@ def fsave(
     Returns:
         None
     """
-    def save_content(fpath, content, mode=mode, how='overwrite'): 
-        if 'wri' in how.lower():
-            with open(fpath, mode, encoding='utf-8') as file:
+
+    def save_content(fpath, content, mode=mode, how="overwrite"):
+        if "wri" in how.lower():
+            with open(fpath, mode, encoding="utf-8") as file:
                 file.write(content)
-        elif 'upd' in how.lower():
+        elif "upd" in how.lower():
             fupdate(fpath, content=content)
-        elif 'app' in how.lower():
+        elif "app" in how.lower():
             fappend(fpath, content=content)
 
-
     def save_docx(fpath, content, font_name, font_size, spacing):
         if isinstance(content, str):
             content = content.split(". ")
@@ -1126,45 +1295,40 @@ def fsave(
                 paragraph.space_after = docx.shared.Pt(spacing)
         doc.save(fpath)
 
-
-    def save_txt_md(fpath, content, sep="\n",mode='w'):
-            # Ensure content is a single string
+    def save_txt_md(fpath, content, sep="\n", mode="w"):
+        # Ensure content is a single string
         if isinstance(content, list):
             content = sep.join(content)
-        save_content(fpath, sep.join(content),mode)
-
+        save_content(fpath, sep.join(content), mode)
 
-    def save_html(fpath, content, font_name, font_size,mode='w'):
+    def save_html(fpath, content, font_name, font_size, mode="w"):
         html_content = "<html><body>"
         for paragraph_text in content:
             html_content += f'<p style="font-family:{font_name}; font-size:{font_size}px;">{paragraph_text}</p>'
         html_content += "</body></html>"
-        save_content(fpath, html_content,mode)
-
+        save_content(fpath, html_content, mode)
 
     def save_pdf(fpath, content, font_name, font_size):
         pdf = FPDF()
         pdf.add_page()
         # pdf.add_font('Arial','',r'/System/Library/Fonts/Supplemental/Arial.ttf',uni=True)
-        pdf.set_font(font_name, '',font_size)
+        pdf.set_font(font_name, "", font_size)
         for paragraph_text in content:
             pdf.multi_cell(0, 10, paragraph_text)
-            pdf.ln(h = '')
-        pdf.output(fpath,'F')
-
+            pdf.ln(h="")
+        pdf.output(fpath, "F")
 
     def save_csv(fpath, data, **kwargs):
         df = pd.DataFrame(data)
         df.to_csv(fpath, **kwargs)
 
-
     def save_xlsx(fpath, data, **kwargs):
         df = pd.DataFrame(data)
         df.to_excel(fpath, **kwargs)
 
-    def save_ipynb(fpath,data,**kwargs):
+    def save_ipynb(fpath, data, **kwargs):
         # Split the content by code fences to distinguish between code and markdown
-        parts = data.split('```')
+        parts = data.split("```")
         cells = []
 
         for i, part in enumerate(parts):
@@ -1176,31 +1340,32 @@ def fsave(
                 cells.append(nbformat.v4.new_code_cell(part.strip()))
         # Create a new notebook
         nb = nbformat.v4.new_notebook()
-        nb['cells'] = cells
+        nb["cells"] = cells
         # Write the notebook to a file
-        with open(fpath, 'w', encoding='utf-8') as ipynb_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)
 
-    def save_json(fpath_fname, var_dict_or_df): 
+    def save_json(fpath_fname, var_dict_or_df):
         with open(fpath_fname, "w") as f_json:
             # Check if var_dict_or_df is a DataFrame
             if isinstance(var_dict_or_df, pd.DataFrame):
                 # Convert DataFrame to a list of dictionaries
                 var_dict_or_df = var_dict_or_df.to_dict(orient="dict")
-            
+
             # Check if var_dict_or_df is a dictionary
             if isinstance(var_dict_or_df, dict):
                 # Convert NumPy arrays to lists
                 for key, value in var_dict_or_df.items():
                     if isinstance(value, np.ndarray):
                         var_dict_or_df[key] = value.tolist()
-            
+
             # Save the dictionary or list of dictionaries to a JSON file
             json.dump(var_dict_or_df, f_json, indent=4)
+
     # # Example usage:
     # sets = {"title": "mse_path_ MSE"}
     # jsonsave("/.json", sets)
@@ -1210,7 +1375,6 @@ def fsave(
         with open(fpath, "w") as file:
             yaml.dump(data, file, **kwargs)
 
-
     def save_xml(fpath, data):
         root = etree.Element("root")
         if isinstance(data, dict):
@@ -1239,18 +1403,18 @@ def fsave(
         "json",
         "xml",
         "yaml",
-        "ipynb"
+        "ipynb",
     ]:
         print(
             f"Warning:\n{kind} is not in the supported list ['docx', 'txt', 'md', 'html', 'pdf', 'csv', 'xlsx', 'json', 'xml', 'yaml']"
         )
 
-    if kind == "docx" or kind=="doc":
+    if kind == "docx" or kind == "doc":
         save_docx(fpath, content, font_name, font_size, spacing)
     elif kind == "txt":
-        save_txt_md(fpath, content, sep="",mode=mode)
+        save_txt_md(fpath, content, sep="", mode=mode)
     elif kind == "md":
-        save_txt_md(fpath, content, sep="",mode=mode)
+        save_txt_md(fpath, content, sep="", mode=mode)
     elif kind == "html":
         save_html(fpath, content, font_name, font_size)
     elif kind == "pdf":
@@ -1260,20 +1424,20 @@ def fsave(
     elif kind == "xlsx":
         save_xlsx(fpath, content, **kwargs)
     elif kind == "json":
-        save_json(fpath, content) 
+        save_json(fpath, content)
     elif kind == "xml":
-        save_xml(fpath, content) 
+        save_xml(fpath, content)
     elif kind == "yaml":
         save_yaml(fpath, content, **kwargs)
     elif kind == "ipynb":
-        save_ipynb(fpath, content, **kwargs) 
+        save_ipynb(fpath, content, **kwargs)
     else:
-        try: 
+        try:
             netfinder.downloader(url=content, dir_save=dirname(fpath), kind=kind)
         except:
             print(
                 f"Error:\n{kind} is not in the supported list ['docx', 'txt', 'md', 'html', 'pdf', 'csv', 'xlsx', 'json', 'xml', 'yaml']"
-                )
+            )
 
 
 # # Example usage
@@ -1294,47 +1458,61 @@ def fsave(
 # fsave(dir_save + "sample.yaml", yaml_content)
 # fsave(dir_save + "sample.xml", xml_content)
 
+
 def addpath(fpath):
-    sys.path.insert(0,dir)
+    sys.path.insert(0, dir)
+
+
 def dirname(fpath):
     """
     dirname: Extracting Directory Name from a File Path
     Args:
-        fpath (str): the file or directory path 
+        fpath (str): the file or directory path
     Returns:
         str: directory, without filename
     """
-    dirname_=os.path.dirname(fpath)
-    if not dirname_.endswith('/'):
-        dirname_=dirname_+"/"
+    dirname_ = os.path.dirname(fpath)
+    if not dirname_.endswith("/"):
+        dirname_ = dirname_ + "/"
     return dirname_
 
-def dir_name(fpath): # same as "dirname"
+
+def dir_name(fpath):  # same as "dirname"
     return dirname(fpath)
+
+
 def basename(fpath):
     """
     basename: # Output: file.txt
     Args:
-        fpath (str): the file or directory path 
+        fpath (str): the file or directory path
     Returns:
         str: # Output: file.txt
     """
     return os.path.basename(fpath)
+
+
 def flist(fpath, contains="all"):
-    all_files = [os.path.join(fpath, f) for f in os.listdir(fpath) if os.path.isfile(os.path.join(fpath, f))]
+    all_files = [
+        os.path.join(fpath, f)
+        for f in os.listdir(fpath)
+        if os.path.isfile(os.path.join(fpath, f))
+    ]
     if isinstance(contains, list):
         filt_files = []
         for filter_ in contains:
             filt_files.extend(flist(fpath, filter_))
         return filt_files
     else:
-        if 'all' in contains.lower():
+        if "all" in contains.lower():
             return all_files
         else:
             filt_files = [f for f in all_files if isa(f, contains)]
             return filt_files
+
+
 def sort_kind(df, by="name", ascending=True):
-    if df[by].dtype == 'object':  # Check if the column contains string values
+    if df[by].dtype == "object":  # Check if the column contains string values
         if ascending:
             sorted_index = df[by].str.lower().argsort()
         else:
@@ -1347,7 +1525,8 @@ def sort_kind(df, by="name", ascending=True):
     sorted_df = df.iloc[sorted_index].reset_index(drop=True)
     return sorted_df
 
-def isa(*args,**kwargs):
+
+def isa(*args, **kwargs):
     """
     fpath, contains='img'
     containss file paths based on the specified contains.
@@ -1360,30 +1539,33 @@ def isa(*args,**kwargs):
     """
     for arg in args:
         if isinstance(arg, str):
-            if '/' in arg or '\\' in arg:
+            if "/" in arg or "\\" in arg:
                 fpath = arg
             else:
-                contains=arg
-    if 'img' in contains.lower() or 'image' in contains.lower():
+                contains = arg
+    if "img" in contains.lower() or "image" in contains.lower():
         return is_image(fpath)
-    elif 'doc' in contains.lower():
+    elif "doc" in contains.lower():
         return is_document(fpath)
-    elif 'zip' in contains.lower():
+    elif "zip" in contains.lower():
         return is_zip(fpath)
-    elif 'dir' in contains.lower() or ('f' in contains.lower() and 'd' in contains.lower()):
+    elif "dir" in contains.lower() or (
+        "f" in contains.lower() and "d" in contains.lower()
+    ):
         return os.path.isdir(fpath)
-    elif 'fi' in contains.lower():#file
+    elif "fi" in contains.lower():  # file
         return os.path.isfile(fpath)
-    elif 'num' in contains.lower():#file
+    elif "num" in contains.lower():  # file
         return os.path.isfile(fpath)
-    elif 'text' in contains.lower() or 'txt' in contains.lower():#file
+    elif "text" in contains.lower() or "txt" in contains.lower():  # file
         return is_text(fpath)
-    elif 'color' in contains.lower():#file
+    elif "color" in contains.lower():  # file
         return is_str_color(fpath)
     else:
         print(f"{contains} was not set up correctly")
         return False
 
+
 def listdir(
     rootdir,
     kind="folder",
@@ -1391,7 +1573,7 @@ def listdir(
     ascending=True,
     contains=None,
     orient="list",
-    output="df" # 'list','dict','records','index','series'
+    output="df",  # 'list','dict','records','index','series'
 ):
     if not kind.startswith("."):
         kind = "." + kind
@@ -1420,12 +1602,12 @@ def listdir(
             is_file = kind.lower() in file_extension.lower() and (
                 os.path.isfile(item_path)
             )
-            if kind in ['.doc','.img','.zip']: #选择大的类别
+            if kind in [".doc", ".img", ".zip"]:  # 选择大的类别
                 if kind != ".folder" and not isa(item_path, kind):
                     continue
-            elif kind in ['.all']:
+            elif kind in [".all"]:
                 return flist(fpath, contains=contains)
-            else: #精确到文件的后缀
+            else:  # 精确到文件的后缀
                 if not is_folder and not is_file:
                     continue
             f["name"].append(filename)
@@ -1433,9 +1615,15 @@ def listdir(
             f["path"].append(os.path.join(os.path.dirname(item_path), item))
             fpath = os.path.join(os.path.dirname(item_path), item)
             f["size"].append(round(os.path.getsize(fpath) / 1024 / 1024, 3))
-            f["created_time"].append(pd.to_datetime(os.path.getctime(item_path), unit='s'))
-            f["modified_time"].append(pd.to_datetime(os.path.getmtime(item_path), unit='s'))
-            f['last_open_time'].append(pd.to_datetime(os.path.getatime(item_path), unit='s'))
+            f["created_time"].append(
+                pd.to_datetime(os.path.getctime(item_path), unit="s")
+            )
+            f["modified_time"].append(
+                pd.to_datetime(os.path.getmtime(item_path), unit="s")
+            )
+            f["last_open_time"].append(
+                pd.to_datetime(os.path.getatime(item_path), unit="s")
+            )
             f["fname"].append(filename)  # will be removed
             f["fpath"].append(fpath)  # will be removed
             i += 1
@@ -1464,35 +1652,39 @@ def listdir(
     elif "s" in sort_by.lower() and "z" in sort_by.lower():
         f = sort_kind(f, by="size", ascending=ascending)
 
-    if 'df' in output:
+    if "df" in output:
         return f
     else:
-        if 'l' in orient.lower():  # list # default
+        if "l" in orient.lower():  # list # default
             res_output = Box(f.to_dict(orient="list"))
             return res_output
-        if 'd' in orient.lower():  # dict
+        if "d" in orient.lower():  # dict
             return Box(f.to_dict(orient="dict"))
-        if 'r' in orient.lower():  # records
+        if "r" in orient.lower():  # records
             return Box(f.to_dict(orient="records"))
-        if 'in' in orient.lower():  # records
+        if "in" in orient.lower():  # records
             return Box(f.to_dict(orient="index"))
-        if 'se' in orient.lower():  # records
+        if "se" in orient.lower():  # records
             return Box(f.to_dict(orient="series"))
 
+
 # Example usage:
 # result = listdir('your_root_directory')
 # print(result)
 # df=listdir("/", contains='sss',sort_by='name',ascending=False)
-# print(df.fname.to_list(),"\n",df.fpath.to_list())  
+# print(df.fname.to_list(),"\n",df.fpath.to_list())
 def list_func(lib_name, opt="call"):
     if opt == "call":
         funcs = [func for func in dir(lib_name) if callable(getattr(lib_name, func))]
     else:
         funcs = dir(lib_name)
     return funcs
+
+
 def func_list(lib_name, opt="call"):
     return list_func(lib_name, opt=opt)
 
+
 def mkdir(*args, **kwargs):
     """
     newfolder(pardir, chdir)
@@ -1503,17 +1695,17 @@ def mkdir(*args, **kwargs):
     Returns:
         mkdir, giving a option if exists_ok or not
     """
-    overwrite=kwargs.get("overwrite",False)
+    overwrite = kwargs.get("overwrite", False)
     for arg in args:
-        if isinstance(arg, (str,list)):
+        if isinstance(arg, (str, list)):
             if "/" in arg or "\\" in arg:
-                pardir=arg
-                print(f'pardir{pardir}')
+                pardir = arg
+                print(f"pardir{pardir}")
             else:
                 chdir = arg
-                print(f'chdir{chdir}')
-        elif isinstance(arg,bool):
-            overwrite=arg
+                print(f"chdir{chdir}")
+        elif isinstance(arg, bool):
+            overwrite = arg
             print(overwrite)
         else:
             print(f"{arg}Error: not support a {type(arg)} type")
@@ -1526,7 +1718,7 @@ def mkdir(*args, **kwargs):
     if isinstance(pardir, str):  # Dir_parents should be 'str' type
         pardir = os.path.normpath(pardir)
     # Get the slash type: "/" or "\"
-    stype = '/' if '/' in pardir else '\\'
+    stype = "/" if "/" in pardir else "\\"
     # Check if the parent directory exists and is a directory path
     if os.path.isdir(pardir):
         os.chdir(pardir)  # Set current path
@@ -1538,80 +1730,83 @@ def mkdir(*args, **kwargs):
                 # Check if the subfolder already exists
                 child_tmp = os.path.join(pardir, folder)
                 if not os.path.isdir(child_tmp):
-                    os.mkdir('./' + folder)
-                    print(f'\n {folder} was created successfully!\n')
+                    os.mkdir("./" + folder)
+                    print(f"\n {folder} was created successfully!\n")
                 else:
                     if overwrite:
                         shutil.rmtree(child_tmp)
-                        os.mkdir('./' + folder)
-                        print(f'\n {folder} overwrite! \n')
+                        os.mkdir("./" + folder)
+                        print(f"\n {folder} overwrite! \n")
                     else:
-                        print(f'\n {folder} already exists! \n')
+                        print(f"\n {folder} already exists! \n")
                 rootdir.append(child_tmp + stype)  # Note down
         else:
-            print('\nWarning: Dir_child doesn\'t exist\n')
+            print("\nWarning: Dir_child doesn't exist\n")
     else:
-        print('\nWarning: Dir_parent is not a directory path\n')
+        print("\nWarning: Dir_parent is not a directory path\n")
     # Dir is the main output, if only one dir, then str type is inconvenient
     if len(rootdir) == 1:
         rootdir = rootdir[0]
     return rootdir
 
-def figsave(*args,dpi=300):
+
+def figsave(*args, dpi=300):
     dir_save = None
-    fname = None 
+    fname = None
     for arg in args:
         if isinstance(arg, str):
-            if '/' in arg or '\\' in arg:
+            if "/" in arg or "\\" in arg:
                 dir_save = arg
-            elif '/' not in arg and '\\' not in arg:
+            elif "/" not in arg and "\\" not in arg:
                 fname = arg
     # Backup original values
-    if '/' in dir_save:
-        if dir_save[-1] != '/':
-            dir_save = dir_save + '/'
-    elif '\\' in dir_save:
-        if dir_save[-1] != '\\':
-            dir_save = dir_save + '\\'
+    if "/" in dir_save:
+        if dir_save[-1] != "/":
+            dir_save = dir_save + "/"
+    elif "\\" in dir_save:
+        if dir_save[-1] != "\\":
+            dir_save = dir_save + "\\"
     else:
-        raise ValueError('Check the Path of dir_save Directory')
-    ftype = fname.split('.')[-1]
-    if len(fname.split('.')) == 1:
-        ftype = 'nofmt'
-        fname = dir_save + fname + '.' + ftype
+        raise ValueError("Check the Path of dir_save Directory")
+    ftype = fname.split(".")[-1]
+    if len(fname.split(".")) == 1:
+        ftype = "nofmt"
+        fname = dir_save + fname + "." + ftype
     else:
         fname = dir_save + fname
     # Save figure based on file type
-    if ftype.lower() == 'eps':
-        plt.savefig(fname, format='eps', bbox_inches='tight')
-        plt.savefig(fname.replace('.eps', '.pdf'),
-                    format='pdf', bbox_inches='tight',dpi=dpi)
-    elif ftype.lower() == 'nofmt': # default: both "tif" and "pdf"
-        fname_corr=fname.replace('nofmt','pdf')
-        plt.savefig(fname_corr, format='pdf', bbox_inches='tight',dpi=dpi)
-        fname=fname.replace('nofmt','tif')
-        plt.savefig(fname, format='tiff', dpi=dpi, bbox_inches='tight')
+    if ftype.lower() == "eps":
+        plt.savefig(fname, format="eps", bbox_inches="tight")
+        plt.savefig(
+            fname.replace(".eps", ".pdf"), format="pdf", bbox_inches="tight", dpi=dpi
+        )
+    elif ftype.lower() == "nofmt":  # default: both "tif" and "pdf"
+        fname_corr = fname.replace("nofmt", "pdf")
+        plt.savefig(fname_corr, format="pdf", bbox_inches="tight", dpi=dpi)
+        fname = fname.replace("nofmt", "tif")
+        plt.savefig(fname, format="tiff", dpi=dpi, bbox_inches="tight")
         print(f"default saving filetype: both 'tif' and 'pdf")
-    elif ftype.lower() == 'pdf':
-        plt.savefig(fname, format='pdf', bbox_inches='tight',dpi=dpi)
-    elif ftype.lower() in ['jpg', 'jpeg']:
-        plt.savefig(fname, format='jpeg', dpi=dpi, bbox_inches='tight')
-    elif ftype.lower() == 'png':
-        plt.savefig(fname, format='png', dpi=dpi,
-                    bbox_inches='tight', transparent=True)
-    elif ftype.lower() in ['tiff', 'tif']:
-        plt.savefig(fname, format='tiff', dpi=dpi, bbox_inches='tight')
-    elif ftype.lower() == 'emf':
-        plt.savefig(fname, format='emf', dpi=dpi, bbox_inches='tight')
-    elif ftype.lower() == 'fig':
-        plt.savefig(fname, format='pdf', bbox_inches='tight',dpi=dpi)
-    print(f'\nSaved @: dpi={dpi}\n{fname}')
+    elif ftype.lower() == "pdf":
+        plt.savefig(fname, format="pdf", bbox_inches="tight", dpi=dpi)
+    elif ftype.lower() in ["jpg", "jpeg"]:
+        plt.savefig(fname, format="jpeg", dpi=dpi, bbox_inches="tight")
+    elif ftype.lower() == "png":
+        plt.savefig(fname, format="png", dpi=dpi, bbox_inches="tight", transparent=True)
+    elif ftype.lower() in ["tiff", "tif"]:
+        plt.savefig(fname, format="tiff", dpi=dpi, bbox_inches="tight")
+    elif ftype.lower() == "emf":
+        plt.savefig(fname, format="emf", dpi=dpi, bbox_inches="tight")
+    elif ftype.lower() == "fig":
+        plt.savefig(fname, format="pdf", bbox_inches="tight", dpi=dpi)
+    print(f"\nSaved @: dpi={dpi}\n{fname}")
 
 
 def is_str_color(s):
     # Regular expression pattern for hexadecimal color codes
     color_code_pattern = r"^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$"
     return re.match(color_code_pattern, s) is not None
+
+
 def is_num(s):
     """
     Check if a string can be converted to a number (int or float).
@@ -1625,58 +1820,72 @@ def is_num(s):
         return True
     except ValueError:
         return False
+
+
 def isnum(s):
     return is_num(s)
+
+
 def is_image(fpath):
     mime_type, _ = mimetypes.guess_type(fpath)
-    if mime_type and mime_type.startswith('image'):
+    if mime_type and mime_type.startswith("image"):
         return True
     else:
         return False
+
+
 def is_document(fpath):
     mime_type, _ = mimetypes.guess_type(fpath)
     if mime_type and (
-        mime_type.startswith('text/') or
-        mime_type == 'application/pdf' or
-        mime_type == 'application/msword' or
-        mime_type == 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' or
-        mime_type == 'application/vnd.ms-excel' or
-        mime_type == 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' or
-        mime_type == 'application/vnd.ms-powerpoint' or
-        mime_type == 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
+        mime_type.startswith("text/")
+        or mime_type == "application/pdf"
+        or mime_type == "application/msword"
+        or mime_type
+        == "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+        or mime_type == "application/vnd.ms-excel"
+        or mime_type
+        == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        or mime_type == "application/vnd.ms-powerpoint"
+        or mime_type
+        == "application/vnd.openxmlformats-officedocument.presentationml.presentation"
     ):
         return True
     else:
         return False
+
+
 def is_zip(fpath):
     mime_type, _ = mimetypes.guess_type(fpath)
-    if mime_type == 'application/zip':
+    if mime_type == "application/zip":
         return True
     else:
         return False
 
 
-def adjust_spines(ax=None, spines=['left', 'bottom'],distance=2):
+def adjust_spines(ax=None, spines=["left", "bottom"], distance=2):
     if ax is None:
         ax = plt.gca()
     for loc, spine in ax.spines.items():
         if loc in spines:
-            spine.set_position(('outward', distance))  # outward by 2 points
+            spine.set_position(("outward", distance))  # outward by 2 points
             # spine.set_smart_bounds(True)
         else:
-            spine.set_color('none')  # don't draw spine
+            spine.set_color("none")  # don't draw spine
     # turn off ticks where there is no spine
-    if 'left' in spines:
-        ax.yaxis.set_ticks_position('left')
+    if "left" in spines:
+        ax.yaxis.set_ticks_position("left")
     else:
         ax.yaxis.set_ticks([])
-    if 'bottom' in spines:
-        ax.xaxis.set_ticks_position('bottom')
+    if "bottom" in spines:
+        ax.xaxis.set_ticks_position("bottom")
     else:
         # no xaxis ticks
         ax.xaxis.set_ticks([])
+
+
 # And then plot the data:
 
+
 def add_colorbar(im, width=None, pad=None, **kwargs):
     # usage: add_colorbar(im, width=0.01, pad=0.005, label="PSD (dB)", shrink=0.8)
     l, b, w, h = im.axes.get_position().bounds  # get boundaries
@@ -1685,6 +1894,8 @@ def add_colorbar(im, width=None, pad=None, **kwargs):
     fig = im.axes.figure  # get figure of image
     cax = fig.add_axes([l + w + pad, b, width, h])  # define cbar Axes
     return fig.colorbar(im, cax=cax, **kwargs)  # draw cbar
+
+
 # =============================================================================
 # # for plot figures: setting rcParams
 # usage: set_pub()
@@ -1697,13 +1908,16 @@ def add_colorbar(im, width=None, pad=None, **kwargs):
 
 
 def list2str(x_str):
-    s = ''.join(str(x) for x in x_str)
+    s = "".join(str(x) for x in x_str)
     return s
+
+
 def str2list(str_):
     l = []
     [l.append(x) for x in str_]
     return l
 
+
 def load_img(fpath):
     """
     Load an image from the specified file path.
@@ -1723,6 +1937,7 @@ def load_img(fpath):
     except OSError:
         raise OSError(f"Unable to open file '{fpath}' or it is not a valid image file.")
 
+
 def apply_filter(img, *args):
     # def apply_filter(img, filter_name, filter_value=None):
     """
@@ -1734,42 +1949,47 @@ def apply_filter(img, *args):
     Returns:
         PIL.Image: The filtered image.
     """
+
     def correct_filter_name(filter_name):
-        if 'bl' in filter_name.lower() and 'box' not in filter_name.lower():
-            return 'BLUR'
-        elif 'cont' in  filter_name.lower():
-            return 'Contour'
-        elif 'det' in  filter_name.lower():
-            return 'Detail'
-        elif 'edg' in  filter_name.lower() and 'mo' not in filter_name.lower() and 'f' not in filter_name.lower():
-            return 'EDGE_ENHANCE'
-        elif 'edg' in  filter_name.lower() and 'mo' in filter_name.lower():
-            return 'EDGE_ENHANCE_MORE'
-        elif 'emb' in  filter_name.lower():
-            return 'EMBOSS'
-        elif 'edg' in  filter_name.lower() and 'f' in filter_name.lower():
-            return 'FIND_EDGES'
-        elif 'sh' in  filter_name.lower() and 'mo' not in filter_name.lower():
-            return 'SHARPEN'
-        elif 'sm' in  filter_name.lower() and 'mo' not in filter_name.lower():
-            return 'SMOOTH'
-        elif 'sm' in  filter_name.lower() and 'mo' in filter_name.lower():
-            return 'SMOOTH_MORE'
-        elif 'min' in  filter_name.lower():
-            return 'MIN_FILTER'
-        elif 'max' in  filter_name.lower():
-            return 'MAX_FILTER'
-        elif 'mod' in  filter_name.lower():
-            return 'MODE_FILTER'
-        elif 'mul' in  filter_name.lower():
-            return 'MULTIBAND_FILTER'
-        elif 'gau' in  filter_name.lower():
-            return 'GAUSSIAN_BLUR'
-        elif 'box' in  filter_name.lower():
-            return 'BOX_BLUR'
-        elif 'med' in  filter_name.lower():
-            return 'MEDIAN_FILTER'
-        else: 
+        if "bl" in filter_name.lower() and "box" not in filter_name.lower():
+            return "BLUR"
+        elif "cont" in filter_name.lower():
+            return "Contour"
+        elif "det" in filter_name.lower():
+            return "Detail"
+        elif (
+            "edg" in filter_name.lower()
+            and "mo" not in filter_name.lower()
+            and "f" not in filter_name.lower()
+        ):
+            return "EDGE_ENHANCE"
+        elif "edg" in filter_name.lower() and "mo" in filter_name.lower():
+            return "EDGE_ENHANCE_MORE"
+        elif "emb" in filter_name.lower():
+            return "EMBOSS"
+        elif "edg" in filter_name.lower() and "f" in filter_name.lower():
+            return "FIND_EDGES"
+        elif "sh" in filter_name.lower() and "mo" not in filter_name.lower():
+            return "SHARPEN"
+        elif "sm" in filter_name.lower() and "mo" not in filter_name.lower():
+            return "SMOOTH"
+        elif "sm" in filter_name.lower() and "mo" in filter_name.lower():
+            return "SMOOTH_MORE"
+        elif "min" in filter_name.lower():
+            return "MIN_FILTER"
+        elif "max" in filter_name.lower():
+            return "MAX_FILTER"
+        elif "mod" in filter_name.lower():
+            return "MODE_FILTER"
+        elif "mul" in filter_name.lower():
+            return "MULTIBAND_FILTER"
+        elif "gau" in filter_name.lower():
+            return "GAUSSIAN_BLUR"
+        elif "box" in filter_name.lower():
+            return "BOX_BLUR"
+        elif "med" in filter_name.lower():
+            return "MEDIAN_FILTER"
+        else:
             supported_filters = [
                 "BLUR",
                 "CONTOUR",
@@ -1843,21 +2063,232 @@ def apply_filter(img, *args):
         return img.filter(supported_filters[filter_name](bands))
     else:
         if filter_value is not None:
-            print(f"{filter_name} doesn't require a value for {filter_value}, but it remains unaffected")
+            print(
+                f"{filter_name} doesn't require a value for {filter_value}, but it remains unaffected"
+            )
         return img.filter(supported_filters[filter_name])
 
 
-def imgsets(
-    img,
-    sets=None,
-    show=True,
-    show_axis=False,
-    size=None,
-    dpi=100,
-    figsize=None,
-    auto=False,
-    filter_kws=None,
-):
+# def imgsetss(
+#     img,
+#     sets=None,
+#     show=True,
+#     show_axis=False,
+#     size=None,
+#     dpi=100,
+#     figsize=None,
+#     auto=False,
+#     filter_kws=None,
+# ):
+#     """
+#     Apply various enhancements and filters to an image using PIL's ImageEnhance and ImageFilter modules.
+
+#     Args:
+#         img (PIL.Image): The input image.
+#         sets (dict): A dictionary specifying the enhancements, filters, and their parameters.
+#         show (bool): Whether to display the enhanced image.
+#         show_axis (bool): Whether to display axes on the image plot.
+#         size (tuple): The size of the thumbnail, cover, contain, or fit operation.
+#         dpi (int): Dots per inch for the displayed image.
+#         figsize (tuple): The size of the figure for displaying the image.
+#         auto (bool): Whether to automatically enhance the image based on its characteristics.
+
+#     Returns:
+#         PIL.Image: The enhanced image.
+
+#     Supported enhancements and filters:
+#         - "sharpness": Adjusts the sharpness of the image. Values > 1 increase sharpness, while values < 1 decrease sharpness.
+#         - "contrast": Adjusts the contrast of the image. Values > 1 increase contrast, while values < 1 decrease contrast.
+#         - "brightness": Adjusts the brightness of the image. Values > 1 increase brightness, while values < 1 decrease brightness.
+#         - "color": Adjusts the color saturation of the image. Values > 1 increase saturation, while values < 1 decrease saturation.
+#         - "rotate": Rotates the image by the specified angle.
+#         - "crop" or "cut": Crops the image. The value should be a tuple specifying the crop box as (left, upper, right, lower).
+#         - "size": Resizes the image to the specified dimensions.
+#         - "thumbnail": Resizes the image to fit within the given size while preserving aspect ratio.
+#         - "cover": Resizes and crops the image to fill the specified size.
+#         - "contain": Resizes the image to fit within the specified size, adding borders if necessary.
+#         - "fit": Resizes and pads the image to fit within the specified size.
+#         - "filter": Applies various filters to the image (e.g., BLUR, CONTOUR, EDGE_ENHANCE).
+
+#     Note:
+#         The "color" and "enhance" enhancements are not implemented in this function.
+#     """
+#     supported_filters = [
+#                 "BLUR",
+#                 "CONTOUR",
+#                 "DETAIL",
+#                 "EDGE_ENHANCE",
+#                 "EDGE_ENHANCE_MORE",
+#                 "EMBOSS",
+#                 "FIND_EDGES",
+#                 "SHARPEN",
+#                 "SMOOTH",
+#                 "SMOOTH_MORE",
+#                 "MIN_FILTER",
+#                 "MAX_FILTER",
+#                 "MODE_FILTER",
+#                 "MULTIBAND_FILTER",
+#                 "GAUSSIAN_BLUR",
+#                 "BOX_BLUR",
+#                 "MEDIAN_FILTER",
+#             ]
+#     print("sets: a dict,'sharp:1.2','color','contrast:'auto' or 1.2','bright', 'crop: x_upperleft,y_upperleft, x_lowerright, y_lowerright','rotation','resize','rem or background'")
+#     print(f"usage: filter_kws 'dict' below:")
+#     pp([str(i).lower() for i in supported_filters])
+#     print("\nlog:\n")
+#     def confirm_rembg_models(model_name):
+#         models_support = [
+#             "u2net",
+#             "u2netp",
+#             "u2net_human_seg",
+#             "u2net_cloth_seg",
+#             "silueta",
+#             "isnet-general-use",
+#             "isnet-anime",
+#             "sam",
+#         ]
+#         if model_name in models_support:
+#             print(f"model_name: {model_name}")
+#             return model_name
+#         else:
+#             print(f"{model_name} cannot be found, check the name:{models_support}, default('isnet-general-use') has been used")
+#             return "isnet-general-use"
+#     def auto_enhance(img):
+#         """
+#         Automatically enhances the image based on its characteristics.
+#         Args:
+#             img (PIL.Image): The input image.
+#         Returns:
+#             dict: A dictionary containing the optimal enhancement values.
+#         """
+#         # Determine the bit depth based on the image mode
+#         if img.mode in ["1", "L", "P", "RGB", "YCbCr", "LAB", "HSV"]:
+#             # 8-bit depth per channel
+#             bit_depth = 8
+#         elif img.mode in ["RGBA", "CMYK"]:
+#             # 8-bit depth per channel + alpha (RGBA) or additional channels (CMYK)
+#             bit_depth = 8
+#         elif img.mode in ["I", "F"]:
+#             # 16-bit depth per channel (integer or floating-point)
+#             bit_depth = 16
+#         else:
+#             raise ValueError("Unsupported image mode")
+#         # Calculate the brightness and contrast for each channel
+#         num_channels = len(img.getbands())
+#         brightness_factors = []
+#         contrast_factors = []
+#         for channel in range(num_channels):
+#             channel_histogram = img.split()[channel].histogram()
+#             brightness = sum(i * w for i, w in enumerate(channel_histogram))/sum(channel_histogram)
+#             channel_min, channel_max = img.split()[channel].getextrema()
+#             contrast = channel_max - channel_min
+#             # Adjust calculations based on bit depth
+#             normalization_factor = 2**bit_depth - 1  # Max value for the given bit depth
+#             brightness_factor = (1.0 + (brightness - normalization_factor / 2) / normalization_factor)
+#             contrast_factor = (1.0 + (contrast - normalization_factor / 2) / normalization_factor)
+#             brightness_factors.append(brightness_factor)
+#             contrast_factors.append(contrast_factor)
+#         # Calculate the average brightness and contrast factors across channels
+#         avg_brightness_factor = sum(brightness_factors) / num_channels
+#         avg_contrast_factor = sum(contrast_factors) / num_channels
+#         return {"brightness": avg_brightness_factor, "contrast": avg_contrast_factor}
+#     # Load image if input is a file path
+#     if isinstance(img, str):
+#         img = load_img(img)
+#     img_update = img.copy()
+#     # Auto-enhance image if requested
+#     if auto:
+#         auto_params = auto_enhance(img_update)
+#         sets.update(auto_params)
+#     if sets is None:
+#         sets = {}
+#     for k, value in sets.items():
+#         if "shar" in k.lower():
+#             enhancer = ImageEnhance.Sharpness(img_update)
+#             img_update = enhancer.enhance(value)
+#         elif "col" in k.lower() and 'bg' not in k.lower():
+#             enhancer = ImageEnhance.Color(img_update)
+#             img_update = enhancer.enhance(value)
+#         elif "contr" in k.lower():
+#             if value and isinstance(value,(float,int)):
+#                 enhancer = ImageEnhance.Contrast(img_update)
+#                 img_update = enhancer.enhance(value)
+#             else:
+#                 print('autocontrasted')
+#                 img_update = ImageOps.autocontrast(img_update)
+#         elif "bri" in k.lower():
+#             enhancer = ImageEnhance.Brightness(img_update)
+#             img_update = enhancer.enhance(value)
+#         elif "cro" in k.lower() or "cut" in k.lower():
+#             img_update=img_update.crop(value)
+#         elif "rota" in k.lower():
+#             img_update = img_update.rotate(value)
+#         elif "si" in k.lower():
+#             img_update = img_update.resize(value)
+#         elif "thum" in k.lower():
+#             img_update.thumbnail(value)
+#         elif "cover" in k.lower():
+#             img_update = ImageOps.cover(img_update, size=value)
+#         elif "contain" in k.lower():
+#             img_update = ImageOps.contain(img_update, size=value)
+#         elif "fit" in k.lower():
+#             img_update = ImageOps.fit(img_update, size=value)
+#         elif "pad" in k.lower():
+#             img_update = ImageOps.pad(img_update, size=value)
+#         elif 'rem' in k.lower() or 'rm' in k.lower() or 'back' in k.lower():
+#             if value and isinstance(value,(int,float,list)):
+#                 print('example usage: {"rm":[alpha_matting_background_threshold(20),alpha_matting_foreground_threshold(270),alpha_matting_erode_sive(11)]}')
+#                 print("https://github.com/danielgatis/rembg/blob/main/USAGE.md")
+#                 #     ###            Parameters:
+#                 #         data (Union[bytes, PILImage, np.ndarray]): The input image data.
+#                 #         alpha_matting (bool, optional): Flag indicating whether to use alpha matting. Defaults to False.
+#                 #         alpha_matting_foreground_threshold (int, optional): Foreground threshold for alpha matting. Defaults to 240.
+#                 #         alpha_matting_background_threshold (int, optional): Background threshold for alpha matting. Defaults to 10.
+#                 #         alpha_matting_erode_size (int, optional): Erosion size for alpha matting. Defaults to 10.
+#                 #         session (Optional[BaseSession], optional): A session object for the 'u2net' model. Defaults to None.
+#                 #         only_mask (bool, optional): Flag indicating whether to return only the binary masks. Defaults to False.
+#                 #         post_process_mask (bool, optional): Flag indicating whether to post-process the masks. Defaults to False.
+#                 #         bgcolor (Optional[Tuple[int, int, int, int]], optional): Background color for the cutout image. Defaults to None.
+#                 #  ###
+#                 if isinstance(value,int):
+#                     value=[value]
+#                 if len(value) <2:
+#                     img_update = remove(img_update,alpha_matting=True,alpha_matting_background_threshold=value)
+#                 elif 2<=len(value)<3:
+#                     img_update = remove(img_update,alpha_matting=True,alpha_matting_background_threshold=value[0],alpha_matting_foreground_threshold=value[1])
+#                 elif 3<=len(value)<4:
+#                     img_update = remove(img_update,alpha_matting=True,alpha_matting_background_threshold=value[0],alpha_matting_foreground_threshold=value[1],alpha_matting_erode_size=value[2])
+#             if isinstance(value,tuple): # replace the background color
+#                 if len(value)==3:
+#                     value+=(255,)
+#                 img_update = remove(img_update, bgcolor=value)
+#             if isinstance(value,str):
+#                 if confirm_rembg_models(value):
+#                     img_update=remove(img_update,session=new_session(value))
+#                 else:
+#                     img_update=remove(img_update)
+#         elif 'bgcolor' in k.lower():
+#             if isinstance(value,list):
+#                 value=tuple(value)
+#             if isinstance(value,tuple): # replace the background color
+#                 if len(value)==3:
+#                     value+=(255,)
+#                 img_update = remove(img_update, bgcolor=value)
+#     if filter_kws:
+#         for filter_name, filter_value in filter_kws.items():
+#             img_update = apply_filter(img_update, filter_name, filter_value)
+#     # Display the image if requested
+#     if show:
+#         if figsize is None:
+#             plt.figure(dpi=dpi)
+#         else:
+#             plt.figure(figsize=figsize, dpi=dpi)
+#         plt.imshow(img_update)
+#         plt.axis("on") if show_axis else plt.axis("off")
+#     return img_update
+
+
+def imgsets(img, **kwargs):
     """
     Apply various enhancements and filters to an image using PIL's ImageEnhance and ImageFilter modules.
 
@@ -1892,28 +2323,27 @@ def imgsets(
         The "color" and "enhance" enhancements are not implemented in this function.
     """
     supported_filters = [
-                "BLUR",
-                "CONTOUR",
-                "DETAIL",
-                "EDGE_ENHANCE",
-                "EDGE_ENHANCE_MORE",
-                "EMBOSS",
-                "FIND_EDGES",
-                "SHARPEN",
-                "SMOOTH",
-                "SMOOTH_MORE",
-                "MIN_FILTER",
-                "MAX_FILTER",
-                "MODE_FILTER",
-                "MULTIBAND_FILTER",
-                "GAUSSIAN_BLUR",
-                "BOX_BLUR",
-                "MEDIAN_FILTER",
-            ]
-    print("sets: a dict,'sharp:1.2','color','contrast:'auto' or 1.2','bright', 'crop: x_upperleft,y_upperleft, x_lowerright, y_lowerright','rotation','resize','rem or background'")
-    print(f"usage: filter_kws 'dict' below:")
-    pp([str(i).lower() for i in supported_filters])
+        "BLUR",
+        "CONTOUR",
+        "DETAIL",
+        "EDGE_ENHANCE",
+        "EDGE_ENHANCE_MORE",
+        "EMBOSS",
+        "FIND_EDGES",
+        "SHARPEN",
+        "SMOOTH",
+        "SMOOTH_MORE",
+        "MIN_FILTER",
+        "MAX_FILTER",
+        "MODE_FILTER",
+        "MULTIBAND_FILTER",
+        "GAUSSIAN_BLUR",
+        "BOX_BLUR",
+        "MEDIAN_FILTER",
+    ]
+    print('usage: imgsets(dir_img, contrast="auto", rm=True, color=2.2)')
     print("\nlog:\n")
+
     def confirm_rembg_models(model_name):
         models_support = [
             "u2net",
@@ -1929,8 +2359,11 @@ def imgsets(
             print(f"model_name: {model_name}")
             return model_name
         else:
-            print(f"{model_name} cannot be found, check the name:{models_support}, default('isnet-general-use') has been used")
+            print(
+                f"{model_name} cannot be found, check the name:{models_support}, default('isnet-general-use') has been used"
+            )
             return "isnet-general-use"
+
     def auto_enhance(img):
         """
         Automatically enhances the image based on its characteristics.
@@ -1957,48 +2390,61 @@ def imgsets(
         contrast_factors = []
         for channel in range(num_channels):
             channel_histogram = img.split()[channel].histogram()
-            brightness = sum(i * w for i, w in enumerate(channel_histogram))/sum(channel_histogram)
+            brightness = sum(i * w for i, w in enumerate(channel_histogram)) / sum(
+                channel_histogram
+            )
             channel_min, channel_max = img.split()[channel].getextrema()
             contrast = channel_max - channel_min
             # Adjust calculations based on bit depth
             normalization_factor = 2**bit_depth - 1  # Max value for the given bit depth
-            brightness_factor = (1.0 + (brightness - normalization_factor / 2) / normalization_factor)
-            contrast_factor = (1.0 + (contrast - normalization_factor / 2) / normalization_factor)
+            brightness_factor = (
+                1.0 + (brightness - normalization_factor / 2) / normalization_factor
+            )
+            contrast_factor = (
+                1.0 + (contrast - normalization_factor / 2) / normalization_factor
+            )
             brightness_factors.append(brightness_factor)
             contrast_factors.append(contrast_factor)
         # Calculate the average brightness and contrast factors across channels
         avg_brightness_factor = sum(brightness_factors) / num_channels
         avg_contrast_factor = sum(contrast_factors) / num_channels
         return {"brightness": avg_brightness_factor, "contrast": avg_contrast_factor}
+
     # Load image if input is a file path
     if isinstance(img, str):
         img = load_img(img)
     img_update = img.copy()
     # Auto-enhance image if requested
+
+    auto = kwargs.get("auto", False)
+    show = kwargs.get("show", True)
+    show_axis = kwargs.get("show_axis", False)
+    size = kwargs.get("size", None)
+    figsize = kwargs.get("figsize", None)
+    dpi = kwargs.get("dpi", 100)
+
     if auto:
-        auto_params = auto_enhance(img_update)
-        sets.update(auto_params)
-    if sets is None:
-        sets = {}
-    for k, value in sets.items():
+        kwargs = {**auto_enhance(img_update), **kwargs}
+
+    for k, value in kwargs.items():
         if "shar" in k.lower():
             enhancer = ImageEnhance.Sharpness(img_update)
             img_update = enhancer.enhance(value)
-        elif "col" in k.lower() and 'bg' not in k.lower():
+        elif "col" in k.lower() and "bg" not in k.lower():
             enhancer = ImageEnhance.Color(img_update)
             img_update = enhancer.enhance(value)
         elif "contr" in k.lower():
-            if value and isinstance(value,(float,int)):
+            if value and isinstance(value, (float, int)):
                 enhancer = ImageEnhance.Contrast(img_update)
                 img_update = enhancer.enhance(value)
             else:
-                print('autocontrasted')
+                print("autocontrasted")
                 img_update = ImageOps.autocontrast(img_update)
         elif "bri" in k.lower():
             enhancer = ImageEnhance.Brightness(img_update)
             img_update = enhancer.enhance(value)
         elif "cro" in k.lower() or "cut" in k.lower():
-            img_update=img_update.crop(value)
+            img_update = img_update.crop(value)
         elif "rota" in k.lower():
             img_update = img_update.rotate(value)
         elif "si" in k.lower():
@@ -2010,12 +2456,21 @@ def imgsets(
         elif "contain" in k.lower():
             img_update = ImageOps.contain(img_update, size=value)
         elif "fit" in k.lower():
-            img_update = ImageOps.fit(img_update, size=value)
+            if isinstance(value, dict):
+                for filter_name, filter_value in value.items():
+                    img_update = apply_filter(img_update, filter_name, filter_value)
+            else:
+                img_update = ImageOps.fit(img_update, size=value)
         elif "pad" in k.lower():
             img_update = ImageOps.pad(img_update, size=value)
-        elif 'rem' in k.lower() or 'rm' in k.lower() or 'back' in k.lower():
-            if value and isinstance(value,(int,float,list)):
-                print('example usage: {"rm":[alpha_matting_background_threshold(20),alpha_matting_foreground_threshold(270),alpha_matting_erode_sive(11)]}')
+        elif "rem" in k.lower() or "rm" in k.lower() or "back" in k.lower():
+            if isinstance(value, bool):
+                session = new_session("isnet-general-use")
+                img_update = remove(img_update, session=session)
+            elif value and isinstance(value, (int, float, list)):
+                print(
+                    'example usage: {"rm":[alpha_matting_background_threshold(20),alpha_matting_foreground_threshold(270),alpha_matting_erode_sive(11)]}'
+                )
                 print("https://github.com/danielgatis/rembg/blob/main/USAGE.md")
                 #     ###            Parameters:
                 #         data (Union[bytes, PILImage, np.ndarray]): The input image data.
@@ -2028,33 +2483,45 @@ def imgsets(
                 #         post_process_mask (bool, optional): Flag indicating whether to post-process the masks. Defaults to False.
                 #         bgcolor (Optional[Tuple[int, int, int, int]], optional): Background color for the cutout image. Defaults to None.
                 #  ###
-                if isinstance(value,int):
-                    value=[value]
-                if len(value) <2:
-                    img_update = remove(img_update,alpha_matting=True,alpha_matting_background_threshold=value)
-                elif 2<=len(value)<3:
-                    img_update = remove(img_update,alpha_matting=True,alpha_matting_background_threshold=value[0],alpha_matting_foreground_threshold=value[1])
-                elif 3<=len(value)<4:
-                    img_update = remove(img_update,alpha_matting=True,alpha_matting_background_threshold=value[0],alpha_matting_foreground_threshold=value[1],alpha_matting_erode_size=value[2])
-            if isinstance(value,tuple): # replace the background color
-                if len(value)==3:
-                    value+=(255,)
+                if isinstance(value, int):
+                    value = [value]
+                if len(value) < 2:
+                    img_update = remove(
+                        img_update,
+                        alpha_matting=True,
+                        alpha_matting_background_threshold=value,
+                    )
+                elif 2 <= len(value) < 3:
+                    img_update = remove(
+                        img_update,
+                        alpha_matting=True,
+                        alpha_matting_background_threshold=value[0],
+                        alpha_matting_foreground_threshold=value[1],
+                    )
+                elif 3 <= len(value) < 4:
+                    img_update = remove(
+                        img_update,
+                        alpha_matting=True,
+                        alpha_matting_background_threshold=value[0],
+                        alpha_matting_foreground_threshold=value[1],
+                        alpha_matting_erode_size=value[2],
+                    )
+            elif isinstance(value, tuple):  # replace the background color
+                if len(value) == 3:
+                    value += (255,)
                 img_update = remove(img_update, bgcolor=value)
-            if isinstance(value,str):
+            elif isinstance(value, str):
                 if confirm_rembg_models(value):
-                    img_update=remove(img_update,session=new_session(value))
+                    img_update = remove(img_update, session=new_session(value))
                 else:
-                    img_update=remove(img_update)
-        elif 'bgcolor' in k.lower():
-            if isinstance(value,list):
-                value=tuple(value)
-            if isinstance(value,tuple): # replace the background color
-                if len(value)==3:
-                    value+=(255,)
+                    img_update = remove(img_update)
+        elif "bg" in k.lower() and "color" in k.lower():
+            if isinstance(value, list):
+                value = tuple(value)
+            if isinstance(value, tuple):  # replace the background color
+                if len(value) == 3:
+                    value += (255,)
                 img_update = remove(img_update, bgcolor=value)
-    if filter_kws:
-        for filter_name, filter_value in filter_kws.items():
-            img_update = apply_filter(img_update, filter_name, filter_value)
     # Display the image if requested
     if show:
         if figsize is None:
@@ -2062,8 +2529,18 @@ def imgsets(
         else:
             plt.figure(figsize=figsize, dpi=dpi)
         plt.imshow(img_update)
-        plt.axis("on") if show_axis else plt.axis("off")
+        if show_axis:
+            plt.axis("on")  # Turn on axis
+            plt.minorticks_on()
+            plt.grid(
+                which="both", linestyle="--", linewidth=0.5, color="gray", alpha=0.7
+            )
+
+        else:
+            plt.axis("off")  # Turn off axis
     return img_update
+
+
 # # usage:
 # img = imgsets(
 #     fpath,
@@ -2074,26 +2551,26 @@ def imgsets(
 # )
 
 
-def thumbnail(dir_img_list,figsize=(10,10),dpi=100, dir_save=None, kind='.png'):
+def thumbnail(dir_img_list, figsize=(10, 10), dpi=100, dir_save=None, kind=".png"):
     """
     Display a thumbnail figure of all images in the specified directory.
     Args:
         dir_img_list (list): List of the Directory containing the images.
     """
     num_images = len(dir_img_list)
-    if not kind.startswith('.'):
-        kind='.'+kind
+    if not kind.startswith("."):
+        kind = "." + kind
 
     if num_images == 0:
         print("No images found to display.")
         return
-    grid_size = int(num_images ** 0.5) + 1 # Determine grid size
-    fig, axs = plt.subplots(grid_size, grid_size, figsize=figsize,dpi=dpi)
+    grid_size = int(num_images**0.5) + 1  # Determine grid size
+    fig, axs = plt.subplots(grid_size, grid_size, figsize=figsize, dpi=dpi)
     for ax, image_file in zip(axs.flatten(), dir_img_list):
         try:
             img = Image.open(image_file)
             ax.imshow(img)
-            ax.axis('off')
+            ax.axis("off")
         except:
             continue
     # for ax in axs.flatten():
@@ -2104,13 +2581,15 @@ def thumbnail(dir_img_list,figsize=(10,10),dpi=100, dir_save=None, kind='.png'):
         plt.show()
     else:
         if basename(dir_save):
-            fname= basename(dir_save) +kind
+            fname = basename(dir_save) + kind
         else:
-            fname= "_thumbnail_"+basename(dirname(dir_save)[:-1])+'.png'
+            fname = "_thumbnail_" + basename(dirname(dir_save)[:-1]) + ".png"
         if dirname(dir_img_list[0]) == dirname(dir_save):
-            figsave(dirname(dir_save[:-1]),fname)
+            figsave(dirname(dir_save[:-1]), fname)
         else:
-            figsave(dirname(dir_save),fname)
+            figsave(dirname(dir_save), fname)
+
+
 # usage:
 # fpath = "/Users/macjianfeng/Dropbox/github/python/py2ls/tests/xample_netfinder/images/"
 # thumbnail(listdir(fpath,'png').fpath.to_list(),dir_save=dirname(fpath))
@@ -2127,6 +2606,8 @@ def read_mplstyle(style_file):
     for i, j in style_dict.items():
         print(f"\n{i}::::{j}")
     return style_dict
+
+
 # #example usage:
 # style_file = "/ std-colors.mplstyle"
 # style_dict = read_mplstyle(style_file)
@@ -2150,63 +2631,10 @@ def dir_lib(lib_oi):
     else:
         print(f"Cannot find the {lib_oi} in site-packages directory.")
     return dir_list
-# example usage:
-# dir_lib("seaborn") 
-
-
-# set up the colorlist, give the number, or the colormap's name
-def get_color(n=1, cmap="auto", by="start"):
-    # Extract the colormap as a list
-    def cmap2hex(cmap_name):
-        cmap_ = matplotlib.pyplot.get_cmap(cmap_name)
-        colors = [cmap_(i) for i in range(cmap_.N)]
-        return [matplotlib.colors.rgb2hex(color) for color in colors]
-        # usage: clist = cmap2hex("viridis")
-    # cycle times, total number is n (defaultn=10)
-    def cycle2list(colorlist, n=10):
-        cycler_ = cycler(tmp=colorlist)
-        clist = []
-        for i, c_ in zip(range(n), cycler_()):
-            clist.append(c_["tmp"])
-            if i > n:
-                break
-        return clist
-    def hue2rgb(hex_colors):
-        def hex_to_rgb(hex_color):
-            """Converts a hexadecimal color code to RGB values."""
-            if hex_colors.startswith("#"):
-                hex_color = hex_color.lstrip("#")
-            return tuple(int(hex_color[i : i + 2], 16) / 255.0 for i in (0, 2, 4))
-        if isinstance(hex_colors, str):
-            return hex_to_rgb(hex_colors)
-        elif isinstance(hex_colors, (list)):
-            """Converts a list of hexadecimal color codes to a list of RGB values."""
-            rgb_values = [hex_to_rgb(hex_color) for hex_color in hex_colors]
-            return rgb_values
-    if "aut" in cmap:
-        colorlist = [
-            "#474747",
-            "#FF2C00",
-            "#0C5DA5",
-            "#845B97",
-            "#58BBCC",
-            "#FF9500",
-            "#D57DBE",
-        ]
-    else:
-        colorlist = cmap2hex(cmap)
-    if "st" in by.lower() or "be" in by.lower(): 
-        # cycle it
-        clist = cycle2list(colorlist, n=n)
-    if "l" in by.lower() or "p" in by.lower():
-        clist = []
-        [
-            clist.append(colorlist[i])
-            for i in [int(i) for i in np.linspace(0, len(colorlist) - 1, n)]
-        ]
 
-    return clist  # a color list
-    # example usage: clist = get_color(4,cmap="auto", by="start") # get_color(4, cmap="hot", by="linspace")
+
+# example usage:
+# dir_lib("seaborn")
 
 """ 
     # n = 7
@@ -2222,7 +2650,18 @@ def get_color(n=1, cmap="auto", by="start"):
 
 
 class FileInfo:
-    def __init__(self, size, creation_time, ctime, mod_time, mtime, parent_dir, fname, kind, extra_info=None):
+    def __init__(
+        self,
+        size,
+        creation_time,
+        ctime,
+        mod_time,
+        mtime,
+        parent_dir,
+        fname,
+        kind,
+        extra_info=None,
+    ):
         self.size = size
         self.creation_time = creation_time
         self.ctime = ctime
@@ -2237,20 +2676,25 @@ class FileInfo:
         print("to show the res: 'finfo(fpath).show()'")
 
     def __repr__(self):
-        return (f"FileInfo(size={self.size} MB, creation_time='{self.creation_time}', "
-                f"ctime='{self.ctime}', mod_time='{self.mod_time}', mtime='{self.mtime}', "
-                f"parent_dir='{self.parent_dir}', fname='{self.fname}', kind='{self.kind}')")
+        return (
+            f"FileInfo(size={self.size} MB, creation_time='{self.creation_time}', "
+            f"ctime='{self.ctime}', mod_time='{self.mod_time}', mtime='{self.mtime}', "
+            f"parent_dir='{self.parent_dir}', fname='{self.fname}', kind='{self.kind}')"
+        )
 
     def __str__(self):
-        return (f"FileInfo:\n"
-                f"  Size: {self.size} MB\n"
-                f"  Creation Time: {self.creation_time}\n"
-                f"  CTime: {self.ctime}\n"
-                f"  Modification Time: {self.mod_time}\n"
-                f"  MTime: {self.mtime}\n"
-                f"  Parent Directory: {self.parent_dir}\n"
-                f"  File Name: {self.fname}\n"
-                f"  Kind: {self.kind}")
+        return (
+            f"FileInfo:\n"
+            f"  Size: {self.size} MB\n"
+            f"  Creation Time: {self.creation_time}\n"
+            f"  CTime: {self.ctime}\n"
+            f"  Modification Time: {self.mod_time}\n"
+            f"  MTime: {self.mtime}\n"
+            f"  Parent Directory: {self.parent_dir}\n"
+            f"  File Name: {self.fname}\n"
+            f"  Kind: {self.kind}"
+        )
+
     def show(self):
         # Convert the object to a dictionary
         return {
@@ -2262,12 +2706,27 @@ class FileInfo:
             "parent_dir": self.parent_dir,
             "fname": self.fname,
             "kind": self.kind,
-            **{key: getattr(self, key) for key in vars(self) if key not in ["size", "creation_time", "ctime", "mod_time", "mtime", "parent_dir", "fname", "kind"]}
+            **{
+                key: getattr(self, key)
+                for key in vars(self)
+                if key
+                not in [
+                    "size",
+                    "creation_time",
+                    "ctime",
+                    "mod_time",
+                    "mtime",
+                    "parent_dir",
+                    "fname",
+                    "kind",
+                ]
+            },
         }
 
+
 def finfo(fpath):
     fname, fmt = os.path.splitext(fpath)
-    dir_par = os.path.dirname(fpath) + '/'
+    dir_par = os.path.dirname(fpath) + "/"
     data = {
         "size": round(os.path.getsize(fpath) / 1024 / 1024, 3),
         "creation_time": time.ctime(os.path.getctime(fpath)),
@@ -2276,12 +2735,12 @@ def finfo(fpath):
         "mtime": time.ctime(os.path.getmtime(fpath)),
         "parent_dir": dir_par,
         "fname": fname.replace(dir_par, ""),
-        "kind": fmt
+        "kind": fmt,
     }
     extra_info = {}
     if data["kind"] == ".pdf":
         extra_info = pdfinfo_from_path(fpath)
-    
+
     return FileInfo(
         size=data["size"],
         creation_time=data["creation_time"],
@@ -2291,5 +2750,5 @@ def finfo(fpath):
         parent_dir=data["parent_dir"],
         fname=data["fname"],
         kind=data["kind"],
-        extra_info=extra_info
-    )
+        extra_info=extra_info,
+    )