cloudpss 4.0.4__py3-none-any.whl → 4.0.5__py3-none-any.whl

cloudpss/job/messageStreamReceiver.py

@@ -1,146 +0,0 @@
-import logging
-import sys
-from .jobReceiver import JobReceiver
-import os
-from urllib.parse import urlparse
-import websocket
-import pytz
-import threading
-import time
-
-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):
-        super().__init__()
-        self.job = job
-        self.id =self.job.output
-        self.origin = os.environ.get("CLOUDPSS_API_URL", "https://cloudpss.net/")
-        self.__hasOpen = False
-
-    def __path(self, from_=None):
-        if self.id is None:
-            raise Exception("id is None")
-        u = list(urlparse(self.origin))
-        head = "wss" if u[0] == "https" else "ws"
-        path = head + "://" + str(u[1]) + "/api/streams/id/" + self.id
-        if from_ is not None:
-            path = path + "?from=" + str(from_)
-        return path
-  
-    ###下面是兼容Receiver部分功能实现
-    def __on_message_legacy(self,  *args, **kwargs):
-        
-        if type(args[0]) != websocket.WebSocketApp:
-            message = args[0]
-        else:
-            message = args[1]
-        return self.__on_message(message)
-
-    def __on_message(self, message):
-        
-        data = IO.deserialize(message, "ubjson")
-        self.ws.url = self.__path(data["id"])
-        msg = IO.deserialize(data["data"], "ubjson")
-        self.messages.append(msg)
-        if(msg['type']=='terminate'):
-            self.close(self.ws)
-        return msg
-
-
-    def __on_error(self,  *args, **kwargs):
-        logging.debug("MessageStreamReceiver error")
-        msg = {
-            "type": "log",
-            "verb": "create",
-            "version": 1,
-            "data": {
-                "level": "error",
-                "content": "websocket error",
-            },
-        }
-        self.messages.append(msg)
-
-    def __on_close(self, *args, **kwargs):
-        if len(args)>1:
-            msg =args[2]
-            
-            if msg is not None and msg.startswith("CMS_NO_STREAM_ID:"):
-                self._status = 1
-                msg = {
-                    "type": "log",
-                    "version": 1,
-                    "data": {
-                        "level": "critical",
-                        "content": "未找到任务的输出流，运行结果可能已被清理。",
-                    },
-                }
-                self.messages.append(msg)
-                return
-        logging.debug("MessageStreamReceiver close")
-        msg = {
-            "type": "log",
-            "verb": "create",
-            "version": 1,
-            "data": {
-                "level": "info",
-                "content": "websocket closed",
-            },
-        }
-        self.messages.append(msg)
-        self._status = 1
-    
-    def __on_open(self,ws, *args, **kwargs):
-        self.ws = ws
-        logging.debug(f"MessageStreamReceiver on_open")
-        self._status = 0
-        self.__hasOpen = True
-        pass
-
-    def close(self, ws):
-        self._status = 1
-        ws.close()
-
-    @property
-    def status(self):
-        return self._status
-
-    def waitFor(self,timeOut=sys.maxsize):
-        """
-            阻塞方法，直到任务完成
-
-            :params timeOut: 超时时间
-        """
-        start = time.time()
-        while self.status == 0:
-            time.sleep(0)
-            if time.time()-start>timeOut:
-                raise Exception("time out")
-       
-
-    def connect(self):
-        self._status = 1
-        path = self.__path()
-        logging.info(f"receive data from websocket: {path}")
-        self.ws = websocket.WebSocketApp(
-            path,
-            on_open=self.__on_open,
-            on_message=self.__on_message_legacy,
-            on_error=self.__on_error,
-            on_close=self.__on_close,
-        )
-        thread = threading.Thread(target=self.ws.run_forever, kwargs={'ping_interval':60,'ping_timeout':5,'reconnect':True})
-        thread.setDaemon(True)
-        thread.start()
-        while not self.__hasOpen:
-            time.sleep(0)
-        

cloudpss/job/messageStreamSender.py

