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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ryry-cli
-Version: 6.16
+Version: 6.18
 Summary: ryry tools
 Home-page: https://github.com/dalipenMedia
 Author: dalipen
@@ -24,8 +24,6 @@ Requires-Dist: urlparser
 Requires-Dist: urllib3
 Requires-Dist: portalocker
 Requires-Dist: PyYAML
-Provides-Extra: with-mecord
-Requires-Dist: mecord-cli>=0.7.407; extra == "with-mecord"
 
 ryry Python Tool
 ===============================================

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

@@ -1,6 +1,6 @@
 #!!!!! do not change this file !!!!!
-app_version="6.16"
-app_bulld_anchor="Noh_2026-06-11 16:51:17.054964"
+app_version="6.18"
+app_bulld_anchor="Noh_2026-07-05 17:02:09.601187"
 app_name="ryry-cli"
 import sys, os
 if getattr(sys, 'frozen', False):

{ryry_cli-6.16 → ryry_cli-6.18}/ryry/main.py

@@ -173,26 +173,14 @@ def status():
     deviceid = utils.generate_unique_id()
     import socket
     machine_name = socket.gethostname()
-    service = ryry_service.ryryService()
-    thread_num = store.get_multithread()
-    def get_shared_memory_max_counter():
-        # 获取系统推荐的共享目录
-        system = platform.system()
-        if system == 'Windows':
-            temp_dir = os.environ.get('TEMP') or os.environ.get('TMP') or os.path.expanduser('~\\AppData\\Local\\Temp')
-            data_dir = os.path.join(temp_dir, 'widget_shared_memory')
-        elif system == 'Darwin':
-            cache_dir = os.path.expanduser('~/Library/Caches')
-            data_dir = os.path.join(cache_dir, 'widget_shared_memory')
-        else:
-            data_dir = '/tmp/widget_shared_memory'
-        data_file = os.path.join(data_dir, 'widget_power.json')
-        try:
-            with open(data_file, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-            return data.get('max_counter', None)
-        except Exception:
-            return None
+    service = ryry_service.ryryService()
+    thread_num = store.get_multithread()
+    def get_shared_memory_max_counter():
+        try:
+            from ryry.shared_memory import shared_memory_service
+            return shared_memory_service.get_max_counter()
+        except Exception:
+            return None
     shared_max_counter = get_shared_memory_max_counter()
     shared_max_counter_str = ""
     if shared_max_counter and shared_max_counter != thread_num:

{ryry_cli-6.16 → ryry_cli-6.18}/ryry/ryry_server_socket.py

@@ -17,8 +17,20 @@ class RyryTaskExecutor(Thread):
     ttt = 0
     
     def appendTask(self, data, callback):
-        shared_memory_service.increment_cur_counter()
-        self.task_queue.put([data, callback])
+        if not self.workers_started:
+            raise Exception("task workers are not ready")
+        counter_incremented = False
+        try:
+            shared_memory_service.increment_cur_counter()
+            counter_incremented = True
+            self.task_queue.put([data, callback])
+        except Exception:
+            if counter_incremented:
+                try:
+                    shared_memory_service.decrement_cur_counter()
+                except:
+                    pass
+            raise
         try:
             taskUUID = data["taskUUID"]
             taskUtils.taskPrint(taskUUID, f"{current_thread().name} === addQueue task : {taskUUID}")
@@ -27,6 +39,15 @@ class RyryTaskExecutor(Thread):
             
     def idlePower(self):
         return shared_memory_service.get_max_counter() - shared_memory_service.get_cur_counter()
+
+    def canAcceptTask(self):
+        if not self.workers_started:
+            return False
+        try:
+            return shared_memory_service.ensure_available()
+        except Exception as e:
+            taskUtils.taskPrint(None, f"{current_thread().name} === shared memory unavailable : {e}")
+            return False
     
     def widgetHasPower(self, cur_widget_id):
         widget_power = shared_memory_service.get_widget_power(cur_widget_id)
@@ -58,6 +79,7 @@ class RyryTaskExecutor(Thread):
         self.max_counter = store.get_multithread()
         self.is_running = True
         self.THEADING_LIST = []
+        self.workers_started = False
         self.start()
 
     def taskRunning(self):
@@ -67,6 +89,14 @@ class RyryTaskExecutor(Thread):
                 data, callback = self.task_queue.get()
                 if data is None: 
                     break
+                taskUUID = data.get("taskUUID", "")
+                widget_id = None
+                task_record_added = False
+                widget_power_added = False
+                callback_needed = False
+                is_ok = False
+                msg = ""
+                result = "{}"
                 try:
                     data_config = json.loads(data["config"])
                     widget_id = data_config["widget_id"]
@@ -76,34 +106,55 @@ class RyryTaskExecutor(Thread):
                     timeout = data_config.get("timeout", 600)
                     if "timeout" in data:
                         timeout = data["timeout"]
-                    
-                    taskUUID = data["taskUUID"]
                     domain = ""
                     params_tmp = json.loads(data["data"])
                     if "domain" in params_tmp:
                         domain = params_tmp["domain"]
                     taskUtils.taskPrint(taskUUID, f"{current_thread().name} === receive task : {taskUUID}")
                     _appendTask(taskUUID, domain)
+                    task_record_added = True
                     self.addWidgetPower(widget_id, max_task_number)
+                    widget_power_added = True
                     is_ok, msg, result = task.runTask(data, timeout)
+                    callback_needed = True
                     if is_ok == False:
                         taskUtils.notifyTaskFail(taskUUID, msg)
-                    shared_memory_service.decrement_cur_counter()
-                    callback(taskUUID, is_ok, msg, result)
-                    _removeTask(taskUUID)
-                    self.delWidgetPower(widget_id)
                 except Exception as e:
-                    taskUtils.taskPrint(taskUUID, f"{current_thread().name} === task exception : {e}")
-                    taskUtils.notifyScriptError(taskUUID)
+                    msg = f"{current_thread().name} === task exception : {e}"
+                    result = "{}"
+                    callback_needed = bool(taskUUID)
+                    taskUtils.taskPrint(taskUUID, msg)
+                    if taskUUID:
+                        taskUtils.notifyScriptError(taskUUID)
                 finally:
-                    taskUtils.taskPrint(taskUUID, None)
+                    try:
+                        shared_memory_service.decrement_cur_counter()
+                    except Exception as e:
+                        taskUtils.taskPrint(taskUUID, f"{current_thread().name} === decrement counter exception : {e}")
+                    if callback_needed and taskUUID:
+                        try:
+                            callback(taskUUID, is_ok, msg, result)
+                        except Exception as e:
+                            taskUtils.taskPrint(taskUUID, f"{current_thread().name} === task callback exception : {e}")
+                    if task_record_added:
+                        try:
+                            _removeTask(taskUUID)
+                        except Exception as e:
+                            taskUtils.taskPrint(taskUUID, f"{current_thread().name} === remove task exception : {e}")
+                    if widget_power_added:
+                        try:
+                            self.delWidgetPower(widget_id)
+                        except Exception as e:
+                            taskUtils.taskPrint(taskUUID, f"{current_thread().name} === widget power cleanup exception : {e}")
+                    if taskUUID:
+                        taskUtils.taskPrint(taskUUID, None)
                 self.task_queue.task_done()
             except Exception as ex:
                 taskUtils.taskPrint(None, f"{current_thread().name} === exception : {ex}")
                 pass
         print(f"   {current_thread().name} taskRunning stop")
 
-    def run(self):
+    def startTaskWorkers(self):
         shared_memory_service.start_service()
         shared_memory_service.set_max_counter(self.max_counter)
         shared_memory_service.set_cur_counter(0)
@@ -111,7 +162,18 @@ class RyryTaskExecutor(Thread):
             self.THEADING_LIST.append(Thread(name=f"exector-{idx}",target=self.taskRunning))
         for t in self.THEADING_LIST:
             t.start()
+        self.workers_started = True
+
+    def run(self):
         while self.is_running:
+            if not self.workers_started:
+                try:
+                    self.startTaskWorkers()
+                    print(f"   {self.name} workers started")
+                except Exception as e:
+                    taskUtils.taskPrint(None, f"{self.name} === start workers exception : {e}")
+                    time.sleep(5)
+                    continue
             time.sleep(5)
         for t in self.THEADING_LIST:
             t.join()
@@ -123,7 +185,10 @@ class RyryTaskExecutor(Thread):
         for _ in range(self.max_counter*2):
             self.task_queue.put([None, None])
         print(f"   {self.name} stop")
-        shared_memory_service.stop_service()
+        try:
+            shared_memory_service.stop_service()
+        except Exception as e:
+            taskUtils.taskPrint(None, f"{self.name} === stop shared memory exception : {e}")
 
 lock = Lock()
 task_config_file = os.path.join(constant.base_path, f"task_config.txt")    
@@ -238,6 +303,9 @@ class RyryShortConnectThread(Thread):
                 if self.executor.idlePower() <= 0:
                     time.sleep(1)
                     continue
+                if not self.executor.canAcceptTask():
+                    time.sleep(wait_time)
+                    continue
                 
                 widget_list = {}
                 map = store.widgetMap()
@@ -250,7 +318,15 @@ class RyryShortConnectThread(Thread):
                             widget_list[it] = map[it].get("version", "0.0")
                 datas = ryry_webapi.GetTask(widget_list)
                 for it in datas:
-                    self.executor.appendTask(it, self.taskCallback)
+                    try:
+                        self.executor.appendTask(it, self.taskCallback)
+                    except Exception as e:
+                        taskUUID = it.get("taskUUID", "")
+                        msg = f"{self.name} === append task exception : {e}"
+                        taskUtils.taskPrint(taskUUID, msg)
+                        if taskUUID:
+                            taskUtils.notifyScriptError(taskUUID)
+                            self.taskCallback(taskUUID, False, msg, "{}")
                     
                 # if task empty -> full, set wait_time = max -> min
                 if len(datas) > 0:
@@ -281,4 +357,4 @@ class RyryShortConnectThread(Thread):
 
     def markStop(self):
         print(f"   {self.name} waiting stop")
-        self.is_running = False
+        self.is_running = False

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

@@ -311,16 +311,6 @@ def upload(localFilePath, ext, keepItAlways=False, needTranscode=False, addition
         return _upload(localFilePath, ext, keepItAlways=keepItAlways)
     except:
         pass
-    from mecord import upload as mecord_upload
-    try:
-        url = mecord_upload.upload(localFilePath,
-                                   None, 
-                                   "sg",
-                                   needTranscode=needTranscode,
-                                   needAddtionUrl=True) #mecord会使用签名信息，强制needAddtionUrl
-        return _changeDomain(url, "m.mecordai.com")
-    except:
-        pass
     def upload_oss(localFilePath, ext, bucket, endpoint):
         import hashlib
         import hmac

{ryry_cli-6.16 → ryry_cli-6.18}/ryry/shared_memory.py

@@ -2,7 +2,6 @@ import os
 import json
 import time
 import threading
-import tempfile
 import platform
 import subprocess
 from threading import Lock
@@ -28,17 +27,20 @@ class SharedMemoryService:
     def __init__(self):
         self.service_name = "widget_power"
         # 使用系统推荐目录，确保多进程共享
-        self.data_dir = self._get_system_shared_dir()
-        self.data_file = os.path.join(self.data_dir, f"{self.service_name}.json")
-        self.lock_file = os.path.join(self.data_dir, f"{self.service_name}.lock")
-        self.process_count_file = os.path.join(self.data_dir, f"{self.service_name}_process_count.json")
-        self.process_count_lock_file = self.process_count_file + '.lock'
+        self._set_data_dir(self._get_system_shared_dir())
         self.current_service_name = os.path.basename(sys.argv[0])
-        # 确保数据目录存在
+        # 确保共享目录存在；锁文件保持固定路径，供其他程序共同读写
         os.makedirs(self.data_dir, exist_ok=True)
         
         # 增加启动标志位，避免重复初始化
         self._started = False
+
+    def _set_data_dir(self, data_dir: str):
+        self.data_dir = data_dir
+        self.data_file = os.path.join(self.data_dir, f"{self.service_name}.json")
+        self.lock_file = os.path.join(self.data_dir, f"{self.service_name}.lock")
+        self.process_count_file = os.path.join(self.data_dir, f"{self.service_name}_process_count.json")
+        self.process_count_lock_file = self.process_count_file + '.lock'
     
     def _get_system_shared_dir(self) -> str:
         """获取系统推荐的共享目录"""
@@ -57,6 +59,86 @@ class SharedMemoryService:
         else:  # Linux 和其他 Unix-like 系统
             # Linux: 使用 /tmp 或 /var/tmp
             return '/tmp/widget_shared_memory'
+
+    def _chmod_if_possible(self, path: str, mode: int):
+        if platform.system() == 'Windows':
+            return
+        try:
+            os.chmod(path, mode)
+        except (PermissionError, FileNotFoundError):
+            pass
+
+    def _shared_dir_mode(self) -> int:
+        if platform.system() == 'Linux':
+            return 0o1777
+        return 0o700
+
+    def _shared_file_mode(self) -> int:
+        if platform.system() == 'Linux':
+            return 0o666
+        return 0o600
+
+    def _path_permission_info(self, path: str) -> str:
+        try:
+            st = os.stat(path)
+            return f"mode={oct(st.st_mode & 0o7777)} uid={st.st_uid} gid={st.st_gid}"
+        except OSError as e:
+            return f"stat failed: {e}"
+
+    def _assert_shared_dir_writable(self):
+        if os.access(self.data_dir, os.W_OK | os.X_OK):
+            return
+        raise PermissionError(
+            f"shared memory dir is not writable: {self.data_dir} "
+            f"({self._path_permission_info(self.data_dir)}). "
+            f"fix: sudo chown -R $(id -u):$(id -g) {self.data_dir} "
+            f"or sudo chmod 1777 {self.data_dir}"
+        )
+
+    def _prepare_existing_shared_file(self, path: str):
+        if os.path.isdir(path):
+            raise PermissionError(f"shared memory file path is a directory: {path}")
+        if os.path.exists(path):
+            self._chmod_if_possible(path, self._shared_file_mode())
+
+    def _touch_shared_file(self, path: str):
+        self._prepare_existing_shared_file(path)
+        with open(path, 'a+', encoding='utf-8'):
+            pass
+        self._chmod_if_possible(path, self._shared_file_mode())
+
+    def _open_lock_file(self, path: str):
+        self._ensure_shared_storage()
+        return open(path, 'a+', encoding='utf-8')
+
+    def _ensure_shared_storage(self):
+        """确保固定共享目录和锁文件可写"""
+        os.makedirs(self.data_dir, mode=self._shared_dir_mode(), exist_ok=True)
+        self._chmod_if_possible(self.data_dir, self._shared_dir_mode())
+        self._assert_shared_dir_writable()
+        self._touch_shared_file(self.lock_file)
+        self._touch_shared_file(self.process_count_lock_file)
+        self._prepare_existing_shared_file(self.data_file)
+        self._prepare_existing_shared_file(self.process_count_file)
+
+    def _default_data(self) -> Dict[str, Any]:
+        return {
+            "max_counter": 999,
+            "cur_counter": 0,
+            "widget_power": {},
+            "last_update": time.time()
+        }
+
+    def _validate_counter_data(self, data: Any) -> bool:
+        if not isinstance(data, dict):
+            return False
+        if not isinstance(data.get("max_counter", 999), int):
+            return False
+        if not isinstance(data.get("cur_counter", 0), int):
+            return False
+        if not isinstance(data.get("widget_power", {}), dict):
+            return False
+        return True
     
     def _acquire_shared_lock(self, file_obj):
         """获取共享锁（跨平台）"""
@@ -102,9 +184,10 @@ class SharedMemoryService:
         def operation(data):
             # 验证数据完整性
             if not self._validate_process_data(data):
-                data = {"processes": {}}
+                data.clear()
+                data["processes"] = {}
             
-            # 清理死亡进程（只清理本服务的）
+            # 清理共享文件中的死亡进程，避免旧状态长期占用任务槽
             self._cleanup_dead_processes_internal(data, current_time, skip_pid=current_pid)
             
             # 检查当前进程是否已经注册
@@ -121,7 +204,7 @@ class SharedMemoryService:
             return len(data["processes"])
         
         # 原子性地注册进程
-        with open(self.process_count_lock_file, 'w') as lock_f:
+        with self._open_lock_file(self.process_count_lock_file) as lock_f:
             self._acquire_exclusive_lock(lock_f)
             try:
                 if os.path.exists(self.process_count_file):
@@ -132,6 +215,7 @@ class SharedMemoryService:
                         data = {"processes": {}}
                 else:
                     data = {"processes": {}}
+                data = self._normalize_process_data(data)
                 
                 process_count = operation(data)
                 
@@ -170,11 +254,7 @@ class SharedMemoryService:
                 if skip_pid is not None and pid == skip_pid:
                     continue  # 跳过当前进程
                 
-                # 只清理本服务的进程
-                if info.get("service_name") != self.current_service_name:
-                    continue
-
-                # 检测1: 检查进程是否真的存在
+                # 检查进程是否真的存在；其他服务的死进程也要清理，避免共享计数长期卡住
                 if not self._is_process_alive(pid):
                     dead_processes.append(pid_str)
                     continue
@@ -197,9 +277,11 @@ class SharedMemoryService:
         def operation(data):
             # 验证数据完整性
             if not self._validate_process_data(data):
+                data.clear()
+                data["processes"] = {}
                 return 0
             
-            # 清理死亡进程（只清理本服务的）
+            # 清理共享文件中的死亡进程，避免旧状态长期占用任务槽
             self._cleanup_dead_processes_internal(data, current_time, skip_pid=current_pid)
             
             # 注销当前进程（只注销本服务的）
@@ -209,7 +291,7 @@ class SharedMemoryService:
             return len(data["processes"])
         
         # 原子性地注销进程
-        with open(self.process_count_lock_file, 'w') as lock_f:
+        with self._open_lock_file(self.process_count_lock_file) as lock_f:
             self._acquire_exclusive_lock(lock_f)
             try:
                 if os.path.exists(self.process_count_file):
@@ -217,7 +299,8 @@ class SharedMemoryService:
                         with open(self.process_count_file, 'r', encoding='utf-8') as f:
                             data = json.load(f)
                     except (json.JSONDecodeError, UnicodeDecodeError, FileNotFoundError):
-                        return 0
+                        data = {"processes": {}}
+                    data = self._normalize_process_data(data)
                     
                     remaining_processes = operation(data)
                     
@@ -241,11 +324,10 @@ class SharedMemoryService:
                     return 0
                 
                 # 验证数据完整性
-                if not self._validate_process_data(data):
-                    return 0
+                data = self._normalize_process_data(data)
                 
                 # 清理死亡进程
-                with open(self.process_count_lock_file, 'w') as lock_f:
+                with self._open_lock_file(self.process_count_lock_file) as lock_f:
                     self._acquire_exclusive_lock(lock_f)
                     try:
                         self._cleanup_dead_processes_internal(data, time.time())
@@ -264,6 +346,8 @@ class SharedMemoryService:
         
         def operation(data):
             if "processes" not in data:
+                data.clear()
+                data["processes"] = {}
                 return 0
             
             dead_processes = []
@@ -290,7 +374,7 @@ class SharedMemoryService:
             return len(data["processes"])
         
         # 原子性地清理死亡进程
-        with open(self.process_count_lock_file, 'w') as lock_f:
+        with self._open_lock_file(self.process_count_lock_file) as lock_f:
             self._acquire_exclusive_lock(lock_f)
             try:
                 if os.path.exists(self.process_count_file):
@@ -299,6 +383,7 @@ class SharedMemoryService:
                             data = json.load(f)
                     except (json.JSONDecodeError, UnicodeDecodeError, FileNotFoundError):
                         data = {"processes": {}}
+                    data = self._normalize_process_data(data)
                     
                     remaining_processes = operation(data)
                     
@@ -358,6 +443,11 @@ class SharedMemoryService:
             
         except Exception:
             return False
+
+    def _normalize_process_data(self, data: Any) -> Dict[str, Any]:
+        if self._validate_process_data(data):
+            return data
+        return {"processes": {}}
     
     def _update_heartbeat(self):
         """更新当前进程的心跳（简化版，仅保持数据结构一致性）"""
@@ -370,7 +460,7 @@ class SharedMemoryService:
             return len(data.get("processes", {}))
         
         # 原子性地更新心跳
-        with open(self.process_count_lock_file, 'w') as lock_f:
+        with self._open_lock_file(self.process_count_lock_file) as lock_f:
             self._acquire_exclusive_lock(lock_f)
             try:
                 if os.path.exists(self.process_count_file):
@@ -379,6 +469,7 @@ class SharedMemoryService:
                             data = json.load(f)
                     except (json.JSONDecodeError, UnicodeDecodeError, FileNotFoundError):
                         data = {"processes": {}}
+                    data = self._normalize_process_data(data)
                     
                     operation(data)
                     
@@ -424,15 +515,12 @@ class SharedMemoryService:
                     data = json.load(f)
                 finally:
                     self._release_lock(f)
+                if not self._validate_counter_data(data):
+                    return self._default_data()
                 return data
-        except (FileNotFoundError, json.JSONDecodeError):
+        except (FileNotFoundError, json.JSONDecodeError, UnicodeDecodeError):
             # 如果文件不存在或损坏，返回默认数据
-            return {
-                "max_counter": 999,
-                "cur_counter": 0,
-                "widget_power": {},
-                "last_update": time.time()
-            }
+            return self._default_data()
     
     def _write_data(self, data: Dict[str, Any]):
         """写入数据文件"""
@@ -459,7 +547,7 @@ class SharedMemoryService:
     def _atomic_operation(self, operation):
         """执行原子操作（多进程安全）"""
         # 使用文件锁确保多进程间的原子性
-        with open(self.lock_file, 'w') as lock_f:
+        with self._open_lock_file(self.lock_file) as lock_f:
             # 获取独占锁，阻塞直到获得锁
             self._acquire_exclusive_lock(lock_f)
             try:
@@ -469,6 +557,12 @@ class SharedMemoryService:
                 return result
             finally:
                 self._release_lock(lock_f)
+
+    def ensure_available(self) -> bool:
+        """确认共享计数文件可读写，避免拉到任务后本地无法入队"""
+        def operation(data):
+            return True
+        return self._atomic_operation(operation)
     
     def start_service(self):
         """启动共享内存服务（轻量级，无需额外进程）"""

{ryry_cli-6.16 → ryry_cli-6.18}/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.16":
+            elif read_data["extend"].get("app", "") == "ryry-cli 6.18":
                 _genExtend()
             elif any(k not in read_data["extend"] for k in ["device_id", "host_name", "cpu", "memory", "disk", "gpu"]):
                 _genExtend()