py2ls 0.2.4.25__py3-none-any.whl → 0.2.4.27__py3-none-any.whl

py2ls/ips.py

@@ -16,7 +16,12 @@ import warnings
 
 warnings.simplefilter("ignore", category=pd.errors.SettingWithCopyWarning)
 warnings.filterwarnings("ignore", category=pd.errors.PerformanceWarning)
-
+warnings.filterwarnings("ignore")
+import os
+import shutil
+import logging
+from pathlib import Path
+from datetime import datetime
 
 def run_once_within(duration=60,reverse=False):  # default 60s
     import time
@@ -541,8 +546,7 @@ def is_text(s):
 
 from typing import Any, Union
 
-
-def shared(*args, strict=True, n_shared=2, verbose=True):
+def share(*args, strict=True, n_shared=2, verbose=True):
     """
     check the shared elelements in two list.
     usage:
@@ -587,12 +591,68 @@ def shared(*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 '......'
+        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):
+    """
+    check the shared elelements in two list.
+    usage:
+        list1 = [1, 2, 3, 4, 5]
+        list2 = [4, 5, 6, 7, 8]
+        list3 = [5, 6, 9, 10]
+        a = shared(list1, list2,list3)
+    """
+    if verbose:
+        print("\n********* checking shared elements *********")
+
+    if len(args) == 1 and isinstance(args[0], list):
+        lists = args[0]  # Unpack the single list
+    else:
+        lists = args  # Use the provided arguments as lists
+    flattened_lists = [flatten(lst, verbose=verbose) for lst in lists]
+
+    if n_shared is None:
+        n_shared = len(flattened_lists)
+        strict = True
+    else:
+        strict = False
+    # Ensure all arguments are lists
+    if any(not isinstance(lst, list) for lst in flattened_lists):
+        print(f"{' ' * 2}All inputs must be lists.")
+        return []
+    first_list = flattened_lists[0]
+    shared_elements = [
+        item for item in first_list if all(item in lst for lst in flattened_lists)
+    ]
+    if strict:
+        # Strict mode: require elements to be in all lists
+        shared_elements = set(flattened_lists[0])
+        for lst in flattened_lists[1:]:
+            shared_elements.intersection_update(lst)
+    else:
+        from collections import Counter
 
-def not_shared(*args, strict=True, n_shared=2, verbose=False):
+        all_elements = [item for sublist in flattened_lists for item in sublist]
+        element_count = Counter(all_elements)
+        # Get elements that appear in at least n_shared lists
+        shared_elements = [
+            item for item, count in element_count.items() if count >= n_shared
+        ]
+
+    shared_elements = flatten(shared_elements, verbose=verbose)
+    if verbose:
+        elements2show = (
+            shared_elements if len(shared_elements) < 10 else shared_elements[:5]
+        )
+        print(f"{' '*2}{len(shared_elements)} elements shared: {' '*2}{elements2show}")
+        print("********* checking shared elements *********")
+    return shared_elements
+
+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:
@@ -600,7 +660,19 @@ def not_shared(*args, strict=True, n_shared=2, verbose=False):
         list2 = [4, 5, 6, 7, 8]
         not_shared(list1,list2)# output [1,3]
     """
