cloudpss 4.1.1b8__tar.gz → 4.5.13__tar.gz

{cloudpss-4.1.1b8 → cloudpss-4.5.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudpss
-Version: 4.1.1b8
+Version: 4.5.13
 Summary: cloudpss sdk
 Home-page: https://www.cloudpss.net
 Author: cloudpss

{cloudpss-4.1.1b8 → cloudpss-4.5.13}/cloudpss/__init__.py

@@ -1,5 +1,5 @@
 # coding=UTF-8
-from cloudpss.ieslab import IESLabSimulation, IESLabPlan
+from cloudpss.ieslab import IESLabSimulation, IESLabPlan, IESLabOpt
 from .verify import setToken
 from .runner import Runner, Result, EMTResult, PowerFlowResult
 from .model import Model, ModelRevision, ModelTopology
@@ -9,11 +9,10 @@ from . import function
 from .job import Job
 from .function import FunctionExecution
 from .version import __version__
-from .dslab import DSLab
 __all__ = [
     'setToken', 'Model', 'ModelRevision', 'ModelTopology', 'Runner', 'Result',
     'PowerFlowResult', 'EMTResult', 'MatlabDataEncoder', 'DateTimeEncode',
-    'function', 'Project', 'currentJob', 'IESLabSimulation', 'IESLabPlan','__version__','Job','DSLab'
+    'function', 'Project', 'currentJob', 'IESLabSimulation', 'IESLabPlan','IESLabOpt','__version__','Job'
 ]
 
 

cloudpss-4.5.13/cloudpss/asyncio/__init__.py

@@ -0,0 +1,8 @@
+# coding=UTF-8
+from .model import Model, ModelRevision, ModelTopology
+from .job import Job
+from ..verify import setToken
+__all__ = [
+   'Model', 'ModelRevision', 'ModelTopology','Job','setToken'
+]
+

cloudpss-4.5.13/cloudpss/asyncio/job/job.py

@@ -0,0 +1,116 @@
+from cloudpss.asyncio.job.messageStreamReceiver import MessageStreamReceiver
+from cloudpss.asyncio.job.messageStreamSender import MessageStreamSender
+from cloudpss.asyncio.utils.AsyncIterable import CustomAsyncIterable
+from cloudpss.asyncio.utils.httpAsyncRequest import graphql_request
+from cloudpss.job import Job as JobBase
+from typing import Any, Callable, TypeVar
+F = TypeVar('F', bound=Callable[..., Any])
+
+class Job(JobBase):
+    
+    @staticmethod
+    async def fetch(id):
+        """
+        获取job信息
+        """
+        if id is None:
+            raise Exception("id is None")
+       
+        variables = {"_a": {"id": id}}
+
+        r = await graphql_request(Job.__jobQuery, variables)
+        if "errors" in r:
+            raise Exception(r["errors"])
+        return Job(**r["data"]["job"])
+    
+    @staticmethod
+    def fetchMany(*args):
+        """
+        批量获取任务信息
+        """
+        jobs = CustomAsyncIterable(Job.fetch,*args)
+        return jobs
+    
+    
+    @staticmethod
+    async def create(revisionHash, job, config, name=None, rid="", policy=None, **kwargs):
+        """
+        创建一个运行任务
+
+        :params: revision 项目版本号
+        :params: job 调用仿真时使用的计算方案，为空时使用项目的第一个计算方案
+        :params: config 调用仿真时使用的参数方案，为空时使用项目的第一个参数方案
+        :params: name 任务名称，为空时使用项目的参数方案名称和计算方案名称
+        :params: rid 项目rid，可为空
+
+        :return: 返回一个运行实例
+
+        >>> runner = Runner.runRevision(revision,job,config,'')
+        """
+        
+        variables=Job.__createJobVariables(job, config, revisionHash, rid, policy)
+        r = await graphql_request(Job.__createJobQuery, variables)
+        if "errors" in r:
+            raise Exception(r["errors"])
+        id = r["data"]["job"]["id"]
+        return await Job.fetch(id)
+    
+    
+    @staticmethod
+    async def abort(id, timeout):
+        """
+        结束当前运行的算例
+
+        """
+        query = """mutation ($input: AbortJobInput!) {
+            job: abortJob(input: $input) {
+                id
+                status
+            }
+        }
+        """
+        variables = {"input": {"id": id, "timeout": timeout}}
+        await graphql_request(query, variables)
+        
+    async def result(self, resultType:F)->F:
+        """
+        获取当前运行实例的输出
+        """
+        receiver = await self.read()
+        sender = await self.write()
+        self._result= resultType(receiver, sender)
+        return self._result
+    
+    async def write(self, sender=None, dev=False, **kwargs) -> MessageStreamSender:
+        """
+        使用发送器为当前运行实例输入
+        """
+
+        if sender is not None:
+            self.__sender = sender
+        if self.__sender is None:
+            self.__sender = MessageStreamSender(self, dev)
+        await self.__sender.connect(**kwargs)
+        return self.__sender
+    
+    async def read(self, receiver=None, dev=False, **kwargs)-> MessageStreamReceiver:
+        """
+        使用接收器获取当前运行实例的输出
+        """
+        if receiver is not None:
+            self.__receiver = receiver
+        if self.__receiver is None:
+            self.__receiver = MessageStreamReceiver(self, dev)
+        await self.__receiver.connect(**kwargs)
+        return self.__receiver
+    
+    async def status(self):
+        """
+        return: 0: 运行中 1: 运行完成 2: 运行失败
+        """
+        if self.__receiver is not None:
+            return await self.__receiver.status
+        # if self.__receiver is None:
+        #     self.__connect()
+        # return 0
+        return 0

cloudpss-4.5.13/cloudpss/asyncio/job/messageStreamReceiver.py

@@ -0,0 +1,121 @@
+import logging
+import os
+from urllib.parse import urlparse
+
+from aiohttp import ClientSession, WSMsgType
+from cloudpss.asyncio.utils.httpAsyncRequest import websocket_connect
+from cloudpss.job.jobReceiver import JobReceiver
+from cloudpss.utils.IO import IO
+
+
+class MessageStreamReceiver(JobReceiver):
+    def __init__(self, job, dev=False):
+        super().__init__()
+        self.job = job
+        self.dev = dev
+        self.origin = os.environ.get("CLOUDPSS_API_URL", "https://cloudpss.net/")
+        
+    async def __receive(self):
+        """
+            读取消息流中的数据
+        """
+        msg = await self.ws.receive()
+        result=None
+        if msg.type == WSMsgType.BINARY:
+           result=await self.__on_message(msg.data)
+        if msg.type == WSMsgType.TEXT:
+            result=await self.__on_message(msg.data)
+        elif msg.type == WSMsgType.CLOSE:
+            self.__on_close(msg)
+        elif msg.type == WSMsgType.CLOSED:
+           await self.__on_closed()
+        elif msg.type == WSMsgType.ERROR:
+            self.__on_error(msg.data)
+        return result
+    
+    def __aiter__(self):
+        return self
+    
+    async def __anext__(self):
+        result = await self.__receive()
+        if result is None:
+            raise StopAsyncIteration
+        return result     
+        
+    def __on_close(self, msg,*args, **kwargs):
+        if msg is not None and msg.startswith("CMS_NO_STREAM_ID:"):
+            self._status = 1
+            msg = {
+                "type": "log",
+                "version": 1,
+                "data": {
+                    "level": "critical",
+                    "content": "未找到任务的输出流，运行结果可能已被清理。",
+                },
+            }
+            self.messages.append(msg)
+            return
+            
+    async def __on_closed(self, *args, **kwargs):
+        logging.debug("MessageStreamReceiver close")
+        self._status = 1
+        msg = {
+            "type": "log",
+            "verb": "create",
+            "version": 1,
+            "data": {
+                "level": "info",
+                "content": "websocket closed",
+            },
+        }
+        self.messages.append(msg)
+        await self.session.close()
+        
+    async def __on_message(self, message):
+        
+        data = IO.deserialize(message, "ubjson")
+        msg = IO.deserialize(data["data"], "ubjson")
+        self.messages.append(msg)
+        # print(msg['type'])
+        if(msg['type']=='terminate'):
+            await self.close(self.ws)
+        return msg
+    
+    def __on_error(self, msg,*args, **kwargs):
+        logging.debug("MessageStreamReceiver error")
+        msg = {
+            "type": "log",
+            "verb": "create",
+            "version": 1,
+            "data": {
+                "level": "error",
+                "content": "websocket error",
+            },
+        }
+        self.messages.append(msg)
+        
+    @property
+    async def status(self):
+        await self.__receive()
+        return self._status
+    
+    async def close(self, ws):
+        self._status = 1
+        await ws.close()
+        
+    async def connect(self,**kwargs):
+        self._status = 0
+        
+        if self.job.output is None:
+            raise Exception("id is None")
+        u = list(urlparse(self.origin))
+        head = "wss" if u[0] == "https" else "ws"
+
+        path = head + "://" + str(u[1]) + "/api/streams/id/" + self.job.output
+        from_=kwargs.get("from",None)
+        if from_ is not None:
+            path = path + "&from=" + str(from_)
+        logging.info(f"MessageStreamReceiver data from websocket: {path}")
+        
+        self.session=  ClientSession()
+        self.ws=  await self.session.ws_connect(path)

cloudpss-4.5.13/cloudpss/asyncio/job/messageStreamSender.py

@@ -0,0 +1,45 @@
+
+import logging
+from typing import IO
+from urllib.parse import urlparse
+import aiohttp
+from cloudpss.job.messageStreamSender import MessageStreamSender as MessageStreamSenderBase
+
+
+class MessageStreamSender(MessageStreamSenderBase):
+    
+    
+    async def receive_data(self):
+        if self.websocket:
+            data = await self.websocket.receive()
+            if data.type == aiohttp.WSMsgType.TEXT:
+                self.__on_message(data.data)
+            elif data.type == aiohttp.WSMsgType.CLOSED:
+                self.__on_close()
+            elif data.type == aiohttp.WSMsgType.ERROR:
+                self.__on_error(data.data)
+        else:
+            logging.info("WebSocket connection not established")
+    
+    async def connect(self):
+        self._status = 0
+        if self.job.input is None:
+            raise Exception("id is None")
+        if self.job.input == "00000000-0000-0000-0000-000000000000":
+            return
+        u = list(urlparse(self.origin))
+        head = "wss" if u[0] == "https" else "ws"
+
+        path = head + "://" + str(u[1]) + "/api/streams/token/" + self.job.input
+        logging.info(f"MessageStreamSender data from websocket: {path}")
+        async with aiohttp.ClientSession() as session:
+            self.websocket = await session.ws_connect(path)
+            
+    async def write(self, message):
+        if self.websocket:
+            data = IO.serialize(message, "ubjson", None)
+            await self.websocket.send_bytes(data)
+        else:
+            logging.info("websocket is None")
+
+    

cloudpss-4.5.13/cloudpss/asyncio/model/model.py

@@ -0,0 +1,257 @@
+import os
+import re
+from cloudpss.asyncio.job.job import Job
+from cloudpss.asyncio.model.revision import ModelRevision
+from cloudpss.asyncio.utils.httpAsyncRequest import graphql_request
+from cloudpss.model.model import Model as ModelBase
+from cloudpss.verify import userName
+
+
+class Model(ModelBase):
+    
+    def __init__(self, model: dict = {}):
+        """
+        项目初始化
+        """
+        for k, v in model.items():
+            if k == "revision":
+                if "version" in v and v["version"] < 5:
+                    self.revision = ModelRevision(v)
+                else:
+                    raise Exception(
+                        "当前SDK版本（ver 3.X.X）不兼容该项目文件，请先升级项目文件。具体方法：将该项目文件导入至XStudio 3.X.X平台后重新保存至本地后即可。"
+                    )
+
+            else:
+                self.__dict__[k] = v
+    @staticmethod
+    async def fetch(rid):
+        """
+        获取项目
+
+        :params rid:  项目 rid
+
+        :return: 返回一个项目实例
+
+        >>> model=Model.fetch('model/Demo/test')
+
+        """
+        data = await graphql_request(Model.__model_query, {"rid": rid})
+        if "errors" in data:
+            raise Exception(data["errors"][0]["message"])
+        return Model(data["data"]["model"])
+
+    async def save(self, key=None):
+        """
+        保存/创建项目
+
+        key 不为空时如果远程存在相同的资源名称时将覆盖远程项目。
+        key 为空时如果项目 rid 不存在则抛异常，需要重新设置 key。
+        如果保存时，当前用户不是该项目的拥有者时，将重新创建项目，重建项目时如果参数的 key 为空将使用当前当前项目的 key 作为资源的 key ，当资源的 key 和远程冲突时保存失败
+
+        :params: model 项目
+        :params: key 资源 id 的唯一标识符，
+
+        :return: 保存成功/保存失败
+
+        >>> model.save(model)
+            model.save(model,'newKey') # 另存为新的项目
+
+        """
+        username = userName()
+
+        if key is not None:
+            matchObj = re.match(r"^[-_A-Za-z0-9]+$", key, re.I | re.S)
+            if matchObj:
+                self.rid = "model/" + username + "/" + key
+                try:
+                    return await Model.update(self)
+                except:
+                    return await Model.create(self)
+            else:
+                raise Exception("key 能包含字母数子和下划线")
+        else:
+            t = "(?<=/)\\S+(?=/)"
+            owner = re.search(t, self.rid)
+            if owner is None:
+                raise Exception("rid 错误，请传入 key")
+            elif owner[0] != username:
+                rid = re.sub(t, username, self.rid)
+                try:
+                    return await Model.create(self)
+                except:
+                    raise Exception(rid + " 该资源已存在，无法重复创建,请修改 key")
+
+        return await Model.update(self)
+
+    @staticmethod
+    async def fetchMany(name=None, cursor=[]):
+        """
+        获取用户可以运行的项目列表
+
+        :params name:  查询名称，模糊查询
+        :params cursor:  游标
+
+        :return: 按分页信息返回项目列表
+
+        >>> data= await Model.fetchMany()
+        {
+            items: [
+                {'rid': 'model/admin/share-test', 'name': '1234', 'description': '1234'}
+                ...
+            ],
+            cursor: ["1699353593000"],
+
+        }
+
+
+        """
+        variables = {
+            "cursor": cursor,
+            "limit": 10,
+            "orderBy": ["updatedAt<"],
+            "permissionEveryone": ["b_any", 2**16],
+        }
+        if name is not None:
+            variables["_search"] = name
+
+        data = await graphql_request(Model.__models_query, {"input": variables})
+
+        if "errors" in data:
+            raise Exception(data["errors"][0]["message"])
+
+        return data["data"]["models"]
+
+
+    @staticmethod
+    async def create(model):
+        """
+        新建项目
+
+        :params: model 项目
+
+        :return: 保存成功/保存失败
+
+        >>> Model.create(model)
+        保存成功
+        """
+        # Model.update(model)
+        t = "(?<=/)\\S+(?=/)"
+        username = userName()
+        owner = re.search(t, model.rid)
+
+        if owner is None:
+            raise Exception("rid 错误，无法保存")
+        elif owner[0] != username:
+            raise Exception("rid 错误，无法保存")
+
+        isPublic = model.context.get("auth", "") != "private"
+        publicRead = model.context.get("publicRead", "") != False
+        auth = (65539 if publicRead else 65537) if isPublic else 0
+        revision = await ModelRevision.create(model.revision, model.revision.hash)
+
+        return await graphql_request(
+            Model.__models_query,
+            {
+                "a": {
+                    "rid": model.rid,
+                    "revision": revision["hash"],
+                    "context": model.context,
+                    "configs": model.configs,
+                    "jobs": model.jobs,
+                    "name": model.name,
+                    "description": model.description,
+                    "tags": model.tags,
+                    "permissions": {
+                        "moderator": 1,
+                        "member": 1,
+                        "everyone": auth,
+                    },
+                }
+            },
+        )
+        
+        
+    @staticmethod
+    async def update(model):
+        """
+        更新项目
+
+        :params: model 项目
+
+        :return: 保存成功/保存失败
+
+        >>> Model.update(model)
+        """
+
+        t = "(?<=/)\\S+(?=/)"
+        username = userName()
+        owner = re.search(t, model.rid)
+
+        if owner is None:
+            raise Exception("rid 错误，无法保存")
+        elif owner[0] != username:
+            raise Exception("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.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_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": {
+                        "moderator": 1,
+                        "member": 1,
+                        "everyone": auth,
+                    },
+                }
+            },
+        )
+
+    async def run(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
+        )

cloudpss-4.5.13/cloudpss/asyncio/model/revision.py

@@ -0,0 +1,41 @@
+from cloudpss.asyncio.utils.httpAsyncRequest import graphql_request
+from cloudpss.model.revision import ModelRevision as ModelRevisionBase
+
+
+class ModelRevision(ModelRevisionBase):
+    
+    @staticmethod
+    async def create(revision, parentHash=None):
+        """
+            创建一个新版本
+
+            :params: revision 版本数据
+
+            :return: 项目版本hash
+
+            >>> ModelRevision.create(model.revision)
+            {hash:'4043acbddb9ce0c6174be65573c0380415bc48186c74a459f88865313743230c'}
+        """
+
+        r = revision.toJSON()
+        del r['hash']
+        variables = {'a': {**r, 'parent': parentHash}}
+        r = await graphql_request(ModelRevision.__createModelRevisionQuery, variables)
+        if 'errors' in r:
+            raise Exception(r['errors'])
+        return r['data']['createModelRevision']
+    
+    async def run(self, job, config, name=None, rid='', policy=None, **kwargs):
+        """
+            运行某个指定版本的项目
+
+            :params job:  调用仿真时使用的计算方案，为空时使用项目的第一个计算方案
+            :params config:  调用仿真时使用的参数方案，为空时使用项目的第一个参数方案
+            :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
+            :params rid:  项目rid，可为空
+
+            :return: 返回一个ModelRevision
+
+            >>> revision.run(revision,job,config,'')
+        """
+        return await ModelRevision.create(self)

cloudpss-4.5.13/cloudpss/asyncio/model/topology.py

@@ -0,0 +1,34 @@
+from cloudpss.asyncio.utils.httpAsyncRequest import graphql_request
+from cloudpss.model.topology import ModelTopology as ModelTopologyBase
+
+
+class ModelTopology(ModelTopologyBase):
+    @staticmethod
+    async def fetch(hash, implementType, config, maximumDepth=None):
+        """
+            获取拓扑
+
+            :params: hash 
+            :params: implementType 实现类型
+            :params: config 参数方案
+            :params: maximumDepth 最大递归深度，用于自定义项目中使用 diagram 实现元件展开情况
+
+            : return: 拓扑实例
+
+            >>> data = ModelTopology.fetch('','emtp',{})
+
+        """
+        args = {} if config is None else config['args']
+        variables = {
+            "a": {
+                'hash': hash,
+                'args': args,
+                'acceptImplementType': implementType,
+                'maximumDepth': maximumDepth
+            }
+        }
+        data = await graphql_request(ModelTopology.__modelTopologyQuery, variables)
+        if 'errors' in data:
+            raise Exception(data['errors'][0]['message'])
+
+        return ModelTopology(data['data']['modelTopology'])

cloudpss-4.5.13/cloudpss/asyncio/utils/__init__.py

@@ -0,0 +1,6 @@
+
+from .httpAsyncRequest import graphql_request
+
+__all__ = [
+    'graphql_request'
+]

{cloudpss-4.1.1b8/cloudpss → cloudpss-4.5.13/cloudpss/asyncio}/utils/httpAsyncRequest.py

@@ -3,7 +3,7 @@ import os
 from aiohttp import ClientSession, WSMsgType
 from urllib.parse import urljoin
 import logging
-from ..version import __version__
+from ...version import __version__
 
 
 def graphql_version_check(uri, response):
@@ -54,7 +54,7 @@ async def fetch_data(method: str, uri, data, baseUrl=None, params={}, **kwargs):
 
 
 # graphql实现方法
-async def graphql_fetch(query, variables=None):
+async def graphql_request(query, variables=None):
     payload = {"query": query, "variables": variables}
     return await fetch_data("POST", "graphql", data=json.dumps(payload))