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

cloudpss/model/model.py

@@ -1,12 +1,11 @@
-import asyncio
 import os
 import re
 from copy import deepcopy
-
 from cloudpss.job.job import Job
+from cloudpss.job.result import EMTResult, IESResult, PowerFlowResult
+from cloudpss.job.result.result import Result
 from cloudpss.utils.IO import IO
-from cloudpss.utils.httpAsyncRequest import graphql_fetch
-
+from cloudpss.utils import graphql_request
 from .revision import ModelRevision
 from .jobDefinitions import JOB_DEFINITIONS
 from ..verify import userName
@@ -36,6 +35,39 @@ class Model(object):
     context     当前项目的上下文相关信息
 
     """
+    __models_query="""query($input:ModelsInput!){models(input:$input){cursor total count items{rid name description owner tags updatedAt }}}"""
+    
+    __model_query= """
+            query  t($rid:ResourceId!){
+                model(input:{rid: $rid}) {
+                    configs
+                    context
+                    description
+                    jobs
+                    name
+                    rid
+                    tags
+                    permissions {
+                        moderator
+                        member
+                        everyone
+                    }
+                    revision {
+                        author
+                        documentation
+                        graphic
+                        hash
+                        implements
+                        message
+                        parameters
+                        pins
+                        version
+                    }
+                }
+            }
+        """
+    __create_model= """mutation($a:CreateModelInput!){createModel(input:$a){rid}}"""
+    __update_model = """mutation($a:UpdateModelInput!){updateModel(input:$a){rid}}"""
 
     context: dict
     jobs: list
@@ -68,7 +100,7 @@ class Model(object):
         model = {**self.__dict__, "revision": self.revision.toJSON()}
         return model
 
-    def getAllComponents(self):
+    def getAllComponents(self)->dict:
         """
         获取实现
 
@@ -83,6 +115,46 @@ class Model(object):
         if diagramImplement is None:
             raise ValueError("不存在拓扑实现")
         return diagramImplement.getAllComponents()
+    
+    def addComponent(self, definition, label, args, pins, canvas=None, position=None, size=None):
+        """
+        创建一个
+
+        :return: Component
+
+        >>>> model.addComponent(args)
+        """
+        diagramImplement = self.revision.getImplements().getDiagram()
+        if diagramImplement is None:
+            raise ValueError("不存在拓扑实现")
+        return diagramImplement.addComponent(definition, label, args, pins, canvas, position, size)
+    
+    def removeComponent(self, key):
+        """
+        删除元件实现
+
+        :return: boolean
+
+        >>>> model.removeComponent(key)
+        """
+        diagramImplement = self.revision.getImplements().getDiagram()
+        if diagramImplement is None:
+            raise ValueError("不存在拓扑实现")
+        return diagramImplement.removeComponent(key)
+    
+    def updateComponent(self, key, **kwargs):
+        """
+        更新元件实现
+
+        :return: bool
+
+        >>>> model.updateComponent(key, args)
+        """
+        diagramImplement = self.revision.getImplements().getDiagram()
+        if diagramImplement is None:
+            raise ValueError("不存在拓扑实现")
+        return diagramImplement.updateComponent(key, **kwargs)
+
 
     def getComponentsByRid(self, rid: str):
         """
@@ -144,7 +216,7 @@ class Model(object):
 
         return jobs
 
-    def createJob(self, jobType: str, name):
+    def createJob(self, jobType:str, name:str):
         """
         创建一个计算方案
         创建出的方案默认不加入到项目中，需要加入请调用 addJob
@@ -207,7 +279,8 @@ class Model(object):
         """
 
         config = deepcopy(self.configs[0])
-        config["name"] = name
+        config['name'] = name
+        self.__updateConfigDefault(config)
         return config
 
     def addConfig(self, config):
@@ -221,14 +294,11 @@ class Model(object):
         """
 
         self.configs.append(config)
+        self.__updateConfigDefault(config)
         return config
 
     @staticmethod
-    def fetchMany(name=None, cursor=[]):
-        return asyncio.run(Model.fetchManyAsync(name, cursor))
-
-    @staticmethod
-    async def fetchManyAsync(name=None, cursor=[]):
+    def fetchMany(name=None, cursor=[], pageSize=10,owner=None):
         """
         获取用户可以运行的项目列表
 
@@ -237,41 +307,38 @@ class Model(object):
 
         :return: 按分页信息返回项目列表
 
-        >>> data= await Model.fetchManyAsync()
-        {
-            items: [
-                {'rid': 'model/admin/share-test', 'name': '1234', 'description': '1234'}
-                ...
-            ],
-            cursor: ["1699353593000"],
-
-        }
-
+        >>> data= await Model.fetchMany()
+        [
+            {'rid': 'model/demo/demo', 'name': 'demo', 'description': 'demo'}
+            ...
+        ]
 
         """
-        query = """query($input:ModelsInput!){models(input:$input){cursor total count items{rid name description owner tags updatedAt pages{pageId resource key path mode}access{permission role}}}}"""
+        if owner is None:
+            owner = userName()
+        elif owner == "*":
+            owner = None
         variables = {
             "cursor": cursor,
-            "limit": 10,
-            "orderBy": ["updatedAt<"],
-            "permissionEveryone": ["b_any", 2**16],
+            "limit": pageSize,
+            "orderBy": [
+                "updatedAt<",
+                "type",
+                "owner",
+                "key"
+            ],
+            "owner":owner,
         }
         if name is not None:
             variables["_search"] = name
 
-        data = await graphql_fetch(query, {"input": variables})
-
+        data = graphql_request(Model.__models_query, {"input": variables})
         if "errors" in data:
             raise Exception(data["errors"][0]["message"])
-
-        return data["data"]["models"]
+        return data["data"]["models"]['items']
 
     @staticmethod
     def fetch(rid):
-        return asyncio.run(Model.fetchAsync(rid))
-
-    @staticmethod
-    async def fetchAsync(rid):
         """
         获取项目
 
@@ -282,72 +349,36 @@ class Model(object):
         >>> model=Model.fetch('model/Demo/test')
 
         """
-        query = """
-            query  t($rid:ResourceId!){
-                model(input:{rid: $rid}) {
-                    configs
-                    context
-                    description
-                    jobs
-                    name
-                    rid
-                    tags
-                    
-                    revision {
-                        author
-                        documentation
-                        graphic
-                        hash
-                        implements
-                        message
-                        parameters
-                        pins
-                        version
-                    }
-                }
-            }
-        """
-        data = await graphql_fetch(query, {"rid": rid})
+        data = graphql_request(Model.__model_query, {"rid": rid})
         if "errors" in data:
             raise Exception(data["errors"][0]["message"])
         return Model(data["data"]["model"])
 
-    def run(self, job=None, config=None, name=None, policy=None,stop_on_entry=None, **kwargs):
-        
-        job= asyncio.run(self.runAsync(job, config, name, policy,stop_on_entry, **kwargs))
-        job._Job__connect_legacy()
-        return job
-
-    async def runAsync(self, job=None, config=None, name=None, policy=None,stop_on_entry=None, **kwargs):
+    def run(self, job=None, config=None, name=None, **kwargs):
         """
 
-        调用仿真
+            调用仿真 
 
-        :params job:  调用仿真时使用的计算方案，不指定将使用算例保存时选中的计算方案
-        :params config:  调用仿真时使用的参数方案，不指定将使用算例保存时选中的参数方案
-        :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
+            :params job:  调用仿真时使用的计算方案，不指定将使用算例保存时选中的计算方案
+            :params config:  调用仿真时使用的参数方案，不指定将使用算例保存时选中的参数方案
+            :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
 
-        :return: 返回一个Job实例
+            :return: 返回一个运行实例
 
-        >>> job=model.run(job,config,'')
-        job
+            >>> runner=model.run(job,config,'')
+            runner
 
         """
         if job is None:
-            currentJob = self.context["currentJob"]
+            currentJob = self.context['currentJob']
             job = self.jobs[currentJob]
         if config is None:
-            currentConfig = self.context["currentConfig"]
+            currentConfig = self.context['currentConfig']
             config = self.configs[currentConfig]
-        revision = await self.revision.run(
-            job, config, name, self.rid, policy, **kwargs
-        )
-        if stop_on_entry is not None:
-            job['args']['stop_on_entry'] = stop_on_entry
-        return await Job.create(
-            revision["hash"], job, config, name, self.rid, policy, **kwargs
-        )
+        self.__updateConfigDefault(config)
+        return self.revision.run(job, config, name, rid=self.rid, **kwargs)
 
+ 
     def iesSimulationRun(self, job=None, config=None, name=None, **kwargs):
         return self.run(job=job, config=config, name=name, kwargs=kwargs)
 
@@ -369,7 +400,8 @@ class Model(object):
         if not os.path.exists(filePath):
             raise FileNotFoundError("未找到文件")
         data = IO.load(filePath, format)
-        return Model(data)
+        return data
+
 
     @staticmethod
     def dump(model, file, format="yaml", compress="gzip"):
@@ -386,12 +418,9 @@ class Model(object):
         >>> Model.dump(model,file)
         """
 
-        IO.dump(model, file, format, compress)
+        IO.dump(model.toJSON(), file, format, compress)
 
     def save(self, key=None):
-        return asyncio.run(self.saveAsync(key))
-
-    async def saveAsync(self, key=None):
         """
         保存/创建项目
 
@@ -399,7 +428,6 @@ class Model(object):
         key 为空时如果项目 rid 不存在则抛异常，需要重新设置 key。
         如果保存时，当前用户不是该项目的拥有者时，将重新创建项目，重建项目时如果参数的 key 为空将使用当前当前项目的 key 作为资源的 key ，当资源的 key 和远程冲突时保存失败
 
-        :params: model 项目
         :params: key 资源 id 的唯一标识符，
 
         :return: 保存成功/保存失败
@@ -415,9 +443,9 @@ class Model(object):
             if matchObj:
                 self.rid = "model/" + username + "/" + key
                 try:
-                    return await Model.updateAsync(self)
+                    return Model.update(self)
                 except:
-                    return await Model.createAsync(self)
+                    return Model.create(self)
             else:
                 raise Exception("key 能包含字母数子和下划线")
         else:
@@ -428,18 +456,15 @@ class Model(object):
             elif owner[0] != username:
                 rid = re.sub(t, username, self.rid)
                 try:
-                    return await Model.createAsync(self)
+                    return Model.create(self)
                 except:
                     raise Exception(rid + " 该资源已存在，无法重复创建,请修改 key")
 
-        return await Model.updateAsync(self)
+        return Model.update(self)
 
-    @staticmethod
-    def create(model):
-        return asyncio.run(Model.createAsync(model))
 
     @staticmethod
-    async def createAsync(model):
+    def create(model):
         """
         新建项目
 
@@ -460,19 +485,10 @@ class Model(object):
         elif owner[0] != username:
             raise Exception("rid 错误，无法保存")
 
-        modelQuery = """
-                    mutation($a:CreateModelInput!){createModel(input:$a){
-                                         rid
-                                }}
-                """
-        isPublic = model.context.get("auth", "") != "private"
-        isComponent = model.context.get("category", "") == "component"
-        publicRead = model.context.get("publicRead", "") != False
-        auth = (65539 if publicRead else 65537) if isPublic else 0
-        revision = await ModelRevision.createAsync(model.revision, model.revision.hash)
-
-        return await graphql_fetch(
-            modelQuery,
+        revision = ModelRevision.create(model.revision, model.revision.hash)
+
+        return graphql_request(
+            Model.__create_model,
             {
                 "a": {
                     "rid": model.rid,
@@ -484,20 +500,18 @@ class Model(object):
                     "description": model.description,
                     "tags": model.tags,
                     "permissions": {
-                        "moderator": 1,
-                        "member": 1,
-                        "everyone": auth,
+                       "moderator": 98367,
+                        "member": 65551,
+                        "everyone": 0
                     },
                 }
             },
         )
 
-    @staticmethod
-    def update(model):
-        return asyncio.run(Model.updateAsync(model))
+    
 
     @staticmethod
-    async def updateAsync(model):
+    def update(model):
         """
         更新项目
 
@@ -517,48 +531,43 @@ class Model(object):
         elif owner[0] != username:
             raise Exception("rid 错误，无法保存")
 
-        modelQuery = """
-                    mutation($a:UpdateModelInput!){updateModel(input:$a){
-                                         rid
-                                }}
-                """
-        isPublic = model.context.get("auth", "") != "private"
-        isComponent = model.context.get("category", "") == "component"
-        publicRead = model.context.get("publicRead", "") != False
-        auth = (65539 if publicRead else 65537) if isPublic else 0
-        revision = await ModelRevision.createAsync(model.revision, model.revision.hash)
-
-        xVersion = int(float(os.environ.get("X_CLOUDPSS_VERSION", 4)))
-        tags = {"replace": model.tags}
-        if xVersion == 3:
-            tags = model.tags
-
-        return await graphql_fetch(
-            modelQuery,
-            {
-                "a": {
-                    "rid": model.rid,
-                    "revision": revision["hash"],
-                    "context": model.context,
-                    "configs": model.configs,
-                    "jobs": model.jobs,
-                    "name": model.name,
-                    "description": model.description,
-                    "tags": tags,
-                    "permissions": {
-                        "moderator": 1,
-                        "member": 1,
-                        "everyone": auth,
-                    },
+        
+        permissions=model.permissions
+        revision = ModelRevision.create(model.revision, model.revision.hash)
+
+        xVersion = int(float(os.environ.get('X_CLOUDPSS_VERSION', 4)))
+        tags= {
+            "replace":model.tags
+        }
+        if xVersion==3:
+            tags=model.tags
+        
+        r= graphql_request(
+            Model.__update_model, {
+                'a': {
+                    'rid': model.rid,
+                    'revision': revision['hash'],
+                    'context': model.context,
+                    'configs': model.configs,
+                    'jobs': model.jobs,
+                    'name': model.name,
+                    'description': model.description,
+                    'tags': tags,
+                    "permissions": permissions,
                 }
-            },
-        )
+            })
+        if "errors" in r:
+            raise Exception(r["errors"][0]["message"])
+        return r
 
+
+    
     def fetchTopology(
         self,
         implementType=None,
         config=None,
         maximumDepth=None,
+         **kwargs
     ):
         """
         通过项目信息，获取当前项目对应的拓扑数据
@@ -573,132 +582,151 @@ class Model(object):
             topology=model.fetchTopology(implementType='powerFlow',config=config) # 获取潮流实现的拓扑数据
             topology=model.fetchTopology(maximumDepth=2) # 获取仅展开 2 层的拓扑数据
         """
-
         if self.revision is not None:
             if implementType is None:
                 implementType = "emtp"
             if config is None:
                 currentConfig = self.context["currentConfig"]
                 config = self.configs[currentConfig]
-            return self.revision.fetchTopology(implementType, config, maximumDepth)
+            return self.revision.fetchTopology(implementType, config,
+                maximumDepth, **kwargs)
         return None
+    
 
-    def runEMT(self, job=None, config=None) -> Job:
+    def __updateConfigDefault(self, config):
+        paramters = self.revision.parameters
+        if paramters is None:
+            return
+        for param in paramters:
+            for val in param['items']:
+                if config['args'].get(val['key'],None) is None:
+                    config['args'][val['key']] = val['value']
+    
+    def runEMT(self,job=None,config=None,**kwargs)->Runner[EMTResult]:
         """
-        运行 emtp 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+            运行 emtp 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
 
-        :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
-        :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
+            :params job:  调用仿真时使用的计算方案，不指定将使用算例保存时选中的计算方案
+            :params config:  调用仿真时使用的参数方案，不指定将使用算例保存时选中的参数方案
+            :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
+
+            :return: 返回一个运行实例
+
+            >>> runner=model.run(job,config,'')
+            runner
 
-        :return: job 运行结果
         """
         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 config is None:
+            currentConfig = self.context["currentConfig"]
+            config = self.configs[currentConfig]
+        return self.revision.run(
+            job, config, name,  policy, stop_on_entry,self.rid,**kwargs
+        )
+        
+    def __findJob(self, jobType):
+        currentJob = self.context["currentJob"]
+        job = self.jobs[currentJob]
+        if job["rid"] != jobType:
+            for j in self.jobs:
+                if j["rid"] ==jobType:
+                    job = j
+        return job        
+        
+    def runEMT(self, job=None, config=None,**kwargs) -> Job[EMTResult]:
+        """
+        运行 emtp 内核，如果当前 model 没有创建  Job 时报错，默认使用算例中选中的计算方案进行仿真，如果选中的计算方案不是 EMT 方案则选第一个EMT 计算方案，如果不存在计算方案则直接报错。
+
+        :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
+        :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
+
+        :return: 生成的任务
+        """
+        if job is None:
+            job = self.__findJob("function/CloudPSS/emtps")
         if job is None:
             raise Exception("找不到电磁暂态运行的计算方案")
-        if job["rid"] != "job-definition/cloudpss/emtp":
+        if job["rid"] != "function/CloudPSS/emtp" and job["rid"] != "function/CloudPSS/emtps":
             raise Exception("不是电磁暂态运行生成算法的计算方案")
         if config is None:
             currentConfig = self.context["currentConfig"]
             config = self.configs[currentConfig]
-        return self.run(job=job, config=config)
+        
+        return self.run(job=job, config=config,**kwargs)
 
-    def runSFEMT(self, job=None, config=None) -> Job:
+    def runSFEMT(self,job=None,config=None,**kwargs)->Runner[EMTResult]:
         """
-        运行 移频电磁暂态 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+            运行 移频电磁暂态 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
 
         :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
         :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
 
-        :return: runner Runner[EMTResult]
+        :return: Job[EMTView]
         """
         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
+            job = self.__findJob("function/CloudPSS/sfemt")
         if job is None:
             raise Exception("找不到移频电磁暂态运行的计算方案")
-        if job["rid"] != "job-definition/cloudpss/sfemt":
+        if job["rid"] != "function/CloudPSS/sfemt":
             raise Exception("不是移频电磁暂态运行生成算法的计算方案")
         if config is None:
             currentConfig = self.context["currentConfig"]
             config = self.configs[currentConfig]
-        return self.run(job=job, config=config)
+        return self.run(job=job, config=config,**kwargs)
 
-    def runPowerFlow(self, job=None, config=None) -> Job:
+    def runPowerFlow(self,job=None,config=None,**kwargs)->Runner[PowerFlowResult]:
         """
-        运行 潮流 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+            运行 潮流 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
 
-        :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
-        :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
+            :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
+            :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
 
-        :return: runner Runner[PowerFlowResult]
+            :return: Job[EMTView]
         """
         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
+            job = self.__findJob("function/CloudPSS/power-flow")
         if job is None:
             raise Exception("找不到潮流内核运行的计算方案")
-        if job["rid"] != "job-definition/cloudpss/power-flow":
+        if job["rid"] != "function/CloudPSS/power-flow":
             raise Exception("不是潮流内核运行生成算法的计算方案")
         if config is None:
             currentConfig = self.context["currentConfig"]
             config = self.configs[currentConfig]
-        return self.run(job=job, config=config)
+        return self.run(job=job, config=config,**kwargs)
 
-    def runThreePhasePowerFlow(self, job=None, config=None) -> Job:
+    def runThreePhasePowerFlow(self, job=None, config=None,**kwargs) -> Job[PowerFlowResult]:
         """
         运行 三相不平衡潮流 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
 
         :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
         :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
 
-        :return: runner Runner[PowerFlowResult]
+        :return: Job[PowerFlowView]
         """
         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
+            job = self.__findJob("function/CloudPSS/three-phase-powerFlow")
         if job is None:
             raise Exception("找不到三相不平衡潮流内核运行的计算方案")
-        if job["rid"] != "job-definition/cloudpss/three-phase-powerFlow":
+        if job["rid"] != "function/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)
+        return self.run(job=job, config=config,**kwargs)
 
-    def runIESLoadPrediction(self, job=None, config=None) -> Runner[IESResult]:
+    def runIESLoadPrediction(self, job=None, config=None,**kwargs) -> Job[IESResult]:
         """
         运行 负荷预测方案 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
 
         :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
         :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
 
-        :return: runner Runner[IESResult]
+        :return: Job[IESView]
         """
         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
+            job = self.__findJob("job-definition/ies/ies-load-prediction")
         if job is None:
             raise Exception("找不到负荷预测方案内核运行的计算方案")
         if job["rid"] != "job-definition/ies/ies-load-prediction":
@@ -708,22 +736,17 @@ class Model(object):
             config = self.configs[currentConfig]
         return self.run(job=job, config=config)
 
-    def runIESPowerFlow(self, job=None, config=None) -> Runner[IESResult]:
+    def runIESPowerFlow(self, job=None, config=None,**kwargs) -> Job[IESResult]:
         """
         运行 时序潮流方案 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
 
         :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
         :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
 
-        :return: runner Runner[IESResult]
+        :return: Job[IESView]
         """
         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
+            job = self.__findJob("job-definition/ies/ies-power-flow")
         if job is None:
             raise Exception("找不到时序潮流方案内核运行的计算方案")
         if job["rid"] != "job-definition/ies/ies-power-flow":
@@ -731,24 +754,19 @@ class Model(object):
         if config is None:
             currentConfig = self.context["currentConfig"]
             config = self.configs[currentConfig]
-        return self.run(job=job, config=config)
+        return self.run(job=job, config=config,**kwargs)
 
-    def runIESEnergyStoragePlan(self, job=None, config=None) -> Runner[IESResult]:
+    def runIESEnergyStoragePlan(self, job=None, config=None,**kwargs) -> Job[IESResult]:
         """
         运行 储能规划方案 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
 
         :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
         :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
 
-        :return: runner Runner[IESResult]
+        :return: Job[IESView]
         """
         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
+            job = self.__findJob("job-definition/ies/ies-energy-storage-plan")
         if job is None:
             raise Exception("找不到储能规划方案内核运行的计算方案")
         if job["rid"] != "job-definition/ies/ies-energy-storage-plan":
@@ -756,4 +774,5 @@ class Model(object):
         if config is None:
             currentConfig = self.context["currentConfig"]
             config = self.configs[currentConfig]
-        return self.run(job=job, config=config)
+        return self.run(job=job, config=config,**kwargs)
+