cloudpss 4.0.4__py3-none-any.whl → 4.0.5__py3-none-any.whl

cloudpss/asyncio/model/topology.py

@@ -1,34 +0,0 @@
-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/asyncio/utils/AsyncIterable.py

@@ -1,27 +0,0 @@
-import asyncio
-
-
-class CustomAsyncIterable:
-    async def __init__(self, async_func, *args):
-        self.async_func = async_func
-        self.queue = asyncio.Queue()
-        self.index = 0
-        self.args = args
-
-    async def __aiter__(self):
-        return self
-
-    async def __anext__(self):
-        try:
-            result = await self.queue.get()
-            if result is None:
-                raise StopAsyncIteration
-            return result
-        except asyncio.QueueEmpty:
-            tasks = []
-            for arg in self.args:
-                tasks.append(asyncio.create_task(self.async_func(arg)))
-            await asyncio.gather(*tasks)
-            for task in tasks:
-                await self.queue.put(await task)
-            return await self.__anext__()

cloudpss/asyncio/utils/__init__.py

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

cloudpss/asyncio/utils/httpAsyncRequest.py

@@ -1,68 +0,0 @@
-import json
-import os
-from aiohttp import ClientSession, WSMsgType
-from urllib.parse import urljoin
-import logging
-from ...version import __version__
-
-
-def graphql_version_check(uri, response):
-    if uri.startswith("graphql"):
-        if "X-Cloudpss-Version" not in response.headers:
-            raise Exception("当前SDK版本（ver 3.X.X）与服务器版本（3.0.0 以下）不兼容，请更换服务器地址或更换SDK版本。")
-        os.environ["X_CLOUDPSS_VERSION"] = response.headers["X-Cloudpss-Version"]
-        if float(response.headers["X-Cloudpss-Version"]) >= 5:
-            raise Exception(
-                "当前SDK版本（ver "
-                + __version__
-                + "）与服务器版本（ver "
-                + response.headers["X-Cloudpss-Version"]
-                + ".X.X）不兼容，请更换服务器地址或更换SDK版本(pip 使用 pip install -U cloudpss 命令更新, conda 使用 conda update cloudpss 命令更新)。"
-            )
-
-
-### 通过aiohttp实现请求
-async def fetch_data(method: str, uri, data, baseUrl=None, params={}, **kwargs):
-    if baseUrl == None:
-        baseUrl = os.environ.get("CLOUDPSS_API_URL", "https://cloudpss.net/")
-    url = urljoin(baseUrl, uri)
-    token = os.environ.get("CLOUDPSS_TOKEN", None)
-    if token:
-        headers = {
-            "Authorization": "Bearer " + token,
-            "Content-Type": "application/json; charset=utf-8",
-        }
-    else:
-        raise Exception("token undefined")
-    logging.debug("fetch start:",uri)
-    async with ClientSession() as session:
-        async with session.request(
-            method, url, data=data, params=params, headers=headers
-        ) as response:
-            if response.status == 200:
-                data = await response.json()
-                graphql_version_check(uri, response)
-                if "errors" in data:
-                    raise  Exception(data["errors"])
-                return data
-            elif 400 <= response.status < 500:
-                raise Exception(f"请求失败，状态码：{response.status}")
-            elif 500 <= response.status < 600:
-                raise Exception(f"请求失败，状态码：{response.status}")
-            else:
-                return
-
-
-# graphql实现方法
-async def graphql_request(query, variables=None):
-    payload = {"query": query, "variables": variables}
-    return await fetch_data("POST", "graphql", data=json.dumps(payload))
-
-
-# websocket
-async def websocket_connect(url, open_func):
-    async with ClientSession() as session:
-        async with session.ws_connect(url) as ws:
-            open_func(ws)
-            async for msg in ws:
-                yield msg

cloudpss/job/__init__.py

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

cloudpss/job/job.py

@@ -1,260 +0,0 @@
-import asyncio
-import random
-import re
-import time
-
-from cloudpss.job.view.view import View
-from .view import getViewClass
-
-from cloudpss.utils.IO import IO
-from .messageStreamReceiver import MessageStreamReceiver
-
-from cloudpss.utils.graphqlUtil import graphql_request
-from .jobMachine import JobMachine
-from .messageStreamSender import MessageStreamSender
-from typing import Any, Callable, Generic, TypeVar
-F = TypeVar('F', bound=Callable[..., Any])
-T = TypeVar('T', bound=Callable[..., View])
-class Job(Generic[T]):
-    """docstring for Job"""
-    __jobQuery = """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
-            }
-        }"""
-    
-    __createJobQuery = """mutation($input:CreateJobInput!){job:createJob(input:$input){id input output status position}}"""
-    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
-    def fetch(id):
-        """
-        获取job信息
-        """
-        if id is None:
-            raise Exception("id is None")
-       
-        variables = {"_a": {"id": id}}
-
-        r =  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
-    def __createJobVariables(job, config, revisionHash, rid, policy, **kwargs):
-        # 处理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
-        function = job["rid"].replace("job-definition/cloudpss/", "function/CloudPSS/")
-        implement = kwargs.get("implement", None)
-        debug = job["args"].get("@debug", None )
-        debugargs={}
-        if debug:
-            t= [ i.split('=') for i in re.split(r'\s+',debug) if i.find('=')>0]
-            for i in t:
-                debugargs[i[0]]=i[1]
-        variables = {
-            "input": {
-                "args": {
-                    **job["args"],
-                    "_ModelRevision": revisionHash,
-                    "_ModelArgs": config["args"],
-                    "implement":implement
-                },
-                "context": [
-                    function,
-                    rid,
-                    f"model/@sdk/{str(int(time.time() * random.random()))}",
-                ],
-                "policy": policy,
-                "debug":debugargs
-            }
-        }
-        return variables
-    @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,'')
-        """
-        variables=Job.__createJobVariables(job, config, revisionHash, rid, policy)
-        r =  graphql_request(Job.__createJobQuery, variables)
-        if "errors" in r:
-            raise Exception(r["errors"])
-        id = r["data"]["job"]["id"]
-        return  Job.fetch(id)
-        
-    
-
-    @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, **kwargs):
-        """
-        使用接收器获取当前运行实例的输出
-        """
-        if receiver is not None:
-            self.__receiver = receiver
-        if self.__receiver is None:
-            self.__receiver = MessageStreamReceiver(self)
-            self.__receiver.connect(**kwargs)
-        return self.__receiver
-
-    
-    
-    def write(self, sender=None,  **kwargs) -> MessageStreamSender:
-        """
-        使用发送器为当前运行实例输入
-        """
-
-        if sender is not None:
-            self.__sender = sender
-        if self.__sender is None:
-            self.__sender = MessageStreamSender(self)
-        self.__sender.connect_legacy(**kwargs)
-        return self.__sender
-    
-    def status(self):
-        """
-        return: 0: 运行中 1: 运行完成 2: 运行失败
-        """
-        time.sleep(0)
-        if self.__receiver is not None:
-            return self.__receiver.status
-        if self.__receiver is None:
-            self.__connect()
-        
-        return 0
-    
-    def __connect(self):
-        """
-        连接接收器和发送器
-        """
-        viewType = getViewClass(self.context[0])
-        self._result = self.view(viewType)
-        
-    @property
-    def result(self)->T:
-        """
-        获取当前运行实例的输出
-        """
-        if self._result is None:
-            self.__connect()
-        return self._result
-   
-    
-    def view(self, viewType:F)->F:
-        """
-        获取当前运行实例的输出
-        """
-        receiver =  self.read()
-        sender =  self.write()
-        return viewType(receiver, sender)
-
-    
-

cloudpss/job/jobMachine.py

@@ -1,11 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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
-        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)
-        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

@@ -1,14 +0,0 @@
-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

@@ -1,39 +0,0 @@
-from deprecated import deprecated
-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)
-    
-    @property
-    @deprecated(version='3.0', reason="该方法将在 5.0 版本移除")
-    def message(self):
-        return self.messages

cloudpss/job/jobTres.py

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