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

cloudpss/__init__.py

@@ -6,14 +6,18 @@ from .model import Model, ModelRevision, ModelTopology
 from .project import Project
 from .utils import MatlabDataEncoder, DateTimeEncode
 from . import function
+
 from .function import FunctionExecution
+from .dslab import DSLab
 
 __all__ = [
     'setToken', 'Model', 'ModelRevision', 'ModelTopology', 'Runner', 'Result',
     'PowerFlowResult', 'EMTResult', 'MatlabDataEncoder', 'DateTimeEncode',
-    'function', 'Project', 'currentJob', 'IESLabSimulation', 'IESLabPlan'
+    'function', 'Project', 'currentJob', 'IESLabSimulation', 'IESLabPlan',
+    'DSLab'
+    
 ]
-__version__ = '3.1.2'
+__version__ = '3.1.3-beta.1'
 
 
 def currentJob():

cloudpss/dslab/DSLabFinancialResult.py

@@ -0,0 +1,96 @@
+import json
+from ..utils.httprequests import request
+
+class DSLabResult(object):
+    _baseUri = 'api/ies/rest/'
+    _kindNameMap = {
+        "利润与利润分配": "getEconomyResult",
+        "财务计划现金": "getFinancialPlanCashFlowResult",
+        "资产负债": "getLiabilityAssetsResult",
+        "投资使用计划与资金筹措": "getInvestPlanDataResult",
+        "借款还本付息计划": "getLoanRepaymentPlanResult",
+        "流动资金估算": "getFlowCashEvaluteResult",
+        "资产折旧与摊销估算": "getFlowCashEvaluteResult",
+        "总成本费用估算表": "getSumCostResult",
+        "项目总投资现金流量": "getSumInvestFlowCashResult",
+        "项目资本金现金流量": "getProjectCashFlowResult",
+        "营业收入、税金、附加和增值税估算": "getIncomeTaxResult",
+    }
+
+    def __init__(self, simulationId, taskId=None, **keywords) -> None:
+        """
+            初始化
+        """
+        self.simulationId = simulationId
+        self.timeId = keywords.get('timeId', 0)
+        self.planId = keywords.get('planId', 0)
+        self.cmdType = keywords.get('cmdType', None)
+
+    def _fetchItemData(self, url, planID):
+        '''
+            获取planID对应的优化方案下resultType财务评估结果
+
+            :param planID int 类型，表示优化方案的ID，数值位于0~优化方案数量之间
+            :param resultType enum 类型，表示财务评价结果表格的类型
+
+            :return: dict 类型，为源数据的引用，代表方案对应的财务评价基础参数信息
+        '''
+        r = request('GET',
+                    url,
+                    params={
+                        "simu": self.simulationId,
+                        "planId": planID,
+                        "time": 0
+                    })
+        data = json.loads(r.text)
+        return data
+
+    # def status(self):
+    #     '''
+    #         获取运行状态
+
+    #         :return: boolean 类型
+    #     '''
+    #     result = None
+    #     if self.cmdType is None:
+    #         result = self.GetOverviewResult()
+    #     if result is None:
+    #         return False
+    #     return True
+
+    def GetFinancialResult(self, resultType):
+        '''
+            获取planID对应的优化方案下resultType财务评估结果
+            :param planID int 类型，表示优化方案的ID，数值位于0~优化方案数量之间
+            :param resultType enum 类型，表示财务评价结果表格的类型
+
+            :return: dict 类型，为源数据的引用，代表方案对应的财务评价基础参数信息
+
+        '''
+        assert (resultType in self._kindNameMap), "数据类型不存在"
+        kind = self._kindNameMap.get(resultType, resultType)
+        url = f'{self._baseUri}{kind}'
+        list = self._fetchItemData(url, self.planId)
+        dict_result = dict()
+        for val in list:
+            for k, v in val.items():
+                dict_result[k] = v
+        return dict_result['data']
+
+    def GetOverviewResult(self):
+        '''
+            获取当前结果类对应的概览结果
+
+            :return: array类型，代表该方案对应的概览结果
+        '''
+        r = request('GET',
+                    "api/ies/rest/getOverviewResult",
+                    params={
+                        "simu": self.simulationId,
+                        "planId": self.planId,
+                        "time": self.timeId
+                    })
+        result = json.loads(r.text)
+        if len(result) > 0:
+            return result[0]['data']
+        return None

