py2ls 0.1.4.7__py3-none-any.whl → 0.1.4.9__py3-none-any.whl

py2ls/ips.py

@@ -1,60 +1,294 @@
 from scipy.ndimage import convolve1d
+from scipy.signal import savgol_filter
+import pingouin as pg
+from scipy import stats
+
 import numpy as np
 import pandas as pd
+
 import json
-import matplotlib.pyplot as plt
-import seaborn as sns
-# import scienceplots
 import matplotlib
-import sys
-import os
-from scipy.signal import savgol_filter
-import pingouin as pg
-from scipy import stats
+import matplotlib.pyplot as plt
 import matplotlib.ticker as tck 
+from mpl_toolkits.mplot3d import Axes3D
+import seaborn as sns
+
+import sys, os,shutil,re, yaml,json
 from cycler import cycler
-import re
+import time
+from dateutil import parser
+from datetime import datetime
+
 from PIL import Image,ImageEnhance, ImageOps,ImageFilter
 from rembg import remove,new_session
-from mpl_toolkits.mplot3d import Axes3D
+
 import docx
-import pandas as pd
 from fpdf import FPDF 
-import yaml
 from lxml import etree 
 from docx import Document
 from PyPDF2 import PdfReader
 from pdf2image import convert_from_path, pdfinfo_from_path
-from nltk.tokenize import sent_tokenize,word_tokenize
+from nltk.tokenize import sent_tokenize, word_tokenize
 import nltk  # nltk.download("punkt")
 from docx2pdf import convert
 import img2pdf as image2pdf
-import pprint
+import nbformat
+from nbconvert import MarkdownExporter
+
 from itertools import pairwise
-import time
 from box import Box, BoxList
 from numerizer import numerize
 from tqdm import tqdm
 import mimetypes
 from pprint import pp
-from dateutil import parser
-from datetime import datetime
+from collections import Counter
+from fuzzywuzzy import fuzz,process
+from langdetect import detect
+from duckduckgo_search import DDGS
 
