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

cloudpss/ieslab/PlanModel.py

@@ -1,12 +1,15 @@
-from cloudpss.runner.IESLabPlanResult import IESLabPlanResult
-from cloudpss.runner.runner import HttpRunner, Runner
+from cloudpss.runner.IESLabPlanResult import IESLabPlanResult, IESLabOptResult
+from cloudpss.runner.runner import HttpRunner, HttpOPTRunner
+from cloudpss.model import Model
+from cloudpss.model.revision import ModelRevision
 from ..utils import request, fileLoad
 import json
 from enum import IntEnum, unique
 
 
 class IESLabPlanModel(object):
-    _baseUri = 'api/ieslab-plan/taskmanager/getSimuLastTasks'
+    _baseUri = 'api/ieslab-plan/rest'
+    _runUri = 'api/ieslab-plan/taskmanager'
 
     def __init__(self, simulationId):
         '''
@@ -14,18 +17,18 @@ class IESLabPlanModel(object):
         '''
         self.simulationId = simulationId
         self.optimizationInfo = self.GetOptimizationInfo()
-        self.OptimizationMode = OptimizationMode
 
-    def _fetchItemData(self, url):
+    def _fetchItemData(self, url, params):
         '''
             获取当前算例的优化目标设置信息
 
-            :return: enum 类型，代表经济性优化和环保性优化的类型
+            :return: List 类型，包括优化目标和全局参数储能动作灵敏度，若没有设置则返回 []
         '''
-        r = request('GET', url, params={"simuid": self.simulationId})
+        r = request('GET', url, params=params)
         data = json.loads(r.text)
-        return data
+        return data['results']
 
+  
     def GetOptimizationInfo(self):
         '''
             获取当前算例的优化目标设置信息
@@ -50,8 +53,8 @@ class IESLabPlanModel(object):
         '''
         self.optimizationInfo = optType
         return True
-
-    def run(self) -> Runner[IESLabPlanResult]:
+    
+    def run(self) -> HttpRunner[IESLabPlanResult]:
         '''
             生成方案优选算例
 
@@ -61,10 +64,9 @@ class IESLabPlanModel(object):
         if isRunning:
             raise Exception('该算例正在运行！请从浏览器算例页面点击结束运行或者调用IESPlan对象的kill接口终止计算后重试！')
         else:
-            url = 'api/ieslab-plan/taskmanager/runOptimization'
-            if self.optimizationInfo is None:
-                self.optimizationInfo = OptimizationMode['经济性']
-            optType = self.optimizationInfo.value or 0
+            url = f'{self._runUri}/runOptimization'
+            optType = self.optimizationInfo if self.optimizationInfo is not None else OptimizationMode.经济性
+            optTypeValue = optType.value if isinstance(optType, OptimizationMode) else 0
             try:
                 r = request('GET',
                             url,
@@ -73,7 +75,7 @@ class IESLabPlanModel(object):
                                 self.simulationId,
                                 "optPara":
                                 json.dumps({
-                                    "OptimizationMode": optType,
+                                    "OptimizationMode": optTypeValue,
                                     "ProjectPeriod": "20"
                                 })
                             })
@@ -82,7 +84,7 @@ class IESLabPlanModel(object):
             except:
                 raise Exception('生成方案优选算例失败')
 
-    def GetRunner(self) -> Runner[IESLabPlanResult]:
+    def GetRunner(self) -> HttpRunner[IESLabPlanResult]:
         '''
             获得运行实例
 
@@ -100,7 +102,7 @@ class IESLabPlanModel(object):
             data = res.get('data', {})
             if data is not None:
                 taskID = data.get('task_id', '')
