def __init__(
self,
config: rpc_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"
})
UtilClient.validate_model(config)
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,
security_token=config.security_token)
self._credential = CredentialClient(credential_config)
elif not UtilClient.is_unset(config.credential):
self._credential = config.credential
else:
raise TeaException({
'code':
'ParameterMissing',
'message':
"'accessKeyId' and 'accessKeySecret' or 'credential' can not be unset"
})
self._network = config.network
self._suffix = config.suffix
self._endpoint = config.endpoint
self._protocol = config.protocol
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._http_proxy = config.http_proxy
self._https_proxy = config.https_proxy
self._no_proxy = config.no_proxy
self._socks_5proxy = config.socks_5proxy
self._socks_5net_work = config.socks_5net_work
self._max_idle_conns = config.max_idle_conns
self._endpoint_type = config.endpoint_type
self._open_platform_endpoint = config.open_platform_endpoint
def __init__(
self,
config: demo_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"
})
self._access_key_id = config.access_key_id
self._access_key_secret = config.access_key_secret
self._security_token = config.security_token
self._endpoint = config.endpoint
self._protocol = config.protocol
self._user_agent = config.user_agent
self._read_timeout = config.read_timeout
self._connect_timeout = config.connect_timeout
self._http_proxy = config.http_proxy
self._https_proxy = config.https_proxy
self._no_proxy = config.no_proxy
self._socks_5proxy = config.socks_5proxy
self._socks_5net_work = config.socks_5net_work
self._max_idle_conns = config.max_idle_conns
def refresh_access_token(self):
tea_request = TeaRequest()
tea_request.method = "POST"
tea_request.pathname = "/v2/oauth/token"
headers = {
"host":
self._endpoint if self._endpoint else self._domain_id +
".api.aliyunpds.com",
"content-type":
"application/x-www-form-urlencoded; charset=utf-8",
"date":
datetime.datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT'),
"accept":
"application/json",
"x-acs-signature-method":
"HMAC-SHA1",
"x-acs-signature-version":
"1.0"
}
tea_request.headers = headers
body_str = "grant_type=refresh_token&refresh_token={0}&client_id={1}&client_secret={2}".format(
self._refresh_token, self._client_id, self._client_secret)
tea_request.body = bytes(body_str, encoding="utf-8")
response = TeaCore.do_action(tea_request)
dic = json.loads(str(response.body, encoding="utf-8"))
if response.status_code == 200:
self._expire_time = dic.get("expire_time")
self._access_token = dic.get("access_token")
self._refresh_token = dic.get("refresh_token")
else:
raise TeaException(dic)
def __refresh_access_token(self):
tea_request = TeaRequest()
tea_request.method = "POST"
tea_request.pathname = "/v2/oauth/token"
headers = {
"host": self.__get_host(self.__endpoint, self.__domain_id + ".api.alicloudccp.com"),
"content-type": "application/x-www-form-urlencoded; charset=utf-8",
"date": datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT'),
"accept": "application/json",
"x-acs-signature-method": "HMAC-SHA1",
"x-acs-signature-version": "1.0"
}
tea_request.headers = headers
body_str = "grant_type=refresh_token&refresh_token={0}&client_id={1}&client_secret={2}".format(
self.__refresh_token, self.__client_id, self.__client_secret)
tea_request.body = bytes(body_str, encoding="utf-8")
response = TeaCore.do_action(tea_request)
dic = json.loads(str(response.body, encoding="utf-8"))
if 400 <= response.status_code < 600:
raise TeaException({
"code": str(dic.get('code')) + "Error",
"message": "code: " + str(response.status_code) + ", " + str(dic.get('message')) +
" requestid: " + str(dic.get('requestId')),
"data": dic
})
else:
self.__expire_time = dic.get("expire_time")
self.__access_token = dic.get("access_token")
self.__refresh_token = dic.get("refresh_token")
def __init__(
self,
config: industry_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"
})
self._access_key_id = config.access_key_id
self._access_key_secret = config.access_key_secret
self._security_token = config.security_token
self._endpoint = config.endpoint
self._protocol = config.protocol
self._user_agent = config.user_agent
self._read_timeout = UtilClient.default_number(config.read_timeout, 20000)
self._connect_timeout = UtilClient.default_number(config.connect_timeout, 20000)
self._http_proxy = config.http_proxy
self._https_proxy = config.https_proxy
self._no_proxy = config.no_proxy
self._socks_5proxy = config.socks_5proxy
self._socks_5net_work = config.socks_5net_work
self._max_idle_conns = UtilClient.default_number(config.max_idle_conns, 60000)
self._max_idle_time_millis = UtilClient.default_number(config.max_idle_time_millis, 5)
self._keep_alive_duration_millis = UtilClient.default_number(config.keep_alive_duration_millis, 5000)
self._max_requests = UtilClient.default_number(config.max_requests, 100)
self._max_requests_per_host = UtilClient.default_number(config.max_requests_per_host, 100)
def get_access_token(self):
if self._access_token is None:
raise TeaException('access token is None')
if self.should_refresh():
self.refresh_access_token()
return self._access_token
def __init__(self,
config,
_endpoint=None,
_region_id=None,
_access_key_id=None,
_access_key_secret=None,
_protocol=None,
_user_agent=None,
_read_timeout=None,
_connect_timeout=None,
_http_proxy=None,
_https_proxy=None,
_socks_5proxy=None,
_socks_5net_work=None,
_no_proxy=None,
_max_idle_conns=None,
_security_token=None):
"""
Init client with Config
@param config: config contains the necessary information to create a client
"""
self._endpoint = _endpoint
self._region_id = _region_id
self._access_key_id = _access_key_id
self._access_key_secret = _access_key_secret
self._protocol = _protocol
self._user_agent = _user_agent
self._read_timeout = _read_timeout
self._connect_timeout = _connect_timeout
self._http_proxy = _http_proxy
self._https_proxy = _https_proxy
self._socks_5proxy = _socks_5proxy
self._socks_5net_work = _socks_5net_work
self._no_proxy = _no_proxy
self._max_idle_conns = _max_idle_conns
self._security_token = _security_token
if UtilClient.is_unset(config):
raise TeaException({
"code": "ParameterMissing",
"message": "'config' can not be unset"
})
self._access_key_id = config.access_key_id
self._access_key_secret = config.access_key_secret
self._security_token = config.security_token
self._endpoint = config.endpoint
self._protocol = config.protocol
self._user_agent = config.user_agent
self._read_timeout = config.read_timeout
self._connect_timeout = config.connect_timeout
self._http_proxy = config.http_proxy
self._https_proxy = config.https_proxy
self._no_proxy = config.no_proxy
self._socks_5proxy = config.socks_5proxy
self._socks_5net_work = config.socks_5net_work
self._max_idle_conns = config.max_idle_conns
def test_tea_exception(self):
dic = {"code": "200", "message": "message", "data": {"test": "test"}}
try:
raise TeaException(dic)
except TeaException as e:
self.assertIsNotNone(e)
self.assertEqual("200", e.code)
self.assertEqual("message", e.message)
self.assertIsNotNone(e.data)
self.assertEqual("test", e.data.get("test"))
def check_config(self, config):
"""
If the endpointRule and config.endpoint are empty, throw error
@param config: config contains the necessary information to create a client
"""
if UtilClient.empty(self._endpoint_rule) and UtilClient.empty(config.endpoint):
raise TeaException({
'code': 'ParameterMissing',
'message': "'config.endpoint' can not be empty"
})
def call_api(self, params, request, runtime):
if UtilClient.is_unset(params):
raise TeaException({
'code': 'ParameterMissing',
'message': "'params' can not be unset"
})
if UtilClient.is_unset(self._signature_algorithm) or not UtilClient.equal_string(self._signature_algorithm, 'v2'):
return self.do_request(params, request, runtime)
elif UtilClient.equal_string(params.style, 'ROA') and UtilClient.equal_string(params.req_body_type, 'json'):
return self.do_roarequest(params.action, params.version, params.protocol, params.method, params.auth_type, params.pathname, params.body_type, request, runtime)
elif UtilClient.equal_string(params.style, 'ROA'):
return self.do_roarequest_with_form(params.action, params.version, params.protocol, params.method, params.auth_type, params.pathname, params.body_type, request, runtime)
else:
return self.do_rpcrequest(params.action, params.version, params.protocol, params.method, params.auth_type, params.body_type, request, runtime)
def put_object(item, headers, url_path):
"""
Upload item with urlPath
@param item the file
@param url_path the upload url
"""
response = requests.put(url_path, headers=headers, data=item)
if 400 <= response.status_code < 600:
err = get_err_message(response.text)
if err.get('Code') and err['Code'] == 'CallbackFailed':
return
raise TeaException({
'code': err.get('Code'),
'message': err.get('Message'),
'data': {
'httpCode': response.status_code,
'requestId': err.get('requestId'),
'hostId': err.get('hostId')
}
})
def __init__(
self,
config: open_search_models.Config,
):
if UtilClient.is_unset(config):
raise TeaException({
'name': 'ParameterMissing',
'message': "'config' can not be unset"
})
if UtilClient.empty(config.type):
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,
security_token=config.security_token)
self._credential = CredentialClient(credential_config)
self._endpoint = config.endpoint
self._protocol = config.protocol
self._user_agent = config.user_agent
def test_unretryable_exception(self):
request = TeaRequest()
ex = RetryError("test exception")
try:
raise UnretryableException(request, ex)
except UnretryableException as e:
self.assertIsNotNone(e)
self.assertIsNotNone(e.last_request)
self.assertEqual("test exception", str(e.inner_exception))
e = TeaException({
'code': 'error code',
'message': 'error message',
'data': 'data',
})
try:
raise UnretryableException(request, e)
except UnretryableException as e:
self.assertEqual('Error: error code error message Response: data', str(e))
self.assertEqual('error code', e.inner_exception.code)
self.assertEqual('error message', e.inner_exception.message)
self.assertEqual('data', e.inner_exception.data)
def test_is_retryable(self):
self.assertFalse(TeaCore.is_retryable("test"))
ex = TeaException({})
self.assertFalse(TeaCore.is_retryable(ex))
ex = RetryError('error')
self.assertTrue(TeaCore.is_retryable(ex))
def do_rpcrequest(self, action, version, protocol, method, auth_type, body_type, request, runtime):
"""
Encapsulate the request and invoke the network
@type action: str
@param action: api name
@type version: str
@param version: product version
@type protocol: str
@param protocol: http or https
@type method: str
@param method: e.g. GET
@type auth_type: str
@param auth_type: authorization type e.g. AK
@type body_type: str
@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
@rtype: dict
@return: the response
"""
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),
'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),
'socks5Proxy': UtilClient.default_string(runtime.socks_5proxy, self._socks_5proxy),
'socks5NetWork': UtilClient.default_string(runtime.socks_5net_work, self._socks_5net_work),
'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 = TeaCore.merge({
'Action': action,
'Format': 'json',
'Version': version,
'Timestamp': OpenApiUtilClient.get_timestamp(),
'SignatureNonce': UtilClient.get_nonce()
}, request.query)
headers = self.get_rpc_headers()
if UtilClient.is_unset(headers):
# endpoint is setted in product client
_request.headers = {
'host': self._endpoint,
'x-acs-version': version,
'x-acs-action': action,
'user-agent': self.get_user_agent()
}
else:
_request.headers = TeaCore.merge({
'host': self._endpoint,
'x-acs-version': version,
'x-acs-action': action,
'user-agent': self.get_user_agent()
}, headers)
if not UtilClient.is_unset(request.body):
m = UtilClient.assert_as_map(request.body)
tmp = UtilClient.anyify_map_value(OpenApiUtilClient.query(m))
_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
t = None
if not UtilClient.is_unset(request.body):
t = UtilClient.assert_as_map(request.body)
signed_param = TeaCore.merge(_request.query,
OpenApiUtilClient.query(t))
_request.query['Signature'] = OpenApiUtilClient.get_rpcsignature(signed_param, _request.method, access_key_secret)
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
if UtilClient.is_4xx(_response.status_code) or UtilClient.is_5xx(_response.status_code):
_res = UtilClient.read_as_json(_response.body)
err = UtilClient.assert_as_map(_res)
request_id = self.default_any(err.get('RequestId'), err.get('requestId'))
raise TeaException({
'code': '%s' % TeaConverter.to_unicode(self.default_any(err.get('Code'), err.get('code'))),
'message': 'code: %s, %s request id: %s' % (TeaConverter.to_unicode(_response.status_code), TeaConverter.to_unicode(self.default_any(err.get('Message'), err.get('message'))), TeaConverter.to_unicode(request_id)),
'data': err
})
if UtilClient.equal_string(body_type, 'binary'):
resp = {
'body': _response.body,
'headers': _response.headers
}
return resp
elif UtilClient.equal_string(body_type, 'byte'):
byt = UtilClient.read_as_bytes(_response.body)
return {
'body': byt,
'headers': _response.headers
}
elif UtilClient.equal_string(body_type, 'string'):
str = UtilClient.read_as_string(_response.body)
return {
'body': str,
'headers': _response.headers
}
elif UtilClient.equal_string(body_type, 'json'):
obj = UtilClient.read_as_json(_response.body)
res = UtilClient.assert_as_map(obj)
return {
'body': res,
'headers': _response.headers
}
elif UtilClient.equal_string(body_type, 'array'):
arr = UtilClient.read_as_json(_response.body)
return {
'body': arr,
'headers': _response.headers
}
else:
return {
'headers': _response.headers
}
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, params, request, runtime):
"""
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
@rtype: dict
@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),
'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),
'socks5Proxy': UtilClient.default_string(runtime.socks_5proxy, self._socks_5proxy),
'socks5NetWork': UtilClient.default_string(runtime.socks_5net_work, self._socks_5net_work),
'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, params.protocol)
_request.method = params.method
_request.pathname = params.pathname
_request.query = request.query
# endpoint is setted in product client
_request.headers = TeaCore.merge({
'host': self._endpoint,
'x-acs-version': params.version,
'x-acs-action': params.action,
'user-agent': self.get_user_agent(),
'x-acs-date': OpenApiUtilClient.get_timestamp(),
'x-acs-signature-nonce': UtilClient.get_nonce(),
'accept': 'application/json'
}, request.headers)
if UtilClient.equal_string(params.style, 'RPC'):
headers = self.get_rpc_headers()
if not UtilClient.is_unset(headers):
_request.headers = TeaCore.merge(_request.headers,
headers)
signature_algorithm = UtilClient.default_string(self._signature_algorithm, 'ACS3-HMAC-SHA256')
hashed_request_payload = OpenApiUtilClient.hex_encode(OpenApiUtilClient.hash(UtilClient.to_bytes(''), signature_algorithm))
if not UtilClient.is_unset(request.stream):
tmp = UtilClient.read_as_bytes(request.stream)
hashed_request_payload = OpenApiUtilClient.hex_encode(OpenApiUtilClient.hash(tmp, signature_algorithm))
_request.body = tmp
_request.headers['content-type'] = 'application/octet-stream'
else:
if not UtilClient.is_unset(request.body):
if UtilClient.equal_string(params.req_body_type, 'json'):
json_obj = UtilClient.to_jsonstring(request.body)
hashed_request_payload = OpenApiUtilClient.hex_encode(OpenApiUtilClient.hash(UtilClient.to_bytes(json_obj), signature_algorithm))
_request.body = json_obj
_request.headers['content-type'] = 'application/json; charset=utf-8'
else:
m = UtilClient.assert_as_map(request.body)
form_obj = OpenApiUtilClient.to_form(m)
hashed_request_payload = OpenApiUtilClient.hex_encode(OpenApiUtilClient.hash(UtilClient.to_bytes(form_obj), signature_algorithm))
_request.body = form_obj
_request.headers['content-type'] = 'application/x-www-form-urlencoded'
_request.headers['x-acs-content-sha256'] = hashed_request_payload
if not UtilClient.equal_string(params.auth_type, 'Anonymous'):
auth_type = self.get_type()
if UtilClient.equal_string(auth_type, 'bearer'):
bearer_token = self.get_bearer_token()
_request.headers['x-acs-bearer-token'] = bearer_token
else:
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.headers['x-acs-accesskey-id'] = access_key_id
_request.headers['x-acs-security-token'] = security_token
_request.headers['Authorization'] = OpenApiUtilClient.get_authorization(_request, signature_algorithm, hashed_request_payload, access_key_id, access_key_secret)
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
if UtilClient.is_4xx(_response.status_code) or UtilClient.is_5xx(_response.status_code):
err = {}
if not UtilClient.is_unset(_response.headers.get('content-type')) and UtilClient.equal_string(_response.headers.get('content-type'), 'text/xml;charset=utf-8'):
_str = UtilClient.read_as_string(_response.body)
resp_map = XMLClient.parse_xml(_str, None)
err = UtilClient.assert_as_map(resp_map.get('Error'))
else:
_res = UtilClient.read_as_json(_response.body)
err = UtilClient.assert_as_map(_res)
err['statusCode'] = _response.status_code
raise TeaException({
'code': '%s' % TeaConverter.to_unicode(self.default_any(err.get('Code'), err.get('code'))),
'message': 'code: %s, %s request id: %s' % (TeaConverter.to_unicode(_response.status_code), TeaConverter.to_unicode(self.default_any(err.get('Message'), err.get('message'))), TeaConverter.to_unicode(self.default_any(err.get('RequestId'), err.get('requestId')))),
'data': err
})
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 {
'body': res,
'headers': _response.headers,
'statusCode': _response.status_code
}
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:
return {
'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 do_roarequest_with_form(self, action, version, protocol, method,
auth_type, pathname, body_type, request,
runtime):
"""
Encapsulate the request and invoke the network with form body
:type action: str
:param action: api name
:type version: str
:param version: product version
:type protocol: str
:param protocol: http or https
:type method: str
:param method: e.g. GET
:type auth_type: str
:param auth_type: authorization type e.g. AK
:type pathname: str
:param pathname: pathname of every api
:type body_type: str
: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
"""
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),
"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.headers = TeaCore.merge(
{
"date": UtilClient.get_date_utcstring(),
"host": self._endpoint,
"accept": "application/json",
"x-acs-signature-nonce": UtilClient.get_nonce(),
"x-acs-signature-method": "HMAC-SHA1",
"x-acs-signature-version": "1.0",
"x-acs-version": version,
"x-acs-action": action,
"user-agent": UtilClient.get_user_agent(
self._user_agent)
}, request.headers)
if not UtilClient.is_unset(request.body):
_request.body = OpenApiUtilClient.to_form(request.body)
_request.headers[
"content-type"] = "application/x-www-form-urlencoded"
if not UtilClient.is_unset(request.query):
_request.query = request.query
if not UtilClient.equal_string(auth_type, "Anonymous"):
access_key_id = self._credential.get_access_key_id()
access_key_secret = self._credential.get_access_key_secret(
)
security_token = self._credential.get_security_token()
if not UtilClient.empty(security_token):
_request.headers["x-acs-accesskey-id"] = access_key_id
_request.headers[
"x-acs-security-token"] = security_token
string_to_sign = OpenApiUtilClient.get_string_to_sign(
_request)
_request.headers["authorization"] = "acs " + str(
access_key_id) + ":" + str(
OpenApiUtilClient.get_roasignature(
string_to_sign, access_key_secret)) + ""
_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):
_res = UtilClient.read_as_json(_response.body)
err = UtilClient.assert_as_map(_res)
raise TeaException({
"message": err.get('Message'),
"data": err,
"code": err.get('Code')
})
if UtilClient.equal_string(body_type, "binary"):
resp = {
"body": _response.body,
"headers": _response.headers
}
return resp
elif UtilClient.equal_string(body_type, "byte"):
byt = UtilClient.read_as_bytes(_response.body)
return {"body": byt, "headers": _response.headers}
elif UtilClient.equal_string(body_type, "string"):
str = UtilClient.read_as_string(_response.body)
return {"body": str, "headers": _response.headers}
elif UtilClient.equal_string(body_type, "json"):
obj = UtilClient.read_as_json(_response.body)
res = UtilClient.assert_as_map(obj)
return {"body": res, "headers": _response.headers}
else:
return {"headers": _response.headers}
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 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)
def do_request(
self,
version: str,
protocol: str,
method: str,
auth_type: str,
pathname: str,
query: Dict[str, str],
headers: Dict[str, str],
body: Any,
runtime: util_models.RuntimeOptions,
) -> dict:
"""
Encapsulate the request and invoke the network
@param version: product version
@param protocol: http or https
@param method: e.g. GET
@param auth_type: when authType is Anonymous, the signature will not be calculate
@param pathname: pathname of every api
@param query: which contains request params
@param headers: request headers
@param body: content of request
@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.headers = TeaCore.merge(
{
'date': UtilClient.get_date_utcstring(),
'host': self._endpoint_host,
'accept': 'application/json',
'x-acs-signature-nonce': UtilClient.get_nonce(),
'x-acs-signature-method': 'HMAC-SHA1',
'x-acs-signature-version': '1.0',
'x-acs-version': version,
'user-agent': UtilClient.get_user_agent(
self._user_agent),
# x-sdk-client': helper.DEFAULT_CLIENT
},
headers)
if not UtilClient.is_unset(body):
_request.body = UtilClient.to_jsonstring(body)
_request.headers[
'content-type'] = 'application/json; charset=utf-8'
if not UtilClient.is_unset(query):
_request.query = query
if not UtilClient.equal_string(auth_type, 'Anonymous'):
access_key_id = self._credential.get_access_key_id()
access_key_secret = self._credential.get_access_key_secret(
)
security_token = self._credential.get_security_token()
if not UtilClient.empty(security_token):
_request.headers['x-acs-accesskey-id'] = access_key_id
_request.headers[
'x-acs-security-token'] = security_token
string_to_sign = ROAUtilClient.get_string_to_sign(_request)
_request.headers['authorization'] = 'acs %s:%s' % (
access_key_id,
ROAUtilClient.get_signature(string_to_sign,
access_key_secret))
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
if UtilClient.equal_number(_response.status_code, 204):
return {'headers': _response.headers}
result = UtilClient.read_as_json(_response.body)
if UtilClient.is_4xx(
_response.status_code) or UtilClient.is_5xx(
_response.status_code):
err = UtilClient.assert_as_map(result)
raise TeaException({
'code':
'%s' %
self.default_any(err.get('Code'), err.get('code')),
'message':
'code: %s, %s request id: %s' %
(_response.status_code,
self.default_any(err.get('Message'),
err.get('message')),
self.default_any(err.get('RequestId'),
err.get('requestId'))),
'data':
err
})
return {'headers': _response.headers, 'body': result}
except Exception as e:
if TeaCore.is_retryable(e):
_last_exception = e
continue
raise e
raise UnretryableException(_last_request, _last_exception)
def _request(
self,
method: str,
pathname: str,
query: Dict[str, Any],
headers: Dict[str, str],
body: Any,
runtime: util_models.RuntimeOptions,
) -> Dict[str, Any]:
runtime.validate()
_runtime = {
'timeouted': 'retry',
'readTimeout': runtime.read_timeout,
'connectTimeout': runtime.connect_timeout,
'httpProxy': runtime.http_proxy,
'httpsProxy': runtime.https_proxy,
'noProxy': runtime.no_proxy,
'maxIdleConns': runtime.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()
accesskey_id = self.get_access_key_id()
access_key_secret = self.get_access_key_secret()
_request.protocol = UtilClient.default_string(
self._protocol, 'HTTP')
_request.method = method
_request.pathname = pathname
_request.headers = TeaCore.merge(
{
'user-agent':
self.get_user_agent(),
'Date':
OpensearchUtil.get_date(),
'host':
UtilClient.default_string(
self._endpoint,
f'opensearch-cn-hangzhou.aliyuncs.com'),
'X-Opensearch-Nonce':
UtilClient.get_nonce()
}, headers)
if not UtilClient.is_unset(query):
_request.query = UtilClient.stringify_map_value(query)
if not UtilClient.is_unset(body):
req_body = UtilClient.to_jsonstring(body)
_request.headers[
'Content-MD5'] = OpensearchUtil.get_content_md5(
req_body)
_request.headers['Content-Type'] = 'application/json'
_request.body = req_body
_request.headers[
'Authorization'] = OpensearchUtil.get_signature(
_request, accesskey_id, access_key_secret)
_last_request = _request
_response = TeaCore.do_action(_request, _runtime)
obj_str = UtilClient.read_as_string(_response.body)
if UtilClient.is_4xx(
_response.status_code) or UtilClient.is_5xx(
_response.status_code):
raise TeaException({
'message': _response.status_message,
'data': obj_str,
'code': _response.status_code
})
obj = UtilClient.parse_json(obj_str)
res = UtilClient.assert_as_map(obj)
return {'body': res, 'headers': _response.headers}
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: 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 __init__(self,
config,
_endpoint=None,
_region_id=None,
_protocol=None,
_user_agent=None,
_endpoint_rule=None,
_endpoint_map=None,
_suffix=None,
_read_timeout=None,
_connect_timeout=None,
_http_proxy=None,
_https_proxy=None,
_socks_5proxy=None,
_socks_5net_work=None,
_no_proxy=None,
_network=None,
_product_id=None,
_max_idle_conns=None,
_endpoint_type=None,
_open_platform_endpoint=None,
_credential=None):
"""
Init client with Config
:param config: config contains the necessary information to create a client
"""
self._endpoint = _endpoint
self._region_id = _region_id
self._protocol = _protocol
self._user_agent = _user_agent
self._endpoint_rule = _endpoint_rule
self._endpoint_map = _endpoint_map
self._suffix = _suffix
self._read_timeout = _read_timeout
self._connect_timeout = _connect_timeout
self._http_proxy = _http_proxy
self._https_proxy = _https_proxy
self._socks_5proxy = _socks_5proxy
self._socks_5net_work = _socks_5net_work
self._no_proxy = _no_proxy
self._network = _network
self._product_id = _product_id
self._max_idle_conns = _max_idle_conns
self._endpoint_type = _endpoint_type
self._open_platform_endpoint = _open_platform_endpoint
self._credential = _credential
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,
security_token=config.security_token)
self._credential = CredentialClient(credential_config)
elif not UtilClient.is_unset(config.credential):
self._credential = config.credential
self._endpoint = config.endpoint
self._protocol = config.protocol
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._http_proxy = config.http_proxy
self._https_proxy = config.https_proxy
self._no_proxy = config.no_proxy
self._socks_5proxy = config.socks_5proxy
self._socks_5net_work = config.socks_5net_work
self._max_idle_conns = config.max_idle_conns
