ryry-cli 6.22__tar.gz → 6.23__tar.gz

{ryry_cli-6.22/ryry_cli.egg-info → ryry_cli-6.23}/PKG-INFO

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

{ryry_cli-6.22 → ryry_cli-6.23}/ryry/constant.py

@@ -1,6 +1,6 @@
 #!!!!! do not change this file !!!!!
-app_version="6.22"
-app_bulld_anchor="Noh_2026-07-09 19:12:26.483937"
+app_version="6.23"
+app_bulld_anchor="Noh_2026-07-13 21:33:09.201410"
 app_name="ryry-cli"
 import sys, os
 if getattr(sys, 'frozen', False):

{ryry_cli-6.22 → ryry_cli-6.23}/ryry/ryry_service.py

@@ -160,21 +160,72 @@ class ryryDaemonThread(Thread):
     def markStop(self):
         print(f"   DaemonThread waiting stop")
         
-class ryryStateThread(Thread):
-    def __init__(self):
-        super().__init__()
-        self.name = f"ryryStateThread"
-        self.daemon = True
-        self.tik_time = 30.0
-        self.start()
+class ryryStateThread(Thread):
+    def __init__(self):
+        super().__init__()
+        self.name = f"ryryStateThread"
+        self.daemon = True
+        self.tik_time = 30.0
+        self.next_network_refresh_at = 0
+        self.start()
+
+    def refreshNetworkProfileIfDue(self):
+        try:
+            now = int(time.time())
+            if now < self.next_network_refresh_at:
+                return
+
+            profile = store.getNetworkProfile()
+            if not store.isNetworkProfileRefreshDue(profile, now):
+                self.next_network_refresh_at = int(profile.get("next_refresh_at", now + self.tik_time))
+                return
+
+            self.next_network_refresh_at = now + store.NETWORK_PROFILE_RETRY_SECONDS
+            detected = utils.detectNetworkProfile()
+            updated_profile = dict(profile)
+            updated_profile.update({
+                "version": 2,
+                "last_attempt_at": now,
+                "baidu_ms": detected.get("baidu_ms"),
+                "google_ms": detected.get("google_ms"),
+                "r2_ms": detected.get("r2_ms"),
+                "aliyun_ms": detected.get("aliyun_ms"),
+                "country": detected.get("country"),
+                "method": detected.get("method", "inconclusive"),
+            })
+
+            is_oversea = detected.get("is_oversea")
+            if isinstance(is_oversea, bool):
+                updated_profile.update({
+                    "is_oversea": is_oversea,
+                    "checked_at": now,
+                    "last_success_at": now,
+                    "next_refresh_at": now + store.NETWORK_PROFILE_REFRESH_SECONDS,
+                    "failure_count": 0,
+                })
+                updated_profile.pop("last_error", None)
+                self.next_network_refresh_at = updated_profile["next_refresh_at"]
+            else:
+                updated_profile.update({
+                    "next_refresh_at": now + store.NETWORK_PROFILE_RETRY_SECONDS,
+                    "failure_count": int(updated_profile.get("failure_count", 0)) + 1,
+                    "last_error": "network detection inconclusive",
+                })
+
+            if not store.saveNetworkProfile(updated_profile):
+                self.next_network_refresh_at = now + store.NETWORK_PROFILE_RETRY_SECONDS
+        except Exception:
+            self.next_network_refresh_at = int(time.time()) + store.NETWORK_PROFILE_RETRY_SECONDS
     
-    def run(self):
-        print(f"   {self.name} start")
-        taskUtils.onlineNotify()
-        while (os.path.exists(stop_thread_file) == False):
-            time.sleep(self.tik_time)
-            try:
-                task_config = TaskConnector._getTaskConfig()
+    def run(self):
+        print(f"   {self.name} start")
+        self.refreshNetworkProfileIfDue()
+        taskUtils.onlineNotify()
+        while (os.path.exists(stop_thread_file) == False):
+            time.sleep(self.tik_time)
+            try:
+                self.refreshNetworkProfileIfDue()
+                task_config = TaskConnector._getTaskConfig()
                 if task_config["last_task_pts"] > 0:
                     cnt = (calendar.timegm(time.gmtime()) - task_config["last_task_pts"]) #second
                     if cnt >= (60*60) and cnt/(60*60)%1 <= self.tik_time/3600:
@@ -204,6 +255,5 @@ class ryryStateThread(Thread):
                 time.sleep(60)
         print(f"   StateChecker stop")
         notify_other_stoped() #because other thread is waiting some signal to close
