def tag_resources(self,
list_of_resource_id=None,
source_ip=None,
region_id=None,
scope=None,
tag_owner_uid=None,
tag_owner_bid=None,
list_of_tag=None,
resource_type=None):
api_request = APIRequest('TagResources', 'GET', 'http', 'RPC', 'query')
api_request._params = {
"ResourceId": list_of_resource_id,
"SourceIp": source_ip,
"RegionId": region_id,
"Scope": scope,
"TagOwnerUid": tag_owner_uid,
"TagOwnerBid": tag_owner_bid,
"Tag": list_of_tag,
"ResourceType": resource_type
}
repeat_info = {
"ResourceId": ('ResourceId', 'list', 'str', None),
"Tag": ('Tag', 'list', 'dict', [
('Value', 'str', None, None),
('Key', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def list_tag_resources(
self,
resource_owner_id=None,
list_of_resource_id=None,
resource_owner_account=None,
region_id=None,
next_token=None,
owner_account=None,
list_of_tag=None,
owner_id=None,
resource_type=None):
api_request = APIRequest('ListTagResources', 'GET', 'http', 'RPC', 'query')
api_request._params = {
"ResourceOwnerId": resource_owner_id,
"ResourceId": list_of_resource_id,
"ResourceOwnerAccount": resource_owner_account,
"RegionId": region_id,
"NextToken": next_token,
"OwnerAccount": owner_account,
"Tag": list_of_tag,
"OwnerId": owner_id,
"ResourceType": resource_type}
repeat_info = {"ResourceId": ('ResourceId', 'list', 'str', None),
"Tag": ('Tag', 'list', 'dict', [('Value', 'str', None, None),
('Key', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def describe_db_instances(self,
db_instance_ids=None,
region_id=None,
page_size=None,
db_instance_description=None,
list_of_tag=None,
owner_id=None,
instance_network_type=None,
page_number=None):
api_request = APIRequest('DescribeDBInstances', 'GET', 'http', 'RPC',
'query')
api_request._params = {
"DBInstanceIds": db_instance_ids,
"RegionId": region_id,
"PageSize": page_size,
"DBInstanceDescription": db_instance_description,
"Tag": list_of_tag,
"OwnerId": owner_id,
"InstanceNetworkType": instance_network_type,
"PageNumber": page_number
}
repeat_info = {
"Tag": ('Tag', 'list', 'dict', [
('Value', 'str', None, None),
('Key', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def add_omni_sec_check_config(self,
list_of_check_detail_dto_list=None,
name=None,
extras=None,
check_target=None,
conf_type=None):
api_request = APIRequest('AddOmniSecCheckConfig', 'POST', 'http',
'RPC', 'body')
api_request._params = {
"CheckDetailDTOList": list_of_check_detail_dto_list,
"Name": name,
"Extras": extras,
"CheckTarget": check_target,
"ConfType": conf_type
}
repeat_info = {
"CheckDetailDTOList": ('CheckDetailDTOList', 'list', 'dict', [
('CheckType', 'str', None, None),
('CheckIntervalUnit', 'str', None, None),
('CheckExtras', 'str', None, None),
('CheckIntervalVal', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def describe_certificate_list(self,
resource_group_id=None,
source_ip=None,
sort_type=None,
show_size=None,
sort_column=None,
current_page=None,
list_of_tag=None,
lang=None,
keyword=None,
status=None):
api_request = APIRequest('DescribeCertificateList', 'GET', 'http',
'RPC', 'query')
api_request._params = {
"ResourceGroupId": resource_group_id,
"SourceIp": source_ip,
"SortType": sort_type,
"ShowSize": show_size,
"SortColumn": sort_column,
"CurrentPage": current_page,
"Tag": list_of_tag,
"Lang": lang,
"Keyword": keyword,
"Status": status
}
repeat_info = {
"Tag": ('Tag', 'list', 'dict', [
('Value', 'str', None, None),
('Key', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def list_vpc_info_by_vpc(self,
access_key_id=None,
resource_owner_id=None,
vpc_id=None,
page_size=None,
page_num=None,
list_of_tag_info=None):
api_request = APIRequest('ListVpcInfoByVpc', 'GET', 'http', 'RPC',
'query')
api_request._params = {
"access_key_id": access_key_id,
"ResourceOwnerId": resource_owner_id,
"VpcId": vpc_id,
"PageSize": page_size,
"PageNum": page_num,
"TagInfo": list_of_tag_info
}
repeat_info = {
"TagInfo": ('TagInfo', 'list', 'dict', [
('TagValue', 'str', None, None),
('TagKey', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def describe_db_clusters(
self,
resource_owner_id=None,
db_cluster_description=None,
db_cluster_status=None,
resource_owner_account=None,
owner_account=None,
owner_id=None,
page_number=None,
region_id=None,
db_type=None,
page_size=None,
list_of_tag=None,
db_cluster_ids=None):
api_request = APIRequest('DescribeDBClusters', 'GET', 'http', 'RPC', 'query')
api_request._params = {
"ResourceOwnerId": resource_owner_id,
"DBClusterDescription": db_cluster_description,
"DBClusterStatus": db_cluster_status,
"ResourceOwnerAccount": resource_owner_account,
"OwnerAccount": owner_account,
"OwnerId": owner_id,
"PageNumber": page_number,
"RegionId": region_id,
"DBType": db_type,
"PageSize": page_size,
"Tag": list_of_tag,
"DBClusterIds": db_cluster_ids}
repeat_info = {"Tag": ('Tag', 'list', 'dict', [('Value', 'str', None, None),
('Key', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def submit_generate_task(self,
image_count=None,
action_point=None,
logo_image_path=None,
type_=None,
list_of_major_image_path=None,
width=None,
list_of_copy_write=None,
list_of_property_id=None,
height=None):
api_request = APIRequest('SubmitGenerateTask', 'POST', 'http', 'RPC',
'query')
api_request._params = {
"ImageCount": image_count,
"ActionPoint": action_point,
"LogoImagePath": logo_image_path,
"Type": type_,
"MajorImagePath": list_of_major_image_path,
"Width": width,
"CopyWrite": list_of_copy_write,
"PropertyId": list_of_property_id,
"Height": height
}
repeat_info = {
"MajorImagePath": ('MajorImagePath', 'list', 'str', None),
"CopyWrite": ('CopyWrite', 'list', 'str', None),
"PropertyId": ('PropertyId', 'list', 'str', None),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def describe_risk_check_result(self,
resource_owner_id=None,
source_ip=None,
group_id=None,
list_of_item_ids=None,
name=None,
page_size=None,
current_page=None,
lang=None,
risk_level=None,
status=None):
api_request = APIRequest('DescribeRiskCheckResult', 'GET', 'http',
'RPC', 'query')
api_request._params = {
"ResourceOwnerId": resource_owner_id,
"SourceIp": source_ip,
"GroupId": group_id,
"ItemIds": list_of_item_ids,
"Name": name,
"PageSize": page_size,
"CurrentPage": current_page,
"Lang": lang,
"RiskLevel": risk_level,
"Status": status
}
repeat_info = {
"ItemIds": ('ItemIds', 'list', 'str', None),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def start_task(self,
list_of_mix_panes=None,
idempotent_id=None,
owner_id=None,
template_id=None,
app_id=None,
channel_id=None):
api_request = APIRequest('StartTask', 'GET', 'http', 'RPC', 'query')
api_request._params = {
"MixPanes": list_of_mix_panes,
"IdempotentId": idempotent_id,
"OwnerId": owner_id,
"TemplateId": template_id,
"AppId": app_id,
"ChannelId": channel_id
}
repeat_info = {
"MixPanes": ('MixPanes', 'list', 'dict', [
('PaneId', 'str', None, None),
('UserId', 'str', None, None),
('SourceType', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def redefine_tag(self,
option_type=None,
tag_name=None,
column_index=None,
tag_id=None,
tag_desc=None,
valid_time=None,
list_of_option_defines=None,
category_id=None,
file_id=None):
api_request = APIRequest('RedefineTag', 'GET', 'http', 'RPC', 'body')
api_request._params = {
"OptionType": option_type,
"TagName": tag_name,
"ColumnIndex": column_index,
"TagId": tag_id,
"TagDesc": tag_desc,
"ValidTime": valid_time,
"OptionDefines": list_of_option_defines,
"CategoryId": category_id,
"FileId": file_id
}
repeat_info = {
"OptionDefines": ('OptionDefines', 'list', 'dict', [
('Name', 'str', None, None),
('Define', 'str', None, None),
('Value', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def untag_resources(
self,
all_=None,
resource_owner_id=None,
list_of_resource_id=None,
resource_owner_account=None,
region_id=None,
owner_account=None,
owner_id=None,
list_of_tag_key=None,
resource_type=None):
api_request = APIRequest('UntagResources', 'GET', 'http', 'RPC', 'query')
api_request._params = {
"All": all_,
"ResourceOwnerId": resource_owner_id,
"ResourceId": list_of_resource_id,
"ResourceOwnerAccount": resource_owner_account,
"RegionId": region_id,
"OwnerAccount": owner_account,
"OwnerId": owner_id,
"TagKey": list_of_tag_key,
"ResourceType": resource_type}
repeat_info = {"ResourceId": ('ResourceId', 'list', 'str', None),
"TagKey": ('TagKey', 'list', 'str', None),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def describe_container_groups(
self,
resource_owner_id=None,
container_group_ids=None,
next_token=None,
limit=None,
tag=None,
resource_owner_account=None,
owner_account=None,
owner_id=None,
v_switch_id=None,
container_group_name=None,
zone_id=None,
status=None):
api_request = APIRequest('DescribeContainerGroups', 'GET', 'http', 'RPC', 'query')
api_request._params = {
"ResourceOwnerId": resource_owner_id,
"ContainerGroupIds": container_group_ids,
"NextToken": next_token,
"Limit": limit,
"Tag": tag,
"ResourceOwnerAccount": resource_owner_account,
"OwnerAccount": owner_account,
"OwnerId": owner_id,
"VSwitchId": v_switch_id,
"ContainerGroupName": container_group_name,
"ZoneId": zone_id,
"Status": status}
repeat_info = {"Tag": ('Tag', 'list', 'dict', [('Key', 'str', None, None),
('Value', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def modify_instance(self,
product_code=None,
instance_id=None,
client_token=None,
subscription_type=None,
modify_type=None,
list_of_parameter=None,
owner_id=None,
product_type=None):
api_request = APIRequest('ModifyInstance', 'GET', 'http', 'RPC',
'query')
api_request._params = {
"ProductCode": product_code,
"InstanceId": instance_id,
"ClientToken": client_token,
"SubscriptionType": subscription_type,
"ModifyType": modify_type,
"Parameter": list_of_parameter,
"OwnerId": owner_id,
"ProductType": product_type
}
repeat_info = {
"Parameter": ('Parameter', 'list', 'dict', [
('Code', 'str', None, None),
('Value', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def get_pay_as_you_go_price(self,
product_code=None,
subscription_type=None,
list_of_module_list=None,
owner_id=None,
region=None,
product_type=None):
api_request = APIRequest('GetPayAsYouGoPrice', 'GET', 'http', 'RPC',
'query')
api_request._params = {
"ProductCode": product_code,
"SubscriptionType": subscription_type,
"ModuleList": list_of_module_list,
"OwnerId": owner_id,
"Region": region,
"ProductType": product_type
}
repeat_info = {
"ModuleList": ('ModuleList', 'list', 'dict', [
('ModuleCode', 'str', None, None),
('PriceType', 'str', None, None),
('Config', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def create_instance(self,
product_code=None,
period=None,
client_token=None,
subscription_type=None,
renew_period=None,
list_of_parameter=None,
renewal_status=None,
owner_id=None,
product_type=None):
api_request = APIRequest('CreateInstance', 'GET', 'http', 'RPC',
'query')
api_request._params = {
"ProductCode": product_code,
"Period": period,
"ClientToken": client_token,
"SubscriptionType": subscription_type,
"RenewPeriod": renew_period,
"Parameter": list_of_parameter,
"RenewalStatus": renewal_status,
"OwnerId": owner_id,
"ProductType": product_type
}
repeat_info = {
"Parameter": ('Parameter', 'list', 'dict', [
('Code', 'str', None, None),
('Value', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def apply_invoice(self,
invoicing_type=None,
apply_user_nick=None,
invoice_by_amount=None,
customer_id=None,
list_of_selected_ids=None,
process_way=None,
caller_bid=None,
owner_id=None,
invoice_amount=None,
address_id=None,
caller_uid=None):
api_request = APIRequest('ApplyInvoice', 'GET', 'http', 'RPC', 'query')
api_request._params = {
"InvoicingType": invoicing_type,
"ApplyUserNick": apply_user_nick,
"InvoiceByAmount": invoice_by_amount,
"CustomerId": customer_id,
"SelectedIds": list_of_selected_ids,
"ProcessWay": process_way,
"callerBid": caller_bid,
"OwnerId": owner_id,
"InvoiceAmount": invoice_amount,
"AddressId": address_id,
"callerUid": caller_uid
}
repeat_info = {
"SelectedIds": ('SelectedIds', 'list', 'str', None),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def arms_query_data_set(self,
list_of_measures=None,
interval_in_sec=None,
date_str=None,
is_drill_down=None,
min_time=None,
dataset_id=None,
max_time=None,
list_of_dimensions=None):
api_request = APIRequest('ARMSQueryDataSet', 'GET', 'http', 'RPC',
'query')
api_request._params = {
"Measures": list_of_measures,
"IntervalInSec": interval_in_sec,
"DateStr": date_str,
"IsDrillDown": is_drill_down,
"MinTime": min_time,
"DatasetId": dataset_id,
"MaxTime": max_time,
"Dimensions": list_of_dimensions
}
repeat_info = {
"Measures": ('Measures', 'list', 'str', None),
"Dimensions": ('Dimensions', 'list', 'dict', [
('Value', 'str', None, None),
('Key', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def insert_instance(self,
access_key_id=None,
cluster_type=None,
resource_owner_id=None,
instance_name=None,
description=None,
list_of_tag_info=None,
network=None):
api_request = APIRequest('InsertInstance', 'POST', 'http', 'RPC',
'query')
api_request._params = {
"access_key_id": access_key_id,
"ClusterType": cluster_type,
"ResourceOwnerId": resource_owner_id,
"InstanceName": instance_name,
"Description": description,
"TagInfo": list_of_tag_info,
"Network": network
}
repeat_info = {
"TagInfo": ('TagInfo', 'list', 'dict', [
('TagValue', 'str', None, None),
('TagKey', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def query_metric(
self,
list_of_measures=None,
interval_in_sec=None,
metric=None,
limit=None,
end_time=None,
order_by=None,
start_time=None,
list_of_filters=None,
list_of_dimensions=None,
order=None):
api_request = APIRequest('QueryMetric', 'GET', 'http', 'RPC', 'query')
api_request._params = {
"Measures": list_of_measures,
"IntervalInSec": interval_in_sec,
"Metric": metric,
"Limit": limit,
"EndTime": end_time,
"OrderBy": order_by,
"StartTime": start_time,
"Filters": list_of_filters,
"Dimensions": list_of_dimensions,
"Order": order}
repeat_info = {"Measures": ('Measures', 'list', 'str', None),
"Filters": ('Filters', 'list', 'dict', [('Value', 'str', None, None),
('Key', 'str', None, None),
]),
"Dimensions": ('Dimensions', 'list', 'str', None),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def buy_origin_pictures(self, list_of_picture_id=None):
api_request = APIRequest('BuyOriginPictures', 'POST', 'http', 'RPC',
'query')
api_request._params = {"PictureId": list_of_picture_id}
repeat_info = {
"PictureId": ('PictureId', 'list', 'str', None),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def submit_cutout_task(self, list_of_picture_url=None):
api_request = APIRequest('SubmitCutoutTask', 'POST', 'http', 'RPC',
'query')
api_request._params = {"PictureUrl": list_of_picture_url}
repeat_info = {
"PictureUrl": ('PictureUrl', 'list', 'str', None),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def list_registered_tags(self, store_name=None, list_of_lang=None):
api_request = APIRequest('ListRegisteredTags', 'GET', 'https', 'RPC',
'query')
api_request._params = {"StoreName": store_name, "Lang": list_of_lang}
repeat_info = {
"Lang": ('Lang', 'list', 'str', None),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def describe_auth_brand(self, list_of_account_ids=None):
api_request = APIRequest('DescribeAuthBrand', 'GET', 'http', 'RPC',
'query')
api_request._params = {"AccountIds": list_of_account_ids}
repeat_info = {
"AccountIds": ('AccountIds', 'list', 'str', None),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def batch_get_aliyun_id_by_aliyun_pk(self, list_of_pk_list=None):
api_request = APIRequest('BatchGetAliyunIdByAliyunPk', 'GET', 'http',
'RPC', 'query')
api_request._params = {"PkList": list_of_pk_list}
repeat_info = {
"PkList": ('PkList', 'list', 'str', None),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def analysis_crowd(self, list_of_tag_ids=None, crowd_id=None):
api_request = APIRequest('AnalysisCrowd', 'GET', 'http', 'RPC',
'query')
api_request._params = {"TagIds": list_of_tag_ids, "CrowdId": crowd_id}
repeat_info = {
"TagIds": ('TagIds', 'list', 'str', None),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def ft_param_list(self, list_of_disk=None, name=None):
api_request = APIRequest('FtParamList', 'GET', 'http', 'RPC', 'query')
api_request._params = {"Disk": list_of_disk, "Name": name}
repeat_info = {
"Disk": ('Disk', 'list', 'dict', [
('Size', 'list', 'str', None),
('Type', 'list', 'str', None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def favorite_tag(self, tag_id=None, list_of_tag_ids=None, favorite=None):
api_request = APIRequest('FavoriteTag', 'GET', 'http', 'RPC', 'query')
api_request._params = {
"TagId": tag_id,
"TagIds": list_of_tag_ids,
"Favorite": favorite
}
repeat_info = {
"TagIds": ('TagIds', 'list', 'str', None),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def remove_tags(self, list_of_tag=None, file_system_id=None):
api_request = APIRequest('RemoveTags', 'GET', 'http', 'RPC', 'query')
api_request._params = {
"Tag": list_of_tag,
"FileSystemId": file_system_id
}
repeat_info = {
"Tag": ('Tag', 'list', 'dict', [
('Value', 'str', None, None),
('Key', 'str', None, None),
]),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
def get_photos(self,
library_id=None,
list_of_photo_id=None,
store_name=None):
api_request = APIRequest('GetPhotos', 'GET', 'https', 'RPC', 'query')
api_request._params = {
"LibraryId": library_id,
"PhotoId": list_of_photo_id,
"StoreName": store_name
}
repeat_info = {
"PhotoId": ('PhotoId', 'list', 'str', None),
}
verify_params(api_request._params, repeat_info)
return self._handle_request(api_request).result
