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

py2ls/ips.py

@@ -779,11 +779,150 @@ 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]):
+    """
+    Compare two images using SSIM, Feature Matching (SIFT), or KNN Matching.
+
+    Parameters:
+    - img (list): List containing two image file paths [img1, img2].
+    - method (str): Comparison method ('ssim', 'match', or 'knn').
+    - plot_ (bool): Whether to display the results visually.
+    - figsize (list): Size of the figure for plots.
+
+    Returns:
+    - For 'ssim': (diff, score): SSIM difference map and similarity score.
+    - For 'match' or 'knn': (good_matches, len(good_matches), similarity_score): Matches and similarity score.
+    """
+    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':
+        # Convert images to grayscale
+        gray1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
+        gray2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
+
+        # Compute SSIM
+        score, diff = ssim(gray1, gray2, full=True)
+        print(f"SSIM Score: {score:.4f}")
+
+        # Convert diff to 8-bit for visualization
+        diff = (diff * 255).astype("uint8")
+
+        # Plot if needed
+        if plot_:
+            fig, ax = plt.subplots(1, 3, figsize=figsize)
+            ax[0].imshow(gray1, cmap='gray')
+            ax[0].set_title("Image 1")
+            ax[1].imshow(gray2, cmap='gray')
+            ax[1].set_title("Image 2")
+            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']:
+        # Convert images to grayscale
+        gray1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
+        gray2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
+
+        # Initialize SIFT detector
+        sift = cv2.SIFT_create()
+
+        # Detect and compute features
+        keypoints1, descriptors1 = sift.detectAndCompute(gray1, None)
+        keypoints2, descriptors2 = sift.detectAndCompute(gray2, None)
+
+        if len(keypoints1) == 0 or len(keypoints2) == 0:
+            raise ValueError("No keypoints found in one or both images.")
+
+        # BFMatcher initialization
+        bf = cv2.BFMatcher()
+
+        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]
+
+        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]
 