-    def markStop(self):
-        print(f"   StateChecker waiting stop")
-        
+    def markStop(self):
+        print(f"   StateChecker waiting stop")

{ryry_cli-6.22 → ryry_cli-6.23}/ryry/store.py

@@ -1,5 +1,13 @@
-import os, platform, json, requests, locale
-from ryry import constant 
+import os, platform, json, requests, locale, time
+from ryry import constant
+
+try:
+    import portalocker
+except ImportError:
+    portalocker = None
+
+NETWORK_PROFILE_REFRESH_SECONDS = 6 * 60 * 60
+NETWORK_PROFILE_RETRY_SECONDS = 15 * 60
 
 def singleton(cls):
     _instance = {}
@@ -11,7 +19,7 @@ def singleton(cls):
     return inner
 
 @singleton
-class Store(object):
+class Store(object):
 
     def __init__(self):
         self.path = os.path.join(constant.base_path, f"data.json")
@@ -26,9 +34,78 @@ class Store(object):
             
         return data
     
-    def write(self, data):
-        with open(self.path, 'w', encoding='utf-8') as f:
-            json.dump(data, f)
+    def write(self, data):
+        with open(self.path, 'w', encoding='utf-8') as f:
+            json.dump(data, f)
+
+def networkProfilePath():
+    configured_path = os.environ.get("RYRY_NETWORK_PROFILE_PATH", "").strip()
+    if configured_path:
+        return os.path.abspath(os.path.expanduser(configured_path))
+    return os.path.join(constant.base_path, "network_profile.json")
+
+def getNetworkProfile():
+    try:
+        with open(networkProfilePath(), 'r', encoding='utf-8') as f:
+            profile = json.load(f)
+        return profile if isinstance(profile, dict) else {}
+    except Exception:
+        return {}
+
+def getNetworkIsOversea():
+    try:
+        value = getNetworkProfile().get("is_oversea")
+        return value if isinstance(value, bool) else None
+    except Exception:
+        return None
+
+def isNetworkProfileRefreshDue(profile=None, now=None):
+    try:
+        profile = profile if isinstance(profile, dict) else getNetworkProfile()
+        next_refresh_at = float(profile.get("next_refresh_at", 0))
+        return next_refresh_at <= (now if now is not None else time.time())
+    except Exception:
+        return True
+
+def saveNetworkProfile(profile):
+    if not isinstance(profile, dict):
+        return False
+
+    path = networkProfilePath()
+    directory = os.path.dirname(path) or "."
+    lock_path = f"{path}.lock"
+    temp_path = f"{path}.{os.getpid()}.{time.time_ns()}.tmp"
+    lock_file = None
+    try:
+        os.makedirs(directory, exist_ok=True)
+        lock_file = open(lock_path, 'a+', encoding='utf-8')
+        if portalocker:
+            portalocker.lock(lock_file, portalocker.LOCK_EX)
+
+        with open(temp_path, 'w', encoding='utf-8') as f:
+            json.dump(profile, f, ensure_ascii=False)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(temp_path, path)
+        return True
+    except Exception:
+        return False
+    finally:
+        if lock_file:
+            if portalocker:
+                try:
+                    portalocker.unlock(lock_file)
+                except Exception:
+                    pass
+            try:
+                lock_file.close()
+            except Exception:
+                pass
+        if os.path.exists(temp_path):
+            try:
+                os.remove(temp_path)
+            except Exception:
+                pass
     
 #============================== widget ================================
 def isCreateWidget():
@@ -197,7 +274,7 @@ def _format_percent(value):
     except:
         return "0%"
 
-def _extendWithRuntimeInfo():
+def _extendWithRuntimeInfo():
     try:
         data = json.loads(GLOBAL_EXT_JSON)
         from ryry import utils
@@ -224,9 +301,12 @@ def _extendWithRuntimeInfo():
         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)
+        data["task_slots"] = runtime.get("task_slots", {})
+        data["timestamp"] = runtime.get("timestamp")
+        network_profile = getNetworkProfile()
+        if network_profile:
+            data["network_profile"] = network_profile
+        data.pop("metrics", None)
         return json.dumps(data)
     except:
         return GLOBAL_EXT_JSON

{ryry_cli-6.22 → ryry_cli-6.23}/ryry/upload.py