cloudpss/dslab/__init__.py

@@ -0,0 +1,2 @@
+from .dslab import DSLab
+__all__ = ['DSLab']

cloudpss/dslab/dataManageModel.py

@@ -0,0 +1,259 @@
+from ..utils import request, fileLoad, graphql_request
+import json
+import time, datetime
+import copy
+import os
+
+class DataManageModel(object):
+    _weatherUrl = ''
+    _baseUri = ''
+    _kindUrlMap = {}
+    _itemDataMap={}
+    _kindItemDataMap={}
+    _kindIdMap={}
+
+    def __init__(self, resourceId):
+        self.resourceId = resourceId
+    
+    def _fetchItemData(self, url):
+        '''
+            私有方法，获取simu对应所有数据项的列表
+            :params: url string类型，request请求对应的url链接
+            
+            :return: list类型，返回该种类下所有数据项的的列表
+        '''
+        r = request('GET',
+                    url,
+                    params={
+                        "simu": self.resourceId,
+                    })
+        return json.loads(r.text)
+    
+    def _saveItemData(self, url, data):
+        '''
+            私有方法，保存url链接对应的data数据
+            :params: url string类型，request请求对应的url链接
+            :params: data dict类型，表示添加的数据内容，其数据结构应满足对应数据项的结构要求
+            
+            :return: 无
+        '''
+        r = request('POST', url, data=json.dumps(data))
+        
+
+    def _updateItemData(self, url, data):
+        '''
+            私有方法，更新url链接对应的data数据
+            :params: url string类型，request请求对应的url链接
+            :params: data dict类型，表示添加的数据内容，其数据结构应满足对应数据项的结构要求
+            
+            :return: 无
+        '''
+        r = request('PUT', url, data=json.dumps(data))
+    
+    def _deleteItemData(self, url):
+        '''
+            私有方法，删除url链接对应的数据
+            :params: url string类型，request请求对应的url链接
+            
+            :return: 无
+        '''
+        r = request('DELETE',url)
+
+    def LocationGet(self):
+        '''
+            获取气象定位点数据
+
+            :return: list<dict>类型，为源数据的引用，包含id，经度坐标，纬度坐标，定位点名称
+        '''
+        url = f"{self._baseUri}rest/location"
+        r = request('GET',
+            url,
+            params={"simu": self.resourceId})
+        return json.loads(r.text)
+
+    def LocationCreate(self, name=None, longitude=None, latitude=None):
+        '''
+            创建气象定位点
+            :param: name 定位点名称，可选
+            :params: longitude float类型，可选，表示经度，范围为气象数据源的经度范围
+            :params: latitude float类型，可选，表示纬度，范围为气象数据源的纬度范围
+    
+            :return: 无
+        '''
+        url = f"{self._baseUri}rest/location"
+        r = request('POST',
+            url,
+            data=json.dumps({
+                "lat": '34.734492',
+                "lng": '113.648906',
+                "simu": self.resourceId,
+                "name": '定位点'
+            }))
+        d = json.loads(r.text)
+        if name is not None and longitude is not None and latitude is not None: 
+            if (float(longitude) > 180 or float(longitude) < -180
+                or float(latitude) > 90 or float(latitude) < -90):
+                raise Exception('经纬度坐标不存在')
+            else:
+                r = request('PUT',
+                    url,
+                    data=json.dumps({
+                        "lat": latitude,
+                        "lng": longitude,
+                        "simu": self.resourceId,
+                        "name": name,
+                        "id": d['id']
+                    }))
+        else:
+            raise Exception('参数缺失')
+        
+    def LocationUpdate(self, id, name, longitude, latitude):
+        '''
+            修改气象定位点
+            :param id: 定位点id
+            :param: name 定位点名称，可选
+            :params: longitude float类型，可选，表示经度，范围为气象数据源的经度范围
+            :params: latitude float类型，可选，表示纬度，范围为气象数据源的纬度范围
+    
+            :return: 无
+        '''
+        if (float(longitude) > 180 or float(longitude) < -180
+            or float(latitude) > 90 or float(latitude) < -90):
+            raise Exception('经纬度坐标不存在')
+        else:
+            url = f"{self._baseUri}rest/location"
+            r = request('PUT',
+                url,
+                data=json.dumps({
+                    "lat": latitude,
+                    "lng": longitude,
+                    "simu": self.resourceId,
+                    "name": name,
+                    "id": id
+                }))
+            
+    def LocationDelete(self, id):
+        '''
+            删除气象定位点
+            :param id: 定位点id
+
+            :return: 无
+        '''
+        url = f"{self._baseUri}rest/location/{str(id)}"
+        r = request('DELETE',
+                url)
+
+    def LoadWeather(self):
+        '''
+            加载气象数据
+
+            :return: 无
+        '''
+        url = f"{self._baseUri}rest/load_weather/"
+        r = request('GET',
+            url,
+            params = {
+                "simu": self.resourceId,
+            })
+        
+    def GetAtmosData(self, locationId, date):
+        '''
+            获取日期在date的气象数据
+            :params: locationId str类型，表示定位点id
+            :params: date dateTime类型，表示时间
+            
+            :return: list<dict>类型，为源数据的引用，返回当前项目位置对应时间范围内的气象数据序列，每个元素用字典进行表示，字典的key即区分不同的气象数据项（如风速、太阳辐照等）以及标识当前时间点
+        '''
+        rDate = datetime.date(*map(int, date.split('-')))
+        r = request('GET',
+                    self._weatherUrl, 
+                    params={
+                        "locationId": str(locationId),
+                        "date": rDate,
+                    })
+        return json.loads(r.text)
+    
+    def AddDataItem(self, kind, data):
+        '''
+            向kind类型的数据库中添加内容为data的数据项
+            :params: kind str类型，数据的种类标识，包含：光伏、风机、燃气、水电、常规小火电、生物质发电、垃圾电厂、传输线、变压器、开关、负荷分类、负荷用户、储能配置、上网电价、输配电价、常数电价、阶梯电价、分时电价、分时阶梯电价
+            :params: data dict类型，表示添加的数据内容，其数据结构应满足对应数据项的结构要求
+    
+            :return: list<dict>类型，返回该种类下所有数据项的列表
+        '''
+        assert (kind in self._kindUrlMap), "数据类型不存在"
+        extra_paths = {
+            '光伏': '基准出力曲线.json',
+            '风机': '基准出力曲线.json',
+            '燃气': '基准出力曲线2.json',
+            '水电': '基准出力曲线2.json',
+            '常规小火电': '基准出力曲线2.json',
+            '生物质发电': '基准出力曲线2.json',
+            '垃圾电厂': '基准出力曲线2.json',
+            '负荷分类': '负荷曲线.json',
+            '负荷用户': '负荷曲线.json',
+            '储能配置': '策略曲线.json',
+        }
+        extra = data.get('extra')
+        if extra is None or not extra:
+            if kind in extra_paths:
+                path = os.path.join(os.path.dirname(__file__), 'data', extra_paths[kind])
+                with open(path) as f:
+                    extra = json.load(f)
+            r = copy.deepcopy(data)
+            r['extra'] = extra
+            url = f"{self._baseUri}rest/{kind}"
+            self._saveItemData(url, r)
+            return self._fetchItemData(url)
+        else:
+            r = copy.deepcopy(data)
+            url = f"{self._baseUri}rest/{kind}"
+            self._saveItemData(url, r)
+            return self._fetchItemData(url)
+
+    def DeleteDataItem(self, id, kind):
+        '''
+            获取kind类型对应所有数据项的列表
+            :params: id int类型，数据的id
+            :params: kind str类型，数据的类型
+    
+            :return: list<dict>类型，返回该种类下所有数据项的列表
+        '''
+        url = f"{self._baseUri}rest/id/{str(id)}"
+        self._deleteItemData(url)
+        return self._fetchItemData(f"{self._baseUri}rest/{kind}")
+
+
+    def UpdateDataItem(self, kind, data):
+        '''
+            更新kind类型对应数据项
+            :params: kind str类型，数据的类型
+            :params: data dict类型，表示添加的数据内容，其数据结构应满足对应数据项的结构要求
+    
+            :return: list<dict>类型，返回该种类下所有数据项的列表
+        '''
+        url = f"{self._baseUri}rest/{kind}"
+        self._updateItemData(url, data)
+        return self._fetchItemData(url)
+
+        
+    def GetItemList(self, kind):
+        '''
+            获取kind类型对应所有数据项的列表
+            :params: kind str类型，数据的种类标识，包含：光伏、风机、燃气、水电、常规小火电、生物质发电、垃圾电厂、传输线、变压器、开关、负荷分类、负荷用户、储能配置、上网电价、输配电价、常数电价、阶梯电价、分时电价、分时阶梯电价
+    
+            :return: list<dict>类型，返回该种类下所有数据项的列表
+        '''
+        assert (kind in self._kindUrlMap), "数据类型不存在"
+        url = f"{self._baseUri}rest/{kind}"
+        return self._fetchItemData(url)
+
+class DSLabDataManageModel(DataManageModel):
+    _baseUri = 'api/ies/'
+    _weatherUrl = 'api/ies/rest/weather'
+    _kindUrlMap = {kind: f"api/ies/rest/{kind}" for kind in [
+        "光伏", "风机", "燃气", "水电", "常规小火电", "生物质发电", "垃圾电厂",
+        "传输线", "变压器", "开关", "负荷分类", "负荷用户", "储能配置", 
+        "上网电价", "输配电价", "常数电价", "阶梯电价", "分时电价", "分时阶梯电价"
+    ]}
+

