cloudpss 3.2.0a2__py3-none-any.whl → 4.0.0a5__py3-none-any.whl

cloudpss/runner/IESLabPlanResult.py

@@ -0,0 +1,195 @@
+import json
+from math import fabs
+from ..utils.httprequests import request
+
+
+class IESLabPlanResult(object):
+    taskId = None
+
+    def __init__(self, simulationId, taskId=None, **kwargs) -> None:
+        """
+            初始化
+            获得taskId
+        """
+        self.simulationId = simulationId
+        if taskId is not None:
+            self.taskId = taskId
+        else:
+            self.taskId = self.__getLastTask()
+        pass
+
+    def __getLastTask(self):
+        '''
+            获取最后一次运行的taskID
+
+            :return: string 类型
+        '''
+        try:
+            r=request('GET','api/ieslab-plan/taskmanager/getSimuLastTasks',params={
+                'simuid':self.simulationId
+            })
+            result= json.loads(r.text)
+            return result['data'].get('task_id',None)
+        except:
+            return None
+
+    def status(self):
+        '''
+            获取运行状态
+
+            :return: boolean 类型
+        '''
+        log = self.GetLogs()
+        for l in log:
+            if l['data'] == 'run ends':
+                return True
+        return False
+
+    def GetLogs(self):
+        '''
+            获取运行日志
+
+            :return: dict 类型，代表日志信息
+        '''
+        if self.taskId is None:
+            raise Exception('未开始运行')
+        r = request('GET',
+                    'api/ieslab-plan/taskmanager/getOptimizationLog',
+                    params={
+                        'simuid': self.simulationId,
+                        'taskid': self.taskId
+                    })
+        result = json.loads(r.text)
+        return result['msg']
+
+    def GetPlanNum(self):
+        '''
+            获取当前result实例对应的优化方案数量
+            
+            :return: int类型，代表优化方案的数量
+        '''
+        if self.taskId is None:
+            raise Exception('未开始运行')
+        r = request('GET',
+                    'api/ieslab-plan/taskmanager/getOptimizationResult',
+                    params={
+                        'simuid': self.simulationId,
+                        'taskid': self.taskId,
+                        'resultType': 0
+                    })
+        result = json.loads(r.text)
+        return len(result['data'])
+
+    def GetPlanInfo(self, planID):
+        '''
+            获取planID对应的优化方案的基础信息
+            
+            :param: planID int类型，表示优化方案的ID，数值位于 0~优化方案数量 之间
+            
+            :return: dict类型，代表该方案的基础信息，包括投资、运行成本、负荷总量等信息
+        '''
+        if self.taskId is None:
+            raise Exception('未开始运行')
+        r = request('GET',
+                'api/ieslab-plan/taskmanager/getOptimizationResult',
+                params={
+                    'simuid': self.simulationId,
+                    'taskid': self.taskId,
+                    'resultType': 0
+                })
+        data = json.loads(r.text).get('data', [])
+        result = data[planID].get('data', {}).get('data', [])[0]
+        header = data[planID].get('data', {}).get('headerDesc', [])
+        dict_result = {val.get('hearderName', ''): result.get(val.get('key', ''), '') for val in header}
+        return dict_result
+
+
+    def GetPlanConfiguration(self, planID):
+        '''
+            获取planID对应的优化方案的配置信息
+            
+            :param: planID int类型，表示优化方案的ID，数值位于 0~优化方案数量 之间
+
+            :return: dict类型，代表该方案的配置信息，包括每种设备的选型配置、容量配置、成本等相关信息
+        '''
+        len = self.GetPlanNum()
+        if int(planID) > len:
+            raise Exception('计算方案id未产生')
+        r = request('GET',
+                    'api/ieslab-plan/taskmanager/getOptimizationResult',
+                    params={
+                        'simuid': self.simulationId,
+                        'taskid': self.taskId,
+                        "planId": planID,
+                        'resultType': 1
+                    })
+        d = json.loads(r.text)
+        result = {}
+        for val in d['data']:
+            result[val['u_name']] = val['data']['data']
+        return result
+
+    def GetComponentResult(self, planID, componentID, typicalDayName=''):
+        '''
+            获取planID对应的优化方案下componentID对应元件的运行信息
+            
+            :param: planID int 类型，表示优化方案的ID，数值位于 0~优化方案数量 之间
+            :param: componentID str 类型，表示元件的标识符
+            :param typicalDayName str 类型，代表典型日的名称
+
+            :return: dict类型，代表该元件在不同典型日下的运行信息
+        '''
+        len = self.GetPlanNum()
+        if int(planID) > len:
+            raise Exception('计算方案id未产生')
+        r = request('GET',
+                    'api/ieslab-plan/taskmanager/getOptimizationResult',
+                    params={
+                        'simuid': self.simulationId,
+                        'taskid': self.taskId,
+                        'resultType': 3,
+                        'typicalDay': typicalDayName,
+                        "planId": planID,
+                        'u_name': componentID
+                    })
+        d = json.loads(r.text)
+        dict_result = dict()
+        for val in d['data']:
+            for k, v in val.items():
+                dict_result[k] = v
+        return dict_result
+
+    def GetComponentTypiDays(self, planId, componentID):
+        '''
+            获取当前result实例对应的优化方案数量
+
+            :param: planID int 类型，表示优化方案的ID，数值位于 0~优化方案数量 之间
+            :param: componentID str 类型，表示元件的标识符
+            
+            :return: int类型，代表优化方案的数量
+        '''
+        if self.taskId is None:
+            raise Exception('未开始运行')
+        r = request('GET',
+                    'api/ieslab-plan/taskmanager/getOptimizationResult',
+                    params={
+                        'simuid': self.simulationId,
+                        'taskid': self.taskId,
+                        "planId": planId,
+                        'u_name': componentID,
+                        'resultType': 2
+                    })
+        result = json.loads(r.text)
+        return result['data']
+    
+    def getLastTaskResult(self):
+        '''
+            获取最后一次运行的taskID的运行结果
+
+            :return: dict 类型
+        '''
+        r=request('GET','api/ieslab-plan/taskmanager/getSimuLastTasks',params={
+            'simuid':self.simulationId
+        })
+        result= json.loads(r.text)
+        return result

