cloudpss 3.1.3__py3-none-any.whl → 3.1.3b1__py3-none-any.whl

cloudpss/ieslab/PlanModel.py

@@ -14,6 +14,7 @@ class IESLabPlanModel(object):
         '''
         self.simulationId = simulationId
         self.optimizationInfo = self.GetOptimizationInfo()
+        self.OptimizationMode = OptimizationMode
 
     def _fetchItemData(self, url):
         '''
@@ -46,9 +47,9 @@ class IESLabPlanModel(object):
             设置当前算例的优化目标
 
             :param optType: enum 类型，代表经济性优化和环保性优化的类型
-            :return: bool 类型，代表参数设置是否成功
         '''
         self.optimizationInfo = optType
+        return True
 
     def run(self) -> Runner[IESLabPlanResult]:
         '''
@@ -87,8 +88,8 @@ class IESLabPlanModel(object):
 
 
     # def GetTaskResult(self):
-    #     return IESLabPlanResult(self.simulationId)
-@unique
+#     #     return IESLabPlanResult(self.simulationId)
+# @unique
 class OptimizationMode(IntEnum):
     经济性 = 0
     环保性 = 1

cloudpss/ieslab/__init__.py

@@ -1,3 +1,4 @@
 from .IESLabSimulation import IESLabSimulation
 from .IESLabPlan import IESLabPlan
-__all__ = ['IESLabSimulation','IESLabPlan']
+from .PlanModel import OptimizationMode
+__all__ = ['IESLabSimulation','IESLabPlan', 'OptimizationMode']

cloudpss/model/jobDefinitions.py

@@ -112,5 +112,39 @@ JOB_DEFINITIONS = {
             "SkipPF": "0",
             "MaxIteration": "30"
         }
+    },
+    "iesLoadPrediction": {
+        "name": "负荷预测方案 1",
+        "rid": "job-definition/ies/ies-load-prediction",
+        "arcs": {
+            "startTime": "2022 -01-01 00:00:00",
+            "endTime": "2022 -12-31 23:00:00",
+            "layer_forcast": "0",
+            "forcast_algorithm": "0",
+            "ratio_sub": [],
+            "ratio_feeder": [],
+            "ratio_trans": []
+        }
+    },
+    "iesPowerFlow": {
+        "name": "时序潮流方案 1",
+        "rid": "job-definition/ies/ies-power-flow",
+        "arcs": {
+            "startTime": "2022 -01-01 00:00:00",
+            "endTime": "2022 -12-31 23:00:00",
+            "solveMethod": "0",
+            "maxIteration": "30"
+        }
+    },
+    "iesEnergyStoragePlan": {
+        "name": "储能规划方案 1",
+        "rid": "job-definition/ies/ies-energy-storage-plan",
+        "arcs": {
+            "Planyear": "15",
+            "NetConfig": [],
+            "SourceConfig": [],
+            "LoadConfig": []
+        }
     }
+
 }

cloudpss/model/model.py

@@ -638,4 +638,79 @@ class Model(object):
             currentConfig = self.context['currentConfig']
             config = self.configs[currentConfig]
         return self.run(job=job, config=config)
