py2ls 0.2.4.30__py3-none-any.whl → 0.2.4.32__py3-none-any.whl

py2ls/ips.py

@@ -23,7 +23,8 @@ import logging
 from pathlib import Path
 from datetime import datetime
 
-def run_once_within(duration=60,reverse=False):  # default 60s
+
+def run_once_within(duration=60, reverse=False):  # default 60s
     import time
 
     """
@@ -546,6 +547,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 +593,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 +655,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 +664,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,7 +785,8 @@ 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="knn", plot_=True, figsize=[12, 6]):
     """
     Compare two images using SSIM, Feature Matching (SIFT), or KNN Matching.
 
@@ -796,15 +803,16 @@ 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 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,18 +827,18 @@ 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)
@@ -848,15 +856,17 @@ def imgcmp(img: list, method='knn', plot_=True, figsize=[12, 6]):
         # 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 < 0.75 * matches[-1].distance
+            ]
 
-        elif method == 'knn':  # KNN matching with ratio test
+        elif method == "knn":  # KNN matching with ratio test
             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]
@@ -865,14 +875,18 @@ def imgcmp(img: list, method='knn', plot_=True, figsize=[12, 6]):
         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)
+        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)
@@ -893,11 +907,15 @@ def imgcmp(img: list, method='knn', plot_=True, figsize=[12, 6]):
 
         # 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.title(f"Feature Matches ({len(good_matches)} matches, Score: {similarity_score:.4f})")
-            plt.axis('off')
+            plt.title(
+                f"Feature Matches ({len(good_matches)} matches, Score: {similarity_score:.4f})"
+            )
+            plt.axis("off")
             plt.show()
         # Identify unmatched keypoints
         matched_idx1 = [m.queryIdx for m in good_matches]
@@ -907,8 +925,20 @@ def imgcmp(img: list, method='knn', plot_=True, figsize=[12, 6]):
         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)
+        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,
+        )
 
         # Display results
         if plot_:
@@ -1017,6 +1047,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 +1062,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 +1088,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 +1194,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)
@@ -1168,6 +1224,7 @@ def text2audio(
             print(f"Error opening file: {e}")
     print("done")
 
+
 def str2time(time_str, fmt="24"):
     """
     Convert a time string into the specified format.
@@ -1624,6 +1681,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 +1707,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 +2255,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 +2406,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 +2565,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 +2588,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 +2727,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 +2780,7 @@ def fload(fpath, kind=None, **kwargs):
         "xml",
         "ipynb",
         "mtx",
-        "rtf"
+        "rtf",
     ]
     zip_types = [
         "gz",
@@ -2735,7 +2800,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 +2825,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 +2841,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 +2983,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 +3425,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 +3588,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)
@@ -3755,22 +3835,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 +3887,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 +3988,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 +4073,31 @@ 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 +4112,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 +4124,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 +4140,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 +4163,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 +4206,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 +4223,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 +4240,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 +4257,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 +4269,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 +4307,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 +4320,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 +4332,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 +4350,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 +4389,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 +4416,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 +4459,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 +4490,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 +4609,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 +4641,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 +4684,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.
@@ -4545,6 +4696,7 @@ def is_image(fpath):
         bool: True if the file is a recognized image, False otherwise.
     """
     import mimetypes
+
     # Known image MIME types
     image_mime_types = {
         "image/jpeg",
@@ -4561,8 +4713,20 @@ def is_image(fpath):
 
     # Known image file extensions
     image_extensions = {
-        ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".tif", ".tiff", 
-        ".ico", ".svg", ".heic", ".heif",".fig",".jpg"
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".gif",
+        ".bmp",
+        ".webp",
+        ".tif",
+        ".tiff",
+        ".ico",
+        ".svg",
+        ".heic",
+        ".heif",
+        ".fig",
+        ".jpg",
     }
 
     # Get MIME type using mimetypes
@@ -4573,12 +4737,15 @@ def is_image(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 image_extensions:
         return True
 
     return False
 
+
 def is_video(fpath):
     """
     Determine if a given file is a video based on MIME type and file extension.
@@ -4590,6 +4757,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 +4778,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 +4804,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 +4824,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 +4865,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 +4893,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 +4912,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 +4935,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 +4957,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
 
@@ -4982,6 +5209,7 @@ def apply_filter(img, *args):
             )
         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,7 +5217,8 @@ 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
     gray_image = rgb2gray(image)
 
@@ -5091,6 +5320,7 @@ def detect_angle(image, by="median", template=None):
         print(f"Unknown method {by}")
         return 0
 
+
 def imgsets(img, **kwargs):
     """
     Apply various enhancements and filters to an image using PIL's ImageEnhance and ImageFilter modules.
@@ -6355,13 +6585,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 +6757,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 +6767,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 +6798,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 +6861,7 @@ def df_astype(
         "day",
         "month",
         "year",
-        "circular"
+        "circular",
     ]
     # If inplace is False, make a copy of the DataFrame
     if not inplace:
@@ -6720,12 +6957,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 +7012,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 +7216,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 +7273,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 +7418,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 +7453,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 +7478,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 +7540,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 +7558,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 +7575,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 +7588,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 +7952,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 +7988,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 +7999,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 +8332,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 +8353,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 +8453,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 +8510,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 +8521,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 +8533,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 +8590,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 +8690,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 +8783,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 +9032,8 @@ def evaluate_cluster(
             metrics["V-Measure"] = np.nan
 
     return metrics
+
+
 def df_qc(
     data: pd.DataFrame,
     columns=None,
@@ -8744,7 +9043,7 @@ def df_qc(
     hue=None,
     output=False,
     verbose=True,
-    dir_save=None
+    dir_save=None,
 ):
     """
     Usage example:
@@ -8752,16 +9051,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 +9075,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 +9103,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 +9122,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 +9153,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 +9186,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 +9197,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 +9227,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 +9299,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 +9314,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 +9409,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 +9424,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 +9496,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 +9517,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 +9525,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 +9540,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 +9607,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 +9629,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 +9695,7 @@ def df_corr(df: pd.DataFrame, method="pearson"):
 
     return corr_matrix, pval_matrix
 
+
 def use_pd(
     func_name="excel",
     verbose=True,
@@ -9338,7 +9716,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 +9805,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 +9829,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 +9846,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 +9912,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:
@@ -9607,7 +9989,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 +10000,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 +10014,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 +10044,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 +10058,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 +10073,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 +10082,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 +10094,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 +10114,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 +10126,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 +10134,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":