ryry-cli 2.26__tar.gz → 2.28__tar.gz

{ryry_cli-2.26/ryry_cli.egg-info → ryry_cli-2.28}/PKG-INFO

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

ryry_cli-2.28/ryry/constant.py

@@ -0,0 +1,5 @@
+#!!!!! do not change this file !!!!!
+app_version="2.28"
+app_bulld_number=228
+app_bulld_anchor="Noh_2024-08-13 19:00:57.272337"
+app_name="ryry-cli"

{ryry_cli-2.26 → ryry_cli-2.28}/ryry/ryry_server_socket.py

@@ -56,12 +56,17 @@ class RyryTaskExecutor(Thread):
                 if data is None: 
                     break
                 try:
+                    print(f"======= get data = {data}")
                     taskUUID = data["taskUUID"]
+                    domain = ""
+                    params_tmp = json.loads(data["data"])
+                    if "domain" in params_tmp:
+                        domain = params_tmp["domain"]
                     timeout = 600
                     if "timeout" in data:
                         timeout = data["timeout"]
                     taskUtils.taskPrint(taskUUID, f"{current_thread().name} === receive task : {taskUUID}")
-                    _appendTask(taskUUID)
+                    _appendTask(taskUUID, domain)
                     is_ok, msg, result = task.runTask(data, timeout)
                     if is_ok == False:
                         taskUtils.notifyTaskFail(taskUUID, msg)
@@ -113,11 +118,12 @@ def _readTaskConfig():
 def _saveTaskConfig(data):
     with open(task_config_file, 'w') as f:
         json.dump(data, f)
-def _appendTask(taskUUID):
+def _appendTask(taskUUID, subDomain):
     lock.acquire()
     task_config = _readTaskConfig()
     task_config[taskUUID] = {
-        "pts": calendar.timegm(time.gmtime())
+        "pts": calendar.timegm(time.gmtime()),
+        "domain": subDomain
     }
     task_config["last_task_pts"] = task_config[taskUUID]["pts"]
     _saveTaskConfig(task_config)

{ryry_cli-2.26 → ryry_cli-2.28}/ryry/ryry_webapi.py

@@ -38,12 +38,8 @@ def _aigc_post(func, params, files={}, timeout=10):
 #======================================== Task Function ==============================
 def _extend():
     extInfo = store.readDeviceInfo()
-    extInfo["app_version"] = constant.app_version
-    extInfo["app_bulld_number"] = constant.app_bulld_number
-    extInfo["app_name"] = constant.app_name
-    extInfo["dts"] = datetime.datetime.now().strftime('%Y_%m_%d_%H_%M_%S_%f')
-    extInfo["trace_id"] = ''.join(str(uuid.uuid4()).split('-'))
-    extInfo["host_name"] = utils.get_hostname()
+    extInfo["app"] = constant.app_name + " " + constant.app_version
+    extInfo["host"] = utils.get_hostname()
     return json.dumps(extInfo)
 
 def GetTask():

{ryry_cli-2.26 → ryry_cli-2.28}/ryry/ryry_widget.py

@@ -126,9 +126,6 @@ def setWidgetData(root, widgetid):
     data["widget_id"] = widgetid
     data["name"] = "Demo"
     data["version"] = "1.0"
-    data["device_keys"] = [
-        utils.generate_unique_id()
-    ]
     data["cmd"] = os.path.join(root, "main.py")
     with open(os.path.join(root, "config.json"), 'w') as f:
         json.dump(data, f)

{ryry_cli-2.26 → ryry_cli-2.28}/ryry/server_func.py

@@ -2,7 +2,7 @@ import time, urllib3, sys, os
 from threading import Thread, Lock
 
 from ryry import ryry_webapi
-from ryry import store
+from ryry import upload
 from ryry import taskUtils
 
 lock = Lock()
@@ -40,7 +40,6 @@ class TaskThread(Thread):
         self.result = False, "Unknow"
         if len(self.func) > 0:
             self.checkUUID = ryry_webapi.createTask(self.func, self.params)
-            print("")
             self.checking = True
             self.checkCount = 0
             time.sleep(5)