@@ -1,5 +1,12 @@
-from urllib.parse import *
-import time
+from urllib.parse import *
+import time
+
+def getCachedNetworkIsOversea():
+    try:
+        from ryry import store
+        return store.getNetworkIsOversea()
+    except Exception:
+        return None
 
 def transcode(srcFile):
     try:
@@ -91,17 +98,21 @@ def uploadByDomain(src, targetDomain,
     
     parsed_domain, upload_path = parseDomainAndPath(targetDomain)
 
-    s3_config = getS3Config(parsed_domain)
-    if s3_config:
-        fallback = s3_config.get("fallback")
-        if isS3ConfigReady(s3_config):
-            new_file_name = ''.join(str(uuid.uuid4()).split('-'))
-            try:
-                return uploadToS3(src, f"{new_file_name}.{ext}", s3_config, upload_path)
-            except Exception as e:
-                if not fallback:
-                    raise
-                print(f"S3 upload failed, fallback to api: {e}")
+    s3_config = getS3Config(parsed_domain)
+    if s3_config:
+        fallback = s3_config.get("fallback")
+        if isS3ConfigReady(s3_config):
+            new_file_name = ''.join(str(uuid.uuid4()).split('-'))
+            use_proxy = shouldUseS3Proxy(s3_config)
+            try:
+                if use_proxy:
+                    return uploadToS3Proxy(src, f"{new_file_name}.{ext}", s3_config, upload_path)
+                return uploadToS3(src, f"{new_file_name}.{ext}", s3_config, upload_path)
+            except Exception as e:
+                if not fallback:
+                    raise
+                upload_type = "S3 proxy" if use_proxy else "S3"
+                print(f"{upload_type} upload failed, fallback to api: {e}")
         return uploadByApiFallback(src, ext, fallback,
                                    keepItAlways=keepItAlways,
                                    needTranscode=needTranscode,
@@ -171,7 +182,7 @@ def uploadByApiFallback(src, ext, fallback,
                               needTranscode=needTranscode,
                               additionalUrl=additionalUrl)
 
-def uploadToOss(file, new_file_name, oss_config, upload_path=""):
+def uploadToOss(file, new_file_name, oss_config, upload_path="", return_domain=None):
     import hashlib
     import hmac
     import base64
@@ -186,11 +197,7 @@ def uploadToOss(file, new_file_name, oss_config, upload_path=""):
     timestamp = datetime.datetime.utcnow().strftime("%a, %d %b %Y %H:%M:%S GMT")        
     content_type = "application/octet-stream"
     
-    if upload_path:
-        upload_path = upload_path.strip('/')
-        object_key = f"{upload_path}/{new_file_name}"
-    else:
-        object_key = f"temp/{new_file_name}"
+    object_key = _upload_object_key(new_file_name, upload_path)
     
     resource = f"/{bucket}/{object_key}"
     string_to_sign = f"PUT\n\n{content_type}\n{timestamp}\n{resource}"    
@@ -208,13 +215,14 @@ def uploadToOss(file, new_file_name, oss_config, upload_path=""):
     with open(file, "rb") as f:
         file_data = f.read()
     
-    response = requests.put(url, data=file_data, headers=headers)
-    if response.status_code == 200:
-        return f"{oss_config['domain']}/{object_key}"
-    else:
-        raise Exception(f"OSS upload failed: {response.status_code}")
-
-def _safe_join_path(*parts):
+    response = requests.put(url, data=file_data, headers=headers)
+    if response.status_code == 200:
+        domain = return_domain or oss_config["domain"]
+        return f"{domain.rstrip('/')}/{object_key}"
+    else:
+        raise Exception(f"OSS upload failed: {response.status_code}")
+
+def _safe_join_path(*parts):
     clean_parts = []
     for part in parts:
         if not part:
@@ -222,14 +230,17 @@ def _safe_join_path(*parts):
         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=""):
+    return "/".join(clean_parts)
+
+def _upload_object_key(new_file_name, upload_path=""):
+    if upload_path:
+        return _safe_join_path(upload_path, new_file_name)
+    return _safe_join_path("temp", new_file_name)
+
+def _s3_object_key(new_file_name, s3_config, upload_path=""):
+    return _upload_object_key(new_file_name, upload_path)
+
+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)
@@ -241,7 +252,19 @@ def uploadToS3(file, new_file_name, s3_config, upload_path=""):
             Body=f,
             ContentType=content_type,
         )