+    
+    def runIESLoadPrediction(self,job=None,config=None)->Runner[IESResult]:
+        '''
+            运行 负荷预测方案 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+            
+            :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
+            :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
+
+            :return: runner Runner[IESResult]
+        '''
+        if job is None:
+            currentJob = self.context['currentJob']
+            job = self.jobs[currentJob]
+            if job['rid'] != 'job-definition/ies/ies-load-prediction':
+                for j in self.jobs:
+                    if j['rid'] == 'job-definition/ies/ies-load-prediction':
+                        job = j
+        if job is None:
+            raise Exception("找不到负荷预测方案内核运行的计算方案")
+        if job['rid'] != 'job-definition/ies/ies-load-prediction':
+            raise Exception("不是负荷预测方案内核运行生成算法的计算方案")
+        if config is None:
+            currentConfig = self.context['currentConfig']
+            config = self.configs[currentConfig]
+        return self.run(job=job, config=config)
+    
+    def runIESPowerFlow(self,job=None,config=None)->Runner[IESResult]:
+        '''
+            运行 时序潮流方案 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+            
+            :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
+            :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
+
+            :return: runner Runner[IESResult]
+        '''
+        if job is None:
+            currentJob = self.context['currentJob']
+            job = self.jobs[currentJob]
+            if job['rid'] != 'job-definition/ies/ies-power-flow':
+                for j in self.jobs:
+                    if j['rid'] == 'job-definition/ies/ies-power-flow':
+                        job = j
+        if job is None:
+            raise Exception("找不到时序潮流方案内核运行的计算方案")
+        if job['rid'] != 'job-definition/ies/ies-power-flow':
+            raise Exception("不是时序潮流方案内核运行生成算法的计算方案")
+        if config is None:
+            currentConfig = self.context['currentConfig']
+            config = self.configs[currentConfig]
+        return self.run(job=job, config=config)
+
+    def runIESEnergyStoragePlan(self,job=None,config=None)->Runner[IESResult]:
+        '''
+            运行 储能规划方案 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+            
+            :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
+            :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
+
+            :return: runner Runner[IESResult]
+        '''
+        if job is None:
+            currentJob = self.context['currentJob']
+            job = self.jobs[currentJob]
+            if job['rid'] != 'job-definition/ies/ies-energy-storage-plan':
+                for j in self.jobs:
+                    if j['rid'] == 'job-definition/ies/ies-energy-storage-plan':
+                        job = j
+        if job is None:
+            raise Exception("找不到储能规划方案内核运行的计算方案")
+        if job['rid'] != 'job-definition/ies/ies-energy-storage-plan':
+            raise Exception("不是储能规划方案内核运行生成算法的计算方案")
+        if config is None:
+            currentConfig = self.context['currentConfig']
+            config = self.configs[currentConfig]
+        return self.run(job=job, config=config)
 

cloudpss/runner/IESLabEvaluationResult.py

@@ -52,18 +52,20 @@ class IESLabEvaluationResult(object):
 
             :return: boolean 类型
         '''
-        result = None
-        if self.cmdType is None:
-            result = self.GetOverviewResult()
-        elif self.cmdType == 'energyEvaluation':
-            result = self.GetEnergyEvaluationResult()
-        elif self.cmdType == 'environmentalEvaluation':
-            result = self.GetEnvironmentalEvaluationResult()
-        if result is None:
+        # 定义一个字典，把命令类型映射到相应的方法
+        cmd_dict = {
+            None: self.GetOverviewResult,
+            'energyEvaluation': self.GetEnergyEvaluationResult,
+            'environmentalEvaluation': self.GetEnvironmentalEvaluationResult
+        }
+        # 从字典中获取对应的方法，如果没有找到，就抛出一个异常或返回False
+        result = cmd_dict.get(self.cmdType, lambda x: None)(self.planId)
+        if result is None or type(result) is list:
             return False
         return True
 
-    def GetFinancialResult(self, resultType):
+
+    def GetFinancialResult(self, resultType, planID):
         '''
             获取planID对应的优化方案下resultType财务评估结果
 
@@ -76,16 +78,17 @@ class IESLabEvaluationResult(object):
         assert (resultType in self._kindNameMap), "数据类型不存在"
         kind = self._kindNameMap.get(resultType, resultType)
         url = self._baseUri + kind
-        list = self._fetchItemData(url, self.planId)
+        list = self._fetchItemData(url, planID)
         dict_result = dict()
         for val in list['results']:
             for k, v in val.items():
                 dict_result[k] = v
         return dict_result['data']
 
-    def GetOverviewResult(self):
+    def GetOverviewResult(self, planID):
         '''
             获取当前结果类对应的优化方案下的概览结果
+            :param planID int 类型，表示优化方案的ID，数值位于0~优化方案数量之间
 
             :return: array类型，代表该方案对应的概览结果
         '''
@@ -93,17 +96,18 @@ class IESLabEvaluationResult(object):
                     "api/ieslab-plan/taskmanager/getOverviewResult",
                     params={
                         "simu_id": self.simulationId,
-                        "planId": self.planId,
+                        "planId": planID,
                         "time": self.timeId
                     })
         result = json.loads(r.text)
-        if len(result['results']) > 0:
+        if len(result['results']) > 0 and len(result['results'][0]['data']) > 0:
             return result['results'][0]['data']
-        return None
+        return []
 