cloudpss/runner/IESLabTypicalDayResult.py

@@ -0,0 +1,142 @@
+from .result import Result
+import re
+import copy
+class IESLabTypicalDayResult(Result):
+    def __init__(self, *args, **kwargs):
+        """
+            初始化
+        """
+        Result.__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.db.getMessageLength()
+        if (length > self.__plotIndex):
+            for num in range(self.__plotIndex, length):# update TypicalMonth
+                val = self.db.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,'没有该类型数据')

cloudpss/runner/MessageStreamReceiver.py

@@ -0,0 +1,193 @@
+import os
+from urllib.parse import urlparse
+import requests
+import websocket
+import datetime
+import pytz
+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(object):
+    """消息流读取函数结果"""
+
+    def __init__(self, id, db):
+        self.origin = os.environ.get('CLOUDPSS_API_URL',
+                                     'https://cloudpss.net/')
+        self.id = id
+        self.db = db
+        self._status = 0
+        self.error = None
+        self.isOpen = False
+
+    def create(self, type, comment=None, durability=1):
+        """
+        创建消息流
+        type: 消息流类型 'object' or 'binary'
+        comment: 消息流描述
+        durability: 消息流的数据将在多少天后被删除，其取值范围从 0 ~ MAX_DURABILITY
+        MAX_DURABILITY 默认为20
+        """
+        param = {}
+        if type != 'object' and type != 'binary':
+            raise Exception('type must be object or binary')
+        param['type'] = type
+        param['comment'] = comment
+        param['durability'] = durability
+        r = requests.post(self.origin + 'api/streams', json=param)
+        r.raise_for_status()
+        res = r.json()
+        print(res)
+        message = Message(res['id'], res['token'])
+        return message
+
+    def createBulk(self, param):
+        """
+        批量创建消息流
+        param: [{ "type": "{{type}}", "comment": "{{comment}}" , "durability": {{durability}}, "volume": {{volume}} }, ... ]
+        type: 消息流类型 'object' or 'binary'
+        comment: 消息流描述
+        durability: 消息流的数据将在多少天后被删除，其取值范围从 0 ~ MAX_DURABILITY
+        MAX_DURABILITY 默认为20
+
+        状态码说明：
+        201 返回流信息数组
+        400 不支持的 type，或其他输入错误
+        """
+        r = requests.post(self.origin + 'api/streams/bulk', json=param)
+        r.raise_for_status()
+        res = r.json()
+        messages = []
+        for item in res:
+            message = Message(item['id'], item['token'])
+            messages.append(message)
+        return messages
+
+    def info(self, id):
+        """
+        获取消息流信息
+        """
+        if id is None:
+            raise Exception('id is None')
+        r = requests.get(self.origin + 'api/streams/id/' + id + '/info')
+        r.raise_for_status()
+        return r.json()
+
+    def infoByToken(self, token):
+        """
+        获取消息流信息
+        相较于id获取消息流信息，token能够额外获取到handler的信息
+        """
+        if token is None:
+            raise Exception('token is None')
+        r = requests.get(self.origin + 'api/streams/token/' + token + '/info')
+        r.raise_for_status()
+        return r.json()
+
+    def freeze(self, token):
+        """
+        冻结消息流
+
+        状态码说明：
+        201 冻结成功
+        204 流已经被冻结
+        409 流正在活动中
+        404 未找到对应流
+        """
+        if token is None:
+            raise Exception('token is None')
+        r = requests.put(self.origin + 'api/streams/token/' + token +
+                         '/freeze')
+        r.raise_for_status()
+        return r.status_code
+
+    def delete(self, token):
+        """
+        删除消息流
+
+        状态码说明：
+        204 删除成功
+        409 流正在活动中
+        404 未找到对应流
+        """
+        if token is None:
+            raise Exception('token is None')
+        r = requests.delete(self.origin + 'api/streams/token/' + token)
+        r.raise_for_status()
+        return r.status_code
+
+    def receive(self, id, fr0m, on_open, on_message, on_error, on_close):
+        """
+        读取消息流中的数据
+        id: 消息流id
+        fr0m: 从哪个位置开始读取，如果为0则从头开始读取
+        on_open: 连接建立时的回调函数
+        on_message: 收到消息时的回调函数
+        on_error: 发生错误时的回调函数
+        on_close: 连接关闭时的回调函数
+        """
+        if 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/' + id
+        if fr0m is not None:
+            path = path + '&from=' + str(fr0m)
+        ws = websocket.WebSocketApp(path,
+                                    on_open=on_open,
+                                    on_message=on_message,
+                                    on_error=on_error,
+                                    on_close=on_close)
+        ws.run_forever()
+        return ws
+
+    ###下面是兼容Receiver部分功能实现
+    def on_message(self, ws, message):
+        data = IO.deserialize(message, 'ubjson')
+        msg = IO.deserialize(data['data'], 'ubjson')
+        if "when" not in msg:
+            msg['when']= datetime.datetime.now()
+        self.db.storeMessage(msg)
+
+    def on_error(self, ws, error):
+        msg = {
+            'type': 'log',
+            'verb': 'create',
+            'version': 1,
+            'data': {
+                'level': 'error',
+                'content': "websocket error",
+            },
+        }
+        self.db.storeMessage(msg)
+        self.error = error
+        self._status = -1
+
+
+    def on_close(self, ws,*args,**kwargs):
+        self.db.finished = datetime.datetime.now(tz=utc_tz).isoformat()
+        self._status = 1
+
+    def on_open(self, ws):
+        self.isOpen = True
+
+    def close(self, ws):
+        ws.close()
+
+    def status(self):
+        return self._status
+
+    def connect(self):
+        self._status = 0
+        self.ws = self.receive(self.id, None, self.on_open, self.on_message, self.on_error, self.on_close)
+
+