-    return f"{s3_config['domain'].rstrip('/')}/{object_key}"
+    return f"{s3_config['domain'].rstrip('/')}/{object_key}"
+
+def shouldUseS3Proxy(s3_config):
+    return bool(s3_config.get("proxy")) and getCachedNetworkIsOversea() is False
+
+def uploadToS3Proxy(file, new_file_name, s3_config, upload_path=""):
+    return uploadToOss(
+        file,
+        new_file_name,
+        s3_config["proxy"],
+        upload_path,
+        return_domain=s3_config["domain"],
+    )
 
 def deepFtpUpload(file, new_file_name, ftp, writepath, readpath):
     try:
@@ -385,15 +408,18 @@ 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,
-    }
+REP = utils._decode_key(utils.RK23)
+def r2Config(bucket, domain, fallback="dalipen_api", proxy=None):
+    config = {
+        "bucket": bucket,
+        "endpoint": REP,
+        "region": "auto",
+        "domain": f"https://{domain}",
+        "fallback": fallback,
+    }
+    if proxy:
+        config["proxy"] = proxy
+    return config
 
 def match_wildcard_domain(target_domain, pattern):
     if pattern.startswith("*."):
@@ -420,15 +446,15 @@ 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")},
+    "app-upload.dalipen.com": {"type": "s3", "config": r2Config("p-app-upload", "app-upload.dalipen.com", proxy=oss_upload_config)},
     "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},
+    "upload.dalipen.com": {"type": "s3", "config": r2Config("p-upload", "upload.dalipen.com", proxy=oss_upload_config), "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")},
+    "app-upload.mekoapp.com": {"type": "s3", "config": r2Config("p-app-upload", "app-upload.mekoapp.com", "meko_api", proxy=oss_upload_config)},
+    "m.mekoapp.com": {"type": "s3", "config": r2Config("p-app-upload", "m.mekoapp.com", "meko_api", proxy=oss_upload_config)},
+    "upload.mekoapp.com": {"type": "s3", "config": r2Config("p-upload", "upload.mekoapp.com", "meko_api", proxy=oss_upload_config)},
     "res.zjtemplate.com": {"type": "oss", "config": oss_res_config},
     "upload.zjtemplate.com": {"type": "oss", "config": oss_upload_config, "oversea": False},
     "oss.zjtemplate.com": {"type": "oss", "config": oss_template_config},
@@ -505,42 +531,8 @@ def getSubdomain(targetDomain):
                     return host_item
     return None
 
-def getFirstSupportSubdomain():
-    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):
+def getFirstSupportSubdomain():
+    def get_network_hash(oversea):
         import socket
         from hashlib import md5
         try:
@@ -561,7 +553,7 @@ def getFirstSupportSubdomain():
                 return {"type": "ftp", "config": ftp_config, "domain": ftp_config["readpath"]}
         return None
 
-    oversea = is_oversea_network()
+    oversea = getCachedNetworkIsOversea()
     network_hash = get_network_hash(oversea)
 
     def _getFirstSupportSubdomain():
@@ -836,4 +828,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.22 → ryry_cli-6.23}/ryry/utils.py

@@ -15,9 +15,15 @@ from datetime import datetime, timedelta
 import http
 import json
 from pathlib import Path
-import socket
-from PIL import Image
-from ryry import constant
+import socket
+from concurrent.futures import ThreadPoolExecutor
+from PIL import Image
+from ryry import constant
+
+NETWORK_PROBE_TIMEOUT_SECONDS = 10
+NETWORK_WHEREAMI_URL = "https://api.dalipen.com/whereami"
+NETWORK_ALIYUN_GUANGZHOU_URL = "https://p-upload-gz.oss-cn-guangzhou.aliyuncs.com/"
+NETWORK_LATENCY_DECISIVE_RATIO = 1.5
 
 def get_mac_from_nettools():
     try:
@@ -106,8 +112,129 @@ def get_cpu_serial():
         cpu_serial = None
     return cpu_serial
 
