cloudpss 4.1.1b8__py3-none-any.whl → 4.5.13__py3-none-any.whl

cloudpss/runner/IESLabTypicalDayResult.py

@@ -9,54 +9,51 @@ class IESLabTypicalDayResult(Result):
         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风速': [] })
-        
+        self.__type_list =['总辐射','散射辐射', '直射辐射','天顶角', '环境温度', '湿球温度','土壤温度', '10m风速', '50m风速','电负荷', '热负荷','冷负荷','氢负荷']
+        self.__map_load = { 'maxElectricalLoad':'电负荷', 'maxHeatLoad':'热负荷','maxCoolLoad':'冷负荷','maxHydrogenLoad':'氢负荷' }
+        self.result = {'TypicalMonth': [{'月份': int,'持续天数': [],**{key: [] for key in self.__type_list}} for i in range(12)],'TypicalDay': []}
 
     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
+                if val['type'] == 'plot':# 每个月各类型数据的各个典型日的数据，由于部分月份可能没有电冷热负荷，某月的某个典型日可能缺少冷热负荷
+                    key_re = re.split('-month',val['key'])#格式为：散射辐射-month1，re后分别为类型和月份
+                    typical_month_m = self.result['TypicalMonth'][int(key_re[1])-1]
+                    typical_month_m['月份'] = int(key_re[1])
+                    val_data_traces = val['data']['traces']
+                    #val['data']['traces'][i]['name']格式为：典型日1-共31天，re正则后[0]为典型日顺序，[1]为持续天数
+                    typicalNum = int(re.findall('\d+',val_data_traces[-1]['name'])[0])
+                    for i in range(typicalNum):#取该类型的最后一个典型日顺序，当该类型缺少后排典型日时，小于实际典型日数量
+                        typical_month_m[key_re[0]].append([])
+                        if key_re[0]  == '环境温度':#各类版本气象数据均有环境温度数据，其典型日数量为实际数量
+                            typical_month_m['持续天数'].append(int(re.findall('\d+',val_data_traces[i]['name'])[1]))
+                    # 当前排典型日缺少数据时，该类型数据为空list[]；当后排典型日缺少数据时，该类型数据为空
+                    for i in range(len(val_data_traces)):
+                        typical_month_m[key_re[0]][int(re.findall('\d+',val_data_traces[i]['name'])[0])-1] = copy.deepcopy(val_data_traces[i]['y'])            
+            
             # 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])