@@ -1,93 +0,0 @@
-import asyncio
-import sys, os
-import threading
-from urllib.parse import urlparse
-
-import aiohttp
-
-
-sys.path.append(os.path.join(os.path.dirname(__file__), "../"))
-
-import websocket
-
-from cloudpss.utils.IO import IO
-import time
-import logging
-
-
-class MessageStreamSender:
-    def __init__(self, job):
-        super().__init__()
-        self.job = job
-        self.origin = os.environ.get("CLOUDPSS_API_URL", "https://cloudpss.net/")
-        self.__hasOpen = False
-
-    def __on_message(self, ws, message):
-        logging.debug("on_message", message)
-
-    def __on_error(self, ws, error):
-        logging.debug("on_error")
-
-    def __on_close(self, *args, **kwargs):
-        # print("on_close")
-        time.sleep(0.5)
-        self._status = 0
-        self.__hasOpen=False
-
-        logging.debug("on_close")
-
-    def __on_open(self,ws):
-        self._status = 1
-        self.__hasOpen=True
-        logging.debug("on_open")
-        pass
-
-    def close(self):
-        # print("close")
-        self._status = 0
-        self.ws.close()
-        if self.websocket is not None:
-            asyncio.run(self.websocket.close())
-        if self.session is not None:
-            asyncio.run(self.session.close())
-
-    @property
-    def status(self):
-        return self._status
-
-    def write(self, message):
-        data = IO.serialize(message, "ubjson", None)
-        self.ws.send(data,websocket.ABNF.OPCODE_BINARY)
-
-    def connect_legacy(self):
-        """
-        同步方法连接ws
-        """
-        self._status = 0
-        if self.job.input 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.debug(f"MessageStreamSender 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,
-        )
-        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)
-        return self.ws
-
-    
-
-    

cloudpss/job/view/EMTView.py