-def get_hostname():
-    return socket.gethostname()
+def get_hostname():
+    return socket.gethostname()
+
+def _network_ping_ms(host, timeout=1):
+    import re
+    try:
+        if platform.system() == "Windows":
+            cmd = ["ping", "-n", "3", "-w", str(int(timeout * 1000)), host]
+        else:
+            cmd = ["ping", "-c", "3", host]
+        result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                                timeout=timeout + 0.5, text=True)
+        if result.returncode != 0:
+            return None
+        matches = re.findall(r"(?:time|时间)[=<]\s*([0-9.]+)\s*ms", result.stdout, re.IGNORECASE)
+        if matches:
+            samples = [float(value) for value in matches]
+            return round(sum(samples) / len(samples), 3)
+    except Exception:
+        pass
+    return None
+
+def _network_http_ms(url, timeout=NETWORK_PROBE_TIMEOUT_SECONDS):
+    if not url:
+        return None
+    try:
+        started_at = time.perf_counter()
+        response = requests.head(url, allow_redirects=False, timeout=timeout)
+        response.close()
+        return round((time.perf_counter() - started_at) * 1000, 2)
+    except Exception:
+        return None
+
+def _network_r2_url():
+    try:
+        return _decode_key(RK23)
+    except Exception:
+        return None
+
+def _network_whereami_country(timeout=NETWORK_PROBE_TIMEOUT_SECONDS):
+    try:
+        response = requests.get(NETWORK_WHEREAMI_URL, timeout=timeout)
+        response.raise_for_status()
+        payload = response.json()
+        if not isinstance(payload, dict) or payload.get("code") != 0:
+            return None
+        country = payload.get("data")
+        if isinstance(country, dict):
+            country = country.get("country") or country.get("country_code")
+        if isinstance(country, str) and len(country.strip()) == 2 and country.strip().isalpha():
+            return country.strip().upper()
+    except Exception:
+        pass
+    return None
+
+def _network_latency_preference(domestic_ms, oversea_ms):
+    if domestic_ms is None and oversea_ms is None:
+        return None, 0
+    if domestic_ms is None:
+        return True, float("inf")
+    if oversea_ms is None:
+        return False, float("inf")
+    if domestic_ms == oversea_ms:
+        return None, 1
+
+    is_oversea = oversea_ms < domestic_ms
+    return is_oversea, max(domestic_ms, oversea_ms) / min(domestic_ms, oversea_ms)
+
+def _network_latency_decision(baidu_ms, google_ms, r2_ms, aliyun_ms):
+    location_result, _ = _network_latency_preference(baidu_ms, google_ms)
+    storage_result, storage_ratio = _network_latency_preference(aliyun_ms, r2_ms)
+
+    if location_result is None:
+        return storage_result, "storage_latency" if storage_result is not None else "inconclusive"
+    if storage_result is None:
+        return location_result, "baidu_google_latency"
+    if location_result == storage_result:
+        return location_result, "combined_latency"
+    if storage_ratio >= NETWORK_LATENCY_DECISIVE_RATIO:
+        return storage_result, "storage_latency"
+    return location_result, "combined_latency"
+
+def detectNetworkProfile(timeout=NETWORK_PROBE_TIMEOUT_SECONDS):
+    probes = {
+        "baidu_ms": (_network_ping_ms, "baidu.com"),
+        "google_ms": (_network_ping_ms, "google.com"),
+        "r2_ms": (_network_http_ms, _network_r2_url()),
+        "aliyun_ms": (_network_http_ms, NETWORK_ALIYUN_GUANGZHOU_URL),
+    }
+    results = {}
+    with ThreadPoolExecutor(max_workers=len(probes)) as executor:
+        futures = {
+            name: executor.submit(probe, target, timeout=timeout)
+            for name, (probe, target) in probes.items()
+        }
+        for name, future in futures.items():
+            try:
+                results[name] = future.result()
+            except Exception:
+                results[name] = None
+
+    is_oversea, method = _network_latency_decision(
+        results.get("baidu_ms"),
+        results.get("google_ms"),
+        results.get("r2_ms"),
+        results.get("aliyun_ms"),
+    )
+    country = None
+    if is_oversea is None:
+        country = _network_whereami_country(timeout=timeout)
+        if country:
+            is_oversea = country != "CN"
+            method = "whereami"
+
+    return {
+        "is_oversea": is_oversea,
+        "baidu_ms": results.get("baidu_ms"),
+        "google_ms": results.get("google_ms"),
+        "r2_ms": results.get("r2_ms"),
+        "aliyun_ms": results.get("aliyun_ms"),
+        "country": country,
+        "method": method,
+    }
 
 def generate_unique_id():
     mac = get_mac_address()

{ryry_cli-6.22 → ryry_cli-6.23/ryry_cli.egg-info}/PKG-INFO

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

{ryry_cli-6.22 → ryry_cli-6.23}/ryry_cli.egg-info/SOURCES.txt

@@ -30,4 +30,6 @@ ryry_cli.egg-info/SOURCES.txt
 ryry_cli.egg-info/dependency_links.txt
 ryry_cli.egg-info/entry_points.txt
 ryry_cli.egg-info/requires.txt