+                typical_month_m = self.result['TypicalMonth'][m]
+                typical_month_m_day = len(typical_month_m['持续天数'])
+                for i in range(typical_month_m_day):
+                    self.result['TypicalDay'].append({'info':{'typicalDayID': int, 'name': str, 'duration': int, **{key: 0.0 for key in self.__map_load}},
+                    'data': {**{key: [] for key in self.__type_list}}})
+                    typical_day_index = self.result['TypicalDay'][self.__typicalIndex]
+                    typical_day_index['info']['typicalDayID'] = self.__typicalIndex
+                    typical_day_index['info']['name'] = str(m+1) + '月典型日' + str(i+1)
+                    typical_day_index['info']['duration'] = typical_month_m['持续天数'][i]
+                    for key,value in self.__map_load.items():
+                        # 分别处理该典型日无此类型负荷数据，缺少后序典型日，缺少前序典型日的情况
+                        if typical_month_m.get(value) and i <len(typical_month_m[value]) and len(typical_month_m[value][i]):
+                            typical_day_index['info'][key] = max(typical_month_m[value][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]
+                        # 某月冷热负荷可能缺少后续典型日数据
+                        if typical_month_m[type_i] and i < len(typical_month_m[type_i]):
+                            typical_day_index['data'][type_i] = typical_month_m[type_i][i]
                     self.__typicalIndex += 1
+            self.__plotIndex = length
             
     def GetTypical(self):
         '''
@@ -71,7 +68,7 @@ class IESLabTypicalDayResult(Result):
 
     def GetTypicalDayNum(self):
         '''
-            获取当前result的典型日数量
+            获取当前result的典型日总数
             
             :return: int类型，代表典型日数量
         '''
@@ -82,25 +79,33 @@ class IESLabTypicalDayResult(Result):
         '''
             获取dayID对应典型日的基础信息
             
-            :params: dayID int类型，表示典型日的ID，数值位于 0~典型日数量 之间
+            :params: dayID int类型，表示典型日的ID，数值位于 [0，典型日总数-1] 中
             
             :return: dict类型，代表典型日的基础信息，包括典型日所代表的日期范围、典型日的名称等
         '''
         self.__readPlotResult()
-        return self.result['TypicalDay'][dayID].get('info','没有该数据')
+        try:
+            return self.result['TypicalDay'][dayID]['info']
+        except:
+            raise Exception('未查询到该数据')
         
 
     def GetTypicalDayCurve(self,dayID, dataType):
         '''
             获取dayID对应典型日下dataType参数的时序曲线
             
-            :params: dayID int类型，表示典型日的ID，数值位于 0~典型日数量 之间
-            :params: dataType enum类型，标识总辐射、环境温度、土壤温度、建筑物高度风速、风机高度风速、电负荷、热负荷、冷负荷的参数类型
+            :params: dayID int类型，表示典型日的ID，数值位于 [0，典型日总数-1] 中
+            :params: dataType enum类型，标识典型场景的数据类型
+            有总辐射、直射辐照、散射辐照、环境温度、湿球温度、土壤温度、10m风速、50m风速、电负荷、热负荷、冷负荷和氢负荷等类型，以该典型场景实际包含的类型为准
             
             :return: list<float>类型，代表以1h为时间间隔的该参数的日内时序曲线
         '''
         self.__readPlotResult()
-        return self.result['TypicalDay'][dayID]['data'].get(dataType,'没有该类型数据')
+        try:
+            return self.result['TypicalDay'][dayID]['data'][dataType]
+        except:
+            raise Exception('未查询到该数据')
+        
         
         
     def GetTypicalMonth(self):
@@ -114,11 +119,11 @@ class IESLabTypicalDayResult(Result):
         self.__readPlotResult()
         return self.result['TypicalMonth']
     
-    def GetTypicalMonthNum(self,monthID):
+    def GetTypicalMonthID(self,monthID):
         '''
             获取第monthID月各类型的典型日数据
 
-            >>> result.GetTypicalMonthNum()
+            >>> result.GetTypicalMonthID()
             
             :params: monthID int类型，表示典型月的ID，数值位于 1-12 之间
 
@@ -126,17 +131,24 @@ class IESLabTypicalDayResult(Result):
             {...}
         '''
         self.__readPlotResult()
-        return self.result['TypicalMonth'][monthID-1]
+        try:
+            return self.result['TypicalMonth'][monthID-1]
+        except:
+            raise Exception('未查询到该数据')
         
     
     def GetTypicalMonthCurve(self,monthID, dataType):
         '''
-            获取dayID对应典型日下dataType参数的时序曲线
+            获取monthID对应典型日下dataType参数的时序曲线
             
             :params: monthID int类型，表示典型月的ID，数值位于 1-12 之间
-            :params: dataType enum类型，标识总辐射、环境温度、土壤温度、建筑物高度风速、风机高度风速、电负荷、热负荷、冷负荷的参数类型
+            :params: dataType enum类型，标识典型场景的数据类型
+            有总辐射、直射辐照、散射辐照、环境温度、湿球温度、土壤温度、10m风速、50m风速、电负荷、热负荷、冷负荷和氢负荷等类型，以该典型场景实际包含的类型为准
             
             :return: list<list>类型，代表以1h为时间间隔的该参数的典型日内时序曲线
         '''
         self.__readPlotResult()
-        return self.result['TypicalMonth'][monthID-1].get(dataType,'没有该类型数据')
+        try:
+            return self.result['TypicalMonth'][monthID-1][dataType]
+        except:
+            raise Exception('未查询到该数据')        

cloudpss/runner/MessageStreamReceiver.py

@@ -19,7 +19,7 @@ class Message(object):
 class MessageStreamReceiver(object):
     """消息流读取函数结果"""
 
-    def __init__(self, id, db):
+    def __init__(self, id, db, **kwargs):
         self.origin = os.environ.get('CLOUDPSS_API_URL',
                                      'https://cloudpss.net/')
         self.id = id
@@ -28,102 +28,6 @@ class MessageStreamReceiver(object):
         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):
         """
         读取消息流中的数据
@@ -142,13 +46,13 @@ class MessageStreamReceiver(object):
         path = head + '://' + str(u[1]) + '/api/streams/id/' + id
         if fr0m is not None:
             path = path + '&from=' + str(fr0m)
-        ws = websocket.WebSocketApp(path,
+        self.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
+        self.ws.run_forever()
+        return self.ws
 
     ###下面是兼容Receiver部分功能实现
     def on_message(self, ws, message):
@@ -182,6 +86,7 @@ class MessageStreamReceiver(object):
 
     def close(self, ws):
         ws.close()
+        self._status = 1
 
     def status(self):
         return self._status

cloudpss/runner/result.py

@@ -84,8 +84,13 @@ class Result(object):
     def __deepModify(self, dict1, dict2):
 
         for key, val in dict1.items():
+            
+                
             if type(val) is dict:
-                self.__deepModify(val, dict2[key])
+                if type(dict2) is dict and dict2.get(key, None) is None:
+                    dict2[key] = val
+                else:
+                    self.__deepModify(val, dict2[key])
             else:
                 dict2[key] = val
 

cloudpss/runner/runner.py

@@ -10,13 +10,12 @@ from cloudpss.utils.graphqlUtil import graphql_request
 from .receiver import Receiver
 from .MessageStreamReceiver import MessageStreamReceiver
 from .result import IESLabSimulationResult, PowerFlowResult, EMTResult, Result, IESResult
-from .IESLabPlanResult import IESLabPlanResult
-from .IESLabEvaluationResult import IESLabEvaluationResult
+from .IESLabPlanResult import IESLabPlanResult, IESLabOptResult
+from .IESLabEvaluationResult import IESLabEvaluationResult, IESLabPlanEvaluationResult, IESLabOptEvaluationResult
 from .IESLabTypicalDayResult import IESLabTypicalDayResult
 from .storage import Storage
 from ..utils import request
 from typing import  TypeVar,  Generic
-from .DSLabResult import DSLabResult
 import re
 
 RECEIVER = {
@@ -28,13 +27,16 @@ T = TypeVar('T', Result, EMTResult, PowerFlowResult, IESResult,
 
 IES_LAB_RESULT = {
     'function/ieslab/plan': IESLabPlanResult,
-    'function/ieslab/evaluation': IESLabEvaluationResult
+    'function/ieslab/evaluation': IESLabPlanEvaluationResult,
 }
 
-DS_LAB_RESULT = {
-    'function/ieslab/evaluation': DSLabResult
+IES_LAB_OPT_RESULT = {
+    'function/ieslab/plan': IESLabOptResult,
+    'function/ieslab/evaluation': IESLabOptEvaluationResult,
 }
 
+
+
 RESULT_DB = {
     'function/CloudPSS/emtp': EMTResult,
     'function/CloudPSS/emtps': EMTResult,
@@ -48,19 +50,23 @@ RESULT_DB = {
     'function/ies/ies-gmm':IESLabTypicalDayResult,
     'function/CloudPSS/ieslab-simulation': IESLabSimulationResult,
     'function/CloudPSS/ieslab-gmm':IESLabTypicalDayResult,
+    'function/CloudPSS/ieslab-gmm-opt':IESLabTypicalDayResult,
     'function/CloudPSS/ieslab-optimization': IESResult,
 }
 
 @deprecated(version='4.0', reason="该类将在 6.0 版本移除，请使用 Job 类代替")
 class Runner(Generic[T]):
-
     def __init__(self, id,taskId, name, job, config, revision, modelRid, policy,
                  **kwargs):
         self.id = id
         self.taskId = taskId
         self.db = Storage(taskId, name, job, config, revision, modelRid)
         rid =job['rid'].replace('job-definition/','function/').replace('/cloudpss/','/CloudPSS/')
-        result = RESULT_DB.get(rid, Result)
+        resultClass = kwargs.get('RESULT_DB', None)
+        if resultClass is not None:
+            result = resultClass
+        else:
+            result = RESULT_DB.get(rid, Result)
         self.result: T = result(self.db)
         self.receiver = kwargs.get('receiver', None)
 
@@ -81,21 +87,29 @@ class Runner(Generic[T]):
         """
         if self.receiver is None:
             raise Exception('not find receiver')
+        time.sleep(0)
         return self.receiver.status()
 
     def __listen(self, **kwargs):
-
         receiver = kwargs.get('RECEIVER', 'default')
-        receiverclass = None
         if type(receiver) is str:
             if receiver not in RECEIVER:
-                receiverclass = RECEIVER['default']
+                receiver = RECEIVER['default']
             else:
-                receiverclass = RECEIVER[receiver]
-        if receiverclass is None:
+                receiver = RECEIVER[receiver]
+        if receiver is None:
             raise Exception('not find receiver')
-        self.receiver = receiverclass(self.taskId, self.db, **kwargs)
+        self.receiver = receiver(self.taskId, self.db, **kwargs)
         self.receiver.connect()
+    def statusCode(self):
+        query="mutation($_a:JobInput!){job(input:$_a){status}}"
+        variables= {
+            "_a": {
+                "id": self.jobId,
+            }
+        }
+
+        return graphql_request(query,variables=variables)
 
     def terminate(self):
         """
@@ -103,7 +117,6 @@ class Runner(Generic[T]):
 
         """
         self.abort(0)
-    
     def abort(self,timeout=3):
         """
         结束当前运行的算例
@@ -125,6 +138,57 @@ class Runner(Generic[T]):
         graphql_request(query, variables)
 
 
+    @staticmethod
+    def __createJobVariables(job, config, revisionHash, rid, policy, **kwargs):
+        # 处理policy字段
+        if policy is None:
+            policy = {}
+            if policy.get("tres", None) is None:
+                policy["tres"] = {}
+            policy["queue"] = job["args"].get("@queue", 1)
+            policy["priority"] = job["args"].get("@priority", 0)
+            tres = {"cpu": 1, "ecpu": 0, "mem": 0}
+            tresStr = job["args"].get("@tres", "")
+            for t in re.split("\s+", tresStr):
+                if t == "":
+                    continue
+                k, v = t.split("=")
+                tres[k] = float(v)  # type: ignore
+            policy["tres"] = tres
+        function = job["rid"].replace("job-definition/cloudpss/", "function/CloudPSS/")
+        implement = kwargs.get("implement", kwargs.get("topology", None))
+        debug = job["args"].get("@debug", None )
+        debugargs={}
+        if debug is not None:
+            t= [ i.split('=') for i in re.split(r'\s+',debug) if i.find('=')>0]
+            for i in t:
+                debugargs[i[0]]=i[1]
+    
+        context= [
+            function,
+            
+            f"model/@sdk/{str(int(time.time() * random.random()))}",
+        ]
+        if rid != '':
+            context.append(rid)
+        
+        PARENT_JOB_ID =kwargs.get("PARENT_JOB_ID",None)
+        if PARENT_JOB_ID is not None:
+            context.append(f"job/parent/{PARENT_JOB_ID}")
+        variables = {
+            "input": {
+                "args": {
+                    **job["args"],
+                    "_ModelRevision": revisionHash,
+                    "_ModelArgs": config["args"],
+                    "implement":implement
+                },
+                "context": context,
+                "policy": policy,
+                "debug":debugargs
+            }
+        }
+        return variables
     @staticmethod
     def create(revisionHash,
                job,
@@ -147,41 +211,9 @@ class Runner(Generic[T]):
             >>> runner = Runner.runRevision(revision,job,config,'')
         '''
 
-        #处理policy字段
-        if policy is None:
-            policy = {}
-            if policy.get('tres', None) is None:
-                policy['tres'] = {}
-            policy['queue'] = job['args'].get('@queue', 1)
-            policy['priority'] = job['args'].get('@priority', 0)
-            tres = {'cpu': 1, 'ecpu': 0, 'mem': 0}
-            tresStr = job['args'].get('@tres', '')
-            for t in re.split('\s+', tresStr):
-                if t == '':
-                    continue
-                k, v = t.split('=')
-                tres[k] = float(v)  #type: ignore
-            policy['tres'] = tres
 
         query = '''mutation($input:CreateJobInput!){job:createJob(input:$input){id input output status position}}'''
-        function = job['rid'].replace('job-definition/cloudpss/',
-                                      'function/CloudPSS/')
-        variables = {
-            'input': {
-                "args":
-                {
-                    **job['args'],
-                    '_ModelRevision' : revisionHash,
-                    '_ModelArgs' : config['args']
-                },
-                "context": [
-                    function,
-                    f"model/@sdk/{str(int(time.time() * random.random()))}"
-                ],
-                "policy":
-                policy,
-            }
-        }
+        variables = Runner.__createJobVariables(job, config, revisionHash, rid,policy, **kwargs)
         r = graphql_request(query, variables)
         if 'errors' in r:
             raise Exception(r['errors'])
@@ -224,13 +256,25 @@ class HttpRunner(Runner[T]):
             return False
         return self.result.status()  # type: ignore
     
-class DSLabRunner(Runner[T]):
+
+class HttpOPTRunner(Runner[T]):
+
     def __init__(self, job, simulationId, **kwargs):
         self.simulationId = simulationId
         self.job = job
-        result = DS_LAB_RESULT.get(job.get('rid', ''), DSLabResult)
-        self.result: T = result(self.simulationId, **kwargs)
+        self.__taskId = self.__getLastTask()
+        result = IES_LAB_OPT_RESULT.get(job.get('rid', ''), IESLabOptResult)
+        self.result: T = result(self.simulationId, self.__taskId,
+                                **kwargs)  # type: ignore
 
-    def status(self):
-        return self.result.status()
+    def __getLastTask(self):
+        r = request('GET',
+                    'api/ieslab-opt/taskmanager/getSimuLastTasks',
+                    params={'simuid': self.simulationId})
+        result = json.loads(r.text)
+        return result['data'].get('task_id', None)
 
+    def status(self):
+        if self.__taskId is None:
+            return False
+        return self.result.status()  # type: ignore

cloudpss/utils/IO.py

@@ -2,6 +2,7 @@ import io
 import json
 import ubjson
 import yaml
+from yaml.dumper import SafeDumper
 import gzip
 import base64
 import struct
@@ -85,6 +86,7 @@ class IO(object):
             result = ubjson.dumpb(obj)
         if format == 'yaml':
             result = yaml.dump(obj).encode(encoding="utf-8")
+
         if result is None:
             assert False, 'format not support'
         if compress == 'gzip':
@@ -104,7 +106,7 @@ class IO(object):
         if format == 'ubjson':
             return ubjson.loadb(byt)
         if format == 'yaml':
-            return yaml.load(io.BytesIO(byt), yaml.FullLoader)
+            return yaml.load(io.BytesIO(byt), Loader=yaml.FullLoader)
         assert False, 'format not support'
 
     @staticmethod

cloudpss/utils/graphqlUtil.py

@@ -3,8 +3,9 @@ import json
 from cloudpss.utils import request
 
 
-def graphql_request(query, variables=None):
+def graphql_request(query, variables=None, **kwargs):
     payload = {'query': query, 'variables': variables}
-    r = request('POST', 'graphql', data=json.dumps(payload))
+    
+    r = request('POST', 'graphql', data=json.dumps(payload), **kwargs)
 
     return json.loads(r.text)