@@ -1,214 +0,0 @@
-import copy
-import uuid
-from deprecated import deprecated
-from .view import View
-class EMTView(View):
-    """
-        电磁暂态结果视图， 
-
-        提供快捷 plot 数据的接口函数，获取到的 plot 数据为合并后的数据格式，不在是接收时分段的数据
-
-        该类只提供 EMT 仿真使用
-
-    """
-
-    def getPlots(self):
-        '''
-            获取所有的 plots 数据
-
-            >>> result.getPlots()
-            {...}
-        '''
-        for val in self._receiver:
-            if val['type'] == 'plot':
-                key = val['key']
-                if self.result.get(key, None) is None:
-                    self.result[key] = copy.deepcopy(val)
-                else:
-                    traces = val['data']['traces']
-                    for i in range(len(traces)):
-                        v = traces[i]
-                        self.result[key]['data']['traces'][i]['x'].extend(
-                            v['x'])
-                        self.result[key]['data']['traces'][i]['y'].extend(
-                            v['y'])
-        return self.result.values()
-    
-    def getPlot(self, index: int):
-        '''
-            获取指定序号的曲线分组
-
-            :params: index 图表位置
-
-            >>> result.getPlot(0)
-            {...}
-        '''
-        self.getPlots()
-        if self.result is not None:
-            return self.result.get('plot-{0}'.format(int(index)), None)
-        
-    def getPlotChannelNames(self, index):
-        '''
-            获取一组输出分组下的所有通道名称
-
-            :params: index 输出通道位置
-
-            :return: 通道名称数组
-
-            >>>names= result.getPlotChannelNames(0)
-            []
-        '''
-        plot = self.getPlot(int(index))
-        if plot is None:
-            return None
-
-        return [val['name'] for val in plot['data']['traces']]
-    
-    def getPlotChannelData(self, index, channelName):
-        '''
-            获取一组输出分组下指定通道名称的数据
-
-            :params: index 输出通道位置
-            :params: channelName 输出通道名称
-
-            :return: 通道数据, 一个 trace 数据
-
-            >>>channel= result.getPlotChannelData(0，'')
-            {...}
-        '''
-        plot = self.getPlot(int(index))
-        if plot is None:
-            return None
-        for val in plot['data']['traces']:
-            if val['name'] == channelName:
-                return val
-        return val
-    
-    def next(self):
-        """
-            前进一个时步
-        """
-        
-        self.goto(-1)
-        
-    def goto(self,step):
-        """
-            前进到指定时步
-        """
-        if self._sender is not None:
-            self._sender.write({'type': 'debug', 'step': step})
-        else:
-            raise Exception('sender is None')
-    
-    
-    def writeShm(self,path,buffer,offset):
-        """
-            写内存接口 （未最终确定，后续版本进行修改，使用时注意版本）
-        """
-        if self._sender is not None:
-            self._sender.write({'type': 'memory', 'path': path,'buffer':buffer,'offset':offset})
-        else:
-            raise Exception('transmitter is None')
-    
-    def _writeEvent(self,eventType,eventTime,eventTimeType,defaultApp):
-        if self._sender is  None:
-            raise Exception('transmitter is None')
-        event = {
-            'eventType': eventType,
-            'eventTime': eventTime,
-            'eventTimeType':eventTimeType,
-            "defaultApp": defaultApp
-        }
-        self._sender.write({'type': 'eventchain', 'event': [event]})
-    
-    def stopSimulation(self):
-        """
-            停止仿真
-        """
-        param = {
-            "ctrl_type": "0",
-            "uuid": str(uuid.uuid1()),
-            'message': {
-                'log': '停止任务 ',
-            }
-        }
-        eventData = {}
-        eventData = {'SimuCtrl': param}
-
-        self._writeEvent('time','-1','1',{'SimuCtrl': eventData})
-            
-    def _snapshotControl(self,ctrlType,snapshotNumber,log):
-        """
-            断面控制
-        """
-        param = {
-            "ctrl_type": ctrlType,
-            "snapshot_number": snapshotNumber,
-            "uuid": str(uuid.uuid1()),
-            'message': {
-                'log': log
-            },
-        }
-        eventData = {}
-        eventData = {'SnapshotCtrl': param}
-        self._writeEvent('time','-1','1',{'SnapshotCtrl': eventData})  
-    def saveSnapshot(self,snapshotNumber,log='保存断面成功'):
-        """
-            通过事件链保存断面
-        """
-        self._snapshotControl('0',snapshotNumber,log)
-    def loadSnapshot(self,snapshotNumber,log='加载断面成功'):
-        """
-            通过事件链加载断面
-        """
-        self._snapshotControl('1',snapshotNumber,log)
-        
-    def control(self,controlParam,eventTime='-1',eventTimeType='1'):
-        """
-            控制仿真
-        """    
-
-        if type(controlParam) is not list:
-            controlParam=[controlParam]
-        para={}
-        
-        for param in controlParam:
-            para[param['key']]={
-                'Value': {
-                    'value': param['value'],
-                    'uuid': param['uuid'] if param.get('uuid',None) is not None else str(uuid.uuid1()),
-                    'cmd': 'add',
-                    'message': param.get('message')  if param.get('message',None) is not None else{
-                        'log': param.get('log')  if param.get('log',None) is not None else '值变化到 '+str(param['value']),
-                    },
-                }
-            }
-        self._writeEvent('time',eventTime,eventTimeType,{'para': para})
-        pass
-    
-    def monitor(self,monitorParam,eventTime='-1',eventTimeType='1'):
-        
-        if type(monitorParam) is not list:
-            monitorParam=[monitorParam]
-        para={}
-        for param in monitorParam:
-            para[param['key']]={
-                'a': {
-                    'uuid':param['uuid'] if param.get('uuid',None) is not None else str(uuid.uuid1()),
-                    'function':param['function'],
-                    'cmd':'add',
-                    'period':param['period'],
-                    'value':param['value'],
-                    'key':param['key'],
-                    'freq':param['freq'],
-                    'condition':param['condition'],
-                    'cycle':param['cycle'],
-                    'nCount':param['nCount'],
-                    'message': param.get('message')  if param.get('message',None) is not None else{
-                        'log': param.get('log')  if param.get('log',None) is not None else '消息达到阈值 '+str(param['value']),
-                    },
-                }
-            }
-        self._writeEvent('time',eventTime,eventTimeType,{'para': para})
-        
-        pass