-def is_num(s):
+from py2ls import netfinder
+
+dir_save='/Users/macjianfeng/Dropbox/Downloads/'
+
+def rm_folder(folder_path, verbose=True):
+    try:
+        shutil.rmtree(folder_path)
+        if verbose:
+            print(f'Successfully deleted {folder_path}')
+    except Exception as e:
+        if verbose:
+            print(f'Failed to delete {folder_path}. Reason: {e}')
+
+def fremove(path, verbose=True):
     """
-    Check if a string can be converted to a number (int or float).
+    Remove a folder and all its contents or a single file.
     Parameters:
-    - s (str): The string to check.
+    path (str): The path to the folder or file to remove.
+    verbose (bool): If True, print success or failure messages. Default is True.
+    """
+    try:
+        if os.path.isdir(path):
+            shutil.rmtree(path)
+            if verbose:
+                print(f'Successfully deleted folder {path}')
+        elif os.path.isfile(path):
+            os.remove(path)
+            if verbose:
+                print(f'Successfully deleted file {path}')
+        else:
+            if verbose:
+                print(f'Path {path} does not exist')
+    except Exception as e:
+        if verbose:
+            print(f'Failed to delete {path}. Reason: {e}')
+
+
+def get_cwd(verbose:bool = True):
+    """
+    get_cwd: to get the current working directory
+    Args:
+        verbose (bool, optional): to show which function is use. Defaults to True.
+    """
+    try:
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        if verbose:
+            print("os.path.dirname(os.path.abspath(__file__)):", script_dir)
+    except NameError:
+        # This works in an interactive environment (like a Jupyter notebook)
+        script_dir = os.getcwd()
+        if verbose:
+            print("os.getcwd():", script_dir) 
+
+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():
+        results = DDGS().text(query, max_results=limit)
+        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)
+        except:
+            if verbose:
+                print(f"failed link")
+    return res
+
+def echo(*args,**kwargs):
+    """
+    query, model="gpt", verbose=True, log=True, dir_save=dir_save
+    a ai chat tool
+    Args:
+        query (str): _description_
+        model (str, optional): _description_. Defaults to "gpt".
+        verbose (bool, optional): _description_. Defaults to True.
+        log (bool, optional): _description_. Defaults to True.
+        dir_save (str, path, optional): _description_. Defaults to dir_save.
+
     Returns:
-    - bool: True if the string can be converted to a number, False otherwise.
+        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)
+    for arg in args:
+        if isinstance(arg, str):
+            if os.path.isdir(arg):
+                dir_save = arg
+            # elif os.path.isfile(arg):
+            #     dir_save = dirname(arg)
+            elif len(arg) <= 5:
+                model = arg
+            else:
+                query = arg
+        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=[]
+        if ignore_case:
+            [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 ]
+        return any(res_bool)
+    def valid_mod_name(str_fly):
+        if is_in_any(str_fly, "claude-3-haiku"):
+            return "claude-3-haiku"
+        elif is_in_any(str_fly, "gpt-3.5"):
+            return "gpt-3.5"
+        elif is_in_any(str_fly, "llama-3-70b"):
+            return "llama-3-70b"
+        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
+    model_valid = valid_mod_name(model)
+    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')
+        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_)
+        print(f"log file:{fpath}")
+    return res
+
+def chat(*args, **kwargs):
+    if len(args) == 1 and isinstance(args[0], str):
+        kwargs['query'] = args[0]
+    return echo(**kwargs)
+
+def ai(*args, **kwargs):
+    if len(args) == 1 and isinstance(args[0], str):
+        kwargs['query'] = args[0]
+    return echo(**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()]
     try:
-        float(s)  # Try converting the string to a float
-        return True
-    except ValueError:
-        return False
-def isnum(s):
-    return is_num(s)
+        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]]
+            else:
+                return l_lang[strcmp(code_detect,l_code, verbose=verbose)[1]]
+        else:
+            print(f"{text} is not supported")
+            return 'no'
+    except:
+        return 'no'
+
+def is_text(s):
+    has_alpha = any(char.isalpha() for char in s)
+    has_non_alpha = any(not char.isalpha() for char in 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'):
+    """
+    Compares a search term with a list of candidate strings and finds the best match based on similarity score.
+
+    Parameters:
+    search_term (str): The term to be searched for.
+    candidates (list of str): A list of candidate strings to compare against the search term.
+    ignore_case (bool): If True, the comparison ignores case differences.
+    verbose (bool): If True, prints the similarity score and the best match.
+
+    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.
+        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)
+    if isinstance(str2_, list):
+        if 'part' in scorer.lower():
+            similarity_scores = [fuzz.partial_ratio(str1_, word) for word in str2_]
+        elif 'W' in scorer.lower():
+            similarity_scores = [fuzz.WRatio(str1_, word) for word in str2_]
+        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_]
+        best_match_index = similarity_scores.index(max(similarity_scores))
+        best_match_score = similarity_scores[best_match_index]
+    else:
+        best_match_index = 0
+        if 'part' in scorer.lower():
+            best_match_score = fuzz.partial_ratio(str1_, str2_)
+        elif 'W' in scorer.lower():
+            best_match_score = fuzz.WRatio(str1_, str2_)
+        elif 'Ratio' in scorer.lower():
+            best_match_score = fuzz.Ratio(str1_, str2_)
+        else:
+            best_match_score = fuzz.WRatio(str1_, str2_)
+    if verbose:
+        print(f"\nbest_match is: {candidates[best_match_index],best_match_score}")
+        best_match = process.extract(search_term, candidates)
+        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
+    for item, count in c.items():
+        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'):
     """
@@ -81,7 +315,8 @@ def str2time(time_str, fmt='24'):
             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():
@@ -94,10 +329,10 @@ def str2time(time_str, fmt='24'):
 
     try:
         # Try to parse the time string assuming it could be in 24-hour or 12-hour format
-        time_obj = datetime.strptime(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_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}")
     
@@ -228,18 +463,33 @@ def num2str(num, *args):
 # 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(text, dict_replace=None, robust=True):
+def sreplace(*args,**kwargs):
     """
+    sreplace(text, by=None, robust=True)
     Replace specified substrings in the input text with provided replacements.
     Args:
         text (str): The input text where replacements will be made.
-        dict_replace (dict, optional): A dictionary containing substrings to be replaced as keys
+        by (dict, optional): A dictionary containing substrings to be replaced as keys
             and their corresponding replacements as values. Defaults to {".com": "..come", "\n": " ", "\t": " ", "  ": " "}.
         robust (bool, optional): If True, additional default replacements for newline and tab characters will be applied.
                                 Default is False.
     Returns:
         str: The text after replacements have been made.
     """
+    text = None
+    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
+        else:
+            Error(f"{type(arg)} is not supported")
+    
     # Default replacements for newline and tab characters
     default_replacements = {
         "\a": "",
@@ -260,19 +510,18 @@ def sreplace(text, dict_replace=None, robust=True):
     }
 
     # If dict_replace is None, use the default dictionary
-    if dict_replace is None:
-        dict_replace = {}
-
+    if by is None:
+        by = {}
     # If robust is True, update the dictionary with default replacements
     if robust:
-        dict_replace.update(default_replacements)
+        by.update(default_replacements)
 
     # Iterate over each key-value pair in the dictionary and replace substrings accordingly
-    for k, v in dict_replace.items():
+    for k, v in by.items():
         text = text.replace(k, v)
     return text
 # usage:
-# sreplace(text, dict_replace=dict(old_str='new_str'), robust=True)
+# 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],
@@ -285,6 +534,7 @@ def paper_size(paper_type_str='a4'):
     if not paper_type:
         paper_type='a4' # default
     return df[paper_type].tolist()
+
 def docx2pdf(dir_docx, dir_pdf=None):
     if dir_pdf:
         convert(dir_docx,dir_pdf)
@@ -414,10 +664,10 @@ def ssplit(text, by="space", verbose=False, **kws):
         if verbose:
             print(f"split_by_word_length(text, length)")
         return split_by_word_length(text, **kws)  # split_by_word_length(text, length)
-    elif "," in by:
-        if verbose:
-            print(f"splited by ','")
-        return text.split(",")
+    # elif "," in by:
+    #     if verbose:
+    #         print(f"splited by ','")
+    #     return text.split(",")
     elif isinstance(by, list):
         if verbose:
             print(f"split_by_multiple_delimiters: ['|','&']")
@@ -500,7 +750,7 @@ 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:
-        pprint.pp(pdfinfo_from_path(dir_pdf))
+        pp(pdfinfo_from_path(dir_pdf))
     if isinstance(page, tuple) and page:
         page = list(page)
     if isinstance(page,int):
@@ -573,7 +823,14 @@ 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)
+        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):
         """
             Parameters:
@@ -635,7 +892,7 @@ def fload(fpath, kind=None, **kwargs):
 
     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"]
+    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}")
@@ -655,6 +912,8 @@ def fload(fpath, kind=None, **kwargs):
         return load_csv(fpath, **kwargs)
     elif kind == "xlsx":
         return load_xlsx(fpath, **kwargs)
+    elif kind == "ipynb":
+        return load_ipynb(fpath, **kwargs)
     elif kind == "pdf":
         print('usage:load_pdf(fpath, page="all", verbose=False)')
         return load_pdf(fpath, **kwargs)
