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

py2ls/ips.py

@@ -17,7 +17,11 @@ 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
@@ -874,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"):
     """
@@ -1322,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):
@@ -1331,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:
@@ -1354,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))
@@ -3205,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():
-    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_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_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(
@@ -3242,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:
@@ -3382,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.
@@ -3401,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)
@@ -3425,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))
@@ -3466,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
 
@@ -3865,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):
     """

py2ls/netfinder.py

@@ -1608,3 +1608,191 @@ def ai(*args, **kwargs):
     if len(args) == 1 and isinstance(args[0], str):
         kwargs["query"] = args[0]
     return echo(**kwargs)
+
+
+#! get_ip()
+def get_ip(ip=None):
+    """
+    Usage:
+        from py2ls import netfinder as nt
+        ip = nt.get_ip()
+    """
+
+    import requests
+    import time
+    import logging
+    from datetime import datetime, timedelta
+
+    # Set up logging configuration
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        handlers=[
+            logging.StreamHandler(),
+            logging.FileHandler("public_ip_log.log"),  # Log to a file
+        ],
+    )
+
+    cache = {}
+
+    # Function to fetch IP addresses synchronously
+    def fetch_ip(url, retries, timeout, headers):
+        """
+        Synchronous function to fetch the IP address with retries.
+        """
+        for attempt in range(retries):
+            try:
+                response = requests.get(url, timeout=timeout, headers=headers)
+                response.raise_for_status()
+                return response.json()
+            except requests.RequestException as e:
+                logging.error(f"Attempt {attempt + 1} failed: {e}")
+                if attempt < retries - 1:
+                    time.sleep(2**attempt)  # Exponential backoff
+                else:
+                    logging.error("Max retries reached.")
+                    return {"error": f"Error fetching IP: {e}"}
+            except requests.Timeout:
+                logging.error("Request timed out")
+                time.sleep(2**attempt)
+        return {"error": "Failed to fetch IP after retries"}
+
+    # Function to fetch geolocation synchronously
+    def fetch_geolocation(url, retries, timeout, headers):
+        """
+        Synchronous function to fetch geolocation data by IP address.
+        """
+        for attempt in range(retries):
+            try:
+                response = requests.get(url, timeout=timeout, headers=headers)
+                response.raise_for_status()
+                return response.json()
+            except requests.RequestException as e:
+                logging.error(f"Geolocation request attempt {attempt + 1} failed: {e}")
+                if attempt < retries - 1:
+                    time.sleep(2**attempt)  # Exponential backoff
+                else:
+                    logging.error("Max retries reached.")
+                    return {"error": f"Error fetching geolocation: {e}"}
+            except requests.Timeout:
+                logging.error("Geolocation request timed out")
+                time.sleep(2**attempt)
+        return {"error": "Failed to fetch geolocation after retries"}
+
+    # Main function to get public IP and geolocation
+    def get_public_ip(
+        ip4=True,
+        ip6=True,
+        verbose=True,
+        retries=3,
+        timeout=5,
+        geolocation=True,
+        headers=None,
+        cache_duration=5,
+    ):
+        """
+        Synchronously fetches public IPv4 and IPv6 addresses, along with optional geolocation info.
+        """
+        # Use the cache if it's still valid
+        cache_key_ip4 = "public_ip4"
+        cache_key_ip6 = "public_ip6"
+        cache_key_geolocation = "geolocation"
+
+        if (
+            cache
+            and cache_key_ip4 in cache
+            and datetime.now() < cache[cache_key_ip4]["expires"]
+        ):
+            logging.info("Cache hit for IPv4, using cached data.")
+            ip4_data = cache[cache_key_ip4]["data"]
+        else:
+            ip4_data = None
+
+        if (
+            cache
+            and cache_key_ip6 in cache
+            and datetime.now() < cache[cache_key_ip6]["expires"]
+        ):
+            logging.info("Cache hit for IPv6, using cached data.")
+            ip6_data = cache[cache_key_ip6]["data"]
+        else:
+            ip6_data = None
+
+        if (
+            cache
+            and cache_key_geolocation in cache
+            and datetime.now() < cache[cache_key_geolocation]["expires"]
+        ):
+            logging.info("Cache hit for Geolocation, using cached data.")
+            geolocation_data = cache[cache_key_geolocation]["data"]
+        else:
+            geolocation_data = None
+
+        # Fetch IPv4 if requested
+        if ip4 and not ip4_data:
+            logging.info("Fetching IPv4...")
+            ip4_data = fetch_ip(
+                "https://api.ipify.org?format=json", retries, timeout, headers
+            )
+            cache[cache_key_ip4] = {
+                "data": ip4_data,
+                "expires": datetime.now() + timedelta(minutes=cache_duration),
+            }
+
+        # Fetch IPv6 if requested
+        if ip6 and not ip6_data:
+            logging.info("Fetching IPv6...")
+            ip6_data = fetch_ip(
+                "https://api6.ipify.org?format=json", retries, timeout, headers
+            )
+            cache[cache_key_ip6] = {
+                "data": ip6_data,
+                "expires": datetime.now() + timedelta(minutes=cache_duration),
+            }
+
+        # Fetch geolocation if requested
+        if geolocation and not geolocation_data:
+            logging.info("Fetching Geolocation...")
+            geolocation_data = fetch_geolocation(
+                "https://ipinfo.io/json", retries, timeout, headers
+            )
+            cache[cache_key_geolocation] = {
+                "data": geolocation_data,
+                "expires": datetime.now() + timedelta(minutes=cache_duration),
+            }
+
+        # Prepare the results
+        ip_info = {
+            "ip4": ip4_data.get("ip") if ip4_data else "N/A",
+            "ip6": ip6_data.get("ip") if ip6_data else "N/A",
+            "geolocation": geolocation_data if geolocation_data else "N/A",
+        }
+
+        # Verbose output if requested
+        if verbose:
+            print(f"Public IPv4: {ip_info['ip4']}")
+            print(f"Public IPv6: {ip_info['ip6']}")
+            print(f"Geolocation: {ip_info['geolocation']}")
+
+        return ip_info
+
+    # Function to get geolocation data by IP
+    def get_geolocation_by_ip(ip, retries=3, timeout=5, headers=None):
+        """
+        Fetches geolocation data for a given IP address.
+        """
+        url = f"https://ipinfo.io/{ip}/json"
+        geolocation_data = fetch_geolocation(url, retries, timeout, headers)
+        return geolocation_data
+    #! here starting get_ip()
+    headers = {"User-Agent": user_agent()}
+    if ip is None:
+        try:
+            ip_data = get_public_ip(headers=headers, verbose=True)
+        except Exception as e:
+            print(e)
+            ip_data = None
+        return ip_data
+    else:
+        geolocation_data = get_geolocation_by_ip(ip, headers=headers)
+        return geolocation_data