cloudpss/dslab/dslab.py

@@ -0,0 +1,66 @@
+import json
+from ..utils import request
+from ..model.model import Model
+from .dataManageModel import DSLabDataManageModel
+from .financialAnalysisModel import DSLabFinancialAnalysisModel
+from  .DSLabFinancialResult import DSLabResult
+
+class DSLab(object):
+    def __init__(self, project={}):
+        '''
+            初始化
+        '''
+        self.id = project.get('id', None)
+        self.resource = project.get('resource', None)
+        self.name = project.get('name', None)
+        self.__modelRid = project.get('model', None)
+        if self.__modelRid is not None:
+            self.model = Model.fetch(self.__modelRid)
+        self.dataManageModel = DSLabDataManageModel(self.resource)
+        self.financialAnalysisModel = DSLabFinancialAnalysisModel(self.resource)
+        self.dsLabResult = DSLabResult(self.resource)
+
+    @staticmethod
+    def fetch(simulationId):
+        '''
+            获取算例信息
+
+            :params: simulationId string类型，代表数据项的算例id
+
+            :return: DSLab
+        '''
+        try:
+            r = request(
+                'GET', 'api/ies/rest/simulation/{0}'.format(simulationId))
+            project = json.loads(r.text)
+            return DSLab(project)
+        except Exception as e:
+            if 'Unauthorized' in str(e): 
+                raise Exception('token 无效')
+            else:
+                raise Exception('未查询到当前算例')
+
+    def run(self, job=None, name=None):
+        '''
+            调用仿真 
+
+            :params job:  调用仿真时使用的计算方案，不指定将使用算例保存时选中的计算方案
+            :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
+
+            :return: 返回一个运行实例
+        '''
+        if job is None:
+            currentJob = self.model.context['currentJob']
+            job = self.model.jobs[currentJob]
+
+        job['args']['simulationId'] = self.id
+        return self.model.run(job, name=name)
+    
+    def dsLabRun(self):
+        '''
+            生成方案优选算例
+
+            :return: 方案优选运行实例
+        '''
+    pass
+