-    _common = shared(*args, strict=strict, 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
+    usage:
+        list1 = [1, 8, 3, 3, 4, 5]
+        list2 = [4, 5, 6, 7, 8]
+        not_shared(list1,list2)# output [1,3]
+    """
+    _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
@@ -806,6 +878,19 @@ 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():
+        # value部分需要是list
+        if isinstance(value, list):
+            pass
+        # get the max_length
+        len_max = len(value) if len(value) > len_max else len_max
+        # 补齐长度
+    for key, value in dict_.items():
+        value.extend([fill] * (len_max - len(value)))
+        dict_[key] = value
+    return pd.DataFrame.from_dict(dict_)
 
 def str2time(time_str, fmt="24"):
     """
@@ -1254,7 +1339,7 @@ def docx2pdf(dir_docx, dir_pdf=None):
         convert(dir_docx)
 
 
-def img2pdf(dir_img, kind="jpeg", page=None, dir_save=None, page_size="a4", dpi=300):
+def img2pdf(dir_img, kind=None, page=None, dir_save=None, page_size="a4", dpi=300):
     import img2pdf as image2pdf
 
     def mm_to_point(size):
@@ -1263,7 +1348,8 @@ def img2pdf(dir_img, kind="jpeg", page=None, dir_save=None, page_size="a4", dpi=
     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("."):
         kind = "." + kind
     if dir_save is None:
@@ -1286,8 +1372,10 @@ def img2pdf(dir_img, kind="jpeg", page=None, dir_save=None, page_size="a4", dpi=
                 continue
             imgs.append(path)
     else:
-        imgs = [os.path.isdir(dir_img), dir_img]
-
+        imgs = [
+            # os.path.isdir(dir_img), 
+            dir_img]
+    print(imgs)
     if page_size:
         if isinstance(page_size, str):
             pdf_in_mm = mm_to_point(paper_size(page_size))
@@ -1983,7 +2071,6 @@ 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
@@ -1994,13 +2081,20 @@ def fload(fpath, kind=None, **kwargs):
         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}")
         engine = "c" if chunksize else engine  # when chunksize, recommend 'c'
         low_memory = kwargs.pop("low_memory", True)# default: True
         low_memory = (
             False if chunksize else True
         )  # when chunksize, recommend low_memory=False # default: 
         verbose = kwargs.pop("verbose", False)
-        if run_once_within():
+        if run_once_within(reverse=True):
             use_pd("read_csv", verbose=verbose)
 
         if comment is None:# default: None
@@ -2176,7 +2270,7 @@ def fload(fpath, kind=None, **kwargs):
     def load_excel(fpath, **kwargs):
         engine = kwargs.get("engine", "openpyxl")
         verbose = kwargs.pop("verbose", False)
-        if run_once_within():
+        if run_once_within(reverse=True):
             use_pd("read_excel", verbose=verbose)
         df = pd.read_excel(fpath, engine=engine, **kwargs)
         try:
@@ -2206,7 +2300,7 @@ def fload(fpath, kind=None, **kwargs):
         engine = kwargs.get("engine", "pyarrow")
         verbose = kwargs.pop("verbose", False)
 
-        if run_once_within():
+        if run_once_within(reverse=True):
             use_pd("read_parquet", verbose=verbose)
         try:
             df = pd.read_parquet(fpath, engine=engine, **kwargs)
@@ -2383,13 +2477,13 @@ def fload(fpath, kind=None, **kwargs):
         return load_xml(fpath)
     elif kind in ["csv", "tsv"]:
         # verbose = kwargs.pop("verbose", False)
-        if run_once_within():
+        if run_once_within(reverse=True):
             use_pd("read_csv")
         content = load_csv(fpath, **kwargs)
         return content
     elif kind == "pkl":
         verbose = kwargs.pop("verbose", False)
-        if run_once_within():
+        if run_once_within(reverse=True):
             use_pd("read_pickle")
         return pd.read_pickle(fpath, **kwargs)
     elif kind in ["ods", "ods", "odt"]:
@@ -2420,12 +2514,12 @@ def fload(fpath, kind=None, **kwargs):
         return load_ipynb(fpath, **kwargs)
     elif kind in ["parquet", "snappy"]:
         verbose = kwargs.pop("verbose", False)
-        if run_once_within():
+        if run_once_within(reverse=True):
             use_pd("read_parquet")
         return load_parquet(fpath, **kwargs)
     elif kind == "feather":
         verbose = kwargs.pop("verbose", False)
-        if run_once_within():
+        if run_once_within(reverse=True):
             use_pd("read_feather")
         content = pd.read_feather(fpath, **kwargs)
         return content
@@ -2684,7 +2778,7 @@ def fsave(
         # https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html
 
         verbose = kwargs.pop("verbose", False)
-        if run_once_within():
+        if run_once_within(reverse=True):
             use_pd("to_csv", verbose=verbose)
         kwargs_csv = dict(
             path_or_buf=None,
@@ -2716,7 +2810,7 @@ def fsave(
     def save_xlsx(fpath, data, **kwargs):
         verbose = kwargs.pop("verbose", False)
         sheet_name = kwargs.pop("sheet_name", "Sheet1")
-        if run_once_within():
+        if run_once_within(reverse=True):
             use_pd("to_excel", verbose=verbose)
         if any(kwargs):
             format_excel(df=data, filename=fpath, **kwargs)
@@ -3131,21 +3225,437 @@ def isa(content, kind):
         return False
 
 
-import sys
+def get_os(full=False, verbose=False):
+    """Collects comprehensive system information.
+    full(bool): True, get more detailed info
+    verbose(bool): True, print it
+    usage:
+        info = get_os(full=True, verbose=False)
+    """
+    import sys
+    import platform
+    import psutil
+    import GPUtil
+    import socket
+    import uuid
+    import cpuinfo
+    import os
+    import subprocess
+    from datetime import datetime, timedelta
+    from collections import defaultdict
+
+    def get_os_type():
+        os_name = sys.platform
+        if "dar" in os_name:
+            return "macOS"
+        else:
+            if "win" in os_name:
+                return "Windows"
+            elif "linux" in os_name:
+                return "Linux"
+            else:
+                print(f"{os_name}, returned 'None'")
+                return None
+
+    def get_os_info():
+        """Get the detailed OS name, version, and other platform-specific details."""
+
+        def get_mac_os_info():
+            """Get detailed macOS version and product name."""
+            try:
+                sw_vers = subprocess.check_output(["sw_vers"]).decode("utf-8")
+                product_name = (
+                    [
+                        line
+                        for line in sw_vers.split("\n")
+                        if line.startswith("ProductName")
+                    ][0]
+                    .split(":")[1]
+                    .strip()
+                )
+                product_version = (
+                    [
+                        line
+                        for line in sw_vers.split("\n")
+                        if line.startswith("ProductVersion")
+                    ][0]
+                    .split(":")[1]
+                    .strip()
+                )
+                build_version = (
+                    [
+                        line
+                        for line in sw_vers.split("\n")
+                        if line.startswith("BuildVersion")
+                    ][0]
+                    .split(":")[1]
+                    .strip()
+                )
+
+                # Return the formatted macOS name, version, and build
+                return f"{product_name} {product_version} (Build {build_version})"
+            except Exception as e:
+                return f"Error retrieving macOS name: {str(e)}"
+
+        def get_windows_info():
+            """Get detailed Windows version and edition."""
+            try:
+                # Get basic Windows version using platform
+                windows_version = platform.version()
+                release = platform.release()
+                version = platform.win32_ver()[0]
+
+                # Additional information using Windows-specific system commands
+                edition_command = "wmic os get caption"
+                edition = (
+                    subprocess.check_output(edition_command, shell=True)
+                    .decode("utf-8")
+                    .strip()
+                    .split("\n")[1]
+                )
 
+                # Return Windows information
+                return f"Windows {version} {release} ({edition})"
+            except Exception as e:
+                return f"Error retrieving Windows information: {str(e)}"
 
-def get_os():
-    os_name = sys.platform
-    if "dar" in os_name:
-        return "macOS"
-    else:
-        if "win" in os_name:
-            return "Windows"
-        elif "linux" in os_name:
-            return "Linux"
+        def get_linux_info():
+            """Get detailed Linux version and distribution info."""
+            try:
+                # Check /etc/os-release for modern Linux distros
+                with open("/etc/os-release") as f:
+                    os_info = f.readlines()
+
+                os_name = (
+                    next(line for line in os_info if line.startswith("NAME"))
+                    .split("=")[1]
+                    .strip()
+                    .replace('"', "")
+                )
+                os_version = (
+                    next(line for line in os_info if line.startswith("VERSION"))
+                    .split("=")[1]
+                    .strip()
+                    .replace('"', "")
+                )
+
+                # For additional info, check for the package manager (e.g., apt, dnf)
+                package_manager = "Unknown"
+                if os.path.exists("/usr/bin/apt"):
+                    package_manager = "APT (Debian/Ubuntu)"
+                elif os.path.exists("/usr/bin/dnf"):
+                    package_manager = "DNF (Fedora/RHEL)"
+
+                # Return Linux distribution, version, and package manager
+                return f"{os_name} {os_version} (Package Manager: {package_manager})"
+            except Exception as e:
+                return f"Error retrieving Linux information: {str(e)}"
+
+        os_name = platform.system()
+
+        if os_name == "Darwin":
+            return get_mac_os_info()
+        elif os_name == "Windows":
+            return get_windows_info()
+        elif os_name == "Linux":
+            return get_linux_info()
         else:
-            print(f"{os_name}, returned 'None'")
-            return None
+            return f"Unknown OS: {os_name} {platform.release()}"
+
+    def get_os_name_and_version():
+        os_name = platform.system()
+        if os_name == "Darwin":
+            try:
+                # Run 'sw_vers' command to get macOS details like "macOS Sequoia"
+                sw_vers = subprocess.check_output(["sw_vers"]).decode("utf-8")
+                product_name = (
+                    [
+                        line
+                        for line in sw_vers.split("\n")
+                        if line.startswith("ProductName")
+                    ][0]
+                    .split(":")[1]
+                    .strip()
+                )
+                product_version = (
+                    [
+                        line
+                        for line in sw_vers.split("\n")
+                        if line.startswith("ProductVersion")
+                    ][0]
+                    .split(":")[1]
+                    .strip()
+                )
+
+                # Return the formatted macOS name and version
+                return f"{product_name} {product_version}"
+
+            except Exception as e:
+                return f"Error retrieving macOS name: {str(e)}"
+
+        # For Windows, we use platform to get the OS name and version
+        elif os_name == "Windows":
+            os_version = platform.version()
+            return f"Windows {os_version}"
+
+        # For Linux, check for distribution info using platform and os-release file
+        elif os_name == "Linux":
+            try:
+                # Try to read Linux distribution info from '/etc/os-release'
+                with open("/etc/os-release") as f:
+                    os_info = f.readlines()
+
+                # Find fields like NAME and VERSION
+                os_name = (
+                    next(line for line in os_info if line.startswith("NAME"))
+                    .split("=")[1]
+                    .strip()
+                    .replace('"', "")
+                )
+                os_version = (
+                    next(line for line in os_info if line.startswith("VERSION"))
+                    .split("=")[1]
+                    .strip()
+                    .replace('"', "")
+                )
+                return f"{os_name} {os_version}"
+
+            except Exception as e:
+                return f"Error retrieving Linux name: {str(e)}"
+
+        # Default fallback (for unknown OS or edge cases)
+        return f"{os_name} {platform.release()}"
+
+    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
+
+    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]
+
+    def get_virtual_environment_info():
+        """Checks if the script is running in a virtual environment and returns details."""
+        try:
+            # Check if running in a virtual environment
+            if hasattr(sys, "real_prefix") or (
+                hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
+            ):
+                return {
+                    "Virtual Environment": sys.prefix,
+                    "Site-Packages Path": os.path.join(
+                        sys.prefix,
+                        "lib",
+                        "python{}/site-packages".format(sys.version_info.major),
+                    ),
+                }
+            else:
+                return {"Virtual Environment": "Not in a virtual environment"}
+        except Exception as e:
+            return {"Error": str(e)}
+
+    def get_temperatures():
+        """Returns temperature sensor readings."""
+        try:
+            return psutil.sensors_temperatures(fahrenheit=False)
+        except AttributeError:
+            return {"Error": "Temperature sensors not available"}
+
+    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"}
+
+    def get_disk_io():
+        """Returns disk I/O statistics."""
+        disk_io = psutil.disk_io_counters()
+        return {
+            "Read (GB)": disk_io.read_bytes / (1024**3),
+            "Write (GB)": disk_io.write_bytes / (1024**3),
+            "Read Count": disk_io.read_count,
+            "Write Count": disk_io.write_count,
+        }
+
+    def get_network_io():
+        """Returns network I/O statistics."""
+        net_io = psutil.net_io_counters()
+        return {
+            "Bytes Sent (GB)": net_io.bytes_sent / (1024**3),
+            "Bytes Received (GB)": net_io.bytes_recv / (1024**3),
+            "Packets Sent": net_io.packets_sent,
+            "Packets Received": net_io.packets_recv,
+        }
+
+    def run_shell_command(command):
+        """Runs a shell command and returns its output."""
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            return (
+                result.stdout.strip()
+                if result.returncode == 0
+                else result.stderr.strip()
+            )
+        except Exception as e:
+            return f"Error running command: {e}"
+
+    system_info = {
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "os": get_os_type(),
+        "system": {
+            "os": get_os_info(),
+            "platform": f"{platform.system()} {platform.release()}",
+            "version": platform.version(),
+            "machine": platform.machine(),
+            "processor": platform.processor(),
+            "architecture": platform.architecture()[0],
+            "hostname": socket.gethostname(),
+            "ip address": socket.gethostbyname(socket.gethostname()),
+            "mac address": ":".join(
+                ["{:02x}".format((uuid.getnode() >> i) & 0xFF) for i in range(0, 48, 8)]
+            ),
+            "cpu brand": cpuinfo.get_cpu_info().get("brand_raw", "Unknown"),
+            "python version": platform.python_version(),
+            "uptime": get_system_uptime(),
+        },
+        "cpu": {
+            "physical cores": psutil.cpu_count(logical=False),
+            "logical cores": psutil.cpu_count(logical=True),
+            "max frequency (MHz)": psutil.cpu_freq().max,
+            "min frequency (MHz)": psutil.cpu_freq().min,
+            "current frequency (MHz)": psutil.cpu_freq().current,
+            "usage per core (%)": psutil.cpu_percent(percpu=True),
+            "total cpu Usage (%)": psutil.cpu_percent(),
+            "load average (1m, 5m, 15m)": (
+                os.getloadavg() if hasattr(os, "getloadavg") else "N/A"
+            ),
+        },
+        "memory": {
+            "total memory (GB)": psutil.virtual_memory().total / (1024**3),
+            "available memory (GB)": psutil.virtual_memory().available / (1024**3),
+            "used memory (GB)": psutil.virtual_memory().used / (1024**3),
+            "memory usage (%)": psutil.virtual_memory().percent,
+            "swap total (GB)": psutil.swap_memory().total / (1024**3),
+            "swap free (GB)": psutil.swap_memory().free / (1024**3),
+            "swap used (GB)": psutil.swap_memory().used / (1024**3),
+            "swap usage (%)": psutil.swap_memory().percent,
+        },
+        "disk": {},
+        "disk io": get_disk_io(),
+        "network": {},
+        "network io": get_network_io(),
+        "gpu": [],
+        "temperatures": get_temperatures(),
+        "battery": get_battery_status(),
+        "active processes": get_active_processes(),
+        "environment": {
+            "user": os.getenv("USER", "Unknown"),
+            "environment variables": dict(os.environ),
+            "virtual environment info": get_virtual_environment_info(),  # Virtual env details
+            "docker running": os.path.exists("/.dockerenv"),  # Check for Docker
+            "shell": os.environ.get("SHELL", "Unknown"),
+            "default terminal": run_shell_command("echo $TERM"),
+            "kernel version": platform.uname().release,
+            "virtualization type": run_shell_command("systemd-detect-virt"),
+        },
+        "additional info": {
+            "Shell": os.environ.get("SHELL", "Unknown"),
+            "default terminal": run_shell_command("echo $TERM"),
+            "kernel version": platform.uname().release,
+            "virtualization type": run_shell_command("systemd-detect-virt"),
+            "running in docker": os.path.exists("/.dockerenv"),
+        },
+    }
+
+    # Disk Information
+    for partition in psutil.disk_partitions():
+        try:
+            usage = psutil.disk_usage(partition.mountpoint)
+            system_info["disk"][partition.device] = {
+                "mountpoint": partition.mountpoint,
+                "file system type": partition.fstype,
+                "total size (GB)": usage.total / (1024**3),
+                "used (GB)": usage.used / (1024**3),
+                "free (GB)": usage.free / (1024**3),
+                "usage (%)": usage.percent,
+            }
+        except PermissionError:
+            system_info["Disk"][partition.device] = "Permission Denied"
+
+    # Network Information
+    if_addrs = psutil.net_if_addrs()
+    for interface_name, interface_addresses in if_addrs.items():
+        system_info["network"][interface_name] = []
+        for address in interface_addresses:
+            if str(address.family) == "AddressFamily.AF_INET":
+                system_info["network"][interface_name].append(
+                    {
+                        "ip address": address.address,
+                        "netmask": address.netmask,
+                        "broadcast ip": address.broadcast,
+                    }
+                )
+            elif str(address.family) == "AddressFamily.AF_PACKET":
+                system_info["network"][interface_name].append(
+                    {
+                        "mac address": address.address,
+                        "netmask": address.netmask,
+                        "broadcast mac": address.broadcast,
+                    }
+                )
+
+    # GPU Information
+    gpus = GPUtil.getGPUs()
+    for gpu in gpus:
+        gpu_info = {
+            "name": gpu.name,
+            "load (%)": gpu.load * 100,
+            "free memory (MB)": gpu.memoryFree,
+            "used memory (MB)": gpu.memoryUsed,
+            "total memory (MB)": gpu.memoryTotal,
+            "driver version": gpu.driver,
+            "temperature (°C)": gpu.temperature,
+        }
+        if hasattr(gpu, "powerDraw"):
+            gpu_info["Power Draw (W)"] = gpu.powerDraw
+        if hasattr(gpu, "powerLimit"):
+            gpu_info["Power Limit (W)"] = gpu.powerLimit
+        system_info["gpu"].append(gpu_info)
+
+    res = system_info if full else get_os_type()
+    if verbose:
+        try:
+            preview(res)
+        except Exception as e:
+            pnrint(e)
+    return res
 
 
 def listdir(
@@ -3168,8 +3678,9 @@ def listdir(
                 print(ls)
         df_all = pd.DataFrame(
             {
-                "fname": ls,
-                "fpath": [os.path.join(rootdir, i) for i in ls],
+                "name": ls,
+                "path": [os.path.join(rootdir, i) for i in ls],
+                "kind":[os.path.splitext(i)[1] for i in ls]
             }
         )
         if verbose:
@@ -3308,7 +3819,94 @@ 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:
+        src = Path(src)
+        dst = Path(dst)
+        if not src.is_dir():
+            if dst.is_dir():
+                dst = dst / src.name
+
+            if dst.exists():
+                if overwrite:
+                    dst.unlink()
+                else:
+                    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
+            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')}")
+            shutil.copytree(src, dst)
+            print(f"\n Done! copy to {dst}\n")
+
+    except Exception as e:
+        logging.error(f"Failed {e}")
+        
+def move(src, dst, overwrite=False):
+    return cut(src=src, dst=dst, overwrite=overwrite)
 
+def cut(src, dst, overwrite=False):
+    try:
+        src = Path(src)
+        dst = Path(dst)
+        if dst.is_dir():
+            dst = dst / src.name
+        if dst.exists():
+            if overwrite:
+                # dst.unlink()  # Delete the existing file
+                pass
+            else:
+                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.""" 
+    try:
+        fpath = Path(fpath)
+        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
+            if fpath.exists():
+                shutil.rmtree(fpath)  # Remove existing directory
+                print(f"\n Done! delete {fpath}\n")
+            else:
+                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
+        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)
+            if dst_kind is not None and src_kind is not None:
+                if dst_kind!=src_kind:
+                    dst=dst + src_kind
+        if os.path.exists(fpath):
+            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.
@@ -3327,7 +3925,9 @@ 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
-    current_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 '/'
+    
     for part in dir_parts:
         if part:
             current_path = os.path.join(current_path, part)
@@ -3351,10 +3951,13 @@ def mkdir(pardir: str = None, chdir: str | list = None, overwrite=False):
     Returns:
     - str: The path of the created directory or an error message.
     """
-
     rootdir = []
+    pardir= mkdir_nest(pardir)
     if chdir is None:
-        return mkdir_nest(pardir)
+        return pardir
+    else:
+        pass
+    print(pardir)
     if isinstance(chdir, str):
         chdir = [chdir]
     chdir = list(set(chdir))
@@ -3392,7 +3995,7 @@ def mkdir(pardir: str = None, chdir: str | list = None, overwrite=False):
     # Dir is the main output, if only one dir, then str type is inconvenient
     if len(rootdir) == 1:
         rootdir = rootdir[0]
-    rootdir = rootdir + stype if not rootdir.endswith(stype) else rootdir
+        rootdir = rootdir + stype if not rootdir.endswith(stype) else rootdir
 
     return rootdir
 
@@ -3791,6 +4394,114 @@ 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
+    from skimage import transform, feature, filters, measure
+    from skimage.color import rgb2gray
+    from scipy.fftpack import fftshift, fft2
+    import numpy as np
+    import cv2 
+    # Convert to grayscale
+    gray_image = rgb2gray(image)
+
+    # Detect edges using Canny edge detector
+    edges = feature.canny(gray_image, sigma=2)
+
+    # Use Hough transform to detect lines
+    lines = transform.probabilistic_hough_line(edges)
+
+    if not lines and any(["me" in by, "pca" in by]):
+        print("No lines detected. Adjust the edge detection parameters.")
+        return 0
+
+    # Hough Transform-based angle detection (Median/Mean)
+    if "me" in by:
+        angles = []
+        for line in lines:
+            (x0, y0), (x1, y1) = line
+            angle = np.arctan2(y1 - y0, x1 - x0) * 180 / np.pi
+            if 80 < abs(angle) < 100:
+                angles.append(angle)
+        if not angles:
+            return 0
+        if "di" in by:
+            median_angle = np.median(angles)
+            rotation_angle = (
+                90 - median_angle if median_angle > 0 else -90 - median_angle
+            )
+
+            return rotation_angle
+        else:
+            mean_angle = np.mean(angles)
+            rotation_angle = 90 - mean_angle if mean_angle > 0 else -90 - mean_angle
+
+            return rotation_angle
+
+    # PCA-based angle detection
+    elif "pca" in by:
+        y, x = np.nonzero(edges)
+        if len(x) == 0:
+            return 0
+        pca = PCA(n_components=2)
+        pca.fit(np.vstack((x, y)).T)
+        angle = np.arctan2(pca.components_[0, 1], pca.components_[0, 0]) * 180 / np.pi
+        return angle
+
+    # Gradient Orientation-based angle detection
+    elif "gra" in by:
+        gx, gy = np.gradient(gray_image)
+        angles = np.arctan2(gy, gx) * 180 / np.pi
+        hist, bin_edges = np.histogram(angles, bins=360, range=(-180, 180))
+        return bin_edges[np.argmax(hist)]
+
+    # Template Matching-based angle detection
+    elif "temp" in by:
+        if template is None:
+            # Automatically extract a template from the center of the image
+            height, width = gray_image.shape
+            center_x, center_y = width // 2, height // 2
+            size = (
+                min(height, width) // 4
+            )  # Size of the template as a fraction of image size
+            template = gray_image[
+                center_y - size : center_y + size, center_x - size : center_x + size
+            ]
+        best_angle = None
+        best_corr = -1
+        for angle in range(0, 180, 1):  # Checking every degree
+            rotated_template = transform.rotate(template, angle)
+            res = cv2.matchTemplate(gray_image, rotated_template, cv2.TM_CCOEFF)
+            _, max_val, _, _ = cv2.minMaxLoc(res)
+            if max_val > best_corr:
+                best_corr = max_val
+                best_angle = angle
+        return best_angle
+
+    # Image Moments-based angle detection
+    elif "mo" in by:
+        moments = measure.moments_central(gray_image)
+        angle = (
+            0.5
+            * np.arctan2(2 * moments[1, 1], moments[0, 2] - moments[2, 0])
+            * 180
+            / np.pi
+        )
+        return angle
+
+    # Fourier Transform-based angle detection
+    elif "fft" in by:
+        f = fft2(gray_image)
+        fshift = fftshift(f)
+        magnitude_spectrum = np.log(np.abs(fshift) + 1)
+        rows, cols = magnitude_spectrum.shape
+        r, c = np.unravel_index(np.argmax(magnitude_spectrum), (rows, cols))
+        angle = np.arctan2(r - rows // 2, c - cols // 2) * 180 / np.pi
+        return angle
+
+    else:
+        print(f"Unknown method {by}")
+        return 0
 
 def imgsets(img, **kwargs):
     """
@@ -5911,6 +6622,9 @@ def df_scaler(
     scaler=None,
     method="standard",
     columns=None,  # default, select all numeric col/row
+    feature_range=None,# specific for 'minmax'
+    vmin=0,
+    vmax=1,
     inplace=False,
     verbose=False,  # show usage
     axis=0,  # defalut column-wise
@@ -5943,11 +6657,13 @@ def df_scaler(
             scaler = StandardScaler(**kwargs)
         elif method == "minmax":
             from sklearn.preprocessing import MinMaxScaler
+            if feature_range is None:
+                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(**kwargs)
+            scaler = MinMaxScaler(feature_range=feature_range,**kwargs)
         elif method == "robust":
             from sklearn.preprocessing import RobustScaler
             if verbose:
@@ -6035,15 +6751,20 @@ def df_special_characters_cleaner(
 
     # 1. Clean column names by replacing special characters with underscores
     if "column" in where_:
-        data.columns = data.columns.str.replace(r"[^\w\s]", "_", regex=True)
+        try:
+            data.columns = data.columns.str.replace(r"[^\w\s]", "_", regex=True)
+        except Exception as e:
+            print(e)
 
     # 2. Clean only object-type columns (text columns)
-    if "content" in where_:
-        for col in data.select_dtypes(include=["object"]).columns:
-            data[col] = data[col].str.replace(r"[^\w\s]", "", regex=True)
-    if data.index.dtype == "object" and index in where_:
-        data.index = data.index.str.replace(r"[^\w\s]", "_", regex=True)
-
+    try:
+        if "content" in where_:
+            for col in data.select_dtypes(include=["object"]).columns:
+                data[col] = data[col].str.replace(r"[^\w\s]", "", regex=True)
+        if data.index.dtype == "object" and index in where_:
+            data.index = data.index.str.replace(r"[^\w\s]", "_", regex=True)
+    except:
+        pass
     return data
 
 
@@ -6426,6 +7147,9 @@ def df_reducer(
         # "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
@@ -6433,16 +7157,20 @@ def df_reducer(
         columns = data.select_dtypes(include="number").columns.tolist()
     if hue is None:
         hue = data.select_dtypes(exclude="number").columns.tolist()
+        print(f"auto select the non-number as 'hue':{hue}")
     if isinstance(hue, list):
         print("Warning: hue is a list, only select the 1st one")
         hue = hue[0]
-    if not hue:
+    if not any(hue):
         # Select columns if specified, else use all columns
         X = data[columns].values if columns else data.values
     else:
         # Select columns to reduce and hue for LDA
-        X = data[columns].values if columns else data.drop(columns=[hue]).values
-        y = data[hue].values
+        try:
+            X = data[columns].values if columns else data.drop(columns=[hue]).values
+            y = data[hue].values
+        except:
+            pass
     print(X.shape)
     # Handle missing values
     if fill_missing:
@@ -6909,33 +7637,49 @@ def df_reducer(
         colname_met = "SVD_"
     # Quick plots
     if plot_ and (not method in ["isolation_forest"]):
-        from .plot import plotxy
-        if ax is None:
-            if figsize is None:
-                _, ax = plt.subplots(figsize=cm2inch(8, 8))
-            else:
-                _, ax = plt.subplots(figsize=figsize)
-        else:
-            ax = ax.cla()
+        from .plot import plotxy,figsets,get_color
+        # if ax is None:
+        #     if figsize is None:
+        #         _, ax = plt.subplots(figsize=cm2inch(8, 8))
+        #     else:
+        #         _, ax = plt.subplots(figsize=figsize)
+        # else:
+        #     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)))
+
+        reduced_df=reduced_df.sort_values(by=hue)
+        print(flatten(reduced_df[hue]))
         ax = plotxy(
             data=reduced_df,
             x=colname_met + "1",
             y=colname_met + "2",
             hue=hue,
-            s=size,
+            palette=palette,
+            # size=size,
             edgecolor=edgecolor,
-            kind_="scater",
-            figsets=dict(
-                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,
-            ),
-            ax=ax,
+            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),
             verbose=False,
             **kwargs,
         )
+        figsets(
+            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,
+        )
 
     if inplace:
         # If inplace=True, add components back into the original data
@@ -7412,6 +8156,7 @@ 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:
@@ -7428,16 +8173,18 @@ def df_qc(
     data = data.copy()
     data.loc[:, data.isna().all()] = 0
     res_qc = {}
-    print(f"data.shape:{data.shape}")
+    print(f"⤵ data.shape:{data.shape}\n⤵ data.sample(10):")
+    display(data.sample(10).style.background_gradient(cmap="coolwarm", axis=1))
 
     # Missing values
     res_qc["missing_values"] = data.isnull().sum()
-    res_qc["missing_percentage"] = (res_qc["missing_values"] / len(data)) * 100
+    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_values"] = data.nunique()
+    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
     ]
@@ -7453,33 +8200,42 @@ 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=(outlier_num / len(data_outliers)) * 100
+    outlier_percentage=round((outlier_num / len(data_outliers)) * 100,2)
     res_qc["outlier_percentage"] = outlier_percentage[outlier_percentage>0]
-    # Correlation and multicollinearity (VIF)
-    if any(data.dtypes.apply(pd.api.types.is_numeric_dtype)):
-        numeric_df = data.select_dtypes(include=[np.number]).dropna()
-        corr_matrix = numeric_df.corr()
-        high_corr_pairs = [
-            (col1, col2)
-            for col1 in corr_matrix.columns
-            for col2 in corr_matrix.columns
-            if col1 != col2 and abs(corr_matrix[col1][col2]) > 0.9
-        ]
-        res_qc["high_correlations"] = high_corr_pairs
-
-        # VIF for multicollinearity check
-        numeric_df = data.select_dtypes(include=[np.number]).dropna()
-        vif_data = pd.DataFrame()
-        res_qc["vif"]=vif_data
-        if numeric_df.shape[1] > 1 and not numeric_df.empty:
-            vif_data["feature"] = numeric_df.columns
-            vif_data["VIF"] = [
-                variance_inflation_factor(numeric_df.values, i)
-                for i in range(numeric_df.shape[1])
+    try:
+        # Correlation and multicollinearity (VIF)
+        if any(data.dtypes.apply(pd.api.types.is_numeric_dtype)):
+            numeric_df = data.select_dtypes(include=[np.number]).dropna()
+            corr_matrix = numeric_df.corr()
+            high_corr_pairs = [
+                (col1, col2)
+                for col1 in corr_matrix.columns
+                for col2 in corr_matrix.columns
+                if col1 != col2 and abs(corr_matrix[col1][col2]) > 0.9
             ]
-            res_qc["vif"] = vif_data[
-                vif_data["VIF"] > 5
-            ]  # Typically VIF > 5 indicates multicollinearity
+            res_qc["high_correlations"] = high_corr_pairs
+
+            # VIF for multicollinearity check
+            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
+                ]
+
+            
+            vif_data = pd.DataFrame()
+            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)
+                    for i in range(numeric_df.shape[1])
+                ]
+                res_qc["vif"] = vif_data[
+                    vif_data["VIF"] > 5
+                ]  # Typically VIF > 5 indicates multicollinearity
+    except Exception as e:
+        print(e)
     # Skewness and Kurtosis
     skewness = data.skew(numeric_only=True)
     kurtosis_vals = data.kurt(numeric_only=True)
@@ -7492,8 +8248,7 @@ def df_qc(
         col: entropy(data[col].value_counts(normalize=True), base=2)
         for col in categorical_cols
     }
-    # number of unique
-    res_qc["unique_counts"] = data.nunique()
+
     # dtypes counts
     res_qc['dtype_counts']=data.dtypes.value_counts()
     
@@ -7540,7 +8295,7 @@ def df_qc(
     res_qc["text_length_analysis"] = text_lengths
 
     # Summary statistics
-    res_qc["summary_statistics"] = data.describe().T
+    res_qc["summary_statistics"] = data.describe().T.style.background_gradient(cmap='coolwarm', axis=0)
 
     # Automated warnings
     warnings = []
@@ -7562,28 +8317,45 @@ def df_qc(
 
     # Report generation
     if verbose:
-        print("=== QC Report Summary ===")
         print("\n⤵  Summary Statistics:")
         display(res_qc["summary_statistics"])
         print("\n⤵  Data Types:")
         display(res_qc["data_types"])
         if any(res_qc["missing_values"][res_qc["missing_values"] > 0]):
             print(" ⤵  Missing Values Counts:")
-            display(res_qc["missing_values"][res_qc["missing_values"] > 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⤵  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(res_qc["outlier_num"])
-        if any(res_qc["unique_values"]):
-            print("\n⤵  Unique Values per Column:")
-            display(res_qc["unique_values"])
+            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)
+                    )
 
-        print("\n⤵  Constant Columns:", res_qc["constant_columns"]) if any(res_qc["constant_columns"]) else None
+        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))
 
-        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 res_qc["empty_columns"]:
             print("\n⤵  Empty Columns:", res_qc["empty_columns"])
@@ -7595,7 +8367,7 @@ def df_qc(
 
         if "vif" in res_qc:
             print("\n⤵  Features with High VIF (>|5|):")
-            print(res_qc["vif"])
+            display(res_qc["vif"].style.background_gradient(cmap="coolwarm", axis=0))
 
         if any(res_qc["high_cardinality_categoricals"]):
             print("\n⤵  High Cardinality Categorical Columns (>|50 unique|):")
@@ -7614,6 +8386,8 @@ def df_qc(
             print("\nWarnings:")
             for warning in res_qc["warnings"]:
                 print("  -", warning)
+
+    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)
     if output or not plot_:
@@ -7632,7 +8406,7 @@ def df_qc_plots(data: pd.DataFrame, columns=None,res_qc: dict=None, max_cols=20,
         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
+    n_row, n_col = int((len_total + 10)), 3
     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(
@@ -7789,8 +8563,10 @@ 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()
 
     # High cardinality: Show top categorical columns by unique value count
     high_cardinality = res_qc["high_cardinality_categoricals"]
@@ -7871,16 +8647,17 @@ def df_qc_plots(data: pd.DataFrame, columns=None,res_qc: dict=None, max_cols=20,
                 title="Correlation Heatmap",
                 ax=ax_heatmap
             )
-    # save figure
-    if dir_save:
-        figsave(dir_save,f"qc_plot_{now_}.pdf")
+    # # 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]
-    len_total = len(res_qc)
-    n_row, n_col = int((len_total + 10) / 3), 3
-    nexttile = subplot(n_row, n_col, figsize=[5 * n_col, 5 * n_row],verbose=False)
+
+    # len_total = len(res_qc)
+    # n_row, n_col = int((len_total + 10) / 3), 3
+    # nexttile = subplot(n_row, n_col, figsize=[5 * n_col, 5 * n_row],verbose=False)
     #! check distribution
     data_num = data.select_dtypes(include=np.number)
     if len(data_num) > max_cols:
@@ -7907,7 +8684,43 @@ def df_qc_plots(data: pd.DataFrame, columns=None,res_qc: dict=None, max_cols=20,
         figsets(ylabel=f'Q-Q Plot:{column}',title=None)
     # save figure
     if dir_save:
-        figsave(dir_save,f"qq_plot_{now_}.pdf")
+        figsave(dir_save,f"qc_plot_{now_}.pdf")
+
+def df_corr(df: pd.DataFrame, method="pearson"):
+    """
+    Compute correlation coefficients and p-values for a DataFrame.
+
+    Parameters:
+    - df (pd.DataFrame): Input DataFrame with numeric data.
+    - method (str): Correlation method ("pearson", "spearman", "kendall").
+
+    Returns:
+    - corr_matrix (pd.DataFrame): Correlation coefficient matrix.
+    - pval_matrix (pd.DataFrame): P-value matrix.
+    """
+    from scipy.stats import pearsonr, spearmanr, kendalltau
+
+    methods = ["pearson", "spearman", "kendall"]
+    method = strcmp(method, methods)[0]
+    methods_dict = {"pearson": pearsonr, "spearman": spearmanr, "kendall": kendalltau}
+
+    cols = df.columns
+    corr_matrix = pd.DataFrame(index=cols, columns=cols, dtype=float)
+    pval_matrix = pd.DataFrame(index=cols, columns=cols, dtype=float)
+    correlation_func = methods_dict[method]
+
+    for col1 in cols:
+        for col2 in cols:
+            if col1 == col2:
+                corr_matrix.loc[col1, col2] = 1.0
+                pval_matrix.loc[col1, col2] = 0.0
+            else:
+                corr, pval = correlation_func(df[col1], df[col2])
+                corr_matrix.loc[col1, col2] = corr
+                pval_matrix.loc[col1, col2] = pval
+
+    return corr_matrix, pval_matrix
+
 def use_pd(
     func_name="excel",
     verbose=True,
@@ -7927,3 +8740,135 @@ def use_pd(
     except Exception as e:
         if verbose:
             print(e)
+
+def get_phone(phone_number: str, region: str = None,verbose=True):
+    """
+    usage:
+        info = get_phone(15237654321, "DE")
+        preview(info)
+
+    Extremely advanced phone number analysis function.
+
+    Args:
+        phone_number (str): The phone number to analyze.
+        region (str): None (Default). Tries to work with international numbers including country codes; otherwise, uses the specified region.
+
+    Returns:
+        dict: Comprehensive information about the phone number.
+    """
+    import phonenumbers
+    from phonenumbers import geocoder, carrier, timezone, number_type
+    from datetime import datetime
+    import pytz
+    from tzlocal import get_localzone
+
+    if not isinstance(phone_number, str):
+        phone_number = str(phone_number)
+    if isinstance(region, str):
+        region = region.upper()
+
+    try:
+        # Parse the phone number
+        parsed_number = phonenumbers.parse(phone_number, region)
+
+        # Validate the phone number
+        valid = phonenumbers.is_valid_number(parsed_number)
+        possible = phonenumbers.is_possible_number(parsed_number)
+
+        if not valid:
+            suggested_fix = phonenumbers.example_number(region) if region else "Unknown"
+            return {
+                "valid": False,
+                "error": "Invalid phone number",
+                "suggested_fix": suggested_fix,
+            }
+
+        # Basic details
+        formatted_international = phonenumbers.format_number(
+            parsed_number, phonenumbers.PhoneNumberFormat.INTERNATIONAL
+        )
+        formatted_national = phonenumbers.format_number(
+            parsed_number, phonenumbers.PhoneNumberFormat.NATIONAL
+        )
+        formatted_e164 = phonenumbers.format_number(
+            parsed_number, phonenumbers.PhoneNumberFormat.E164
+        )
+        country_code = parsed_number.country_code
+        region_code = geocoder.region_code_for_number(parsed_number)
+        country_name = geocoder.country_name_for_number(parsed_number, "en")
+
+        location = geocoder.description_for_number(parsed_number, "en")
+        carrier_name = carrier.name_for_number(parsed_number, "en") or "Unknown Carrier"
+        time_zones = timezone.time_zones_for_number(parsed_number)[0]
+        current_times = datetime.now(pytz.timezone(time_zones)).strftime(
+            "%Y-%m-%d %H:%M:%S %Z"
+        )
+        number_type_str = {
+            phonenumbers.PhoneNumberType.FIXED_LINE: "Fixed Line",
+            phonenumbers.PhoneNumberType.MOBILE: "Mobile",
+            phonenumbers.PhoneNumberType.FIXED_LINE_OR_MOBILE: "Fixed Line or Mobile",
+            phonenumbers.PhoneNumberType.TOLL_FREE: "Toll Free",
+            phonenumbers.PhoneNumberType.PREMIUM_RATE: "Premium Rate",
+            phonenumbers.PhoneNumberType.SHARED_COST: "Shared Cost",
+            phonenumbers.PhoneNumberType.VOIP: "VOIP",
+            phonenumbers.PhoneNumberType.PERSONAL_NUMBER: "Personal Number",
+            phonenumbers.PhoneNumberType.PAGER: "Pager",
+            phonenumbers.PhoneNumberType.UAN: "UAN",
+            phonenumbers.PhoneNumberType.UNKNOWN: "Unknown",
+        }.get(number_type(parsed_number), "Unknown")
+
+        # Advanced Features
+        is_toll_free = (
+            number_type(parsed_number) == phonenumbers.PhoneNumberType.TOLL_FREE
+        )
+        is_premium_rate = (
+            number_type(parsed_number) == phonenumbers.PhoneNumberType.PREMIUM_RATE
+        )
+
+        # Dialing Information
+        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
+        # Get the local timezone (current computer's time)
+        local_timezone = get_localzone()
+        #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= {
+            "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,
+            "location": location if location else "Unknown",
+            "carrier": carrier_name,
+            "time_zone": time_zones,
+            "current_times": current_times,
+            "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,  
+            "dialing_instructions": dialing_instructions,
+            "suggested_fix": None,  # Use phonenumbers.example_number if invalid 
+            "logs": {
+                "number_analysis_completed": datetime.now().strftime(
+                    "%Y-%m-%d %H:%M:%S"
+                ),
+                "raw_input": phone_number,
+                "parsed_number": str(parsed_number),
+            },
+        }
+
+    except phonenumbers.NumberParseException as e:
+        res= {"valid": False, "error": str(e)}
+    if verbose:
+        preview(res)
+    return res