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)