cloudpss/dslab/financialAnalysisModel.py

@@ -0,0 +1,113 @@
+import time
+from cloudpss.runner.runner import Runner
+from cloudpss.dslab.DSLabFinancialResult import DSLabResult
+from ..utils import request
+import json
+
+
+class DSLabFinancialAnalysisModel(object):
+    _baseUri = 'api/ies/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, 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 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/ieslab/DataManageModel.py

@@ -146,19 +146,19 @@ class DataManageModel(object):
         if r['timeid'] is not None:
             del r['timeid']
         try:
-            ret = self._saveItemData(self._kindUrlMap[kind], r)
+            self._saveItemData(self._kindUrlMap[kind], r)
             self._kindIdMap[str(data['timeid'])]=kind
             self._kindIdMap[str(data['id'])]=kind
             self._itemDataMap[str(data['timeid'])]=data
             self._itemDataMap[str(data['id'])]=data
             if kind in ['thermalLoads', 'electricLoads', 'fuels']:
                 dataList = self._fetchItemData(self._kindUrlMap[kind], None)
-                self._kindItemDataMap[kind].append(dataList)
-                return dataList[len(dataList) - 1]['id']
+                self._kindItemDataMap[kind] = dataList
+                return dataList[-1]['id']
             else:
                 dataList = self._fetchItemData(self._kindUrlMap[kind], kind)