-# Example usaged
-# str1 = "plos biology"
-# str2 = ['PLoS Computational Biology', 'PLOS BIOLOGY']
-# best_match, idx = strcmp(str1, str2, ignore_case=1)
+        # Calculate similarity score
+        similarity_score = len(good_matches) / min(len(keypoints1), len(keypoints2))
+        print(f"Number of good matches: {len(good_matches)}")
+        print(f"Similarity Score: {similarity_score:.4f}")
+     # Handle case where no good matches are found
+        if len(good_matches) == 0:
+            print("No good matches found.")
+            return good_matches, 0.0, None
+
+        # Identify matched keypoints
+        src_pts = np.float32([keypoints1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
+        dst_pts = np.float32([keypoints2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
+
+        # Calculate Homography using RANSAC
+        homography_matrix, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
+
+        # Apply the homography to image2
+        h, w = image1.shape[:2]
+        warped_image2 = cv2.warpPerspective(image2, homography_matrix, (w, h))
+
+        # Plot result if needed
+        if plot_:
+            fig, ax = plt.subplots(1, 2, figsize=figsize)
+            ax[0].imshow(cv2.cvtColor(image1, cv2.COLOR_BGR2RGB))
+            ax[0].set_title("Image 1")
+            ax[1].imshow(cv2.cvtColor(warped_image2, cv2.COLOR_BGR2RGB))
+            ax[1].set_title("Warped Image 2")
+            plt.tight_layout()
+            plt.show()
+
+        # Plot matches if needed
+        if plot_:
+            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.show()
+        # Identify unmatched keypoints
+        matched_idx1 = [m.queryIdx for m in good_matches]
+        matched_idx2 = [m.trainIdx for m in good_matches]
+
+        unmatched_kp1 = [kp for i, kp in enumerate(keypoints1) if i not in matched_idx1]
+        unmatched_kp2 = [kp for i, kp in enumerate(keypoints2) if i not in matched_idx2]
+
+        # Mark unmatched keypoints on the images
+        img1_marked = cv2.drawKeypoints(image1, unmatched_kp1, None, color=(0, 0, 255), flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
+        img2_marked = cv2.drawKeypoints(image2, unmatched_kp2, None, color=(0, 0, 255), flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
+
+        # Display results
+        if plot_:
+            fig, ax = plt.subplots(1, 2, figsize=figsize)
+            ax[0].imshow(cv2.cvtColor(img1_marked, cv2.COLOR_BGR2RGB))
+            ax[0].set_title("Unmatched Keypoints (Image 1)")
+            ax[1].imshow(cv2.cvtColor(img2_marked, cv2.COLOR_BGR2RGB))
+            ax[1].set_title("Unmatched Keypoints (Image 2)")
+            plt.tight_layout()
+            plt.show()
+        return good_matches, similarity_score, homography_matrix
+
+    else:
+        raise ValueError("Invalid method. Use 'ssim', 'match', or 'knn'.")
 
 
 def cn2pinyin(
@@ -892,6 +1031,143 @@ 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"
+    volume=1.0,
+    voice=None,
+    lang=None,
+    gender=None,
+    age=None,
+    dir_save=None,
+):
+    """
+    # sample_text = "Hello! This is a test of the pyttsx3 text-to-speech system."
+    # sample_text = "这个是中文, 测试"
+    # sample_text = "Hallo, ich bin echo, Wie Heissen Sie"
+
+    # text2audio(
+    #     text=sample_text,
+    #     rate=150,
+    #     volume=0.9,
+    #     # voice=None,  # Replace with a voice name or ID available on your system
+    # )
+    """
+    if method is not None:
+        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)
+        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":
+        import pyttsx3
+
+        try:
+            engine = pyttsx3.init()
+            engine.setProperty("rate", rate)
+            if 0.0 <= volume <= 1.0:
+                engine.setProperty("volume", volume)
+            else:
+                raise ValueError("Volume must be between 0.0 and 1.0")
+
+            if gender is not None:
+                gender = strcmp(gender, ["male", "female"])[0]
+            if age is not None:
+                if isinstance(age, (float, int)):
+                    if age <= 10:
+                        age = "child"
+                    elif 10 < age < 18:
+                        age = "senior"
+                    else:
+                        age = "adult"
+                elif isinstance(age, str):
+                    age = strcmp(age, ["child", "adult", "senior"])[0]
+                else:
+                    raise ValueError("age: should be in ['child', 'adult', 'senior']")
+            voices = engine.getProperty("voices")
+            if voice is None:
+                if lang is None:
+                    voice = strcmp(detect_lang(text), [v.name for v in voices])[0]
+                else:
+                    if run_once_within():
+                        print([v.name for v in voices])
+                    print(f"lang:{lang}")
+                    voice = strcmp(lang, [v.name for v in voices])[0]
+            selected_voice = None
+
+            for v in voices:
+                # Check if the voice matches the specified gender or age
+                if voice and (voice.lower() in v.name.lower() or voice in v.id):
+                    selected_voice = v
+                    break
+                if gender and gender.lower() in v.name.lower():
+                    selected_voice = v
+                if age and age.lower() in v.name.lower():
+                    selected_voice = v
+
+            if selected_voice:
+                engine.setProperty("voice", selected_voice.id)
+            else:
+                if voice or gender or age:
+                    raise ValueError(
+                        f"No matching voice found for specified criteria. Available voices: {[v.name for v in voices]}"
+                    )
+            # Generate audio
+            if dir_save:
+                engine.save_to_file(text, dir_save)
+                print(f"Audio saved to {dir_save}")
+            else:
+                engine.say(text)
+
+            engine.runAndWait()
+        except Exception as e:
+            print(f"An error occurred: {e}")
+            #     # Explicitly terminate the pyttsx3 engine to release resources
+            try:
+                engine.stop()
+            except RuntimeError:
+                pass
+                # Safely exit the script if running interactively to avoid kernel restarts
+            try:
+                import sys
+
+                sys.exit()
+            except SystemExit:
+                pass
+    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"
+            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"
+            tts.save(dir_save)
+        try:
+            fopen(dir_save)
+        except Exception as e:
+            print(f"Error opening file: {e}")
+    print("done")
+
 def str2time(time_str, fmt="24"):
     """
     Convert a time string into the specified format.
@@ -2094,7 +2370,7 @@ def fload(fpath, kind=None, **kwargs):
             False if chunksize else True
         )  # when chunksize, recommend low_memory=False # default: 
         verbose = kwargs.pop("verbose", False)
-        if run_once_within(reverse=True):
+        if run_once_within(reverse=True) and verbose:
             use_pd("read_csv", verbose=verbose)
 
         if comment is None:# default: None
@@ -2212,7 +2488,7 @@ def fload(fpath, kind=None, **kwargs):
                         if chunksize:
                             df = _get_chunks(df)
                             print(df.shape)
-                        if not is_df_abnormal(df, verbose=0):  # normal
+                        if not is_df_abnormal(df, verbose=0) and verbose:  # normal
                             display(df.head(2))
                             print(f"shape: {df.shape}")
                             return df
@@ -2245,26 +2521,28 @@ def fload(fpath, kind=None, **kwargs):
                                         df = _get_chunks(df)
                                         print(df.shape)
                                     if not is_df_abnormal(df, verbose=0):
-                                        (
-                                            display(df.head(2))
-                                            if isinstance(df, pd.DataFrame)
-                                            else display("it is not a DataFrame")
-                                        )
-                                        (
-                                            print(f"shape: {df.shape}")
-                                            if isinstance(df, pd.DataFrame)
-                                            else display("it is not a DataFrame")
-                                        )
+                                        if verbose:
+                                            (
+                                                display(df.head(2))
+                                                if isinstance(df, pd.DataFrame) 
+                                                else display("it is not a DataFrame")
+                                            )
+                                            (
+                                                print(f"shape: {df.shape}")
+                                                if isinstance(df, pd.DataFrame) 
+                                                else display("it is not a DataFrame")
+                                            )
                                         return df
                                 except EmptyDataError as e:
                                     continue
                             else:
                                 pass
-        print(kwargs)
+        # print(kwargs)
         # if is_df_abnormal(df,verbose=verbose):
         #     df=pd.read_csv(fpath,**kwargs)
-        display(df.head(2))
-        print(f"shape: {df.shape}")
+        if verbose:
+            display(df.head(2))
+            print(f"shape: {df.shape}")
         return df
 
     def load_excel(fpath, **kwargs):
@@ -2300,7 +2578,7 @@ def fload(fpath, kind=None, **kwargs):
         engine = kwargs.get("engine", "pyarrow")
         verbose = kwargs.pop("verbose", False)
 
-        if run_once_within(reverse=True):
+        if run_once_within(reverse=True) and verbose:
             use_pd("read_parquet", verbose=verbose)
         try:
             df = pd.read_parquet(fpath, engine=engine, **kwargs)
@@ -2385,6 +2663,16 @@ 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()
+                text = rtf_to_text(rtf_content)
+                return text
+        except Exception as e:
+            print(f"Error loading RTF file: {e}")
 
     if kind is None:
         _, kind = os.path.splitext(fpath)
@@ -2427,6 +2715,7 @@ def fload(fpath, kind=None, **kwargs):
         "xml",
         "ipynb",
         "mtx",
+        "rtf"
     ]
     zip_types = [
         "gz",
@@ -2446,22 +2735,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}')
-    # if os.path.splitext(fpath)[1][1:].lower() in zip_types:
-    #     keep=kwargs.get("keep", False)
-    #     ifile=kwargs.get("ifile",(0,0))
-    #     kwargs.pop("keep",None)
-    #     kwargs.pop("ifile",None)
-    #     fpath_unzip=unzip(fpath)
-    #     if isinstance(fpath_unzip,list):
-    #         fpath_unzip=fpath_unzip[ifile[0]]
-    #     if os.path.isdir(fpath_unzip):
-    #         fpath_selected=listdir(fpath_unzip,kind=kind).fpath[ifile[1]]
-    #         fpath_unzip=fpath_selected
-    #     content_unzip=fload(fpath_unzip, **kwargs)
-    #     if not keep:
-    #         os.remove(fpath_unzip)
-    #     return content_unzip
+        )  # {supported_types}') 
 
     if kind == "docx":
         return load_docx(fpath)
@@ -2477,37 +2751,45 @@ def fload(fpath, kind=None, **kwargs):
         return load_xml(fpath)
     elif kind in ["csv", "tsv"]:
         # verbose = kwargs.pop("verbose", False)
-        if run_once_within(reverse=True):
-            use_pd("read_csv")
+        # if run_once_within(reverse=True) and verbose:
+        #     use_pd("read_csv")
         content = load_csv(fpath, **kwargs)
         return content
     elif kind == "pkl":
         verbose = kwargs.pop("verbose", False)
-        if run_once_within(reverse=True):
+        if run_once_within(reverse=True) and verbose:
             use_pd("read_pickle")
-        return pd.read_pickle(fpath, **kwargs)
+        try:
+            res_=pd.read_pickle(fpath, **kwargs)
+        except Exception as e:
+            import pickle
+            with open('sgd_classifier.pkl', 'rb') as f:
+                res_ = pickle.load(f)
+        return res_
     elif kind in ["ods", "ods", "odt"]:
         engine = kwargs.get("engine", "odf")
         kwargs.pop("engine", None)
         return load_excel(fpath, engine=engine, **kwargs)
     elif kind == "xls":
+        verbose = kwargs.pop("verbose", False)
         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) 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) 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) 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":
@@ -2578,6 +2860,8 @@ def fload(fpath, kind=None, **kwargs):
 
     elif kind == "mplstyle":
         return read_mplstyle(fpath)
+    elif kind == "rtf":
+        return load_rtf(fpath)
 
     else:
         print("direct reading...")
@@ -2616,6 +2900,38 @@ def fload(fpath, kind=None, **kwargs):
 # docx_content = fload('sample.docx')
 
 
+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}\"")
+        elif system == "Windows":  # Windows
+            # Ensure the path is handled correctly in Windows, escape spaces
+            os.system(f"start \"\" \"{fpath}\"")
+        elif system == "Linux":  # Linux
+            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.
@@ -3025,13 +3341,18 @@ def fsave(
             content.to_pickle(fpath, **kwargs)
         else:
             try:
-                print("trying to convert it as a DataFrame...")
                 content = pd.DataFrame(content)
                 content.to_pickle(fpath, **kwargs)
             except Exception as e:
-                raise ValueError(
-                    f"content is not a DataFrame, cannot be saved as a 'pkl' format: {e}"
-                )
+                try:
+                    import pickle
+                    with open(fpath, 'wb') as f:
+                        pickle.dump(content, f)
+                    print('done!', fpath)
+                except Exception as e:
+                    raise ValueError(
+                        f"content is not a DataFrame, cannot be saved as a 'pkl' format: {e}"
+                    )
     elif kind.lower() in ["fea", "feather", "ft", "fe", "feat", "fether"]:
         # Feather: The Feather format, based on Apache Arrow, is designed for fast I/O operations. It's
         # optimized for data analytics tasks and is especially fast when working with Pandas.
@@ -3187,16 +3508,22 @@ def isa(content, kind):
     """
     if "img" in kind.lower() or "image" in kind.lower():
         return is_image(content)
+    elif 'vid' in kind.lower():
+        return is_video(content)
+    elif 'aud' in kind.lower():
+        return is_audio(content)
     elif "doc" in kind.lower():
         return is_document(content)
     elif "zip" in kind.lower():
         return is_zip(content)
     elif "dir" in kind.lower() or ("f" in kind.lower() and "d" in kind.lower()):
         return os.path.isdir(content)
+    elif "code" in kind.lower():  # file
+        return is_code(content)
     elif "fi" in kind.lower():  # file
         return os.path.isfile(content)
     elif "num" in kind.lower():  # file
-        return os.path.isfile(content)
+        return isnum(content)
     elif "text" in kind.lower() or "txt" in kind.lower():  # file
         return is_text(content)
     elif "color" in kind.lower():  # file
@@ -3607,7 +3934,7 @@ def get_os(full=False, verbose=False):
                 "usage (%)": usage.percent,
             }
         except PermissionError:
-            system_info["Disk"][partition.device] = "Permission Denied"
+            system_info["disk"][partition.device] = "Permission Denied"
 
     # Network Information
     if_addrs = psutil.net_if_addrs()
@@ -3667,11 +3994,33 @@ def listdir(
     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 
     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.")
+            return bool(attribute & 2)  # FILE_ATTRIBUTE_HIDDEN
+        else:  # macOS/Linux: Hidden if the name starts with a dot
+            return os.path.basename(filepath).startswith(".")
+
+    def get_user():
+        """Retrieve the username of the current user."""
+        system = platform.system()
+        if system == "Windows":
+            return os.environ.get("USERNAME", "Unknown")
+        else:
+            import pwd
+            return pwd.getpwuid(os.getuid()).pw_name
+
     if isinstance(kind, list):
         f_ = []
         for kind_ in kind:
@@ -3681,7 +4030,7 @@ def listdir(
                 sort_by=sort_by,
                 ascending=ascending,
                 contains=contains,
-                booster=booster,# walk in subfolders
+                depth=depth,# walk in subfolders
                 hidden=hidden,
                 orient=orient,
                 output=output,
@@ -3710,12 +4059,24 @@ def listdir(
         "rootdir":[],
         "fname": [],
         "fpath": [],
+        "num":[],
+        "os":[]
     }
+    root_depth = rootdir.rstrip(os.sep).count(os.sep)
     for dirpath, dirnames, ls in os.walk(rootdir):
+        current_depth = dirpath.rstrip(os.sep).count(os.sep) - root_depth
+        # Check depth limit
+        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 d.startswith(".")]
-            ls = [i for i in ls if not i.startswith(".")]
-        for dirname in dirnames: 
+            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
+                continue
             if contains and not re.search(contains, dirname):
                 continue
             dirname_path = os.path.join(dirpath, dirname)
@@ -3734,21 +4095,23 @@ def listdir(
             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(os.path.getctime(dirname_path), unit="s")
+                pd.to_datetime(int(os.path.getctime(dirname_path)), unit="s")
             )
             f["modified_time"].append(
-                pd.to_datetime(os.path.getmtime(dirname_path), unit="s")
+                pd.to_datetime(int(os.path.getmtime(dirname_path)), unit="s")
             )
             f["last_open_time"].append(
-                pd.to_datetime(os.path.getatime(dirname_path), unit="s")
+                pd.to_datetime(int(os.path.getatime(dirname_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(get_user()),
             f["rootdir"].append(dirpath)
             f["fname"].append(filename)  # will be removed
             f["fpath"].append(fpath)  # will be removed
             i += 1
-        for item in ls: 
+        for item in ls:
+            if kind in fd:# only check folders
+                continue
             if contains and not re.search(contains, item):
                 continue
             item_path = os.path.join(dirpath, item)
@@ -3760,13 +4123,11 @@ def listdir(
                 continue
             filename, file_extension = os.path.splitext(item)
             if kind is not None:
-                if not kind.startswith("."):
-                    kind = "." + kind
                 is_folder = kind.lower() in fd and os.path.isdir(item_path)
                 is_file = kind.lower() in file_extension.lower() and (
                     os.path.isfile(item_path)
                 )
-                if kind in [".doc", ".img", ".zip"]:  # 选择大的类别
+                if kind in [".doc", ".img", ".zip",".code",".file",".image",".video",".audio"]:  # 选择大的类别
                     if kind != ".folder" and not isa(item_path, kind):
                         continue
                 elif kind in [".all"]:
@@ -3780,15 +4141,15 @@ def listdir(
             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["path"].append(os.path.join(os.path.dirname(item_path), item)) 
             f["created_time"].append(
-                pd.to_datetime(os.path.getctime(item_path), unit="s")
+                pd.to_datetime(int(os.path.getctime(item_path)), unit="s")
             )
             f["modified_time"].append(
-                pd.to_datetime(os.path.getmtime(item_path), unit="s")
+                pd.to_datetime(int(os.path.getmtime(item_path)), unit="s")
             )
             f["last_open_time"].append(
-                pd.to_datetime(os.path.getatime(item_path), unit="s")
+                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"),
@@ -3799,13 +4160,13 @@ def listdir(
 
         f["num"] = i
         f["os"] = get_os()  # os.uname().machine
-        if not booster: # go deeper subfolders
-            break
+        # if not booster: # go deeper subfolders
+        #     break
     #* 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",
-        "fname","fpath","permission","owner","os",]]
+        "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():
@@ -4173,39 +4534,233 @@ 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.
+
+    Args:
+        fpath (str): Path to the file.
+
+    Returns:
+        bool: True if the file is a recognized image, False otherwise.
+    """
     import mimetypes
+    # Known image MIME types
+    image_mime_types = {
+        "image/jpeg",
+        "image/png",
+        "image/gif",
+        "image/bmp",
+        "image/webp",
+        "image/tiff",
+        "image/x-icon",
+        "image/svg+xml",
+        "image/heic",
+        "image/heif",
+    }
 
+    # Known image file extensions
+    image_extensions = {
+        ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".tif", ".tiff", 
+        ".ico", ".svg", ".heic", ".heif",".fig",".jpg"
+    }
+
+    # Get MIME type using mimetypes
     mime_type, _ = mimetypes.guess_type(fpath)
-    if mime_type and mime_type.startswith("image"):
+
+    # Check MIME type
+    if mime_type in image_mime_types:
+        return True
+
+    # Fallback: Check file extension
+    ext = os.path.splitext(fpath)[-1].lower()  # Get the file extension and ensure lowercase
+    if ext in image_extensions:
+        return True
+
+    return False
+
+def is_video(fpath):
+    """
+    Determine if a given file is a video based on MIME type and file extension.
+
+    Args:
+        fpath (str): Path to the file.
+
+    Returns:
+        bool: True if the file is a recognized video, False otherwise.
+    """
+    import mimetypes
+    # Known video MIME types
+    video_mime_types = {
+        "video/mp4",
+        "video/quicktime",
+        "video/x-msvideo",
+        "video/x-matroska",
+        "video/x-flv",
+        "video/webm",
+        "video/ogg",
+        "video/x-ms-wmv",
+        "video/x-mpeg",
+        "video/3gpp",
+        "video/avi",
+        "video/mpeg",
+        "video/x-mpeg2",
+        "video/x-ms-asf",
+    }
+
+    # Known video file extensions
+    video_extensions = {
+        ".mp4", ".mov", ".avi", ".mkv", ".flv", ".webm", ".ogv", ".wmv", 
+        ".mpg", ".mpeg", ".3gp", ".mpeg2", ".asf", ".ts", ".m4v", ".divx",
+    }
+
+    # Get MIME type using mimetypes
+    mime_type, _ = mimetypes.guess_type(fpath)
+
+    # Check MIME type
+    if mime_type in video_mime_types:
+        return True
+
+    # Fallback: Check file extension
+    ext = os.path.splitext(fpath)[-1].lower()  # Get the file extension and ensure lowercase
+    if ext in video_extensions:
         return True
-    else:
-        return False
 
+    return False
 
 def is_document(fpath):
+    """
+    Determine if a given file is a document based on MIME type and file extension.
+
+    Args:
+        fpath (str): Path to the file.
+
+    Returns:
+        bool: True if the file is a recognized document, False otherwise.
+    """
     import mimetypes
+    # Define known MIME types for documents
+    document_mime_types = {
+        "text/",
+        "application/pdf",
+        "application/msword",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "application/vnd.ms-excel",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "application/vnd.ms-powerpoint",
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        "application/rtf",
+        "application/x-latex",
+        "application/vnd.oasis.opendocument.text",
+        "application/vnd.oasis.opendocument.spreadsheet",
+        "application/vnd.oasis.opendocument.presentation",
+    }
+
+    # Define extensions for fallback
+    document_extensions = {
+        ".txt",
+        ".log",
+        ".csv",
+        ".json",
+        ".xml",
+        ".pdf",
+        ".doc",
+        ".docx",
+        ".xls",
+        ".xlsx",
+        ".ppt",
+        ".pptx",
+        ".odt",
+        ".ods",
+        ".odp",
+        ".rtf",
+        ".tex",
+    }
 
+    # Get MIME type
     mime_type, _ = mimetypes.guess_type(fpath)
-    if mime_type and (
-        mime_type.startswith("text/")
-        or mime_type == "application/pdf"
-        or mime_type == "application/msword"
-        or mime_type
-        == "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-        or mime_type == "application/vnd.ms-excel"
-        or mime_type
-        == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-        or mime_type == "application/vnd.ms-powerpoint"
-        or mime_type
-        == "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-    ):
+    
+    # Check MIME type
+    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
+    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.
+
+    Args:
+        fpath (str): Path to the file.
+
+    Returns:
+        bool: True if the file is a recognized audio file, False otherwise.
+    """
+    import mimetypes
+    # Known audio MIME types
+    audio_mime_types = {
+        "audio/mpeg",
+        "audio/wav",
+        "audio/ogg",
+        "audio/aac",
+        "audio/flac",
+        "audio/midi",
+        "audio/x-midi",
+        "audio/x-wav",
+        "audio/x-flac",
+        "audio/pcm",
+        "audio/x-aiff",
+        "audio/x-m4a",
+    }
+
+    # Known audio file extensions
+    audio_extensions = {
+        ".mp3", ".wav", ".ogg", ".aac", ".flac", ".midi", ".m4a", 
+        ".aiff", ".pcm", ".wma", ".ape", ".alac", ".opus",
+    }
+
+    # Get MIME type using mimetypes
+    mime_type, _ = mimetypes.guess_type(fpath)
+
+    # Check MIME type
+    if mime_type in audio_mime_types:
+        return True
+
+    # Fallback: Check file extension
+    ext = os.path.splitext(fpath)[-1].lower()  # Get the file extension and ensure lowercase
+    if ext in audio_extensions:
         return True
-    else:
-        return False
 
+    return False
 
+def is_code(fpath):
+    """
+    Determine if a given file is a code file based on file extension and optionally MIME type.
+
+    Args:
+        fpath (str): Path to the file.
+        check_mime (bool): Whether to perform a MIME type check in addition to file extension check.
+
+    Returns:
+        bool: True if the file is a recognized code file, False otherwise.
+    """
+    # 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"
+    }
+
+    # Check file extension
+    ext = os.path.splitext(fpath)[-1].lower() 
+    if ext in code_extensions:
+        return True 
+    return False
+    
 def is_zip(fpath):
     import mimetypes
 
@@ -6190,12 +6745,12 @@ def df_astype(
 
 
 # ! DataFrame
-def df_sort_values(df, column, by=None, ascending=True, inplace=True, **kwargs):
+def df_sort_values(data, column, by=None, ascending=True, inplace=True, **kwargs):
     """
     Sort a DataFrame by a specified column based on a custom order or by count.
 
     Parameters:
-    - df: DataFrame to be sorted.
+    - data: DataFrame to be sorted.
     - column: The name of the column to sort by.
     - by: List specifying the custom order for sorting or 'count' to sort by frequency.
     - ascending: Boolean or list of booleans, default True.
@@ -6211,7 +6766,7 @@ def df_sort_values(df, column, by=None, ascending=True, inplace=True, **kwargs):
 
     if isinstance(by, str) and "count" in by.lower():
         # Count occurrences of each value in the specified column
-        value_counts = df[column].value_counts()
+        value_counts = data[column].value_counts()
 
         # Determine the order based on counts
         count_ascending = kwargs.pop("count_ascending", ascending)
@@ -6220,12 +6775,12 @@ def df_sort_values(df, column, by=None, ascending=True, inplace=True, **kwargs):
         ).index.tolist()
 
         # Convert to a categorical type with the new order
-        df[column] = pd.Categorical(df[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):
         # Convert the specified column to a categorical type with the custom order
-        df[column] = pd.Categorical(df[column], categories=by, ordered=True)
+        data[column] = pd.Categorical(data[column], categories=by, ordered=True)
     else:
         raise ValueError("Custom order must be a list or 'count'.")
 
@@ -6240,7 +6795,7 @@ def df_sort_values(df, column, by=None, ascending=True, inplace=True, **kwargs):
             return sorted_df
     except Exception as e:
         print(f"Error sorting DataFrame by '{column}': {e}")
-        return df
+        return data
 
 
 # # Example usage:
@@ -7742,7 +8297,7 @@ def df_reducer(
 # example:
 # df_reducer(data=data_log, columns=markers, n_components=2)
 
-def df_format(data, threshold_unique=0.5, verbose=False):
+def get_df_format(data, threshold_unique=0.5, verbose=False):
     """
     检测表格: long, wide or uncertain.
 
@@ -7834,13 +8389,16 @@ def df_format(data, threshold_unique=0.5, verbose=False):
     # Step 5: Clustering analysis on numerical columns for correlation in wide format
     numeric_cols = data.select_dtypes(include="number").columns
     if len(numeric_cols) > 1:
-        scaled_data = StandardScaler().fit_transform(data[numeric_cols].dropna())
-        clustering = AgglomerativeClustering(n_clusters=2).fit(scaled_data.T)
-        cluster_labels = pd.Series(clustering.labels_)
-        if cluster_labels.nunique() < len(numeric_cols) * 0.5:
-            wide_score += 2
-            if verbose:
-                print("Clustering on columns shows grouping, suggesting wide format.")
+        try:
+            scaled_data = StandardScaler().fit_transform(data[numeric_cols].dropna())
+            clustering = AgglomerativeClustering(n_clusters=2).fit(scaled_data.T)
+            cluster_labels = pd.Series(clustering.labels_)
+            if cluster_labels.nunique() < len(numeric_cols) * 0.5:
+                wide_score += 2
+                if verbose:
+                    print("Clustering on columns shows grouping, suggesting wide format.")
+        except Exception as e:
+            print(e) if verbose else None
 
     # Step 6: Inter-column correlation analysis
     if len(numeric_cols) > 1:
@@ -7868,11 +8426,14 @@ def df_format(data, threshold_unique=0.5, verbose=False):
 
     # Step 8: Multi-level clustering on rows to detect block structure for wide format
     if len(numeric_cols) > 1 and n_rows > 5:
-        clustering_rows = AgglomerativeClustering(n_clusters=2).fit(scaled_data)
-        if pd.Series(clustering_rows.labels_).nunique() < 2:
-            wide_score += 2
-            if verbose:
-                print("Row clustering reveals homogeneity, suggesting wide format.")
+        try:
+            clustering_rows = AgglomerativeClustering(n_clusters=2).fit(scaled_data)
+            if pd.Series(clustering_rows.labels_).nunique() < 2:
+                wide_score += 2
+                if verbose:
+                    print("Row clustering reveals homogeneity, suggesting wide format.")
+        except Exception as e:
+            print(e) if verbose else None
 
     # Step 9: Sequential name detection for time-series pattern in wide format
     if any(col.isdigit() or col.startswith("T") for col in col_names):
@@ -7881,15 +8442,18 @@ def df_format(data, threshold_unique=0.5, verbose=False):
             print("Detected time-like sequential column names, supporting wide format.")
 
     # Step 10: Entropy of numeric columns
-    numeric_entropy = data[numeric_cols].apply(
-        lambda x: entropy(pd.cut(x, bins=10).value_counts(normalize=True))
-    )
-    if numeric_entropy.mean() < 2:
-        wide_score += 2
-        if verbose:
-            print(
-                "Low entropy in numeric columns indicates stability across columns, supporting wide format."
-            )
+    try:
+        numeric_entropy = data[numeric_cols].apply(
+            lambda x: entropy(pd.cut(x, bins=10).value_counts(normalize=True))
+        )
+        if numeric_entropy.mean() < 2:
+            wide_score += 2
+            if verbose:
+                print(
+                    "Low entropy in numeric columns indicates stability across columns, supporting wide format."
+                )
+    except Exception as e:
+        print(e) if verbose else None
 
     # Step 11: Tie-breaking strategy if scores are equal
     if wide_score == long_score:
@@ -8905,3 +9469,286 @@ def get_phone(phone_number: str, region: str = None,verbose=True):
     if verbose:
         preview(res)
     return res
+
+
+def decode_pluscode(
+    pluscode: str, reference: tuple = (52.5200, 13.4050), return_bbox: bool = False
+):
+    """
+    Decodes a Plus Code into latitude and longitude (and optionally returns a bounding box).
+
+    Parameters:
+        pluscode (str): The Plus Code to decode. Can be full or short.
+        reference (tuple, optional): Reference latitude and longitude for decoding short Plus Codes.
+                                     Default is None, required if Plus Code is short.
+        return_bbox (bool): If True, returns the bounding box coordinates (latitude/longitude bounds).
+                            Default is False.
+
+    Returns:
+        tuple: (latitude, longitude) if `return_bbox` is False.
+               (latitude, longitude, bbox) if `return_bbox` is True.
+               bbox = (latitudeLo, latitudeHi, longitudeLo, longitudeHi)
+    Raises:
+        ValueError: If the Plus Code is invalid or reference is missing for a short code.
+
+    Usage:
+    lat, lon = decode_pluscode("7FG6+89")
+    print(f"Decoded Short Plus Code: Latitude: {lat}, Longitude: {lon}, Bounding Box: {bbox}")
+
+    lat, lon = decode_pluscode("9F4M7FG6+89")
+    print(f"Decoded Full Plus Code: Latitude: {lat}, Longitude: {lon}")
+    """
+    from openlocationcode import openlocationcode as olc
+
+    # Validate Plus Code
+    if not olc.isValid(pluscode):
+        raise ValueError(f"Invalid Plus Code: {pluscode}")
+
+    # Handle Short Plus Codes
+    if olc.isShort(pluscode):
+        if reference is None:
+            raise ValueError(
+                "Reference location (latitude, longitude) is required for decoding short Plus Codes."
+            )
+        # Recover the full Plus Code using the reference location
+        pluscode = olc.recoverNearest(pluscode, reference[0], reference[1])
+
+    # Decode the Plus Code
+    decoded = olc.decode(pluscode)
+
+    # Calculate the center point of the bounding box
+    latitude = (decoded.latitudeLo + decoded.latitudeHi) / 2
+    longitude = (decoded.longitudeLo + decoded.longitudeHi) / 2
+
+    if return_bbox:
+        bbox = (
+            decoded.latitudeLo,
+            decoded.latitudeHi,
+            decoded.longitudeLo,
+            decoded.longitudeHi,
+        )
+        return latitude, longitude, bbox
+
+    return latitude, longitude
+
+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:
+        get_loc("Berlin, Germany")  # Example city
+        # get_loc((48.8566, 2.3522))  # Example latitude and longitude
+        # get_loc("48 51 24.3 N")  # Example DMS input
+    """
+    from geopy.geocoders import Nominatim
+    import re
+
+    def dms_to_decimal(dms):
+        """
+        Convert DMS (Degrees, Minutes, Seconds) to Decimal format.
+        Input should be in the format of "DD MM SS" or "D M S".
+        """
+        # Regex pattern for DMS input
+        pattern = r"(\d{1,3})[^\d]*?(\d{1,2})[^\d]*?(\d{1,2})"
+        match = re.match(pattern, dms)
+
+        if match:
+            degrees, minutes, seconds = map(float, match.groups())
+            decimal = degrees + (minutes / 60) + (seconds / 3600)
+            return decimal
+        else:
+            raise ValueError("Invalid DMS format")
+
+    geolocator = Nominatim(user_agent="0413@mygmail.com)")
+    # Case 1: Input is a city name (string)
+    if isinstance(input_data, str) and not re.match(r"^\d+(\.\d+)?$", input_data):
+        location = geolocator.geocode(input_data)
+        if verbose:
+            print(
+                f"Latitude and Longitude for {input_data}: {location.latitude}, {location.longitude}"
+            )
+        else:
+            print(f"Could not find {input_data}.")
+        return location
+
+    # Case 2: Input is latitude and longitude (float or tuple)
+    elif isinstance(input_data, (float, tuple)):
+        if isinstance(input_data, tuple) and len(input_data) == 2:
+            latitude, longitude = input_data
+        elif isinstance(input_data, float):
+            latitude = input_data
+            longitude = None  # No longitude provided for a single float
+
+        # Reverse geocoding
+        location_reversed = geolocator.reverse(
+            (latitude, longitude) if longitude else latitude
+        )
+        if verbose:
+            print(
+                f"Address from coordinates ({latitude}, {longitude if longitude else ''}): {location_reversed.address}"
+            )
+        else:
+            print("Could not reverse geocode the coordinates.")
+        return location_reversed
+
+    # Case 3: Input is a DMS string
+    elif isinstance(input_data, str):
+        try:
+            decimal_lat = dms_to_decimal(input_data)
+            print(f"Converted DMS to decimal latitude: {decimal_lat}")
+
+            location_reversed = geolocator.reverse(decimal_lat)
+            if verbose:
+                print(f"Address from coordinates: {location_reversed.address}")
+            else:
+                print("Could not reverse geocode the coordinates.")
+            return location_reversed
+        except ValueError:
+            print(
+                "Invalid input format. Please provide a city name, latitude/longitude, or DMS string."
+            )
+
+def enpass(code: str, method: str="AES", key: str = None):
+    """
+    usage: enpass("admin")
+    Master encryption function that supports multiple methods: AES, RSA, and SHA256.
+    :param code: The input data to encrypt or hash.
+    :param method: The encryption or hashing method ('AES', 'RSA', or 'SHA256').
+    :param key: The key to use for encryption. For AES and RSA, it can be a password or key in PEM format.
+    :return: The encrypted data or hashed value.
+    """
+    import hashlib
+    # AES Encryption (Advanced)
+    def aes_encrypt(data: str, key: str):
+        """
+        Encrypts data using AES algorithm in CBC mode.
+        :param data: The data to encrypt.
+        :param key: The key to use for AES encryption.
+        :return: The encrypted data, base64 encoded.
+        """
+        from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+        from cryptography.hazmat.backends import default_backend
+        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
+
+        # Pad the data to be a multiple of 16 bytes using PKCS7
+        padder = padding.PKCS7(128).padder()
+        padded_data = padder.update(data.encode()) + padder.finalize()
+
+        # Create AES cipher object using CBC mode
+        cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
+        encryptor = cipher.encryptor()
+        encrypted_data = encryptor.update(padded_data) + encryptor.finalize()
+
+        # Return the base64 encoded result (IV + encrypted data)
+        return base64.b64encode(iv + encrypted_data).decode()
+
+    # RSA Encryption (Advanced)
+    def rsa_encrypt(data: str, public_key: str):
+        """
+        Encrypts data using RSA encryption with OAEP padding.
+        :param data: The data to encrypt.
+        :param public_key: The public key in PEM format.
+        :return: The encrypted data, base64 encoded.
+        """
+        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):
+        """
+        Generates a SHA256 hash of the data.
+        :param data: The data to hash.
+        :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]
+    if method == "AES":
+        return aes_encrypt(code, key)
+    elif method == "RSA":
+        return rsa_encrypt(code, key)
+    elif method == "SHA256":
+        return sha256_hash(code)
+    else:
+        raise ValueError("Unsupported encryption method")
+
+
+# Master Decryption Function (Supports AES, RSA)
+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.
+    :param method: The encryption method ('AES' or 'RSA').
+    :param key: The key to use for decryption. For AES and RSA, it can be a password or key in PEM format.
+    :return: The decrypted data.
+    """
+    import hashlib
+    def aes_decrypt(encrypted_data: str, key: str):
+        """
+        Decrypts data encrypted using AES in CBC mode.
+        :param encrypted_data: The encrypted data, base64 encoded.
+        :param key: The key to use for AES decryption.
+        :return: The decrypted data (string).
+        """
+        from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+        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
+
+        # Create AES cipher object using CBC mode
+        cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
+        decryptor = cipher.decryptor()
+        decrypted_data = decryptor.update(encrypted_data) + decryptor.finalize()
+
+        # Unpad the decrypted data using PKCS7
+        unpadder = padding.PKCS7(128).unpadder()
+        unpadded_data = unpadder.update(decrypted_data) + unpadder.finalize()
+
+        return unpadded_data.decode() 
+    def rsa_decrypt(encrypted_data: str, private_key: str):
+        """
+        Decrypts RSA-encrypted data using the private key.
+        :param encrypted_data: The encrypted data, base64 encoded.
+        :param private_key: The private key in PEM format.
+        :return: The decrypted data (string).
+        """
+        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)
+        decrypted_data = cipher_rsa.decrypt(encrypted_data)
+        return decrypted_data.decode()
+
+    if key is None:
+        key="worldpeace"
+    method=strcmp(method,["AES","RSA",'SHA256'])[0]
+    if method == "AES":
+        return aes_decrypt(encrypted_code, key)
+    elif method == "RSA":
+        return rsa_decrypt(encrypted_code, key)
+    elif method == "SHA256":
+        raise ValueError("SHA256 is a hash function and cannot be decrypted.")
+    else:
+        raise ValueError("Unsupported decryption method")