maxcompute-tea-openapi 0.0.4__py3-none-any.whl

maxcompute_tea_openapi/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.4"

maxcompute_tea_openapi/client.py

@@ -0,0 +1,690 @@
+# -*- coding: utf-8 -*-
+# This file is auto-generated, don't edit it. Thanks.
+import time
+
+from Tea.exceptions import TeaException, UnretryableException
+from Tea.request import TeaRequest
+from Tea.core import TeaCore
+from Tea.model import TeaModel
+from typing import Dict, Any
+
+from alibabacloud_credentials.client import Client as CredentialClient
+from maxcompute_tea_openapi import models as openapi_models
+from alibabacloud_tea_util.client import Client as UtilClient
+from alibabacloud_credentials import models as credential_models
+from alibabacloud_tea_util import models as util_models
+from maxcompute_tea_util.client import Client as McUtilClient
+
+
+class Client:
+    _endpoint: str = None
+    _project: str = None
+    _region_id: str = None
+    _protocol: str = None
+    _method: str = None
+    _user_agent: str = None
+    _read_timeout: int = None
+    _connect_timeout: int = None
+    _credential: CredentialClient = None
+    _signature_version: str = None
+    _headers: Dict[str, str] = None
+    _suffix: str = None
+    _global_parameters: openapi_models.GlobalParameters = None
+    _odps_endpoint: str = None
+
+    def __init__(
+        self, 
+        config: openapi_models.Config,
+    ):
+        """
+        Init client with Config
+        @param config: config contains the necessary information to create a client
+        """
+        if UtilClient.is_unset(config):
+            raise TeaException({
+                'code': 'ParameterMissing',
+                'message': "'config' can not be unset"
+            })
+        if not UtilClient.empty(config.access_key_id) and not UtilClient.empty(config.access_key_secret):
+            if not UtilClient.empty(config.security_token):
+                config.type = 'sts'
+            else:
+                config.type = 'access_key'
+            credential_config = credential_models.Config(
+                access_key_id=config.access_key_id,
+                type=config.type,
+                access_key_secret=config.access_key_secret
+            )
+            credential_config.security_token = config.security_token
+            self._credential = CredentialClient(credential_config)
+        elif not UtilClient.empty(config.bearer_token):
+            cc = credential_models.Config(
+                type='bearer',
+                bearer_token=config.bearer_token
+            )
+            self._credential = CredentialClient(cc)
+        elif not UtilClient.is_unset(config.credential):
+            self._credential = config.credential
+        self._project = config.project
+        self._endpoint = config.endpoint
+        self._protocol = config.protocol
+        self._method = config.method
+        self._region_id = config.region_id
+        self._user_agent = config.user_agent
+        self._read_timeout = config.read_timeout
+        self._connect_timeout = config.connect_timeout
+        self._signature_version = config.signature_version
+        self._global_parameters = config.global_parameters
+        self._suffix = config.suffix
+        self._odps_endpoint = config.odps_endpoint
+
+    def do_request(
+        self,
+        params: openapi_models.Params,
+        request: openapi_models.OpenApiRequest,
+        runtime: util_models.RuntimeOptions,
+    ) -> dict:
+        """
+        Encapsulate the request and invoke the network
+        @param action: api name
+        @param version: product version
+        @param protocol: http or https
+        @param method: e.g. GET
+        @param auth_type: authorization type e.g. AK
+        @param body_type: response body type e.g. String
+        @param request: object of OpenApiRequest
+        @param runtime: which controls some details of call api, such as retry times
+        @return: the response
+        """
+        params.validate()
+        request.validate()
+        runtime.validate()
+        _runtime = {
+            'timeouted': 'retry',
+            'readTimeout': UtilClient.default_number(runtime.read_timeout, self._read_timeout),
+            'connectTimeout': UtilClient.default_number(runtime.connect_timeout, self._connect_timeout),
+            'retry': {
+                'retryable': runtime.autoretry,
+                'maxAttempts': UtilClient.default_number(runtime.max_attempts, 3)
+            },
+            'backoff': {
+                'policy': UtilClient.default_string(runtime.backoff_policy, 'no'),
+                'period': UtilClient.default_number(runtime.backoff_period, 1)
+            },
+            'ignoreSSL': runtime.ignore_ssl
+        }
+        _last_request = None
+        _last_exception = None
+        _now = time.time()
+        _retry_times = 0
+        while TeaCore.allow_retry(_runtime.get('retry'), _retry_times, _now):
+            if _retry_times > 0:
+                _backoff_time = TeaCore.get_backoff_time(_runtime.get('backoff'), _retry_times)
+                if _backoff_time > 0:
+                    TeaCore.sleep(_backoff_time)
+            _retry_times = _retry_times + 1
+            try:
+                _request = TeaRequest()
+                _request.protocol = UtilClient.default_string(request.protocol_override, UtilClient.default_string(self._protocol, params.protocol))
+                _request.method = params.method
+                if not UtilClient.is_unset(self._suffix):
+                    _request.pathname = f'/{self._suffix}{params.pathname}'
+                else:
+                    _request.pathname = params.pathname
+                if not UtilClient.is_unset(request.pathname_prefix):
+                    _request.pathname = f'{request.pathname_prefix}{_request.pathname}'
+                global_queries = {}
+                global_headers = {}
+                if not UtilClient.is_unset(self._global_parameters):
+                    global_params = self._global_parameters
+                    if not UtilClient.is_unset(global_params.queries):
+                        global_queries = global_params.queries
+                    if not UtilClient.is_unset(global_params.headers):
+                        global_headers = global_params.headers
+                extends_headers = {}
+                extends_queries = {}
+                if not UtilClient.is_unset(runtime.extends_parameters):
+                    extends_parameters = runtime.extends_parameters
+                    if not UtilClient.is_unset(extends_parameters.headers):
+                        extends_headers = extends_parameters.headers
+                    if not UtilClient.is_unset(extends_parameters.queries):
+                        extends_queries = extends_parameters.queries
+                _request.query = TeaCore.merge(global_queries,
+                    extends_queries,
+                    request.query)
+                # endpoint is setted in product client
+                _request.headers = TeaCore.merge({
+                    'host': UtilClient.default_string(request.endpoint_override, self._endpoint),
+                    'user-agent': self.get_user_agent(),
+                    'x-odps-user-agent': self.get_user_agent(),
+                    'Date': McUtilClient.get_api_timestamp()
+                }, global_headers,
+                    extends_headers,
+                    request.headers)
+                if not UtilClient.is_unset(request.stream):
+                    tmp = UtilClient.read_as_bytes(request.stream)
+                    _request.body = tmp
+                if not UtilClient.is_unset(request.body):
+                    json_obj = UtilClient.to_jsonstring(request.body)
+                    _request.body = json_obj
+                    _request.headers['content-type'] = 'application/json; charset=utf-8'
+                canonical_string = McUtilClient.build_canonical_string(params.method, params.pathname, _request.query, _request.headers)
+                if not UtilClient.equal_string(params.auth_type, 'Anonymous'):
+                    if UtilClient.is_unset(self._credential):
+                        raise TeaException({
+                            'code': f'InvalidCredentials',
+                            'message': f'Please set up the credentials correctly. If you are setting them through environment variables, please ensure that ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set correctly. See https://help.aliyun.com/zh/sdk/developer-reference/configure-the-alibaba-cloud-accesskey-environment-variable-on-linux-macos-and-windows-systems for more details.'
+                        })
+                    credential_model = self._credential.get_credential()
+                    auth_type = credential_model.type
+                    if UtilClient.equal_string(auth_type, 'bearer'):
+                        bearer_token = credential_model.bearer_token
+                        _request.headers['x-odps-bearer-token'] = bearer_token
+                    else:
+                        access_key_id = credential_model.access_key_id
+                        access_key_secret = credential_model.access_key_secret
+                        security_token = credential_model.security_token
+                        _request.headers['Authorization'] = McUtilClient.get_signature(canonical_string, access_key_id, access_key_secret)
+                        if not UtilClient.empty(security_token):
+                            _request.headers['authorization-sts-token'] = security_token
+                _last_request = _request
+                _response = TeaCore.do_action(_request, _runtime)
+                if UtilClient.equal_number(_response.status_code, 204):
+                    return {
+                        'headers': _response.headers
+                    }
+                if UtilClient.is_4xx(_response.status_code) or UtilClient.is_5xx(_response.status_code):
+                    err = {}
+                    response_body = UtilClient.read_as_string(_response.body)
+                    try:
+                        _res = UtilClient.parse_json(response_body)
+                        err = UtilClient.assert_as_map(_res)
+                    except Exception as error:
+                        err = {}
+                        err['Code'] = 'Unknown'
+                        err['Message'] = response_body
+                    request_id = McUtilClient.to_string(self.default_any(_response.headers.get('x-odps-request-id'), _response.headers.get('X-Odps-Request-Id')))
+                    err['statusCode'] = _response.status_code
+                    raise TeaException({
+                        'code': f"{self.default_any(err.get('Code'), err.get('code'))}",
+                        'message': f"code: {_response.status_code}, {self.default_any(err.get('Message'), err.get('message'))} request id: {request_id}",
+                        'data': err,
+                        'description': f"{self.default_any(err.get('Description'), err.get('description'))}",
+                        'accessDeniedDetail': self.default_any(err.get('AccessDeniedDetail'), err.get('accessDeniedDetail'))
+                    })
+                if UtilClient.equal_string(params.body_type, 'binary'):
+                    resp = {
+                        'body': _response.body,
+                        'headers': _response.headers,
+                        'statusCode': _response.status_code
+                    }
+                    return resp
+                elif UtilClient.equal_string(params.body_type, 'byte'):
+                    byt = UtilClient.read_as_bytes(_response.body)
+                    return {
+                        'body': byt,
+                        'headers': _response.headers,
+                        'statusCode': _response.status_code
+                    }
+                elif UtilClient.equal_string(params.body_type, 'string'):
+                    str = UtilClient.read_as_string(_response.body)
+                    return {
+                        'body': str,
+                        'headers': _response.headers,
+                        'statusCode': _response.status_code
+                    }
+                elif UtilClient.equal_string(params.body_type, 'json'):
+                    obj = UtilClient.read_as_json(_response.body)
+                    res = UtilClient.assert_as_map(obj)
+                    return res
+                elif UtilClient.equal_string(params.body_type, 'array'):
+                    arr = UtilClient.read_as_json(_response.body)
+                    return {
+                        'body': arr,
+                        'headers': _response.headers,
+                        'statusCode': _response.status_code
+                    }
+                else:
+                    anything = UtilClient.read_as_string(_response.body)
+                    return {
+                        'body': anything,
+                        'headers': _response.headers,
+                        'statusCode': _response.status_code
+                    }
+            except Exception as e:
+                if TeaCore.is_retryable(e):
+                    _last_exception = e
+                    continue
+                raise e
+        raise UnretryableException(_last_request, _last_exception)
+
+    async def do_request_async(
+        self,
+        params: openapi_models.Params,
+        request: openapi_models.OpenApiRequest,
+        runtime: util_models.RuntimeOptions,
+    ) -> dict:
+        """
+        Encapsulate the request and invoke the network
+        @param action: api name
+        @param version: product version
+        @param protocol: http or https
+        @param method: e.g. GET
+        @param auth_type: authorization type e.g. AK
+        @param body_type: response body type e.g. String
+        @param request: object of OpenApiRequest
+        @param runtime: which controls some details of call api, such as retry times
+        @return: the response
+        """
+        params.validate()
+        request.validate()
+        runtime.validate()
+        _runtime = {
+            'timeouted': 'retry',
+            'readTimeout': UtilClient.default_number(runtime.read_timeout, self._read_timeout),
+            'connectTimeout': UtilClient.default_number(runtime.connect_timeout, self._connect_timeout),
+            'retry': {
+                'retryable': runtime.autoretry,
+                'maxAttempts': UtilClient.default_number(runtime.max_attempts, 3)
+            },
+            'backoff': {
+                'policy': UtilClient.default_string(runtime.backoff_policy, 'no'),
+                'period': UtilClient.default_number(runtime.backoff_period, 1)
+            },
+            'ignoreSSL': runtime.ignore_ssl
+        }
+        _last_request = None
+        _last_exception = None
+        _now = time.time()
+        _retry_times = 0
+        while TeaCore.allow_retry(_runtime.get('retry'), _retry_times, _now):
+            if _retry_times > 0:
+                _backoff_time = TeaCore.get_backoff_time(_runtime.get('backoff'), _retry_times)
+                if _backoff_time > 0:
+                    TeaCore.sleep(_backoff_time)
+            _retry_times = _retry_times + 1
+            try:
+                _request = TeaRequest()
+                _request.protocol = UtilClient.default_string(request.protocol_override, UtilClient.default_string(self._protocol, params.protocol))
+                _request.method = params.method
+                if not UtilClient.is_unset(self._suffix):
+                    _request.pathname = f'/{self._suffix}{params.pathname}'
+                else:
+                    _request.pathname = params.pathname
+                if not UtilClient.is_unset(request.pathname_prefix):
+                    _request.pathname = f'{request.pathname_prefix}{_request.pathname}'
+                global_queries = {}
+                global_headers = {}
+                if not UtilClient.is_unset(self._global_parameters):
+                    global_params = self._global_parameters
+                    if not UtilClient.is_unset(global_params.queries):
+                        global_queries = global_params.queries
+                    if not UtilClient.is_unset(global_params.headers):
+                        global_headers = global_params.headers
+                extends_headers = {}
+                extends_queries = {}
+                if not UtilClient.is_unset(runtime.extends_parameters):
+                    extends_parameters = runtime.extends_parameters
+                    if not UtilClient.is_unset(extends_parameters.headers):
+                        extends_headers = extends_parameters.headers
+                    if not UtilClient.is_unset(extends_parameters.queries):
+                        extends_queries = extends_parameters.queries
+                _request.query = TeaCore.merge(global_queries,
+                    extends_queries,
+                    request.query)
+                # endpoint is setted in product client
+                _request.headers = TeaCore.merge({
+                    'host': UtilClient.default_string(request.endpoint_override, self._endpoint),
+                    'user-agent': self.get_user_agent(),
+                    'x-odps-user-agent': self.get_user_agent(),
+                    'Date': McUtilClient.get_api_timestamp()
+                }, global_headers,
+                    extends_headers,
+                    request.headers)
+                if not UtilClient.is_unset(request.stream):
+                    tmp = await UtilClient.read_as_bytes_async(request.stream)
+                    _request.body = tmp
+                if not UtilClient.is_unset(request.body):
+                    json_obj = UtilClient.to_jsonstring(request.body)
+                    _request.body = json_obj
+                    _request.headers['content-type'] = 'application/json; charset=utf-8'
+                canonical_string = McUtilClient.build_canonical_string(params.method, params.pathname, _request.query, _request.headers)
+                if not UtilClient.equal_string(params.auth_type, 'Anonymous'):
+                    if UtilClient.is_unset(self._credential):
+                        raise TeaException({
+                            'code': f'InvalidCredentials',
+                            'message': f'Please set up the credentials correctly. If you are setting them through environment variables, please ensure that ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set correctly. See https://help.aliyun.com/zh/sdk/developer-reference/configure-the-alibaba-cloud-accesskey-environment-variable-on-linux-macos-and-windows-systems for more details.'
+                        })
+                    credential_model = await self._credential.get_credential_async()
+                    auth_type = credential_model.type
+                    if UtilClient.equal_string(auth_type, 'bearer'):
+                        bearer_token = credential_model.bearer_token
+                        _request.headers['x-odps-bearer-token'] = bearer_token
+                    else:
+                        access_key_id = credential_model.access_key_id
+                        access_key_secret = credential_model.access_key_secret
+                        security_token = credential_model.security_token
+                        _request.headers['Authorization'] = McUtilClient.get_signature(canonical_string, access_key_id, access_key_secret)
+                        if not UtilClient.empty(security_token):
+                            _request.headers['authorization-sts-token'] = security_token
+                _last_request = _request
+                _response = await TeaCore.async_do_action(_request, _runtime)
+                if UtilClient.equal_number(_response.status_code, 204):
+                    return {
+                        'headers': _response.headers
+                    }
+                if UtilClient.is_4xx(_response.status_code) or UtilClient.is_5xx(_response.status_code):
+                    err = {}
+                    response_body = await UtilClient.read_as_string_async(_response.body)
+                    try:
+                        _res = UtilClient.parse_json(response_body)
+                        err = UtilClient.assert_as_map(_res)
+                    except Exception as error:
+                        err = {}
+                        err['Code'] = 'Unknown'
+                        err['Message'] = response_body
+                    request_id = McUtilClient.to_string(self.default_any(_response.headers.get('x-odps-request-id'), _response.headers.get('X-Odps-Request-Id')))
+                    err['statusCode'] = _response.status_code
+                    raise TeaException({
+                        'code': f"{self.default_any(err.get('Code'), err.get('code'))}",
+                        'message': f"code: {_response.status_code}, {self.default_any(err.get('Message'), err.get('message'))} request id: {request_id}",
+                        'data': err,
+                        'description': f"{self.default_any(err.get('Description'), err.get('description'))}",
+                        'accessDeniedDetail': self.default_any(err.get('AccessDeniedDetail'), err.get('accessDeniedDetail'))
+                    })
+                if UtilClient.equal_string(params.body_type, 'binary'):
+                    resp = {
+                        'body': _response.body,
+                        'headers': _response.headers,
+                        'statusCode': _response.status_code
+                    }
+                    return resp
+                elif UtilClient.equal_string(params.body_type, 'byte'):
+                    byt = await UtilClient.read_as_bytes_async(_response.body)
+                    return {
+                        'body': byt,
+                        'headers': _response.headers,
+                        'statusCode': _response.status_code
+                    }
+                elif UtilClient.equal_string(params.body_type, 'string'):
+                    str = await UtilClient.read_as_string_async(_response.body)
+                    return {
+                        'body': str,
+                        'headers': _response.headers,
+                        'statusCode': _response.status_code
+                    }
+                elif UtilClient.equal_string(params.body_type, 'json'):
+                    obj = await UtilClient.read_as_json_async(_response.body)
+                    res = UtilClient.assert_as_map(obj)
+                    return res
+                elif UtilClient.equal_string(params.body_type, 'array'):
+                    arr = await UtilClient.read_as_json_async(_response.body)
+                    return {
+                        'body': arr,
+                        'headers': _response.headers,
+                        'statusCode': _response.status_code
+                    }
+                else:
+                    anything = await UtilClient.read_as_string_async(_response.body)
+                    return {
+                        'body': anything,
+                        'headers': _response.headers,
+                        'statusCode': _response.status_code
+                    }
+            except Exception as e:
+                if TeaCore.is_retryable(e):
+                    _last_exception = e
+                    continue
+                raise e
+        raise UnretryableException(_last_request, _last_exception)
+
+    def request_with_model(
+        self,
+        model: TeaModel,
+        method: str,
+        path: str,
+        params: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> dict:
+        UtilClient.validate_model(model)
+        req = openapi_models.OpenApiRequest(
+            body=UtilClient.to_map(model),
+            query=params
+        )
+        openapi_params = openapi_models.Params(
+            pathname=path,
+            method=method,
+            body_type='json'
+        )
+        return self.call_api(openapi_params, req, runtime)
+
+    async def request_with_model_async(
+        self,
+        model: TeaModel,
+        method: str,
+        path: str,
+        params: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> dict:
+        UtilClient.validate_model(model)
+        req = openapi_models.OpenApiRequest(
+            body=UtilClient.to_map(model),
+            query=params
+        )
+        openapi_params = openapi_models.Params(
+            pathname=path,
+            method=method,
+            body_type='json'
+        )
+        return await self.call_api_async(openapi_params, req, runtime)
+
+    def request_without_model(
+        self,
+        model: TeaModel,
+        method: str,
+        path: str,
+        params: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> dict:
+        UtilClient.validate_model(model)
+        req = openapi_models.OpenApiRequest(
+            body=UtilClient.to_map(model),
+            query=params
+        )
+        openapi_params = openapi_models.Params(
+            pathname=path,
+            method=method,
+            body_type='none'
+        )
+        return self.call_api(openapi_params, req, runtime)
+
+    async def request_without_model_async(
+        self,
+        model: TeaModel,
+        method: str,
+        path: str,
+        params: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> dict:
+        UtilClient.validate_model(model)
+        req = openapi_models.OpenApiRequest(
+            body=UtilClient.to_map(model),
+            query=params
+        )
+        openapi_params = openapi_models.Params(
+            pathname=path,
+            method=method,
+            body_type='none'
+        )
+        return await self.call_api_async(openapi_params, req, runtime)
+
+    def call_routing_api(self) -> openapi_models.RoutingResponse:
+        req = openapi_models.OpenApiRequest(
+            endpoint_override=self._odps_endpoint,
+            pathname_prefix='/api'
+        )
+        openapi_params = openapi_models.Params(
+            pathname='/catalogapi',
+            method='GET',
+            body_type='string'
+        )
+        return TeaCore.from_map(
+            openapi_models.RoutingResponse(),
+            self.do_request(openapi_params, req, util_models.RuntimeOptions())
+        )
+
+    async def call_routing_api_async(self) -> openapi_models.RoutingResponse:
+        req = openapi_models.OpenApiRequest(
+            endpoint_override=self._odps_endpoint,
+            pathname_prefix='/api'
+        )
+        openapi_params = openapi_models.Params(
+            pathname='/catalogapi',
+            method='GET',
+            body_type='string'
+        )
+        return TeaCore.from_map(
+            openapi_models.RoutingResponse(),
+            await self.do_request_async(openapi_params, req, util_models.RuntimeOptions())
+        )
+
+    def get_catalog_endpoint(self) -> str:
+        resp = self.call_routing_api()
+        return resp.body
+
+    async def get_catalog_endpoint_async(self) -> str:
+        resp = await self.call_routing_api_async()
+        return resp.body
+
+    def call_api(
+        self,
+        params: openapi_models.Params,
+        request: openapi_models.OpenApiRequest,
+        runtime: util_models.RuntimeOptions,
+    ) -> dict:
+        if UtilClient.is_unset(params):
+            raise TeaException({
+                'code': 'ParameterMissing',
+                'message': "'params' can not be unset"
+            })
+        if UtilClient.empty(self._endpoint) and not UtilClient.empty(self._odps_endpoint):
+            self._endpoint = self.get_catalog_endpoint()
+        return self.do_request(params, request, runtime)
+
+    async def call_api_async(
+        self,
+        params: openapi_models.Params,
+        request: openapi_models.OpenApiRequest,
+        runtime: util_models.RuntimeOptions,
+    ) -> dict:
+        if UtilClient.is_unset(params):
+            raise TeaException({
+                'code': 'ParameterMissing',
+                'message': "'params' can not be unset"
+            })
+        if UtilClient.empty(self._endpoint) and not UtilClient.empty(self._odps_endpoint):
+            self._endpoint = await self.get_catalog_endpoint_async()
+        return await self.do_request_async(params, request, runtime)
+
+    def get_user_agent(self) -> str:
+        """
+        Get user agent
+        @return: user agent
+        """
+        user_agent = UtilClient.get_user_agent(self._user_agent)
+        return user_agent
+
+    def get_access_key_id(self) -> str:
+        """
+        Get accesskey id by using credential
+        @return: accesskey id
+        """
+        if UtilClient.is_unset(self._credential):
+            return ''
+        access_key_id = self._credential.get_access_key_id()
+        return access_key_id
+
+    async def get_access_key_id_async(self) -> str:
+        """
+        Get accesskey id by using credential
+        @return: accesskey id
+        """
+        if UtilClient.is_unset(self._credential):
+            return ''
+        access_key_id = await self._credential.get_access_key_id_async()
+        return access_key_id
+
+    def get_access_key_secret(self) -> str:
+        """
+        Get accesskey secret by using credential
+        @return: accesskey secret
+        """
+        if UtilClient.is_unset(self._credential):
+            return ''
+        secret = self._credential.get_access_key_secret()
+        return secret
+
+    async def get_access_key_secret_async(self) -> str:
+        """
+        Get accesskey secret by using credential
+        @return: accesskey secret
+        """
+        if UtilClient.is_unset(self._credential):
+            return ''
+        secret = await self._credential.get_access_key_secret_async()
+        return secret
+
+    def get_security_token(self) -> str:
+        """
+        Get security token by using credential
+        @return: security token
+        """
+        if UtilClient.is_unset(self._credential):
+            return ''
+        token = self._credential.get_security_token()
+        return token
+
+    async def get_security_token_async(self) -> str:
+        """
+        Get security token by using credential
+        @return: security token
+        """
+        if UtilClient.is_unset(self._credential):
+            return ''
+        token = await self._credential.get_security_token_async()
+        return token
+
+    def get_bearer_token(self) -> str:
+        """
+        Get bearer token by credential
+        @return: bearer token
+        """
+        if UtilClient.is_unset(self._credential):
+            return ''
+        token = self._credential.get_bearer_token()
+        return token
+
+    async def get_bearer_token_async(self) -> str:
+        """
+        Get bearer token by credential
+        @return: bearer token
+        """
+        if UtilClient.is_unset(self._credential):
+            return ''
+        token = self._credential.get_bearer_token()
+        return token
+
+    @staticmethod
+    def default_any(
+        input_value: Any,
+        default_value: Any,
+    ) -> Any:
+        """
+        If inputValue is not null, return it or return defaultValue
+        @param input_value:  users input value
+        @param default_value: default value
+        @return: the final result
+        """
+        if UtilClient.is_unset(input_value):
+            return default_value
+        return input_value

maxcompute_tea_openapi/models.py

@@ -0,0 +1,377 @@
+# -*- coding: utf-8 -*-
+# This file is auto-generated, don't edit it. Thanks.
+from Tea.model import TeaModel
+from typing import Dict, Any, BinaryIO
+
+from alibabacloud_credentials.client import Client as CredentialClient
+
+
+class GlobalParameters(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        queries: Dict[str, str] = None,
+    ):
+        self.headers = headers
+        self.queries = queries
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.queries is not None:
+            result['queries'] = self.queries
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('queries') is not None:
+            self.queries = m.get('queries')
+        return self
+
+
+class Config(TeaModel):
+    """
+    Model for initing client
+    """
+    def __init__(
+        self,
+        project: str = None,
+        access_key_id: str = None,
+        access_key_secret: str = None,
+        security_token: str = None,
+        bearer_token: str = None,
+        protocol: str = None,
+        method: str = None,
+        region_id: str = None,
+        read_timeout: int = None,
+        connect_timeout: int = None,
+        credential: CredentialClient = None,
+        endpoint: str = None,
+        type: str = None,
+        user_agent: str = None,
+        suffix: str = None,
+        signature_version: str = None,
+        global_parameters: GlobalParameters = None,
+        odps_endpoint: str = None,
+    ):
+        # project
+        self.project = project
+        # accesskey id
+        self.access_key_id = access_key_id
+        # accesskey secret
+        self.access_key_secret = access_key_secret
+        # security token
+        self.security_token = security_token
+        # bearer token
+        self.bearer_token = bearer_token
+        # http protocol
+        self.protocol = protocol
+        # http method
+        self.method = method
+        # region id
+        self.region_id = region_id
+        # read timeout
+        self.read_timeout = read_timeout
+        # connect timeout
+        self.connect_timeout = connect_timeout
+        # credential
+        self.credential = credential
+        # endpoint
+        self.endpoint = endpoint
+        # credential type
+        self.type = type
+        # user agent
+        self.user_agent = user_agent
+        # suffix for endpoint
+        self.suffix = suffix
+        # Signature Version
+        self.signature_version = signature_version
+        # Global Parameters
+        self.global_parameters = global_parameters
+        # ODPS endpoint, used to resolve catalog endpoint via routing API when endpoint is not set
+        self.odps_endpoint = odps_endpoint
+
+    def validate(self):
+        if self.global_parameters:
+            self.global_parameters.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.project is not None:
+            result['project'] = self.project
+        if self.access_key_id is not None:
+            result['accessKeyId'] = self.access_key_id
+        if self.access_key_secret is not None:
+            result['accessKeySecret'] = self.access_key_secret
+        if self.security_token is not None:
+            result['securityToken'] = self.security_token
+        if self.bearer_token is not None:
+            result['bearerToken'] = self.bearer_token
+        if self.protocol is not None:
+            result['protocol'] = self.protocol
+        if self.method is not None:
+            result['method'] = self.method
+        if self.region_id is not None:
+            result['regionId'] = self.region_id
+        if self.read_timeout is not None:
+            result['readTimeout'] = self.read_timeout
+        if self.connect_timeout is not None:
+            result['connectTimeout'] = self.connect_timeout
+        if self.credential is not None:
+            result['credential'] = self.credential
+        if self.endpoint is not None:
+            result['endpoint'] = self.endpoint
+        if self.type is not None:
+            result['type'] = self.type
+        if self.user_agent is not None:
+            result['userAgent'] = self.user_agent
+        if self.suffix is not None:
+            result['suffix'] = self.suffix
+        if self.signature_version is not None:
+            result['signatureVersion'] = self.signature_version
+        if self.global_parameters is not None:
+            result['globalParameters'] = self.global_parameters.to_map()
+        if self.odps_endpoint is not None:
+            result['odpsEndpoint'] = self.odps_endpoint
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('project') is not None:
+            self.project = m.get('project')
+        if m.get('accessKeyId') is not None:
+            self.access_key_id = m.get('accessKeyId')
+        if m.get('accessKeySecret') is not None:
+            self.access_key_secret = m.get('accessKeySecret')
+        if m.get('securityToken') is not None:
+            self.security_token = m.get('securityToken')
+        if m.get('bearerToken') is not None:
+            self.bearer_token = m.get('bearerToken')
+        if m.get('protocol') is not None:
+            self.protocol = m.get('protocol')
+        if m.get('method') is not None:
+            self.method = m.get('method')
+        if m.get('regionId') is not None:
+            self.region_id = m.get('regionId')
+        if m.get('readTimeout') is not None:
+            self.read_timeout = m.get('readTimeout')
+        if m.get('connectTimeout') is not None:
+            self.connect_timeout = m.get('connectTimeout')
+        if m.get('credential') is not None:
+            self.credential = m.get('credential')
+        if m.get('endpoint') is not None:
+            self.endpoint = m.get('endpoint')
+        if m.get('type') is not None:
+            self.type = m.get('type')
+        if m.get('userAgent') is not None:
+            self.user_agent = m.get('userAgent')
+        if m.get('suffix') is not None:
+            self.suffix = m.get('suffix')
+        if m.get('signatureVersion') is not None:
+            self.signature_version = m.get('signatureVersion')
+        if m.get('globalParameters') is not None:
+            temp_model = GlobalParameters()
+            self.global_parameters = temp_model.from_map(m['globalParameters'])
+        if m.get('odpsEndpoint') is not None:
+            self.odps_endpoint = m.get('odpsEndpoint')
+        return self
+
+
+class Params(TeaModel):
+    def __init__(
+        self,
+        action: str = None,
+        version: str = None,
+        protocol: str = None,
+        pathname: str = None,
+        method: str = None,
+        auth_type: str = None,
+        body_type: str = None,
+        req_body_type: str = None,
+        style: str = None,
+    ):
+        self.action = action
+        self.version = version
+        self.protocol = protocol
+        self.pathname = pathname
+        self.method = method
+        self.auth_type = auth_type
+        self.body_type = body_type
+        self.req_body_type = req_body_type
+        self.style = style
+
+    def validate(self):
+        self.validate_required(self.pathname, 'pathname')
+        self.validate_required(self.method, 'method')
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.action is not None:
+            result['action'] = self.action
+        if self.version is not None:
+            result['version'] = self.version
+        if self.protocol is not None:
+            result['protocol'] = self.protocol
+        if self.pathname is not None:
+            result['pathname'] = self.pathname
+        if self.method is not None:
+            result['method'] = self.method
+        if self.auth_type is not None:
+            result['authType'] = self.auth_type
+        if self.body_type is not None:
+            result['bodyType'] = self.body_type
+        if self.req_body_type is not None:
+            result['reqBodyType'] = self.req_body_type
+        if self.style is not None:
+            result['style'] = self.style
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('action') is not None:
+            self.action = m.get('action')
+        if m.get('version') is not None:
+            self.version = m.get('version')
+        if m.get('protocol') is not None:
+            self.protocol = m.get('protocol')
+        if m.get('pathname') is not None:
+            self.pathname = m.get('pathname')
+        if m.get('method') is not None:
+            self.method = m.get('method')
+        if m.get('authType') is not None:
+            self.auth_type = m.get('authType')
+        if m.get('bodyType') is not None:
+            self.body_type = m.get('bodyType')
+        if m.get('reqBodyType') is not None:
+            self.req_body_type = m.get('reqBodyType')
+        if m.get('style') is not None:
+            self.style = m.get('style')
+        return self
+
+
+class OpenApiRequest(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        query: Dict[str, str] = None,
+        body: Any = None,
+        stream: BinaryIO = None,
+        host_map: Dict[str, str] = None,
+        endpoint_override: str = None,
+        pathname_prefix: str = None,
+        protocol_override: str = None,
+    ):
+        self.headers = headers
+        self.query = query
+        self.body = body
+        self.stream = stream
+        self.host_map = host_map
+        self.endpoint_override = endpoint_override
+        self.pathname_prefix = pathname_prefix
+        self.protocol_override = protocol_override
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.query is not None:
+            result['query'] = self.query
+        if self.body is not None:
+            result['body'] = self.body
+        if self.stream is not None:
+            result['stream'] = self.stream
+        if self.host_map is not None:
+            result['hostMap'] = self.host_map
+        if self.endpoint_override is not None:
+            result['endpointOverride'] = self.endpoint_override
+        if self.pathname_prefix is not None:
+            result['pathnamePrefix'] = self.pathname_prefix
+        if self.protocol_override is not None:
+            result['protocolOverride'] = self.protocol_override
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('query') is not None:
+            self.query = m.get('query')
+        if m.get('body') is not None:
+            self.body = m.get('body')
+        if m.get('stream') is not None:
+            self.stream = m.get('stream')
+        if m.get('hostMap') is not None:
+            self.host_map = m.get('hostMap')
+        if m.get('endpointOverride') is not None:
+            self.endpoint_override = m.get('endpointOverride')
+        if m.get('pathnamePrefix') is not None:
+            self.pathname_prefix = m.get('pathnamePrefix')
+        if m.get('protocolOverride') is not None:
+            self.protocol_override = m.get('protocolOverride')
+        return self
+
+
+class RoutingResponse(TeaModel):
+    def __init__(
+        self,
+        body: str = None,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+    ):
+        self.body = body
+        self.headers = headers
+        self.status_code = status_code
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.body is not None:
+            result['body'] = self.body
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('body') is not None:
+            self.body = m.get('body')
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        return self
+
+

maxcompute_tea_openapi-0.0.4.dist-info/METADATA

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: maxcompute_tea_openapi
+Version: 0.0.4
+Summary: Alibaba Cloud MaxCompute openapi SDK Library for Python
+Home-page: https://github.com/aliyun/aliyun-odps-openapi-sdk
+Author: Alibaba Cloud MaxCompute Team
+Author-email: zhangdingxin.zdx@alibaba-inc.com
+License: Apache License 2.0
+Keywords: maxcompute,tea,openapi
+Platform: any
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Software Development
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: maxcompute_tea_util<1.0.0,>=0.0.1
+Requires-Dist: alibabacloud_tea_util<1.0.0,>=0.3.14
+Requires-Dist: alibabacloud_credentials<2.0.0,>=1.0.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: platform
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

maxcompute_tea_openapi-0.0.4.dist-info/RECORD

@@ -0,0 +1,7 @@
+maxcompute_tea_openapi/__init__.py,sha256=1mptEzQihbdyqqzMgdns_j5ZGK9gz7hR2bsgA_TnjO4,22
+maxcompute_tea_openapi/client.py,sha256=Ey5tCQ-mLML7ysmYxRAjCi67vBcZgSVJ2iGzBh8g1Ik,31025
+maxcompute_tea_openapi/models.py,sha256=jkA1Ufh2M-ue09N0Ld1I15avfiZMA-PqNSYRvMn49Ac,12796
+maxcompute_tea_openapi-0.0.4.dist-info/METADATA,sha256=q7cEUXkGqd4QpUowqRIf-yP8rqQe2OC1MpW7fQuBnrU,1282
+maxcompute_tea_openapi-0.0.4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+maxcompute_tea_openapi-0.0.4.dist-info/top_level.txt,sha256=ynGm4_autZM7ZP1j4UsrrMCZIUtYxzjz7rnvGoppTVg,23
+maxcompute_tea_openapi-0.0.4.dist-info/RECORD,,

maxcompute_tea_openapi-0.0.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

maxcompute_tea_openapi-0.0.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+maxcompute_tea_openapi