cloudpss 3.2.0a2__py3-none-any.whl → 4.0.0a5__py3-none-any.whl

cloudpss/__init__.py

@@ -1,22 +1,24 @@
 # coding=UTF-8
+from cloudpss.ieslab import IESLabSimulation, IESLabPlan
 from .verify import setToken
 from .runner import Runner, Result, EMTResult, PowerFlowResult
 from .model import Model, ModelRevision, ModelTopology
 from .project import Project
 from .utils import MatlabDataEncoder, DateTimeEncode
 from . import function
-from .function import FunctionExecution
 
+from .function import FunctionExecution
+from .version import __version__
 __all__ = [
     'setToken', 'Model', 'ModelRevision', 'ModelTopology', 'Runner', 'Result',
     'PowerFlowResult', 'EMTResult', 'MatlabDataEncoder', 'DateTimeEncode',
-    'function', 'Project', 'currentJob'
+    'function', 'Project', 'currentJob', 'IESLabSimulation', 'IESLabPlan','__version__'
 ]
-__version__ = '3.2.0.alpha.2'
+
 
 
 def currentJob():
     """
         获取当前的 currentExecution 实例
     """
-    return FunctionExecution.current()
+    return FunctionExecution.current()

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,267 @@
+from ..utils import request, fileLoad, graphql_request
+import json
+import time, datetime
+import copy
+import os 
+from cloudpss.dslab.files import getCurveData
+
+class DataManageModel(object):
+    _weatherUrl = ''
+    _baseUri = ''
+    _kindUrlMap = {}
+    _itemDataMap={}
+    _kindItemDataMap={}
+    _kindIdMap={}
+
+    def __init__(self, resourceId):
+        self.resourceId = resourceId
+
+    def _status(self):
+        '''
+            获取运行状态
+
+            :return: boolean 类型
+        '''
+        pass
+    
+    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 = data.get('extra')
+        if extra is None or not extra:
+            extra = getCurveData(kind)
+            r = {
+                'simu': self.resourceId,
+                'name': data.get('name', ''),
+                'extra': extra,
+                'data': data.get('data', {}),
+            }
+            url = f"{self._baseUri}rest/{kind}"
+            self._saveItemData(url, r)
+            return self._fetchItemData(url)
+        else:
+            r = {
+                'simu': self.resourceId,
+                'name': data.get('name', ''),
+                'extra': extra,
+                'data': data.get('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}"
+        r = {
+            'id': data.get('id', ''),
+            'name': data.get('name', ''),
+            'data': data.get('data', {}),
+        }
+        self._updateItemData(url, r)
+        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,145 @@
+import json
+from ..utils import request
+from ..model.model import Model
+from .dataManageModel import DSLabDataManageModel
+from .financialAnalysisModel import DSLabFinancialAnalysisModel
+from cloudpss.runner.DSLabResult import DSLabResult
+from cloudpss.runner.runner import Runner
+from cloudpss.runner.result import IESResult, EMTResult
+
+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.currentEvaluationResult = 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.resource
+        return self.model.run(job, name=name)
+    
+    def dsLabRun(self):
+        '''
+            生成方案优选算例
+
+            :return: 方案优选运行实例
+        '''
+    pass
+
+    def dsLabFinancialRun(self, planID):
+        '''
+            运行技术经济分析
+            :param planID int 类型，表示优化方案的ID，数值位于0~优化方案数量之间
+
+            :return: 技术经济分析实例
+
+        '''
+        return self.financialAnalysisModel.run(planID)
+    
+
+    def runIESLoadPrediction(self,job=None,name=None, **kwargs)->Runner[IESResult]:
+        '''
+            运行 负荷预测方案 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+            
+            :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
+            :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
+
+            :return: runner Runner[IESResult]
+        '''
+        if job is None:
+            currentJob = self.model.context['currentJob']
+            job = self.model.jobs[currentJob]
+            if job['rid'] != 'job-definition/ies/ies-load-prediction':
+                for j in self.model.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("不是负荷预测方案内核运行生成算法的计算方案")
+        return self.run(job=job, name=name)
+    
+    def runIESPowerFlow(self,job=None,name=None, **kwargs)->Runner[IESResult]:
+        '''
+            运行 时序潮流方案 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+            
+            :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
+            :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
+
+            :return: runner Runner[IESResult]
+        '''
+        if job is None:
+            currentJob = self.model.context['currentJob']
+            job = self.model.jobs[currentJob]
+            if job['rid'] != 'job-definition/ies/ies-power-flow':
+                for j in self.model.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("不是时序潮流方案内核运行生成算法的计算方案")
+        return self.run(job=job, name=name)
+
+    def runIESEnergyStoragePlan(self,job=None,name=None, **kwargs)->Runner[IESResult]:
+        '''
+            运行 储能规划方案 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+            
+            :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
+            :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
+
+            :return: runner Runner[IESResult]
+        '''
+        if job is None:
+            currentJob = self.model.context['currentJob']
+            job = self.model.jobs[currentJob]
+            if job['rid'] != 'job-definition/ies/ies-energy-storage-plan':
+                for j in self.model.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("不是储能规划方案内核运行生成算法的计算方案")
+        return self.run(job=job, name=name)
+

cloudpss/dslab/files/__init__.py

@@ -0,0 +1,2 @@
+from .files import getCurveData
+__all__ = ['getCurveData']