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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ryry-cli
-Version: 6.17
+Version: 6.19
 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.17 → ryry_cli-6.19}/ryry/constant.py

@@ -1,6 +1,6 @@
 #!!!!! do not change this file !!!!!
-app_version="6.17"
-app_bulld_anchor="Noh_2026-07-02 15:26:27.184223"
+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.17 → ryry_cli-6.19}/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.17 → ryry_cli-6.19}/ryry/shared_memory.py

@@ -78,6 +78,23 @@ class SharedMemoryService:
             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}")
@@ -98,6 +115,7 @@ class SharedMemoryService:
         """确保固定共享目录和锁文件可写"""
         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)

{ryry_cli-6.17 → 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.17":
+            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.19/ryry/taskUtils.py

@@ -0,0 +1,496 @@
+import os
+import requests
+import datetime
+import json
+import socket
+from io import BytesIO
+from requests_toolbelt import MultipartEncoder
+from urllib import parse
+import base64
+import calendar, time
+import hashlib
+from contextlib import contextmanager
+from threading import RLock
+from ryry import utils, constant
+
+try:
+    import fcntl
+except ImportError:
+    fcntl = None
+
+# 获取版本信息的兼容函数
+def get_version():
+    try:
+        from importlib.metadata import version
+        return version("ryry-cli")
+    except ImportError:
+        from importlib_metadata import version
+        return version("ryry-cli")
+
+task_config_file = os.path.join(constant.base_path, f"task_config.txt")
+def taskInfoWithFirstTask():
+    if os.path.exists(task_config_file):
+        with open(task_config_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        for it in data:
+            if it not in ["last_task_pts"]:
+                return it, data[it]
+    return None, None
+def taskInfoWithUUID(taskUUID):
+    if os.path.exists(task_config_file):
+        with open(task_config_file, 'r', encoding='utf-8') as f:
+            task_config = json.load(f)
+        if taskUUID in task_config:
+            return task_config[taskUUID]
+    return None
+    
+WECHAT_URL = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=1b006560-7012-4bf0-8c5e-a23830bc0a0b"
+def uploadFile2Wechat(filepath):
+    real_robot_url = WECHAT_URL
+    params = parse.parse_qs( parse.urlparse( real_robot_url ).query )
+    webHookKey=params['key'][0]
+    upload_url = f'https://qyapi.weixin.qq.com/cgi-bin/webhook/upload_media?key={webHookKey}&type=file'
+    headers = {"Accept": "application/json, text/plain, */*", "Accept-Encoding": "gzip, deflate",
+               "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.100 Safari/537.36"}
+    filename = os.path.basename(filepath)
+    try:
+        multipart = MultipartEncoder(
+            fields={'filename': filename, 'filelength': '', 'name': 'media', 'media': (filename, open(filepath, 'rb'), 'application/octet-stream')},
+            boundary='-------------------------acebdf13572468')
+        headers['Content-Type'] = multipart.content_type
+        resp = requests.post(upload_url, headers=headers, data=multipart, timeout=300)
+        json_res = resp.json()
+        if json_res.get('media_id'):
+            return json_res.get('media_id')
+    except Exception as e:
+        return ""
+def notifyWechatRobot(param):
+    real_robot_url = WECHAT_URL
+    try:
+        s = requests.session()
+        s.headers.update({'Connection':'close'})
+        headers = dict()
+        headers['Content-Type'] = "application/json"
+        res = s.post(real_robot_url, json.dumps(param), headers=headers, verify=False, timeout=30)
+        s.close()
+    except Exception as e:
+        print(f"===== qyapi.weixin.qq.com fail ", True)
+
+logs = {}
+def taskPrint(taskUUID, msg):
+    global logs
+    if (taskUUID == None or len(taskUUID) == 0) and msg == None:
+        return
+    if taskUUID and msg == None:
+        del logs[taskUUID]
+        return
+    if taskUUID and msg:
+        if taskUUID not in logs:
+            logs[taskUUID] = []
+        logs[taskUUID].append(msg)
+    if taskUUID == None and msg:
+        for uuid in logs:
+            logs[uuid].append(msg)
+    print(msg)
+def getTaskLog(taskUUID):
+    if taskUUID in logs:
+        return logs[taskUUID]
+    return []
+
+def _uploadLog(taskUUID):
+    log_path = f"{constant.base_path}/log_{taskUUID}.log"
+    try:
+        with open(log_path, 'w', encoding='utf-8') as f:
+            f.write("\n".join(getTaskLog(taskUUID)))
+        notifyWechatRobot({
+            "msgtype": "file",
+            "file": {
+                "media_id": uploadFile2Wechat(log_path)
+            }
+        })
+    except:
+        pass
+    finally:
+        if os.path.exists(log_path):
+            os.remove(log_path)
+
+def notifyTaskFail(taskUUID, reason):
+    try:
+        real_reason = ""
+        if len(reason) > 2010:
+            real_reason = f"{reason[0:1000]}\n...\n{reason[len(reason)-1000:]}"
+        else:
+            real_reason = reason
+        notifyWechatRobot({
+            "msgtype": "markdown",
+            "markdown": {
+                "content": f"机器<<font color=\"warning\">{socket.gethostname()}</font>> 执行任务<{taskUUID}>失败\n<{real_reason}>"
+            }
+        })
+        _uploadLog(taskUUID)
+    except:
+        pass
+
+def notifyServerError(taskUUID):
+    try:
+        notifyWechatRobot({
+            "msgtype": "markdown",
+            "markdown": {
+                "content": f"机器<<font color=\"warning\">{socket.gethostname()}</font>> 执行任务<{taskUUID}>上报失败, retry..."
+            }
+        })
+    except:
+        pass
+
+def notifyScriptError(taskUUID):
+    try:
+        notifyWechatRobot({
+            "msgtype": "markdown",
+            "markdown": {
+                "content": f"机器<<font color=\"warning\">{socket.gethostname()}</font>> 执行任务<{taskUUID}>异常"
+            }
+        })
+        _uploadLog(taskUUID)
+    except:
+        pass
+
+def idlingNotify(cnt):
+    device_id = utils.generate_unique_id()
+    machine_name = socket.gethostname()
+    hour = int(float(cnt)/(60.0*60.0))
+    if hour<72:
+        if hour not in [1, 2, 3, 10, 30, 50, 70]:
+            return
+    notifyWechatRobot({
+        "msgtype": "text",
+        "text": {
+            "content": f"机器<{machine_name}[{device_id}]> 空转{hour}小时"
+        }
+    })
+
+def onlineNotify():
+    device_id = utils.generate_unique_id()
+    machine_name = socket.gethostname()
+    ver = get_version()
+    notifyWechatRobot({
+        "msgtype": "text",
+        "text": {
+            "content": f"机器<{machine_name}[{device_id}]>[{ver}] 上线"
+        }
+    })
+
+def restartNotify(msg):
+    device_id = utils.generate_unique_id()
+    machine_name = socket.gethostname()
+    notifyWechatRobot({
+        "msgtype": "text",
+        "text": {
+            "content": f"机器<{machine_name}[{device_id}]> 即将下线，原因：{msg}"
+        }
+    })
+    
+def offlineNotify():
+    device_id = utils.generate_unique_id()
+    machine_name = socket.gethostname()
+    ver = get_version()
+    notifyWechatRobot({
+        "msgtype": "text",
+        "text": {
+            "content": f"机器<{machine_name}[{device_id}]> 下线"
+        }
+    })
+
+#===================================================== counter ===============================================#
+task_counter_file = os.path.join(constant.base_path, "task_counter.txt")
+task_counter_lock_file = os.path.join(constant.base_path, "task_counter.lock")
+counter_lock = RLock()
+
+@contextmanager
+def counterFileLock():
+    with counter_lock:
+        lock_fp = open(task_counter_lock_file, 'a+', encoding='utf-8')
+        try:
+            if fcntl:
+                fcntl.flock(lock_fp.fileno(), fcntl.LOCK_EX)
+            yield
+        finally:
+            if fcntl:
+                fcntl.flock(lock_fp.fileno(), fcntl.LOCK_UN)
+            lock_fp.close()
+
+def _readCounterData():
+    if os.path.exists(task_counter_file) == False:
+        return {}
+    try:
+        with open(task_counter_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        if isinstance(data, dict):
+            return data
+    except:
+        pass
+    return {}
+
+def _writeCounterData(data):
+    tmp_file = f"{task_counter_file}.tmp"
+    with open(tmp_file, 'w', encoding='utf-8') as f:
+        json.dump(data, f)
+    os.replace(tmp_file, task_counter_file)
+
+def _hourKeys(data):
+    return [str(i) for i in range(0, 24) if str(i) in data and isinstance(data[str(i)], dict)]
+
+def _resetCounterData(counter_date, last_report_date=None):
+    data = {
+        "_counter_date": counter_date
+    }
+    if last_report_date:
+        data["_last_report_date"] = last_report_date
+    return data
+
+def _counterReportStats(data):
+    s_cnt = 0
+    f_cnt = 0
+    all_day_usage = 0
+    s_l = []
+    f_l = []
+    usage_l = []
+    for i in range(0,24):
+        usage = 0
+        if str(i) in data:
+            s_cnt += data[str(i)]["success"]
+            f_cnt += data[str(i)]["fail"]
+            s_l.append(data[str(i)]["success"])
+            f_l.append(data[str(i)]["fail"])
+            if "usage" in data[str(i)]:
+                usage = data[str(i)]["usage"]
+                all_day_usage += usage
+        else:
+            s_cnt += 0
+            f_cnt += 0
+            s_l.append(0)
+            f_l.append(0)
+        usage_l.append(int((float(usage)/float(60*60))*100) if usage > 0 else 0)
+    usage_percentage = int((float(all_day_usage)/float(24*60*60))*100)
+    return {
+        "success": s_cnt,
+        "fail": f_cnt,
+        "total": s_cnt + f_cnt,
+        "usage": usage_percentage,
+        "hour_success": s_l,
+        "hour_fail": f_l,
+        "hour_usage": usage_l
+    }
+
+def _sendCounterMarkdownReport(report_date, stats):
+    notifyWechatRobot({
+        "msgtype": "markdown",
+        "markdown": {
+            "content": f"机器<<font color=\"warning\">{socket.gethostname()}</font>> {report_date} 日报 \n\n\
+                            >过去24小时执行任务<<font color=\"warning\">{stats['total']}</font>>个, 负载<<font color=\"warning\">{stats['usage']}%</font>> \n\
+                            >成功<font color=\"warning\">{stats['success']}</font>个 \n\
+                            >失败<font color=\"warning\">{stats['fail']}</font>个"
+        }
+    })
+
+def _reportFont(size, bold=False):
+    try:
+        from PIL import ImageFont
+        font_paths = [
+            "/System/Library/Fonts/STHeiti Medium.ttc" if bold else "/System/Library/Fonts/STHeiti Light.ttc",
+            "/System/Library/Fonts/PingFang.ttc",
+            "/Library/Fonts/Arial Unicode.ttf",
+            "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
+            "/usr/share/fonts/opentype/noto/NotoSansCJKSC-Regular.otf",
+            "/usr/share/fonts/truetype/wqy/wqy-microhei.ttc",
+            "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf" if bold else "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+            "C:/Windows/Fonts/msyhbd.ttc" if bold else "C:/Windows/Fonts/msyh.ttc",
+        ]
+        for font_path in font_paths:
+            if font_path and os.path.exists(font_path):
+                return ImageFont.truetype(font_path, size)
+        return ImageFont.load_default()
+    except:
+        return None
+
+def _text(draw, xy, text, fill, font=None, **kwargs):
+    try:
+        draw.text(xy, text, fill=fill, font=font, **kwargs)
+    except TypeError:
+        kwargs.pop("anchor", None)
+        draw.text(xy, text, fill=fill, font=font, **kwargs)
+    except UnicodeEncodeError:
+        safe_text = text.encode("ascii", "ignore").decode("ascii")
+        try:
+            draw.text(xy, safe_text, fill=fill, font=font, **kwargs)
+        except TypeError:
+            kwargs.pop("anchor", None)
+            draw.text(xy, safe_text, fill=fill, font=font, **kwargs)
+
+def _roundedRectangle(draw, box, radius, fill, outline=None):
+    if hasattr(draw, "rounded_rectangle"):
+        draw.rounded_rectangle(box, radius=radius, fill=fill, outline=outline)
+    else:
+        draw.rectangle(box, fill=fill, outline=outline)
+
+def _counterReportImageBytes(report_date, stats):
+    from PIL import Image, ImageDraw
+
+    width = 1120
+    height = 700
+    margin = 54
+    bg = "#f6f8fb"
+    ink = "#172033"
+    muted = "#667085"
+    grid = "#d8dee8"
+    green = "#34a853"
+    red = "#ea4335"
+    blue = "#1a73e8"
+
+    img = Image.new("RGB", (width, height), bg)
+    draw = ImageDraw.Draw(img)
+    title_font = _reportFont(36, True)
+    card_font = _reportFont(22, True)
+    text_font = _reportFont(18)
+    small_font = _reportFont(14)
+
+    host = socket.gethostname()
+    _text(draw, (margin, 38), f"机器<{host}> {report_date} 日报", ink, title_font)
+    _text(draw, (margin, 88), "每日任务执行概览", muted, text_font)
+
+    cards = [
+        ("执行任务", stats["total"], blue),
+        ("成功", stats["success"], green),
+        ("失败", stats["fail"], red),
+        ("负载", f"{stats['usage']}%", "#f29900"),
+    ]
+    card_y = 126
+    card_w = 238
+    card_h = 92
+    gap = 18
+    for idx, (label, value, color) in enumerate(cards):
+        x = margin + idx * (card_w + gap)
+        _roundedRectangle(draw, (x, card_y, x + card_w, card_y + card_h), 16, "#ffffff", "#e4e8f0")
+        _text(draw, (x + 22, card_y + 18), label, muted, text_font)
+        _text(draw, (x + 22, card_y + 46), str(value), color, card_font)
+
+    chart_left = margin
+    chart_top = 272
+    chart_right = width - margin
+    chart_bottom = height - 86
+    chart_w = chart_right - chart_left
+    _roundedRectangle(draw, (chart_left - 16, chart_top - 26, chart_right + 16, chart_bottom + 48), 18, "#ffffff", "#e4e8f0")
+    _text(draw, (chart_left, chart_top - 6), "24小时任务分布", ink, card_font)
+    _text(draw, (chart_right - 220, chart_top - 2), "绿色=成功  红色=失败", muted, small_font)
+
+    plot_top = chart_top + 48
+    plot_bottom = chart_bottom - 36
+    plot_h = plot_bottom - plot_top
+    max_count = max([s + f for s, f in zip(stats["hour_success"], stats["hour_fail"])] + [1])
+    for i in range(0, 5):
+        y = plot_bottom - int(plot_h * i / 4)
+        draw.line((chart_left, y, chart_right, y), fill=grid, width=1)
+        tick = int(max_count * i / 4)
+        _text(draw, (chart_left - 36, y - 8), str(tick), muted, small_font)
+
+    slot = chart_w / 24.0
+    bar_w = max(12, int(slot * 0.54))
+    for hour in range(0, 24):
+        success = stats["hour_success"][hour]
+        fail = stats["hour_fail"][hour]
+        total = success + fail
+        x_center = chart_left + slot * hour + slot / 2
+        x0 = int(x_center - bar_w / 2)
+        x1 = int(x_center + bar_w / 2)
+        total_h = int((float(total) / max_count) * plot_h) if total > 0 else 0
+        y_total = plot_bottom - total_h
+        fail_h = int((float(fail) / max(total, 1)) * total_h) if total > 0 else 0
+        y_fail = y_total + fail_h
+        if success > 0:
+            draw.rectangle((x0, y_fail, x1, plot_bottom), fill=green)
+        if fail > 0:
+            draw.rectangle((x0, y_total, x1, y_fail), fill=red)
+        if total > 0:
+            _text(draw, (x_center, y_total - 18), str(total), ink, small_font, anchor="mm")
+        if hour % 2 == 0:
+            _text(draw, (x_center, plot_bottom + 18), str(hour), muted, small_font, anchor="mm")
+        if stats["hour_usage"][hour] > 0 and hour % 3 == 0:
+            _text(draw, (x_center, plot_bottom + 38), f"{stats['hour_usage'][hour]}%", muted, small_font, anchor="mm")
+
+    _text(draw, (chart_left, height - 50), "柱顶数字为任务数；底部百分比为该小时任务累计忙时。", muted, small_font)
+    output = BytesIO()
+    img.save(output, format="PNG", optimize=True)
+    return output.getvalue()
+
+def _sendCounterImageReport(report_date, stats):
+    image_bytes = _counterReportImageBytes(report_date, stats)
+    md5 = hashlib.md5()
+    md5.update(image_bytes)
+    notifyWechatRobot({
+        "msgtype": "image",
+        "image": {
+            "base64": str(base64.b64encode(image_bytes), encoding='utf-8'),
+            "md5": md5.hexdigest()
+        }
+    })
+
+def _notifyCounterWithData(data, report_date):
+    stats = _counterReportStats(data)
+    try:
+        _sendCounterImageReport(report_date, stats)
+    except:
+        _sendCounterMarkdownReport(report_date, stats)
+
+def _rolloverCounterIfNeed(data, now):
+    today = now.strftime('%Y-%m-%d')
+    hour_keys = _hourKeys(data)
+    if "_counter_date" not in data:
+        # Legacy counters have no date and may already contain stale totals.
+        # Start a fresh dated counter so an old file cannot pollute tomorrow's report.
+        return _resetCounterData(today), True
+    counter_date = data.get("_counter_date")
+    if counter_date == today:
+        return data, False
+    if len(hour_keys) == 0:
+        return _resetCounterData(today, data.get("_last_report_date")), True
+    if data.get("_last_report_date") != counter_date:
+        _notifyCounterWithData(data, counter_date)
+    return _resetCounterData(today, counter_date), True
+
+def notifyCounterIfNeed():
+    try:
+        with counterFileLock():
+            data = _readCounterData()
+            data, changed = _rolloverCounterIfNeed(data, datetime.datetime.now())
+            if changed:
+                _writeCounterData(data)
+    except:
+        pass
+
+def saveCounter(taskUUID, duration, isSuccess):
+    try:
+        with counterFileLock():
+            now = datetime.datetime.now()
+            data = _readCounterData()
+            data, _ = _rolloverCounterIfNeed(data, now)
+            if "_counter_date" not in data:
+                data["_counter_date"] = now.strftime('%Y-%m-%d')
+            #update
+            now_hour = str(now.hour)
+            if now_hour in data:
+                if isSuccess:
+                    data[now_hour]["success"] += 1
+                else:
+                    data[now_hour]["fail"] += 1
+                if "usage" not in data[now_hour]:
+                    data[now_hour]["usage"] = 0
+                data[now_hour]["usage"] += duration
+            else:
+                data[now_hour] = {
+                    "success" : 1 if isSuccess else 0,
+                    "fail" : 0 if isSuccess else 1,
+                    "usage" : duration
+                }
+            #save
+            _writeCounterData(data)
+    except:
+        pass