cloudpss/job/view/IESLabSimulationView.py

@@ -1,5 +0,0 @@
-from .IESView import IESView
-
-
-class IESLabSimulationView(IESView):
-    pass

cloudpss/job/view/IESLabTypicalDayView.py

@@ -1,136 +0,0 @@
-from .IESView import IESView
-import re
-import copy
-class IESLabTypicalDayView(IESView):
-    
-    def __init__(self, *args, **kwargs):
-        """
-            初始化
-        """
-        IESView.__init__(self, *args, **kwargs)
-        self.__plotIndex = 0
-        self.__typicalIndex = 0
-        self.__type_list =['电负荷', '热负荷','冷负荷','总辐射','散射辐射', '直射辐射',  '天顶角', '环境温度', '土壤温度', '10m风速', '50m风速', '建筑物高度风速', '风机高度风速']
-        self.result = {'TypicalMonth': [],'TypicalDay': []}
-        for i in range(12):
-            self.result['TypicalMonth'].append({'月份': int, '持续天数': [],'电负荷': [], '热负荷': [],'冷负荷':[],'总辐射': [],'直射辐射': [],'散射辐射': [],'天顶角': [],
-                                                '环境温度': [], '土壤温度': [], '建筑物高度风速': [], '风机高度风速': [],'10m风速': [], '50m风速': [] })
-    def __readPlotResult(self):
-        length = self.getMessageLength()
-        if (length > self.__plotIndex):
-            for num in range(self.__plotIndex, length):# update TypicalMonth
-                val = self.getMessage(num)
-                if val['type'] == 'plot':
-                    key_list = re.split('-month',val['key'])#分别为类型和月份
-                    # print(key_list)
-                    self.result['TypicalMonth'][int(key_list[1])-1]['月份'] = int(key_list[1])
-                    if key_list[0] in ['总辐射','散射辐射']:#从第一类数据中分析每个月各个典型日的天数
-                        typicalNum = len(val['data']['traces'])
-                        for i in range(typicalNum):
-                            self.result['TypicalMonth'][int(key_list[1])-1]['持续天数'].append(int(re.findall('\d+',val['data']['traces'][i]['name'])[1]))
-                    # 每个月各类型数据的各个典型日的数据，由于部分月份可能没有电冷热负荷，某月的某个典型日可能缺少冷热负荷
-                    for i in range(typicalNum):
-                        self.result['TypicalMonth'][int(key_list[1])-1][key_list[0]].append([])
-                    for i in range(len(val['data']['traces'])):
-                        self.result['TypicalMonth'][int(key_list[1])-1][key_list[0]][int(re.findall('\d+',val['data']['traces'][i]['name'])[0])-1] = copy.deepcopy(val['data']['traces'][i]['y'])
-            self.__plotIndex = length
-            # update TypicalDay based on TypicalMonth
-            for m in range(12):
-                for i in range(len(self.result['TypicalMonth'][m]['持续天数'])):
-                    self.result['TypicalDay'].append({'info':{'typicalDayID': int, 'name': str, 'duration': int, 'maxElectricalLoad': 0.0, 'maxHeatLoad': 0.0, 'maxCoolLoad': 0.0}, 
-                                                      'data': {'电负荷': [], '热负荷': [],'冷负荷':[],'总辐射': [],'直射辐射': [],'散射辐射': [],'天顶角': [],
-                                                               '环境温度': [], '土壤温度': [], '建筑物高度风速': [], '风机高度风速': [],'10m风速': [], '50m风速': []}})
-                    self.result['TypicalDay'][-1]['info']['typicalDayID'] = self.__typicalIndex
-                    self.result['TypicalDay'][-1]['info']['name'] = str(m+1) + '月典型日' + str(i+1)
-                    self.result['TypicalDay'][-1]['info']['duration'] = self.result['TypicalMonth'][m]['持续天数'][i]
-                    if self.result['TypicalMonth'][m]['电负荷']:
-                        if self.result['TypicalMonth'][m]['电负荷'][i]:
-                            self.result['TypicalDay'][-1]['info']['maxElectricalLoad'] = max(self.result['TypicalMonth'][m]['电负荷'][i])
-                    if self.result['TypicalMonth'][m]['热负荷']:
-                        if self.result['TypicalMonth'][m]['热负荷'][i]:
-                            self.result['TypicalDay'][-1]['info']['maxHeatLoad'] = max(self.result['TypicalMonth'][m]['热负荷'][i])
-                    if self.result['TypicalMonth'][m]['冷负荷']:
-                        if self.result['TypicalMonth'][m]['冷负荷'][i]:
-                            self.result['TypicalDay'][-1]['info']['maxCoolLoad'] = max(self.result['TypicalMonth'][m]['冷负荷'][i])
-                    for type_i in self.__type_list:
-                        if self.result['TypicalMonth'][m][type_i]:
-                            self.result['TypicalDay'][-1]['data'][type_i] = self.result['TypicalMonth'][m][type_i][i]
-                    self.__typicalIndex += 1
-    def GetTypical(self):
-        '''
-            获取所有的 GetTypical 典型日数据
-
-            >>> result.GetTypical()
-            {...}
-        '''
-        self.__readPlotResult()
-        return self.result['TypicalDay']
-    def GetTypicalDayNum(self):
-        '''
-            获取当前result的典型日数量
-            
-            :return: int类型，代表典型日数量
-        '''
-        
-        self.__readPlotResult()
-        return self.__typicalIndex
-    def GetTypicalDayInfo(self,dayID):
-        '''
-            获取dayID对应典型日的基础信息
-            
-            :params: dayID int类型，表示典型日的ID，数值位于 0~典型日数量 之间
-            
-            :return: dict类型，代表典型日的基础信息，包括典型日所代表的日期范围、典型日的名称等
-        '''
-        self.__readPlotResult()
-        return self.result['TypicalDay'][dayID].get('info','没有该数据')
-        
-    def GetTypicalDayCurve(self,dayID, dataType):
-        '''
-            获取dayID对应典型日下dataType参数的时序曲线
-            
-            :params: dayID int类型，表示典型日的ID，数值位于 0~典型日数量 之间
-            :params: dataType enum类型，标识辐照强度、环境温度、土壤温度、建筑物高度风速、风机高度风速、电负荷、热负荷、冷负荷的参数类型
-            
-            :return: list<float>类型，代表以1h为时间间隔的该参数的日内时序曲线
-        '''
-        self.__readPlotResult()
-        return self.result['TypicalDay'][dayID]['data'].get(dataType,'没有该类型数据')
-    
-    def GetTypicalMonth(self):
-        '''
-            获取所有的 GetTypicalMonth 数据
-            
-            >>> result.GetTypicalMonth()
-            
-            :return: list<dict>类型，代表各月各类型的典型日数据
-        '''
-        self.__readPlotResult()
-        return self.result['TypicalMonth']
-    
-    def GetTypicalMonthNum(self,monthID):
-        '''
-            获取第monthID月各类型的典型日数据
-
-            >>> result.GetTypicalMonthNum()
-            
-            :params: monthID int类型，表示典型月的ID，数值位于 1-12 之间
-
-            :return: dict类型，代表第monthID月各类型的典型日数据
-            {...}
-        '''
-        self.__readPlotResult()
-        return self.result['TypicalMonth'][monthID-1]
-        
-    
-    def GetTypicalMonthCurve(self,monthID, dataType):
-        '''
-            获取dayID对应典型日下dataType参数的时序曲线
-            
-            :params: monthID int类型，表示典型月的ID，数值位于 1-12 之间
-            :params: dataType enum类型，标识总辐射、环境温度、土壤温度、建筑物高度风速、风机高度风速、电负荷、热负荷、冷负荷的参数类型
-            
-            :return: list<list>类型，代表以1h为时间间隔的该参数的典型日内时序曲线
-        '''
-        self.__readPlotResult()
-        return self.result['TypicalMonth'][monthID-1].get(dataType,'没有该类型数据')