-                self._kindItemDataMap[kind].append(dataList)
-                return dataList[len(dataList) - 1]['id']
+                self._kindItemDataMap[kind] = dataList
+                return dataList[-1]['id']
         except Exception as e:
             raise Exception(str(e))
 

cloudpss/ieslab/EvaluationModel.py

@@ -5,7 +5,6 @@ from ..utils import request
 import json
 from enum import IntEnum, unique
 
-
 class IESLabEvaluationModel(object):
     _baseUri = 'api/ieslab-plan/rest/'
     _taskUri = 'api/ieslab-plan/taskmanager/getSimuLastTasks'
@@ -58,6 +57,12 @@ class IESLabEvaluationModel(object):
         }
     }
 
+    # 评价基础参数接口默认值
+    _evaluationType = {
+        "环保评价": "environmentalEvaluation",
+        "能效评价": "energyEvaluation"
+    }
+
     def __init__(self, simulationId):
         '''
             初始化
@@ -91,7 +96,7 @@ class IESLabEvaluationModel(object):
         data = json.loads(r.text)
         return data
 
-    def GetFinancialParas(self, planID):
+    def GetFinancialParams(self, planID):
         '''
             获取planID对应的优化方案下财务评估模块的基础信息
             :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
@@ -135,20 +140,20 @@ class IESLabEvaluationModel(object):
                         params={
                             "simuid": self.simulationId,
                             "planId": planID,
-                            "CMD_TYPE": type
+                            "CMD_TYPE": self._evaluationType[type]
                         })
             data = json.loads(r.text)
             return HttpRunner({'rid': 'function/ieslab/evaluation'},
                 self.simulationId,
                 timeId=timeId,
                 planId=planID,
-                cmdType=type)
+                cmdType=self._evaluationType[type])
         except:
             raise Exception('方案评估开始计算失败')
 
     def EnvironmentalEvaluationRun(self, planID):
         '''
-            运行方案评估
+            运行环保评价方案评估
 
             :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
 
@@ -158,7 +163,7 @@ class IESLabEvaluationModel(object):
 
     def EnergyEvaluationRun(self, planID):
         '''
-            运行方案评估
+            运行能效评价方案评估
 
             :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
 

cloudpss/ieslab/IESLabPlan.py

@@ -74,20 +74,21 @@ class IESLabPlan(object):
                         job = j
         if job is None:
             raise Exception("找不到默认的综合能源系统规划典型日生成算法的计算方案")
-        if job['rid'] != 'job-definition/ies/ies-gmm'or job['rid'] != 'job-definition/cloudpss/ieslab-gmm':
+        if job['rid'] != 'job-definition/ies/ies-gmm' and job['rid'] != 'job-definition/cloudpss/ieslab-gmm':
             raise Exception("不是综合能源系统规划典型日生成算法的计算方案")
         return self.__run(job=job, name=name)
 
-    def iesLabEvaluationRun(self, planId):
+    def iesLabEvaluationRun(self, planId, type=None):
         '''
             运行方案评估
 
             :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
+            :param type string类型，表示评估类型，可选值为：能效评价、环保评价
 
             :return: 方案评估运行实例
 
         '''
-        return self.evaluationModel.run(planId)
+        return self.evaluationModel.run(planId, type)
 
     def iesLabEnergyEvaluationRun(self, planId):
         '''