-        url = f'api/ieslab-plan/taskmanager/removeOptimizationTask'
+        url = f'{self._runUri}/removeOptimizationTask'
         try:
             r = request('GET',
                         url,
@@ -128,7 +130,208 @@ class IESLabPlanModel(object):
                 status = data.get('status', '')
                 if status == 'stop':
                     isRunning = False
-        logs = IESLabPlanResult(self.simulationId).GetLogs()
+        try:
+            
+            logs = IESLabPlanResult(self.simulationId).GetLogs()
+            if logs is not None:
+                for log in logs:
+                    if(log.get('data', '') == 'run ends'):
+                        isRunning = False
+                        break
+        except:
+            return False
+        return isRunning
+
+
+  
+class IESLabOptModel(object):
+    _baseUri = 'api/ieslab-opt/rest'
+    _runUri = 'api/ieslab-opt/taskmanager'
+
+
+    def __init__(self, simulationId, rid):
+        '''
+            初始化
+        '''
+        self.simulationId = simulationId
+        self.rid = rid
+        self.optimizationInfo = self.GetOptimizationInfo()
+
+    def _fetchItemData(self, url, params):
+        '''
+            获取当前算例的优化目标设置信息
+
+            :return: List 类型，包括优化目标和全局参数储能动作灵敏度，若没有设置则返回 []
+        '''
+        r = request('GET', url, params=params)
+        data = json.loads(r.text)
+        return data['results']
+
+    def GetOptimizationInfo(self):
+        '''
+            获取当前算例的优化目标设置信息
+
+            :return: Dict 类型，例如：{'OptGoal': <OptimizationMode.经济性: 0>, 'StoSen': "10", '@debug': '', 'clustering_algorithm': '0', 'num_method': '0', 'PowUnPrice': '1000', 'HeatAbandonPrice': '1000'}
+        '''
+        try:
+            url = f'{self._baseUri}/simuOpt/'
+            params = {"simu_id": self.simulationId}
+            r = self._fetchItemData(url, params)
+            if (len(r) == 0): 
+                return {
+                    "OptGoal": OptimizationMode['经济性'],
+                    "StoSen": "10",
+                    "@debug": "",
+                    "clustering_algorithm": "0",
+                    "num_method": "0",
+                    "PowUnPrice": "1000",
+                    "HeatAbandonPrice": "1000"
+                }
+            else:
+                value = json.loads(r[0]['opt_params'])
+                return {
+                    "OptGoal": OptimizationMode(int(value['OptGoal'])),
+                    "StoSen": value['StoSen'],
+                    "@debug": value["@debug"],
+                    "clustering_algorithm": value["clustering_algorithm"],
+                    "num_method": value["num_method"],
+                    "PowUnPrice": value["PowUnPrice"],
+                    "HeatAbandonPrice": value["HeatAbandonPrice"]
+                }
+        except:
+            raise Exception('获得优化目标设置失败')
+
+    def SetOptimizationInfo(self, data: dict):
+        '''
+            设置当前算例的优化目标
+
+            :param data: dict 类型，例如：{'OptGoal': <OptimizationMode.经济性: 0>, 'StoSen': "10", '@debug': '', 'clustering_algorithm': '0', 'num_method': '0', 'PowUnPrice': '1000', 'HeatAbandonPrice': '1000'}
+
+            :return: boolean 类型，为 True 则设置成功
+        '''
+        try:
+            url = f'{self._baseUri}/simuOpt/'
+            params = {"simu_id": self.simulationId}
+            r = self._fetchItemData(url, params)
+            opt_params = {
+                "OptGoal": data.get('OptGoal', ''),
+                "StoSen": data.get('StoSen', ''),
+                "@debug": data.get('@debug', ''),
+                "clustering_algorithm": data.get('clustering_algorithm', ''),
+                "num_method": data.get('num_method', ''),
+                "PowUnPrice": data.get('PowUnPrice', ''),
+                "HeatAbandonPrice": data.get('HeatAbandonPrice', '')
+            }
+            if(len(r) == 0):
+                payload = {
+                    "simu_id": self.simulationId,
+                    "opt_params": json.dumps(opt_params)
+                }
+                r = request('POST',
+                            url,
+                            data=json.dumps(payload))
+                return True
+            else:
+                url2 = f'{self._baseUri}/simuOpt/{r[0]["id"]}/'
+                payload = {
+                    "simu_id": self.simulationId,
+                    "opt_params": json.dumps(opt_params),
+                    "id": r[0]["id"]
+                }
+                r = request('PUT',
+                            url2,
+                            data=json.dumps(payload))
+                return True
+        except:
+            return False
+    
+    def run(self) -> HttpOPTRunner[IESLabOptResult]:
+        '''
+            生成方案优选算例
+
+            :return: Runner[IESLabOptResult]
+        '''
+        isRunning = self.GetLastTaskResult()
+        if isRunning:
+            raise Exception('该算例正在运行！请从浏览器算例页面点击结束运行或者调用IESPlan对象的kill接口终止计算后重试！')
+        else:
+            # 通过 rid 获取 model
+            model = Model.fetch(self.rid)
+            # 通过 model 获取 revision
+            revision = ModelRevision.create(model.revision, model.revision.hash)
+            hash = revision.get('hash', '')
+            url = f'{self._runUri}/runOptimization'
+            opt = {
+                "OptGoal": self.optimizationInfo.get('OptGoal', 0).value,
+                "StoSen": self.optimizationInfo.get('StoSen', 10),
+                "@debug": self.optimizationInfo.get('@debug', ''),
+                "clustering_algorithm": self.optimizationInfo.get('clustering_algorithm', '0'),
+                "num_method": self.optimizationInfo.get('num_method', '0'),
+                "PowUnPrice": self.optimizationInfo.get('PowUnPrice', '1000'),
+                "HeatAbandonPrice": self.optimizationInfo.get('HeatAbandonPrice', '1000'),
+            }
+            try:
+                r = request('GET',
+                            url,
+                            params={
+                                "simuid":
+                                self.simulationId,
+                                "optPara":
+                                json.dumps(opt),
+                                "revision": hash
+                            })
+                data = json.loads(r.text)
+                return HttpOPTRunner({}, self.simulationId)
+            except:
+                raise Exception('生成方案优选算例失败')
+
+    def GetRunner(self) -> HttpOPTRunner[IESLabOptResult]:
+        '''
+            获得运行实例
+
+            :return: Runner[IESLabOptResult]
+        '''
+        return HttpOPTRunner({}, self.simulationId)
+    
+    def kill(self) -> bool:
+        '''
+            停止并删除当前运行的优化算例
+        '''
+        res = IESLabOptResult(self.simulationId).getLastTaskResult()
+        error = res.get('error', 0)
+        if error == 0:
+            data = res.get('data', {})
+            if data is not None:
+                taskID = data.get('task_id', '')
+        url = f'{self._runUri}/removeOptimizationTask'
+        try:
+            r = request('GET',
+                        url,
+                        params={
+                            "taskid": taskID,
+                            "stopFlag": '2'
+                        })
+            json.loads(r.text)
+            return True
+        except:
+            return False
+
+    def GetLastTaskResult(self)-> bool:
+        '''
+            获取最后一次运行的taskID的运行结果与日志
+
+            :return: boolean 类型
+        '''
+        isRunning = True
+        res = IESLabOptResult(self.simulationId).getLastTaskResult()
+        error = res.get('error', 0)
+        if error == 0:
+            data = res.get('data', {})
+            if data is not None:
+                status = data.get('status', '')
+                if status == 'stop':
+                    isRunning = False
+        logs = IESLabOptResult(self.simulationId).GetLogs()
         if logs is not None:
             for log in logs:
                 if(log.get('data', '') == 'run ends'):
@@ -137,6 +340,7 @@ class IESLabPlanModel(object):
         return isRunning
 
 
+
 # @unique
 class OptimizationMode(IntEnum):
     经济性 = 0

cloudpss/ieslab/__init__.py

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

cloudpss/job/TemplateCompiler.py

@@ -0,0 +1,273 @@
+import json
+from collections import namedtuple
+from typing import Any, Dict, List, Union
+
+PARSER_STATUS_TEXT = 0
+PARSER_STATUS_EXPRESSION_SIMPLE = 1
+PARSER_STATUS_EXPRESSION_COMPLEX = 2
+
+def is_identifier_char(char):
+    char_code = ord(char)
+    return ((char_code >= 97 and char_code <= 122) or
+            (char_code >= 65 and char_code <= 90) or
+            (char_code >= 48 and char_code <= 57) or
+            char_code == 95)
+
+INTERPOLATION_CHAR = '$'
+INTERPOLATION_EXPRESSION_START = '{'
+INTERPOLATION_EXPRESSION_END = '}'
+
+def parse_interpolation_impl(template, start, length):
+    templates = []
+    values = []
+    current_template = ''
+    current_value = ''
+    expression_complex_depth = 0
+    status = PARSER_STATUS_TEXT
+    end = start + length - 1
+    
+    i = start
+    while i <= end:
+        if status == PARSER_STATUS_TEXT:
+            next_interpolation_char = template.find(INTERPOLATION_CHAR, i)
+            if next_interpolation_char < 0 or next_interpolation_char >= end:
+                current_template += template[i:end + 1]
+                break
+            current_template += template[i:next_interpolation_char]
+            next_char = template[next_interpolation_char + 1]
+            i = next_interpolation_char
+            if next_char == INTERPOLATION_CHAR:
+                current_template += INTERPOLATION_CHAR
+                i += 1
+                continue
+            if next_char == INTERPOLATION_EXPRESSION_START:
+                templates.append(current_template)
+                current_template = ''
+                status = PARSER_STATUS_EXPRESSION_COMPLEX
+                expression_complex_depth = 1
+                i += 1
+                continue
+            if is_identifier_char(next_char):
+                templates.append(current_template)
+                current_template = ''
+                current_value = next_char
+                status = PARSER_STATUS_EXPRESSION_SIMPLE
+                i += 1
+                continue
+            current_template += INTERPOLATION_CHAR
+            continue
+        
+        char = template[i]
+        if status == PARSER_STATUS_EXPRESSION_SIMPLE:
+            if is_identifier_char(char):
+                current_value += char
+                i += 1
+                continue
+            values.append(current_value)
+            current_value = ''
+            status = PARSER_STATUS_TEXT
+            continue
+        
+        if status == PARSER_STATUS_EXPRESSION_COMPLEX:
+            if char == INTERPOLATION_EXPRESSION_START:
+                expression_complex_depth += 1
+            elif char == INTERPOLATION_EXPRESSION_END:
+                expression_complex_depth -= 1
+                if expression_complex_depth == 0:
+                    values.append(current_value.strip())
+                    current_value = ''
+                    status = PARSER_STATUS_TEXT
+                    i += 1
+                    continue
+            current_value += char
+            i += 1
+            continue
+    
+    if status == PARSER_STATUS_TEXT:
+        templates.append(current_template)
+    elif status == PARSER_STATUS_EXPRESSION_SIMPLE:
+        values.append(current_value)
+        templates.append('')
+    else:
+        raise ValueError('Unexpected end of input')
+    
+    return {
+        'type': 'interpolation',
+        'templates': templates,
+        'values': values,
+    }
+    
+# 是否为 ArrayBuffer
+def is_array_buffer(value: Any) -> bool:
+    return isinstance(value, (memoryview, bytearray))
+
+# 是否为 Error
+def is_error(value: Any) -> bool:
+    return isinstance(value, Exception)
+
+
+def parse_template(template: str) -> Any:
+    if not template:
+        return ''
+    if template.startswith('='):
+        return {
+            'type': 'formula',
+            'value': template[1:].strip(),
+        }
+    if template.startswith('$'):
+        result = parse_interpolation_impl(template, 1, len(template)-1)
+        if len(result['templates']) == 0:
+            return result['templates'][0]
+        return result        
+    return template
+# KNOWN_ERRORS = [EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError]
+
+# 模板序列号
+seq = 0
+
+# 创建模板
+class TemplateCompiler:
+    def __init__(self, template: Any, options: Dict[str, Any]):
+        self.template = template
+        self.options = options
+        self.params = {}
+        self.copyable = []
+
+    # 构建求值
+    def build_eval(self, expression: str, type_: str) -> str:
+        evaluator = self.options['evaluator']
+        if 'evaluator' not in self.params:
+            self.params['evaluator'] = evaluator.get('inject',None)
+        return evaluator['compile'](expression, type_)
+
+    # 构建字符串
+    def build_string(self, str_: str) -> Union[str, bool]:
+        parsed = parse_template(str_)
+        if isinstance(parsed, str):
+            return json.dumps(parsed), False
+        if parsed['type'] == 'formula':
+            return self.build_eval(parsed['value'], parsed['type']), True
+        result = ''
+        for i in range(len(parsed['templates'])):
+            if parsed['templates'][i]:
+                result += (result and '+' or '') + json.dumps(parsed['templates'][i])
+            if i < len(parsed['values']):
+                if not result:
+                    result = '""'
+                result += '+' + self.build_eval(parsed['values'][i], parsed['type'])
+        return result, True
+
+    # 构建 Error
+    def build_error(self, err: Exception) -> str:
+        constructor="Error"
+        if err.__class__.__name__ == constructor:
+            return f'new {constructor}({self.build_string(err.message)[0]})'
+        return f'Object.assign(new {constructor}({self.build_string(err.message)[0]}), {{name: {self.build_string(err.name)[0]}}})'
+
+    # 构建数组
+    def build_array(self, arr: List[Any]) -> str:
+        return f'[{", ".join(self.build_value(v) for v in arr)}]'
+
+    # 构建 ArrayBuffer
+    def build_array_buffer(self, buffer: Union[memoryview, bytearray]) -> str:
+        self.copyable.append(buffer[:])
+        return f'copyable[{len(self.copyable) - 1}][:]'
+
+    # 构建 ArrayBufferView
+    def build_array_buffer_view(self, view: memoryview) -> str:
+        self.copyable.append(view.tobytes())
+        return f'new {view.__class__.__name__}(copyable[{len(self.copyable) - 1}][:])'
+
+    # 构建对象
+    def build_object(self, obj: Dict[str, Any]) -> str:
+        result = ''
+        for key, value in obj.items():
+            if result:
+                result += ',\n'
+            if self.options['objectKeyMode'] == 'ignore':
+                result += json.dumps(key)
+            else:
+                e, is_expression = self.build_string(key)
+                if is_expression:
+                    result += f'[{e}]'
+                else:
+                    result += e
+            result += ':'
+            result += self.build_value(value)
+        return '{' + result + '}'
+
+    # 构建值
+    def build_value(self, value: Any) -> str:
+        if value is None:
+            return 'null'
+        if value is True:
+            return 'true'
+        if value is False:
+            return 'false'
+        if isinstance(value, (int, float)):
+            return str(value)
+        if isinstance(value, str):
+            return self.build_string(value)[0]
+        if isinstance(value, Exception):
+            return self.build_error(value)
+        if isinstance(value, list):
+            return self.build_array(value)
+        if is_array_buffer(value):
+            return self.build_array_buffer(value)
+        if isinstance(value, memoryview):
+            return self.build_array_buffer_view(value)
+        if isinstance(value, dict):
+            return self.build_object(value)
+        raise ValueError(f'Unsupported value: {type(value)}')
+
+    # 构建模板
+    def build(self) -> Any:
+        global seq
+        source = self.build_value(self.template)
+        if self.copyable:
+            self.params['copyable'] = self.copyable
+        params = list(self.params.items())
+        try:
+            result = eval(f'lambda context: ({source})')
+            result.source = source
+            return result
+        except Exception as e:
+            raise ValueError(f'Failed to compile template: {source}\n{str(e)}')
+
+
+
+def template(templates,options={}):
+    def compile_template(expression, type):
+        if type == 'formula':
+            return f'context[{json.dumps(expression)}]'
+        elif type == 'interpolation':
+            return f"context[{json.dumps(expression)}] ?? ''"
+        raise ValueError(f'Unsupported type: {type}')
+    opt = {
+        'objectKeyMode': 'template',
+        'evaluator':{
+            'compile':compile_template
+        },
+        **options
+    }
+    return TemplateCompiler(templates, opt).build()
+
+
+
+if __name__ == "__main__":
+    
+    message =[1, 1, {'component_load_5_无功功率': [0], 'component_load_5_有功功率': [0], 'time': ['placeholder']}, {'data': {'title': '负荷5功率(kW)', 'traces': [{'name': '有功功率', 'type': 'scatter', 'x': '=time', 'y': '=component_load_5_有功功率'}, {'name': '无功功率', 'type': 'scatter', 'x': '=time', 'y': '=component_load_5_无功功率'}], 'xAxis': {'title': 'time'}, 'yAxis': {'title': '功率(kW)'}}, 'key': '/component_load_5_功率(kW)', 'type': 'plot', 'verb': 'append', 'version': 1}]
+    id =message[0]
+    
+    templates=message[3:]
+    
+    x= template(templates)
+    
+    values=[1, 1, {'component_load_5_无功功率': [5.44544554016478], 'component_load_5_有功功率': [16.3363363363363], 'time': ['2021-08-19 09:00:00']}]
+    
+    print(x)
+    
+    data= values[2]
+    s=x(data)
+    
+    print(s)

cloudpss/job/TemplateManager.py

@@ -0,0 +1,37 @@
+import logging
+from cloudpss.job.TemplateCompiler import template
+class TemplateManager():
+    
+    def __init__(self) -> None:
+        self.templateMap = {}
+
+    def isCreate(self, value):
+        return type(value) == list and len(value) > 3 and type(value[0]) == int and value[1] == 1
+    
+    def create(self,  value):
+        if not self.isCreate(value):
+            print("is create")
+            return
+        id =value[0]
+    
+        templates=value[3:]
+        if self.templateMap.get(id,None) is not None:
+            logging.debug(f"template {id} is already exist")
+        
+        self.templateMap[id] = {'template':template(templates),'value':value}
+        
+        
+    
+    def isInvoke(self, value):
+        return type(value) == list and len(value) == 3 and type(value[0]) == int and value[1] == 1
+    
+    def invoke(self, value):
+        if not self.isInvoke(value):
+            return []
+        id,_version,args = value
+        
+        t = self.templateMap.get(id,None)
+        if t is None:
+            return []
+        return t['template'](args)
+