cloudpss/runner/receiver.py

@@ -16,7 +16,7 @@ class Receiver(object):
     '''
         socket 接收服务
     '''
-    def __init__(self, taskId, db, url: str = None, **kwargs):
+    def __init__(self, taskId, db, url = None, **kwargs):
         '''
             连接远程服务器接收结果数据
 
@@ -113,7 +113,7 @@ class Receiver(object):
         self.db.storeMessage(msg)
         self.error = error
 
-    def on_close(self, ws):
+    def on_close(self, *args,**kwargs):
         msg = {
             'type': 'log',
             'verb': 'create',
@@ -130,7 +130,7 @@ class Receiver(object):
 
     def connect(self):
         self._status = 0
-        url = requests.compat.urljoin(self.url, self.taskId)
+        url = requests.compat.urljoin(self.url, self.taskId)  # type: ignore
         self.ws = websocket.WebSocketApp(url + '?subscribe-broadcast',
                                          on_open=self.on_open,
                                          on_message=self.on_message,

cloudpss/runner/result.py

@@ -1,8 +1,9 @@
 import copy
 import re
 import collections
-from .storage import Storage
 
+from cloudpss.utils.httprequests import request
+from .storage import Storage
 
 class Result(object):
     """
@@ -333,8 +334,12 @@ class IESResult(Result):
         '''
             获取元件ID为compID的元件，对应标签为labelName、图例名称为traceName的plot 数据的第index项
 
-            >>> result.getPlots(compID, labelName, traceName, index)
-            {...}
+            :params: compID string类型，代表元件的标识符
+            :params: labelName string类型，代表plot曲线的分组标签
+            :params: traceName string类型，代表Plot曲线对应分组下的图例名称，当为'all'时，返回所有图例的数据
+            :params: index int类型，代表对应图例时序数据中的第index项，当小于0时，返回该图例所有的时序数据
+            
+            :return: dict类型
         '''
         self.__readPlotResult()
         key = compID + '_' + labelName
@@ -389,4 +394,33 @@ class IESResult(Result):
             >>> result.getSankeyNum()
         '''
         self.__readPlotResult()
-        return len(self.result['Sankey'])
+        return len(self.result['Sankey'])
+
+class IESLabSimulationResult(IESResult):
+    pass
+
+class IESLabTypicalDayResult(IESResult):
+    def GetTypicalDayNum():
+        '''
+            获取当前result的典型日数量
+            
+            :return: int类型，代表典型日数量
+        '''
+    def GetTypicalDayInfo(dayID):
+        '''
+            获取dayID对应典型日的基础信息
+            
+            :params: dayID int类型，表示典型日的ID，数值位于 0~典型日数量 之间
+            
+            :return: dict类型，代表典型日的基础信息，包括典型日所代表的日期范围、典型日的名称等
+        '''
+    def GetTypicalDayCurve(dayID, dataType):
+        '''
+            获取dayID对应典型日下dataType参数的时序曲线
+            
+            :params: dayID int类型，表示典型日的ID，数值位于 0~典型日数量 之间
+            :params: dataType enum类型，标识辐照强度、环境温度、土壤温度、建筑物高度风速、风机高度风速、电负荷、热负荷、冷负荷的参数类型
+            
+            :return: list<float>类型，代表以1h为时间间隔的该参数的日内时序曲线
+        '''
+    pass