py2ls/ocr.py

@@ -486,6 +486,18 @@ def preprocess_img(
 
     return img_preprocessed
 
+def convert_image_to_bytes(image):
+    """
+    Convert a CV2 or numpy image to bytes for ddddocr.
+    """
+    import io
+    # Convert OpenCV image (numpy array) to PIL image
+    if isinstance(image, np.ndarray):
+        image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+    # Save PIL image to a byte stream
+    img_byte_arr = io.BytesIO()
+    image.save(img_byte_arr, format='PNG')
+    return img_byte_arr.getvalue()
 
 def text_postprocess(
     text,
@@ -604,10 +616,11 @@ def get_text(
     """
         )
 
-    models = ["easyocr", "paddleocr", "pytesseract"]
+    models = ["easyocr", "paddleocr", "pytesseract","ddddocr"]
     model = strcmp(model, models)[0]
     lang = lang_auto_detect(lang, model)
     if isinstance(image, str):
+        dir_img=image
         image = cv2.imread(image)
 
     # Ensure lang is always a list
@@ -705,9 +718,10 @@ def get_text(
         )  # PaddleOCR supports only one language at a time
         result = ocr.ocr(image_process, **kwargs)
         detections = []
-        for line in result[0]:
-            bbox, (text, score) = line
-            detections.append((bbox, text, score))
+        if result[0] is not None:
+            for line in result[0]:
+                bbox, (text, score) = line
+                detections.append((bbox, text, score))
         if postprocess is None:
             postprocess = dict(
                 spell_check=True,
@@ -787,7 +801,49 @@ def get_text(
             else:
                 # 默认返回所有检测信息
                 return detections
+    elif "ddddocr" in  model.lower():
+        import ddddocr 
+        
+        ocr = ddddocr.DdddOcr(det=False, ocr=True)
+        image_bytes = convert_image_to_bytes(image_process)
+
+        results = ocr.classification(image_bytes)  # Text extraction
+
+        # Optional: Perform detection for bounding boxes
+        detections = []
+        if kwargs.get("det", False):
+            det_ocr = ddddocr.DdddOcr(det=True)
+            det_results = det_ocr.detect(image_bytes)
+            for box in det_results:
+                top_left = (box[0], box[1])
+                bottom_right = (box[2], box[3])
+                detections.append((top_left, bottom_right))
 
+        if postprocess is None:
+            postprocess = dict(
+                spell_check=True,
+                clean=True,
+                filter=dict(min_length=2),
+                pattern=None,
+                merge=True,
+            )
+            text_corr = []
+            [
+                text_corr.extend(text_postprocess(text, **postprocess))
+                for _, text, _ in detections
+            ]
+        # Visualization
+        if show:
+            if ax is None:
+                ax = plt.gca()
+            image_vis = image.copy()
+            if detections:
+                for top_left, bottom_right in detections:
+                    cv2.rectangle(image_vis, top_left, bottom_right, box_color, 2)
+            image_vis = cv2.cvtColor(image_vis, cmap)
+            ax.imshow(image_vis)
+            ax.axis("off")
+        return detections
     else:  # "pytesseract"
         if ax is None:
             ax = plt.gca()

{py2ls-0.2.4.26.dist-info → py2ls-0.2.4.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py2ls
-Version: 0.2.4.26
+Version: 0.2.4.27
 Summary: py(thon)2(too)ls
 Author: Jianfeng
 Author-email: Jianfeng.Liu0413@gmail.com
@@ -18,6 +18,7 @@ Provides-Extra: extr
 Requires-Dist: CacheControl (>=0.13.1)
 Requires-Dist: Cython (>=3.0.10)
 Requires-Dist: Deprecated (>=1.2.14)
+Requires-Dist: GPUtil (>=1.4.0)
 Requires-Dist: Jinja2 (>=3.1.4)
 Requires-Dist: Markdown (>=3.6)
 Requires-Dist: MarkupSafe (>=2.1.5)

{py2ls-0.2.4.26.dist-info → py2ls-0.2.4.27.dist-info}/RECORD

@@ -18,7 +18,7 @@ py2ls/.git/hooks/pre-receive.sample,sha256=pMPSuce7P9jRRBwxvU7nGlldZrRPz0ndsxAlI
 py2ls/.git/hooks/prepare-commit-msg.sample,sha256=6d3KpBif3dJe2X_Ix4nsp7bKFjkLI5KuMnbwyOGqRhk,1492
 py2ls/.git/hooks/push-to-checkout.sample,sha256=pT0HQXmLKHxt16-mSu5HPzBeZdP0lGO7nXQI7DsSv18,2783
 py2ls/.git/hooks/update.sample,sha256=jV8vqD4QPPCLV-qmdSHfkZT0XL28s32lKtWGCXoU0QY,3650
-py2ls/.git/index,sha256=tY-wVtv3c8-pVaRjwyhHPzN3gfiFSOedioDHy3a7G3U,4232
+py2ls/.git/index,sha256=X6N4wzd4ONwHaOyemlvaqQkoXIroIn7A7Q7RgUgXpaI,4232
 py2ls/.git/info/exclude,sha256=ZnH-g7egfIky7okWTR8nk7IxgFjri5jcXAbuClo7DsE,240
 py2ls/.git/logs/HEAD,sha256=8ID7WuAe_TlO9g-ARxhIJYdgdL3u3m7-1qrOanaIUlA,3535
 py2ls/.git/logs/refs/heads/main,sha256=8ID7WuAe_TlO9g-ARxhIJYdgdL3u3m7-1qrOanaIUlA,3535
@@ -240,18 +240,18 @@ py2ls/export_requirements.py,sha256=x2WgUF0jYKz9GfA1MVKN-MdsM-oQ8yUeC6Ua8oCymio,
 py2ls/fetch_update.py,sha256=9LXj661GpCEFII2wx_99aINYctDiHni6DOruDs_fdt8,4752
 py2ls/freqanalysis.py,sha256=F4218VSPbgL5tnngh6xNCYuNnfR-F_QjECUUxrPYZss,32594
 py2ls/ich2ls.py,sha256=3E9R8oVpyYZXH5PiIQgT3CN5NxLe4Dwtm2LwaeacE6I,21381
-py2ls/ips.py,sha256=8hTQgwt8Hd2RIDDMrPL0EaVohYArj_B13tWlgGNS57U,316588
+py2ls/ips.py,sha256=255SRYfnZXRDQ2NTyMV3V7fqsQRKyF1qJXfmqC1Il9Q,340739
 py2ls/ml2ls.py,sha256=kIk-ZnDdJGd-fw9GPIFf1r4jtrw5hgvBpRnYNoL1U8I,209494
 py2ls/mol.py,sha256=AZnHzarIk_MjueKdChqn1V6e4tUle3X1NnHSFA6n3Nw,10645
-py2ls/netfinder.py,sha256=oWDs3uE7RHE38SnEerxL2LYmRgVmUFQmYbU9QSmyrKQ,57499
+py2ls/netfinder.py,sha256=UfsruqlFwUOZQx4mO7P7-UiRJqcxcT0WN3QRLv22o74,64059
 py2ls/nl2ls.py,sha256=UEIdok-OamFZFIvvz_PdZenu085zteMdaJd9mLu3F-s,11485
-py2ls/ocr.py,sha256=5lhUbJufIKRSOL6wAWVLEo8TqMYSjoI_Q-IO-_4u3DE,31419
+py2ls/ocr.py,sha256=CmG2GUBorz4q1aaq5TkQ7bKn3iueQJ9JKrPTzloGqlY,33447
 py2ls/plot.py,sha256=HcOtaSwaz2tQT-diA-_r46BFIYM_N1LFBCj-HUUsWgY,229795
 py2ls/setuptools-70.1.0-py3-none-any.whl,sha256=2bi3cUVal8ip86s0SOvgspteEF8SKLukECi-EWmFomc,882588
 py2ls/sleep_events_detectors.py,sha256=bQA3HJqv5qnYKJJEIhCyhlDtkXQfIzqksnD0YRXso68,52145
 py2ls/stats.py,sha256=qBn2rJmNa_QLLUqjwYqXUlGzqmW94sgA1bxJU2FC3r0,39175
 py2ls/translator.py,sha256=77Tp_GjmiiwFbEIJD_q3VYpQ43XL9ZeJo6Mhl44mvh8,34284
 py2ls/wb_detector.py,sha256=7y6TmBUj9exCZeIgBAJ_9hwuhkDh1x_-yg4dvNY1_GQ,6284
-py2ls-0.2.4.26.dist-info/METADATA,sha256=Olm6L8WrbHjFL3gklMSqlZwDgi8FG_9iqVCniuvo_2E,20216
-py2ls-0.2.4.26.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-py2ls-0.2.4.26.dist-info/RECORD,,
+py2ls-0.2.4.27.dist-info/METADATA,sha256=HWrS9YqO12ydb_7jNR9CtR_a-HCyGqE9nmSX2xvnPdk,20248
+py2ls-0.2.4.27.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+py2ls-0.2.4.27.dist-info/RECORD,,