cloudpss 4.0.2a1__py3-none-any.whl → 4.1.1a2__py3-none-any.whl

cloudpss/job/messageStreamReceiver.py

@@ -1,35 +1,30 @@
 import logging
+
+from cloudpss.utils.httpAsyncRequest import websocket_connect
 from .jobReceiver import JobReceiver
 import os
 from urllib.parse import urlparse
-import websocket
 import pytz
-import threading
-import time
-utc_tz = pytz.timezone('UTC')
+
+utc_tz = pytz.timezone("UTC")
 
 from ..utils.IO import IO
 
 
 class Message(object):
-
     def __init__(self, id, token):
         self.id = id
         self.token = token
-        
 
 
 class MessageStreamReceiver(JobReceiver):
-
     def __init__(self, job, dev=False):
         super().__init__()
         self.job = job
         self.dev = dev
-        self.origin = os.environ.get('CLOUDPSS_API_URL',
-                                     'https://cloudpss.net/')
-        self.__hasOpen=False
+        self.origin = os.environ.get("CLOUDPSS_API_URL", "https://cloudpss.net/")
 
-    def receive(self, id, fr0m, on_open, on_message, on_error, on_close):
+    async def receive(self, id, fr0m, on_open, on_message, on_error, on_close):
         """
         读取消息流中的数据
         id: 消息流id
@@ -40,29 +35,30 @@ class MessageStreamReceiver(JobReceiver):
         on_close: 连接关闭时的回调函数
         """
         if id is None:
-            raise Exception('id is None')
+            raise Exception("id is None")
         u = list(urlparse(self.origin))
-        head = 'wss' if u[0] == 'https' else 'ws'
+        head = "wss" if u[0] == "https" else "ws"
 
-        path = head + '://' + str(u[1]) + '/api/streams/id/' + id
+        path = head + "://" + str(u[1]) + "/api/streams/id/" + id
         if fr0m is not None:
-            path = path + '&from=' + str(fr0m)
-        logging.info(f"receive data from websocket: {path}")
-        ws = websocket.WebSocketApp(path,
-                                    on_open=on_open,
-                                    on_message=on_message,
-                                    on_error=on_error,
-                                    on_close=on_close)
-        
+            path = path + "&from=" + str(fr0m)
+        logging.info(f"MessageStreamReceiver data from websocket: {path}")
+        ws =await websocket_connect(
+            path,
+            open_func=on_open,
+            receive_func=on_message,
+            error_func=on_error,
+            closed_func=on_close,
+        )
+
         return ws
-    
+
     ###下面是兼容Receiver部分功能实现
 
-    def on_message(self, ws, message):
-        data = IO.deserialize(message, 'ubjson')
-        msg = IO.deserialize(data['data'], 'ubjson')
-        if msg.get('type', None) == 'log' and self.dev:
-            print(msg)
+    def on_message(self, message):
+        data = IO.deserialize(message, "ubjson")
+        msg = IO.deserialize(data["data"], "ubjson")
+        print(msg)
         self.messages.append(msg)
         # if msg and type(msg) is dict and msg.get('type', None) == 'terminate':
         #     self.close(ws)
