cloudpss 4.1.1b8__py3-none-any.whl → 4.1.1b9__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.view import EMTView, IESView, PowerFlowView
+from cloudpss.job.view.view import View
 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,34 @@ 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
+                    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 +95,7 @@ class Model(object):
         model = {**self.__dict__, "revision": self.revision.toJSON()}
         return model
 
-    def getAllComponents(self):
+    def getAllComponents(self)->dict:
         """
         获取实现
 
@@ -83,6 +110,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, args):
+        """
+        更新元件实现
+
+        :return: bool
+
+        >>>> model.updateComponent(key, args)
+        """
+        diagramImplement = self.revision.getImplements().getDiagram()
+        if diagramImplement is None:
+            raise ValueError("不存在拓扑实现")
+        return diagramImplement.updateComponent(key, args)
+
 
     def getComponentsByRid(self, rid: str):
         """
@@ -144,7 +211,7 @@ class Model(object):
 
         return jobs
 
-    def createJob(self, jobType: str, name):
+    def createJob(self, jobType:str, name:str):
         """
         创建一个计算方案
         创建出的方案默认不加入到项目中，需要加入请调用 addJob
@@ -224,11 +291,7 @@ class Model(object):
         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 +300,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 +342,15 @@ 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):
-        """
-
-        调用仿真
-
-        :params job:  调用仿真时使用的计算方案，不指定将使用算例保存时选中的计算方案
-        :params config:  调用仿真时使用的参数方案，不指定将使用算例保存时选中的参数方案
-        :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
-
-        :return: 返回一个Job实例
-
-        >>> job=model.run(job,config,'')
-        job
-
-        """
-        if job is None:
-            currentJob = self.context["currentJob"]
-            job = self.jobs[currentJob]
-        if config is None:
-            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
-        )
+  
+    
 
+ 
     def iesSimulationRun(self, job=None, config=None, name=None, **kwargs):
         return self.run(job=job, config=config, name=name, kwargs=kwargs)
 
@@ -389,9 +392,6 @@ class Model(object):
         IO.dump(model, file, format, compress)
 
     def save(self, key=None):
-        return asyncio.run(self.saveAsync(key))
-
-    async def saveAsync(self, key=None):
         """
         保存/创建项目
 
@@ -399,7 +399,6 @@ class Model(object):
         key 为空时如果项目 rid 不存在则抛异常，需要重新设置 key。
         如果保存时，当前用户不是该项目的拥有者时，将重新创建项目，重建项目时如果参数的 key 为空将使用当前当前项目的 key 作为资源的 key ，当资源的 key 和远程冲突时保存失败
 
-        :params: model 项目
         :params: key 资源 id 的唯一标识符，
 
         :return: 保存成功/保存失败
@@ -415,9 +414,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 +427,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 +456,13 @@ 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)
+        revision = ModelRevision.create(model.revision, model.revision.hash)
 
-        return await graphql_fetch(
-            modelQuery,
+        return graphql_request(
+            Model.__create_model,
             {
                 "a": {
                     "rid": model.rid,
@@ -492,12 +482,10 @@ class Model(object):
             },
         )
 
-    @staticmethod
-    def update(model):
-        return asyncio.run(Model.updateAsync(model))
+    
 
     @staticmethod
-    async def updateAsync(model):
+    def update(model):
         """
         更新项目
 
@@ -517,24 +505,20 @@ 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)
+        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
 
-        return await graphql_fetch(
-            modelQuery,
+        return graphql_request(
+            Model.__update_model,
             {
                 "a": {
                     "rid": model.rid,
@@ -554,6 +538,8 @@ class Model(object):
             },
         )
 
+
+    
     def fetchTopology(
         self,
         implementType=None,
@@ -582,123 +568,133 @@ class Model(object):
                 config = self.configs[currentConfig]
             return self.revision.fetchTopology(implementType, config, maximumDepth)
         return None
+    
+    def run(self, job=None, config=None, name=None, policy=None,stop_on_entry=None, **kwargs)-> Job[View]:
+        
+        """
+
+            运行仿真任务 
+
+            :params job:  调用仿真时使用的计算方案，不指定将使用算例保存时选中的计算方案
+            :params config:  调用仿真时使用的参数方案，不指定将使用算例保存时选中的参数方案
+            :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
+
+            :return: 返回一个运行实例
+
+            >>> runner=model.run(job,config,'')
+            runner
 
-    def runEMT(self, job=None, config=None) -> Job:
         """
-        运行 emtp 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
+        if job is None:
+            currentJob = self.context["currentJob"]
+            job = self.jobs[currentJob]
+        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[EMTView]:
+        """
+        运行 emtp 内核，如果当前 model 没有创建  Job 时报错，默认使用算例中选中的计算方案进行仿真，如果选中的计算方案不是 EMT 方案则选第一个EMT 计算方案，如果不存在计算方案则直接报错。
 
         :param: job 计算方案名称，可选，字符串类型或者字典类型,默认使用第一个计算方案，如果同名使用最靠前一个
         :param: config 参数方案，可选，字符串类型或者字典类型,默认使用保存时选中的参数方案
 
-        :return: job 运行结果
+        :return: 生成的任务
         """
         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
+            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) -> Job[EMTView]:
         """
         运行 移频电磁暂态 内核，如果当前 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)
 
-    def runPowerFlow(self, job=None, config=None) -> Job:
+    def runPowerFlow(self, job=None, config=None,**kwargs) -> Job[PowerFlowView]:
         """
         运行 潮流 内核，如果当前 model 没有创建  Job 时报错，默认使用第一个计算方案，进行仿真。
 
         :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[PowerFlowView]:
         """
         运行 三相不平衡潮流 内核，如果当前 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[IESView]:
         """
         运行 负荷预测方案 内核，如果当前 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 +704,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[IESView]:
         """
         运行 时序潮流方案 内核，如果当前 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 +722,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[IESView]:
         """
         运行 储能规划方案 内核，如果当前 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 +742,6 @@ 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)
+
+