cloudpss 4.0.2a1__tar.gz → 4.1.1a1__tar.gz

{cloudpss-4.0.2a1 → cloudpss-4.1.1a1}/PKG-INFO

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

{cloudpss-4.0.2a1 → cloudpss-4.1.1a1}/cloudpss/__init__.py

@@ -6,13 +6,13 @@ from .model import Model, ModelRevision, ModelTopology
 from .project import Project
 from .utils import MatlabDataEncoder, DateTimeEncode
 from . import function
-
+from .job import Job
 from .function import FunctionExecution
 from .version import __version__
 __all__ = [
     'setToken', 'Model', 'ModelRevision', 'ModelTopology', 'Runner', 'Result',
     'PowerFlowResult', 'EMTResult', 'MatlabDataEncoder', 'DateTimeEncode',
-    'function', 'Project', 'currentJob', 'IESLabSimulation', 'IESLabPlan','__version__'
+    'function', 'Project', 'currentJob', 'IESLabSimulation', 'IESLabPlan','__version__','Job'
 ]
 
 

{cloudpss-4.0.2a1 → cloudpss-4.1.1a1}/cloudpss/function/functionExecution.py

@@ -163,7 +163,7 @@ class FunctionExecution(object):
         sys.exit(code)
 
     def print(self, data):
-        print(json.dumps(data, cls=MatlabDataEncoder), flush=True)
+        print(json.dumps(data, cls=MatlabDataEncoder)+'\n', flush=True)
 
     def log(self, content, level='info', html=False, key=None):
         '''

{cloudpss-4.0.2a1 → cloudpss-4.1.1a1}/cloudpss/ieslab/IESLabPlan.py

@@ -130,90 +130,3 @@ class IESLabPlan(object):
             :return: Boolean
         '''
         return self.planModel.kill()
-    
-    def createProjectGroup(self, name):
-        '''
-            创建项目组
-
-            :params name: 项目组名称
-
-            :return: 返回一个创建的项目组
-        '''
-
-    @staticmethod
-    def createProjectGroup(group_name, desc=None, createById=None):
-        '''
-            创建项目组
-
-            :params group_name: String 项目组名称 
-            :params desc: String 项目组描述 可选参数
-            :params createById Int 父项目组id  可选参数，如果是从已有项目组导入的项目组，必填此项
-
-            :return: Int 返回创建的项目组id
-        '''
-        try:
-            if createById is None: 
-                isImport = 0
-            else:
-                isImport = 1
-            payload = {
-                'group_name': group_name,
-                'desc': desc,
-                'isImport': isImport,
-                'createById': createById,
-            }
-            r = request(
-                'POST', 'api/ieslab-plan/rest/projectgroup/', data=json.dumps(payload))
-            project = json.loads(r.text)
-            return project.get('id', None)
-        except Exception as e:
-            raise Exception('创建项目组失败')
-
-    @staticmethod  
-    def createProject(name, project_group, start_date, end_date, construction_cycle, desc=None, createById=None):
-        '''
-            创建项目
-
-            :params name: String 项目名称 
-            :params project_group: Int 父项目组id
-            :param start_date: Int 项目开始年限，范围在[1500,3000]之间
-            :param end_date: Int 项目结束年限，范围在项目开始时间之后且不超过五十年
-            :param construction_cycle: Int 项目建设周期(年), 必须小于等于 项目结束年限 - 项目开始年限
-            :params desc: String 项目描述, 可选参数
-            :params createById Int 父项目id, 可选参数, 如果是从已有项目导入的项目，必填此项
-
-            :return: Int 返回创建的项目id
-        '''
-        try:
-            if start_date < 1500 or start_date > 3000:
-                raise Exception('项目开始年限错误，范围在[1500,3000]之间')
-            if end_date < start_date or end_date > start_date + 50:
-                raise Exception('项目结束年限错误，范围在项目开始时间之后且不超过五十年')
-            if construction_cycle > end_date - start_date:
-                raise Exception('项目建设周期错误，必须小于等于 项目结束年限 - 项目开始年限')
-            if createById is None: 
-                payload = {
-                    'name': name,
-                    'project_group': project_group,
-                    'start_date': start_date,
-                    'end_date': end_date,
-                    'construction_cycle': construction_cycle,
-                    'desc': desc
-                }
-            else:
-                payload = {
-                    'name': name,
-                    'project_group': project_group,
-                    'start_date': start_date,
-                    'end_date': end_date,
-                    'construction_cycle': construction_cycle,
-                    'desc': desc,
-                    'createById': createById
-                }
-            r = request(
-                'POST', 'api/ieslab-plan/rest/simu/', data=json.dumps(payload))
-            project = json.loads(r.text)
-            return project.get('id', None)
-        except Exception as e:
-            raise Exception('创建项目失败')
-