@@ -73,11 +72,17 @@ class Task:
         if realTaskUUID == None or len(realTaskUUID) <= 0:
             realTaskUUID = taskUtils.taskInfoWithFirstTask()
             
+        support_subdomain = upload.getFirstSupportSubdomain()
+        domain = ""
+        if support_subdomain:
+            domain = support_subdomain["readpath"]
+            
         def _callback(idx, data):
             self.thread_data[str(idx)]["result"] = data
         idx = 0
         for param in multi_params:
             param["fromUUID"] = realTaskUUID
+            param["domain"] = domain
             self.thread_data[str(idx)] = {
                 "thread" :  TaskThread(idx, len(multi_params), func, param, _callback),
                 "result" : None

{ryry_cli-2.26 → ryry_cli-2.28}/ryry/task.py

@@ -73,7 +73,7 @@ def executeLocalPython(taskUUID, cmd, param, timeout):
     process = None
     try:
         if timeout == 0:
-            timeout = 60*60 #max 1 hour expire time
+            timeout = 60*30 #max half hour expire time
         process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         timeout_killprocess(process, timeout)
         output, error = process.communicate()

{ryry_cli-2.26 → ryry_cli-2.28}/ryry/taskUtils.py

@@ -19,6 +19,13 @@ def taskInfoWithFirstTask():
             if it not in ["last_task_pts"]:
                 return it
     return None
+def taskDomainWithUUID(taskUUID):
+    if os.path.exists(task_config_file):
+        with open(task_config_file, 'r') as f:
+            task_config = json.load(f)
+        if taskUUID in task_config:
+            return task_config[taskUUID]["domain"]
+    return ""
 
 WECHAT_URL = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=f40c5fb0-2734-48b0-a2d0-0faedf7dd2e4"
 def uploadFile2Wechat(filepath):

ryry_cli-2.28/ryry/upload.py

@@ -0,0 +1,245 @@
+from urllib.parse import *
+
+def addtionExif(srcFile, taskUUID):
+    if taskUUID == None or len(taskUUID) == 0:
+        return
+    try:
+        from pathlib import Path
+        file_name = Path(srcFile).name
+        ext = file_name[file_name.index("."):].lower()
+        if ext in [".jpg", ".png", ".jpeg", ".bmp", ".webp", ".gif"]:
+            from PIL import Image
+            img = Image.open(srcFile)
+            exif_dict = {
+                "0th": { }, 
+                "Exif": { }, 
+                "1st": { },
+                "thumbnail": None, 
+                "GPS": { }
+            }
+            import piexif
+            if taskUUID:
+                exif_dict["0th"] = { 
+                    piexif.ImageIFD.Software: f'make with ryry({taskUUID})'.encode(),
+                    piexif.ImageIFD.Copyright: f'dalipen'.encode(),
+                }
+                exif_dict["Exif"] = {
+                    piexif.ExifIFD.UserComment: f'make with ryry({taskUUID})'.encode(),
+                }
+            exif_dat = piexif.dump(exif_dict)
+            img.save(srcFile, "webp", quality=90, exif=exif_dat)
+        # elif ext in [".mp4",".mov",".avi",".wmv",".mpg",".mpeg",".rm",".ram",".flv",".swf",".ts"]:
+        #     params = {}
+        # elif ext in [".mp3",".aac",".wav",".wma",".cda",".flac",".m4a",".mid",".mka",".mp2",".mpa",".mpc",".ape",".ofr",".ogg",".ra",".wv",".tta",".ac3",".dts"]:
+        #     params = {}
+        # else:
+        #     params = {}
+    except:
+        return
+
+def transcode(srcFile):
+    try:
+        from pathlib import Path
+        from PIL import Image
+        file_name = Path(srcFile).name
+        ext = file_name[file_name.index("."):].lower()
+        if ext in [".jpg", ".png", ".jpeg", ".bmp"]:
+            image = Image.open(srcFile, "r")
+            format = image.format
+            if format.lower() != "webp":
+                fname = Path(srcFile).name
+                newFile = srcFile.replace(fname[fname.index("."):], ".webp")
+                image.save(newFile, "webp", quality=90)
+                image.close()
+                return True, newFile
+    except Exception as e:
+        pass
+    return False, srcFile
+
+def additionalUrl(srcFile, ossUrl):
+    from pathlib import Path
+    from PIL import Image
+    try:
+        file_name = Path(srcFile).name
+        ext = file_name[file_name.index("."):].lower()
+        params = {}
+        if ext in [".jpg", ".png", ".jpeg", ".bmp", ".webp", ".gif"]:
+            img = Image.open(srcFile)
+            params["width"] = img.width
+            params["height"] = img.height
+        elif ext in [".mp4",".mov",".avi",".wmv",".mpg",".mpeg",".rm",".ram",".flv",".swf",".ts"]:
+            params = {}
+        elif ext in [".mp3",".aac",".wav",".wma",".cda",".flac",".m4a",".mid",".mka",".mp2",".mpa",".mpc",".ape",".ofr",".ogg",".ra",".wv",".tta",".ac3",".dts"]:
+            params = {}
+        else:
+            params = {}
+        parsed_url = urlparse(ossUrl)
+        updated_query_string = urlencode(params, doseq=True)
+        final_url = parsed_url._replace(query=updated_query_string).geturl()
+        return final_url
+    except:
+        return ossUrl
+
+def upload(src, taskUUID, timeout=300, needTranscode=True):
+    import os
+    from pathlib import Path
+    from ryry import 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)
+
+    if needTranscode:
+        needDeleteSrc, newSrc = transcode(src)
+    else:
+        needDeleteSrc = False
+        newSrc = src
+    addtionExif(newSrc, taskUUID)
+    support_subdomain = getSubdomain(targetDomain)
+    if support_subdomain:
+        import uuid
+        file_name = Path(newSrc).name
+        ext = os.path.splitext(file_name)[-1][1:]
+        new_file_name = ''.join(str(uuid.uuid4()).split('-'))
+        ossurl = ftpUpload(newSrc, f"{new_file_name}.{ext}", support_subdomain)
+    else:
+        from ryry import ryry_webapi
+        file_name = Path(newSrc).name
+        ossurl = ryry_webapi.upload(newSrc, os.path.splitext(file_name)[-1][1:])
+        
+    ossurl = additionalUrl(newSrc, ossurl)
+    if needDeleteSrc:
+        os.remove(newSrc)
+    return ossurl
+
+def deepFtpUpload(file, new_file_name, ftp, writepath, readpath):
+    import ftplib, os
+    try:
+        ftp.cwd(writepath)
+    except ftplib.error_perm as e:
+        if e.args[0].startswith('550'):
+            ftp.mkd(writepath)
+            ftp.cwd(writepath)
+            
+    with open(file, 'rb') as f:
+        ftp.storbinary(f'STOR {new_file_name}', f)
+    return f"{readpath}/{new_file_name}"
+
+def ftpUpload(file, new_file_name, subdomain):
+    ip = subdomain["host"]
+    username = subdomain["username"]
+    password = subdomain["password"]
+    writepath = subdomain["writepath"]
+    readpath = subdomain["readpath"]
+    import ftplib
+    ftp = ftplib.FTP(ip)
+    ftp.login(username, password)
+
+    s = deepFtpUpload(file, new_file_name, ftp, writepath, readpath)
+    ftp.quit()
+    return s
+    
+def _can_connect_ftp(ip, username, password, writepath):  
+    import ftplib
+    try:  
+        ftp = ftplib.FTP(ip)
+        ftp.login(username, password)
+        try:
+            ftp.cwd(writepath)
+        except ftplib.error_perm as e:
+            if e.args[0].startswith('550'):
+                # 如果远程目录不存在，则创建它
+                ftp.mkd(writepath)
+                ftp.cwd(writepath)
+        ftp.quit()
+        return True
+    except Exception as e:  
+        print(f"Failed to connect to FTP server {ip}:{writepath} {e}")  
+        return False 
+    
+SUBDOMAIN = {
+    "192.168.3.220": {
+        "host": "192.168.3.220",
+        "username" : "xinyu100",
+        "password" : "xinyu100.com",
+        "writepath" : "1TB01/data/cache/",
+        # "readpath" : "http://192.168.3.220/01/cache"
+        "readpath" : "ftp://192.168.3.220/1TB01/data/cache"
+    },
+    "192.168.50.113": {
+        "host" : "192.168.50.113",
+        "username" : "ftpuser",
+        "password" : "ftpuser",
+        "writepath" : "cache/",
+        "readpath" : "ftp://192.168.50.113/cache"
+    }
+}
+def getSubdomain(targetDomain):
+    if len(targetDomain) <= 0:
+        return None
+    for ip in SUBDOMAIN.keys():
+        if _can_connect_ftp(ip, SUBDOMAIN[ip]["username"], SUBDOMAIN[ip]["password"], SUBDOMAIN[ip]["writepath"]) and targetDomain == SUBDOMAIN[ip]["readpath"]:
+            return SUBDOMAIN[ip]
+    return None
+
+def getFirstSupportSubdomain():
+    for ip in SUBDOMAIN.keys():
+        if _can_connect_ftp(ip, SUBDOMAIN[ip]["username"], SUBDOMAIN[ip]["password"], SUBDOMAIN[ip]["writepath"]):
+            return SUBDOMAIN[ip]
+    return None
+
+def download(url, saveDir):
+    import uuid, requests, os
+    from urlparser import urlparser
+    from fake_useragent import UserAgent
+    if len(url) <= 0:
+        return None
+    try:
+        name = ''.join(str(uuid.uuid4()).split('-'))
+        ext = urlparser.urlparse(url).path[urlparser.urlparse(url).path.index("."):]
+        savePath = os.path.join(saveDir, f"{name}{ext}")
+        
+        if url.startswith("ftp"):
+            import ftplib
+            parsed_url = urlparse(url)  
+            host = parsed_url.hostname
+            if host in SUBDOMAIN:
+                ip = SUBDOMAIN[host]["host"]
+                username = SUBDOMAIN[host]["username"]
+                password = SUBDOMAIN[host]["password"]
+                writepath = SUBDOMAIN[host]["writepath"]
+                readpath = SUBDOMAIN[host]["readpath"]
+                ftp = ftplib.FTP(ip)  
+                ftp.login(username, password)  
+            
+                remote_filepath = parsed_url.path[1:]
+                with open(savePath, 'wb') as f:  
+                    ftp.retrbinary(f'RETR {remote_filepath}', f.write)  
+                ftp.quit()  
+            else:
+                print(f"download fail: domain {host} not support")
+        elif url.startswith("http"):
+            requests.adapters.DEFAULT_RETRIES = 2
+            s = requests.session()
+            s.keep_alive = False
+            s.headers.update({'Connection':'close'})
+            ua = UserAgent()
+            file = s.get(url, verify=False, headers={'User-Agent': ua.random}, timeout=30)
+            if os.path.exists(savePath):
+                os.remove(savePath)
+            with open(savePath, "wb") as c:
+                c.write(file.content)
+            s.close()
+            if os.path.exists(savePath):
+                return savePath
+            else:
+                print(f"download success but file not found")
+        else:
+            print(f"url {url} not support")
+    except Exception as e:
+        print(f"download fail: {e}")
+    return None
+
+# url = upload("D:\\0505.mp4", "111", 300)
+# download(url, "D:\\")

