def test_query(self):
result = Client.query(None)
self.assertEqual(0, len(result))
dic = {
'str_test': 'test',
'bytes_test': b'test',
'none_test': None,
'int_test': 1
}
result = Client.query(dic)
self.assertEqual('test', result.get('str_test'))
self.assertEqual('test', result.get('bytes_test'))
self.assertIsNone(result.get("none_test"))
self.assertEqual("1", result.get("int_test"))
with open(os.path.join(module_path, "test_open.txt")) as f:
fl = [1, None]
sub_dict_fl = {
'none_test': None,
'int_test': 2,
'str_test': 'test',
'file_test': f
}
fl.append(sub_dict_fl)
sl = [1, None]
fl.append(sl)
dic['list'] = fl
result = Client.query(dic)
self.assertEqual("1", result.get("list.1"))
self.assertIsNone(result.get("list.2"))
self.assertEqual("1", result.get("int_test"))
self.assertEqual("2", result.get("list.3.int_test"))
self.assertIsNone(result.get("list.3.none_test"))
self.assertEqual("test", result.get("list.3.str_test"))
self.assertEqual("1", result.get("list.4.1"))
self.assertEqual(None, result.get("list.3.file_test"))
sub_map_fd = {'none_test': None, 'int_test': 2, 'str_test': 'test'}
fd = {
'first_map_map': sub_map_fd,
'first_map_list': sl,
'none_test': None,
'int_test': 2,
'str_test': 'test'
}
dic['map'] = fd
result = Client.query(dic)
self.assertEqual("1", result.get("map.first_map_list.1"))
self.assertIsNone(result.get("map.none_test"))
self.assertEqual("2", result.get("map.int_test"))
self.assertEqual("test", result.get("map.str_test"))
self.assertIsNone(result.get("map.first_map_map.none_test"))
self.assertEqual("2", result.get("map.first_map_map.int_test"))
self.assertEqual("test", result.get("map.first_map_map.str_test"))
def create_pid_data_source_advance(self, request, runtime):
# Step 0: init client
access_key_id = self._credential.get_access_key_id()
access_key_secret = self._credential.get_access_key_secret()
auth_config = rpc_models.Config(access_key_id=access_key_id,
access_key_secret=access_key_secret,
type="access_key",
endpoint="openplatform.aliyuncs.com",
protocol=self._protocol,
region_id=self._region_id)
auth_client = OpenPlatformClient(auth_config)
auth_request = open_platform_models.AuthorizeFileUploadRequest(
product="brain-industrial", region_id=self._region_id)
auth_response = open_platform_models.AuthorizeFileUploadResponse()
oss_config = oss_models.Config(access_key_secret=access_key_secret,
type="access_key",
protocol=self._protocol,
region_id=self._region_id)
oss_client = None
file_obj = file_form_models.FileField()
oss_header = oss_models.PostObjectRequestHeader()
upload_request = oss_models.PostObjectRequest()
oss_runtime = ossutil_models.RuntimeOptions()
RPCUtilClient.convert(runtime, oss_runtime)
create_pid_data_sourcereq = brain_industrial_20200920_models.CreatePidDataSourceRequest(
)
RPCUtilClient.convert(request, create_pid_data_sourcereq)
auth_response = auth_client.authorize_file_upload_with_options(
auth_request, runtime)
oss_config.access_key_id = auth_response.access_key_id
oss_config.endpoint = RPCUtilClient.get_endpoint(
auth_response.endpoint, auth_response.use_accelerate,
self._endpoint_type)
oss_client = OSSClient(oss_config)
file_obj = file_form_models.FileField(
filename=auth_response.object_key,
content=request.oss_path_object,
content_type="")
oss_header = oss_models.PostObjectRequestHeader(
access_key_id=auth_response.access_key_id,
policy=auth_response.encoded_policy,
signature=auth_response.signature,
key=auth_response.object_key,
file=file_obj,
success_action_status="201")
upload_request = oss_models.PostObjectRequest(
bucket_name=auth_response.bucket, header=oss_header)
oss_client.post_object(upload_request, oss_runtime)
create_pid_data_sourcereq.oss_path = "http://" + str(
auth_response.bucket) + "." + str(
auth_response.endpoint) + "/" + str(
auth_response.object_key) + ""
create_pid_data_source_resp = self.create_pid_data_source(
create_pid_data_sourcereq, runtime)
return create_pid_data_source_resp
def search_image_by_pic_advance(self, request, runtime):
# Step 0: init client
access_key_id = self._credential.get_access_key_id()
access_key_secret = self._credential.get_access_key_secret()
auth_config = rpc_models.Config(access_key_id=access_key_id,
access_key_secret=access_key_secret,
type="access_key",
endpoint="openplatform.aliyuncs.com",
protocol=self._protocol,
region_id=self._region_id)
auth_client = OpenPlatformClient(auth_config)
auth_request = open_platform_models.AuthorizeFileUploadRequest(
product="ImageSearch", region_id=self._region_id)
auth_response = open_platform_models.AuthorizeFileUploadResponse()
oss_config = oss_models.Config(access_key_secret=access_key_secret,
type="access_key",
protocol=self._protocol,
region_id=self._region_id)
oss_client = None
file_obj = file_form_models.FileField()
oss_header = oss_models.PostObjectRequestHeader()
upload_request = oss_models.PostObjectRequest()
oss_runtime = ossutil_models.RuntimeOptions()
RPCUtilClient.convert(runtime, oss_runtime)
search_image_by_picreq = image_search_20200212_models.SearchImageByPicRequest(
)
RPCUtilClient.convert(request, search_image_by_picreq)
auth_response = auth_client.authorize_file_upload_with_options(
auth_request, runtime)
oss_config.access_key_id = auth_response.access_key_id
oss_config.endpoint = RPCUtilClient.get_endpoint(
auth_response.endpoint, auth_response.use_accelerate,
self._endpoint_type)
oss_client = OSSClient(oss_config)
file_obj = file_form_models.FileField(
filename=auth_response.object_key,
content=request.pic_content_object,
content_type="")
oss_header = oss_models.PostObjectRequestHeader(
access_key_id=auth_response.access_key_id,
policy=auth_response.encoded_policy,
signature=auth_response.signature,
key=auth_response.object_key,
file=file_obj,
success_action_status="201")
upload_request = oss_models.PostObjectRequest(
bucket_name=auth_response.bucket, header=oss_header)
oss_client.post_object(upload_request, oss_runtime)
search_image_by_picreq.pic_content = "http://" + str(
auth_response.bucket) + "." + str(
auth_response.endpoint) + "/" + str(
auth_response.object_key) + ""
search_image_by_pic_resp = self.search_image_by_pic(
search_image_by_picreq, runtime)
return search_image_by_pic_resp
def segment_video_body_advance(self, request, runtime):
# Step 0: init client
access_key_id = self._credential.get_access_key_id()
access_key_secret = self._credential.get_access_key_secret()
auth_config = rpc_models.Config(access_key_id=access_key_id,
access_key_secret=access_key_secret,
type="access_key",
endpoint="openplatform.aliyuncs.com",
protocol=self._protocol,
region_id=self._region_id)
auth_client = OpenPlatformClient(auth_config)
auth_request = open_platform_models.AuthorizeFileUploadRequest(
product="videoseg", region_id=self._region_id)
auth_response = auth_client.authorize_file_upload_with_options(
auth_request, runtime)
# Step 1: request OSS api to upload file
oss_config = oss_models.Config(
access_key_id=auth_response.access_key_id,
access_key_secret=access_key_secret,
type="access_key",
endpoint=RPCUtilClient.get_endpoint(auth_response.endpoint,
auth_response.use_accelerate,
self._endpoint_type),
protocol=self._protocol,
region_id=self._region_id)
oss_client = OSSClient(oss_config)
file_obj = file_form_models.FileField(
filename=auth_response.object_key,
content=request.video_url_object,
content_type="")
oss_header = oss_models.PostObjectRequestHeader(
access_key_id=auth_response.access_key_id,
policy=auth_response.encoded_policy,
signature=auth_response.signature,
key=auth_response.object_key,
file=file_obj,
success_action_status="201")
upload_request = oss_models.PostObjectRequest(
bucket_name=auth_response.bucket, header=oss_header)
oss_runtime = ossutil_models.RuntimeOptions()
RPCUtilClient.convert(runtime, oss_runtime)
oss_client.post_object(upload_request, oss_runtime)
# Step 2: request final api
segment_video_bodyreq = videoseg_20200320_models.SegmentVideoBodyRequest(
)
RPCUtilClient.convert(request, segment_video_bodyreq)
segment_video_bodyreq.video_url = "http://" + str(
auth_response.bucket) + "." + str(
auth_response.endpoint) + "/" + str(
auth_response.object_key) + ""
segment_video_body_resp = self.segment_video_body(
segment_video_bodyreq, runtime)
return segment_video_body_resp
def make_super_resolution_image_advance(self, request, runtime):
# Step 0: init client
access_key_id = self._credential.get_access_key_id()
access_key_secret = self._credential.get_access_key_secret()
auth_config = _rpc_models.Config(access_key_id=access_key_id,
access_key_secret=access_key_secret,
type="access_key",
endpoint="openplatform.aliyuncs.com",
protocol=self._protocol,
region_id=self._region_id)
auth_client = OpenPlatformClient(auth_config)
auth_request = open_platform_models.AuthorizeFileUploadRequest(
product="imageenhan", region_id=self._region_id)
auth_response = auth_client.authorize_file_upload_with_options(
auth_request, runtime)
# Step 1: request OSS api to upload file
oss_config = _oss_models.Config(
access_key_id=auth_response.access_key_id,
access_key_secret=access_key_secret,
type="access_key",
endpoint=RPCUtilClient.get_endpoint(auth_response.endpoint,
auth_response.use_accelerate,
self._endpoint_type),
protocol=self._protocol,
region_id=self._region_id)
oss_client = OSSClient(oss_config)
file_obj = file_form_models.FileField(
filename=auth_response.object_key,
content=request.url_object,
content_type="")
oss_header = _oss_models.PostObjectRequestHeader(
access_key_id=auth_response.access_key_id,
policy=auth_response.encoded_policy,
signature=auth_response.signature,
key=auth_response.object_key,
file=file_obj,
success_action_status="201")
upload_request = _oss_models.PostObjectRequest(
bucket_name=auth_response.bucket, header=oss_header)
oss_runtime = ossutil_models.RuntimeOptions()
RPCUtilClient.convert(runtime, oss_runtime)
oss_client.post_object(upload_request, oss_runtime)
# Step 2: request final api
make_super_resolution_imagereq = imageenhan_20190930_models.MakeSuperResolutionImageRequest(
)
RPCUtilClient.convert(request, make_super_resolution_imagereq)
make_super_resolution_imagereq.url = "http://" + str(
auth_response.bucket) + "." + str(
auth_response.endpoint) + "/" + str(
auth_response.object_key) + ""
make_super_resolution_image_resp = self.make_super_resolution_image(
make_super_resolution_imagereq, runtime)
return make_super_resolution_image_resp
def test_has_error(self):
self.assertTrue(Client.has_error(None))
dic = {}
self.assertFalse(Client.has_error(dic))
dic["Code"] = "a"
self.assertTrue(Client.has_error(dic))
dic["Code"] = "1"
self.assertTrue(Client.has_error(dic))
dic["Code"] = "0"
self.assertFalse(Client.has_error(dic))
def test_get_open_plat_form_endpoint(self):
self.assertEqual(
"openplatform.aliyuncs.com",
Client.get_open_plat_form_endpoint("openplatform.aliyuncs.com",
""))
self.assertEqual(
"openplatform.aliyuncs.com",
Client.get_open_plat_form_endpoint("openplatform.aliyuncs.com",
"cn-hangzhou"))
self.assertEqual(
"openplatform.ap-northeast-1.aliyuncs.com",
Client.get_open_plat_form_endpoint("openplatform.aliyuncs.com",
"ap-northeast-1"))
def test_convert(self):
filename = module_path + "/test_open.txt"
with open(filename) as f:
model = TestClient.TestConvertModel()
model.dic["key"] = "value"
model.dic["testKey"] = "testValue"
sub_model = TestClient.TestConvertSubModel()
model.sub_model = sub_model
model.file = f
map_model = TestClient.TestConvertMapModel()
Client.convert(model, map_model)
self.assertIsNotNone(map_model)
self.assertEqual("test", map_model.requestId)
self.assertEqual(0, map_model.extendId)
self.assertEqual(2, map_model.sub_model.id)
def test_http_api_with_options(self, tmp, runtime):
UtilClient.validate_model(tmp)
request = ft_20180713_models.TestHttpApiShrinkRequest()
RPCUtilClient.convert(tmp, request)
if not UtilClient.is_unset(tmp.string_value):
request.string_value_shrink = UtilClient.to_jsonstring(
tmp.string_value)
if not UtilClient.is_unset(tmp.default_value):
request.default_value_shrink = UtilClient.to_jsonstring(
tmp.default_value)
if not UtilClient.is_unset(tmp.other_param):
request.other_param_shrink = UtilClient.to_jsonstring(
tmp.other_param)
return ft_20180713_models.TestHttpApiResponse().from_map(
self.do_request("TestHttpApi", "HTTPS", "POST", "2018-07-13", "AK",
None, request.to_map(), runtime))
def do_request(
self,
version: str,
action: str,
protocol: str,
method: str,
pathname: str,
request: dict,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> dict:
"""
Encapsulate the request and invoke the network
@param action: api name
@param protocol: http or https
@param method: e.g. GET
@param pathname: pathname of every api
@param request: which contains request params
@param runtime: which controls some details of call api, such as retry times
@return: the response
"""
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),
'httpProxy':
UtilClient.default_string(runtime.http_proxy, self._http_proxy),
'httpsProxy':
UtilClient.default_string(runtime.https_proxy, self._https_proxy),
'noProxy':
UtilClient.default_string(runtime.no_proxy, self._no_proxy),
'maxIdleConns':
UtilClient.default_number(runtime.max_idle_conns,
self._max_idle_conns),
'maxIdleTimeMillis':
self._max_idle_time_millis,
'keepAliveDurationMillis':
self._keep_alive_duration_millis,
'maxRequests':
self._max_requests,
'maxRequestsPerHost':
self._max_requests_per_host,
'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(
self._protocol, protocol)
_request.method = method
_request.pathname = pathname
_request.query = {
'method': action,
'version': version,
'sign_type': 'HmacSHA1',
'req_time': AntchainUtils.get_timestamp(),
'req_msg_id': AntchainUtils.get_nonce(),
'access_key': self._access_key_id,
'base_sdk_version': 'TeaSDK-2.0',
'sdk_version': '1.1.8'
}
if not UtilClient.empty(self._security_token):
_request.query['security_token'] = self._security_token
_request.headers = TeaCore.merge(
{
'host':
UtilClient.default_string(
self._endpoint, 'openapi.antchain.antgroup.com'),
'user-agent':
UtilClient.get_user_agent(self._user_agent)
}, headers)
tmp = UtilClient.anyify_map_value(RPCUtilClient.query(request))
_request.body = UtilClient.to_form_string(tmp)
_request.headers[
'content-type'] = 'application/x-www-form-urlencoded'
signed_param = TeaCore.merge(_request.query,
RPCUtilClient.query(request))
_request.query['sign'] = AntchainUtils.get_signature(
signed_param, self._access_key_secret)
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
raw = UtilClient.read_as_string(_response.body)
obj = UtilClient.parse_json(raw)
res = UtilClient.assert_as_map(obj)
resp = UtilClient.assert_as_map(res.get('response'))
if AntchainUtils.has_error(raw, self._access_key_secret):
raise TeaException({
'message': resp.get('result_msg'),
'data': resp,
'code': resp.get('result_code')
})
return resp
except Exception as e:
if TeaCore.is_retryable(e):
_last_exception = e
continue
raise e
raise UnretryableException(_last_request, _last_exception)
def do_request(self, version, action, protocol, method, pathname, request, runtime):
"""
Encapsulate the request and invoke the network
:type action: str
:param action: api name
:type protocol: str
:param protocol: http or https
:type method: str
:param method: e.g. GET
:type pathname: str
:param pathname: pathname of every api
:type request: dict
:param request: which contains request params
:param runtime: which controls some details of call api, such as retry times
:return: the response
"""
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),
"httpProxy": UtilClient.default_string(runtime.http_proxy, self._http_proxy),
"httpsProxy": UtilClient.default_string(runtime.https_proxy, self._https_proxy),
"noProxy": UtilClient.default_string(runtime.no_proxy, self._no_proxy),
"maxIdleConns": UtilClient.default_number(runtime.max_idle_conns, self._max_idle_conns),
"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(self._protocol, protocol)
_request.method = method
_request.pathname = pathname
_request.query = {
"method": action,
"version": version,
"sign_type": "HmacSHA1",
"req_time": AlipayUtilClient.get_timestamp(),
"req_msg_id": UtilClient.get_nonce(),
"access_key": self._access_key_id,
"charset": "UTF-8",
"baseSdkVersion": "Tea-SDK",
"sdkVersion": "Tea-SDK-20200804"
}
if not UtilClient.empty(self._security_token):
_request.query["security_token"] = self._security_token
_request.headers = {
"host": self._endpoint,
"user-agent": self.get_user_agent()
}
tmp = UtilClient.anyify_map_value(RPCUtilClient.query(request))
_request.body = UtilClient.to_form_string(tmp)
_request.headers["content-type"] = "application/x-www-form-urlencoded"
signed_param = TeaCore.merge(_request.query,
RPCUtilClient.query(request))
_request.query["sign"] = AlipayUtilClient.get_signature(signed_param, self._access_key_secret)
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
obj = UtilClient.read_as_json(_response.body)
res = UtilClient.assert_as_map(obj)
resp = UtilClient.assert_as_map(res.get('response'))
if AlipayUtilClient.has_error(res):
raise TeaException({
"message": resp.get('result_msg'),
"data": resp,
"code": resp.get('result_code')
})
return resp
except Exception as e:
if TeaCore.is_retryable(e):
_last_exception = e
continue
raise e
raise UnretryableException(_last_request, _last_exception)
def test_get_signature_v1(self):
query = {'query': 'test', 'body': 'test'}
result = Client.get_signature_v1(query, 'GET', 'secret')
self.assertEqual("XlUyV4sXjOuX5FnjUz9IF9tm5rU=", result)
def test_get_signature(self):
request = TeaRequest()
request.query["query"] = "test"
request.query["body"] = "test"
result = Client.get_signature(request, "secret")
self.assertEqual("XlUyV4sXjOuX5FnjUz9IF9tm5rU=", result)
def test_get_host(self):
self.assertEqual("testEndpoint",
Client.get_host("", "", "testEndpoint"))
self.assertEqual("cc.CN.aliyuncs.com",
Client.get_host("CC_CN", "CN", None))
def test_get_timestamp(self):
self.assertIsNotNone(Client.get_timestamp())
self.assertIn("T", Client.get_timestamp())
self.assertIn("Z", Client.get_timestamp())
def do_request(self, action, protocol, method, version, auth_type, query, body, runtime):
"""
Encapsulate the request and invoke the network
@type action: unicode
@param action: api name
@type protocol: unicode
@param protocol: http or https
@type method: unicode
@param method: e.g. GET
@type version: unicode
@param version: product version
@type auth_type: unicode
@param auth_type: when authType is Anonymous, the signature will not be calculate
@param pathname: pathname of every api
@type query: dict
@param query: which contains request params
@type body: dict
@param body: content of request
@param runtime: which controls some details of call api, such as retry times
@rtype: dict
@return: the response
"""
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),
'httpProxy': UtilClient.default_string(runtime.http_proxy, self._http_proxy),
'httpsProxy': UtilClient.default_string(runtime.https_proxy, self._https_proxy),
'noProxy': UtilClient.default_string(runtime.no_proxy, self._no_proxy),
'maxIdleConns': UtilClient.default_number(runtime.max_idle_conns, self._max_idle_conns),
'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(self._protocol, protocol)
_request.method = method
_request.pathname = '/'
_request.query = RPCUtilClient.query(TeaCore.merge({
'Action': action,
'Format': 'json',
'Timestamp': RPCUtilClient.get_timestamp(),
'Version': version,
'SignatureNonce': UtilClient.get_nonce()
}, query))
# endpoint is setted in product client
_request.headers = {
'x-acs-version': version,
'x-acs-action': action,
'host': self._endpoint,
'user-agent': self.get_user_agent()
}
if not UtilClient.is_unset(body):
tmp = UtilClient.anyify_map_value(RPCUtilClient.query(body))
_request.body = UtilClient.to_form_string(tmp)
_request.headers['content-type'] = 'application/x-www-form-urlencoded'
if not UtilClient.equal_string(auth_type, 'Anonymous'):
access_key_id = self.get_access_key_id()
access_key_secret = self.get_access_key_secret()
security_token = self.get_security_token()
if not UtilClient.empty(security_token):
_request.query['SecurityToken'] = security_token
_request.query['SignatureMethod'] = 'HMAC-SHA1'
_request.query['SignatureVersion'] = '1.0'
_request.query['AccessKeyId'] = access_key_id
signed_param = TeaCore.merge(_request.query,
RPCUtilClient.query(body))
_request.query['Signature'] = RPCUtilClient.get_signature_v1(signed_param, _request.method, access_key_secret)
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
obj = UtilClient.read_as_json(_response.body)
res = UtilClient.assert_as_map(obj)
if UtilClient.is_4xx(_response.status_code) or UtilClient.is_5xx(_response.status_code):
raise TeaException({
'code': '%s' % TeaConverter.to_unicode(self.default_any(res.get('Code'), res.get('code'))),
'message': 'code: %s, %s request id: %s' % (TeaConverter.to_unicode(_response.status_code), TeaConverter.to_unicode(self.default_any(res.get('Message'), res.get('message'))), TeaConverter.to_unicode(self.default_any(res.get('RequestId'), res.get('requestId')))),
'data': res
})
return res
except Exception as e:
if TeaCore.is_retryable(e):
_last_exception = e
continue
raise e
raise UnretryableException(_last_request, _last_exception)