cloudpss-4.1.1a1/cloudpss/ieslab/IESLabSimulation.py

@@ -0,0 +1,54 @@
+import json
+from ..utils import request
+from ..model.model import Model
+from .DataManageModel import IESSimulationDataManageModel
+
+
+class IESLabSimulation(object):
+    def __init__(self, project={}):
+        '''
+            初始化
+        '''
+        self.id = project.get('id', None)
+        self.name = project.get('name', None)
+        self.__modelRid = project.get('model', None)
+        self.project_group = project.get('project_group', None)
+        if self.__modelRid is not None:
+            self.model = Model.fetch(self.__modelRid)
+        self.dataManageModel = IESSimulationDataManageModel(self.id)
+
+    @staticmethod
+    def fetch(simulationId):
+        '''
+            获取算例信息
+
+            :params: simulationId string类型，代表数据项的算例id
+
+            :return: IESLabSimulation
+        '''
+        try:
+            r = request(
+                'GET', 'api/ieslab-simulation/rest/simu/{0}/'.format(simulationId))
+            project = json.loads(r.text)
+            print(project)
+            return IESLabSimulation(project)
+        except:
+            raise Exception('未查询到当前算例')
+
+    def run(self, job=None, name=None):
+        '''
+            调用仿真 
+
+            :params job:  调用仿真时使用的计算方案，不指定将使用算例保存时选中的计算方案
+            :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
+
+            :return: 返回一个运行实例
+        '''
+        if job is None:
+            currentJob = self.model.context['currentJob']
+            job = self.model.jobs[currentJob]
+
+        job['args']['simulationId'] = self.id
+        print(job)
+        return self.model.run(job, name=name)
+

cloudpss-4.1.1a1/cloudpss/job/__init__.py

@@ -0,0 +1,5 @@
+from .job import Job
+
+__all__ = [
+    'Job'
+]

cloudpss-4.1.1a1/cloudpss/job/job.py

@@ -0,0 +1,240 @@
+import asyncio
+import random
+import re
+import time
+from cloudpss.utils.AsyncIterable import CustomAsyncIterable
+
+from cloudpss.utils.httpAsyncRequest import graphql_fetch
+from .view import getViewClass
+
+from cloudpss.utils.IO import IO
+from .messageStreamReceiver import MessageStreamReceiver
+
+from cloudpss.utils.graphqlUtil import graphql_request
+from .jobPolicy import JobPolicy
+from .jobMachine import JobMachine
+from .messageStreamSender import MessageStreamSender
+
+
+class Job(object):
+    """docstring for Job"""
+
+    def __init__(
+        self,
+        id,
+        args,
+        createTime,
+        startTime,
+        endTime,
+        status,
+        context,
+        user,
+        priority,
+        policy,
+        machine,
+        input,
+        output,
+        position,
+    ):
+        super(Job, self).__init__()
+        self.id = id
+        self.args = args
+        self.createTime = createTime
+        self.startTime = startTime
+        self.endTime = endTime
+        self.job_status = status #这里的status字段与原本的status()冲突
+        self.context = context
+        self.user = user
+        self.priority = priority
+        self.policy = policy  # type: ignore
+        self.machine = JobMachine(**machine)  # type: ignore
+        self.input = input
+        self.output = output
+        self.position = position
+        self.__receiver = None
+        self.__sender = None
+        self._result = None
+
+    @staticmethod
+    async def fetch(id):
+        """
+        获取job信息
+        """
+        if id is None:
+            raise Exception("id is None")
+        query = """query($_a:JobInput!){
+            job(input:$_a){
+                id
+                args
+                createTime
+                startTime
+                endTime
+                status
+                context
+                user
+                priority
+                policy  { 
+                    name
+                    queue
+                    tres {
+                        cpu
+                        ecpu
+                        mem
+                    } 
+                    priority 
+                    maxDuration 
+                }
+                machine {
+                    id
+                    name
+                    tres {
+                        cpu
+                        ecpu
+                        mem
+                    }
+                }
+                input
+                output
+                position
+            }
+        }"""
+        variables = {"_a": {"id": id}}
+
+        r = await graphql_fetch(query, 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,'')
+        """
+
+        # 处理policy字段
+        if policy is None:
+            policy = {}
+            if policy.get("tres", None) is None:
+                policy["tres"] = {}
+            policy["queue"] = job["args"].get("@queue", 1)
+            policy["priority"] = job["args"].get("@priority", 0)
+            tres = {"cpu": 1, "ecpu": 0, "mem": 0}
+            tresStr = job["args"].get("@tres", "")
+            for t in re.split("\s+", tresStr):
+                if t == "":
+                    continue
+                k, v = t.split("=")
+                tres[k] = float(v)  # type: ignore
+            policy["tres"] = tres
+
+        query = """mutation($input:CreateJobInput!){job:createJob(input:$input){id input output status position}}"""
+        function = job["rid"].replace("job-definition/cloudpss/", "function/CloudPSS/")
+        variables = {
+            "input": {
+                "args": {
+                    **job["args"],
+                    "_ModelRevision": revisionHash,
+                    "_ModelArgs": config["args"],
+                },
+                "context": [
+                    function,
+                    rid,
+                    f"model/@sdk/{str(int(time.time() * random.random()))}",
+                ],
+                "policy": policy,
+            }
+        }
+        r = await graphql_fetch(query, 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_fetch(query, variables)
+
+    @staticmethod
+    def load(file, format="yaml"):
+        return IO.load(file, format)
+
+    @staticmethod
+    def dump(job, file, format="yaml", compress="gzip"):
+        return IO.dump(job, file, format, compress)
+
+    async def read(self, receiver=None, dev=False, **kwargs):
+        """
+        使用接收器获取当前运行实例的输出
+        """
+        if receiver is not None:
+            self.__sender = receiver
+        if self.__receiver is None:
+            self.__receiver = MessageStreamReceiver(self, dev)
+        await self.__receiver.connect(**kwargs)
+        return self.__receiver
+
+    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
+    
+    def status(self):
+        if self.__receiver is not None:
+            return self.__receiver.status
+        return 0
+
+    @property
+    def result(self):
+        """
+        获取当前运行实例的输出
+        """
+        if self._result is None:
+            viewType = getViewClass(self.context[0])
+            self._result = asyncio.run(self.view(viewType))
+        return self._result
+
+    async def view(self, viewType):
+        """
+        获取当前运行实例的输出
+        """
+        receiver = await self.read()
+        sender = await self.write()
+        return viewType(receiver, sender)

cloudpss-4.1.1a1/cloudpss/job/jobMachine.py

@@ -0,0 +1,11 @@
+from cloudpss.job.jobTres import JobTres
+
+
+class JobMachine(object):
+    '''job machine'''
+
+    def __init__(self, id, name, tres, valid=None):
+        self.id = id
+        self.name = name
+        self.tres = JobTres(**tres)  # type: ignore
+        self.valid = valid

cloudpss-4.1.1a1/cloudpss/job/jobPolicy.py

@@ -0,0 +1,129 @@
+from cloudpss.job.jobQueue import JobQueue
+from cloudpss.job.jobTres import JobTres
+from cloudpss.utils.graphqlUtil import graphql_request
+
+
+class JobPolicy(object):
+
+    def __init__(self, id, name, users, functions, tres, minPriority,
+                 maxPriority, maxDuration, createTime, updateTime, visibility,
+                 queue):
+        self.id = id
+        self.name = name
+        self.users = users
+        self.functions = functions
+        print(tres)
+        self.tres = []
+        for tre in tres:
+            self.tres.append(JobTres(**tre))  # type: ignore
+        self.minPriority = minPriority
+        self.maxPriority = maxPriority
+        self.maxDuration = maxDuration
+        self.createTime = createTime
+        self.updateTime = updateTime
+        self.visibility = visibility
+        self.queue = JobQueue(**queue)  # type: ignore
+
+    @staticmethod
+    def fetch(id):
+        query = '''query($input:JobPolicyInput!)
+            {
+                jobPolicy(input:$input)
+                {
+                    id 
+                    name 
+                    users 
+                    functions 
+                    tres {
+                        cpu
+                        ecpu
+                        mem
+                    } 
+                    minPriority 
+                    maxPriority 
+                    maxDuration 
+                    createTime 
+                    updateTime 
+                    visibility 
+                    queue {
+                        id
+                        name
+                        scheduler
+                        machines {
+                            id
+                            name
+                            tres {
+                                cpu
+                                ecpu
+                                mem
+                            }
+                            valid
+                        }
+                        createTime
+                        updateTime
+                        load
+                    }
+                }
+                
+            }'''
+        variables = {'input': {'id': id}}
+        r = graphql_request(query, variables)
+        print (r)
+        if 'errors' in r:
+            raise Exception(r['errors'])
+        return JobPolicy(**r['data']['jobPolicy'])
+
+    @staticmethod
+    def fetchMany(input):
+        query = '''query($input:JobPoliciesInput!)
+            {
+                jobPolicies(input:$input)
+                {
+                    items {
+                        id 
+                        name 
+                        users 
+                        functions 
+                        tres {
+                            cpu
+                            ecpu
+                            mem
+                        } 
+                        minPriority 
+                        maxPriority 
+                        maxDuration 
+                        createTime 
+                        updateTime 
+                        visibility 
+                        queue {
+                            id
+                            name
+                            scheduler
+                            machines {
+                                id
+                                name
+                                tres {
+                                    cpu
+                                    ecpu
+                                    mem
+                                }
+                                valid
+                            }
+                            createTime
+                            updateTime
+                            load
+                        }
+                    }
+                    cursor
+                    count
+                    total
+                }
+            }'''
+        variables = {'input': input}
+        r = graphql_request(query, variables)
+        if 'errors' in r:
+            raise Exception(r['errors'])
+        policies = []
+        for policy in r['data']['jobPolicies']['items']:
+            policies.append(JobPolicy(**policy))
+        return policies

cloudpss-4.1.1a1/cloudpss/job/jobQueue.py

@@ -0,0 +1,14 @@
+from cloudpss.job.jobMachine import JobMachine
+
+
+class JobQueue(object):
+
+    def __init__(self, id, name, scheduler, machines, createTime, updateTime,
+                 load):
+        self.id = id
+        self.name = name
+        self.scheduler = scheduler
+        self.machines = [JobMachine(**m) for m in machines]
+        self.createTime = createTime
+        self.updateTime = updateTime
+        self.load = load

cloudpss-4.1.1a1/cloudpss/job/jobReceiver.py

@@ -0,0 +1,33 @@
+class JobReceiver(object):
+    messages = []
+    index = 0
+
+    def __init__(self):
+        self.index = 0
+        self.messages = []
+
+    def __len__(self):
+        return len(self.messages)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        maxLength = len(self.messages)
+        if self.index < maxLength:
+            message = self.messages[self.index]
+            self.index += 1
+            return message
+        raise StopIteration()
+
+    def view(self, ViewType):
+        """
+            获取指定类型的视图数据
+
+            :params viewType: 视图类型
+
+            :returns: 对应类型的视图数据
+
+            >>> view= receiver.view(EMTView)
+        """
+        return ViewType(self)

cloudpss-4.1.1a1/cloudpss/job/jobTres.py

@@ -0,0 +1,6 @@
+class JobTres(object):
+    '''tres'''
+    def __init__(self, cpu, mem, ecpu):
+        self.cpu = cpu
+        self.mem = mem
+        self.ecpu = ecpu