ryry-cli 6.18__tar.gz → 6.19__tar.gz

{ryry_cli-6.18/ryry_cli.egg-info → ryry_cli-6.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ryry-cli
-Version: 6.18
+Version: 6.19
 Summary: ryry tools
 Home-page: https://github.com/dalipenMedia
 Author: dalipen

{ryry_cli-6.18 → ryry_cli-6.19}/ryry/constant.py

@@ -1,6 +1,6 @@
 #!!!!! do not change this file !!!!!
-app_version="6.18"
-app_bulld_anchor="Noh_2026-07-05 17:02:09.601187"
+app_version="6.19"
+app_bulld_anchor="Noh_2026-07-09 01:20:20.729214"
 app_name="ryry-cli"
 import sys, os
 if getattr(sys, 'frozen', False):

{ryry_cli-6.18 → ryry_cli-6.19}/ryry/store.py

@@ -177,7 +177,7 @@ def extend():
                 _genExtend()
             elif read_data["extend"].get("device_id", "") != read_data.get("deviceInfo", {}).get("device_id", ""):
                 _genExtend()
-            elif read_data["extend"].get("app", "") == "ryry-cli 6.18":
+            elif read_data["extend"].get("app", "") == "ryry-cli 6.19":
                 _genExtend()
             elif any(k not in read_data["extend"] for k in ["device_id", "host_name", "cpu", "memory", "disk", "gpu"]):
                 _genExtend()

{ryry_cli-6.18 → ryry_cli-6.19}/ryry/upload.py

@@ -78,8 +78,8 @@ def upload(src, taskUUID=None, needTranscode=False, keepItAlways=False, addition
         os.remove(newSrc)
     return ossurl
 
-def uploadByDomain(src, targetDomain, 
-                   taskUUID, keepItAlways=False, 
+def uploadByDomain(src, targetDomain,
+                   taskUUID, keepItAlways=False,
                    needTranscode=False, additionalUrl=False):
     import os
     from pathlib import Path
@@ -90,23 +90,33 @@ def uploadByDomain(src, targetDomain,
     ext = os.path.splitext(file_name)[-1][1:]
     
     parsed_domain, upload_path = parseDomainAndPath(targetDomain)
-    if isMekoConfig(parsed_domain):
-        return uploadToMeko(src, ext=ext)
-    
+
+    s3_config = getS3Config(parsed_domain)
+    if s3_config:
+        if isS3ConfigReady(s3_config):
+            new_file_name = ''.join(str(uuid.uuid4()).split('-'))
+            return uploadToS3(src, f"{new_file_name}.{ext}", s3_config, upload_path)
+        return uploadByApiFallback(src, ext, s3_config.get("fallback"),
+                                   keepItAlways=keepItAlways,
+                                   needTranscode=needTranscode,
+                                   additionalUrl=additionalUrl)
+
     oss_config = getOssConfig(parsed_domain)
     if oss_config:
         new_file_name = ''.join(str(uuid.uuid4()).split('-'))
         return uploadToOss(src, f"{new_file_name}.{ext}", oss_config, upload_path)
-    
+
+    if isMekoConfig(parsed_domain):
+        return uploadToMeko(src, ext=ext)
+
     ftp_config = getFtpConfig(parsed_domain)
     if ftp_config:
         return ftpUpload(src, file_name, ftp_config, upload_path)
        
-    from ryry import ryry_webapi
-    return ryry_webapi.upload(src, ext, 
-                              keepItAlways=keepItAlways, 
-                              needTranscode=needTranscode, 
-                              additionalUrl=additionalUrl)
+    return uploadByApiFallback(src, ext, "dalipen_api",
+                               keepItAlways=keepItAlways,
+                               needTranscode=needTranscode,
+                               additionalUrl=additionalUrl)
 
 def parseDomainAndPath(targetDomain):
     from urllib.parse import urlparse
@@ -131,13 +141,29 @@ def parseDomainAndPath(targetDomain):
 def uploadToMeko(file_path: str, ext: str = ".jpg") -> str:
     import requests
     url = "https://api.mekoapp.com/upload/create"
-    
+
     with open(file_path, "rb") as f:
         files = {"file": (file_path.split("/")[-1], f)}
         data = {"ext": ext}
         response = requests.post(url, files=files, data=data)
     response.raise_for_status()
-    return response.json()["url"]
+    result = response.json()
+    if "url" in result:
+        return result["url"]
+    if result.get("code") == 0 and result.get("data"):
+        return result["data"]
+    raise Exception(f"meko upload failed: {result}")
+
+def uploadByApiFallback(src, ext, fallback,
+                        keepItAlways=False, needTranscode=False, additionalUrl=False):
+    if fallback == "meko_api":
+        return uploadToMeko(src, ext=ext)
+
+    from ryry import ryry_webapi
+    return ryry_webapi.upload(src, ext,
+                              keepItAlways=keepItAlways or fallback == "dalipen_datanet_api",
+                              needTranscode=needTranscode,
+                              additionalUrl=additionalUrl)
 
 def uploadToOss(file, new_file_name, oss_config, upload_path=""):
     import hashlib
@@ -182,6 +208,35 @@ def uploadToOss(file, new_file_name, oss_config, upload_path=""):
     else:
         raise Exception(f"OSS upload failed: {response.status_code}")
 
+def _safe_join_path(*parts):
+    clean_parts = []
+    for part in parts:
+        if not part:
+            continue
+        clean = str(part).strip("/")
+        if clean:
+            clean_parts.append(clean)
+    return "/".join(clean_parts)
+
+def _s3_object_key(new_file_name, s3_config, upload_path=""):
+    if upload_path:
+        return _safe_join_path(upload_path, new_file_name)
+    return _safe_join_path("temp", new_file_name)
+
+def uploadToS3(file, new_file_name, s3_config, upload_path=""):
+    bucket = s3_config["bucket"]
+    content_type = s3_config.get("content_type", "application/octet-stream")
+    object_key = _s3_object_key(new_file_name, s3_config, upload_path)
+    s3_client = getS3Client(s3_config)
+    with open(file, "rb") as f:
+        s3_client.put_object(
+            Bucket=bucket,
+            Key=object_key,
+            Body=f,
+            ContentType=content_type,
+        )
+    return f"{s3_config['domain'].rstrip('/')}/{object_key}"
+
 def deepFtpUpload(file, new_file_name, ftp, writepath, readpath):
     try:
         safe_cwd(ftp, writepath)
@@ -280,6 +335,32 @@ ftp_219_136_123_179={
 }
 
 from ryry import utils
+_s3_client_cache = {}
+def getS3Client(s3_config):
+    import boto3
+    from botocore.config import Config
+
+    a_k_i, s_a_k = utils._decode_key(utils.RK11), utils._decode_key(utils.RK22)
+    endpoint = s3_config["endpoint"].rstrip("/")
+    region = s3_config.get("region", "auto")
+    cache_key = (endpoint, region, a_k_i)
+    if cache_key not in _s3_client_cache:
+        _s3_client_cache[cache_key] = boto3.client(
+            "s3",
+            endpoint_url=endpoint,
+            aws_access_key_id=a_k_i,
+            aws_secret_access_key=s_a_k,
+            region_name=region,
+            config=Config(
+                signature_version="s3v4",
+                connect_timeout=10,
+                read_timeout=100,
+                retries={"max_attempts": 3, "mode": "standard"},
+                s3={"addressing_style": "path"},
+            ),
+        )
+    return _s3_client_cache[cache_key]
+
 oss_res_config = {
     "bucket": "p-res-gz",
     "endpoint": "oss-cn-guangzhou.aliyuncs.com",
@@ -298,6 +379,16 @@ oss_template_config = {
     "domain": "https://oss.zjtemplate.com"
 }
 
+REP = utils._decode_key(utils.RK23)
+def r2Config(bucket, domain, fallback="dalipen_api"):
+    return {
+        "bucket": bucket,
+        "endpoint": REP,
+        "region": "auto",
+        "domain": f"https://{domain}",
+        "fallback": fallback,
+    }
+
 def match_wildcard_domain(target_domain, pattern):
     if pattern.startswith("*."):
         suffix = pattern[1:]  # 去掉 "*." 前缀
@@ -323,10 +414,19 @@ DOMAIN_CONFIG = {
     # "ftp://192.168.50.12/mnt/NAS/mcn/cache": {"type": "ftp", "config": ftp_192_168_50_12},
     # "ftp://183.6.90.205/mnt/NAS/mcn/cache": {"type": "ftp", "config": ftp_219_136_123_179},
     # "ftp://219.136.123.179/mnt/NAS/mcn/cache": {"type": "ftp", "config": ftp_219_136_123_179},
+    "app-upload.dalipen.com": {"type": "s3", "config": r2Config("p-app-upload", "app-upload.dalipen.com")},
+    "datanet.dalipen.com": {"type": "s3", "config": r2Config("p-crawler", "datanet.dalipen.com", "dalipen_datanet_api")},
+    "model.dalipen.com": {"type": "s3", "config": r2Config("p-model", "model.dalipen.com")},
+    "r2.dalipen.com": {"type": "s3", "config": r2Config("p-template", "r2.dalipen.com")},
+    "upload.dalipen.com": {"type": "s3", "config": r2Config("p-upload", "upload.dalipen.com"), "oversea": True},
+    "widget.dalipen.com": {"type": "s3", "config": r2Config("p-widget", "widget.dalipen.com")},
+    "app-upload.mekoapp.com": {"type": "s3", "config": r2Config("p-app-upload", "app-upload.mekoapp.com", "meko_api")},
+    "m.mekoapp.com": {"type": "s3", "config": r2Config("p-app-upload", "m.mekoapp.com", "meko_api")},
+    "upload.mekoapp.com": {"type": "s3", "config": r2Config("p-upload", "upload.mekoapp.com", "meko_api")},
     "res.zjtemplate.com": {"type": "oss", "config": oss_res_config},
-    "upload.zjtemplate.com": {"type": "oss", "config": oss_upload_config},
+    "upload.zjtemplate.com": {"type": "oss", "config": oss_upload_config, "oversea": False},
     "oss.zjtemplate.com": {"type": "oss", "config": oss_template_config},
-    "*.mekoapp.com": {"type": "", "config": {}},
+    "*.mekoapp.com": {"type": "meko_api", "config": {}},
 }
 
 FTP_REPLACEMENT = {
@@ -356,9 +456,24 @@ def getOssConfig(targetDomain):
         return config["config"]
     return None
 
+def isS3ConfigReady(s3_config):
+    return all([
+        s3_config.get("bucket"),
+        s3_config.get("endpoint"),
+        s3_config.get("domain"),
+    ])
+
+def getS3Config(targetDomain):
+    config = get_domain_config(targetDomain)
+    if config and config["type"] == "s3":
+        return config["config"]
+    return None
+
 def isMekoConfig(targetDomain):
     config = get_domain_config(targetDomain)
-    if config:
+    if config and config["type"] == "meko_api":
+        return True
+    if config and config.get("config", {}).get("fallback") == "meko_api":
         return True
     return False
 
@@ -385,16 +500,74 @@ def getSubdomain(targetDomain):
     return None
 
 def getFirstSupportSubdomain():
-    def get_network_hash():
+    def ping_ms(host, timeout=1):
+        import platform
+        import re
+        import subprocess
+        try:
+            if platform.system() == "Windows":
+                cmd = ["ping", "-n", "1", "-w", str(int(timeout * 1000)), host]
+            else:
+                cmd = ["ping", "-c", "1", host]
+            result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                                    timeout=timeout + 0.5, text=True)
+            if result.returncode != 0:
+                return None
+            match = re.search(r"(?:time|时间)[=<]\s*([0-9.]+)\s*ms", result.stdout, re.IGNORECASE)
+            if match:
+                return float(match.group(1))
+        except:
+            pass
+        return None
+
+    def is_oversea_network():
+        baidu_ms = ping_ms("baidu.com", timeout=1)
+        if baidu_ms is not None and baidu_ms <= 80:
+            return False
+
+        google_ms = ping_ms("google.com", timeout=1)
+        if google_ms is None and baidu_ms is not None:
+            return False
+        if google_ms is not None and baidu_ms is None:
+            return True
+        if google_ms is not None and baidu_ms is not None:
+            return google_ms < baidu_ms
+        return None
+
+    def get_network_hash(oversea):
         import socket
         from hashlib import md5
         try:
             local_ip = socket.gethostbyname('localhost')
         except socket.gaierror:
             local_ip = '127.0.0.1'  # 默认回退到 localhost 地址
-        return md5(local_ip.encode('utf-8')).hexdigest()
-    network_hash = get_network_hash()  
+        return md5(f"{local_ip}:{oversea}".encode('utf-8')).hexdigest()
+
+    def configToSupportSubdomain(config):
+        if config["type"] == "s3":
+            s3_config = config["config"]
+            return {"type": "s3", "config": s3_config, "domain": s3_config["domain"]}
+        if config["type"] == "oss":
+            return {"type": "oss", "config": config["config"], "domain": config["config"]["domain"]}
+        if config["type"] == "ftp":
+            ftp_config = config["config"]
+            if _can_connect_ftp(ftp_config["host"], ftp_config["port"], ftp_config["username"], ftp_config["password"], ftp_config["writepath"]):
+                return {"type": "ftp", "config": ftp_config, "domain": ftp_config["readpath"]}
+        return None
+
+    oversea = is_oversea_network()
+    network_hash = get_network_hash(oversea)
+
     def _getFirstSupportSubdomain():
+        if oversea is not None:
+            for domain, config in DOMAIN_CONFIG.items():
+                if config.get("oversea", None) != oversea:
+                    continue
+                support = configToSupportSubdomain(config)
+                if support:
+                    support["oversea"] = oversea
+                    return support
+
         for domain, config in DOMAIN_CONFIG.items():
             if config["type"] == "oss":
                 return {"type": "oss", "config": config["config"], "domain": config["config"]["domain"]}
@@ -657,4 +830,4 @@ def downloadDir(url, saveDir, useCount=-1, autoDelete=False):
             print(f"url {url} not support")
     except Exception as e:
         print(f"downloadDir fail: {e}")
-    return None
+    return None

{ryry_cli-6.18 → ryry_cli-6.19}/ryry/utils.py

@@ -1,12 +1,12 @@
 import uuid
 import platform
-import subprocess
-import os
-import sys
-import requests
-import time
-from io import BytesIO
-import psutil
+import subprocess
+import os
+import sys
+import requests
+import time
+from io import BytesIO
+import psutil
 try:
     import pynvml
 except ImportError:
@@ -120,219 +120,219 @@ def generate_unique_id():
         unique_id = uuid.uuid5(uuid.NAMESPACE_DNS, mac + hostname)
         return str(unique_id).replace('-', '')
 
-def getOssImageSize(p):
-    try:
-        s = requests.session()
+def getOssImageSize(p):
+    try:
+        s = requests.session()
         s.keep_alive = False
         res = s.get(p, timeout=60)
         image = Image.open(BytesIO(res.content), "r")
         s.close()
         return image.size
-    except:
-        return 0, 0
-
-def _round_float(value, digits=2):
-    try:
-        return round(float(value), digits)
-    except:
-        return None
-
-def _percent(used, total):
-    try:
-        if not total:
-            return 0
-        return round((float(used) / float(total)) * 100, 2)
-    except:
-        return 0
-
-def _load_average(logical_count):
-    try:
-        load1, load5, load15 = os.getloadavg()
-        normalized = _percent(load1, logical_count or 1)
-        return {
-            "1m": _round_float(load1),
-            "5m": _round_float(load5),
-            "15m": _round_float(load15),
-            "percent_1m": normalized
-        }
-    except:
-        return {
-            "1m": None,
-            "5m": None,
-            "15m": None,
-            "percent_1m": None
-        }
-
-def _decode_gpu_name(name):
-    try:
-        if isinstance(name, bytes):
-            return name.decode("utf-8")
-        return str(name)
-    except:
-        return "Unknown GPU"
-
-def _collect_gpu_info(G):
-    gpu_info = {
-        "count": 0,
-        "list": [],
-        "mem": [],
-        "devices": []
-    }
-    try:
-        if pynvml is None:
-            raise ImportError("pynvml/nvidia-ml-py not available")
-        pynvml.nvmlInit()
-        gpu_count = pynvml.nvmlDeviceGetCount()
-        gpu_info["count"] = gpu_count
-        for i in range(gpu_count):
-            handle = pynvml.nvmlDeviceGetHandleByIndex(i)
-            name = _decode_gpu_name(pynvml.nvmlDeviceGetName(handle))
-            mem_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
-            used_gb = _round_float(mem_info.used / G)
-            free_gb = _round_float(mem_info.free / G)
-            total_gb = _round_float(mem_info.total / G)
-            memory_percent = _percent(mem_info.used, mem_info.total)
-            utilization_percent = None
-            temperature_c = None
-            power_w = None
-            try:
-                utilization_percent = pynvml.nvmlDeviceGetUtilizationRates(handle).gpu
-            except:
-                pass
-            try:
-                temperature_c = pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)
-            except:
-                pass
-            try:
-                power_w = _round_float(pynvml.nvmlDeviceGetPowerUsage(handle) / 1000)
-            except:
-                pass
-            gpu_info["list"].append(f"GPU{i}: {name}")
-            gpu_info["mem"].append(f"GPU{i}: total:{total_gb:.1f} G free:{free_gb:.1f} G")
-            gpu_info["devices"].append({
-                "index": i,
-                "name": name,
-                "memory_total_gb": total_gb,
-                "memory_used_gb": used_gb,
-                "memory_free_gb": free_gb,
-                "memory_percent": memory_percent,
-                "utilization_percent": utilization_percent,
-                "temperature_c": temperature_c,
-                "power_w": power_w
-            })
-        pynvml.nvmlShutdown()
-    except Exception as e:
-        gpu_info["error"] = str(e)
-        try:
-            pynvml.nvmlShutdown()
-        except:
-            pass
-    return gpu_info
-
-def runtimeInfo():
-    G = 1024 * 1024 * 1024
-    logical_count = psutil.cpu_count() or 1
-    virtual_mem = psutil.virtual_memory()
-    disk = psutil.disk_usage("/")
-    metrics = {
-        "timestamp": int(time.time()),
-        "cpu": {
-            "percent": _round_float(psutil.cpu_percent(interval=0.1)),
-            "logical_count": logical_count,
-            "physical_count": psutil.cpu_count(logical=False),
-            "load_avg": _load_average(logical_count)
-        },
-        "memory": {
-            "total_gb": _round_float(virtual_mem.total / G),
-            "available_gb": _round_float(virtual_mem.available / G),
-            "used_gb": _round_float(virtual_mem.used / G),
-            "free_gb": _round_float(virtual_mem.free / G),
-            "percent": _round_float(virtual_mem.percent)
-        },
-        "disk": {
-            "path": "/",
-            "total_gb": _round_float(disk.total / G),
-            "used_gb": _round_float(disk.used / G),
-            "free_gb": _round_float(disk.free / G),
-            "percent": _round_float(disk.percent)
-        },
-        "gpu": _collect_gpu_info(G),
-        "task_slots": {
-            "max": 1,
-            "cur": 0,
-            "idle": 1,
-            "usage_percent": 0,
-            "widget_power": {}
-        }
-    }
-    try:
-        from ryry.shared_memory import shared_memory_service
-        max_counter = shared_memory_service.get_max_counter()
-        cur_counter = shared_memory_service.get_cur_counter()
-        widget_power = shared_memory_service.get_all_widget_power()
-        if max_counter >= 999 and cur_counter == 0 and not widget_power:
-            max_counter = 1
-        idle_counter = max(0, max_counter - cur_counter)
-        metrics["task_slots"] = {
-            "max": max_counter,
-            "cur": cur_counter,
-            "idle": idle_counter,
-            "usage_percent": _percent(cur_counter, max_counter),
-            "widget_power": widget_power
-        }
-    except:
-        pass
-    return metrics
-    
-def deviceInfo():
-    mac = get_mac_address()
-    mac = "" if mac == None else mac
-    cpu_serial = get_cpu_serial()
-    cpu_serial = "" if cpu_serial == None else cpu_serial
-    hostname = get_hostname()
-    G=1024*1024*1024
-    cpu_freq = None
-    cpu_cur_freq = None
-    try:
-        freq = psutil.cpu_freq()
-        if freq:
-            cpu_freq = freq.max / 1000 if freq.max else None
-            cpu_cur_freq = freq.current / 1000 if freq.current else None
-    except:
-        pass
-    
-    virtual_mem = psutil.virtual_memory()
-    disk = psutil.disk_usage("/")
-    runtime = runtimeInfo()
-    data = {
-        "cpu": {
-            "logical_count" : psutil.cpu_count(),
-            "count" : psutil.cpu_count(logical=False),
-            "max_freq" : f"{cpu_freq} GHz" if cpu_freq else "None",
-            "current_freq" : f"{cpu_cur_freq} GHz" if cpu_cur_freq else "None",
-            "percent" : runtime["cpu"].get("percent"),
-            "load_avg": runtime["cpu"].get("load_avg")
-        },
-        "disk": {
-            "total": f"{(disk.total / G):.1f} G",
-            "used": f"{(disk.used / G):.1f} G",
-            "free": f"{(disk.free / G):.1f} G",
-            "percent": f"{disk.percent}%"
-        },
-        "memory": {
-            "total": f"{(virtual_mem.total / G):.1f} G",
-            "available": f"{(virtual_mem.available / G):.1f} G",
-            "used": f"{(virtual_mem.used / G):.1f} G",
-            "free": f"{(virtual_mem.free / G):.1f} G",
-            "percent": f"{virtual_mem.percent}%"
-        },
-        "gpu": runtime["gpu"],
-        "device_id": generate_unique_id(),
-        "host_name": hostname,
-        "task_slots": runtime["task_slots"],
-        "timestamp": runtime["timestamp"]
-    }
-    return data
+    except:
+        return 0, 0
+
+def _round_float(value, digits=2):
+    try:
+        return round(float(value), digits)
+    except:
+        return None
+
+def _percent(used, total):
+    try:
+        if not total:
+            return 0
+        return round((float(used) / float(total)) * 100, 2)
+    except:
+        return 0
+
+def _load_average(logical_count):
+    try:
+        load1, load5, load15 = os.getloadavg()
+        normalized = _percent(load1, logical_count or 1)
+        return {
+            "1m": _round_float(load1),
+            "5m": _round_float(load5),
+            "15m": _round_float(load15),
+            "percent_1m": normalized
+        }
+    except:
+        return {
+            "1m": None,
+            "5m": None,
+            "15m": None,
+            "percent_1m": None
+        }
+
+def _decode_gpu_name(name):
+    try:
+        if isinstance(name, bytes):
+            return name.decode("utf-8")
+        return str(name)
+    except:
+        return "Unknown GPU"
+
+def _collect_gpu_info(G):
+    gpu_info = {
+        "count": 0,
+        "list": [],
+        "mem": [],
+        "devices": []
+    }
+    try:
+        if pynvml is None:
+            raise ImportError("pynvml/nvidia-ml-py not available")
+        pynvml.nvmlInit()
+        gpu_count = pynvml.nvmlDeviceGetCount()
+        gpu_info["count"] = gpu_count
+        for i in range(gpu_count):
+            handle = pynvml.nvmlDeviceGetHandleByIndex(i)
+            name = _decode_gpu_name(pynvml.nvmlDeviceGetName(handle))
+            mem_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
+            used_gb = _round_float(mem_info.used / G)
+            free_gb = _round_float(mem_info.free / G)
+            total_gb = _round_float(mem_info.total / G)
+            memory_percent = _percent(mem_info.used, mem_info.total)
+            utilization_percent = None
+            temperature_c = None
+            power_w = None
+            try:
+                utilization_percent = pynvml.nvmlDeviceGetUtilizationRates(handle).gpu
+            except:
+                pass
+            try:
+                temperature_c = pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)
+            except:
+                pass
+            try:
+                power_w = _round_float(pynvml.nvmlDeviceGetPowerUsage(handle) / 1000)
+            except:
+                pass
+            gpu_info["list"].append(f"GPU{i}: {name}")
+            gpu_info["mem"].append(f"GPU{i}: total:{total_gb:.1f} G free:{free_gb:.1f} G")
+            gpu_info["devices"].append({
+                "index": i,
+                "name": name,
+                "memory_total_gb": total_gb,
+                "memory_used_gb": used_gb,
+                "memory_free_gb": free_gb,
+                "memory_percent": memory_percent,
+                "utilization_percent": utilization_percent,
+                "temperature_c": temperature_c,
+                "power_w": power_w
+            })
+        pynvml.nvmlShutdown()
+    except Exception as e:
+        gpu_info["error"] = str(e)
+        try:
+            pynvml.nvmlShutdown()
+        except:
+            pass
+    return gpu_info
+
+def runtimeInfo():
+    G = 1024 * 1024 * 1024
+    logical_count = psutil.cpu_count() or 1
+    virtual_mem = psutil.virtual_memory()
+    disk = psutil.disk_usage("/")
+    metrics = {
+        "timestamp": int(time.time()),
+        "cpu": {
+            "percent": _round_float(psutil.cpu_percent(interval=0.1)),
+            "logical_count": logical_count,
+            "physical_count": psutil.cpu_count(logical=False),
+            "load_avg": _load_average(logical_count)
+        },
+        "memory": {
+            "total_gb": _round_float(virtual_mem.total / G),
+            "available_gb": _round_float(virtual_mem.available / G),
+            "used_gb": _round_float(virtual_mem.used / G),
+            "free_gb": _round_float(virtual_mem.free / G),
+            "percent": _round_float(virtual_mem.percent)
+        },
+        "disk": {
+            "path": "/",
+            "total_gb": _round_float(disk.total / G),
+            "used_gb": _round_float(disk.used / G),
+            "free_gb": _round_float(disk.free / G),
+            "percent": _round_float(disk.percent)
+        },
+        "gpu": _collect_gpu_info(G),
+        "task_slots": {
+            "max": 1,
+            "cur": 0,
+            "idle": 1,
+            "usage_percent": 0,
+            "widget_power": {}
+        }
+    }
+    try:
+        from ryry.shared_memory import shared_memory_service
+        max_counter = shared_memory_service.get_max_counter()
+        cur_counter = shared_memory_service.get_cur_counter()
+        widget_power = shared_memory_service.get_all_widget_power()
+        if max_counter >= 999 and cur_counter == 0 and not widget_power:
+            max_counter = 1
+        idle_counter = max(0, max_counter - cur_counter)
+        metrics["task_slots"] = {
+            "max": max_counter,
+            "cur": cur_counter,
+            "idle": idle_counter,
+            "usage_percent": _percent(cur_counter, max_counter),
+            "widget_power": widget_power
+        }
+    except:
+        pass
+    return metrics
+    
+def deviceInfo():
+    mac = get_mac_address()
+    mac = "" if mac == None else mac
+    cpu_serial = get_cpu_serial()
+    cpu_serial = "" if cpu_serial == None else cpu_serial
+    hostname = get_hostname()
+    G=1024*1024*1024
+    cpu_freq = None
+    cpu_cur_freq = None
+    try:
+        freq = psutil.cpu_freq()
+        if freq:
+            cpu_freq = freq.max / 1000 if freq.max else None
+            cpu_cur_freq = freq.current / 1000 if freq.current else None
+    except:
+        pass
+    
+    virtual_mem = psutil.virtual_memory()
+    disk = psutil.disk_usage("/")
+    runtime = runtimeInfo()
+    data = {
+        "cpu": {
+            "logical_count" : psutil.cpu_count(),
+            "count" : psutil.cpu_count(logical=False),
+            "max_freq" : f"{cpu_freq} GHz" if cpu_freq else "None",
+            "current_freq" : f"{cpu_cur_freq} GHz" if cpu_cur_freq else "None",
+            "percent" : runtime["cpu"].get("percent"),
+            "load_avg": runtime["cpu"].get("load_avg")
+        },
+        "disk": {
+            "total": f"{(disk.total / G):.1f} G",
+            "used": f"{(disk.used / G):.1f} G",
+            "free": f"{(disk.free / G):.1f} G",
+            "percent": f"{disk.percent}%"
+        },
+        "memory": {
+            "total": f"{(virtual_mem.total / G):.1f} G",
+            "available": f"{(virtual_mem.available / G):.1f} G",
+            "used": f"{(virtual_mem.used / G):.1f} G",
+            "free": f"{(virtual_mem.free / G):.1f} G",
+            "percent": f"{virtual_mem.percent}%"
+        },
+        "gpu": runtime["gpu"],
+        "device_id": generate_unique_id(),
+        "host_name": hostname,
+        "task_slots": runtime["task_slots"],
+        "timestamp": runtime["timestamp"]
+    }
+    return data
 
 def process_is_alive(pid: int) -> bool:
     try:
@@ -385,6 +385,9 @@ def begin_restart(reason, update_cli=False, simple="https://pypi.python.org/simp
     
 K1 = "TFRBSTV0UkR3NXhocHc1eDlVdkZaUWsy"
 K2 = "TFVuYlRuZFRQMHpxYmU3TjVJSGw0YlVvdlJNQkR6"
+RK11 = "NjM2OTJhNjIyYTc3MWZlY2ZmMDkxYmM5OGUxMzBjNGE="
+RK22 = "MGUxM2E2MGQ0YjBiMDk3Yzc0NzIwOWNiZjdhM2I3ZjgxZWM3ODk1NTQzOGJmMjc1ZWJiY2QwMzM5ZjY0YmFjNw=="
+RK23 = "aHR0cHM6Ly8xMTg2NDlkOGY5ZDA0MGFhN2M1NWU4ZGE5NWRlYWE0OS5yMi5jbG91ZGZsYXJlc3RvcmFnZS5jb20="
 def _decode_key(encoded_key):
     import base64
     try:
@@ -415,7 +418,6 @@ def _encode_key(raw_input):
         raise TypeError("Input must be str or bytes")
     return encoded.decode('utf-8')
 
-
 def check_restart():
     restart_file = os.path.join(constant.base_path, "restart")
     if os.path.exists(restart_file) == False:
@@ -495,4 +497,4 @@ nohup {restart_command} &''')
         result = subprocess.run(f"at now + 1 minutes -f {time_task_file} > {ot}", stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
         print(f"{result.stdout}\n{result.stderr}")
     os.remove(restart_file)
-    print("one minute later must be start!")
+    print("one minute later must be start!")

{ryry_cli-6.18 → ryry_cli-6.19/ryry_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ryry-cli
-Version: 6.18
+Version: 6.19
 Summary: ryry tools
 Home-page: https://github.com/dalipenMedia
 Author: dalipen

{ryry_cli-6.18 → ryry_cli-6.19}/setup.py

@@ -3,7 +3,7 @@ import os
 import subprocess
 import datetime
 
-ryry_version = "6.18"
+ryry_version = "6.19"
 cur_dir = os.path.dirname(os.path.abspath(__file__))
 constanspy = os.path.join(cur_dir, "ryry", "constant.py")
 try: