cloudpss 4.5.0__py3-none-any.whl → 4.5.1a1__py3-none-any.whl

cloudpss/dslab/files/files.py

@@ -0,0 +1,27 @@
+from .curveData import 基准出力曲线, 基准出力曲线2, 基准出力曲线3, 负荷曲线, 策略曲线, 运行策略曲线
+
+extra_paths = {
+    '光伏': 基准出力曲线,
+    '光伏曲线': 基准出力曲线,
+    '风机': 基准出力曲线,
+    '风机曲线': 基准出力曲线,
+    '燃气': 基准出力曲线2,
+    '燃气曲线': 基准出力曲线,
+    '水电': 基准出力曲线2,
+    '水电曲线': 基准出力曲线,
+    '火电': 基准出力曲线2,
+    '火电曲线': 基准出力曲线,
+    '生物质发电': 基准出力曲线2,
+    '生物质发电曲线': 基准出力曲线,
+    '垃圾电厂': 基准出力曲线2,
+    '垃圾电厂曲线': 基准出力曲线,
+    '负荷分类':  负荷曲线,
+    '负荷用户':  负荷曲线,
+    '储能运行策略': 运行策略曲线,
+}
+
+def getCurveData(kind):
+    if kind in extra_paths:
+        return extra_paths[kind]
+    else :
+        return []

cloudpss/dslab/financialAnalysisModel.py

@@ -0,0 +1,137 @@
+import time
+from cloudpss.runner.runner import Runner, HttpRunner, DSLabRunner
+from cloudpss.runner.DSLabResult import DSLabResult
+from ..utils import request
+import json
+
+class DSLabFinancialAnalysisModel(object):
+    _baseUri = 'api/dslab/rest/pe/'
+
+    _kindNameMap = {
+        "投资组成": "investmentbanchandproportion",
+        "资金来源": "capitalsource",
+        "资产形式": "assetformation",
+        "生产成本": "productioncost",
+        "流动资金及财务费用": "workingcapitalandfinancialexpenses",
+        "税率及附加": "projectcalculation",
+    }
+
+    # 财务评价基础参数接口默认值
+    _financialParasDefaultValues = {
+        "资产形式": {
+            "fixedAssetsRatio": "95",
+            "residualRrate": "5",
+            "depreciationPeriod": "15",
+            "reimbursementPeriod": "5"
+        },
+        "生产成本": {
+            'annualSalary': "8",
+            'capacity': "4",
+            'insuranceRate': "0.25",
+            'materialsExpenses': "5.0",
+            'otherExpenses': "1.0",
+            'welfareFactor': "0"
+        },
+        "流动资金及财务费用": {
+            "annualAPCirculationTimes": "12",
+            "annualARCirculationTimes": "12",
+            "annualCashCirculationTimes": "12",
+            "annualStockCirculationTimes": "12",
+            "interestRateAndWorkingCapital": "4",
+            "workingCapitalLoanRatio": "70"
+        },
+        "税率及附加": {
+            "aleatoricAccumulationFundRate": "0",
+            "basicDiscountRate": "8",
+            "cityMaintenanceConstructionTaxTate": "5",
+            "corporateIncomeTaxRate": "25",
+            "educationFeePlus": "5",
+            "electricityVATRate": "18",
+            "fuelBoughtVATRate": "10",
+            "hotColdVATRate": "12",
+            "legalAccumulationFundRate": "10",
+            "localEducationPlus": "2",
+            "materialBoughtVATRate": "17",
+            "steamSaleVATRate": "12"
+        }
+    }
+
+    def __init__(self, simulationId):
+        '''
+            初始化
+        '''
+        self.simulationId = simulationId
+
+    def _saveItemData(self, url, data):
+        '''
+            保存url链接对应的优化方案下财务评估模块的基础信息
+            :param url string类型，表示优化方案的接口链接
+
+            :return: dict 类型，代表方案对应的财务评价基础参数信息
+        '''
+        r = request('POST', url, None, data=json.dumps(data))
+        return json.loads(r.text)
+
+    def _fetchItemData(self, url, planID):
+        '''
+            获取planID对应的优化方案下财务评估模块的基础信息
+            :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
+
+            :return: dict 类型，为源数据的引用，代表方案对应的财务评价基础参数信息
+        '''
+        r = request('GET',
+                    url,
+                    params={
+                        "planId": planID,
+                        "simu": self.simulationId
+                    })
+        return json.loads(r.text)
+    
+    def run(self, planID) -> Runner[DSLabResult]:
+        '''
+            运行财务评价概览计算
+
+            :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
+
+            :return: Runner[DSLabResult]
+        '''
+        url = 'api/dslab/rest/saveDataToclickhouse'
+        try:
+            r = request('GET',
+                        url,
+                        params={
+                            "planId": planID,
+                            "simu": self.simulationId,
+                            "CMD_TYPE": 'financialEvaluation'
+                        })
+            data = json.loads(r.text)
+            return DSLabRunner({'rid': 'function/ieslab/evaluation'},
+                self.simulationId,
+                planId=planID,
+                cmdType='financialEvaluation')
+        except:
+            raise Exception('财务评价概览计算失败')
+
+    def GetFinancialParams(self, planID):
+        '''
+            获取planID对应的优化方案下财务评估模块的基础信息
+            :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
+
+            :return: dict 类型，为源数据的引用，代表方案对应的财务评价基础参数信息
+        '''
+        dict_result = dict()
+        for k, v in self._kindNameMap.items():
+            kind = self._kindNameMap.get(k, k)
+            url = f"{self._baseUri}{kind}"
+            list_data  = self._fetchItemData(url, planID)
+            if not list_data :
+                data = {
+                    "simu": self.simulationId,
+                    "planId": planID,
+                }
+                if k in self._financialParasDefaultValues:
+                    data.update(self._financialParasDefaultValues[k])
+                    dict_result[v]  = self._saveItemData(url, data)
+            else:
+                dict_result[v] = list_data
+        return dict_result

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,36 @@
+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)
+    

