ryry-cli 4.2__tar.gz → 4.4__tar.gz

{ryry_cli-4.2/ryry_cli.egg-info → ryry_cli-4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ryry-cli
-Version: 4.2
+Version: 4.4
 Summary: ryry tools
 Home-page: https://github.com/dalipenMedia
 Author: dalipen
@@ -23,6 +23,7 @@ Requires-Dist: gputil
 Requires-Dist: urlparser
 Requires-Dist: urllib3
 Requires-Dist: portalocker
+Requires-Dist: mecord-cli>=0.7.405
 
 ryry Python Tool
 ===============================================

{ryry_cli-4.2 → ryry_cli-4.4}/ryry/constant.py

@@ -1,6 +1,6 @@
 #!!!!! do not change this file !!!!!
-app_version="4.2"
-app_bulld_anchor="Noh_2025-07-15 16:56:04.603552"
+app_version="4.4"
+app_bulld_anchor="Noh_2025-07-18 15:18:12.819574"
 app_name="ryry-cli"
 import sys, os
 if getattr(sys, 'frozen', False):

ryry_cli-4.4/ryry/daemon_base.py

@@ -0,0 +1,224 @@
+import sys
+import os
+import json
+import time
+import signal
+from typing import Optional, Dict, Any
+
+class SimpleDaemonBase:
+    """
+    简化的Daemon基类
+    
+    用户需要实现的方法：
+    - initialize(): 初始化资源
+    - loop_function(): 循环执行的任务（可选）
+    - on_stop(): 清理资源（可选）
+    """
+    
+    def __init__(self, widget_id: str):
+        # 基础配置
+        self.widget_id = widget_id
+        self.widget_name = "???"
+        self.running = False
+        
+        # 配置加载
+        self._load_config()
+        
+        # 信号处理
+        self._setup_signal_handlers()
+        
+        print(f"【{self.widget_name}】Daemon实例创建完成", file=sys.stderr)
+
+    def _load_config(self):
+        """加载配置文件"""
+        try:
+            self._script_path = os.path.abspath(sys.modules[self.__class__.__module__].__file__)
+            self.base_path = sys.argv[2] if len(sys.argv) > 2 else os.path.expanduser("~/.ryry")
+            config_path = os.path.join(os.path.dirname(self._script_path), "config.json")
+            
+            if os.path.exists(config_path):
+                with open(config_path, 'r', encoding='utf-8') as f:
+                    config = json.load(f)
+                    self.timeout = config.get("timeout", 600)
+                    self.widget_name = config.get("name", self.widget_name)
+            else:
+                self.timeout = 600
+        except Exception as e:
+            print(f"配置加载失败: {e}", file=sys.stderr)
+            self.timeout = 600
+
+    def _setup_signal_handlers(self):
+        """设置信号处理器"""
+        def signal_handler(signum, frame):
+            print(f"【{self.widget_name}】收到信号 {signum}，开始停止", file=sys.stderr)
+            self.running = False
+        
+        # 注册信号处理器
+        signal.signal(signal.SIGINT, signal_handler)   # Ctrl+C
+        signal.signal(signal.SIGTERM, signal_handler)  # 终止信号
+        
+        if hasattr(signal, 'SIGBREAK'):
+            signal.signal(signal.SIGBREAK, signal_handler)
+
+    # ==================== 生命周期方法 ====================
+    
+    def initialize(self):
+        """
+        初始化方法 - 子类可选实现
+        在这里进行资源初始化，如数据库连接、模型加载等
+        """
+        pass
+
+    def loop_function(self):
+        """
+        循环执行的方法 - 子类可选实现
+        每秒调用一次，用于定时任务、心跳等
+        """
+        pass
+
+    def on_stop(self):
+        """
+        停止时的清理方法 - 子类可选实现
+        在这里进行资源清理，如关闭连接、保存状态等
+        """
+        pass
+
+    # ==================== 通信方法 ====================
+    
+    def send_ready_signal(self):
+        """发送就绪信号"""
+        try:
+            ready_file = os.path.join(self.base_path, f"daemon_ready_{self.widget_id}.json")
+            with open(ready_file, 'w', encoding='utf-8') as f:
+                json.dump({"accept_tasks": False}, f)
+        except Exception as e:
+            print(f"发送就绪信号失败: {e}", file=sys.stderr)
+
+    def process_command(self):
+        """处理命令文件"""
+        cmd_file = os.path.join(self.base_path, f"daemon_cmd_{self.widget_id}.json")
+        if not os.path.exists(cmd_file):
+            return
+        
+        try:
+            with open(cmd_file, 'r', encoding='utf-8') as f:
+                command = json.load(f)
+            os.remove(cmd_file)
+            
+            cmd_type = command.get("type")
+            if cmd_type == "task":
+                self._handle_task_command(command)
+            elif cmd_type == "health":
+                self._handle_health_command(command)
+            elif cmd_type == "stop":
+                self._handle_stop_command(command)
+                
+        except Exception as e:
+            print(f"处理命令失败: {e}", file=sys.stderr)
+
+    def _handle_task_command(self, command: Dict[str, Any]):
+        """处理任务命令"""
+        task_data = command.get("data", {})
+        timeout = command.get("timeout", self.timeout)
+        
+        try:
+            result = self.process_task(task_data, timeout)
+            self._send_response({
+                "type": "task_result",
+                "task_id": command.get("task_id"),
+                "success": True,
+                "data": result
+            })
+        except Exception as e:
+            self._send_response({
+                "type": "task_result", 
+                "task_id": command.get("task_id"),
+                "success": False,
+                "error": str(e),
+                "data": {"result": [], "status": 1, "message": str(e)}
+            })
+
+    def _handle_health_command(self, command: Dict[str, Any]):
+        """处理健康检查命令"""
+        health = self.health_check()
+        self._send_response({
+            "type": "health_result",
+            "data": health
+        })
+
+    def _handle_stop_command(self, command: Dict[str, Any]):
+        """处理停止命令"""
+        self.running = False
+        self._send_response({
+            "type": "stop_result",
+            "success": True
+        })
+
+    def _send_response(self, response: Dict[str, Any]):
+        """发送响应"""
+        try:
+            result_file = os.path.join(self.base_path, f"daemon_result_{self.widget_id}.json")
+            with open(result_file, 'w', encoding='utf-8') as f:
+                json.dump(response, f)
+        except Exception as e:
+            print(f"发送响应失败: {e}", file=sys.stderr)
+
+    # ==================== 子类可选重写的方法 ====================
+    
+    def process_task(self, task_data: Dict[str, Any], timeout: Optional[int] = None) -> Dict[str, Any]:
+        """
+        处理短链任务 - 子类可选实现
+        默认返回空结果
+        """
+        return {
+            "result": [{"type": "text", "content": [f"Processed: {task_data}"]}],
+            "status": 0,
+            "message": "Success"
+        }
+
+    def health_check(self) -> Dict[str, Any]:
+        """
+        健康检查 - 子类可选重写
+        """
+        return {
+            "healthy": True,
+            "state": "running",
+            "accept_tasks": False,
+            "timestamp": time.time()
+        }
+
+    # ==================== 控制方法 ====================
+    
+    def run(self):
+        """
+        运行daemon的主入口方法
+        """
+        try:
+            # 初始化
+            self.initialize()
+            
+            # 发送就绪信号
+            self.send_ready_signal()
+            
+            # 主循环
+            self.running = True
+            while self.running:
+                try:
+                    # 处理命令
+                    self.process_command()
+                    # 执行循环函数
+                    self.loop_function()
+                    time.sleep(1)
+                except KeyboardInterrupt:
+                    print(f"【{self.widget_name}】收到KeyboardInterrupt", file=sys.stderr)
+                    break
+                except Exception as e:
+                    print(f"主循环异常: {e}", file=sys.stderr)
+                    time.sleep(5)  # 异常后等待5秒再继续
+            # 清理
+            self.on_stop()
+            
+        except Exception as e:
+            print(f"运行异常: {e}", file=sys.stderr)
+        finally:
+            print(f"【{self.widget_name}】进程终止", file=sys.stderr) 

{ryry_cli-4.2 → ryry_cli-4.4}/ryry/server_func.py

@@ -79,10 +79,11 @@ class Task:
         if realTaskUUID == None or len(realTaskUUID) <= 0:
             realTaskUUID = taskUtils.taskInfoWithFirstTask()
             
-        support_subdomain = upload.getFirstSupportSubdomain()
         mayby_domain = ""
-        if support_subdomain:
-            mayby_domain = support_subdomain["readpath"]
+        if "domain" not in multi_params[0]:
+            support_subdomain = upload.getFirstSupportSubdomain()
+            if support_subdomain:
+                mayby_domain = support_subdomain["domain"]
             
         def _callback(idx, data):
             self.thread_data[str(idx)]["result"] = data
@@ -118,12 +119,11 @@ class AsyncTask:
         if realTaskUUID == None or len(realTaskUUID) <= 0:
             realTaskUUID = taskUtils.taskInfoWithFirstTask()
             
-        support_subdomain = upload.getFirstSupportSubdomain()
-        domain = ""
-        if support_subdomain:
-            domain = support_subdomain["readpath"]
         self.params["fromUUID"] = realTaskUUID
-        self.params["domain"] = domain
+        if "domain" not in self.params:
+            support_subdomain = upload.getFirstSupportSubdomain()
+            if support_subdomain:
+                self.params["domain"] = support_subdomain["domain"]
         
     def call(self):
         cmd = task.cmdWithWidgetName(self.func)

{ryry_cli-4.2 → ryry_cli-4.4}/ryry/upload.py

@@ -46,12 +46,17 @@ def additionalUrl(srcFile, ossUrl):
 def upload(src, taskUUID=None, needTranscode=True, keepItAlways=False, additionalUrl=False):
     import os
     from pathlib import Path
-    from ryry import taskUtils
+    from ryry import taskUtils as ryry_taskUtils
     if os.path.exists(src) == False:
         raise Exception(f"upload file not found")
     if taskUUID == None or len(taskUUID) <= 0:
-        taskUUID = taskUtils.taskInfoWithFirstTask()
-    targetDomain = taskUtils.taskDomainWithUUID(taskUUID)
+        taskUUID = ryry_taskUtils.taskInfoWithFirstTask()
+        targetDomain = ryry_taskUtils.taskDomainWithUUID(taskUUID)
+    else:
+        targetDomain = ryry_taskUtils.taskDomainWithUUID(taskUUID)
+        if targetDomain == None or len(targetDomain) <= 0:
+            from mecord import taskUtils as mecord_taskUtils
+            targetDomain = mecord_taskUtils.taskDomainWithUUID(taskUUID)
 
     if needTranscode:
         needDeleteSrc, newSrc = transcode(src)
@@ -60,7 +65,7 @@ def upload(src, taskUUID=None, needTranscode=True, keepItAlways=False, additiona
         newSrc = src
     
     # 根据targetDomain判断使用不同的上传逻辑
-    ossurl = uploadByDomain(newSrc, targetDomain, keepItAlways)
+    ossurl = uploadByDomain(newSrc, targetDomain, taskUUID, keepItAlways)
         
     if additionalUrl:
         ossurl = additionalUrl(newSrc, ossurl)
@@ -68,7 +73,7 @@ def upload(src, taskUUID=None, needTranscode=True, keepItAlways=False, additiona
         os.remove(newSrc)
     return ossurl
 
-def uploadByDomain(src, targetDomain, keepItAlways=False):
+def uploadByDomain(src, targetDomain, taskUUID, keepItAlways=False):
     import os
     from pathlib import Path
     import uuid
@@ -79,6 +84,10 @@ def uploadByDomain(src, targetDomain, keepItAlways=False):
     new_file_name = ''.join(str(uuid.uuid4()).split('-'))
     
     parsed_domain, upload_path = parseDomainAndPath(targetDomain)
+    if isMecordConfig(parsed_domain):
+        from mecord import upload as mecord_upload
+        return mecord_upload.upload(src, taskUUID)
+    
     oss_config = getOssConfig(parsed_domain)
     if oss_config:
         return uploadToOss(src, f"{new_file_name}.{ext}", oss_config, upload_path)
@@ -239,14 +248,34 @@ oss_template_config = {
     "domain": "https://oss.zjtemplate.com"
 }
 
+def match_wildcard_domain(target_domain, pattern):
+    if pattern.startswith("*."):
+        suffix = pattern[1:]  # 去掉 "*." 前缀
+        return target_domain.endswith(suffix)
+    return target_domain == pattern
+
+def get_domain_config(target_domain):
+    # 首先尝试精确匹配
+    if target_domain in DOMAIN_CONFIG:
+        return DOMAIN_CONFIG[target_domain]
+    
+    # 然后尝试通配符匹配
+    for pattern, config in DOMAIN_CONFIG.items():
+        if match_wildcard_domain(target_domain, pattern):
+            return config
+    
+    return None
+
 DOMAIN_CONFIG = {
+    "192.168.50.12": {"type": "ftp", "config": ftp_192_168_50_12},
+    "183.6.90.205": {"type": "ftp", "config": ftp_183_6_90_205},
+    "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_183_6_90_205},
     "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},
-    "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_183_6_90_205},
-    "192.168.50.12": {"type": "ftp", "config": ftp_192_168_50_12},
-    "183.6.90.205": {"type": "ftp", "config": ftp_183_6_90_205},
+    "*.mecoai.cn": {"type": "mecord-cli", "config": {}},
+    "*.mecordai.com": {"type": "mecord-cli", "config": {}},
 }
 
 SUBDOMAIN = {
@@ -261,13 +290,21 @@ SUBDOMAIN = {
 }
 
 def getOssConfig(targetDomain):
-    if targetDomain in DOMAIN_CONFIG and DOMAIN_CONFIG[targetDomain]["type"] == "oss":
-        return DOMAIN_CONFIG[targetDomain]["config"]
+    config = get_domain_config(targetDomain)
+    if config and config["type"] == "oss":
+        return config["config"]
     return None
 
+def isMecordConfig(targetDomain):
+    config = get_domain_config(targetDomain)
+    if config and config["type"] == "mecord-cli":
+        return True
+    return False
+
 def getFtpConfig(targetDomain):
-    if targetDomain in DOMAIN_CONFIG and DOMAIN_CONFIG[targetDomain]["type"] == "ftp":
-        return DOMAIN_CONFIG[targetDomain]["config"]
+    config = get_domain_config(targetDomain)
+    if config and config["type"] == "ftp":
+        return config["config"]
     return None
 
 def getSubdomain(targetDomain):
@@ -299,11 +336,19 @@ def getFirstSupportSubdomain():
     def _getFirstSupportSubdomain():
         for domain, config in DOMAIN_CONFIG.items():
             if config["type"] == "oss":
-                return {"type": "oss", "config": config["config"], "domain": domain}
+                return {"type": "oss", "config": config["config"], "domain": config["config"]["domain"]}
+            if config["type"] == "mecord-cli":
+                # 对于通配符域名，返回一个示例域名
+                if domain.startswith("*."):
+                    # 将 *.mecoai.cn 转换为 example.mecoai.cn
+                    example_domain = "example" + domain[1:]
+                    return {"type": "mecord-cli", "config": {}, "domain": example_domain}
+                else:
+                    return {"type": "mecord-cli", "config": {}, "domain": domain}
             elif 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": domain}
+                    return {"type": "ftp", "config": ftp_config, "domain": ftp_config["readpath"]}
         
         for ip in SUBDOMAIN.keys():
             for host_item in SUBDOMAIN[ip]:
@@ -322,7 +367,8 @@ def getFirstSupportSubdomain():
             sp.write(read_data)
     else:
         last_network_hash = firstSupportDomainConfig.get("hash", "")
-        if last_network_hash != network_hash:
+        #网络变化，或者旧版本数据的时候，重新更新
+        if last_network_hash != network_hash or "domain" not in firstSupportDomainConfig:
             firstSupportDomainConfig = _getFirstSupportSubdomain()
             if firstSupportDomainConfig:
                 firstSupportDomainConfig["hash"] = network_hash

{ryry_cli-4.2 → ryry_cli-4.4/ryry_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ryry-cli
-Version: 4.2
+Version: 4.4
 Summary: ryry tools
 Home-page: https://github.com/dalipenMedia
 Author: dalipen
@@ -23,6 +23,7 @@ Requires-Dist: gputil
 Requires-Dist: urlparser
 Requires-Dist: urllib3
 Requires-Dist: portalocker
+Requires-Dist: mecord-cli>=0.7.405
 
 ryry Python Tool
 ===============================================

{ryry_cli-4.2 → ryry_cli-4.4}/ryry_cli.egg-info/requires.txt

@@ -10,3 +10,4 @@ gputil
 urlparser
 urllib3
 portalocker
+mecord-cli>=0.7.405

{ryry_cli-4.2 → ryry_cli-4.4}/setup.py

@@ -3,7 +3,7 @@ import os
 import subprocess
 import datetime
 
-ryry_version = "4.2"
+ryry_version = "4.4"
 cur_dir = os.path.dirname(os.path.abspath(__file__))
 constanspy = os.path.join(cur_dir, "ryry", "constant.py")
 try:
@@ -70,6 +70,7 @@ setuptools.setup(
         'urlparser',
         'urllib3',
         'portalocker',
+        'mecord-cli>=0.7.405',
     ],
     dependency_links=[],
     entry_points={

ryry_cli-4.2/ryry/daemon_base.py

@@ -1,131 +0,0 @@
-import sys
-import os
-import json
-import time
-from threading import Event
-
-DEFAULT_ACCEPT_TASKS = False  # 默认是否接受短链任务
-
-class DaemonBase:
-    def __init__(self, widget_id: str):
-        self.widget_id = widget_id
-        self.running = True
-        self.stop_event = Event()
-        self.accept_tasks = self.default_accept_tasks()
-        self.widget_name = "???"
-        # 获取子类文件（即实际widget的daemon.py）所在目录
-        self._script_path = os.path.abspath(sys.modules[self.__class__.__module__].__file__)
-        self.base_path = sys.argv[2] if len(sys.argv) > 2 else os.path.expanduser("~/.ryry")
-        config_path = os.path.join(os.path.dirname(self._script_path), "config.json")
-        if os.path.exists(config_path):
-            try:
-                with open(config_path, 'r', encoding='utf-8') as f:
-                    config = json.load(f)
-                    self.timeout = config.get("timeout", 600)
-                    self.widget_name = config.get("name", self.widget_name)
-            except:
-                self.timeout = 600
-        else:
-            self.timeout = 600
-
-    def default_accept_tasks(self):
-        return DEFAULT_ACCEPT_TASKS
-
-    def initialize(self):
-        pass
-
-    def process_task(self, task_data, timeout=None):
-        raise NotImplementedError("process_task必须由子类实现")
-
-    def on_stop(self):
-        pass
-
-    def health_check(self):
-        return {
-            "healthy": True,
-            "accept_tasks": self.accept_tasks,
-            "timestamp": time.time()
-        }
-
-    def loop_function(self):
-        pass
-
-    def _send_ready_signal(self):
-        try:
-            ready_file = os.path.join(self.base_path, f"daemon_ready_{self.widget_id}.json")
-            with open(ready_file, 'w', encoding='utf-8') as f:
-                json.dump({"accept_tasks": self.accept_tasks}, f)
-        except Exception as e:
-            print(f"Failed to send ready signal: {e}", file=sys.stderr)
-
-    def _send_response(self, response):
-        try:
-            result_file = os.path.join(self.base_path, f"daemon_result_{self.widget_id}.json")
-            with open(result_file, 'w', encoding='utf-8') as f:
-                json.dump(response, f)
-        except Exception as e:
-            print(f"Failed to send response: {e}", file=sys.stderr)
-
-    def _process_command(self, command):
-        cmd_type = command.get("type")
-        if cmd_type == "task":
-            task_data = command.get("data", {})
-            timeout = command.get("timeout", self.timeout)
-            try:
-                result = self.process_task(task_data, timeout)
-                self._send_response({
-                    "type": "task_result",
-                    "task_id": command.get("task_id"),
-                    "success": True,
-                    "data": result
-                })
-            except Exception as e:
-                self._send_response({
-                    "type": "task_result", 
-                    "task_id": command.get("task_id"),
-                    "success": False,
-                    "error": str(e),
-                    "data": {"result": [], "status": 1, "message": str(e)}
-                })
-        elif cmd_type == "health":
-            health = self.health_check()
-            self._send_response({
-                "type": "health_result",
-                "data": health
-            })
-        elif cmd_type == "stop":
-            print(f"【{self.widget_name}后台进程】Received stop command", file=sys.stderr)
-            self.running = False
-            self.stop_event.set()
-            self._send_response({
-                "type": "stop_result",
-                "success": True
-            })
-
-    def run(self):
-        try:
-            self.initialize()
-            self._send_ready_signal()
-            cmd_file = os.path.join(self.base_path, f"daemon_cmd_{self.widget_id}.json")
-            while self.running:
-                try:
-                    if os.path.exists(cmd_file):
-                        try:
-                            with open(cmd_file, 'r', encoding='utf-8') as f:
-                                command = json.load(f)
-                            os.remove(cmd_file)
-                            self._process_command(command)
-                        except Exception as e:
-                            print(f"Error processing command: {e}", file=sys.stderr)
-                    if self.stop_event.is_set():
-                        break
-                    self.loop_function()
-                    time.sleep(1)
-                except KeyboardInterrupt:
-                    break
-                except Exception as e:
-                    print(f"Error in main loop: {e}", file=sys.stderr)
-                    time.sleep(1)
-        finally:
-            self.on_stop()
-            print(f"【{self.widget_name}】已终止", file=sys.stderr)