cloudpss 4.0.0a7__py3-none-any.whl → 4.0.2__py3-none-any.whl

cloudpss/dslab/dataManageModel.py

@@ -182,16 +182,16 @@ class DataManageModel(object):
                     })
         return json.loads(r.text)
     
-    def AddDataItem(self, kind, data):
+    def AddDataItem(self, kind, data, extra=None):
         '''
             向kind类型的数据库中添加内容为data的数据项
             :params: kind str类型，数据的种类标识，包含：光伏、风机、燃气、水电、常规小火电、生物质发电、垃圾电厂、传输线、变压器、开关、负荷分类、负荷用户、储能配置、上网电价、输配电价、常数电价、阶梯电价、分时电价、分时阶梯电价
             :params: data dict类型，表示添加的数据内容，其数据结构应满足对应数据项的结构要求
+            :params extra list类型，表示添加的基准出力曲线、负荷曲线、策略曲线数据
     
             :return: list<dict>类型，返回该种类下所有数据项的列表
         '''
         assert (kind in self._kindUrlMap), "数据类型不存在"
-        extra = data.get('extra')
         if extra is None or not extra:
             extra = getCurveData(kind)
             r = {
@@ -255,6 +255,17 @@ class DataManageModel(object):
         assert (kind in self._kindUrlMap), "数据类型不存在"
         url = f"{self._baseUri}rest/{kind}"
         return self._fetchItemData(url)
+    
+    def GetItemExtra(self, kind, uuid):
+        '''
+            获取kind类型对应数据项的基准出力曲线、负荷曲线、策略曲线数据
+            :params: kind str类型，数据的类型
+            :params: uuid str类型，数据的unique id
+        '''
+        assert (kind in self._kindUrlMap), "数据类型不存在"
+        url = f"{self._baseUri}rest/id/{uuid}"
+        data = self._fetchItemData(url)
+        return data.get('extra', None).get('data', None)
 
 class DSLabDataManageModel(DataManageModel):
     _baseUri = 'api/ies/'

cloudpss/dslab/dslab.py

@@ -143,3 +143,68 @@ class DSLab(object):
             raise Exception("不是储能规划方案内核运行生成算法的计算方案")
         return self.run(job=job, name=name)
 
+    @staticmethod
+    def createProjectGroup(name, description=None, createById=None):
+        '''
+            创建项目组
+
+            :params name: String 项目组名称 
+            :params description: String 项目组描述 可选参数
+            :params createById Int 父项目组id  可选参数，如果是从已有项目组导入的项目组，必填此项
+
+            :return: Int 返回创建的项目组id
+        '''
+        try:
+            if createById is None: 
+                isImport = 0
+            else:
+                isImport = 1
+            payload = {
+                'name': name,
+                'description': description,
+                'isImport': isImport,
+                'createById': createById,
+            }
+            r = request(
+                'POST', 'api/ies/rest/group', data=json.dumps(payload))
+            if r.ok:
+                r = request('GET', 'api/ies/rest/group')
+                groupList = json.loads(r.text)
+                id = groupList[len(groupList) -1].get('id', None)
+                return id
+        except Exception as e:
+            raise Exception('创建项目组失败')
+        
+    @staticmethod
+    def createProject(name, gid, description=None, initialTerm=None, build=None, operate=None, yearsInOperation=None):
+        '''
+            创建项目
+
+            :params name: String 项目名称 
+            :params gid: Int 父项目组id,
+            :params description: String 项目描述, 可选参数
+            :params initialTerm: String 项目起始年限，可选参数
+            :params build: String 项目建设期（年），可选参数
+            :params operate: String 项目生命周期（年），可选参数
+            :params yearsInOperation: String 已投运年限，可选参数
+
+            :return: Int 返回创建的项目id
+        '''
+        try:
+            payload = {
+                'name': name,
+                'gid': gid,
+                'description': description,
+                'config': {
+                    'initialTerm': initialTerm,
+                    'build': build,
+                    'operate': operate,
+                    'yearsInOperation': yearsInOperation,
+                }
+            }
+            r = request(
+                'POST', 'api/ies/rest/simulation', data=json.dumps(payload))
+            project = json.loads(r.text)
+            return project.get('resource', None)
+        except Exception as e:
+            raise Exception('创建项目失败')

cloudpss/job/__init__.py

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

cloudpss/job/job.py

@@ -0,0 +1,277 @@
+import random
+import re
+import time
+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.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
+
+    @staticmethod
+    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 = graphql_request(query, variables)
+        if 'errors' in r:
+            raise Exception(r['errors'])
+        return Job(**r['data']['job'])
+
+    @staticmethod
+    def fetchMany(input):
+        """
+        批量获取任务信息
+        """
+        if input is None:
+            raise Exception('input is None')
+        query = '''query($_a:JobsInput!){
+            jobs(input:$_a){
+                item {
+                    id
+                    args
+                    createTime
+                    startTime
+                    endTime
+                    status
+                    context
+                    user
+                    priority
+                    policy  {
+                        id 
+                        name 
+                        users 
+                        functions 
+                        tres {
+                            cpu
+                            ecpu
+                            mem
+                        } 
+                        minPriority 
+                        maxPriority 
+                        maxDuration 
+                        createTime 
+                        updateTime 
+                        visibility 
+                        queue
+                    }
+                    machine {
+                        id
+                        name
+                        tres {
+                            cpu
+                            ecpu
+                            mem
+                        }
+                        valid
+                    }
+                    input
+                    output
+                    position
+                } 
+                cursor 
+                count 
+                total
+                }
+            }'''
+        variables = {"_a": input}
+        r = graphql_request(query, variables)
+        if 'errors' in r:
+            raise Exception(r['errors'])
+        jobs = []
+        for job in r['data']['jobs']['item']:
+            jobs.append(Job(**job))
+        return jobs
+
+    @staticmethod
+    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 = graphql_request(query, variables)
+        if 'errors' in r:
+            raise Exception(r['errors'])
+        id = r['data']['job']['id']
+        return Job.fetch(id)
+
+    @staticmethod
+    def abort(id, timeout):
+        """
+        结束当前运行的算例
+
+        """
+        query = '''mutation ($input: AbortJobInput!) {
+            job: abortJob(input: $input) {
+                id
+                status
+            }
+        }
+        '''
+        variables = {'input': {'id': id, 'timeout': timeout}}
+        graphql_request(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)
+
+    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)
+        self.__receiver.connect(**kwargs)
+        return self.__receiver
+
+    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)
+        self.__sender.connect(**kwargs)
+        return self.__sender
+    
+    @property
+    def result(self):
+        """
+        获取当前运行实例的输出
+        """
+        viewType = getViewClass(self.context[0])
+        return self.view(viewType)
+
+    def view(self, viewType):
+        """
+        获取当前运行实例的输出
+        """
+        receiver = self.read()
+        sender=self.write()
+        return viewType(receiver,sender)

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/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/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/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/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