-    def GetEnergyEvaluationResult(self):
+    def GetEnergyEvaluationResult(self, planID):
         '''
             获取当前结果类对应的优化方案下的能效评价
+            :param planID int 类型，表示优化方案的ID，数值位于0~优化方案数量之间
 
             :return: array类型，代表该方案对应的能效评价结果
         '''
@@ -111,17 +115,18 @@ class IESLabEvaluationResult(object):
                     "api/ieslab-plan/taskmanager/getEnergyEvaluation",
                     params={
                         "simu_id": self.simulationId,
-                        "planId": self.planId,
+                        "planId": planID,
                         "time": self.timeId
                     })
         result = json.loads(r.text)
-        if len(result['results']) > 0:
+        if len(result['results']) > 0 and len(result['results'][0]['data']) > 0:
             return result['results'][0]['data']
-        return None
+        return []
 
-    def GetEnvironmentalEvaluationResult(self):
+    def GetEnvironmentalEvaluationResult(self, planID):
         '''
             获取当前结果类对应的优化方案下的环保评价
+            :param planID int 类型，表示优化方案的ID，数值位于0~优化方案数量之间
 
             :return: array类型，代表该方案对应的环保评价结果
         '''
@@ -129,10 +134,10 @@ class IESLabEvaluationResult(object):
                     "api/ieslab-plan/taskmanager/getEnvironmentalEvaluation",
                     params={
                         "simu_id": self.simulationId,
-                        "planId": self.planId,
+                        "planId": planID,
                         "time": self.timeId
                     })
         result = json.loads(r.text)
-        if len(result['results']) > 0:
+        if len(result['results']) > 0 and len(result['results'][0]['data']) > 0:
             return result['results'][0]['data']
-        return None
+        return []

cloudpss/runner/IESLabPlanResult.py

@@ -68,6 +68,30 @@ class IESLabPlanResult(object):
         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对应的优化方案的配置信息
@@ -91,7 +115,6 @@ class IESLabPlanResult(object):
         result = {}
         for val in d['data']:
             result[val['u_name']] = val['data']['data']
-
         return result
 
     def GetComponentResult(self, planID, componentID, typicalDayName=''):

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/result.py

@@ -335,7 +335,7 @@ class IESResult(Result):
             获取元件ID为compID的元件，对应标签为labelName、图例名称为traceName的plot 数据的第index项
 
             :params: compID string类型，代表元件的标识符
-            :params: lableName string类型，代表plot曲线的分组标签
+            :params: labelName string类型，代表plot曲线的分组标签
             :params: traceName string类型，代表Plot曲线对应分组下的图例名称，当为'all'时，返回所有图例的数据
             :params: index int类型，代表对应图例时序数据中的第index项，当小于0时，返回该图例所有的时序数据
             

cloudpss/runner/runner.py

@@ -22,6 +22,7 @@ IES_LAB_RESULT = {
     'function/ieslab/plan': IESLabPlanResult,
     'function/ieslab/evaluation': IESLabEvaluationResult
 }
+
 RESULT_DB = {
     'job-definition/cloudpss/emtp': EMTResult,
     'job-definition/cloudpss/emtps': EMTResult,
@@ -29,6 +30,8 @@ RESULT_DB = {
     'job-definition/cloudpss/power-flow': PowerFlowResult,
     'job-definition/cloudpss/ies-simulation': IESResult,
     'job-definition/cloudpss/ies-optimization': IESResult,
+    # 'job-definition/ies/ies-simulation': IESResult,
+    'job-definition/ies/ies-optimization': IESResult,
     'job-definition/cloudpss/three-phase-powerFlow': PowerFlowResult,
     'job-definition/ies/ies-simulation': IESLabSimulationResult,
     'job-definition/ies/ies-gmm':IESLabTypicalDayResult,
@@ -36,11 +39,9 @@ RESULT_DB = {
     'job-definition/cloudpss/ieslab-gmm':IESLabTypicalDayResult,
 }
 
-
 class Runner(Generic[T]):
     def __init__(self, taskId, name, job, config, revision, modelRid,
                  **kwargs):
-
         self.taskId = taskId
         self.db = Storage(taskId, name, job, config, revision, modelRid)
         result = RESULT_DB.get(job['rid'], Result)
@@ -143,4 +144,3 @@ class HttpRunner(Runner[T]):
         if self.__taskId is None:
             return False
         return self.result.status()  # type: ignore
-        pass