@@ -70,12 +66,12 @@ class MessageStreamReceiver(JobReceiver):
     def on_error(self, ws, error):
         logging.info("MessageStreamReceiver error")
         msg = {
-            'type': 'log',
-            'verb': 'create',
-            'version': 1,
-            'data': {
-                'level': 'error',
-                'content': "websocket error",
+            "type": "log",
+            "verb": "create",
+            "version": 1,
+            "data": {
+                "level": "error",
+                "content": "websocket error",
             },
         }
         self.messages.append(msg)
@@ -84,37 +80,47 @@ class MessageStreamReceiver(JobReceiver):
         logging.info("MessageStreamReceiver close")
         self._status = 0
         msg = {
-            'type': 'log',
-            'verb': 'create',
-            'version': 1,
-            'data': {
-                'level': 'error',
-                'content': "websocket closed",
+            "type": "log",
+            "verb": "create",
+            "version": 1,
+            "data": {
+                "level": "error",
+                "content": "websocket closed",
             },
         }
         self.messages.append(msg)
 
-    def on_open(self, ws):
+    def on_open(self):
+        logging.info(f"MessageStreamReceiver on_open")
         self._status = 1
-        self.__hasOpen=True
+        self.__hasOpen = True
         pass
 
     def close(self, ws):
         self._status = 0
         ws.close()
 
+    @property
+    def status(self):
+        return self._status
+
     @property
     def end(self):
-        return  not self._status
+        return not self._status
 
-    def connect(self):
+    async def connect(self):
         self._status = 0
-        self.ws = self.receive(self.job.output, None, self.on_open,
-                               self.on_message, self.on_error, self.on_close)
-        
-        
-        thread = threading.Thread(target=self.ws.run_forever, args=(None , None , 6, 3))
-        thread.setDaemon(True)
-        thread.start()
-        while not self.__hasOpen:
-            time.sleep(0.2)
+        self.ws = await self.receive(
+            self.job.output,
+            None,
+            self.on_open,
+            self.on_message,
+            self.on_error,
+            self.on_close,
+        )
+
+        # thread = threading.Thread(target=self.ws.run_forever, args=(None, None, 6, 3))
+        # thread.setDaemon(True)
+        # thread.start()
+        # while not self.__hasOpen:
+        #     time.sleep(0.2)

cloudpss/job/messageStreamSender.py

@@ -1,7 +1,10 @@
-import sys,os
+import sys, os
 import threading
 from urllib.parse import urlparse
-sys.path.append(os.path.join(os.path.dirname(__file__), '../'))
+
+from cloudpss.utils.httpAsyncRequest import websocket_connect
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "../"))
 
 import websocket
 
@@ -9,36 +12,34 @@ from cloudpss.utils.IO import IO
 import time
 import logging
 
-class MessageStreamSender():
 
+class MessageStreamSender:
     def __init__(self, job, dev=False):
         super().__init__()
         self.job = job
         self.dev = dev
-        self.origin = os.environ.get('CLOUDPSS_API_URL',
-                                     'https://cloudpss.net/')
+        self.origin = os.environ.get("CLOUDPSS_API_URL", "https://cloudpss.net/")
 
     ###下面是兼容Receiver部分功能实现
 
     def on_message(self, ws, message):
-        logging.info('on_message',message)
+        logging.info("on_message", message)
 
     def on_error(self, ws, error):
-        logging.info('on_error')
+        logging.info("on_error")
 
     def on_close(self, *args, **kwargs):
         time.sleep(0.5)
         self._status = 0
-        
-        logging.info('on_close')
 
-    def on_open(self, ws):
+        logging.info("on_close")
+
+    def on_open(self):
         self._status = 1
-        logging.info('on_open')
+        logging.info("on_open")
         pass
 
     def close(self):
-        
         self._status = 0
         self.ws.close()
 
@@ -47,28 +48,32 @@ class MessageStreamSender():
         return self._status
 
     def write(self, message):
-        data = IO.serialize(message, 'ubjson',None)
-        self.ws.send(data, websocket.ABNF.OPCODE_BINARY)
-        
-    def connect(self):
-        logging.info('connect')
+        data = IO.serialize(message, "ubjson", None)
+        self.ws.send_bytes(data)
+
+    async def connect(self):
         self._status = 0
         if self.job.input is None:
-            raise Exception('id is None')
+            raise Exception("id is None")
+        if self.job.input=='00000000-0000-0000-0000-000000000000':
+            return
         u = list(urlparse(self.origin))
-        head = 'wss' if u[0] == 'https' else 'ws'
-
-        path = head + '://' + str(u[1]) + '/api/streams/token/' + self.job.input
-        logging.info(f"receive data from websocket: {path}")
-        
-        self.ws = websocket.WebSocketApp(path,
-                                    on_open=self.on_open,
-                                    on_message=self.on_message,
-                                    on_error=self.on_error,
-                                    on_close=self.on_close)
+        head = "wss" if u[0] == "https" else "ws"
         