{ryry_cli-2.26 → ryry_cli-2.28/ryry_cli.egg-info}/PKG-INFO

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

{ryry_cli-2.26 → ryry_cli-2.28}/setup.py

@@ -3,7 +3,7 @@ import os
 import subprocess
 import datetime
 
-ryry_version = "2.26"
+ryry_version = "2.28"
 ryry_build_number = int(ryry_version.replace(".",""))
 cur_dir = os.path.dirname(os.path.abspath(__file__))
 constanspy = os.path.join(cur_dir, "ryry", "constant.py")

ryry_cli-2.26/ryry/constant.py

@@ -1,5 +0,0 @@
-#!!!!! do not change this file !!!!!
-app_version="2.26"
-app_bulld_number=226
-app_bulld_anchor="Noh_2024-08-05 19:23:55.100225"
-app_name="ryry-cli"

ryry_cli-2.26/ryry/upload.py

@@ -1,106 +0,0 @@
-from urllib.parse import *
-
-def addtionExif(srcFile, taskUUID):
-    if taskUUID == None or len(taskUUID) == 0:
-        return
-    try:
-        from pathlib import Path
-        file_name = Path(srcFile).name
-        ext = file_name[file_name.index("."):].lower()
-        if ext in [".jpg", ".png", ".jpeg", ".bmp", ".webp", ".gif"]:
-            from PIL import Image
-            img = Image.open(srcFile)
-            exif_dict = {
-                "0th": { }, 
-                "Exif": { }, 
-                "1st": { },
-                "thumbnail": None, 
-                "GPS": { }
-            }
-            import piexif
-            if taskUUID:
-                exif_dict["0th"] = { 
-                    piexif.ImageIFD.Software: f'make with ryry({taskUUID})'.encode(),
-                    piexif.ImageIFD.Copyright: f'dalipen'.encode(),
-                }
-                exif_dict["Exif"] = {
-                    piexif.ExifIFD.UserComment: f'make with ryry({taskUUID})'.encode(),
-                }
-            exif_dat = piexif.dump(exif_dict)
-            img.save(srcFile, "webp", quality=90, exif=exif_dat)
-        # elif ext in [".mp4",".mov",".avi",".wmv",".mpg",".mpeg",".rm",".ram",".flv",".swf",".ts"]:
-        #     params = {}
-        # elif ext in [".mp3",".aac",".wav",".wma",".cda",".flac",".m4a",".mid",".mka",".mp2",".mpa",".mpc",".ape",".ofr",".ogg",".ra",".wv",".tta",".ac3",".dts"]:
-        #     params = {}
-        # else:
-        #     params = {}
-    except:
-        return
-
-def transcode(srcFile):
-    try:
-        from pathlib import Path
-        from PIL import Image
-        file_name = Path(srcFile).name
-        ext = file_name[file_name.index("."):].lower()
-        if ext in [".jpg", ".png", ".jpeg", ".bmp"]:
-            image = Image.open(srcFile, "r")
-            format = image.format
-            if format.lower() != "webp":
-                fname = Path(srcFile).name
-                newFile = srcFile.replace(fname[fname.index("."):], ".webp")
-                image.save(newFile, "webp", quality=90)
-                image.close()
-                return True, newFile
-    except Exception as e:
-        pass
-    return False, srcFile
-
-def additionalUrl(srcFile, ossUrl):
-    from pathlib import Path
-    from PIL import Image
-    try:
-        file_name = Path(srcFile).name
-        ext = file_name[file_name.index("."):].lower()
-        params = {}
-        if ext in [".jpg", ".png", ".jpeg", ".bmp", ".webp", ".gif"]:
-            img = Image.open(srcFile)
-            params["width"] = img.width
-            params["height"] = img.height
-        elif ext in [".mp4",".mov",".avi",".wmv",".mpg",".mpeg",".rm",".ram",".flv",".swf",".ts"]:
-            params = {}
-        elif ext in [".mp3",".aac",".wav",".wma",".cda",".flac",".m4a",".mid",".mka",".mp2",".mpa",".mpc",".ape",".ofr",".ogg",".ra",".wv",".tta",".ac3",".dts"]:
-            params = {}
-        else:
-            params = {}
-        parsed_url = urlparse(ossUrl)
-        updated_query_string = urlencode(params, doseq=True)
-        final_url = parsed_url._replace(query=updated_query_string).geturl()
-        return final_url
-    except:
-        return ossUrl
-
-def upload(src, taskUUID, timeout=300, needTranscode=True):
-    import os
-    from ryry import store
-    from pathlib import Path
-    from ryry import taskUtils
-    from ryry import ryry_webapi
-    import requests
-    if os.path.exists(src) == False:
-        raise Exception(f"upload file not found")
-    if taskUUID==None or len(taskUUID) <= 0:
-        taskUUID = taskUtils.taskInfoWithFirstTask()
-
-    if needTranscode:
-        needDeleteSrc, newSrc = transcode(src)
-    else:
-        needDeleteSrc = False
-        newSrc = src
-    addtionExif(newSrc, taskUUID)
-    file_name = Path(newSrc).name
-    ossurl = ryry_webapi.upload(newSrc, os.path.splitext(file_name)[-1][1:])
-    ossurl = additionalUrl(newSrc, ossurl)
-    if needDeleteSrc:
-        os.remove(newSrc)
-    return ossurl