-ryry_cli.egg-info/top_level.txt
+ryry_cli.egg-info/top_level.txt
+tests/test_network_profile.py
+tests/test_upload_proxy.py

{ryry_cli-6.22 → ryry_cli-6.23}/setup.py

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

ryry_cli-6.23/tests/test_network_profile.py

@@ -0,0 +1,137 @@
+import json
+import os
+import unittest
+from tempfile import TemporaryDirectory
+from unittest.mock import Mock, patch
+
+from ryry import store, upload, utils
+
+
+class NetworkProfileStoreTest(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = TemporaryDirectory()
+        self.profile_path = os.path.join(self.temp_dir.name, "network_profile.json")
+        self.path_patch = patch.dict(
+            os.environ,
+            {"RYRY_NETWORK_PROFILE_PATH": self.profile_path},
+        )
+        self.path_patch.start()
+
+    def tearDown(self):
+        self.path_patch.stop()
+        self.temp_dir.cleanup()
+
+    def test_profile_round_trip(self):
+        profile = {
+            "is_oversea": False,
+            "checked_at": 100,
+            "next_refresh_at": 200,
+        }
+
+        self.assertTrue(store.saveNetworkProfile(profile))
+        self.assertEqual(store.getNetworkProfile(), profile)
+        self.assertFalse(store.getNetworkIsOversea())
+
+    def test_corrupt_profile_falls_back_to_unknown(self):
+        with open(self.profile_path, 'w', encoding='utf-8') as f:
+            f.write("{invalid json")
+
+        self.assertEqual(store.getNetworkProfile(), {})
+        self.assertIsNone(store.getNetworkIsOversea())
+
+    def test_invalid_profile_does_not_enable_proxy(self):
+        with open(self.profile_path, 'w', encoding='utf-8') as f:
+            json.dump({"is_oversea": "false"}, f)
+
+        s3_config = upload.getS3Config("upload.dalipen.com")
+        self.assertFalse(upload.shouldUseS3Proxy(s3_config))
+
+    def test_profile_read_exception_does_not_enable_proxy(self):
+        s3_config = upload.getS3Config("upload.dalipen.com")
+        with patch("ryry.store.getNetworkProfile", side_effect=OSError("read failed")):
+            self.assertFalse(upload.shouldUseS3Proxy(s3_config))
+
+    @patch("ryry.utils._network_whereami_country")
+    @patch("ryry.utils._network_http_ms")
+    @patch("ryry.utils._network_ping_ms")
+    def test_combined_domestic_latency_uses_proxy(self, ping, http, whereami):
+        ping.side_effect = lambda host, timeout: {
+            "baidu.com": 20,
+            "google.com": 180,
+        }[host]
+        http.side_effect = lambda url, timeout: (
+            40 if url == utils.NETWORK_ALIYUN_GUANGZHOU_URL else 260
+        )
+
+        profile = utils.detectNetworkProfile()
+
+        self.assertFalse(profile["is_oversea"])
+        self.assertEqual(profile["method"], "combined_latency")
+        self.assertEqual(profile["r2_ms"], 260)
+        self.assertEqual(profile["aliyun_ms"], 40)
+        whereami.assert_not_called()
+        self.assertEqual(
+            {call.args for call in ping.call_args_list},
+            {("baidu.com",), ("google.com",)},
+        )
+        self.assertTrue(all(call.kwargs["timeout"] == 10 for call in ping.call_args_list))
+
+    @patch("ryry.utils._network_whereami_country")
+    @patch("ryry.utils._network_http_ms")
+    @patch("ryry.utils._network_ping_ms")
+    def test_decisive_storage_latency_wins_conflicting_location(self, ping, http, whereami):
+        ping.side_effect = lambda host, timeout: {
+            "baidu.com": 20,
+            "google.com": 180,
+        }[host]
+        http.side_effect = lambda url, timeout: (
+            300 if url == utils.NETWORK_ALIYUN_GUANGZHOU_URL else 40
+        )
+
+        profile = utils.detectNetworkProfile()
+
+        self.assertTrue(profile["is_oversea"])
+        self.assertEqual(profile["method"], "storage_latency")
+        whereami.assert_not_called()
+
+    @patch("ryry.utils._network_whereami_country", return_value="CN")
+    @patch("ryry.utils._network_http_ms", return_value=None)
+    @patch("ryry.utils._network_ping_ms", return_value=None)
+    def test_whereami_cn_is_used_when_latency_is_inconclusive(self, ping, http, whereami):
+        profile = utils.detectNetworkProfile()
+
+        self.assertFalse(profile["is_oversea"])
+        self.assertEqual(profile["country"], "CN")
+        self.assertEqual(profile["method"], "whereami")
+        whereami.assert_called_once_with(timeout=10)
+
+    @patch("ryry.utils._network_whereami_country", return_value="US")
+    @patch("ryry.utils._network_http_ms", return_value=None)
+    @patch("ryry.utils._network_ping_ms", return_value=None)
+    def test_whereami_non_cn_stays_on_r2(self, ping, http, whereami):
+        profile = utils.detectNetworkProfile()
+
+        self.assertTrue(profile["is_oversea"])
+        self.assertEqual(profile["country"], "US")
+
+    @patch("ryry.utils._network_whereami_country", return_value=None)
+    @patch("ryry.utils._network_http_ms", return_value=None)
+    @patch("ryry.utils._network_ping_ms", return_value=None)
+    def test_all_detection_failures_remain_unknown(self, ping, http, whereami):
+        profile = utils.detectNetworkProfile()
+
+        self.assertIsNone(profile["is_oversea"])
+        self.assertEqual(profile["method"], "inconclusive")
+
+    @patch("ryry.utils.requests.get")
+    def test_whereami_response_is_parsed(self, get):
+        response = Mock()
+        response.json.return_value = {"code": 0, "data": "cn"}
+        get.return_value = response
+
+        self.assertEqual(utils._network_whereami_country(), "CN")
+        get.assert_called_once_with(utils.NETWORK_WHEREAMI_URL, timeout=10)
+
+
+if __name__ == "__main__":
+    unittest.main()

ryry_cli-6.23/tests/test_upload_proxy.py

@@ -0,0 +1,175 @@
+import unittest
+from tempfile import NamedTemporaryFile
+from unittest.mock import Mock, patch
+
+from ryry import upload
+
+
+class UploadProxyTest(unittest.TestCase):
+    def setUp(self):
+        self.s3_config = upload.getS3Config("app-upload.mekoapp.com")
+        self.proxy_config = self.s3_config["proxy"]
+
+    def test_worker_domains_enable_upload_proxy(self):
+        domains = [
+            "upload.dalipen.com",
+            "app-upload.dalipen.com",
+            "upload.mekoapp.com",
+            "app-upload.mekoapp.com",
+            "m.mekoapp.com",
+        ]
+
+        for domain in domains:
+            with self.subTest(domain=domain):
+                self.assertIs(upload.getS3Config(domain)["proxy"], upload.oss_upload_config)
+
+    def test_other_s3_domains_do_not_enable_upload_proxy(self):
+        domains = [
+            "datanet.dalipen.com",
+            "model.dalipen.com",
+            "r2.dalipen.com",
+            "widget.dalipen.com",
+        ]
+
+        for domain in domains:
+            with self.subTest(domain=domain):
+                self.assertNotIn("proxy", upload.getS3Config(domain))
+
+    @patch("uuid.uuid4", return_value="fixed-id")
+    @patch("ryry.upload.uploadToS3")
+    @patch("ryry.upload.uploadToS3Proxy")
+    @patch("ryry.upload.getCachedNetworkIsOversea", return_value=False)
+    def test_domestic_s3_upload_uses_proxy(self, _network, proxy_upload, s3_upload, _uuid):
+        proxy_upload.return_value = "https://app-upload.mekoapp.com/upload/2026/07/fixed-id.png"
+
+        result = upload.uploadByDomain(
+            "/tmp/source.png",
+            "https://app-upload.mekoapp.com/upload/2026/07",
+        )
+
+        self.assertEqual(
+            result,
+            "https://app-upload.mekoapp.com/upload/2026/07/fixed-id.png",
+        )
+        proxy_upload.assert_called_once_with(
+            "/tmp/source.png",
+            "fixedid.png",
+            self.s3_config,
+            "upload/2026/07",
+        )
+        s3_upload.assert_not_called()
+
+    @patch("uuid.uuid4", return_value="fixed-id")
+    @patch("ryry.upload.uploadToS3")
+    @patch("ryry.upload.uploadToS3Proxy")
+    @patch("ryry.upload.getCachedNetworkIsOversea", return_value=True)
+    def test_oversea_s3_upload_stays_on_r2(self, _network, proxy_upload, s3_upload, _uuid):
+        s3_upload.return_value = "https://app-upload.mekoapp.com/temp/fixed-id.png"
+
+        result = upload.uploadByDomain("/tmp/source.png", "app-upload.mekoapp.com")
+
+        self.assertEqual(result, "https://app-upload.mekoapp.com/temp/fixed-id.png")
+        s3_upload.assert_called_once_with(
+            "/tmp/source.png",
+            "fixedid.png",
+            self.s3_config,
+            "",
+        )
+        proxy_upload.assert_not_called()
+
+    @patch("uuid.uuid4", return_value="fixed-id")
+    @patch("ryry.upload.uploadToS3")
+    @patch("ryry.upload.uploadToS3Proxy")
+    @patch("ryry.upload.getCachedNetworkIsOversea", return_value=None)
+    def test_unknown_network_stays_on_r2(self, _network, proxy_upload, s3_upload, _uuid):
+        s3_upload.return_value = "https://app-upload.mekoapp.com/temp/fixed-id.png"
+
+        result = upload.uploadByDomain("/tmp/source.png", "app-upload.mekoapp.com")
+
+        self.assertEqual(result, "https://app-upload.mekoapp.com/temp/fixed-id.png")
+        s3_upload.assert_called_once()
+        proxy_upload.assert_not_called()
+
+    @patch("uuid.uuid4", return_value="fixed-id")
+    @patch("ryry.upload.uploadToS3")
+    @patch("ryry.upload.getCachedNetworkIsOversea")
+    def test_s3_without_proxy_does_not_check_network(self, network, s3_upload, _uuid):
+        config = dict(self.s3_config)
+        config.pop("proxy")
+        s3_upload.return_value = "https://model.dalipen.com/temp/fixed-id.png"
+
+        with patch("ryry.upload.getS3Config", return_value=config):
+            result = upload.uploadByDomain("/tmp/source.png", "model.dalipen.com")
+
+        self.assertEqual(result, "https://model.dalipen.com/temp/fixed-id.png")
+        network.assert_not_called()
+
+    @patch("uuid.uuid4", return_value="fixed-id")
+    @patch("ryry.upload.uploadByApiFallback", return_value="https://fallback.example/file.png")
+    @patch("ryry.upload.uploadToS3Proxy", side_effect=RuntimeError("proxy unavailable"))
+    @patch("ryry.upload.getCachedNetworkIsOversea", return_value=False)
+    def test_proxy_failure_uses_existing_api_fallback(
+        self,
+        _network,
+        _proxy_upload,
+        api_fallback,
+        _uuid,
+    ):
+        result = upload.uploadByDomain("/tmp/source.png", "app-upload.mekoapp.com")
+
+        self.assertEqual(result, "https://fallback.example/file.png")
+        api_fallback.assert_called_once_with(
+            "/tmp/source.png",
+            "png",
+            "meko_api",
+            keepItAlways=False,
+            needTranscode=False,
+            additionalUrl=False,
+        )
+
+    @patch("ryry.upload.uploadToOss")
+    def test_proxy_upload_returns_target_s3_domain(self, oss_upload):
+        oss_upload.return_value = "https://app-upload.mekoapp.com/temp/file.png"
+
+        result = upload.uploadToS3Proxy(
+            "/tmp/source.png",
+            "file.png",
+            self.s3_config,
+        )
+
+        self.assertEqual(result, "https://app-upload.mekoapp.com/temp/file.png")
+        oss_upload.assert_called_once_with(
+            "/tmp/source.png",
+            "file.png",
+            self.proxy_config,
+            "",
+            return_domain="https://app-upload.mekoapp.com",
+        )
+
+    @patch("requests.put")
+    def test_proxy_oss_put_uses_proxy_bucket_and_target_url(self, put_request):
+        put_request.return_value = Mock(status_code=200)
+
+        with NamedTemporaryFile() as source:
+            source.write(b"image")
+            source.flush()
+            result = upload.uploadToOss(
+                source.name,
+                "file.png",
+                self.proxy_config,
+                "upload/2026/07",
+                return_domain="https://app-upload.mekoapp.com",
+            )
+
+        self.assertEqual(
+            result,
+            "https://app-upload.mekoapp.com/upload/2026/07/file.png",
+        )
+        self.assertEqual(
+            put_request.call_args.args[0],
+            "https://p-upload-gz.oss-cn-guangzhou.aliyuncs.com/upload/2026/07/file.png",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()