ryry-cli 6.14__tar.gz → 6.16__tar.gz

{ryry_cli-6.14/ryry_cli.egg-info → ryry_cli-6.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ryry-cli
-Version: 6.14
+Version: 6.16
 Summary: ryry tools
 Home-page: https://github.com/dalipenMedia
 Author: dalipen
@@ -8,7 +8,7 @@ Author-email: dalipen01@gmail.com
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.5
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests

{ryry_cli-6.14 → ryry_cli-6.16}/ryry/constant.py

@@ -1,6 +1,6 @@
 #!!!!! do not change this file !!!!!
-app_version="6.14"
-app_bulld_anchor="Noh_2026-05-15 22:09:11.985350"
+app_version="6.16"
+app_bulld_anchor="Noh_2026-06-11 16:51:17.054964"
 app_name="ryry-cli"
 import sys, os
 if getattr(sys, 'frozen', False):

{ryry_cli-6.14 → ryry_cli-6.16}/ryry/ryry_webapi.py

@@ -308,7 +308,7 @@ def _changeDomain(url, fix_domain):
     
 def upload(localFilePath, ext, keepItAlways=False, needTranscode=False, additionalUrl=False):
     try:
-        return _upload(localFilePath, ext, keepItAlways=False)
+        return _upload(localFilePath, ext, keepItAlways=keepItAlways)
     except:
         pass
     from mecord import upload as mecord_upload

{ryry_cli-6.14 → ryry_cli-6.16}/ryry/store.py

@@ -177,19 +177,73 @@ 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.14":
+            elif read_data["extend"].get("app", "") == "ryry-cli 6.16":
+                _genExtend()
+            elif any(k not in read_data["extend"] for k in ["device_id", "host_name", "cpu", "memory", "disk", "gpu"]):
                 _genExtend()
         else:
             _genExtend()
-    return GLOBAL_EXT_JSON
+    return _extendWithRuntimeInfo()
+
+def _format_gb(value):
+    try:
+        return f"{float(value):.1f} G"
+    except:
+        return "-"
+
+def _format_percent(value):
+    try:
+        return f"{float(value):.1f}%"
+    except:
+        return "0%"
+
+def _extendWithRuntimeInfo():
+    try:
+        data = json.loads(GLOBAL_EXT_JSON)
+        from ryry import utils
+        runtime = utils.runtimeInfo()
+        cpu = data.setdefault("cpu", {})
+        cpu["percent"] = runtime.get("cpu", {}).get("percent")
+        cpu["load_avg"] = runtime.get("cpu", {}).get("load_avg")
+        cpu.setdefault("logical_count", runtime.get("cpu", {}).get("logical_count"))
+        cpu.setdefault("count", runtime.get("cpu", {}).get("physical_count"))
+
+        memory_runtime = runtime.get("memory", {})
+        memory = data.setdefault("memory", {})
+        memory["total"] = _format_gb(memory_runtime.get("total_gb"))
+        memory["available"] = _format_gb(memory_runtime.get("available_gb"))
+        memory["used"] = _format_gb(memory_runtime.get("used_gb"))
+        memory["free"] = _format_gb(memory_runtime.get("free_gb"))
+        memory["percent"] = _format_percent(memory_runtime.get("percent"))
+
+        disk_runtime = runtime.get("disk", {})
+        disk = data.setdefault("disk", {})
+        disk["total"] = _format_gb(disk_runtime.get("total_gb"))
+        disk["used"] = _format_gb(disk_runtime.get("used_gb"))
+        disk["free"] = _format_gb(disk_runtime.get("free_gb"))
+        disk["percent"] = _format_percent(disk_runtime.get("percent"))
+
+        data["gpu"] = runtime.get("gpu", data.get("gpu", {}))
+        data["task_slots"] = runtime.get("task_slots", {})
+        data["timestamp"] = runtime.get("timestamp")
+        data.pop("metrics", None)
+        return json.dumps(data)
+    except:
+        return GLOBAL_EXT_JSON
 
 def _genExtend():
     sp = Store()
     read_data = sp.read()
-    if "deviceInfo" in read_data:
+    required_device_keys = ["device_id", "host_name", "cpu", "memory", "disk", "gpu"]
+    if "deviceInfo" in read_data and all(k in read_data["deviceInfo"] for k in required_device_keys):
         extInfo = read_data["deviceInfo"]
     else:
-        extInfo = {}
+        try:
+            from ryry import utils
+            extInfo = utils.deviceInfo()
+            read_data["deviceInfo"] = extInfo
+        except:
+            extInfo = {}
     extInfo["app"] = constant.app_name + " " + constant.app_version
     extInfo["device"] = platform.system()
     extInfo["device_version"] = platform.version()
@@ -254,4 +308,4 @@ def save_user_token(user_token):
     read_data["Authorization"] = user_token
     sp.write(read_data)
     
-        
+        

{ryry_cli-6.14 → ryry_cli-6.16}/ryry/upload.py

@@ -44,7 +44,7 @@ def additionalUrl(srcFile, ossUrl):
     except:
         return ossUrl
 
-def upload(src, taskUUID=None, needTranscode=False, keepItAlways=False, additionalUrl=False, uploadPath=None):
+def upload(src, taskUUID=None, needTranscode=False, keepItAlways=False, additionalUrl=False):
     import os
     from pathlib import Path
     from ryry import taskUtils as ryry_taskUtils
@@ -74,8 +74,7 @@ def upload(src, taskUUID=None, needTranscode=False, keepItAlways=False, addition
     
     # 根据targetDomain判断使用不同的上传逻辑
     ossurl = uploadByDomain(newSrc, targetDomain, taskUUID, 
-                            keepItAlways=keepItAlways, 
-                            uploadPath=uploadPath,
+                            keepItAlways=keepItAlways,
                             needTranscode=needTranscode,
                             additionalUrl=additionalUrl)
         
@@ -85,7 +84,9 @@ def upload(src, taskUUID=None, needTranscode=False, keepItAlways=False, addition
         os.remove(newSrc)
     return ossurl
 
-def uploadByDomain(src, targetDomain, taskUUID, keepItAlways=False, uploadPath=None, needTranscode=False, additionalUrl=False):
+def uploadByDomain(src, targetDomain, 
+                   taskUUID, keepItAlways=False, 
+                   needTranscode=False, additionalUrl=False):
     import os
     from pathlib import Path
     import uuid
@@ -95,8 +96,6 @@ def uploadByDomain(src, targetDomain, taskUUID, keepItAlways=False, uploadPath=N
     ext = os.path.splitext(file_name)[-1][1:]
     
     parsed_domain, upload_path = parseDomainAndPath(targetDomain)
-    if uploadPath:
-        upload_path = uploadPath
     if isMecordConfig(parsed_domain):
         from mecord import upload as mecord_upload
         return mecord_upload.upload(src, taskUUID, 
@@ -114,18 +113,6 @@ def uploadByDomain(src, targetDomain, taskUUID, keepItAlways=False, uploadPath=N
     ftp_config = getFtpConfig(parsed_domain)
     if ftp_config:
         return ftpUpload(src, file_name, ftp_config, upload_path)
-    
-    if upload_path:
-        if "mnt/NAS/mcn" in upload_path or "aigc_output/" in upload_path:
-            ftp_config = getFtpConfig("219.136.123.179")
-            return ftpUpload(src, file_name, ftp_config, upload_path)
-        elif (targetDomain != None and"aigc_output/" in targetDomain):
-            ftp_config = getFtpConfig("219.136.123.179")
-            return ftpUpload(src, file_name, ftp_config, upload_path)
-        elif (targetDomain == None or len(targetDomain) <= 0) and (uploadPath and len(uploadPath) > 0):
-            #找不到domain，但是有uploadPath的情况下，默认走ftp
-            ftp_config = getFtpConfig("219.136.123.179")
-            return ftpUpload(src, file_name, ftp_config, upload_path)
        
     from ryry import ryry_webapi
     return ryry_webapi.upload(src, ext, 
@@ -342,17 +329,17 @@ def get_domain_config(target_domain):
     return None
 
 DOMAIN_CONFIG = {
-    "192.168.50.12": {"type": "ftp", "config": ftp_192_168_50_12},
-    "219.136.123.179": {"type": "ftp", "config": ftp_219_136_123_179},
-    "183.6.90.205": {"type": "ftp", "config": ftp_219_136_123_179},
-    "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},
+    # "192.168.50.12": {"type": "ftp", "config": ftp_192_168_50_12},
+    # "219.136.123.179": {"type": "ftp", "config": ftp_219_136_123_179},
+    # "183.6.90.205": {"type": "ftp", "config": ftp_219_136_123_179},
+    # "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},
     "res.zjtemplate.com": {"type": "oss", "config": oss_res_config},
     "upload.zjtemplate.com": {"type": "oss", "config": oss_upload_config},
     "oss.zjtemplate.com": {"type": "oss", "config": oss_template_config},
-    "*.mecoai.cn": {"type": "mecord-cli", "config": {}},
-    "*.mecordai.com": {"type": "mecord-cli", "config": {}},
+    # "*.mecoai.cn": {"type": "mecord-cli", "config": {}},
+    # "*.mecordai.com": {"type": "mecord-cli", "config": {}},
     "*.mekoapp.com": {"type": "", "config": {}},
 }
 

{ryry_cli-6.14 → ryry_cli-6.16}/ryry/utils.py

@@ -1,11 +1,12 @@
 import uuid
 import platform
-import subprocess
-import os
-import sys
-import requests
-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:
@@ -119,73 +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 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"
-    try:
-        cpu_freq = psutil.cpu_freq().max / 1000
-    except:
-        pass
-    
-    virtual_mem = psutil.virtual_memory()
-    disk = psutil.disk_usage("/")
-    data = {
-        "cpu": {
-            "logical_count" : psutil.cpu_count(),
-            "count" : psutil.cpu_count(logical=False),
-            "max_freq" : f"{cpu_freq} GHz",
-        },
-        "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",
-            "free": f"{(virtual_mem.free / G):.1f} G"
-        },
-        "gpu": {
-            "count" : 0,
-            "list" : [],
-            "mem" : []
-        },
-        "device_id": generate_unique_id(),
-        "host_name": hostname
-    }
-    try:
-        if pynvml is None:
-            raise ImportError("pynvml/nvidia-ml-py not available")
-        pynvml.nvmlInit()
-        gpuCount = pynvml.nvmlDeviceGetCount()
-        data["gpu"]["count"] = gpuCount
-        for i in range(gpuCount):
-            handle = pynvml.nvmlDeviceGetHandleByIndex(i)
-            data["gpu"]["list"].append(f"GPU{i}: {pynvml.nvmlDeviceGetName(handle)}")
-            memInfo = pynvml.nvmlDeviceGetMemoryInfo(handle)
-            data["gpu"]["mem"].append(f"GPU{i}: total:{(memInfo.total/G):.1f} G free:{(memInfo.free/G):.1f} G")
-            
-        pynvml.nvmlShutdown()
-    except Exception as e:
-        data["gpu"]["count"] = 1
-        data["gpu"]["list"].append(f"GPU0: Normal")
-    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:
@@ -348,4 +495,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.14 → ryry_cli-6.16/ryry_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ryry-cli
-Version: 6.14
+Version: 6.16
 Summary: ryry tools
 Home-page: https://github.com/dalipenMedia
 Author: dalipen
@@ -8,7 +8,7 @@ Author-email: dalipen01@gmail.com
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.5
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests

{ryry_cli-6.14 → ryry_cli-6.16}/setup.py

@@ -3,7 +3,7 @@ import os
 import subprocess
 import datetime
 
-ryry_version = "6.14"
+ryry_version = "6.16"
 cur_dir = os.path.dirname(os.path.abspath(__file__))
 constanspy = os.path.join(cur_dir, "ryry", "constant.py")
 try:
@@ -84,5 +84,5 @@ setuptools.setup(
     # scripts=[
     #     'ryry/upload.py'
     # ],
-    python_requires='>=3.5',
+    python_requires='>=3.9',
 )