@@ -675,6 +934,31 @@ 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.
+    Parameters
+    ----------
+    fpath : str
+        The file path where the content should be updated.
+    content : str, optional
+        The new content to add at the top of the file. If not provided, the function will not add any new content.
+    Notes
+    -----
+    - If the file at `fpath` does not exist, it will be created.
+    - The new content will be added at the top, followed by the old content of the file.
+    """
+    content = content or ""
+    if os.path.exists(fpath):
+        with open(fpath, 'r') as file:
+            old_content = file.read()
+    else:
+        old_content = '' 
+        
+    with open(fpath, 'w') as file:
+        file.write(content)
+        file.write(old_content)
+        
 def fsave(
     fpath,
     content,
@@ -682,6 +966,7 @@ def fsave(
     font_name="Times",
     font_size=10,
     spacing=6,
+    mode='w',
     **kwargs,
 ):
     """
@@ -697,8 +982,8 @@ def fsave(
     Returns:
         None
     """
-    def save_content(fpath, content): 
-        with open(fpath, "w", encoding='utf-8') as file:
+    def save_content(fpath, content, mode=mode): 
+        with open(fpath, mode, encoding='utf-8') as file:
             file.write(content)
 
 
@@ -717,19 +1002,19 @@ def fsave(
         doc.save(fpath)
 
 
-    def save_txt_md(fpath, content, sep="\n"):
+    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))
+        save_content(fpath, sep.join(content),mode)
 
 
-    def save_html(fpath, content, font_name, font_size):
+    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)
+        save_content(fpath, html_content,mode)
 
 
     def save_pdf(fpath, content, font_name, font_size):
@@ -752,7 +1037,25 @@ def fsave(
         df = pd.DataFrame(data)
         df.to_excel(fpath, **kwargs)
 
+    def save_ipynb(fpath,data,**kwargs):
+        # Split the content by code fences to distinguish between code and markdown
+        parts = data.split('```')
+        cells = []
 
+        for i, part in enumerate(parts):
+            if i % 2 == 0:
+                # Even index: markdown content
+                cells.append(nbf.v4.new_markdown_cell(part.strip()))
+            else:
+                # Odd index: code content
+                cells.append(nbf.v4.new_code_cell(part.strip()))
+        # Create a new notebook
+        nb = nbformat.v4.new_notebook()
+        nb['cells'] = cells
+        # Write the notebook to a file
+        with open(fpath, 'w', encoding='utf-8') as ipynb_file:
+            nbf.write(fpath, ipynb_file)
+        
     # def save_json(fpath, data, **kwargs):
     #     with open(fpath, "w") as file:
     #         json.dump(data, file, **kwargs)
@@ -811,39 +1114,41 @@ def fsave(
         "json",
         "xml",
         "yaml",
+        "ipynb"
     ]:
-        raise ValueError(
-            f"Error:\n{kind} is not in the supported list ['docx', 'txt', 'md', 'html', 'pdf', 'csv', 'xlsx', 'json', 'xml', 'yaml']"
+        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":
         save_docx(fpath, content, font_name, font_size, spacing)
     elif kind == "txt":
-        save_txt_md(fpath, content, sep="")
+        save_txt_md(fpath, content, sep="",mode=mode)
     elif kind == "md":
-        save_txt_md(fpath, content, sep="")
+        save_txt_md(fpath, content, sep="",mode=mode)
     elif kind == "html":
         save_html(fpath, content, font_name, font_size)
     elif kind == "pdf":
         save_pdf(fpath, content, font_name, font_size)
     elif kind == "csv":
-        save_csv(
-            fpath, content, **kwargs
-        )  # Assuming content is in tabular form (list of dicts or DataFrame)
+        save_csv(fpath, content, **kwargs)
     elif kind == "xlsx":
-        save_xlsx(
-            fpath, content, **kwargs
-        )  # Assuming content is in tabular form (list of dicts or DataFrame)
+        save_xlsx(fpath, content, **kwargs)
     elif kind == "json":
-        save_json(fpath, content)  # Assuming content is a serializable object
+        save_json(fpath, content) 
     elif kind == "xml":
-        save_xml(fpath, content)  # Assuming content is a dictionary
+        save_xml(fpath, content) 
     elif kind == "yaml":
-        save_yaml(fpath, content, **kwargs)  # Assuming content is a serializable object
+        save_yaml(fpath, content, **kwargs)
+    elif kind == "ipynb":
+        save_ipynb(fpath, content, **kwargs) 
     else:
-        raise ValueError(
-            f"Error:\n{kind} is not in the supported list ['docx', 'txt', 'md', 'html', 'pdf', 'csv', 'xlsx', 'json', 'xml', 'yaml']"
-        )
+        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
@@ -867,14 +1172,92 @@ def fsave(
 def addpath(fpath):
     sys.path.insert(0,dir)
 def dirname(fpath):
+    """
+    dirname: Extracting Directory Name from a File Path
+    Args:
+        fpath (str): the file or directory path 
+    Returns:
+        str: directory, without filename
+    """
     dirname_=os.path.dirname(fpath)
     if not dirname_.endswith('/'):
         dirname_=dirname_+"/"
     return dirname_
-def dir_name(fpath):
+
+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 
+    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))]
+    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():
+            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 ascending:
+            sorted_index = df[by].str.lower().argsort()
+        else:
+            sorted_index = df[by].str.lower().argsort()[::-1]
+    else:
+        if ascending:
+            sorted_index = df[by].argsort()
+        else:
+            sorted_index = df[by].argsort()[::-1]
+    sorted_df = df.iloc[sorted_index].reset_index(drop=True)
+    return sorted_df
+
+def isa(*args,**kwargs):
+    """
+    fpath, contains='img'
+    containss file paths based on the specified contains.
+    Args:
+        fpath (str): Path to the file.
+        contains (str): contains of file to contains. Default is 'img' for images. Other options include 'doc' for documents,
+                    'zip' for ZIP archives, and 'other' for other types of files.
+    Returns:
+        bool: True if the file matches the contains, False otherwise.
+    """
+    for arg in args:
+        if isinstance(arg, str):
+            if '/' in arg or '\\' in arg:
+                fpath = arg
+            else:
+                contains=arg
+    if 'img' in contains.lower() or 'image' in contains.lower():
+        return is_image(fpath)
+    elif 'doc' in contains.lower():
+        return is_document(fpath)
+    elif 'zip' in contains.lower():
+        return is_zip(fpath)
+    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
+        return os.path.isfile(fpath)
+    elif 'num' in contains.lower():#file
+        return os.path.isfile(fpath)
+    elif 'text' in contains.lower() or 'txt' in contains.lower():#file
+        return is_text(fpath)
+    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,
@@ -885,83 +1268,6 @@ def listdir(
     orient="list",
     output="df"
 ):
-    def sort_kind(df, by="name", ascending=True):
-        if df[by].dtype == 'object':  # Check if the column contains string values
-            if ascending:
-                sorted_index = df[by].str.lower().argsort()
-            else:
-                sorted_index = df[by].str.lower().argsort()[::-1]
-        else:
-            if ascending:
-                sorted_index = df[by].argsort()
-            else:
-                sorted_index = df[by].argsort()[::-1]
-        sorted_df = df.iloc[sorted_index].reset_index(drop=True)
-        return sorted_df
-
-    def flist(fpath, filter="all"):
-        all_files = [os.path.join(fpath, f) for f in os.listdir(fpath) if os.path.isfile(os.path.join(fpath, f))]
-        if isinstance(filter, list):
-            filt_files = []
-            for filter_ in filter:
-                filt_files.extend(flist(fpath, filter_))
-            return filt_files
-        else:
-            if 'all' in filter.lower():
-                return all_files
-            else:
-                filt_files = [f for f in all_files if istype(f, filter)]
-                return filt_files
-
-    def istype(fpath, filter='img'):
-        """
-        Filters file paths based on the specified filter.
-        Args:
-            fpath (str): Path to the file.
-            filter (str): Filter of file to filter. Default is 'img' for images. Other options include 'doc' for documents,
-                        'zip' for ZIP archives, and 'other' for other types of files.
-        Returns:
-            bool: True if the file matches the filter, False otherwise.
-        """
-        if 'img' in filter.lower():
-            return is_image(fpath)
-        elif 'doc' in filter.lower():
-            return is_document(fpath)
-        elif 'zip' in filter.lower():
-            return is_zip(fpath)
-        else:
-            return False
-
-    def is_image(fpath):
-        mime_type, _ = mimetypes.guess_type(fpath)
-        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'
-        ):
-            return True
-        else:
-            return False
-
-    def is_zip(fpath):
-        mime_type, _ = mimetypes.guess_type(fpath)
-        if mime_type == 'application/zip':
-            return True
-        else:
-            return False
-
     if not kind.startswith("."):
         kind = "." + kind
 
@@ -990,8 +1296,10 @@ def listdir(
                 os.path.isfile(item_path)
             )
             if kind in ['.doc','.img','.zip']: #选择大的类别
-                if kind != ".folder" and not istype(item_path, kind):
+                if kind != ".folder" and not isa(item_path, kind):
                     continue
+            elif kind in ['.all']:
+                return flist(fpath, contains=contains)
             else: #精确到文件的后缀
                 if not is_folder and not is_file:
                     continue
@@ -1058,32 +1366,45 @@ def list_func(lib_name, opt="call"):
         funcs = dir(lib_name)
     return funcs
 def func_list(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
+    return list_func(lib_name, opt=opt)
 
-def newfolder(pardir, chdir):
-    import os
+def newfolder(*args, **kwargs):
+    """
+    newfolder(pardir, chdir)
+    Args:
+        pardir (dir): parent dir
+        chdir (str): children dir
+        overwrite (bool): overwrite?
+    Returns:
+        mkdir, giving a option if exists_ok or not
+    """
+    overwrite=kwargs.get("overwrite",False)
+    for arg in args:
+        if isinstance(arg, str):
+            if "/" in arg or "\\" in arg:
+                pardir=arg
+                print(f'pardir{pardir}')
+            else:
+                chdir = arg
+                print(f'chdir{chdir}')
+        elif isinstance(arg,bool):
+            overwrite=arg
+            print(overwrite)
+        else:
+            print(f"{arg}Error: not support a {type(arg)} type")
     rootdir = []
     # Convert string to list
     if isinstance(chdir, str):
         chdir = [chdir]
-
     # Subfoldername should be unique
     chdir = list(set(chdir))
-
     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 '\\'
-
     # Check if the parent directory exists and is a directory path
     if os.path.isdir(pardir):
         os.chdir(pardir)  # Set current path
-
         # Check if subdirectories are not empty
         if chdir:
             chdir.sort()
@@ -1095,51 +1416,46 @@ def newfolder(pardir, chdir):
                     os.mkdir('./' + folder)
                     print(f'\n {folder} was created successfully!\n')
                 else:
-                    print(f'\n {folder} already exists! \n')
-
+                    if overwrite:
+                        shutil.rmtree(child_tmp)
+                        os.mkdir('./' + folder)
+                        print(f'\n {folder} overwrite! \n')
+                    else:
+                        print(f'\n {folder} already exists! \n')
                 rootdir.append(child_tmp + stype)  # Note down
-
         else:
             print('\nWarning: Dir_child doesn\'t exist\n')
-
     else:
         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):
-    DirSave = None
+    dir_save = None
     fname = None 
-
     for arg in args:
         if isinstance(arg, str):
             if '/' in arg or '\\' in arg:
-                DirSave = arg
+                dir_save = arg
             elif '/' not in arg and '\\' not in arg:
                 fname = arg
-
     # Backup original values
-    if '/' in DirSave:
-        if DirSave[-1] != '/':
-            DirSave = DirSave + '/'
-    elif '\\' in DirSave:
-        if DirSave[-1] != '\\':
-            DirSave = DirSave + '\\'
+    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 DirSave Directory')
-
+        raise ValueError('Check the Path of dir_save Directory')
     ftype = fname.split('.')[-1]
     if len(fname.split('.')) == 1:
         ftype = 'nofmt'
-        fname = DirSave + fname + '.' + ftype
+        fname = dir_save + fname + '.' + ftype
     else:
-        fname = DirSave + fname
-
+        fname = dir_save + fname
     # Save figure based on file type
     if ftype.lower() == 'eps':
         plt.savefig(fname, format='eps', bbox_inches='tight')
@@ -1164,7 +1480,6 @@ def figsave(*args,dpi=300):
         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}')
 
 
@@ -1198,8 +1513,6 @@ def FuncStars(ax,
               report=None,
               report_scale=-0.1,
               report_loc=None):
-
-
     if ax is None:
         ax = plt.gca()
     if Ylim is None:
@@ -1210,11 +1523,9 @@ def FuncStars(ax,
         report_loc = np.min(Ylim) + report_scale*np.abs(np.diff(Ylim))
     if report_scale > 0:
         report_scale = -np.abs(report_scale)
-
     yscale = np.float64(yscale)
     y_loc = np.min(Ylim) + yscale*(np.max(Ylim)-np.min(Ylim))
     xcenter = np.mean([x1, x2])
-
     # ns / *
     if alpha < pval:
         if nsshow == 'on':
@@ -1238,7 +1549,6 @@ def FuncStars(ax,
         plt.text(xcenter, y_loc, symbol * 3,
                  ha='center', va='center_baseline',
                  fontsize=fontsize, fontname=fontname, color=symbolcolor)
-
     # lines indicators
     if linego:  # and 0 < pval <= 0.05:
         print(pval)
@@ -1278,12 +1588,10 @@ def FuncStars(ax,
                      [np.min(Ylim) + 0.95*(np.max(Ylim)-np.min(Ylim)) - np.abs(np.diff(Ylim)) * tailindicator[1],
                       np.min(Ylim) + 0.95*(np.max(Ylim)-np.min(Ylim)) - np.abs(np.diff(Ylim)) * 0.002],
                      linestyle=linestyle, color=linecolor, linewidth=linewidth)
-
     if values_below is not None:
         plt.text(xcenter, y_loc * (-0.1), values_below,
                  ha='center', va='bottom',  # 'center_baseline', rotation=rotation,
                  fontsize=fontsize_note, fontname=fontname, color='k')
-
     # report / comments
     if report is not None:
         plt.text(xcenter, report_loc, report,
@@ -1293,7 +1601,49 @@ 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).
+    Parameters:
+    - s (str): The string to check.
+    Returns:
+    - bool: True if the string can be converted to a number, False otherwise.
+    """
+    try:
+        float(s)  # Try converting the string to a float
+        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'):
+        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'
+    ):
+        return True
+    else:
+        return False
+def is_zip(fpath):
+    mime_type, _ = mimetypes.guess_type(fpath)
+    if mime_type == 'application/zip':
+        return True
+    else:
+        return False
+    
 def stdshade(ax=None,*args, **kwargs):
     if (
         isinstance(ax, np.ndarray)
@@ -1315,7 +1665,6 @@ def stdshade(ax=None,*args, **kwargs):
     l_style2 = ["--", "-."]
     l_style1 = ["-", ":"]
     l_mark = ["o", "+", "*", ".", "x", "_", "|", "s", "d", "^", "v", ">", "<", "p", "h"]
-
     # Check each argument
     for iarg in range(len(args)):
         if (
@@ -1428,8 +1777,6 @@ def stdshade(ax=None,*args, **kwargs):
     else:
         line = ax.plot(x, yMean, color=acolor, ls=plotStyle, marker=plotMarker, **line_kws)
     return line[0], fill
-
-
 # =============================================================================
 # # for plot figures {Qiu et al.2023}
 # =============================================================================
@@ -1610,7 +1957,6 @@ def FuncCmpt(X1, X2, pmc='auto', pair='unpaired'):
         X1, X2, cfg_pmc=cfg_pmc, pair=cfg_pair)
     return p, output
 
-
 # ======compare 2 group test===================================================
 # # Example
 # X1 = [19, 22, 16, 29, 24]
@@ -1932,7 +2278,6 @@ def FuncMultiCmpt(pmc='pmc', pair='unpair', data=None, dv=None, factor=None,
         'both' in cfg_pair) else None
     go_mix_within = factor if ('pa' in cfg_pair) or (
         'np' not in cfg_pair) else None
-
     if res_tab['p-unc'][0] <= .05:
         # Pairwise Comparisons
         method_post_hoc = [
@@ -1946,7 +2291,6 @@ def FuncMultiCmpt(pmc='pmc', pair='unpair', data=None, dv=None, factor=None,
         for met in method_post_hoc:
             post_curr = pg.pairwise_tests(data=data, dv=dv, between=go_mix_between, within=go_mix_within, subject=go_subject, parametric=go_pmc, marginal=True, alpha=0.05, alternative='two-sided',
                                           padjust=met)
-
             res_posthoc = pd.concat([res_posthoc, post_curr],
                                     ignore_index=True)
     else:
@@ -1966,7 +2310,6 @@ def FuncMultiCmpt(pmc='pmc', pair='unpair', data=None, dv=None, factor=None,
         output['res_tab']['APA'] = output['APA']  # note APA in the table
     # print(output['stat'])
     # print(output['res_tab'])
-
     return output
 
 
@@ -2192,18 +2535,14 @@ def str2list(str_):
 def load_img(fpath):
     """
     Load an image from the specified file path.
-
     Args:
         fpath (str): The file path to the image.
-
     Returns:
         PIL.Image: The loaded image.
-
     Raises:
         FileNotFoundError: If the specified file is not found.
         OSError: If the specified file cannot be opened or is not a valid image file.
     """
-
     try:
         img = Image.open(fpath)
         return img
@@ -2216,12 +2555,10 @@ def apply_filter(img, *args):
     # def apply_filter(img, filter_name, filter_value=None):
     """
     Apply the specified filter to the image.
-
     Args:
         img (PIL.Image): The input image.
         filter_name (str): The name of the filter to apply.
         **kwargs: Additional parameters specific to the filter.
-
     Returns:
         PIL.Image: The filtered image.
     """
@@ -2425,10 +2762,8 @@ def imgsets(
     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.
         """
@@ -2444,47 +2779,33 @@ def imgsets(
             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
-            )
+            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
     if auto:
         auto_params = auto_enhance(img_update)
         sets.update(auto_params)
-
     if sets is None:
         sets = {}
     for k, value in sets.items():
@@ -2559,12 +2880,9 @@ def imgsets(
                 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:
@@ -2573,7 +2891,6 @@ def imgsets(
             plt.figure(figsize=figsize, dpi=dpi)
         plt.imshow(img_update)
         plt.axis("on") if show_axis else plt.axis("off")
-
     return img_update
 # # usage:
 # img = imgsets(
@@ -2594,7 +2911,6 @@ def figsets(*args):
         "scatter","ieee","no-latex","std-colors","high-vis","bright","dark_background","science",
         "high-vis","vibrant","muted","retro","grid","high-contrast","light","cjk-tc-font","cjk-kr-font",
     ]
-
     def sets_priority(ax,key, value):
         if ("fo" in key) and (("size" in key) or ("sz" in key)):
             fontsize=value