cloudpss/job/job.py

@@ -202,7 +202,7 @@ class Job(Generic[T]):
         if receiver is not None:
             self.__receiver = receiver
         if self.__receiver is None:
-            self.__receiver = MessageStreamReceiver(self)
+            self.__receiver = MessageStreamReceiver(self.output)
             self.__receiver.connect(**kwargs)
         return self.__receiver
 
@@ -216,7 +216,7 @@ class Job(Generic[T]):
         if sender is not None:
             self.__sender = sender
         if self.__sender is None:
-            self.__sender = MessageStreamSender(self)
+            self.__sender = MessageStreamSender(self.input)
         self.__sender.connect_legacy(**kwargs)
         return self.__sender
     

cloudpss/job/messageStreamReceiver.py

@@ -1,5 +1,8 @@
 import logging
 import sys
+
+from cloudpss.job.TemplateManager import TemplateManager
+
 from .jobReceiver import JobReceiver
 import os
 from urllib.parse import urlparse
@@ -7,7 +10,6 @@ import websocket
 import pytz
 import threading
 import time
-
 utc_tz = pytz.timezone("UTC")
 
 from ..utils.IO import IO
@@ -18,14 +20,15 @@ class Message(object):
         self.id = id
         self.token = token
 
-
+    
+    
 class MessageStreamReceiver(JobReceiver):
-    def __init__(self, job):
+    def __init__(self, output):
         super().__init__()
-        self.job = job
-        self.id =self.job.output
+        self.id = output
         self.origin = os.environ.get("CLOUDPSS_API_URL", "https://cloudpss.net/")
         self.__hasOpen = False
+        self.templates=TemplateManager()
 
     def __path(self, from_=None):
         if self.id is None:
@@ -39,25 +42,36 @@ class MessageStreamReceiver(JobReceiver):
   
     ###下面是兼容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")
+        
+        if type(msg) is list:
+            if len(msg) == 3:
+                pass
+                
+                templateMessage = self.templates.invoke(msg)
+                # print(templateMessage)
+                for m in templateMessage:
+                    self.messages.append(m)
+                return
+            else:
+                self.templates.create(msg)
+                return
+        
         self.messages.append(msg)
-        if(msg['type']=='terminate'):
-            self.close(self.ws)
         return msg
 
 
     def __on_error(self,  *args, **kwargs):
+        print(args)
         logging.debug("MessageStreamReceiver error")
         msg = {
             "type": "log",
@@ -128,7 +142,7 @@ class MessageStreamReceiver(JobReceiver):
        
 
     def connect(self):
-        self._status = 1
+        self._status = 0
         path = self.__path()
         logging.info(f"receive data from websocket: {path}")
         self.ws = websocket.WebSocketApp(

cloudpss/job/messageStreamSender.py

@@ -12,9 +12,9 @@ import logging
 
 
 class MessageStreamSender:
-    def __init__(self, job):
+    def __init__(self, input):
         super().__init__()
-        self.job = job
+        self.input = input
         self.origin = os.environ.get("CLOUDPSS_API_URL", "https://cloudpss.net/")
         self.__hasOpen = False
 
@@ -60,14 +60,14 @@ class MessageStreamSender:
         同步方法连接ws
         """
         self._status = 0
-        if self.job.input is None:
+        if self.input is None:
             raise Exception("id is None")
-        if self.job.input == "00000000-0000-0000-0000-000000000000":
+        if self.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
+        path = head + "://" + str(u[1]) + "/api/streams/token/" + self.input
         logging.debug(f"MessageStreamSender data from websocket: {path}")
 
         self.ws = websocket.WebSocketApp(

cloudpss/job/result/result.py

@@ -82,7 +82,6 @@ class Result(object):
 
             >>> message= db.getMessagesByType('log')
         """
-
         result = []
         for val in self._receiver:
             if val['type'] == type: