ucloud-sdk-python3 0.11.81__py3-none-any.whl

ucloud/client.py

@@ -0,0 +1,469 @@
+""" Code is generated by ucloud-model, DO NOT EDIT IT. """
+
+from ucloud.core import client
+
+
+class Client(client.Client):
+    def __init__(
+        self, config: dict, transport=None, middleware=None, logger=None
+    ):
+        self._config = config
+        super(Client, self).__init__(
+            self._auto_config(), transport, middleware, logger
+        )
+
+    def pathx(self):
+        from ucloud.services.pathx.client import PathXClient
+
+        return PathXClient(
+            self._auto_config("pathx"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def cube(self):
+        from ucloud.services.cube.client import CubeClient
+
+        return CubeClient(
+            self._auto_config("cube"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def iam(self):
+        from ucloud.services.iam.client import IAMClient
+
+        return IAMClient(
+            self._auto_config("iam"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def ipsecvpn(self):
+        from ucloud.services.ipsecvpn.client import IPSecVPNClient
+
+        return IPSecVPNClient(
+            self._auto_config("ipsecvpn"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def isms(self):
+        from ucloud.services.isms.client import ISMSClient
+
+        return ISMSClient(
+            self._auto_config("isms"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def sts(self):
+        from ucloud.services.sts.client import STSClient
+
+        return STSClient(
+            self._auto_config("sts"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def stepflow(self):
+        from ucloud.services.stepflow.client import StepFlowClient
+
+        return StepFlowClient(
+            self._auto_config("stepflow"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def tidb(self):
+        from ucloud.services.tidb.client import TiDBClient
+
+        return TiDBClient(
+            self._auto_config("tidb"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def uaaa(self):
+        from ucloud.services.uaaa.client import UAAAClient
+
+        return UAAAClient(
+            self._auto_config("uaaa"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def uads(self):
+        from ucloud.services.uads.client import UADSClient
+
+        return UADSClient(
+            self._auto_config("uads"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def uaccount(self):
+        from ucloud.services.uaccount.client import UAccountClient
+
+        return UAccountClient(
+            self._auto_config("uaccount"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def ubill(self):
+        from ucloud.services.ubill.client import UBillClient
+
+        return UBillClient(
+            self._auto_config("ubill"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def ucdn(self):
+        from ucloud.services.ucdn.client import UCDNClient
+
+        return UCDNClient(
+            self._auto_config("ucdn"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def ucompshare(self):
+        from ucloud.services.ucompshare.client import UCompShareClient
+
+        return UCompShareClient(
+            self._auto_config("ucompshare"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def udb(self):
+        from ucloud.services.udb.client import UDBClient
+
+        return UDBClient(
+            self._auto_config("udb"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def udbproxy(self):
+        from ucloud.services.udbproxy.client import UDBProxyClient
+
+        return UDBProxyClient(
+            self._auto_config("udbproxy"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def uddb(self):
+        from ucloud.services.uddb.client import UDDBClient
+
+        return UDDBClient(
+            self._auto_config("uddb"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def udi(self):
+        from ucloud.services.udi.client import UDIClient
+
+        return UDIClient(
+            self._auto_config("udi"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def udns(self):
+        from ucloud.services.udns.client import UDNSClient
+
+        return UDNSClient(
+            self._auto_config("udns"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def udpn(self):
+        from ucloud.services.udpn.client import UDPNClient
+
+        return UDPNClient(
+            self._auto_config("udpn"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def udts(self):
+        from ucloud.services.udts.client import UDTSClient
+
+        return UDTSClient(
+            self._auto_config("udts"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def udisk(self):
+        from ucloud.services.udisk.client import UDiskClient
+
+        return UDiskClient(
+            self._auto_config("udisk"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def uec(self):
+        from ucloud.services.uec.client import UECClient
+
+        return UECClient(
+            self._auto_config("uec"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def ufs(self):
+        from ucloud.services.ufs.client import UFSClient
+
+        return UFSClient(
+            self._auto_config("ufs"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def ufile(self):
+        from ucloud.services.ufile.client import UFileClient
+
+        return UFileClient(
+            self._auto_config("ufile"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def ugn(self):
+        from ucloud.services.ugn.client import UGNClient
+
+        return UGNClient(
+            self._auto_config("ugn"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def uhost(self):
+        from ucloud.services.uhost.client import UHostClient
+
+        return UHostClient(
+            self._auto_config("uhost"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def uhub(self):
+        from ucloud.services.uhub.client import UHubClient
+
+        return UHubClient(
+            self._auto_config("uhub"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def uk8s(self):
+        from ucloud.services.uk8s.client import UK8SClient
+
+        return UK8SClient(
+            self._auto_config("uk8s"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def ulb(self):
+        from ucloud.services.ulb.client import ULBClient
+
+        return ULBClient(
+            self._auto_config("ulb"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def ulighthost(self):
+        from ucloud.services.ulighthost.client import ULightHostClient
+
+        return ULightHostClient(
+            self._auto_config("ulighthost"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def umem(self):
+        from ucloud.services.umem.client import UMemClient
+
+        return UMemClient(
+            self._auto_config("umem"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def umongodb(self):
+        from ucloud.services.umongodb.client import UMongoDBClient
+
+        return UMongoDBClient(
+            self._auto_config("umongodb"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def unvs(self):
+        from ucloud.services.unvs.client import UNVSClient
+
+        return UNVSClient(
+            self._auto_config("unvs"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def unet(self):
+        from ucloud.services.unet.client import UNetClient
+
+        return UNetClient(
+            self._auto_config("unet"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def upfs(self):
+        from ucloud.services.upfs.client import UPFSClient
+
+        return UPFSClient(
+            self._auto_config("upfs"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def uphost(self):
+        from ucloud.services.uphost.client import UPHostClient
+
+        return UPHostClient(
+            self._auto_config("uphost"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def upgsql(self):
+        from ucloud.services.upgsql.client import UPgSQLClient
+
+        return UPgSQLClient(
+            self._auto_config("upgsql"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def uphone(self):
+        from ucloud.services.uphone.client import UPhoneClient
+
+        return UPhoneClient(
+            self._auto_config("uphone"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def uslk(self):
+        from ucloud.services.uslk.client import USLKClient
+
+        return USLKClient(
+            self._auto_config("uslk"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def usms(self):
+        from ucloud.services.usms.client import USMSClient
+
+        return USMSClient(
+            self._auto_config("usms"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def utsdb(self):
+        from ucloud.services.utsdb.client import UTSDBClient
+
+        return UTSDBClient(
+            self._auto_config("utsdb"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def uvms(self):
+        from ucloud.services.uvms.client import UVMSClient
+
+        return UVMSClient(
+            self._auto_config("uvms"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def ipv6gw(self):
+        from ucloud.services.ipv6gw.client import ipv6gwClient
+
+        return ipv6gwClient(
+            self._auto_config("ipv6gw"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def vpc(self):
+        from ucloud.services.vpc.client import VPCClient
+
+        return VPCClient(
+            self._auto_config("vpc"),
+            self.transport,
+            self.middleware,
+            self.logger,
+        )
+
+    def _auto_config(self, package="generic"):
+        user_agent = "Package/{} {}".format(
+            package, self._config.get("user_agent") or ""
+        )
+        return dict(user_agent=user_agent.rstrip(), **self._config)

ucloud/core/auth/__init__.py

@@ -0,0 +1,3 @@
+from ucloud.core.auth._cfg import Credential
+
+__all__ = ["Credential"]

ucloud/core/auth/_cfg.py

@@ -0,0 +1,72 @@
+import hashlib
+from collections import OrderedDict
+from ucloud.core.typesystem import schema, fields, encoder
+
+
+class CredentialSchema(schema.Schema):
+    fields = {
+        "public_key": fields.Str(required=True),
+        "private_key": fields.Str(required=True),
+    }
+
+
+def verify_ac(private_key: str, params: dict) -> str:
+    """calculate signature by private_key/public_key
+
+    the keys can be found on `APIKey documentation <https://console.ucloud.cn/uapi/apikey>`__
+
+    >>> verify_ac("my_private_key", {"foo": "bar"})
+    '634edc1bb957c0d65e5ab5494cf3b7784fbc87af'
+
+    >>> verify_ac("my_private_key", {"foo": "bar"})
+    '634edc1bb957c0d65e5ab5494cf3b7784fbc87af'
+
+    :param private_key: private key
+    :param params:
+    :return:
+    """
+    params = OrderedDict(sorted(params.items(), key=lambda item: item[0]))
+
+    simplified = ""
+    for key, value in params.items():
+        simplified += str(key) + encoder.encode_value(value)
+    simplified += private_key
+
+    hash_new = hashlib.sha1()
+    hash_new.update(simplified.encode("utf-8"))
+    hash_value = hash_new.hexdigest()
+    return hash_value
+
+
+class Credential:
+    """credential is the object to store credential information
+
+    the keys can be found on `APIKey documentation <https://console.ucloud.cn/uapi/apikey>`__
+
+    it can calculate signature for OpenAPI:
+
+    >>> cred = Credential('my_public_key', 'my_private_key')
+    >>> cred.verify_ac({"foo": "bar"})
+    'd4411ab30953fb0bbcb1e7313081f05e4e91a394'
+
+    :param public_key:
+    :param private_key:
+    """
+
+    PUBLIC_KEY_NAME = "PublicKey"
+
+    def __init__(self, public_key: str, private_key: str, **kwargs):
+        self.public_key = public_key
+        self.private_key = private_key
+
+    def verify_ac(self, args: dict) -> str:
+        args[Credential.PUBLIC_KEY_NAME] = self.public_key
+        return verify_ac(self.private_key, args)
+
+    @classmethod
+    def from_dict(cls, d: dict):
+        parsed = CredentialSchema().dumps(d)
+        return cls(**parsed)
+
+    def to_dict(self) -> dict:
+        return {"public_key": self.public_key, "private_key": self.private_key}

ucloud/core/client/__init__.py

@@ -0,0 +1,8 @@
+"""
+Client
+"""
+
+from ucloud.core.client._cfg import Config
+from ucloud.core.client._client import Client
+
+__all__ = ["Config", "Client"]

ucloud/core/client/_cfg.py

@@ -0,0 +1,96 @@
+import logging
+
+from ucloud.core.typesystem import schema, fields
+
+
+class ConfigSchema(schema.Schema):
+    fields = {
+        "region": fields.Str(),
+        "project_id": fields.Str(),
+        "base_url": fields.Str(default="https://api.ucloud.cn"),
+        "user_agent": fields.Str(),
+        "timeout": fields.Int(default=30),
+        "max_retries": fields.Int(default=0),
+        "log_level": fields.Int(default=logging.INFO),
+        "validate_request": fields.Bool(default=True),
+        "ssl_verify": fields.Bool(default=True),
+        "ssl_cacert": fields.Str(),
+        "ssl_cert": fields.Str(),
+        "ssl_key": fields.Str(),
+    }
+
+
+class Config:
+    """
+    Config is the config of ucloud sdk, use for setting up
+
+    :type region: str
+    :param region: Region is the region of backend service,
+        See also `Region list Documentation <https://docs.ucloud.cn/api/summary/regionlist>`_
+    :type project_id: str
+    :param project_id: ProjectId is the unique identify of project, used for organize resources,
+                       Most of resources should belong to a project. Sub-Account must have an project id.
+                       See also `Project list Documentation <https://docs.ucloud.cn/api/summary/get_project_list>`_
+    :type base_url: str
+    :param base_url: BaseUrl is the url of backend api
+    :param user_agent: UserAgent is an attribute for sdk client, used for distinguish who is using sdk.
+                       See also `User Agent <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent>`_
+                       It will be appended to the end of sdk user-agent.
+                       eg. "MyAPP/0.10.1" -> "Python/3.7.0 Python-SDK/0.1.0 MyAPP/0.10.1"
+    :type timeout: int
+    :param timeout: Timeout is timeout for every request.
+    :type max_retries: int
+    :param max_retries: MaxRetries is the number of max retry times.
+                        Set MaxRetries more than 0 to enable auto-retry for network and service availability problem
+                        if auto-retry is enabled, it will enable default retry policy using exponential backoff.
+    :type log_level: int
+    :param log_level:  LogLevel is equal to builtin logging level,
+        if logLevel not be set, use INFO level as default.
+    """
+
+    def __init__(
+        self,
+        region: str = None,
+        project_id: str = None,
+        base_url: str = "https://api.ucloud.cn",
+        user_agent: str = None,
+        timeout: int = 30,
+        max_retries: int = 3,
+        log_level: int = logging.INFO,
+        ssl_verify: bool = True,
+        ssl_cacert: str = None,
+        ssl_cert: str = None,
+        ssl_key: str = None,
+        **kwargs
+    ):
+        self.region = region
+        self.project_id = project_id
+        self.base_url = base_url
+        self.user_agent = user_agent
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.log_level = log_level
+        self.ssl_verify = ssl_verify
+        self.ssl_cacert = ssl_cacert
+        self.ssl_cert = ssl_cert
+        self.ssl_key = ssl_key
+
+    @classmethod
+    def from_dict(cls, d: dict):
+        parsed = ConfigSchema().dumps(d)
+        return cls(**parsed)
+
+    def to_dict(self) -> dict:
+        return {
+            "region": self.region,
+            "project_id": self.project_id,
+            "base_url": self.base_url,
+            "user_agent": self.user_agent,
+            "timeout": self.timeout,
+            "max_retries": self.max_retries,
+            "log_level": self.log_level,
+            "ssl_verify": self.ssl_verify,
+            "ssl_cacert": self.ssl_cacert,
+            "ssl_cert": self.ssl_cert,
+            "ssl_key": self.ssl_key,
+        }