py2ls 0.2.4.31__py3-none-any.whl → 0.2.4.33__py3-none-any.whl

py2ls/ips.py

@@ -1,6 +1,7 @@
 import numpy as np
 import pandas as pd
-import sys, os
+import sys
+import os
 from IPython.display import display
 from typing import List, Optional, Union
 
@@ -17,13 +18,15 @@ import warnings
 warnings.simplefilter("ignore", category=pd.errors.SettingWithCopyWarning)
 warnings.filterwarnings("ignore", category=pd.errors.PerformanceWarning)
 warnings.filterwarnings("ignore")
-import os
 import shutil
 import logging
 from pathlib import Path
 from datetime import datetime
+import re
+import stat
+import platform
 
-def run_once_within(duration=60,reverse=False):  # default 60s
+def run_once_within(duration=60, reverse=False):  # default 60s
     import time
 
     """
@@ -546,6 +549,7 @@ def is_text(s):
 
 from typing import Any, Union
 
+
 def share(*args, strict=True, n_shared=2, verbose=True):
     """
     check the shared elelements in two list.
@@ -591,13 +595,14 @@ def share(*args, strict=True, n_shared=2, verbose=True):
         elements2show = (
             shared_elements if len(shared_elements) < 10 else shared_elements[:5]
         )
-        tail = '' if len(shared_elements) < 10 else '......'
+        tail = "" if len(shared_elements) < 10 else "......"
         elements2show.append(tail)
         print(f"{' '*2}{len(shared_elements)} elements shared: {' '*2}{elements2show}")
         print("********* checking shared elements *********")
     return shared_elements
 
-def shared(*args, n_shared=None, verbose=True,**kwargs):
+
+def shared(*args, n_shared=None, verbose=True, **kwargs):
     """
     check the shared elelements in two list.
     usage:
@@ -652,7 +657,8 @@ def shared(*args, n_shared=None, verbose=True,**kwargs):
         print("********* checking shared elements *********")
     return shared_elements
 
-def share_not(*args,  n_shared=None, verbose=False):
+
+def share_not(*args, n_shared=None, verbose=False):
     """
     To find the elements in list1 that are not shared with list2 while maintaining the original order of list1
     usage:
@@ -660,10 +666,12 @@ def share_not(*args,  n_shared=None, verbose=False):
         list2 = [4, 5, 6, 7, 8]
         not_shared(list1,list2)# output [1,3]
     """
-    _common = shared(*args,  n_shared=n_shared, verbose=verbose)
+    _common = shared(*args, n_shared=n_shared, verbose=verbose)
     list1 = flatten(args[0], verbose=verbose)
     _not_shared = [item for item in list1 if item not in _common]
     return _not_shared
+
+
 def not_shared(*args, n_shared=None, verbose=False):
     """
     To find the elements in list1 that are not shared with list2 while maintaining the original order of list1
@@ -779,13 +787,23 @@ def strcmp(
         print(f"建议: {best_match}")
     return candidates[best_match_index], best_match_index
 
-def imgcmp(img: list, method='knn', plot_=True, figsize=[12, 6]):
+
+def imgcmp(img: list, 
+           method:str ="knn", 
+           thr:float =0.75,
+           detector: str = "sift", 
+           plot_:bool =True, 
+           figsize=[12, 6],
+           grid_size=10,# only for grid detector
+           **kwargs):
     """
     Compare two images using SSIM, Feature Matching (SIFT), or KNN Matching.
 
     Parameters:
-    - img (list): List containing two image file paths [img1, img2].
+    - img (list): List containing two image file paths [img1, img2] or two numpy arrays.
     - method (str): Comparison method ('ssim', 'match', or 'knn').
+    - detector (str): Feature detector ('sift', 'grid', 'pixel').
+    - thr (float): Threshold for filtering matches.
     - plot_ (bool): Whether to display the results visually.
     - figsize (list): Size of the figure for plots.
 
@@ -796,15 +814,21 @@ def imgcmp(img: list, method='knn', plot_=True, figsize=[12, 6]):
     import cv2
     import matplotlib.pyplot as plt
     from skimage.metrics import structural_similarity as ssim
+
     # Load images
-    image1 = cv2.imread(img[0])
-    image2 = cv2.imread(img[1])
+    if isinstance(img, list) and isinstance(img[0],str):
+        image1 = cv2.imread(img[0])
+        image2 = cv2.imread(img[1])
+        bool_cvt=True
+    else:
+        image1, image2 = np.array(img[0]),np.array(img[1])
+        bool_cvt=False
 
     if image1 is None or image2 is None:
         raise ValueError("Could not load one or both images. Check file paths.")
-    methods=['ssim','match','knn']
-    method=strcmp(method, methods)[0]
-    if method == 'ssim':
+    methods = ["ssim", "match", "knn"]
+    method = strcmp(method, methods)[0]
+    if method == "ssim":
         # Convert images to grayscale
         gray1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
         gray2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
@@ -819,107 +843,187 @@ def imgcmp(img: list, method='knn', plot_=True, figsize=[12, 6]):
         # Plot if needed
         if plot_:
             fig, ax = plt.subplots(1, 3, figsize=figsize)
-            ax[0].imshow(gray1, cmap='gray')
+            ax[0].imshow(gray1, cmap="gray")
             ax[0].set_title("Image 1")
-            ax[1].imshow(gray2, cmap='gray')
+            ax[1].imshow(gray2, cmap="gray")
             ax[1].set_title("Image 2")
-            ax[2].imshow(diff, cmap='gray')
+            ax[2].imshow(diff, cmap="gray")
             ax[2].set_title("Difference (SSIM)")
             plt.tight_layout()
             plt.show()
-        
+
         return diff, score
 
-    elif method in ['match', 'knn']:
+    elif method in ["match", "knn"]:
         # Convert images to grayscale
         gray1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
-        gray2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
+        gray2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY) 
+
+        if detector == "sift":
+            # SIFT detector
+            sift = cv2.SIFT_create()
+            keypoints1, descriptors1 = sift.detectAndCompute(gray1, None)
+            keypoints2, descriptors2 = sift.detectAndCompute(gray2, None)
+
+        elif detector == "grid":
+            # Grid-based detection
+            keypoints1, descriptors1 = [], []
+            keypoints2, descriptors2 = [], []
+
+            for i in range(0, gray1.shape[0], grid_size):
+                for j in range(0, gray1.shape[1], grid_size):
+                    patch1 = gray1[i:i + grid_size, j:j + grid_size]
+                    patch2 = gray2[i:i + grid_size, j:j + grid_size]
+                    if patch1.size > 0 and patch2.size > 0:
+                        keypoints1.append(cv2.KeyPoint(j + grid_size // 2, i + grid_size // 2, grid_size))
+                        keypoints2.append(cv2.KeyPoint(j + grid_size // 2, i + grid_size // 2, grid_size))
+                        descriptors1.append(np.mean(patch1))
+                        descriptors2.append(np.mean(patch2))
+
+            descriptors1 = np.array(descriptors1).reshape(-1, 1)
+            descriptors2 = np.array(descriptors2).reshape(-1, 1)
+
+        elif detector == "pixel":
+            # Pixel-based direct comparison
+            descriptors1 = gray1.flatten()
+            descriptors2 = gray2.flatten()
+            keypoints1 = [cv2.KeyPoint(x, y, 1) for y in range(gray1.shape[0]) for x in range(gray1.shape[1])]
+            keypoints2 = [cv2.KeyPoint(x, y, 1) for y in range(gray2.shape[0]) for x in range(gray2.shape[1])]
 
-        # Initialize SIFT detector
-        sift = cv2.SIFT_create()
-
-        # Detect and compute features
-        keypoints1, descriptors1 = sift.detectAndCompute(gray1, None)
-        keypoints2, descriptors2 = sift.detectAndCompute(gray2, None)
-
-        if len(keypoints1) == 0 or len(keypoints2) == 0:
-            raise ValueError("No keypoints found in one or both images.")
+        else:
+            raise ValueError("Invalid detector. Use 'sift', 'grid', or 'pixel'.")
+ 
+        # Handle missing descriptors
+        if descriptors1 is None or descriptors2 is None:
+            raise ValueError("Failed to compute descriptors for one or both images.")
+        # Ensure descriptors are in the correct data type
+        if descriptors1.dtype != np.float32:
+            descriptors1 = descriptors1.astype(np.float32)
+        if descriptors2.dtype != np.float32:
+            descriptors2 = descriptors2.astype(np.float32)
 
         # BFMatcher initialization
         bf = cv2.BFMatcher()
-
-        if method == 'match':  # Cross-check matching
+        if method == "match":  # Cross-check matching
             bf = cv2.BFMatcher(cv2.NORM_L2, crossCheck=True)
             matches = bf.match(descriptors1, descriptors2)
             matches = sorted(matches, key=lambda x: x.distance)
 
             # Filter good matches
-            good_matches = [m for m in matches if m.distance < 0.75 * matches[-1].distance]
+            good_matches = [
+                m for m in matches if m.distance < thr * matches[-1].distance
+            ]
 
-        elif method == 'knn':  # KNN matching with ratio test
+        elif method == "knn":  # KNN matching with ratio test
+            bf = cv2.BFMatcher()
             matches = bf.knnMatch(descriptors1, descriptors2, k=2)
             # Apply Lowe's ratio test
-            good_matches = [m for m, n in matches if m.distance < 0.75 * n.distance]
+            good_matches = [m for m, n in matches if m.distance < thr * n.distance]
 
         # Calculate similarity score
         similarity_score = len(good_matches) / min(len(keypoints1), len(keypoints2))
         print(f"Number of good matches: {len(good_matches)}")
         print(f"Similarity Score: {similarity_score:.4f}")
-     # Handle case where no good matches are found
+        # Handle case where no good matches are found
         if len(good_matches) == 0:
             print("No good matches found.")
             return good_matches, 0.0, None
 
         # Identify matched keypoints
-        src_pts = np.float32([keypoints1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
-        dst_pts = np.float32([keypoints2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
-
-        # Calculate Homography using RANSAC
-        homography_matrix, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
-
+        src_pts = np.float32([keypoints1[m.queryIdx].pt for m in good_matches]).reshape(
+            -1, 1, 2
+        )
+        dst_pts = np.float32([keypoints2[m.trainIdx].pt for m in good_matches]).reshape(
+            -1, 1, 2
+        )
         # Apply the homography to image2
-        h, w = image1.shape[:2]
-        warped_image2 = cv2.warpPerspective(image2, homography_matrix, (w, h))
-
-        # Plot result if needed
-        if plot_:
-            fig, ax = plt.subplots(1, 2, figsize=figsize)
-            ax[0].imshow(cv2.cvtColor(image1, cv2.COLOR_BGR2RGB))
-            ax[0].set_title("Image 1")
-            ax[1].imshow(cv2.cvtColor(warped_image2, cv2.COLOR_BGR2RGB))
-            ax[1].set_title("Warped Image 2")
-            plt.tight_layout()
-            plt.show()
+        try:
+            # Calculate Homography using RANSAC
+            homography_matrix, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
+            h, w = image1.shape[:2]
+            warped_image2 = cv2.warpPerspective(image2, homography_matrix, (w, h))
+
+            # Plot result if needed
+            if plot_:
+                fig, ax = plt.subplots(1, 2, figsize=figsize)
+                ax[0].imshow(cv2.cvtColor(image1, cv2.COLOR_BGR2RGB)) if bool_cvt else ax[0].imshow(image1)
+                ax[0].set_title("Image 1")
+                ax[1].imshow(cv2.cvtColor(warped_image2, cv2.COLOR_BGR2RGB)) if bool_cvt else ax[1].imshow(warped_image2)
+                ax[1].set_title("Warped Image 2")
+                plt.tight_layout()
+                plt.show()
+        except Exception as e:
+            print(e)
 
         # Plot matches if needed
         if plot_:
-            result = cv2.drawMatches(image1, keypoints1, image2, keypoints2, good_matches, None, flags=2)
+            result = cv2.drawMatches(
+                image1, keypoints1, image2, keypoints2, good_matches, None, flags=2
+            )
             plt.figure(figsize=figsize)
-            plt.imshow(cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
+            plt.imshow(cv2.cvtColor(result, cv2.COLOR_BGR2RGB)) if bool_cvt else plt.imshow(result)
             plt.title(f"Feature Matches ({len(good_matches)} matches, Score: {similarity_score:.4f})")
-            plt.axis('off')
+            plt.axis("off")
             plt.show()
         # Identify unmatched keypoints
         matched_idx1 = [m.queryIdx for m in good_matches]
         matched_idx2 = [m.trainIdx for m in good_matches]
-
+        matched_kp1 = [kp for i, kp in enumerate(keypoints1) if i in matched_idx1]
+        matched_kp2 = [kp for i, kp in enumerate(keypoints2) if i in matched_idx2]
         unmatched_kp1 = [kp for i, kp in enumerate(keypoints1) if i not in matched_idx1]
         unmatched_kp2 = [kp for i, kp in enumerate(keypoints2) if i not in matched_idx2]
 
-        # Mark unmatched keypoints on the images
-        img1_marked = cv2.drawKeypoints(image1, unmatched_kp1, None, color=(0, 0, 255), flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
-        img2_marked = cv2.drawKeypoints(image2, unmatched_kp2, None, color=(0, 0, 255), flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
+        # Mark keypoints on the images
+        img1_match = cv2.drawKeypoints(
+            image1,
+            matched_kp1,
+            None,
+            color=(0, 0, 255),
+            flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS,
+        )
+        img2_match = cv2.drawKeypoints(
+            image2,
+            matched_kp2,
+            None,
+            color=(0, 0, 255),
+            flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS,
+        )
+        img1_unmatch = cv2.drawKeypoints(
+            image1,
+            unmatched_kp1,
+            None,
+            color=(0, 0, 255),
+            flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS,
+        )
+        img2_unmatch = cv2.drawKeypoints(
+            image2,
+            unmatched_kp2,
+            None,
+            color=(0, 0, 255),
+            flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS,
+        )
 
-        # Display results
         if plot_:
             fig, ax = plt.subplots(1, 2, figsize=figsize)
-            ax[0].imshow(cv2.cvtColor(img1_marked, cv2.COLOR_BGR2RGB))
+            ax[0].imshow(cv2.cvtColor(img1_unmatch, cv2.COLOR_BGR2RGB)) if bool_cvt else ax[0].imshow(img1_unmatch)
             ax[0].set_title("Unmatched Keypoints (Image 1)")
-            ax[1].imshow(cv2.cvtColor(img2_marked, cv2.COLOR_BGR2RGB))
+            ax[1].imshow(cv2.cvtColor(img2_unmatch, cv2.COLOR_BGR2RGB)) if bool_cvt else ax[1].imshow(img2_unmatch)
             ax[1].set_title("Unmatched Keypoints (Image 2)")
+            ax[0].axis("off")
+            ax[1].axis("off")
             plt.tight_layout()
             plt.show()
-        return good_matches, similarity_score, homography_matrix
+        if plot_:
+            fig, ax = plt.subplots(1, 2, figsize=figsize)
+            ax[0].imshow(cv2.cvtColor(img1_match, cv2.COLOR_BGR2RGB)) if bool_cvt else ax[0].imshow(img1_match)
+            ax[0].set_title("Matched Keypoints (Image 1)")
+            ax[1].imshow(cv2.cvtColor(img2_match, cv2.COLOR_BGR2RGB)) if bool_cvt else ax[1].imshow(img2_match)
+            ax[1].set_title("Matched Keypoints (Image 2)")
+            ax[0].axis("off")
+            ax[1].axis("off")
+            plt.tight_layout()
+            plt.show()
+        return good_matches, similarity_score#, homography_matrix
 
     else:
         raise ValueError("Invalid method. Use 'ssim', 'match', or 'knn'.")
@@ -939,9 +1043,7 @@ def cn2pinyin(
     Args:
         cn_str (str): Chinese string to convert.
         sep (str): Separator for the output Pinyin string.
-        style (Style): "normal","tone", "tone2","tone3",
-        "finals","finals_tone","finals_tone2","finals_tone3",
-        "initials","bopomofo","bopomofo_first","cyrillic","pl",
+        fmt (Style): "normal","tone", "tone2","tone3","finals","finals_tone","finals_tone2","finals_tone3","initials","bopomofo","bopomofo_first","cyrillic","pl",
     Returns:
         cn_str: The Pinyin representation of the Chinese string.
     """
@@ -1017,6 +1119,7 @@ def counter(list_, verbose=True):
 # print(f"Return a list of the n most common elements:\n{c.most_common()}")
 # print(f"Compute the sum of the counts:\n{c.total()}")
 
+
 def dict2df(dict_, fill=None):
     len_max = 0
     for key, value in dict_.items():
@@ -1031,11 +1134,12 @@ def dict2df(dict_, fill=None):
         dict_[key] = value
     return pd.DataFrame.from_dict(dict_)
 
+
 def text2audio(
     text,
     method=None,  # "pyttsx3","gTTS"
     rate=200,
-    slow=False,#"gTTS"
+    slow=False,  # "gTTS"
     volume=1.0,
     voice=None,
     lang=None,
@@ -1056,16 +1160,38 @@ def text2audio(
     # )
     """
     if method is not None:
-        methods=["gTTS","pyttsx3","google"]
-        method=strcmp(method, methods)[0]
+        methods = ["gTTS", "pyttsx3", "google"]
+        method = strcmp(method, methods)[0]
     else:
         try:
-            text2audio(text,method='google',rate=rate, slow=slow, volume=volume, voice=voice,lang=lang,gender=gender,age=age,dir_save=dir_save)
+            text2audio(
+                text,
+                method="google",
+                rate=rate,
+                slow=slow,
+                volume=volume,
+                voice=voice,
+                lang=lang,
+                gender=gender,
+                age=age,
+                dir_save=dir_save,
+            )
         except Exception as e:
             print(e)
-            text2audio(text,method='pyttsx3',rate=rate, slow=slow, volume=volume, voice=voice,lang=lang,gender=gender,age=age,dir_save=dir_save)
-            
-    if method=="pyttsx3":
+            text2audio(
+                text,
+                method="pyttsx3",
+                rate=rate,
+                slow=slow,
+                volume=volume,
+                voice=voice,
+                lang=lang,
+                gender=gender,
+                age=age,
+                dir_save=dir_save,
+            )
+
+    if method == "pyttsx3":
         import pyttsx3
 
         try:
@@ -1140,27 +1266,29 @@ def text2audio(
                 sys.exit()
             except SystemExit:
                 pass
-    elif method.lower() in ['google','gtts']:
+    elif method.lower() in ["google", "gtts"]:
         from gtts import gTTS
+
         try:
             if lang is None:
                 from langdetect import detect
+
                 lang = detect(text)
             # Initialize gTTS with the provided parameters
             tts = gTTS(text=text, lang=lang, slow=slow)
         except Exception as e:
             print(f"An error occurred: {e}")
-        
+
         print("not realtime reading...")
         if dir_save:
             if "." not in dir_save:
-                dir_save=dir_save+".mp3"
+                dir_save = dir_save + ".mp3"
             tts.save(dir_save)
             print(f"Audio saved to {dir_save}")
         else:
             dir_save = "temp_audio.mp3"
             if "." not in dir_save:
-                dir_save=dir_save+".mp3"
+                dir_save = dir_save + ".mp3"
             tts.save(dir_save)
         try:
             fopen(dir_save)
@@ -1624,6 +1752,7 @@ def img2pdf(dir_img, kind=None, page=None, dir_save=None, page_size="a4", dpi=30
     def set_dpi(x):
         dpix = dpiy = x
         return image2pdf.get_fixed_dpi_layout_fun((dpix, dpiy))
+
     if kind is None:
         _, kind = os.path.splitext(dir_img)
     if not kind.startswith("."):
@@ -1649,8 +1778,9 @@ def img2pdf(dir_img, kind=None, page=None, dir_save=None, page_size="a4", dpi=30
             imgs.append(path)
     else:
         imgs = [
-            # os.path.isdir(dir_img), 
-            dir_img]
+            # os.path.isdir(dir_img),
+            dir_img
+        ]
     print(imgs)
     if page_size:
         if isinstance(page_size, str):
@@ -2196,7 +2326,7 @@ def is_df_abnormal(df: pd.DataFrame, verbose=False) -> bool:
     # Check data types
     data_types = df.dtypes
     # messages.append(f"Data types of columns:\n{data_types}")
-    
+
     # Check for an unreasonable number of rows or columns
     if actual_shape[0] < 2 or actual_shape[1] < 2:
         messages.append(
@@ -2347,33 +2477,36 @@ def fload(fpath, kind=None, **kwargs):
 
     def load_csv(fpath, **kwargs):
         from pandas.errors import EmptyDataError
-        engine = kwargs.pop("engine", "pyarrow")# default: None
-        sep = kwargs.pop("sep", None)# default: ','
-        index_col = kwargs.pop("index_col", None)# default: None
-        memory_map = kwargs.pop("memory_map", False)# default: False
-        skipinitialspace = kwargs.pop("skipinitialspace", False)# default: False
-        encoding = kwargs.pop("encoding", "utf-8")# default: "utf-8"
-        on_bad_lines = kwargs.pop("on_bad_lines", "skip")# default: 'error'
-        comment = kwargs.pop("comment", None)# default: None
-        fmt = kwargs.pop("fmt", False)# default: 
-        chunksize = kwargs.pop("chunksize", None)# default: None
-
-        #check filesize
-        f_size=round(os.path.getsize(fpath) / 1024 / 1024, 3)
-        if f_size>=50: #50 MB
+
+        engine = kwargs.pop("engine", "pyarrow")  # default: None
+        sep = kwargs.pop("sep", None)  # default: ','
+        index_col = kwargs.pop("index_col", None)  # default: None
+        memory_map = kwargs.pop("memory_map", False)  # default: False
+        skipinitialspace = kwargs.pop("skipinitialspace", False)  # default: False
+        encoding = kwargs.pop("encoding", "utf-8")  # default: "utf-8"
+        on_bad_lines = kwargs.pop("on_bad_lines", "skip")  # default: 'error'
+        comment = kwargs.pop("comment", None)  # default: None
+        fmt = kwargs.pop("fmt", False)  # default:
+        chunksize = kwargs.pop("chunksize", None)  # default: None
+
+        # check filesize
+        f_size = round(os.path.getsize(fpath) / 1024 / 1024, 3)
+        if f_size >= 50:  # 50 MB
             if chunksize is None:
-                chunksize  = 5000
-                print(f"file size is {f_size}MB, then set the chunksize with {chunksize}")
+                chunksize = 5000
+                print(
+                    f"file size is {f_size}MB, then set the chunksize with {chunksize}"
+                )
         engine = "c" if chunksize else engine  # when chunksize, recommend 'c'
-        low_memory = kwargs.pop("low_memory", True)# default: True
+        low_memory = kwargs.pop("low_memory", True)  # default: True
         low_memory = (
             False if chunksize else True
-        )  # when chunksize, recommend low_memory=False # default: 
+        )  # when chunksize, recommend low_memory=False # default:
         verbose = kwargs.pop("verbose", False)
         if run_once_within(reverse=True) and verbose:
             use_pd("read_csv", verbose=verbose)
 
-        if comment is None:# default: None
+        if comment is None:  # default: None
             comment = get_comment(
                 fpath, comment=None, encoding="utf-8", lines_to_check=5
             )
@@ -2503,7 +2636,9 @@ def fload(fpath, kind=None, **kwargs):
                                 try:
                                     sep2show = sep if sep != "\t" else "\\t"
                                     if verbose:
-                                        print(f"trying with: engine={engine}, sep='{sep2show}'")
+                                        print(
+                                            f"trying with: engine={engine}, sep='{sep2show}'"
+                                        )
                                     # print(".")
                                     df = pd.read_csv(
                                         fpath,
@@ -2524,12 +2659,12 @@ def fload(fpath, kind=None, **kwargs):
                                         if verbose:
                                             (
                                                 display(df.head(2))
-                                                if isinstance(df, pd.DataFrame) 
+                                                if isinstance(df, pd.DataFrame)
                                                 else display("it is not a DataFrame")
                                             )
                                             (
                                                 print(f"shape: {df.shape}")
-                                                if isinstance(df, pd.DataFrame) 
+                                                if isinstance(df, pd.DataFrame)
                                                 else display("it is not a DataFrame")
                                             )
                                         return df
@@ -2663,9 +2798,10 @@ def fload(fpath, kind=None, **kwargs):
         doc = Document(fpath)
         content = [para.text for para in doc.paragraphs]
         return content
-    
+
     def load_rtf(file_path):
         from striprtf.striprtf import rtf_to_text
+
         try:
             with open(file_path, "r") as file:
                 rtf_content = file.read()
@@ -2715,7 +2851,7 @@ def fload(fpath, kind=None, **kwargs):
         "xml",
         "ipynb",
         "mtx",
-        "rtf"
+        "rtf",
     ]
     zip_types = [
         "gz",
@@ -2735,7 +2871,7 @@ def fload(fpath, kind=None, **kwargs):
     if kind not in supported_types:
         print(
             f'Warning:\n"{kind}" is not in the supported list '
-        )  # {supported_types}') 
+        )  # {supported_types}')
 
     if kind == "docx":
         return load_docx(fpath)
@@ -2760,10 +2896,11 @@ def fload(fpath, kind=None, **kwargs):
         if run_once_within(reverse=True) and verbose:
             use_pd("read_pickle")
         try:
-            res_=pd.read_pickle(fpath, **kwargs)
+            res_ = pd.read_pickle(fpath, **kwargs)
         except Exception as e:
             import pickle
-            with open('sgd_classifier.pkl', 'rb') as f:
+
+            with open("sgd_classifier.pkl", "rb") as f:
                 res_ = pickle.load(f)
         return res_
     elif kind in ["ods", "ods", "odt"]:
@@ -2775,21 +2912,34 @@ def fload(fpath, kind=None, **kwargs):
         engine = kwargs.get("engine", "xlrd")
         kwargs.pop("engine", None)
         content = load_excel(fpath, engine=engine, **kwargs)
-        print(f"shape: {content.shape}") if isinstance(content, pd.DataFrame) and verbose else None
+        (
+            print(f"shape: {content.shape}")
+            if isinstance(content, pd.DataFrame) and verbose
+            else None
+        )
         display(content.head(3)) if isinstance(content, pd.DataFrame) else None
         return content
     elif kind == "xlsx":
         verbose = kwargs.pop("verbose", False)
         content = load_excel(fpath, **kwargs)
-        display(content.head(3)) if isinstance(content, pd.DataFrame) and verbose else None
+        (
+            display(content.head(3))
+            if isinstance(content, pd.DataFrame) and verbose
+            else None
+        )
         print(f"shape: {content.shape}") if isinstance(content, pd.DataFrame) else None
         return content
     elif kind == "mtx":
         from scipy.io import mmread
+
         verbose = kwargs.pop("verbose", False)
         dat_mtx = mmread(fpath)
         content = pd.DataFrame.sparse.from_spmatrix(dat_mtx, **kwargs)
-        display(content.head(3)) if isinstance(content, pd.DataFrame) and verbose else None
+        (
+            display(content.head(3))
+            if isinstance(content, pd.DataFrame) and verbose
+            else None
+        )
         print(f"shape: {content.shape}")
         return content
     elif kind == "ipynb":
@@ -2904,34 +3054,34 @@ def fopen(fpath):
     import os
     import platform
     import sys
+
     try:
         # Check if the file exists
         if not os.path.isfile(fpath):
             print(f"Error: The file does not exist - {fpath}")
             return
-        
+
         # Get the system platform
         system = platform.system()
 
         # Platform-specific file opening commands
         if system == "Darwin":  # macOS
-            os.system(f"open \"{fpath}\"")
+            os.system(f'open "{fpath}"')
         elif system == "Windows":  # Windows
             # Ensure the path is handled correctly in Windows, escape spaces
-            os.system(f"start \"\" \"{fpath}\"")
+            os.system(f'start "" "{fpath}"')
         elif system == "Linux":  # Linux
-            os.system(f"xdg-open \"{fpath}\"")
+            os.system(f'xdg-open "{fpath}"')
         elif system == "Java":  # Java (or other unhandled systems)
             print(f"Opening {fpath} on unsupported system.")
         else:
             print(f"Unsupported OS: {system}")
-        
+
         print(f"Successfully opened {fpath} with the default application.")
     except Exception as e:
         print(f"Error opening file {fpath}: {e}")
 
 
-
 def fupdate(fpath, content=None, how="head"):
     """
     Update a file by adding new content at the top and moving the old content to the bottom.
@@ -3346,9 +3496,10 @@ def fsave(
             except Exception as e:
                 try:
                     import pickle
-                    with open(fpath, 'wb') as f:
+
+                    with open(fpath, "wb") as f:
                         pickle.dump(content, f)
-                    print('done!', fpath)
+                    print("done!", fpath)
                 except Exception as e:
                     raise ValueError(
                         f"content is not a DataFrame, cannot be saved as a 'pkl' format: {e}"
@@ -3508,9 +3659,9 @@ def isa(content, kind):
     """
     if "img" in kind.lower() or "image" in kind.lower():
         return is_image(content)
-    elif 'vid' in kind.lower():
+    elif "vid" in kind.lower():
         return is_video(content)
-    elif 'aud' in kind.lower():
+    elif "aud" in kind.lower():
         return is_audio(content)
     elif "doc" in kind.lower():
         return is_document(content)
@@ -3569,8 +3720,8 @@ def get_os(full=False, verbose=False):
     import os
     import subprocess
     from datetime import datetime, timedelta
-    from collections import defaultdict
 
+    
     def get_os_type():
         os_name = sys.platform
         if "dar" in os_name:
@@ -3583,7 +3734,8 @@ def get_os(full=False, verbose=False):
             else:
                 print(f"{os_name}, returned 'None'")
                 return None
-
+    if not full:
+        return get_os_type()
     def get_os_info():
         """Get the detailed OS name, version, and other platform-specific details."""
 
@@ -3755,22 +3907,28 @@ def get_os(full=False, verbose=False):
 
     def get_system_uptime():
         """Returns system uptime as a human-readable string."""
-        boot_time = datetime.fromtimestamp(psutil.boot_time())
-        uptime = datetime.now() - boot_time
-        return str(uptime).split(".")[0]  # Remove microseconds
+        try:
+            boot_time = datetime.fromtimestamp(psutil.boot_time())
+            uptime = datetime.now() - boot_time
+            return str(uptime).split(".")[0]  # Remove microseconds
+        except:
+            return None
 
     def get_active_processes(limit=10):
-        processes = []
-        for proc in psutil.process_iter(
-            ["pid", "name", "cpu_percent", "memory_percent"]
-        ):
-            try:
-                processes.append(proc.info)
-            except psutil.NoSuchProcess:
-                pass
-        # Handle NoneType values by treating them as 0
-        processes.sort(key=lambda x: x["cpu_percent"] or 0, reverse=True)
-        return processes[:limit]
+        try:
+            processes = []
+            for proc in psutil.process_iter(
+                ["pid", "name", "cpu_percent", "memory_percent"]
+            ):
+                try:
+                    processes.append(proc.info)
+                except psutil.NoSuchProcess:
+                    pass
+            # Handle NoneType values by treating them as 0
+            processes.sort(key=lambda x: x["cpu_percent"] or 0, reverse=True)
+            return processes[:limit]
+        except:
+            return None
 
     def get_virtual_environment_info():
         """Checks if the script is running in a virtual environment and returns details."""
@@ -3801,19 +3959,22 @@ def get_os(full=False, verbose=False):
 
     def get_battery_status():
         """Returns battery status."""
-        battery = psutil.sensors_battery()
-        if battery:
-            time_left = (
-                str(timedelta(seconds=battery.secsleft))
-                if battery.secsleft != psutil.POWER_TIME_UNLIMITED
-                else "Charging/Unlimited"
-            )
-            return {
-                "Percentage": battery.percent,
-                "Plugged In": battery.power_plugged,
-                "Time Left": time_left,
-            }
-        return {"Status": "No battery detected"}
+        try:
+            battery = psutil.sensors_battery()
+            if battery:
+                time_left = (
+                    str(timedelta(seconds=battery.secsleft))
+                    if battery.secsleft != psutil.POWER_TIME_UNLIMITED
+                    else "Charging/Unlimited"
+                )
+                return {
+                    "Percentage": battery.percent,
+                    "Plugged In": battery.power_plugged,
+                    "Time Left": time_left,
+                }
+            return {"Status": "No battery detected"}
+        except:
+            return {"Status": "No battery detected"}
 
     def get_disk_io():
         """Returns disk I/O statistics."""
@@ -3899,8 +4060,8 @@ def get_os(full=False, verbose=False):
         "network": {},
         "network io": get_network_io(),
         "gpu": [],
-        "temperatures": get_temperatures(),
-        "battery": get_battery_status(),
+        # "temperatures": get_temperatures(),
+        # "battery": get_battery_status(),
         "active processes": get_active_processes(),
         "environment": {
             "user": os.getenv("USER", "Unknown"),
@@ -3984,27 +4145,26 @@ def get_os(full=False, verbose=False):
             pnrint(e)
     return res
 
-import re
-import stat
-import platform
+
 def listdir(
     rootdir,
     kind=None,
     sort_by="name",
     ascending=True,
-    contains=None,# filter filenames using re
-    booster=False,# walk in subfolders
-    depth = 0, # 0: no subfolders; None: all subfolders; [int 1,2,3]: levels of subfolders 
+    contains=None,  # filter filenames using re
+    booster=False,  # walk in subfolders
+    depth=0,  # 0: no subfolders; None: all subfolders; [int 1,2,3]: levels of subfolders
     hidden=False,  # Include hidden files/folders
     orient="list",
     output="df",  # "df", 'list','dict','records','index','series'
     verbose=True,
-):  
+):
     def is_hidden(filepath):
         """Check if a file or folder is hidden."""
         system = platform.system()
         if system == "Windows":
             import ctypes
+
             attribute = ctypes.windll.kernel32.GetFileAttributesW(filepath)
             if attribute == -1:
                 raise FileNotFoundError(f"File {filepath} not found.")
@@ -4019,6 +4179,7 @@ def listdir(
             return os.environ.get("USERNAME", "Unknown")
         else:
             import pwd
+
             return pwd.getpwuid(os.getuid()).pw_name
 
     if isinstance(kind, list):
@@ -4030,7 +4191,7 @@ def listdir(
                 sort_by=sort_by,
                 ascending=ascending,
                 contains=contains,
-                depth=depth,# walk in subfolders
+                depth=depth,  # walk in subfolders
                 hidden=hidden,
                 orient=orient,
                 output=output,
@@ -4046,21 +4207,21 @@ def listdir(
     i = 0
     f = {
         "name": [],
-        'kind':[],
+        "kind": [],
         "length": [],
-        "basename":[],
+        "basename": [],
         "path": [],
         "created_time": [],
         "modified_time": [],
         "last_open_time": [],
         "size": [],
-        "permission":[],
-        "owner":[],
-        "rootdir":[],
+        "permission": [],
+        "owner": [],
+        "rootdir": [],
         "fname": [],
         "fpath": [],
-        "num":[],
-        "os":[]
+        "num": [],
+        "os": [],
     }
     root_depth = rootdir.rstrip(os.sep).count(os.sep)
     for dirpath, dirnames, ls in os.walk(rootdir):
@@ -4069,30 +4230,32 @@ def listdir(
         if depth is not None and current_depth > depth:
             dirnames[:] = []  # Prevent further traversal into subfolders
             continue
-        
+
         if not hidden:
-            dirnames[:] = [d for d in dirnames if not is_hidden(os.path.join(dirpath, d))]
+            dirnames[:] = [
+                d for d in dirnames if not is_hidden(os.path.join(dirpath, d))
+            ]
             ls = [i for i in ls if not is_hidden(os.path.join(dirpath, i))]
 
         for dirname in dirnames:
-            if kind is not None and kind not in fd: # do not check folders
+            if kind is not None and kind not in fd:  # do not check folders
                 continue
             if contains and not re.search(contains, dirname):
                 continue
             dirname_path = os.path.join(dirpath, dirname)
-            fpath = os.path.join(os.path.dirname(dirname_path), dirname) 
+            fpath = os.path.join(os.path.dirname(dirname_path), dirname)
             try:
                 stats_file = os.stat(fpath)
             except Exception as e:
                 print(e)
                 continue
             filename, file_extension = os.path.splitext(dirname)
-            file_extension = file_extension if file_extension!='' else None
+            file_extension = file_extension if file_extension != "" else None
             f["name"].append(filename)
-            f['kind'].append(file_extension)
+            f["kind"].append(file_extension)
             f["length"].append(len(filename))
             f["size"].append(round(os.path.getsize(fpath) / 1024 / 1024, 3))
-            f['basename'].append(os.path.basename(dirname_path))
+            f["basename"].append(os.path.basename(dirname_path))
             f["path"].append(os.path.join(os.path.dirname(dirname_path), dirname))
             f["created_time"].append(
                 pd.to_datetime(int(os.path.getctime(dirname_path)), unit="s")
@@ -4110,7 +4273,7 @@ def listdir(
             f["fpath"].append(fpath)  # will be removed
             i += 1
         for item in ls:
-            if kind in fd:# only check folders
+            if kind in fd:  # only check folders
                 continue
             if contains and not re.search(contains, item):
                 continue
@@ -4127,7 +4290,16 @@ def listdir(
                 is_file = kind.lower() in file_extension.lower() and (
                     os.path.isfile(item_path)
                 )
-                if kind in [".doc", ".img", ".zip",".code",".file",".image",".video",".audio"]:  # 选择大的类别
+                if kind in [
+                    ".doc",
+                    ".img",
+                    ".zip",
+                    ".code",
+                    ".file",
+                    ".image",
+                    ".video",
+                    ".audio",
+                ]:  # 选择大的类别
                     if kind != ".folder" and not isa(item_path, kind):
                         continue
                 elif kind in [".all"]:
@@ -4135,13 +4307,13 @@ def listdir(
                 else:  # 精确到文件的后缀
                     if not is_folder and not is_file:
                         continue
-            file_extension = file_extension if file_extension!='' else None
+            file_extension = file_extension if file_extension != "" else None
             f["name"].append(filename)
-            f['kind'].append(file_extension)
+            f["kind"].append(file_extension)
             f["length"].append(len(filename))
             f["size"].append(round(os.path.getsize(fpath) / 1024 / 1024, 3))
-            f['basename'].append(os.path.basename(item_path))
-            f["path"].append(os.path.join(os.path.dirname(item_path), item)) 
+            f["basename"].append(os.path.basename(item_path))
+            f["path"].append(os.path.join(os.path.dirname(item_path), item))
             f["created_time"].append(
                 pd.to_datetime(int(os.path.getctime(item_path)), unit="s")
             )
@@ -4152,7 +4324,9 @@ def listdir(
                 pd.to_datetime(int(os.path.getatime(item_path)), unit="s")
             )
             f["permission"].append(stat.filemode(stats_file.st_mode)),
-            f["owner"].append(os.getlogin() if platform.system() != "Windows" else "N/A"),
+            f["owner"].append(
+                os.getlogin() if platform.system() != "Windows" else "N/A"
+            ),
             f["fname"].append(filename)  # will be removed
             f["fpath"].append(fpath)  # will be removed
             f["rootdir"].append(dirpath)
@@ -4162,11 +4336,28 @@ def listdir(
         f["os"] = get_os()  # os.uname().machine
         # if not booster: # go deeper subfolders
         #     break
-    #* convert to pd.DataFrame
+    # * convert to pd.DataFrame
     f = pd.DataFrame(f)
-    f=f[["basename","name","kind","length","size","num","path","created_time",
-        "modified_time","last_open_time","rootdir",
-        "permission","owner","os","fname","fpath",]]
+    f = f[
+        [
+            "basename",
+            "name",
+            "kind",
+            "length",
+            "size",
+            "num",
+            "path",
+            "created_time",
+            "modified_time",
+            "last_open_time",
+            "rootdir",
+            "permission",
+            "owner",
+            "os",
+            "fname",
+            "fpath",
+        ]
+    ]
     if "nam" in sort_by.lower():
         f = sort_kind(f, by="name", ascending=ascending)
     elif "crea" in sort_by.lower():
@@ -4183,6 +4374,7 @@ def listdir(
         return f
     else:
         from box import Box
+
         if "l" in orient.lower():  # list # default
             res_output = Box(f.to_dict(orient="list"))
             return res_output
@@ -4195,6 +4387,7 @@ def listdir(
         if "se" in orient.lower():  # records
             return Box(f.to_dict(orient="series"))
 
+
 def listfunc(lib_name, opt="call"):
     if opt == "call":
         funcs = [func for func in dir(lib_name) if callable(getattr(lib_name, func))]
@@ -4206,6 +4399,7 @@ def listfunc(lib_name, opt="call"):
 def func_list(lib_name, opt="call"):
     return list_func(lib_name, opt=opt)
 
+
 def copy(src, dst, overwrite=False):
     """Copy a file from src to dst."""
     try:
@@ -4223,25 +4417,31 @@ def copy(src, dst, overwrite=False):
                 if overwrite:
                     dst.unlink()
                 else:
-                    dst = dst.with_name(f"{dst.stem}_{datetime.now().strftime('_%H%M%S')}{dst.suffix}")
+                    dst = dst.with_name(
+                        f"{dst.stem}_{datetime.now().strftime('_%H%M%S')}{dst.suffix}"
+                    )
             shutil.copy(src, dst)
             print(f"\n Done! copy to {dst}\n")
         else:
-            dst = dst/src.name
+            dst = dst / src.name
             if dst.exists():
                 if overwrite:
                     shutil.rmtree(dst)  # Remove existing directory
                 else:
-                    dst = dst.with_name(f"{dst.stem}_{datetime.now().strftime('%H%M%S')}")
+                    dst = dst.with_name(
+                        f"{dst.stem}_{datetime.now().strftime('%H%M%S')}"
+                    )
             shutil.copytree(src, dst)
             print(f"\n Done! copy to {dst}\n")
 
     except Exception as e:
         logging.error(f"Failed {e}")
-        
+
+
 def cut(src, dst, overwrite=False):
     return move(src=src, dst=dst, overwrite=overwrite)
 
+
 def move(src, dst, overwrite=False):
     try:
         dir_par_dst = os.path.dirname(dst)
@@ -4256,23 +4456,26 @@ def move(src, dst, overwrite=False):
                 # dst.unlink()  # Delete the existing file
                 pass
             else:
-                dst = dst.with_name(f"{dst.stem}_{datetime.now().strftime('_%H%M%S')}{dst.suffix}")
+                dst = dst.with_name(
+                    f"{dst.stem}_{datetime.now().strftime('_%H%M%S')}{dst.suffix}"
+                )
         shutil.move(src, dst)
         print(f"\n Done! moved to {dst}\n")
     except Exception as e:
         logging.error(f"Failed to move file from {src} to {dst}: {e}")
-        
+
+
 def delete(fpath):
-    """Delete a file/folder.""" 
+    """Delete a file/folder."""
     try:
         fpath = Path(fpath)
-        if not fpath.is_dir(): # file
+        if not fpath.is_dir():  # file
             if fpath.exists():
                 fpath.unlink()
                 print(f"\n Done! delete {fpath}\n")
             else:
                 print(f"File '{fpath}' does not exist.")
-        else:#folder
+        else:  # folder
             if fpath.exists():
                 shutil.rmtree(fpath)  # Remove existing directory
                 print(f"\n Done! delete {fpath}\n")
@@ -4280,27 +4483,31 @@ def delete(fpath):
                 print(f"Folder '{fpath}' does not exist.")
     except Exception as e:
         logging.error(f"Failed to delete {fpath}: {e}")
+
+
 def rename(fpath, dst, smart=True):
     """Rename a file or folder."""
     try:
-        src_kind,dst_kind = None,None
+        src_kind, dst_kind = None, None
         if smart:
-            dir_name_src=os.path.dirname(fpath)
-            dir_name_dst=os.path.dirname(dst)
-            src_kind=os.path.splitext(fpath)[1]
-            dst_kind=os.path.splitext(dst)[1]
-            if dir_name_dst!=dir_name_src:
-                dst=os.path.join(dir_name_src,dst)
+            dir_name_src = os.path.dirname(fpath)
+            dir_name_dst = os.path.dirname(dst)
+            src_kind = os.path.splitext(fpath)[1]
+            dst_kind = os.path.splitext(dst)[1]
+            if dir_name_dst != dir_name_src:
+                dst = os.path.join(dir_name_src, dst)
             if dst_kind is not None and src_kind is not None:
-                if dst_kind!=src_kind:
-                    dst=dst + src_kind
+                if dst_kind != src_kind:
+                    dst = dst + src_kind
         if os.path.exists(fpath):
-            os.rename(fpath,dst)
+            os.rename(fpath, dst)
             print(f"Done! rename to {dst}")
         else:
             print(f"Failed: {fpath} does not exist.")
     except Exception as e:
         logging.error(f"Failed to rename {fpath} to {dst}: {e}")
+
+
 def mkdir_nest(fpath: str) -> str:
     """
     Create nested directories based on the provided file path.
@@ -4319,9 +4526,13 @@ def mkdir_nest(fpath: str) -> str:
     dir_parts = fpath.split(f_slash)  # Split the path by the OS-specific separator
 
     # Start creating directories from the root to the desired path
-    root_dir = os.path.splitdrive(fpath)[0]  # Get the root drive on Windows (e.g., 'C:')
-    current_path = root_dir if root_dir else f_slash  # Start from the root directory or POSIX '/'
-    
+    root_dir = os.path.splitdrive(fpath)[
+        0
+    ]  # Get the root drive on Windows (e.g., 'C:')
+    current_path = (
+        root_dir if root_dir else f_slash
+    )  # Start from the root directory or POSIX '/'
+
     for part in dir_parts:
         if part:
             current_path = os.path.join(current_path, part)
@@ -4346,7 +4557,7 @@ def mkdir(pardir: str = None, chdir: str | list = None, overwrite=False):
     - str: The path of the created directory or an error message.
     """
     rootdir = []
-    pardir= mkdir_nest(pardir)
+    pardir = mkdir_nest(pardir)
     if chdir is None:
         return pardir
     else:
@@ -4465,6 +4676,7 @@ def figsave(*args, dpi=300):
                 img.save(fname, format=ftype.upper(), dpi=(dpi, dpi))
             elif isinstance(img, np.ndarray):
                 import cv2
+
                 # Check the shape of the image to determine color mode
                 if img.ndim == 2:
                     # Grayscale image
@@ -4496,8 +4708,13 @@ def figsave(*args, dpi=300):
                     )
         else:
             plt.savefig(
-                fname, format=ftype.lower(), dpi=dpi, bbox_inches="tight", transparent=True,pad_inches=0
-            ) 
+                fname,
+                format=ftype.lower(),
+                dpi=dpi,
+                bbox_inches="tight",
+                transparent=True,
+                pad_inches=0,
+            )
     elif ftype.lower() == "emf":
         plt.savefig(fname, format="emf", dpi=dpi, bbox_inches="tight", pad_inches=0)
     elif ftype.lower() == "fig":
@@ -4534,6 +4751,7 @@ def is_num(s):
 def isnum(s):
     return is_num(s)
 
+
 def is_image(fpath):
     """
     Determine if a given file is an image based on MIME type and file extension.
@@ -4544,37 +4762,60 @@ def is_image(fpath):
     Returns:
         bool: True if the file is a recognized image, False otherwise.
     """
-    import mimetypes
-    # Known image MIME types
-    image_mime_types = {
-        "image/jpeg",
-        "image/png",
-        "image/gif",
-        "image/bmp",
-        "image/webp",
-        "image/tiff",
-        "image/x-icon",
-        "image/svg+xml",
-        "image/heic",
-        "image/heif",
-    }
+    from PIL import Image
+    if isinstance(fpath,str):
+        import mimetypes
+
+        # Known image MIME types
+        image_mime_types = {
+            "image/jpeg",
+            "image/png",
+            "image/gif",
+            "image/bmp",
+            "image/webp",
+            "image/tiff",
+            "image/x-icon",
+            "image/svg+xml",
+            "image/heic",
+            "image/heif",
+        }
 
-    # Known image file extensions
-    image_extensions = {
-        ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".tif", ".tiff", 
-        ".ico", ".svg", ".heic", ".heif",".fig",".jpg"
-    }
+        # Known image file extensions
+        image_extensions = {
+            ".jpg",
+            ".jpeg",
+            ".png",
+            ".gif",
+            ".bmp",
+            ".webp",
+            ".tif",
+            ".tiff",
+            ".ico",
+            ".svg",
+            ".heic",
+            ".heif",
+            ".fig",
+            ".jpg",
+        }
 
-    # Get MIME type using mimetypes
-    mime_type, _ = mimetypes.guess_type(fpath)
+        # Get MIME type using mimetypes
+        mime_type, _ = mimetypes.guess_type(fpath)
 
-    # Check MIME type
-    if mime_type in image_mime_types:
-        return True
+        # Check MIME type
+        if mime_type in image_mime_types:
+            return True
 
-    # Fallback: Check file extension
-    ext = os.path.splitext(fpath)[-1].lower()  # Get the file extension and ensure lowercase
-    if ext in image_extensions:
+        # Fallback: Check file extension
+        ext = os.path.splitext(fpath)[
+            -1
+        ].lower()  # Get the file extension and ensure lowercase
+        if ext in image_extensions:
+            return True
+
+        return False
+
+    elif isinstance(fpath, Image.Image):
+        # If the input is a PIL Image object
         return True
 
     return False
@@ -4590,6 +4831,7 @@ def is_video(fpath):
         bool: True if the file is a recognized video, False otherwise.
     """
     import mimetypes
+
     # Known video MIME types
     video_mime_types = {
         "video/mp4",
@@ -4610,8 +4852,22 @@ def is_video(fpath):
 
     # Known video file extensions
     video_extensions = {
-        ".mp4", ".mov", ".avi", ".mkv", ".flv", ".webm", ".ogv", ".wmv", 
-        ".mpg", ".mpeg", ".3gp", ".mpeg2", ".asf", ".ts", ".m4v", ".divx",
+        ".mp4",
+        ".mov",
+        ".avi",
+        ".mkv",
+        ".flv",
+        ".webm",
+        ".ogv",
+        ".wmv",
+        ".mpg",
+        ".mpeg",
+        ".3gp",
+        ".mpeg2",
+        ".asf",
+        ".ts",
+        ".m4v",
+        ".divx",
     }
 
     # Get MIME type using mimetypes
@@ -4622,12 +4878,15 @@ def is_video(fpath):
         return True
 
     # Fallback: Check file extension
-    ext = os.path.splitext(fpath)[-1].lower()  # Get the file extension and ensure lowercase
+    ext = os.path.splitext(fpath)[
+        -1
+    ].lower()  # Get the file extension and ensure lowercase
     if ext in video_extensions:
         return True
 
     return False
 
+
 def is_document(fpath):
     """
     Determine if a given file is a document based on MIME type and file extension.
@@ -4639,6 +4898,7 @@ def is_document(fpath):
         bool: True if the file is a recognized document, False otherwise.
     """
     import mimetypes
+
     # Define known MIME types for documents
     document_mime_types = {
         "text/",
@@ -4679,18 +4939,23 @@ def is_document(fpath):
 
     # Get MIME type
     mime_type, _ = mimetypes.guess_type(fpath)
-    
+
     # Check MIME type
-    if mime_type and any(mime_type.startswith(doc_type) for doc_type in document_mime_types):
+    if mime_type and any(
+        mime_type.startswith(doc_type) for doc_type in document_mime_types
+    ):
         return True
 
     # Fallback: Check file extension
-    ext = os.path.splitext(fpath)[-1].lower()  # Get the extension, ensure it's lowercase
+    ext = os.path.splitext(fpath)[
+        -1
+    ].lower()  # Get the extension, ensure it's lowercase
     if ext in document_extensions:
         return True
 
     return False
 
+
 def is_audio(fpath):
     """
     Determine if a given file is an audio file based on MIME type and file extension.
@@ -4702,6 +4967,7 @@ def is_audio(fpath):
         bool: True if the file is a recognized audio file, False otherwise.
     """
     import mimetypes
+
     # Known audio MIME types
     audio_mime_types = {
         "audio/mpeg",
@@ -4720,8 +4986,19 @@ def is_audio(fpath):
 
     # Known audio file extensions
     audio_extensions = {
-        ".mp3", ".wav", ".ogg", ".aac", ".flac", ".midi", ".m4a", 
-        ".aiff", ".pcm", ".wma", ".ape", ".alac", ".opus",
+        ".mp3",
+        ".wav",
+        ".ogg",
+        ".aac",
+        ".flac",
+        ".midi",
+        ".m4a",
+        ".aiff",
+        ".pcm",
+        ".wma",
+        ".ape",
+        ".alac",
+        ".opus",
     }
 
     # Get MIME type using mimetypes
@@ -4732,12 +5009,15 @@ def is_audio(fpath):
         return True
 
     # Fallback: Check file extension
-    ext = os.path.splitext(fpath)[-1].lower()  # Get the file extension and ensure lowercase
+    ext = os.path.splitext(fpath)[
+        -1
+    ].lower()  # Get the file extension and ensure lowercase
     if ext in audio_extensions:
         return True
 
     return False
 
+
 def is_code(fpath):
     """
     Determine if a given file is a code file based on file extension and optionally MIME type.
@@ -4751,16 +5031,37 @@ def is_code(fpath):
     """
     # Known programming and scripting file extensions
     code_extensions = {
-        ".m", ".py", ".ipynb", ".js", ".html", ".css", ".java", ".cpp", ".h", ".cs", ".go", 
-        ".rs", ".sh", ".rb", ".swift", ".ts", ".json", ".xml", ".yaml", ".toml", ".bash", ".r"
+        ".m",
+        ".py",
+        ".ipynb",
+        ".js",
+        ".html",
+        ".css",
+        ".java",
+        ".cpp",
+        ".h",
+        ".cs",
+        ".go",
+        ".rs",
+        ".sh",
+        ".rb",
+        ".swift",
+        ".ts",
+        ".json",
+        ".xml",
+        ".yaml",
+        ".toml",
+        ".bash",
+        ".r",
     }
 
     # Check file extension
-    ext = os.path.splitext(fpath)[-1].lower() 
+    ext = os.path.splitext(fpath)[-1].lower()
     if ext in code_extensions:
-        return True 
+        return True
     return False
-    
+
+
 def is_zip(fpath):
     import mimetypes
 
@@ -4828,6 +5129,105 @@ def str2list(str_):
     [l.append(x) for x in str_]
     return l
 
+def str2words(content, method="combined", custom_dict=None, sym_spell_params=None, use_threading=True):
+    """
+    Ultimate text correction function supporting multiple methods,
+    lists or strings, and domain-specific corrections.
+
+    Parameters:
+        content (str or list): Input text or list of strings to correct.
+        method (str): Correction method ('textblob', 'sym', 'combined').
+        custom_dict (dict): Custom dictionary for domain-specific corrections.
+        sym_spell_params (dict): Parameters for initializing SymSpell.
+
+    Returns:
+        str or list: Corrected text or list of corrected strings.
+    """
+    from textblob import TextBlob
+    from symspellpy import SymSpell, Verbosity
+    from functools import lru_cache
+    import pkg_resources
+    from concurrent.futures import ThreadPoolExecutor
+
+    def initialize_symspell(max_edit_distance=2, prefix_length=7):
+        """Initialize SymSpell for advanced spelling correction."""
+        sym_spell = SymSpell(max_edit_distance, prefix_length)
+        dictionary_path = pkg_resources.resource_filename(
+            "symspellpy",
+            # "frequency_bigramdictionary_en_243_342.txt",
+            "frequency_dictionary_en_82_765.txt",
+        )
+
+        sym_spell.load_dictionary(dictionary_path, term_index=0, count_index=1)
+        return sym_spell
+
+    def segment_words(text, sym_spell):
+        """Segment concatenated words into separate words."""
+        segmented = sym_spell.word_segmentation(text)
+        return segmented.corrected_string
+    
+    @lru_cache(maxsize=1000)  # Cache results for repeated corrections
+    def advanced_correction(word, sym_spell):
+        """Correct a single word using SymSpell."""
+        suggestions = sym_spell.lookup(word, Verbosity.CLOSEST, max_edit_distance=2)
+        return suggestions[0].term if suggestions else word
+
+    def apply_custom_corrections(word, custom_dict):
+        """Apply domain-specific corrections using a custom dictionary."""
+        return custom_dict.get(word.lower(), word)
+    def preserve_case(original_word, corrected_word):
+        """
+        Preserve the case of the original word in the corrected word.
+        """
+        if original_word.isupper():
+            return corrected_word.upper()
+        elif original_word[0].isupper():
+            return corrected_word.capitalize()
+        else:
+            return corrected_word.lower()
+    def process_string(text, method, sym_spell=None, custom_dict=None):
+        """
+        Process a single string for spelling corrections.
+        Handles TextBlob, SymSpell, and custom corrections.
+        """
+        if method in ("sym", "combined") and sym_spell:
+            text = segment_words(text, sym_spell)
+
+        if method in ("textblob", "combined"):
+            text = str(TextBlob(text).correct())
+
+        corrected_words = []
+        for word in text.split():
+            original_word = word
+            if method in ("sym", "combined") and sym_spell:
+                word = advanced_correction(word, sym_spell)
+
+            # Step 3: Apply custom corrections
+            if custom_dict:
+                word = apply_custom_corrections(word, custom_dict)
+            # Preserve original case
+            word = preserve_case(original_word, word)
+            corrected_words.append(word)
+
+        return " ".join(corrected_words)
+
+    # Initialize SymSpell if needed
+    sym_spell = None
+    if method in ("sym", "combined"):
+        if not sym_spell_params:
+            sym_spell_params = {"max_edit_distance": 2, "prefix_length": 7}
+        sym_spell = initialize_symspell(**sym_spell_params)
+
+    # Process lists or strings
+    if isinstance(content, list):
+        if use_threading:
+            with ThreadPoolExecutor() as executor:
+                corrected_content = list(executor.map(lambda x: process_string(x, method, sym_spell, custom_dict), content))
+            return corrected_content
+        else:
+            return [process_string(item, method, sym_spell, custom_dict) for item in content]
+    else:
+        return process_string(content, method, sym_spell, custom_dict)
 
 def load_img(fpath):
     """
@@ -4851,7 +5251,7 @@ def load_img(fpath):
         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, *args,verbose=True):
     # def apply_filter(img, filter_name, filter_value=None):
     """
     Apply the specified filter to the image.
@@ -4865,7 +5265,7 @@ def apply_filter(img, *args):
     from PIL import ImageFilter
 
     def correct_filter_name(filter_name):
-        if "bl" in filter_name.lower() and "box" not in filter_name.lower():
+        if all(["b" in filter_name.lower(),"ur" in filter_name.lower(), "box" not in filter_name.lower()]):
             return "BLUR"
         elif "cont" in filter_name.lower():
             return "Contour"
@@ -4929,10 +5329,11 @@ def apply_filter(img, *args):
 
     for arg in args:
         if isinstance(arg, str):
-            filter_name = arg
-            filter_name = correct_filter_name(filter_name)
+            filter_name = correct_filter_name(arg)
         else:
             filter_value = arg
+    if verbose:
+        print(f'processing {filter_name}')
     filter_name = filter_name.upper()  # Ensure filter name is uppercase
 
     # Supported filters
@@ -4976,12 +5377,13 @@ def apply_filter(img, *args):
         bands = filter_value if filter_value is not None else None
         return img.filter(supported_filters[filter_name](bands))
     else:
-        if filter_value is not None:
+        if filter_value is not None and verbose:
             print(
                 f"{filter_name} doesn't require a value for {filter_value}, but it remains unaffected"
             )
         return img.filter(supported_filters[filter_name])
 
+
 def detect_angle(image, by="median", template=None):
     """Detect the angle of rotation using various methods."""
     from sklearn.decomposition import PCA
@@ -4989,8 +5391,11 @@ def detect_angle(image, by="median", template=None):
     from skimage.color import rgb2gray
     from scipy.fftpack import fftshift, fft2
     import numpy as np
-    import cv2 
+    import cv2
+
     # Convert to grayscale
+    if np.array(image).shape[-1]>3:
+        image=np.array(image)[:,:,:3]
     gray_image = rgb2gray(image)
 
     # Detect edges using Canny edge detector
@@ -5002,9 +5407,10 @@ def detect_angle(image, by="median", template=None):
     if not lines and any(["me" in by, "pca" in by]):
         print("No lines detected. Adjust the edge detection parameters.")
         return 0
-
+    methods=['mean','median','pca','gradient orientation','template matching','moments','fft']
+    by=strcmp(by, methods)[0]
     # Hough Transform-based angle detection (Median/Mean)
-    if "me" in by:
+    if "me" in by.lower():
         angles = []
         for line in lines:
             (x0, y0), (x1, y1) = line
@@ -5027,7 +5433,7 @@ def detect_angle(image, by="median", template=None):
             return rotation_angle
 
     # PCA-based angle detection
-    elif "pca" in by:
+    elif "pca" in by.lower():
         y, x = np.nonzero(edges)
         if len(x) == 0:
             return 0
@@ -5037,14 +5443,14 @@ def detect_angle(image, by="median", template=None):
         return angle
 
     # Gradient Orientation-based angle detection
-    elif "gra" in by:
+    elif "gra" in by.lower():
         gx, gy = np.gradient(gray_image)
         angles = np.arctan2(gy, gx) * 180 / np.pi
         hist, bin_edges = np.histogram(angles, bins=360, range=(-180, 180))
         return bin_edges[np.argmax(hist)]
 
     # Template Matching-based angle detection
-    elif "temp" in by:
+    elif "temp" in by.lower():
         if template is None:
             # Automatically extract a template from the center of the image
             height, width = gray_image.shape
@@ -5067,7 +5473,7 @@ def detect_angle(image, by="median", template=None):
         return best_angle
 
     # Image Moments-based angle detection
-    elif "mo" in by:
+    elif "mo" in by.lower():
         moments = measure.moments_central(gray_image)
         angle = (
             0.5
@@ -5078,7 +5484,7 @@ def detect_angle(image, by="median", template=None):
         return angle
 
     # Fourier Transform-based angle detection
-    elif "fft" in by:
+    elif "fft" in by.lower():
         f = fft2(gray_image)
         fshift = fftshift(f)
         magnitude_spectrum = np.log(np.abs(fshift) + 1)
@@ -5088,10 +5494,19 @@ def detect_angle(image, by="median", template=None):
         return angle
 
     else:
-        print(f"Unknown method {by}")
+        print(f"Unknown method {by}: supported methods: {methods}")
         return 0
 
-def imgsets(img, **kwargs):
+
+def imgsets(img, 
+            auto:bool=True,
+            size=None,
+            figsize=None,
+            dpi:int=200,
+            show_axis:bool=False,
+            plot_:bool=True,
+            verbose:bool=False,
+            **kwargs):
     """
     Apply various enhancements and filters to an image using PIL's ImageEnhance and ImageFilter modules.
 
@@ -5125,6 +5540,9 @@ def imgsets(img, **kwargs):
     Note:
         The "color" and "enhance" enhancements are not implemented in this function.
     """
+
+    import matplotlib.pyplot as plt
+    from PIL import ImageEnhance, ImageOps,Image
     supported_filters = [
         "BLUR",
         "CONTOUR",
@@ -5144,8 +5562,22 @@ def imgsets(img, **kwargs):
         "BOX_BLUR",
         "MEDIAN_FILTER",
     ]
-    print('usage: imgsets(dir_img, contrast="auto", rm=True, color=2.2)')
-    print("\nlog:\n")
+    str_usage="""
+    imgsets(dir_img, auto=1, color=1.5, plot_=0)
+    imgsets(dir_img, color=2)
+    imgsets(dir_img, pad=(300, 300), bgcolor=(73, 162, 127), plot_=0)
+    imgsets(dir_img, contrast=0, color=1.2, plot_=0)
+    imgsets(get_clip(), flip="tb")# flip top and bottom
+    imgsets(get_clip(), contrast=1, rm=[100, 5, 2]) #'foreground_threshold', 'background_threshold' and 'erode_structure_size'
+    """
+    if run_once_within():
+        print(str_usage)
+
+    def gamma_correction(image, gamma=1.0, v_max=255):
+        # adjust gama value
+        inv_gamma = 1.0 / gamma
+        lut = [int((i / float(v_max)) ** inv_gamma * int(v_max)) for i in range(int(v_max))]
+        return lut #image.point(lut)
 
     def confirm_rembg_models(model_name):
         models_support = [
@@ -5169,37 +5601,52 @@ def imgsets(img, **kwargs):
 
     def auto_enhance(img):
         """
-        Automatically enhances the image based on its characteristics.
+        Automatically enhances the image based on its characteristics, including brightness,
+        contrast, color range, sharpness, and gamma correction.
+
         Args:
             img (PIL.Image): The input image.
+
         Returns:
-            dict: A dictionary containing the optimal enhancement values.
+            dict: A dictionary containing the optimal enhancement values applied.
+            PIL.Image: The enhanced image.
         """
+        from PIL import Image, ImageEnhance, ImageOps, ImageFilter
+        import numpy as np
         # 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)
+        try:
+            if img.mode in ["1", "L", "P", "RGB", "YCbCr", "LAB", "HSV"]:
+                bit_depth = 8
+            elif img.mode in ["RGBA", "CMYK"]:
+                bit_depth = 8
+            elif img.mode in ["I", "F"]:
+                bit_depth = 16
+            else:
+                raise ValueError("Unsupported image mode")
+        except:
             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
+
+        # Initialize enhancement factors
+        enhancements = {
+            "brightness": 1.0,
+            "contrast": 0,# autocontrasted
+            "color": 1.35,
+            "sharpness": 1.0,
+            "gamma": 1.0
+        }
+
+        # Calculate 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
-            )
+            total_pixels = sum(channel_histogram)
+            brightness = sum(i * w for i, w in enumerate(channel_histogram)) / total_pixels
             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
+            normalization_factor = 2**bit_depth - 1
             brightness_factor = (
                 1.0 + (brightness - normalization_factor / 2) / normalization_factor
             )
@@ -5208,37 +5655,62 @@ def imgsets(img, **kwargs):
             )
             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}
 
-    import matplotlib.pyplot as plt
-    from PIL import ImageEnhance, ImageOps
+        # Calculate average brightness and contrast factors across channels
+        enhancements["brightness"] = sum(brightness_factors) / num_channels
+        # Adjust brightness and contrast
+        img = ImageEnhance.Brightness(img).enhance(enhancements["brightness"])
+
+        # # Automatic color enhancement (saturation)
+        # if img.mode == "RGB":
+        #     color_enhancer = ImageEnhance.Color(img)
+        #     color_histogram = np.array(img.histogram()).reshape(3, -1)
+        #     avg_saturation = np.mean([np.std(channel) for channel in color_histogram]) / normalization_factor
+        #     print(avg_saturation)
+        #     enhancements["color"] = min(0, max(0.5, 1.0 + avg_saturation))  # Clamp to a reasonable range
+        #     # img = color_enhancer.enhance(enhancements["color"])
+
+        # Adjust sharpness
+        sharpness_enhancer = ImageEnhance.Sharpness(img)
+        # Use edge detection to estimate sharpness need
+        edges = img.filter(ImageFilter.FIND_EDGES).convert("L")
+        avg_edge_intensity = np.mean(np.array(edges))
+        enhancements["sharpness"] = min(2.0, max(0.5, 1.0 + avg_edge_intensity / normalization_factor))
+        # img = sharpness_enhancer.enhance(enhancements["sharpness"])
+
+        # # Apply gamma correction
+        # def gamma_correction(image, gamma):
+        #     inv_gamma = 1.0 / gamma
+        #     lut = [min(255, max(0, int((i / 255.0) ** inv_gamma * 255))) for i in range(256)]
+        #     return image.point(lut)
+
+        # avg_brightness = np.mean(np.array(img.convert("L"))) / 255
+        # enhancements["gamma"] = min(2.0, max(0.5, 1.0 if avg_brightness > 0.5 else 1.2 - avg_brightness))
+        # img = gamma_correction(img, enhancements["gamma"])
+
+        # Return the enhancements and the enhanced image
+        return enhancements
+
 
     # 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)
+    img_update = img.copy() 
 
     if auto:
         kwargs = {**auto_enhance(img_update), **kwargs}
-
+    params=["sharp","color","contrast","bright","crop","rotate",'size',"resize",
+            "thumbnail","cover","contain","filter","fit","pad",
+            "rem","rm","back","bg_color","cut",'gamma','flip']
     for k, value in kwargs.items():
+        k = strcmp(k, params)[0] # correct the param name
         if "shar" in k.lower():
             enhancer = ImageEnhance.Sharpness(img_update)
             img_update = enhancer.enhance(value)
         elif all(
             ["col" in k.lower(), "bg" not in k.lower(), "background" not in k.lower()]
         ):
+            # *color
             enhancer = ImageEnhance.Color(img_update)
             img_update = enhancer.enhance(value)
         elif "contr" in k.lower():
@@ -5246,8 +5718,11 @@ def imgsets(img, **kwargs):
                 enhancer = ImageEnhance.Contrast(img_update)
                 img_update = enhancer.enhance(value)
             else:
-                print("autocontrasted")
-                img_update = ImageOps.autocontrast(img_update)
+                try:
+                    img_update = ImageOps.autocontrast(img_update)
+                    print("autocontrasted")
+                except Exception as e:
+                    print(f"Failed 'autocontrasted':{e}")
         elif "bri" in k.lower():
             enhancer = ImageEnhance.Brightness(img_update)
             img_update = enhancer.enhance(value)
@@ -5258,7 +5733,13 @@ def imgsets(img, **kwargs):
                 value = detect_angle(img_update, by=value)
                 print(f"rotated by {value}°")
             img_update = img_update.rotate(value)
-
+        elif 'flip' in k.lower():
+            if 'l' in value and 'r' in value:
+                # left/right
+                img_update = img_update.transpose(Image.FLIP_LEFT_RIGHT)
+            elif any(['u' in value and'd' in value, 't' in value and 'b' in value]):
+                # up/down or top/bottom
+                img_update = img_update.transpose(Image.FLIP_TOP_BOTTOM)
         elif "si" in k.lower():
             if isinstance(value, tuple):
                 value = list(value)
@@ -5270,13 +5751,17 @@ def imgsets(img, **kwargs):
             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():
+        elif "fi" in k.lower() and "t" in k.lower(): # filter
             if isinstance(value, dict):
+                if verbose:
+                    print(f"supported filter: {supported_filters}")
                 for filter_name, filter_value in value.items():
-                    img_update = apply_filter(img_update, filter_name, filter_value)
+                    img_update = apply_filter(img_update, filter_name, filter_value,verbose=verbose)
             else:
                 img_update = ImageOps.fit(img_update, size=value)
         elif "pad" in k.lower():
+            # *ImageOps.pad ensures that the resized image has the exact size specified by the size parameter while maintaining the aspect ratio.
+            # size: A tuple specifying the target size (width, height).
             img_update = ImageOps.pad(img_update, size=value)
         elif "rem" in k.lower() or "rm" in k.lower() or "back" in k.lower():
             from rembg import remove, new_session
@@ -5285,7 +5770,9 @@ def imgsets(img, **kwargs):
                 session = new_session("isnet-general-use")
                 img_update = remove(img_update, session=session)
             elif value and isinstance(value, (int, float, list)):
-                print("https://github.com/danielgatis/rembg/blob/main/USAGE.md")
+                if verbose:
+                    print("https://github.com/danielgatis/rembg/blob/main/USAGE.md")
+                    print(f"rm=True # using default setting;\nrm=(240,10,10)\n'foreground_threshold'(240) and 'background_threshold' (10) values used to determine foreground and background pixels. \nThe 'erode_structure_size'(10) parameter specifies the size of the erosion structure to be applied to the mask.")
                 if isinstance(value, int):
                     value = [value]
                 if len(value) < 2:
@@ -5327,8 +5814,11 @@ def imgsets(img, **kwargs):
                 if len(value) == 3:
                     value += (255,)
                 img_update = remove(img_update, bgcolor=value)
+        
+        # elif "ga" in k.lower() and "m" in k.lower():
+        #     img_update = gamma_correction(img_update, gamma=value)
     # Display the image if requested
-    if show:
+    if plot_:
         if figsize is None:
             plt.figure(dpi=dpi)
         else:
@@ -6355,13 +6845,13 @@ def _df_outlier(
     from scipy.stats import zscore
     from sklearn.ensemble import IsolationForest
     from sklearn.preprocessing import StandardScaler
-    
+
     # Fill completely NaN columns with a default value (e.g., 0)
     data = data.copy()
     data.loc[:, data.isna().all()] = 0
     if columns is not None:
-        if isinstance(columns, (list,pd.core.indexes.base.Index)):
-            data=data[columns]
+        if isinstance(columns, (list, pd.core.indexes.base.Index)):
+            data = data[columns]
     col_names_org = data.columns.tolist()
     index_names_org = data.index.tolist()
     # Separate numeric and non-numeric columns
@@ -6527,6 +7017,7 @@ def df_extend(data: pd.DataFrame, column, axis=0, sep=None, prefix="col"):
     data = data.explode(column, ignore_index=True)
     return data
 
+
 def df_cycle(data: pd.DataFrame, columns=None, max_val=None, inplace=False):
     """
     Purpose: transforms a datetime feature (like month or day) into a cyclic encoding for use in machine learning models, particularly neural networks.
@@ -6536,24 +7027,30 @@ def df_cycle(data: pd.DataFrame, columns=None, max_val=None, inplace=False):
         data = df_cycle(data, 'month', 12)
     """
     if columns is None:
-        columns = list(data.select_dtypes(include=np.number).columns)  # If no columns specified, use all columns
+        columns = list(
+            data.select_dtypes(include=np.number).columns
+        )  # If no columns specified, use all columns
     if max_val is None:
-        max_val = np.max(data[columns])  # If no max_val specified, use the maximum value across all columns
+        max_val = np.max(
+            data[columns]
+        )  # If no max_val specified, use the maximum value across all columns
     if isinstance(columns, str):
-        columns = [columns]  # If a single column name is provided as a string, convert it to a list
-    
+        columns = [
+            columns
+        ]  # If a single column name is provided as a string, convert it to a list
+
     # Check if inplace is True, so we modify the original dataframe
     if inplace:
         # Modify the data in place, no return statement needed
         for col in columns:
-            data[col + '_sin'] = np.sin(2 * np.pi * data[col] / max_val)
-            data[col + '_cos'] = np.cos(2 * np.pi * data[col] / max_val)
+            data[col + "_sin"] = np.sin(2 * np.pi * data[col] / max_val)
+            data[col + "_cos"] = np.cos(2 * np.pi * data[col] / max_val)
     else:
         # If inplace is False, return the modified dataframe
         new_data = data.copy()
         for col in columns:
-            new_data[col + '_sin'] = np.sin(2 * np.pi * new_data[col] / max_val)
-            new_data[col + '_cos'] = np.cos(2 * np.pi * new_data[col] / max_val)
+            new_data[col + "_sin"] = np.sin(2 * np.pi * new_data[col] / max_val)
+            new_data[col + "_cos"] = np.cos(2 * np.pi * new_data[col] / max_val)
         return new_data
 
 
@@ -6561,7 +7058,7 @@ def df_cycle(data: pd.DataFrame, columns=None, max_val=None, inplace=False):
 def df_astype(
     data: pd.DataFrame,
     columns: Optional[Union[str, List[str]]] = None,
-    astype: str = None,#"datetime",
+    astype: str = None,  # "datetime",
     skip_row: Union[str, list] = None,
     fmt: Optional[str] = None,
     inplace: bool = False,
@@ -6624,7 +7121,7 @@ def df_astype(
         "day",
         "month",
         "year",
-        "circular"
+        "circular",
     ]
     # If inplace is False, make a copy of the DataFrame
     if not inplace:
@@ -6720,12 +7217,12 @@ def df_astype(
                 data[column] = pd.to_timedelta(data[column], errors=errors, **kwargs)
                 # print(f"Successfully converted '{column}' to timedelta.")
             elif astype == "circular":
-                max_val = kwargs.get('max_val',None)
-                data[column]=df_cycle(data=data,columns=column,max_val=max_val)
+                max_val = kwargs.get("max_val", None)
+                data[column] = df_cycle(data=data, columns=column, max_val=max_val)
             else:
                 # Convert to other types (e.g., float, int)
-                if astype=='int':
-                    data[column] = data[column].astype('float').astype('int')
+                if astype == "int":
+                    data[column] = data[column].astype("float").astype("int")
                 else:
                     data[column] = data[column].astype(astype)
                 # print(f"Successfully converted '{column}' to {astype}.")
@@ -6775,7 +7272,9 @@ def df_sort_values(data, column, by=None, ascending=True, inplace=True, **kwargs
         ).index.tolist()
 
         # Convert to a categorical type with the new order
-        data[column] = pd.Categorical(data[column], categories=sorted_counts, ordered=True)
+        data[column] = pd.Categorical(
+            data[column], categories=sorted_counts, ordered=True
+        )
         # Set ascending to count_ascending for sorting
         ascending = count_ascending  # Adjust ascending for the final sort
     elif isinstance(by, list):
@@ -6977,7 +7476,7 @@ def df_fillna(
     # Fill completely NaN columns with a default value (e.g., 0)
     data = data.copy()
     data.loc[:, data.isna().all()] = 0
-    
+
     col_names_org = data.columns.tolist()
     index_names_org = data.index.tolist()
     # Separate numeric and non-numeric columns
@@ -7034,7 +7533,7 @@ def df_fillna(
         imputed_data = imputer.fit_transform(numeric_data.T)
     else:
         raise ValueError("Invalid axis. Use 0 for columns or 1 for rows.")
- 
+
     imputed_data = pd.DataFrame(
         imputed_data if axis == 0 else imputed_data.T,
         index=numeric_data.index if axis == 0 else numeric_data.columns,
@@ -7179,11 +7678,15 @@ def df_encoder(
 
         encoder = LabelEncoder()
         # Apply LabelEncoder only to non-numeric columns
-        non_numeric_columns = [col for col in columns if not pd.api.types.is_numeric_dtype(data[col])]
+        non_numeric_columns = [
+            col for col in columns if not pd.api.types.is_numeric_dtype(data[col])
+        ]
 
         if not non_numeric_columns:
             return data
-        encoded_data = data[non_numeric_columns].apply(lambda col: encoder.fit_transform(col))
+        encoded_data = data[non_numeric_columns].apply(
+            lambda col: encoder.fit_transform(col)
+        )
         return pd.concat([data.drop(non_numeric_columns, axis=1), encoded_data], axis=1)
 
     # Target encoding (Mean of the target for each category)
@@ -7210,13 +7713,13 @@ def df_scaler(
     scaler=None,
     method="standard",
     columns=None,  # default, select all numeric col/row
-    feature_range=None,# specific for 'minmax'
+    feature_range=None,  # specific for 'minmax'
     vmin=0,
     vmax=1,
     inplace=False,
     verbose=False,  # show usage
     axis=0,  # defalut column-wise
-    return_scaler:bool=False,# True: return both: return df, scaler
+    return_scaler: bool = False,  # True: return both: return df, scaler
     **kwargs,
 ):
     """
@@ -7235,34 +7738,56 @@ def df_scaler(
     if verbose:
         print('df_scaler(data, scaler="standard", inplace=False, axis=0, verbose=True)')
     if scaler is None:
-        methods = ["standard", "minmax", "robust","maxabs"]
+        methods = ["standard", "minmax", "robust", "maxabs"]
         method = strcmp(method, methods)[0]
         if method == "standard":
             from sklearn.preprocessing import StandardScaler
+
             if verbose:
-                print("performs z-score normalization: This will standardize each feature to have a mean of 0 and a standard deviation of 1.")
-                print("Use when the data is approximately normally distributed (Gaussian).\nWorks well with algorithms sensitive to feature distribution, such as SVMs, linear regression, logistic regression, and neural networks.")
+                print(
+                    "performs z-score normalization: This will standardize each feature to have a mean of 0 and a standard deviation of 1."
+                )
+                print(
+                    "Use when the data is approximately normally distributed (Gaussian).\nWorks well with algorithms sensitive to feature distribution, such as SVMs, linear regression, logistic regression, and neural networks."
+                )
             scaler = StandardScaler(**kwargs)
         elif method == "minmax":
             from sklearn.preprocessing import MinMaxScaler
+
             if feature_range is None:
-                feature_range=(vmin,vmax)
+                feature_range = (vmin, vmax)
             if verbose:
-                print("don't forget to define the range: e.g., 'feature_range=(0, 1)'. ")
-                print("scales the features to the range [0, 1]. Adjust feature_range if you want a different range, like [-1, 1].")
-                print("Use when the data does not follow a normal distribution and you need all features in a specific range (e.g., [0, 1]).\nIdeal for algorithms that do not assume a particular distribution, such as k-nearest neighbors and neural networks.")
-            scaler = MinMaxScaler(feature_range=feature_range,**kwargs)
+                print(
+                    "don't forget to define the range: e.g., 'feature_range=(0, 1)'. "
+                )
+                print(
+                    "scales the features to the range [0, 1]. Adjust feature_range if you want a different range, like [-1, 1]."
+                )
+                print(
+                    "Use when the data does not follow a normal distribution and you need all features in a specific range (e.g., [0, 1]).\nIdeal for algorithms that do not assume a particular distribution, such as k-nearest neighbors and neural networks."
+                )
+            scaler = MinMaxScaler(feature_range=feature_range, **kwargs)
         elif method == "robust":
             from sklearn.preprocessing import RobustScaler
+
             if verbose:
-                print("scales the data based on the median and interquartile range, which is robust to outliers.")
-                print("Use when the dataset contains outliers.\nThis method is useful because it scales based on the median and the interquartile range (IQR), which are more robust to outliers than the mean and standard deviation.")
+                print(
+                    "scales the data based on the median and interquartile range, which is robust to outliers."
+                )
+                print(
+                    "Use when the dataset contains outliers.\nThis method is useful because it scales based on the median and the interquartile range (IQR), which are more robust to outliers than the mean and standard deviation."
+                )
             scaler = RobustScaler(**kwargs)
-        elif method=="maxabs":
+        elif method == "maxabs":
             from sklearn.preprocessing import MaxAbsScaler
+
             if verbose:
-                print("This scales each feature by its maximum absolute value, resulting in values within the range [-1, 1] for each feature.")
-                print("Use for data that is already sparse or when features have positive or negative values that need scaling without shifting the data.\nOften used with sparse data (data with many zeros), where preserving zero entries is essential, such as in text data or recommendation systems.")
+                print(
+                    "This scales each feature by its maximum absolute value, resulting in values within the range [-1, 1] for each feature."
+                )
+                print(
+                    "Use for data that is already sparse or when features have positive or negative values that need scaling without shifting the data.\nOften used with sparse data (data with many zeros), where preserving zero entries is essential, such as in text data or recommendation systems."
+                )
             scaler = MaxAbsScaler(**kwargs)
         if axis not in [0, 1]:
             raise ValueError("Axis must be 0 (column-wise) or 1 (row-wise).")
@@ -7275,7 +7800,7 @@ def df_scaler(
         non_numeric_columns = data.columns.difference(columns)
 
         # scaled_data = scaler.fit_transform(data[columns])
-        if scaler is None or not hasattr(scaler, 'mean_'):
+        if scaler is None or not hasattr(scaler, "mean_"):
             scaled_data = scaler.fit_transform(data[columns])
         else:
             scaled_data = scaler.transform(data[columns])
@@ -7293,7 +7818,7 @@ def df_scaler(
             )
             scaled_df = scaled_df[data.columns]  # Maintain column order
             if return_scaler:
-                return scaled_df,scaler
+                return scaled_df, scaler
             else:
                 return scaled_df
 
@@ -7310,7 +7835,11 @@ def df_scaler(
         # scaled_data = scaler.fit_transform(
         #     numeric_rows.T
         # ).T  # Transpose for scaling and then back
-        scaled_data = scaler.fit_transform(numeric_rows.T).T if scaler is None or not hasattr(scaler, 'mean_') else scaler.transform(numeric_rows.T).T
+        scaled_data = (
+            scaler.fit_transform(numeric_rows.T).T
+            if scaler is None or not hasattr(scaler, "mean_")
+            else scaler.transform(numeric_rows.T).T
+        )
 
         if inplace:
             data.loc[numeric_rows.index] = scaled_data
@@ -7319,7 +7848,7 @@ def df_scaler(
             scaled_df = data.copy()
             scaled_df.loc[numeric_rows.index] = scaled_data
             if return_scaler:
-                return scaled_df,scaler
+                return scaled_df, scaler
             else:
                 return scaled_df
 
@@ -7683,10 +8212,10 @@ def df_reducer(
     hue: str = None,  # lda-specific
     scale: bool = True,
     fill_missing: bool = True,
-    size=2,# for plot marker size
-    markerscale=4,# for plot, legend marker size scale
-    edgecolor='none',# for plot, 
-    legend_loc='best',# for plot, 
+    size=2,  # for plot marker size
+    markerscale=4,  # for plot, legend marker size scale
+    edgecolor="none",  # for plot,
+    legend_loc="best",  # for plot,
     bbox_to_anchor=None,
     ncols=1,
     debug: bool = False,
@@ -7719,7 +8248,7 @@ def df_reducer(
         "autoencoder": "Autoencoder:\n\tA neural network-based approach for complex feature learning and non-linear dimensionality reduction. Advantage: Can capture very complex relationships. Limitation: Computationally expensive, requires neural network expertise for effective tuning.",
         "nmf": "Non-negative Matrix Factorization:\n\tEffective for parts-based decomposition, commonly used for sparse and non-negative data, e.g., text data or images. Advantage: Interpretability with non-negativity, efficient with sparse data. Limitation: Less effective for negative or zero-centered data.",
         "umap_hdbscan": "UMAP + HDBSCAN:\n\tCombination of UMAP for dimensionality reduction and HDBSCAN for density-based clustering, suitable for cluster discovery in high-dimensional data. Advantage: Effective in discovering clusters in embeddings. Limitation: Requires careful tuning of both UMAP and HDBSCAN parameters.",
-        "manifold_learning": "Manifold Learning (Isomap, Hessian LLE, etc.):\n\tMethods designed to capture intrinsic geometrical structure. Advantage: Preserves non-linear relationships in low dimensions. Limitation: Computationally expensive and sensitive to noise."
+        "manifold_learning": "Manifold Learning (Isomap, Hessian LLE, etc.):\n\tMethods designed to capture intrinsic geometrical structure. Advantage: Preserves non-linear relationships in low dimensions. Limitation: Computationally expensive and sensitive to noise.",
     }
 
     from sklearn.preprocessing import StandardScaler
@@ -7730,14 +8259,27 @@ def df_reducer(
         import seaborn as sns
     # Check valid method input
     methods = [
-        "pca", "umap",  "umap_hdbscan", "tsne", "factor", "isolation_forest","manifold_learning", "lda", "kpca", "ica",
-        "mds", "lle", "svd", "truncated_svd", "spectral_embedding",
+        "pca",
+        "umap",
+        "umap_hdbscan",
+        "tsne",
+        "factor",
+        "isolation_forest",
+        "manifold_learning",
+        "lda",
+        "kpca",
+        "ica",
+        "mds",
+        "lle",
+        "svd",
+        "truncated_svd",
+        "spectral_embedding",
         # "autoencoder","nmf",
     ]
     method = strcmp(method, methods)[0]
     if run_once_within(reverse=True):
         print(f"support methods:{methods}")
-        
+
     if verbose:
         print(f"\nprocessing with using {dict_methods[method]}:")
     xlabel, ylabel = None, None
@@ -8050,8 +8592,9 @@ def df_reducer(
             svd_df[hue] = y
         if debug:
             print("Singular Value Decomposition (SVD) completed.")
-    elif method=="truncated_svd":
+    elif method == "truncated_svd":
         from sklearn.decomposition import TruncatedSVD
+
         svd = TruncatedSVD(n_components=n_components, random_state=random_state)
         X_reduced = svd.fit_transform(X)
         reduced_df = pd.DataFrame(
@@ -8070,7 +8613,9 @@ def df_reducer(
     elif method == "spectral_embedding":
         from sklearn.manifold import SpectralEmbedding
 
-        spectral = SpectralEmbedding(n_components=n_components, random_state=random_state)
+        spectral = SpectralEmbedding(
+            n_components=n_components, random_state=random_state
+        )
         X_reduced = spectral.fit_transform(X)
         reduced_df = pd.DataFrame(
             X_reduced,
@@ -8168,7 +8713,7 @@ def df_reducer(
             print("Manifold Learning (Isomap) completed.")
         if hue:
             reduced_df[hue] = y
-            
+
     #! Return reduced data and info as a new DataFrame with the same index
     if method == "pca":
         reduced_df = pca_df
@@ -8225,7 +8770,8 @@ def df_reducer(
         colname_met = "SVD_"
     # Quick plots
     if plot_ and (not method in ["isolation_forest"]):
-        from .plot import plotxy,figsets,get_color
+        from .plot import plotxy, figsets, get_color
+
         # if ax is None:
         #     if figsize is None:
         #         _, ax = plt.subplots(figsize=cm2inch(8, 8))
@@ -8235,9 +8781,9 @@ def df_reducer(
         #     ax = ax.cla()
         xlabel = f"{colname_met}1" if xlabel is None else xlabel
         ylabel = f"{colname_met}2" if ylabel is None else ylabel
-        palette=get_color(len(flatten(data[hue],verbose=0)))
+        palette = get_color(len(flatten(data[hue], verbose=0)))
 
-        reduced_df=reduced_df.sort_values(by=hue)
+        reduced_df = reduced_df.sort_values(by=hue)
         print(flatten(reduced_df[hue]))
         ax = plotxy(
             data=reduced_df,
@@ -8247,24 +8793,31 @@ def df_reducer(
             palette=palette,
             # size=size,
             edgecolor=edgecolor,
-            kind_=["joint",
-                #    "kde", 
-                   "ell",
-                   ],
+            kind_=[
+                "joint",
+                #    "kde",
+                "ell",
+            ],
             kws_kde=dict(
-                    hue=hue,
-                    levels=2,
-                    common_norm=False,
-                    fill=True,
-                    alpha=0.05,
-                    ),
-            kws_joint=dict(kind='scatter',joint_kws=dict(s=size)),
-            kws_ellipse=dict(alpha=0.1,lw=1,label=None),
+                hue=hue,
+                levels=2,
+                common_norm=False,
+                fill=True,
+                alpha=0.05,
+            ),
+            kws_joint=dict(kind="scatter", joint_kws=dict(s=size)),
+            kws_ellipse=dict(alpha=0.1, lw=1, label=None),
             verbose=False,
             **kwargs,
         )
         figsets(
-            legend=dict(loc=legend_loc, markerscale=markerscale,bbox_to_anchor=bbox_to_anchor,ncols=ncols,fontsize=8),
+            legend=dict(
+                loc=legend_loc,
+                markerscale=markerscale,
+                bbox_to_anchor=bbox_to_anchor,
+                ncols=ncols,
+                fontsize=8,
+            ),
             xlabel=xlabel if xlabel else None,
             ylabel=ylabel if ylabel else None,
         )
@@ -8297,6 +8850,7 @@ def df_reducer(
 # example:
 # df_reducer(data=data_log, columns=markers, n_components=2)
 
+
 def get_df_format(data, threshold_unique=0.5, verbose=False):
     """
     检测表格: long, wide or uncertain.
@@ -8396,7 +8950,9 @@ def get_df_format(data, threshold_unique=0.5, verbose=False):
             if cluster_labels.nunique() < len(numeric_cols) * 0.5:
                 wide_score += 2
                 if verbose:
-                    print("Clustering on columns shows grouping, suggesting wide format.")
+                    print(
+                        "Clustering on columns shows grouping, suggesting wide format."
+                    )
         except Exception as e:
             print(e) if verbose else None
 
@@ -8487,7 +9043,8 @@ def get_df_format(data, threshold_unique=0.5, verbose=False):
         if verbose:
             print("Final decision: Uncertain format.")
         return "uncertain"
-    
+
+
 def plot_cluster(
     data: pd.DataFrame,
     labels: np.ndarray,
@@ -8735,6 +9292,8 @@ def evaluate_cluster(
             metrics["V-Measure"] = np.nan
 
     return metrics
+
+
 def df_qc(
     data: pd.DataFrame,
     columns=None,
@@ -8744,7 +9303,7 @@ def df_qc(
     hue=None,
     output=False,
     verbose=True,
-    dir_save=None
+    dir_save=None,
 ):
     """
     Usage example:
@@ -8752,16 +9311,17 @@ def df_qc(
     """
     from statsmodels.stats.outliers_influence import variance_inflation_factor
     from scipy.stats import skew, kurtosis, entropy
-    
+
     pd.options.display.max_seq_items = 10
     #! display(data.select_dtypes(include=[np.number]).describe())
     #!skim
     if columns is not None:
-        if isinstance(columns, (list,pd.core.indexes.base.Index)):
-            data=data[columns]
+        if isinstance(columns, (list, pd.core.indexes.base.Index)):
+            data = data[columns]
     if skim:
         try:
-            import skimpy 
+            import skimpy
+
             skimpy.skim(data)
         except:
             numerical_data = data.select_dtypes(include=[np.number])
@@ -8775,13 +9335,19 @@ def df_qc(
 
     # Missing values
     res_qc["missing_values"] = data.isnull().sum()
-    res_qc["missing_percentage"] = round((res_qc["missing_values"] / len(data)) * 100,2)
+    res_qc["missing_percentage"] = round(
+        (res_qc["missing_values"] / len(data)) * 100, 2
+    )
     res_qc["rows_with_missing"] = data.isnull().any(axis=1).sum()
 
     # Data types and unique values
     res_qc["data_types"] = data.dtypes
-    res_qc["unique_counts"] = data.select_dtypes(exclude=np.number).nunique().sort_values()
-    res_qc["unique_values"] = data.select_dtypes(exclude=np.number).apply(lambda x: x.unique())
+    res_qc["unique_counts"] = (
+        data.select_dtypes(exclude=np.number).nunique().sort_values()
+    )
+    res_qc["unique_values"] = data.select_dtypes(exclude=np.number).apply(
+        lambda x: x.unique()
+    )
     res_qc["constant_columns"] = [
         col for col in data.columns if data[col].nunique() <= 1
     ]
@@ -8797,8 +9363,8 @@ def df_qc(
     data_outliers = df_outlier(data)
     outlier_num = data_outliers.isna().sum() - data.isnull().sum()
     res_qc["outlier_num"] = outlier_num[outlier_num > 0]
-    outlier_percentage=round((outlier_num / len(data_outliers)) * 100,2)
-    res_qc["outlier_percentage"] = outlier_percentage[outlier_percentage>0]
+    outlier_percentage = round((outlier_num / len(data_outliers)) * 100, 2)
+    res_qc["outlier_percentage"] = outlier_percentage[outlier_percentage > 0]
     try:
         # Correlation and multicollinearity (VIF)
         if any(data.dtypes.apply(pd.api.types.is_numeric_dtype)):
@@ -8816,16 +9382,16 @@ def df_qc(
             numeric_df = data.select_dtypes(include=[np.number]).dropna()
             if isinstance(numeric_df.columns, pd.MultiIndex):
                 numeric_df.columns = [
-                    "_".join(col).strip() if isinstance(col, tuple) else col for col in numeric_df.columns
+                    "_".join(col).strip() if isinstance(col, tuple) else col
+                    for col in numeric_df.columns
                 ]
 
-            
             vif_data = pd.DataFrame()
-            res_qc["vif"]=vif_data
+            res_qc["vif"] = vif_data
             if numeric_df.shape[1] > 1 and not numeric_df.empty:
                 vif_data["feature"] = numeric_df.columns.tolist()
                 vif_data["VIF"] = [
-                    round(variance_inflation_factor(numeric_df.values, i),2)
+                    round(variance_inflation_factor(numeric_df.values, i), 2)
                     for i in range(numeric_df.shape[1])
                 ]
                 res_qc["vif"] = vif_data[
@@ -8847,8 +9413,8 @@ def df_qc(
     }
 
     # dtypes counts
-    res_qc['dtype_counts']=data.dtypes.value_counts()
-    
+    res_qc["dtype_counts"] = data.dtypes.value_counts()
+
     # Distribution Analysis (mean, median, mode, std dev, IQR for numeric columns)
     distribution_stats = data.select_dtypes(include=[np.number]).describe().T
     iqr = data.select_dtypes(include=[np.number]).apply(
@@ -8880,7 +9446,6 @@ def df_qc(
         if len(unique_types) > 1:
             inconsistent_types[col] = unique_types
     res_qc["inconsistent_types"] = inconsistent_types
- 
 
     # Text length analysis for text fields
     text_lengths = {}
@@ -8892,7 +9457,9 @@ def df_qc(
     res_qc["text_length_analysis"] = text_lengths
 
     # Summary statistics
-    res_qc["summary_statistics"] = data.describe().T.style.background_gradient(cmap='coolwarm', axis=0)
+    res_qc["summary_statistics"] = data.describe().T.style.background_gradient(
+        cmap="coolwarm", axis=0
+    )
 
     # Automated warnings
     warnings = []
@@ -8920,39 +9487,60 @@ def df_qc(
         display(res_qc["data_types"])
         if any(res_qc["missing_values"][res_qc["missing_values"] > 0]):
             print(" ⤵  Missing Values Counts:")
-            display(pd.DataFrame(
-                                {
-                                    "missing_values": res_qc["missing_values"][res_qc["missing_values"] > 0],
-                                    "missing_percent(%)": res_qc["missing_percentage"][
-                                        res_qc["missing_percentage"] > 0
-                                    ],
-                                }
-                            ).style.background_gradient(cmap="coolwarm", axis=0)
-                    )
+            display(
+                pd.DataFrame(
+                    {
+                        "missing_values": res_qc["missing_values"][
+                            res_qc["missing_values"] > 0
+                        ],
+                        "missing_percent(%)": res_qc["missing_percentage"][
+                            res_qc["missing_percentage"] > 0
+                        ],
+                    }
+                ).style.background_gradient(cmap="coolwarm", axis=0)
+            )
             # print(res_qc["missing_percentage"][res_qc["missing_percentage"] > 0])
-            print("\n⤵  Rows with Missing Values:",res_qc["rows_with_missing"])
+            print("\n⤵  Rows with Missing Values:", res_qc["rows_with_missing"])
+
+        (
+            print("\n⤵  Constant Columns:", res_qc["constant_columns"])
+            if any(res_qc["constant_columns"])
+            else None
+        )
+        (
+            print("⤵  Duplicate Rows:", res_qc["duplicate_rows"])
+            if res_qc["duplicate_rows"]
+            else None
+        )
+        (
+            print("⤵  Duplicate Columns:", res_qc["duplicate_columns"])
+            if any(res_qc["duplicate_columns"])
+            else None
+        )
 
-        print("\n⤵  Constant Columns:", res_qc["constant_columns"]) if any(res_qc["constant_columns"]) else None
-        print("⤵  Duplicate Rows:", res_qc["duplicate_rows"]) if res_qc["duplicate_rows"] else None
-        print("⤵  Duplicate Columns:", res_qc["duplicate_columns"]) if any(res_qc["duplicate_columns"]) else None
-        
         if any(res_qc["outlier_num"]):
             print("\n⤵  Outlier Report:")
-            display(pd.DataFrame(
-                                {
-                                    "outlier_num": res_qc["outlier_num"][res_qc["outlier_num"] > 0],
-                                    "outlier_percentage(%)": res_qc["outlier_percentage"][
-                                        res_qc["outlier_percentage"] > 0
-                                    ],
-                                }
-                            ).style.background_gradient(cmap="coolwarm", axis=0)
-                    )
+            display(
+                pd.DataFrame(
+                    {
+                        "outlier_num": res_qc["outlier_num"][res_qc["outlier_num"] > 0],
+                        "outlier_percentage(%)": res_qc["outlier_percentage"][
+                            res_qc["outlier_percentage"] > 0
+                        ],
+                    }
+                ).style.background_gradient(cmap="coolwarm", axis=0)
+            )
 
         if any(res_qc["unique_counts"]):
             print("\n⤵  Unique Values per Column:")
-            display(pd.DataFrame({"unique_counts":res_qc["unique_counts"],
-                                  "unique_values":res_qc["unique_values"]}).style.background_gradient(cmap="coolwarm", axis=0))
-
+            display(
+                pd.DataFrame(
+                    {
+                        "unique_counts": res_qc["unique_counts"],
+                        "unique_values": res_qc["unique_values"],
+                    }
+                ).style.background_gradient(cmap="coolwarm", axis=0)
+            )
 
         if res_qc["empty_columns"]:
             print("\n⤵  Empty Columns:", res_qc["empty_columns"])
@@ -8971,7 +9559,7 @@ def df_qc(
             print(res_qc["high_cardinality_categoricals"])
         if any(res_qc["inconsistent_types"]):
             print("\n⤵  Inconsistent Data Types:")
-            display(res_qc["inconsistent_types"]) 
+            display(res_qc["inconsistent_types"])
         if any(res_qc["text_length_analysis"]):
             print("\n⤵  Text Length Analysis:")
             for col, stats in res_qc["text_length_analysis"].items():
@@ -8986,67 +9574,93 @@ def df_qc(
 
     pd.reset_option("display.max_seq_items")
     if plot_:
-        df_qc_plots(data=data, res_qc=res_qc, max_cols=max_cols,hue=hue,dir_save=dir_save)
+        df_qc_plots(
+            data=data, res_qc=res_qc, max_cols=max_cols, hue=hue, dir_save=dir_save
+        )
     if output or not plot_:
         return res_qc
     return None
 
 
-def df_qc_plots(data: pd.DataFrame, columns=None,res_qc: dict=None, max_cols=20,hue=None,dir_save=None):
+def df_qc_plots(
+    data: pd.DataFrame,
+    columns=None,
+    res_qc: dict = None,
+    max_cols=20,
+    hue=None,
+    dir_save=None,
+):
     import matplotlib.pyplot as plt
     import seaborn as sns
     from .plot import subplot, figsets, get_color
     from datetime import datetime
+
     now_ = datetime.now().strftime("%y%m%d_%H%M%S")
-    
+
     if columns is not None:
-        if isinstance(columns, (list,pd.core.indexes.base.Index)):
-            data=data[columns]
+        if isinstance(columns, (list, pd.core.indexes.base.Index)):
+            data = data[columns]
     len_total = len(res_qc)
     n_row, n_col = int((len_total + 10)), 3
-    nexttile = subplot(n_row, n_col, figsize=[5 * n_col, 5 * n_row],verbose=False)
+    nexttile = subplot(n_row, n_col, figsize=[5 * n_col, 5 * n_row], verbose=False)
 
     missing_data = res_qc["missing_values"][res_qc["missing_values"] > 0].sort_values(
         ascending=False
     )
     if len(missing_data) > max_cols:
         missing_data = missing_data[:max_cols]
-    ax_missing_data=sns.barplot(
+    ax_missing_data = sns.barplot(
         y=missing_data.index,
         x=missing_data.values,
         hue=missing_data.index,
         palette=get_color(len(missing_data), cmap="coolwarm")[::-1],
         ax=nexttile(),
     )
-    figsets(title="Missing (#)", xlabel="#",ax=ax_missing_data,ylabel=None,fontsize=8 if len(missing_data)<=20 else 6)
+    figsets(
+        title="Missing (#)",
+        xlabel="#",
+        ax=ax_missing_data,
+        ylabel=None,
+        fontsize=8 if len(missing_data) <= 20 else 6,
+    )
 
     outlier_num = res_qc["outlier_num"].sort_values(ascending=False)
     if len(outlier_num) > max_cols:
         outlier_num = outlier_num[:max_cols]
-    ax_outlier_num=sns.barplot(
+    ax_outlier_num = sns.barplot(
         y=outlier_num.index,
         x=outlier_num.values,
-        hue=outlier_num.index, 
+        hue=outlier_num.index,
         palette=get_color(len(outlier_num), cmap="coolwarm")[::-1],
         ax=nexttile(),
     )
-    figsets(ax=ax_outlier_num,title="Outliers (#)", xlabel="#",ylabel=None,fontsize=8 if len(outlier_num)<=20 else 6)
- 
+    figsets(
+        ax=ax_outlier_num,
+        title="Outliers (#)",
+        xlabel="#",
+        ylabel=None,
+        fontsize=8 if len(outlier_num) <= 20 else 6,
+    )
+
     #!
     try:
-        for col in data.select_dtypes(include='category').columns:
-            sns.countplot(y=data[col],
-                          palette=get_color(data.select_dtypes(include='category').shape[1], cmap="coolwarm")[::-1],
-                          ax=nexttile())
+        for col in data.select_dtypes(include="category").columns:
+            sns.countplot(
+                y=data[col],
+                palette=get_color(
+                    data.select_dtypes(include="category").shape[1], cmap="coolwarm"
+                )[::-1],
+                ax=nexttile(),
+            )
             figsets(title=f"Count Plot: {col}", xlabel="Count", ylabel=col)
     except Exception as e:
-        pass 
+        pass
 
     # Skewness and Kurtosis Plots
     skewness = res_qc["skewness"].sort_values(ascending=False)
     kurtosis = res_qc["kurtosis"].sort_values(ascending=False)
     if not skewness.empty:
-        ax_skewness=sns.barplot(
+        ax_skewness = sns.barplot(
             y=skewness.index,
             x=skewness.values,
             hue=skewness.index,
@@ -9055,11 +9669,13 @@ def df_qc_plots(data: pd.DataFrame, columns=None,res_qc: dict=None, max_cols=20,
         )
         figsets(
             title="Highly Skewed Numeric Columns (Skewness > 1)",
-            xlabel="Skewness",ylabel=None,ax=ax_skewness,
-            fontsize=8 if len(skewness)<=20 else 6
+            xlabel="Skewness",
+            ylabel=None,
+            ax=ax_skewness,
+            fontsize=8 if len(skewness) <= 20 else 6,
         )
     if not kurtosis.empty:
-        ax_kurtosis=sns.barplot(
+        ax_kurtosis = sns.barplot(
             y=kurtosis.index,
             x=kurtosis.values,
             hue=kurtosis.index,
@@ -9068,59 +9684,68 @@ def df_qc_plots(data: pd.DataFrame, columns=None,res_qc: dict=None, max_cols=20,
         )
         figsets(
             title="Highly Kurtotic Numeric Columns (Kurtosis > 3)",
-            xlabel="Kurtosis",ylabel=None,ax=ax_kurtosis,
-            fontsize=8 if len(kurtosis)<=20 else 6
+            xlabel="Kurtosis",
+            ylabel=None,
+            ax=ax_kurtosis,
+            fontsize=8 if len(kurtosis) <= 20 else 6,
         )
 
     # Entropy for Categorical Variables
     entropy_data = pd.Series(res_qc["entropy_categoricals"]).sort_values(
         ascending=False
     )
-    ax_entropy_data=sns.barplot(
-        y=entropy_data.index, x=entropy_data.values,hue=entropy_data.index,
+    ax_entropy_data = sns.barplot(
+        y=entropy_data.index,
+        x=entropy_data.values,
+        hue=entropy_data.index,
         palette=get_color(len(entropy_data), cmap="coolwarm")[::-1],
-        ax=nexttile()
-    ) 
+        ax=nexttile(),
+    )
     figsets(
-            ylabel="Categorical Columns",
-            title="Entropy of Categorical Variables",
-            xlabel="Entropy (bits)",
-            ax=ax_entropy_data,
-            fontsize=8 if len(entropy_data)<=20 else 6
-        ) 
+        ylabel="Categorical Columns",
+        title="Entropy of Categorical Variables",
+        xlabel="Entropy (bits)",
+        ax=ax_entropy_data,
+        fontsize=8 if len(entropy_data) <= 20 else 6,
+    )
 
     # unique counts
-    unique_counts=res_qc["unique_counts"].sort_values(ascending=False)
-    ax_unique_counts_=sns.barplot(
-                y=unique_counts.index, 
-                x=unique_counts.values,
-                hue=unique_counts.index,
-                palette=get_color(len(unique_counts), cmap="coolwarm")[::-1],
-                ax=nexttile())
+    unique_counts = res_qc["unique_counts"].sort_values(ascending=False)
+    ax_unique_counts_ = sns.barplot(
+        y=unique_counts.index,
+        x=unique_counts.values,
+        hue=unique_counts.index,
+        palette=get_color(len(unique_counts), cmap="coolwarm")[::-1],
+        ax=nexttile(),
+    )
     figsets(
-            title="Unique Counts",
-            ylabel=None,
-            xlabel="#",
-            ax=ax_unique_counts_,
-            fontsize=8 if len(unique_counts)<=20 else 6
-        )
+        title="Unique Counts",
+        ylabel=None,
+        xlabel="#",
+        ax=ax_unique_counts_,
+        fontsize=8 if len(unique_counts) <= 20 else 6,
+    )
     # Binary Checking
-    ax_unique_counts=sns.barplot(y=unique_counts[unique_counts<8].index, 
-                x=unique_counts[unique_counts<8].values,
-                hue=unique_counts[unique_counts<8].index,
-                palette=get_color(len(unique_counts[unique_counts<8].index), cmap="coolwarm")[::-1],
-                ax=nexttile())
+    ax_unique_counts = sns.barplot(
+        y=unique_counts[unique_counts < 8].index,
+        x=unique_counts[unique_counts < 8].values,
+        hue=unique_counts[unique_counts < 8].index,
+        palette=get_color(len(unique_counts[unique_counts < 8].index), cmap="coolwarm")[
+            ::-1
+        ],
+        ax=nexttile(),
+    )
     plt.axvline(x=2, color="r", linestyle="--", lw=2)
     figsets(
-            ylabel=None,
-            title="Binary Checking",
-            xlabel="#",
-            ax=ax_unique_counts,
-            fontsize=8 if len(unique_counts[unique_counts<10].index)<=20 else 6
-        )
+        ylabel=None,
+        title="Binary Checking",
+        xlabel="#",
+        ax=ax_unique_counts,
+        fontsize=8 if len(unique_counts[unique_counts < 10].index) <= 20 else 6,
+    )
 
     # dtypes counts
-    dtype_counts = res_qc['dtype_counts']
+    dtype_counts = res_qc["dtype_counts"]
     txt = []
     for tp in dtype_counts.index:
         txt.append(list(data.select_dtypes(include=tp).columns))
@@ -9131,9 +9756,9 @@ def df_qc_plots(data: pd.DataFrame, columns=None,res_qc: dict=None, max_cols=20,
         color="#F3C8B2",
         ax=nexttile(),
     )
-    max_columns_per_row = 1 # Maximum number of columns per row
+    max_columns_per_row = 1  # Maximum number of columns per row
     for i, tp in enumerate(dtype_counts.index):
-        if i<=20:
+        if i <= 20:
             column_names = txt[i]
             # Split the column names into multiple lines if too long
             column_name_str = ", ".join(column_names)
@@ -9152,7 +9777,7 @@ def df_qc_plots(data: pd.DataFrame, columns=None,res_qc: dict=None, max_cols=20,
                 ha="center",
                 va="top",
                 c="k",
-                fontsize=8  if len(dtype_counts.index)<=20 else 6,
+                fontsize=8 if len(dtype_counts.index) <= 20 else 6,
                 rotation=0,
             )
     figsets(
@@ -9160,7 +9785,7 @@ def df_qc_plots(data: pd.DataFrame, columns=None,res_qc: dict=None, max_cols=20,
         title="Dtypes",
         ylabel="#",
         ax=ax_dtype_counts,
-        fontsize=8 if len(dtype_counts.index)<=20 else 6,
+        fontsize=8 if len(dtype_counts.index) <= 20 else 6,
     )
     # from .plot import pie
     # pie()
@@ -9175,57 +9800,66 @@ def df_qc_plots(data: pd.DataFrame, columns=None,res_qc: dict=None, max_cols=20,
         )
 
     if high_cardinality:
-        ax_high_cardinality=sns.barplot(
+        ax_high_cardinality = sns.barplot(
             y=list(high_cardinality.keys()),
             x=list(high_cardinality.values()),
             hue=list(high_cardinality.keys()),
-            palette=get_color(len(list(high_cardinality.keys())), cmap="coolwarm")[::-1],
+            palette=get_color(len(list(high_cardinality.keys())), cmap="coolwarm")[
+                ::-1
+            ],
             ax=nexttile(),
         )
         figsets(
             title="High Cardinality Categorical Columns",
             xlabel="Unique Value Count",
             ax=ax_high_cardinality,
-            fontsize=8 if len(list(high_cardinality.keys()))<=20 else 6
+            fontsize=8 if len(list(high_cardinality.keys())) <= 20 else 6,
         )
     if res_qc["low_variance_features"]:
         low_variance_data = data[res_qc["low_variance_features"]].copy()
         for col in low_variance_data.columns:
-            ax_low_variance_features=sns.histplot(
+            ax_low_variance_features = sns.histplot(
                 low_variance_data[col], bins=20, kde=True, color="coral", ax=nexttile()
             )
-            figsets(title=f"Low Variance Feature: {col}",ax=ax_low_variance_features,
-            fontsize=8 if len(low_variance_data[col])<=20 else 6)
+            figsets(
+                title=f"Low Variance Feature: {col}",
+                ax=ax_low_variance_features,
+                fontsize=8 if len(low_variance_data[col]) <= 20 else 6,
+            )
 
     # VIF plot for multicollinearity detection
     if "vif" in res_qc and not res_qc["vif"].empty:
         vif_data = res_qc["vif"].sort_values(by="VIF", ascending=False)
         if len(vif_data) > max_cols:
             vif_data = vif_data[:max_cols]
-        ax_vif=sns.barplot(data=vif_data, 
-                    x="VIF", 
-                    y="feature", 
-                    hue="VIF",
-                    palette=get_color(len(vif_data), cmap="coolwarm")[::-1],
-                    ax=nexttile()) 
+        ax_vif = sns.barplot(
+            data=vif_data,
+            x="VIF",
+            y="feature",
+            hue="VIF",
+            palette=get_color(len(vif_data), cmap="coolwarm")[::-1],
+            ax=nexttile(),
+        )
         figsets(
             title="Variance Inflation Factor(VIF)",
             xlabel="VIF",
             ylabel="Features",
             legend=None,
             ax=ax_vif,
-            fontsize=8 if len(vif_data)<=20 else 6
+            fontsize=8 if len(vif_data) <= 20 else 6,
         )
 
     # Correlation heatmap for numeric columns with high correlation pairs
     if any(data.dtypes.apply(pd.api.types.is_numeric_dtype)):
         corr = data.select_dtypes(include=[np.number]).corr()
-        if corr.shape[1]<=33:
+        if corr.shape[1] <= 33:
             mask = np.triu(np.ones_like(corr, dtype=bool))
             num_columns = corr.shape[1]
-            fontsize = max(6, min(12, 12 - (num_columns - 10) * 0.2))  # Scale between 8 and 12
+            fontsize = max(
+                6, min(12, 12 - (num_columns - 10) * 0.2)
+            )  # Scale between 8 and 12
 
-            ax_heatmap=sns.heatmap(
+            ax_heatmap = sns.heatmap(
                 corr,
                 mask=mask,
                 annot=True,
@@ -9233,24 +9867,21 @@ def df_qc_plots(data: pd.DataFrame, columns=None,res_qc: dict=None, max_cols=20,
                 center=0,
                 fmt=".1f",
                 linewidths=0.5,
-                vmin=-1, vmax=1,
+                vmin=-1,
+                vmax=1,
                 ax=nexttile(2, 2),
-                cbar_kws=dict(shrink=0.2,ticks=np.arange(-1, 2, 1)),
-                annot_kws={"size": fontsize} 
-            ) 
-
-            figsets(
-                xangle=45,
-                title="Correlation Heatmap",
-                ax=ax_heatmap
+                cbar_kws=dict(shrink=0.2, ticks=np.arange(-1, 2, 1)),
+                annot_kws={"size": fontsize},
             )
+
+            figsets(xangle=45, title="Correlation Heatmap", ax=ax_heatmap)
     # # save figure
     # if dir_save:
     #     figsave(dir_save,f"qc_plot_{now_}.pdf")
 
     if columns is not None:
-        if isinstance(columns, (list,pd.core.indexes.base.Index)):
-            data=data[columns]
+        if isinstance(columns, (list, pd.core.indexes.base.Index)):
+            data = data[columns]
 
     # len_total = len(res_qc)
     # n_row, n_col = int((len_total + 10) / 3), 3
@@ -9258,30 +9889,36 @@ def df_qc_plots(data: pd.DataFrame, columns=None,res_qc: dict=None, max_cols=20,
     #! check distribution
     data_num = data.select_dtypes(include=np.number)
     if len(data_num) > max_cols:
-        data_num = data_num.iloc[:,:max_cols]
+        data_num = data_num.iloc[:, :max_cols]
+
+    data_num = df_scaler(data=data_num, method="standard")
 
-    data_num = df_scaler(data=data_num, method='standard')
-        
     import scipy.stats as stats
+
     for column in data_num.columns:
-        #* Shapiro-Wilk test for normality
+        # * Shapiro-Wilk test for normality
         stat, p_value = stats.shapiro(data_num[column])
-        normality = "norm" if p_value > 0.05 else "not_norm" 
-        #* Plot histogram
-        ax_hist=sns.histplot(data_num[column], kde=True, ax=nexttile())
+        normality = "norm" if p_value > 0.05 else "not_norm"
+        # * Plot histogram
+        ax_hist = sns.histplot(data_num[column], kde=True, ax=nexttile())
         x_min, x_max = ax_hist.get_xlim()
         y_min, y_max = ax_hist.get_ylim()
-        ax_hist.text(x_min+(x_max-x_min)*0.5, y_min+(y_max-y_min)*0.75, 
-                     f'p(Shapiro-Wilk)={p_value:.3f}\n{normality}',
-                     ha='center', va='top')
-        figsets(title=column,ax=ax_hist)
-        ax_twin=ax_hist.twinx()
-        #* Q-Q plot
+        ax_hist.text(
+            x_min + (x_max - x_min) * 0.5,
+            y_min + (y_max - y_min) * 0.75,
+            f"p(Shapiro-Wilk)={p_value:.3f}\n{normality}",
+            ha="center",
+            va="top",
+        )
+        figsets(title=column, ax=ax_hist)
+        ax_twin = ax_hist.twinx()
+        # * Q-Q plot
         stats.probplot(data_num[column], dist="norm", plot=ax_twin)
-        figsets(ylabel=f'Q-Q Plot:{column}',title=None)
+        figsets(ylabel=f"Q-Q Plot:{column}", title=None)
     # save figure
     if dir_save:
-        figsave(dir_save,f"qc_plot_{now_}.pdf")
+        figsave(dir_save, f"qc_plot_{now_}.pdf")
+
 
 def df_corr(df: pd.DataFrame, method="pearson"):
     """
@@ -9318,6 +9955,7 @@ def df_corr(df: pd.DataFrame, method="pearson"):
 
     return corr_matrix, pval_matrix
 
+
 def use_pd(
     func_name="excel",
     verbose=True,
@@ -9338,7 +9976,8 @@ def use_pd(
         if verbose:
             print(e)
 
-def get_phone(phone_number: str, region: str = None,verbose=True):
+
+def get_phone(phone_number: str, region: str = None, verbose=True):
     """
     usage:
         info = get_phone(15237654321, "DE")
@@ -9426,21 +10065,23 @@ def get_phone(phone_number: str, region: str = None,verbose=True):
         dialing_instructions = f"Dial {formatted_national} within {country_name}. Dial {formatted_e164} from abroad."
 
         # Advanced Timezone Handling
-        gmt_offsets = pytz.timezone(time_zones).utcoffset(datetime.now()).total_seconds()/ 3600
+        gmt_offsets = (
+            pytz.timezone(time_zones).utcoffset(datetime.now()).total_seconds() / 3600
+        )
         # Get the local timezone (current computer's time)
         local_timezone = get_localzone()
-        #local_timezone = pytz.timezone(pytz.country_timezones[region_code][0])
+        # local_timezone = pytz.timezone(pytz.country_timezones[region_code][0])
         local_offset = local_timezone.utcoffset(datetime.now()).total_seconds() / 3600
         offset_diff = local_offset - gmt_offsets
         head_time = "earlier" if offset_diff < 0 else "later" if offset_diff > 0 else ""
-        res= {
+        res = {
             "valid": True,
             "possible": possible,
             "formatted": {
                 "international": formatted_international,
                 "national": formatted_national,
                 "e164": formatted_e164,
-            }, 
+            },
             "country_code": country_code,
             "country_name": country_name,
             "region_code": region_code,
@@ -9448,13 +10089,13 @@ def get_phone(phone_number: str, region: str = None,verbose=True):
             "carrier": carrier_name,
             "time_zone": time_zones,
             "current_times": current_times,
-            "local_offset":f"{local_offset} utcoffset",
+            "local_offset": f"{local_offset} utcoffset",
             "time_zone_diff": f"{head_time} {int(np.abs(offset_diff))} h",
             "number_type": number_type_str,
             "is_toll_free": is_toll_free,
-            "is_premium_rate": is_premium_rate,  
+            "is_premium_rate": is_premium_rate,
             "dialing_instructions": dialing_instructions,
-            "suggested_fix": None,  # Use phonenumbers.example_number if invalid 
+            "suggested_fix": None,  # Use phonenumbers.example_number if invalid
             "logs": {
                 "number_analysis_completed": datetime.now().strftime(
                     "%Y-%m-%d %H:%M:%S"
@@ -9465,7 +10106,7 @@ def get_phone(phone_number: str, region: str = None,verbose=True):
         }
 
     except phonenumbers.NumberParseException as e:
-        res= {"valid": False, "error": str(e)}
+        res = {"valid": False, "error": str(e)}
     if verbose:
         preview(res)
     return res
@@ -9531,7 +10172,8 @@ def decode_pluscode(
 
     return latitude, longitude
 
-def get_loc(input_data, user_agent="0413@mygmail.com)",verbose=True):
+
+def get_loc(input_data, user_agent="0413@mygmail.com)", verbose=True):
     """
         Determine if the input is a city name, lat/lon, or DMS and perform geocoding or reverse geocoding.
     Usage:
@@ -9562,13 +10204,17 @@ def get_loc(input_data, user_agent="0413@mygmail.com)",verbose=True):
     # Case 1: Input is a city name (string)
     if isinstance(input_data, str) and not re.match(r"^\d+(\.\d+)?$", input_data):
         location = geolocator.geocode(input_data)
-        if verbose:
-            print(
-                f"Latitude and Longitude for {input_data}: {location.latitude}, {location.longitude}"
-            )
-        else:
-            print(f"Could not find {input_data}.")
-        return location
+        try:
+            if verbose:
+                print(
+                    f"Latitude and Longitude for {input_data}: {location.latitude}, {location.longitude}"
+                )
+            else:
+                print(f"Could not find {input_data}.")
+            return location
+        except Exception as e:
+            print(f'Error: {e}')
+            return
 
     # Case 2: Input is latitude and longitude (float or tuple)
     elif isinstance(input_data, (float, tuple)):
@@ -9607,7 +10253,8 @@ def get_loc(input_data, user_agent="0413@mygmail.com)",verbose=True):
                 "Invalid input format. Please provide a city name, latitude/longitude, or DMS string."
             )
 
-def enpass(code: str, method: str="AES", key: str = None):
+
+def enpass(code: str, method: str = "AES", key: str = None):
     """
     usage: enpass("admin")
     Master encryption function that supports multiple methods: AES, RSA, and SHA256.
@@ -9617,6 +10264,7 @@ def enpass(code: str, method: str="AES", key: str = None):
     :return: The encrypted data or hashed value.
     """
     import hashlib
+
     # AES Encryption (Advanced)
     def aes_encrypt(data: str, key: str):
         """
@@ -9630,9 +10278,10 @@ def enpass(code: str, method: str="AES", key: str = None):
         from cryptography.hazmat.primitives import padding
         import base64
         import os
+
         # Generate a 256-bit key from the provided password
         key = hashlib.sha256(key.encode()).digest()
-        
+
         # Generate a random initialization vector (IV)
         iv = os.urandom(16)  # 16 bytes for AES block size
 
@@ -9659,10 +10308,12 @@ def enpass(code: str, method: str="AES", key: str = None):
         import base64
         from Crypto.PublicKey import RSA
         from Crypto.Cipher import PKCS1_OAEP
+
         public_key_obj = RSA.import_key(public_key)
         cipher_rsa = PKCS1_OAEP.new(public_key_obj)
         encrypted_data = cipher_rsa.encrypt(data.encode())
         return base64.b64encode(encrypted_data).decode()
+
     # SHA256 Hashing (Non-reversible)
     def sha256_hash(data: str):
         """
@@ -9671,9 +10322,10 @@ def enpass(code: str, method: str="AES", key: str = None):
         :return: The hashed value (hex string).
         """
         return hashlib.sha256(data.encode()).hexdigest()
+
     if key is None:
-        key="worldpeace"
-    method=strcmp(method,["AES","RSA",'SHA256'])[0]
+        key = "worldpeace"
+    method = strcmp(method, ["AES", "RSA", "SHA256"])[0]
     if method == "AES":
         return aes_encrypt(code, key)
     elif method == "RSA":
@@ -9685,7 +10337,7 @@ def enpass(code: str, method: str="AES", key: str = None):
 
 
 # Master Decryption Function (Supports AES, RSA)
-def depass(encrypted_code: str, method: str='AES', key: str = None):
+def depass(encrypted_code: str, method: str = "AES", key: str = None):
     """
     Master decryption function that supports multiple methods: AES and RSA.
     :param encrypted_code: The encrypted data to decrypt.
@@ -9694,6 +10346,7 @@ def depass(encrypted_code: str, method: str='AES', key: str = None):
     :return: The decrypted data.
     """
     import hashlib
+
     def aes_decrypt(encrypted_data: str, key: str):
         """
         Decrypts data encrypted using AES in CBC mode.
@@ -9705,12 +10358,13 @@ def depass(encrypted_code: str, method: str='AES', key: str = None):
         from cryptography.hazmat.backends import default_backend
         from cryptography.hazmat.primitives import padding
         import base64
+
         # Generate the same 256-bit key from the password
         key = hashlib.sha256(key.encode()).digest()
-        
+
         # Decode the encrypted data from base64
         encrypted_data = base64.b64decode(encrypted_data)
-        
+
         # Extract the IV and the actual encrypted data
         iv = encrypted_data[:16]  # First 16 bytes are the IV
         encrypted_data = encrypted_data[16:]  # Remaining data is the encrypted message
@@ -9724,7 +10378,8 @@ def depass(encrypted_code: str, method: str='AES', key: str = None):
         unpadder = padding.PKCS7(128).unpadder()
         unpadded_data = unpadder.update(decrypted_data) + unpadder.finalize()
 
-        return unpadded_data.decode() 
+        return unpadded_data.decode()
+
     def rsa_decrypt(encrypted_data: str, private_key: str):
         """
         Decrypts RSA-encrypted data using the private key.
@@ -9735,6 +10390,7 @@ def depass(encrypted_code: str, method: str='AES', key: str = None):
         from Crypto.PublicKey import RSA
         from Crypto.Cipher import PKCS1_OAEP
         import base64
+
         encrypted_data = base64.b64decode(encrypted_data)
         private_key_obj = RSA.import_key(private_key)
         cipher_rsa = PKCS1_OAEP.new(private_key_obj)
@@ -9742,8 +10398,8 @@ def depass(encrypted_code: str, method: str='AES', key: str = None):
         return decrypted_data.decode()
 
     if key is None:
-        key="worldpeace"
-    method=strcmp(method,["AES","RSA",'SHA256'])[0]
+        key = "worldpeace"
+    method = strcmp(method, ["AES", "RSA", "SHA256"])[0]
     if method == "AES":
         return aes_decrypt(encrypted_code, key)
     elif method == "RSA":
@@ -9752,3 +10408,311 @@ def depass(encrypted_code: str, method: str='AES', key: str = None):
         raise ValueError("SHA256 is a hash function and cannot be decrypted.")
     else:
         raise ValueError("Unsupported decryption method")
+
+def get_clip(dir_save=None):
+    """
+    Master function to extract content from the clipboard (text, URL, or image).
+
+    Parameters:
+        dir_save (str, optional): If an image is found, save it to this path.
+
+    Returns:
+        dict: A dictionary with extracted content:
+              {
+                  "type": "text" | "url" | "image" | "none",
+                  "content": <str|Image|None>,
+                  "saved_to": <str|None>  # Path if an image is saved
+              }
+    """
+    result = {"type": "none", "content": None, "saved_to": None}
+
+    try:
+        import pyperclip
+        from PIL import ImageGrab, Image
+        import validators
+        # 1. Check for text in the clipboard
+        clipboard_content = pyperclip.paste()
+        if clipboard_content:
+            if validators.url(clipboard_content.strip()):
+                result["type"] = "url"
+                result["content"] = clipboard_content.strip()
+
+            else:
+                result["type"] = "text"
+                result["content"] = clipboard_content.strip()
+            return clipboard_content.strip()
+
+        # 2. Check for image in the clipboard
+        image = ImageGrab.grabclipboard()
+        if isinstance(image, Image.Image):
+            result["type"] = "image"
+            result["content"] = image
+            if dir_save:
+                image.save(dir_save)
+                result["saved_to"] = dir_save
+                print(f"Image saved to {dir_save}.")
+            else:
+                print("Image detected in clipboard but not saved.")
+            return image
+        print("No valid text, URL, or image found in clipboard.")
+        return result
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return result
+
+def keyboard(*args, action='press', n_click=1,interval=0,verbose=False,**kwargs):
+    """
+    Simulates keyboard input using pyautogui.
+
+    Parameters:
+        input_key (str): The key to simulate. Check the list of supported keys with verbose=True.
+        action (str): The action to perform. Options are 'press', 'keyDown', or 'keyUp'.
+        n_click (int): Number of times to press the key (only for 'press' action).
+        interval (float): Time interval between key presses for 'press' action.
+        verbose (bool): Print detailed output, including supported keys and debug info.
+        kwargs: Additional arguments (reserved for future extensions).
+
+    keyboard("command", "d", action="shorcut")
+    """
+    import pyautogui
+    input_key  = args
+
+    actions = ['press','keyDown','keyUp', 'hold','release', 'hotkey','shortcut']
+    action = strcmp(action,actions)[0]
+    keyboard_keys_=['\t', '\n', '\r', ' ', '!', '"', '#', '$', '%', '&', "'", '(',
+                    ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7',
+                    '8', '9', ':', ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '_', '`',
+                    'a', 'b', 'c', 'd', 'e','f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+                    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~',
+                    'accept', 'add', 'alt', 'altleft', 'altright', 'apps', 'backspace',
+                    'browserback', 'browserfavorites', 'browserforward', 'browserhome',
+                    'browserrefresh', 'browsersearch', 'browserstop', 'capslock', 'clear',
+                    'convert', 'ctrl', 'ctrlleft', 'ctrlright', 'decimal', 'del', 'delete',
+                    'divide', 'down', 'end', 'enter', 'esc', 'escape', 'execute', 'f1', 'f10',
+                    'f11', 'f12', 'f13', 'f14', 'f15', 'f16', 'f17', 'f18', 'f19', 'f2', 'f20',
+                    'f21', 'f22', 'f23', 'f24', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9',
+                    'final', 'fn', 'hanguel', 'hangul', 'hanja', 'help', 'home', 'insert', 'junja',
+                    'kana', 'kanji', 'launchapp1', 'launchapp2', 'launchmail',
+                    'launchmediaselect', 'left', 'modechange', 'multiply', 'nexttrack',
+                    'nonconvert', 'num0', 'num1', 'num2', 'num3', 'num4', 'num5', 'num6',
+                    'num7', 'num8', 'num9', 'numlock', 'pagedown', 'pageup', 'pause', 'pgdn',
+                    'pgup', 'playpause', 'prevtrack', 'print', 'printscreen', 'prntscrn',
+                    'prtsc', 'prtscr', 'return', 'right', 'scrolllock', 'select', 'separator',
+                    'shift', 'shiftleft', 'shiftright', 'sleep', 'space', 'stop', 'subtract', 'tab',
+                    'up', 'volumedown', 'volumemute', 'volumeup', 'win', 'winleft', 'winright', 'yen',
+                    'command', 'option', 'optionleft', 'optionright']
+    if verbose:
+        print(f"supported keys: {keyboard_keys_}")
+
+    if action not in ['hotkey','shortcut']:
+        if not isinstance(input_key, list):
+            input_key=list(input_key)
+        input_key = [strcmp(i, keyboard_keys_)[0] for i in input_key ]
+
+    # correct action
+    cmd_keys = ['command', 'option', 'optionleft', 'optionright','win', 'winleft', 'winright','ctrl', 'ctrlleft', 'ctrlright']
+    try:
+        if any([i in cmd_keys for i in input_key]):
+            action='hotkey'
+    except:
+        pass
+
+    print(f"\n{action}: {input_key}")
+    # keyboard
+    if action in ["press"]:
+        # pyautogui.press(input_key, presses=n_click,interval=interval)
+        for _ in range(n_click):
+            for key in input_key:
+                pyautogui.press(key)
+                pyautogui.sleep(interval)
+    elif action in ['keyDown','hold']:
+        # pyautogui.keyDown(input_key)
+        for _ in range(n_click):
+            for key in input_key:
+                pyautogui.keyDown(key)
+                pyautogui.sleep(interval)
+        
+    elif action in ['keyUp','release']:
+        # pyautogui.keyUp(input_key)
+        for _ in range(n_click):
+            for key in input_key:
+                pyautogui.keyUp(key)
+                pyautogui.sleep(interval)
+        
+    elif action in ['hotkey','shortcut']:
+        pyautogui.hotkey(input_key)
+    
+def mouse(
+    *args,  # loc
+    action: str = "move",
+    duration: float = 0.5,
+    loc_type: str = "absolute",  # 'absolute', 'relative'
+    region: tuple = None,  # (tuple, optional): A region (x, y, width, height) to search for the image.
+    image_path: str = None,
+    wait:float = 0,
+    text: str = None,
+    confidence: float = 0.8,
+    button: str = "left",
+    n_click: int = 1,  # number of clicks
+    interval: float = 0.25,  # time between clicks
+    scroll_amount: int = -500,
+    fail_safe: bool = True,
+    grayscale: bool = False,
+    **kwargs,
+):
+    """
+    Master function to handle pyautogui actions.
+
+    Parameters:
+        action (str): The action to perform ('click', 'double_click', 'type', 'drag', 'scroll', 'move', 'locate', etc.).
+        image_path (str, optional): Path to the image for 'locate' or 'click' actions.
+        text (str, optional): Text to type for 'type' action.
+        confidence (float, optional): Confidence level for image recognition (default 0.8).
+        duration (float, optional): Duration for smooth movements in seconds (default 0.5).
+        region (tuple, optional): A region (x, y, width, height) to search for the image.
+        button (str, optional): Mouse button to use ('left', 'right', 'middle').
+        n_click (int, optional): Number of times to click for 'click' actions.
+        interval (float, optional): Interval between clicks for 'click' actions.
+        offset (tuple, optional): Horizontal offset from the located image. y_offset (int, optional): Vertical offset from the located image.
+        scroll_amount (int, optional): Amount to scroll (positive for up, negative for down).
+        fail_safe (bool, optional): Enable/disable pyautogui's fail-safe feature.
+        grayscale (bool, optional): Search for the image in grayscale mode.
+
+    Returns:
+        tuple or None: Returns coordinates for 'locate' actions, otherwise None.
+    """
+    import pyautogui
+    import time
+
+    pyautogui.FAILSAFE = fail_safe  # Enable/disable fail-safe
+    loc_type = "absolute" if "abs" in loc_type else "relative"
+    if len(args) == 1:
+        if isinstance(args[0], str):
+            image_path = args[0]
+            x_offset, y_offset = None, None
+        else:
+            x_offset, y_offset = args
+
+    elif len(args) == 2:
+        x_offset, y_offset = args
+    elif len(args) == 3:
+        x_offset, y_offset, action = args
+    elif len(args) == 4:
+        x_offset, y_offset, action, duration = args
+    else:
+        x_offset, y_offset = None, None
+
+    what_action = [
+        "locate",
+        "click",
+        "double_click",
+        "triple_click",
+        "input",
+        "write",
+        "type",
+        "drag",
+        "move",
+        "scroll",
+        "down",
+        "up",
+        "hold",
+        "press",
+        "release"
+    ]
+    action = strcmp(action, what_action)[0]
+    # get the locations
+    location = None
+    if any([x_offset is None, y_offset is None]):
+        if region is None:
+            w,h=pyautogui.size()
+            region=(0,0,w,h)
+            print(region)
+        try:
+            print(image_path)
+            location = pyautogui.locateOnScreen(
+                image_path, confidence=confidence, region=region, grayscale=grayscale
+            )
+            print(pyautogui.center(location))
+        except Exception as e:
+            location = None
+
+    # try:
+    if location:
+        x, y = pyautogui.center(location)
+        x += x_offset if x_offset else 0
+        y += y_offset if y_offset else 0
+        x_offset, y_offset = x,y
+    print(action)
+    if action in ['locate']:
+        x, y = pyautogui.position()
+    elif action in ["click", "double_click","triple_click"]:
+        # if location:
+        #     x, y = pyautogui.center(location)
+        #     x += x_offset
+        #     y += y_offset
+        #     pyautogui.moveTo(x, y, duration=duration) 
+        #     if action == "click":
+        #         pyautogui.click(x=x, y=y, clicks=n_click, interval=interval, button=button)
+        #     elif action == "double_click":
+        #         pyautogui.doubleClick(x=x, y=y, interval=interval, button=button)
+        #     elif action=='triple_click':
+        #         pyautogui.tripleClick(x=x,y=y,interval=interval,  button=button)
+        # else:
+        if action == "click":
+            pyautogui.moveTo(x_offset, y_offset, duration=duration)
+            time.sleep(wait)
+            pyautogui.click(x=x_offset, y=y_offset, clicks=n_click, interval=interval, button=button)
+        elif action == "double_click":
+            pyautogui.moveTo(x_offset, y_offset, duration=duration)
+            time.sleep(wait)
+            pyautogui.doubleClick(x=x_offset, y=y_offset, interval=interval, button=button)
+        elif action=='triple_click':
+            pyautogui.moveTo(x_offset, y_offset, duration=duration)
+            time.sleep(wait)
+            pyautogui.tripleClick(x=x_offset, y=y_offset, interval=interval, button=button)
+
+    elif action in ["type", "write", "input"]:
+        pyautogui.moveTo(x_offset, y_offset, duration=duration)
+        time.sleep(wait)
+        if text is not None:
+            pyautogui.typewrite(text, interval=interval)
+        else:
+            raise ValueError("Text must be provided for the 'type' action.")
+
+    elif action == "drag":
+        if loc_type == "absolute":
+            pyautogui.dragTo(x_offset, y_offset, duration=duration, button=button)
+        else:
+            pyautogui.dragRel(x_offset, y_offset, duration=duration, button=button)
+
+    elif action in ["move"]:
+        if loc_type == "absolute":
+            pyautogui.moveTo(x_offset, y_offset, duration=duration)
+        else:
+            pyautogui.moveRel(x_offset, y_offset, duration=duration)
+
+    elif action == "scroll":
+        pyautogui.moveTo(x_offset, y_offset, duration=duration)
+        time.sleep(wait)
+        pyautogui.scroll(scroll_amount)
+
+    elif action in ["down",'hold','press']:
+        pyautogui.moveTo(x_offset, y_offset, duration=duration)
+        time.sleep(wait)
+        pyautogui.mouseDown(x_offset, y_offset, button=button, duration=duration)
+
+    elif action in ['up','release']:
+        pyautogui.moveTo(x_offset, y_offset, duration=duration)
+        time.sleep(wait)
+        pyautogui.mouseUp(x_offset, y_offset, button=button, duration=duration)
+
+    else:
+        raise ValueError(f"Unsupported action: {action}")
+
+    # except pyautogui.ImageNotFoundException:
+    #     print(
+    #         "Image not found. Ensure the image is visible and parameters are correct."
+    #     )
+    # except Exception as e:
+    #     print(f"An error occurred: {e}")