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

cloudpss/model/model.py

@@ -5,9 +5,14 @@ import json
 import yaml
 import gzip
 from copy import deepcopy
+
 from .revision import ModelRevision
 from .jobDefinitions import JOB_DEFINITIONS
 from ..utils import request, fileLoad, graphql_request
+from ..verify import userName
+
+from cloudpss.runner.result import  PowerFlowResult, EMTResult, Result, IESResult
+from cloudpss.runner.runner import  Runner
 
 
 class Model(object):
@@ -31,18 +36,17 @@ class Model(object):
         context     当前项目的上下文相关信息
 
     """
+    context: dict
+    jobs: list
+    configs: list
+
     def __init__(self, model: dict = {}):
         """
             项目初始化
         """
         for k, v in model.items():
             if k == 'revision':
-                if 'version' in v and v['version'] == 3:
-                    self.__dict__[k] = ModelRevision(v)
-                else:
-                    raise Exception(
-                        '当前SDK版本（ver 3.X.X）不兼容该项目文件，请先升级项目文件。具体方法：将该项目文件导入至XStudio 3.X.X平台后重新保存至本地后即可。'
-                    )
+                self.revision = ModelRevision(v)
 
             else:
                 self.__dict__[k] = v
@@ -96,9 +100,7 @@ class Model(object):
         cells = {}
         for key, val in v.items():
 
-            if val.shape.endswith('edge'):
-                continue
-            if val.shape != 'diagram-component':
+            if not val.shape.startswith('diagram-component'):
                 continue
             if val.definition == rid:
                 cells[key] = val
@@ -311,9 +313,11 @@ class Model(object):
         if config is None:
             currentConfig = self.context['currentConfig']
             config = self.configs[currentConfig]
-
         return self.revision.run(job, config, name, self.rid, **kwargs)
 
+    def iesSimulationRun(self, job=None, config=None, name=None, **kwargs):
+        return self.run(job=job, config=config, name=name, kwargs=kwargs)
+
     @staticmethod
     def load(filePath):
         """
@@ -369,7 +373,7 @@ class Model(object):
                 model.save(model,'newKey') # 另存为新的项目
 
         """
-        username = os.environ.get('USER_NAME')
+        username = userName()
 
         if key is not None:
             matchObj = re.match(r'^[-_A-Za-z0-9]+$', key, re.I | re.S)
@@ -411,7 +415,7 @@ class Model(object):
         """
         # Model.update(model)
         t = '(?<=/)\\S+(?=/)'
-        username = os.environ.get('USER_NAME')
+        username = userName()
         owner = re.search(t, model.rid)
 
         if owner is None:
@@ -462,7 +466,7 @@ class Model(object):
         """
 
         t = '(?<=/)\\S+(?=/)'
-        username = os.environ.get('USER_NAME')
+        username = userName()
         owner = re.search(t, model.rid)
 
         if owner is None:
@@ -481,6 +485,13 @@ class Model(object):
         auth = (65539 if publicRead else 65537) if isPublic else 0
         revision = ModelRevision.create(model.revision, model.revision.hash)
 
+        xVersion = int(os.environ.get('X_CLOUDPSS_VERSION', 4))
+        tags= {
+            "replace":model.tags
+        }
+        if xVersion==3:
+            tags=model.tags
+        
         return graphql_request(
             modelQuery, {
                 'a': {
@@ -491,7 +502,7 @@ class Model(object):
                     'jobs': model.jobs,
                     'name': model.name,
                     'description': model.description,
-                    'tags': model.tags,
+                    'tags': tags,
                     "permissions": {
                         "moderator": 1,
                         "member": 1,
@@ -527,5 +538,181 @@ class Model(object):
                 currentConfig = self.context['currentConfig']
                 config = self.configs[currentConfig]
             return self.revision.fetchTopology(implementType, config,
-                                               maximumDepth)
+                maximumDepth)
         return None
+
+    def runEMT(self,job=None,config=None)->Runner[EMTResult]:
+        '''
+            运行 emtp 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+
+            :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
+            :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
+            
+            :return: runner Runner[EMTResult]
+        '''
+        if job is None:
+            currentJob = self.context['currentJob']
+            job = self.jobs[currentJob]
+            if job['rid'] != 'job-definition/cloudpss/emtp':
+                for j in self.jobs:
+                    if j['rid'] == 'job-definition/cloudpss/emtp':
+                        job = j
+        if job is None:
+            raise Exception("找不到电磁暂态运行的计算方案")
+        if job['rid'] != 'job-definition/cloudpss/emtp':
+            raise Exception("不是电磁暂态运行生成算法的计算方案")
+        if config is None:
+            currentConfig = self.context['currentConfig']
+            config = self.configs[currentConfig]
+        return self.run(job=job, config=config)
+
+    def runSFEMT(self,job=None,config=None)->Runner[EMTResult]:
+        '''
+            运行 移频电磁暂态 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+
+            :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
+            :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
+
+            :return: runner Runner[EMTResult]
+        '''
+        if job is None:
+            currentJob = self.context['currentJob']
+            job = self.jobs[currentJob]
+            if job['rid'] != 'job-definition/cloudpss/sfemt':
+                for j in self.jobs:
+                    if j['rid'] == 'job-definition/cloudpss/sfemt':
+                        job = j
+        if job is None:
+            raise Exception("找不到移频电磁暂态运行的计算方案")
+        if job['rid'] != 'job-definition/cloudpss/sfemt':
+            raise Exception("不是移频电磁暂态运行生成算法的计算方案")
+        if config is None:
+            currentConfig = self.context['currentConfig']
+            config = self.configs[currentConfig]
+        return self.run(job=job, config=config)
+
+    def runPowerFlow(self,job=None,config=None)->Runner[PowerFlowResult]:
+        '''
+            运行 潮流 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+
+            :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
+            :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
+
+            :return: runner Runner[PowerFlowResult]
+        '''
+        if job is None:
+            currentJob = self.context['currentJob']
+            job = self.jobs[currentJob]
+            if job['rid'] != 'job-definition/cloudpss/power-flow':
+                for j in self.jobs:
+                    if j['rid'] == 'job-definition/cloudpss/power-flow':
+                        job = j
+        if job is None:
+            raise Exception("找不到潮流内核运行的计算方案")
+        if job['rid'] != 'job-definition/cloudpss/power-flow':
+            raise Exception("不是潮流内核运行生成算法的计算方案")
+        if config is None:
+            currentConfig = self.context['currentConfig']
+            config = self.configs[currentConfig]
+        return self.run(job=job, config=config)
+
+    def runThreePhasePowerFlow(self,job=None,config=None)->Runner[PowerFlowResult]:
+        '''
+            运行 三相不平衡潮流 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+            
+            :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
+            :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
+
+            :return: runner Runner[PowerFlowResult]
+        '''
+        if job is None:
+            currentJob = self.context['currentJob']
+            job = self.jobs[currentJob]
+            if job['rid'] != 'job-definition/cloudpss/three-phase-powerFlow':
+                for j in self.jobs:
+                    if j['rid'] == 'job-definition/cloudpss/three-phase-powerFlow':
+                        job = j
+        if job is None:
+            raise Exception("找不到三相不平衡潮流内核运行的计算方案")
+        if job['rid'] != 'job-definition/cloudpss/three-phase-powerFlow':
+            raise Exception("不是三相不平衡潮流内核运行生成算法的计算方案")
+        if config is None:
+            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/model/revision.py

@@ -1,4 +1,3 @@
-import json
 from .topology import ModelTopology
 from .implements import ModelImplement
 from ..utils import request, graphql_request
@@ -68,7 +67,6 @@ class ModelRevision(object):
 
             >>> revision.run(revision,job,config,'')
         """
-
         revision = ModelRevision.create(self)
         return Runner.create(revision['hash'], job, config, name, rid,
                              **kwargs)
@@ -96,6 +94,8 @@ class ModelRevision(object):
         variables = {'a': {**r, 'parent': parentHash}}
 
         r = graphql_request(query, variables)
+        if 'errors' in r:
+            raise Exception(r['errors'])
         return r['data']['createModelRevision']
 
     def fetchTopology(self, implementType, config, maximumDepth):

cloudpss/project/project.py

@@ -10,6 +10,7 @@ from ..model.jobDefinitions import JOB_DEFINITIONS
 from ..utils import request, fileLoad, graphql_request
 from ..model import Model
 from deprecated import deprecated
+from ..verify import userName
 
 
 @deprecated(version='3.0', reason="该类将在 5.0 版本移除，请使用 Model 类代替")
@@ -388,7 +389,7 @@ class Project(Model):
                 project.save(project,'newKey') # 另存为新的项目
 
         """
-        username = os.environ.get('USER_NAME')
+        username = userName()
 
         if key is not None:
             matchObj = re.match(r'^[-_A-Za-z0-9]+$', key, re.I | re.S)
@@ -431,7 +432,7 @@ class Project(Model):
         """
         # Project.update(project)
         t = '(?<=/)\\S+(?=/)'
-        username = os.environ.get('USER_NAME')
+        username = userName()
         owner = re.search(t, model.rid)
 
         if owner is None:
@@ -483,7 +484,7 @@ class Project(Model):
         """
 
         t = '(?<=/)\\S+(?=/)'
-        username = os.environ.get('USER_NAME')
+        username = userName()
         owner = re.search(t, project.rid)
 
         if owner is None:

cloudpss/runner/DSLabResult.py

@@ -0,0 +1,92 @@
+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 = self.GetOverviewResult()
+        if result is None or type(result) is list:
+            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/runner/IESLabEvaluationResult.py

@@ -0,0 +1,143 @@
+import json
+from ..utils.httprequests import request
+
+
+class IESLabEvaluationResult(object):
+    _baseUri = 'api/ieslab-plan/taskmanager/'
+    _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_id": self.simulationId,
+                        "planId": planID,
+                        "time": 0
+                    })
+        data = json.loads(r.text)
+        return data
+
+    def status(self):
+        '''
+            获取运行状态
+
+            :return: boolean 类型
+        '''
+        # 定义一个字典，把命令类型映射到相应的方法
+        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, planID):
+        '''
+            获取planID对应的优化方案下resultType财务评估结果
+
+            :param planID int 类型，表示优化方案的ID，数值位于0~优化方案数量之间
+            :param resultType enum 类型，表示财务评价结果表格的类型
+
+            :return: dict 类型，为源数据的引用，代表方案对应的财务评价基础参数信息
+
+        '''
+        assert (resultType in self._kindNameMap), "数据类型不存在"
+        kind = self._kindNameMap.get(resultType, resultType)
+        url = self._baseUri + kind
+        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, planID):
+        '''
+            获取当前结果类对应的优化方案下的概览结果
+            :param planID int 类型，表示优化方案的ID，数值位于0~优化方案数量之间
+
+            :return: array类型，代表该方案对应的概览结果
+        '''
+        r = request('GET',
+                    "api/ieslab-plan/taskmanager/getOverviewResult",
+                    params={
+                        "simu_id": self.simulationId,
+                        "planId": planID,
+                        "time": self.timeId
+                    })
+        result = json.loads(r.text)
+        if len(result['results']) > 0 and len(result['results'][0]['data']) > 0:
+            return result['results'][0]['data']
+        return []
+
+    def GetEnergyEvaluationResult(self, planID):
+        '''
+            获取当前结果类对应的优化方案下的能效评价
+            :param planID int 类型，表示优化方案的ID，数值位于0~优化方案数量之间
+
+            :return: array类型，代表该方案对应的能效评价结果
+        '''
+        r = request('GET',
+                    "api/ieslab-plan/taskmanager/getEnergyEvaluation",
+                    params={
+                        "simu_id": self.simulationId,
+                        "planId": planID,
+                        "time": self.timeId
+                    })
+        result = json.loads(r.text)
+        if len(result['results']) > 0 and len(result['results'][0]['data']) > 0:
+            return result['results'][0]['data']
+        return []
+
+    def GetEnvironmentalEvaluationResult(self, planID):
+        '''
+            获取当前结果类对应的优化方案下的环保评价
+            :param planID int 类型，表示优化方案的ID，数值位于0~优化方案数量之间
+
+            :return: array类型，代表该方案对应的环保评价结果
+        '''
+        r = request('GET',
+                    "api/ieslab-plan/taskmanager/getEnvironmentalEvaluation",
+                    params={
+                        "simu_id": self.simulationId,
+                        "planId": planID,
+                        "time": self.timeId
+                    })
+        result = json.loads(r.text)
+        if len(result['results']) > 0 and len(result['results'][0]['data']) > 0:
+            return result['results'][0]['data']
+        return []