-        thread = threading.Thread(target=self.ws.run_forever, args=(None , None , 6, 3))
-        thread.setDaemon(True)
-        thread.start()
-        while self.status != 1:
-            time.sleep(0.2)
+
+        path = head + "://" + str(u[1]) + "/api/streams/token/" + self.job.input
+        logging.info(f"MessageStreamSender data from websocket: {path}")
+
+        self.ws = await websocket_connect(
+            path,
+            open_func=self.on_open,
+            receive_func=self.on_message,
+            error_func=self.on_error,
+            closed_func=self.on_close,
+        )
+
+        # thread = threading.Thread(target=self.ws.run_forever, args=(None, None, 6, 3))
+        # thread.setDaemon(True)
+        # thread.start()
+        # while self.status != 1:
+        #     time.sleep(0.2)

cloudpss/model/implements/diagram.py

@@ -1,6 +1,4 @@
 from .component import Component
-from typing import Optional
-import uuid
 
 
 class DiagramImplement(object):
@@ -46,114 +44,3 @@ class DiagramImplement(object):
         """
 
         return self.cells
-    
-    def addComponent(
-        self,
-        definition: str,
-        label: str,
-        args: dict = {},
-        pins: dict = {},
-        canvas: Optional[str] = None,
-        position: Optional[dict] = None,
-        size: Optional[dict] = None,
-    ) -> Component:
-        """
-        添加元件
-
-        :param definition 元件定义， 连接线没有definition
-        :param label 元件标签
-        :param args 元件参数数据，连接线没有参数数据
-        :param pins 元件引脚数据，连接线没有引脚数据
-        :param canvas 元件所在图纸数据
-        :param position 元件位置数据, 连接线没有位置数据
-        :param size 元件大小数据，连接线没有大小数据
-
-        :return: Component
-
-        >>>> diagram.addComponent(args)
-        """
-        id = "comp_" + str(uuid.uuid4())
-        shape = "diagram-component"
-        definition = definition
-        label = label or definition
-        args = args.copy()
-        pins = pins.copy()
-        props = {"enabled": True}
-        context = {}
-        canvas or self.canvas[0].get("key", "canvas_0")
-        position = position.copy() if position else {"x": 0, "y": 0}
-        size = size.copy() if size else None
-        zIndex = 0
-        style = {
-            "--fill": "var(--spectrum-global-color-gray-100)",
-            "--fill-opacity": 1,
-            "--font-family": "var(--spectrum-global-font-family-base, Arial, Helvetica, sans-serif)",
-            "--stroke": "var(--spectrum-global-color-gray-900)",
-            "--stroke-opacity": 1,
-            "--stroke-width": 2,
-            "--text": "var(--spectrum-global-color-gray-900)",
-            "--text-opacity": 1,
-        }
-        diagram = {
-            "id": id,
-            "shape": shape,
-            "definition": definition,
-            "label": label,
-            "args": args,
-            "pins": pins,
-            "props": props,
-            "context": context,
-            "canvas": canvas,
-            "position": position,
-            "size": size,
-            "zIndex": zIndex,
-            "style": style,
-        }
-        component = Component(diagram)
-        self.cells[id] = component
-        return component
-
-    def removeComponent(self, key: str) -> bool:
-        """
-        删除元件
-
-        :param key: str
-        :return: bool
-
-        >>>> diagram.removeComponent(key)
-        """
-        component = self.cells.get(key)
-        if not component:
-            return False
-        position = component.position.copy()
-        del self.cells[key]
-        for edge in self.cells.values():
-            if edge.shape == "diagram-edge":
-                if edge.source.get("cell") == key:
-                    edge.source = position.copy()
-                    position["x"] += 5
-                    position["y"] += 5
-
-                if edge.target.get("cell") == key:
-                    edge.target = position.copy()
-                    position["x"] += 5
-                    position["y"] += 5
-        return True
-
-    def updateComponent(self, key: str, args: dict) -> bool:
-        """
-        更新元件
-
-        :param key: str
-        :param args: dict
-        :return: bool
-
-        >>>> diagram.updateComponent(key)
-        """
-        component = self.cells.get(key)
-        if not component:
-            return False
-        for k, v in self.cells.items():
-            if k == key:
-                v.__dict__.update(args)
-                return True