pcdn-20170411/alibabacloud_pcdn20170411/models.py (5,490 lines of code) (raw):
# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
from Tea.model import TeaModel
from typing import Dict, List
class AddConsumerRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
business_type: str = None,
company: str = None,
site: str = None,
requirement: str = None,
mobile: str = None,
ca: str = None,
operator: str = None,
email: str = None,
bandwidth_requirement: str = None,
):
self.security_token = security_token
self.version = version
self.business_type = business_type
self.company = company
self.site = site
self.requirement = requirement
self.mobile = mobile
self.ca = ca
self.operator = operator
self.email = email
self.bandwidth_requirement = bandwidth_requirement
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.company is not None:
result['Company'] = self.company
if self.site is not None:
result['Site'] = self.site
if self.requirement is not None:
result['Requirement'] = self.requirement
if self.mobile is not None:
result['Mobile'] = self.mobile
if self.ca is not None:
result['Ca'] = self.ca
if self.operator is not None:
result['Operator'] = self.operator
if self.email is not None:
result['Email'] = self.email
if self.bandwidth_requirement is not None:
result['BandwidthRequirement'] = self.bandwidth_requirement
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('Company') is not None:
self.company = m.get('Company')
if m.get('Site') is not None:
self.site = m.get('Site')
if m.get('Requirement') is not None:
self.requirement = m.get('Requirement')
if m.get('Mobile') is not None:
self.mobile = m.get('Mobile')
if m.get('Ca') is not None:
self.ca = m.get('Ca')
if m.get('Operator') is not None:
self.operator = m.get('Operator')
if m.get('Email') is not None:
self.email = m.get('Email')
if m.get('BandwidthRequirement') is not None:
self.bandwidth_requirement = m.get('BandwidthRequirement')
return self
class AddConsumerResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
resource_id: str = None,
code: int = None,
):
self.request_id = request_id
self.resource_id = resource_id
self.code = code
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class AddConsumerResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: AddConsumerResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = AddConsumerResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddDomainRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
business_type: str = None,
domain: str = None,
live_format: str = None,
slice_domain: str = None,
region: str = None,
demo_urls: str = None,
):
self.security_token = security_token
self.version = version
self.business_type = business_type
self.domain = domain
self.live_format = live_format
self.slice_domain = slice_domain
self.region = region
self.demo_urls = demo_urls
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.domain is not None:
result['Domain'] = self.domain
if self.live_format is not None:
result['LiveFormat'] = self.live_format
if self.slice_domain is not None:
result['SliceDomain'] = self.slice_domain
if self.region is not None:
result['Region'] = self.region
if self.demo_urls is not None:
result['DemoUrls'] = self.demo_urls
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('LiveFormat') is not None:
self.live_format = m.get('LiveFormat')
if m.get('SliceDomain') is not None:
self.slice_domain = m.get('SliceDomain')
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('DemoUrls') is not None:
self.demo_urls = m.get('DemoUrls')
return self
class AddDomainResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
resource_id: str = None,
code: int = None,
):
self.request_id = request_id
self.resource_id = resource_id
self.code = code
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class AddDomainResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: AddDomainResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = AddDomainResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddPcdnControlRuleRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
name: str = None,
region: str = None,
isp_name: str = None,
platform_type: str = None,
business_type: str = None,
market: str = None,
app_version: str = None,
):
self.security_token = security_token
self.version = version
self.name = name
self.region = region
self.isp_name = isp_name
self.platform_type = platform_type
self.business_type = business_type
self.market = market
self.app_version = app_version
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.name is not None:
result['Name'] = self.name
if self.region is not None:
result['Region'] = self.region
if self.isp_name is not None:
result['IspName'] = self.isp_name
if self.platform_type is not None:
result['PlatformType'] = self.platform_type
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.market is not None:
result['Market'] = self.market
if self.app_version is not None:
result['AppVersion'] = self.app_version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('IspName') is not None:
self.isp_name = m.get('IspName')
if m.get('PlatformType') is not None:
self.platform_type = m.get('PlatformType')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('Market') is not None:
self.market = m.get('Market')
if m.get('AppVersion') is not None:
self.app_version = m.get('AppVersion')
return self
class AddPcdnControlRuleResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
resource_id: str = None,
code: int = None,
):
self.request_id = request_id
self.resource_id = resource_id
self.code = code
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class AddPcdnControlRuleResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: AddPcdnControlRuleResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = AddPcdnControlRuleResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteDomainRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
domain: str = None,
):
self.security_token = security_token
self.version = version
self.domain = domain
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.domain is not None:
result['Domain'] = self.domain
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
return self
class DeleteDomainResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
resource_id: str = None,
code: int = None,
):
self.request_id = request_id
self.resource_id = resource_id
self.code = code
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DeleteDomainResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DeleteDomainResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DeleteDomainResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeletePcdnControlRuleRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
resource_id: str = None,
):
self.security_token = security_token
self.version = version
self.resource_id = resource_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
return self
class DeletePcdnControlRuleResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
code: int = None,
):
self.request_id = request_id
self.code = code
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DeletePcdnControlRuleResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DeletePcdnControlRuleResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DeletePcdnControlRuleResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DisablePcdnControlRuleRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
resource_id: str = None,
):
self.security_token = security_token
self.version = version
self.resource_id = resource_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
return self
class DisablePcdnControlRuleResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
resource_id: str = None,
code: int = None,
):
self.request_id = request_id
self.resource_id = resource_id
self.code = code
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DisablePcdnControlRuleResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: DisablePcdnControlRuleResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DisablePcdnControlRuleResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class EditPcdnControlRuleRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
name: str = None,
resource_id: str = None,
region: str = None,
isp_name: str = None,
platform_type: str = None,
business_type: str = None,
market: str = None,
app_version: str = None,
):
self.security_token = security_token
self.version = version
self.name = name
self.resource_id = resource_id
self.region = region
self.isp_name = isp_name
self.platform_type = platform_type
self.business_type = business_type
self.market = market
self.app_version = app_version
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.name is not None:
result['Name'] = self.name
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.region is not None:
result['Region'] = self.region
if self.isp_name is not None:
result['IspName'] = self.isp_name
if self.platform_type is not None:
result['PlatformType'] = self.platform_type
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.market is not None:
result['Market'] = self.market
if self.app_version is not None:
result['AppVersion'] = self.app_version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('IspName') is not None:
self.isp_name = m.get('IspName')
if m.get('PlatformType') is not None:
self.platform_type = m.get('PlatformType')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('Market') is not None:
self.market = m.get('Market')
if m.get('AppVersion') is not None:
self.app_version = m.get('AppVersion')
return self
class EditPcdnControlRuleResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
resource_id: str = None,
code: int = None,
):
self.request_id = request_id
self.resource_id = resource_id
self.code = code
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class EditPcdnControlRuleResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: EditPcdnControlRuleResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = EditPcdnControlRuleResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class EnablePcdnControlRuleRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
resource_id: str = None,
):
self.security_token = security_token
self.version = version
self.resource_id = resource_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
return self
class EnablePcdnControlRuleResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
resource_id: str = None,
code: int = None,
):
self.request_id = request_id
self.resource_id = resource_id
self.code = code
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class EnablePcdnControlRuleResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: EnablePcdnControlRuleResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = EnablePcdnControlRuleResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetAccessDataRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
domain: str = None,
region: str = None,
isp_name: str = None,
platform_type: str = None,
business_type: str = None,
start_date: str = None,
end_date: str = None,
):
self.security_token = security_token
self.version = version
self.domain = domain
self.region = region
self.isp_name = isp_name
self.platform_type = platform_type
self.business_type = business_type
self.start_date = start_date
self.end_date = end_date
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.domain is not None:
result['Domain'] = self.domain
if self.region is not None:
result['Region'] = self.region
if self.isp_name is not None:
result['IspName'] = self.isp_name
if self.platform_type is not None:
result['PlatformType'] = self.platform_type
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.start_date is not None:
result['StartDate'] = self.start_date
if self.end_date is not None:
result['EndDate'] = self.end_date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('IspName') is not None:
self.isp_name = m.get('IspName')
if m.get('PlatformType') is not None:
self.platform_type = m.get('PlatformType')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('StartDate') is not None:
self.start_date = m.get('StartDate')
if m.get('EndDate') is not None:
self.end_date = m.get('EndDate')
return self
class GetAccessDataResponseBodyDataListUsageDataValues(TeaModel):
def __init__(
self,
values: List[str] = None,
):
self.values = values
def validate(self):
pass
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
self.values = m.get('Values')
return self
class GetAccessDataResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
values: GetAccessDataResponseBodyDataListUsageDataValues = None,
date: str = None,
):
self.values = values
self.date = date
def validate(self):
if self.values:
self.values.validate()
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values.to_map()
if self.date is not None:
result['Date'] = self.date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
temp_model = GetAccessDataResponseBodyDataListUsageDataValues()
self.values = temp_model.from_map(m['Values'])
if m.get('Date') is not None:
self.date = m.get('Date')
return self
class GetAccessDataResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetAccessDataResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetAccessDataResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetAccessDataResponseBodyLabels(TeaModel):
def __init__(
self,
label: List[str] = None,
):
self.label = label
def validate(self):
pass
def to_map(self):
result = dict()
if self.label is not None:
result['Label'] = self.label
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Label') is not None:
self.label = m.get('Label')
return self
class GetAccessDataResponseBody(TeaModel):
def __init__(
self,
data_list: GetAccessDataResponseBodyDataList = None,
request_id: str = None,
labels: GetAccessDataResponseBodyLabels = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.labels = labels
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
if self.labels:
self.labels.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.labels is not None:
result['Labels'] = self.labels.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetAccessDataResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Labels') is not None:
temp_model = GetAccessDataResponseBodyLabels()
self.labels = temp_model.from_map(m['Labels'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetAccessDataResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetAccessDataResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetAccessDataResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetAllAppVersionsRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
):
self.security_token = security_token
self.version = version
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class GetAllAppVersionsResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
value: str = None,
code: int = None,
):
self.value = value
self.code = code
def validate(self):
pass
def to_map(self):
result = dict()
if self.value is not None:
result['Value'] = self.value
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Value') is not None:
self.value = m.get('Value')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetAllAppVersionsResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetAllAppVersionsResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetAllAppVersionsResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetAllAppVersionsResponseBody(TeaModel):
def __init__(
self,
data_list: GetAllAppVersionsResponseBodyDataList = None,
request_id: str = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetAllAppVersionsResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetAllAppVersionsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetAllAppVersionsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetAllAppVersionsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetAllIspRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
):
self.security_token = security_token
self.version = version
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class GetAllIspResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
name_en: str = None,
name_cn: str = None,
resource_id: str = None,
):
self.name_en = name_en
self.name_cn = name_cn
self.resource_id = resource_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.name_en is not None:
result['NameEn'] = self.name_en
if self.name_cn is not None:
result['NameCn'] = self.name_cn
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('NameEn') is not None:
self.name_en = m.get('NameEn')
if m.get('NameCn') is not None:
self.name_cn = m.get('NameCn')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
return self
class GetAllIspResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetAllIspResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetAllIspResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetAllIspResponseBody(TeaModel):
def __init__(
self,
data_list: GetAllIspResponseBodyDataList = None,
request_id: str = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetAllIspResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetAllIspResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetAllIspResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetAllIspResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetAllMarketsRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
):
self.security_token = security_token
self.version = version
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class GetAllMarketsResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
code: int = None,
market_code: str = None,
market_name: str = None,
):
self.code = code
self.market_code = market_code
self.market_name = market_name
def validate(self):
pass
def to_map(self):
result = dict()
if self.code is not None:
result['Code'] = self.code
if self.market_code is not None:
result['MarketCode'] = self.market_code
if self.market_name is not None:
result['MarketName'] = self.market_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Code') is not None:
self.code = m.get('Code')
if m.get('MarketCode') is not None:
self.market_code = m.get('MarketCode')
if m.get('MarketName') is not None:
self.market_name = m.get('MarketName')
return self
class GetAllMarketsResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetAllMarketsResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetAllMarketsResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetAllMarketsResponseBody(TeaModel):
def __init__(
self,
data_list: GetAllMarketsResponseBodyDataList = None,
request_id: str = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetAllMarketsResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetAllMarketsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetAllMarketsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetAllMarketsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetAllPlatformTypesRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
):
self.security_token = security_token
self.version = version
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class GetAllPlatformTypesResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
code: int = None,
name: str = None,
):
self.code = code
self.name = name
def validate(self):
pass
def to_map(self):
result = dict()
if self.code is not None:
result['Code'] = self.code
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Code') is not None:
self.code = m.get('Code')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class GetAllPlatformTypesResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetAllPlatformTypesResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetAllPlatformTypesResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetAllPlatformTypesResponseBody(TeaModel):
def __init__(
self,
data_list: GetAllPlatformTypesResponseBodyDataList = None,
request_id: str = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetAllPlatformTypesResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetAllPlatformTypesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetAllPlatformTypesResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetAllPlatformTypesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetAllRegionsRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
):
self.security_token = security_token
self.version = version
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class GetAllRegionsResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
code: str = None,
name: str = None,
):
self.code = code
self.name = name
def validate(self):
pass
def to_map(self):
result = dict()
if self.code is not None:
result['Code'] = self.code
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Code') is not None:
self.code = m.get('Code')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class GetAllRegionsResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetAllRegionsResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetAllRegionsResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetAllRegionsResponseBody(TeaModel):
def __init__(
self,
data_list: GetAllRegionsResponseBodyDataList = None,
request_id: str = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetAllRegionsResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetAllRegionsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetAllRegionsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetAllRegionsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetBalanceBandwidthDataRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
data_interval: int = None,
resource_id: str = None,
):
self.security_token = security_token
self.version = version
self.data_interval = data_interval
self.resource_id = resource_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.data_interval is not None:
result['DataInterval'] = self.data_interval
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('DataInterval') is not None:
self.data_interval = m.get('DataInterval')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
return self
class GetBalanceBandwidthDataResponseBodyDataListUsageDataValues(TeaModel):
def __init__(
self,
values: List[str] = None,
):
self.values = values
def validate(self):
pass
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
self.values = m.get('Values')
return self
class GetBalanceBandwidthDataResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
values: GetBalanceBandwidthDataResponseBodyDataListUsageDataValues = None,
date: str = None,
):
self.values = values
self.date = date
def validate(self):
if self.values:
self.values.validate()
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values.to_map()
if self.date is not None:
result['Date'] = self.date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
temp_model = GetBalanceBandwidthDataResponseBodyDataListUsageDataValues()
self.values = temp_model.from_map(m['Values'])
if m.get('Date') is not None:
self.date = m.get('Date')
return self
class GetBalanceBandwidthDataResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetBalanceBandwidthDataResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetBalanceBandwidthDataResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetBalanceBandwidthDataResponseBodyLabels(TeaModel):
def __init__(
self,
label: List[str] = None,
):
self.label = label
def validate(self):
pass
def to_map(self):
result = dict()
if self.label is not None:
result['Label'] = self.label
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Label') is not None:
self.label = m.get('Label')
return self
class GetBalanceBandwidthDataResponseBody(TeaModel):
def __init__(
self,
data_list: GetBalanceBandwidthDataResponseBodyDataList = None,
request_id: str = None,
labels: GetBalanceBandwidthDataResponseBodyLabels = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.labels = labels
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
if self.labels:
self.labels.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.labels is not None:
result['Labels'] = self.labels.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetBalanceBandwidthDataResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Labels') is not None:
temp_model = GetBalanceBandwidthDataResponseBodyLabels()
self.labels = temp_model.from_map(m['Labels'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetBalanceBandwidthDataResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetBalanceBandwidthDataResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetBalanceBandwidthDataResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetBalanceTrafficDataRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
data_interval: int = None,
resource_id: str = None,
):
self.security_token = security_token
self.version = version
self.data_interval = data_interval
self.resource_id = resource_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.data_interval is not None:
result['DataInterval'] = self.data_interval
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('DataInterval') is not None:
self.data_interval = m.get('DataInterval')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
return self
class GetBalanceTrafficDataResponseBodyDataListUsageDataValues(TeaModel):
def __init__(
self,
values: List[str] = None,
):
self.values = values
def validate(self):
pass
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
self.values = m.get('Values')
return self
class GetBalanceTrafficDataResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
values: GetBalanceTrafficDataResponseBodyDataListUsageDataValues = None,
date: str = None,
):
self.values = values
self.date = date
def validate(self):
if self.values:
self.values.validate()
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values.to_map()
if self.date is not None:
result['Date'] = self.date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
temp_model = GetBalanceTrafficDataResponseBodyDataListUsageDataValues()
self.values = temp_model.from_map(m['Values'])
if m.get('Date') is not None:
self.date = m.get('Date')
return self
class GetBalanceTrafficDataResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetBalanceTrafficDataResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetBalanceTrafficDataResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetBalanceTrafficDataResponseBodyLabels(TeaModel):
def __init__(
self,
label: List[str] = None,
):
self.label = label
def validate(self):
pass
def to_map(self):
result = dict()
if self.label is not None:
result['Label'] = self.label
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Label') is not None:
self.label = m.get('Label')
return self
class GetBalanceTrafficDataResponseBody(TeaModel):
def __init__(
self,
data_list: GetBalanceTrafficDataResponseBodyDataList = None,
request_id: str = None,
labels: GetBalanceTrafficDataResponseBodyLabels = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.labels = labels
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
if self.labels:
self.labels.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.labels is not None:
result['Labels'] = self.labels.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetBalanceTrafficDataResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Labels') is not None:
temp_model = GetBalanceTrafficDataResponseBodyLabels()
self.labels = temp_model.from_map(m['Labels'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetBalanceTrafficDataResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetBalanceTrafficDataResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetBalanceTrafficDataResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetBandwidthDataRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
domain: str = None,
region: str = None,
isp_name: str = None,
platform_type: str = None,
business_type: str = None,
start_date: str = None,
end_date: str = None,
):
self.security_token = security_token
self.version = version
self.domain = domain
self.region = region
self.isp_name = isp_name
self.platform_type = platform_type
self.business_type = business_type
self.start_date = start_date
self.end_date = end_date
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.domain is not None:
result['Domain'] = self.domain
if self.region is not None:
result['Region'] = self.region
if self.isp_name is not None:
result['IspName'] = self.isp_name
if self.platform_type is not None:
result['PlatformType'] = self.platform_type
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.start_date is not None:
result['StartDate'] = self.start_date
if self.end_date is not None:
result['EndDate'] = self.end_date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('IspName') is not None:
self.isp_name = m.get('IspName')
if m.get('PlatformType') is not None:
self.platform_type = m.get('PlatformType')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('StartDate') is not None:
self.start_date = m.get('StartDate')
if m.get('EndDate') is not None:
self.end_date = m.get('EndDate')
return self
class GetBandwidthDataResponseBodyDataListUsageDataValues(TeaModel):
def __init__(
self,
values: List[str] = None,
):
self.values = values
def validate(self):
pass
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
self.values = m.get('Values')
return self
class GetBandwidthDataResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
values: GetBandwidthDataResponseBodyDataListUsageDataValues = None,
date: str = None,
):
self.values = values
self.date = date
def validate(self):
if self.values:
self.values.validate()
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values.to_map()
if self.date is not None:
result['Date'] = self.date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
temp_model = GetBandwidthDataResponseBodyDataListUsageDataValues()
self.values = temp_model.from_map(m['Values'])
if m.get('Date') is not None:
self.date = m.get('Date')
return self
class GetBandwidthDataResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetBandwidthDataResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetBandwidthDataResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetBandwidthDataResponseBodyLabels(TeaModel):
def __init__(
self,
label: List[str] = None,
):
self.label = label
def validate(self):
pass
def to_map(self):
result = dict()
if self.label is not None:
result['Label'] = self.label
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Label') is not None:
self.label = m.get('Label')
return self
class GetBandwidthDataResponseBody(TeaModel):
def __init__(
self,
data_list: GetBandwidthDataResponseBodyDataList = None,
request_id: str = None,
labels: GetBandwidthDataResponseBodyLabels = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.labels = labels
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
if self.labels:
self.labels.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.labels is not None:
result['Labels'] = self.labels.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetBandwidthDataResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Labels') is not None:
temp_model = GetBandwidthDataResponseBodyLabels()
self.labels = temp_model.from_map(m['Labels'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetBandwidthDataResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetBandwidthDataResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetBandwidthDataResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetClientsRatioRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
):
self.security_token = security_token
self.version = version
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class GetClientsRatioResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
value: str = None,
name: str = None,
rate: str = None,
):
self.value = value
self.name = name
self.rate = rate
def validate(self):
pass
def to_map(self):
result = dict()
if self.value is not None:
result['Value'] = self.value
if self.name is not None:
result['Name'] = self.name
if self.rate is not None:
result['Rate'] = self.rate
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Value') is not None:
self.value = m.get('Value')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Rate') is not None:
self.rate = m.get('Rate')
return self
class GetClientsRatioResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetClientsRatioResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetClientsRatioResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetClientsRatioResponseBody(TeaModel):
def __init__(
self,
data_list: GetClientsRatioResponseBodyDataList = None,
request_id: str = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetClientsRatioResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetClientsRatioResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetClientsRatioResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetClientsRatioResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetConsumerStatusRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
):
self.security_token = security_token
self.version = version
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class GetConsumerStatusResponseBody(TeaModel):
def __init__(
self,
comment: str = None,
live_monitor: bool = None,
audit: int = None,
request_id: str = None,
integreated_mode: int = None,
created_at: str = None,
cdn_url_redirect_flag: bool = None,
business_type: str = None,
inservice: bool = None,
realtime_monitor: bool = None,
code: int = None,
updated_at: str = None,
):
self.comment = comment
self.live_monitor = live_monitor
self.audit = audit
self.request_id = request_id
self.integreated_mode = integreated_mode
self.created_at = created_at
self.cdn_url_redirect_flag = cdn_url_redirect_flag
self.business_type = business_type
self.inservice = inservice
self.realtime_monitor = realtime_monitor
self.code = code
self.updated_at = updated_at
def validate(self):
pass
def to_map(self):
result = dict()
if self.comment is not None:
result['Comment'] = self.comment
if self.live_monitor is not None:
result['LiveMonitor'] = self.live_monitor
if self.audit is not None:
result['Audit'] = self.audit
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.integreated_mode is not None:
result['IntegreatedMode'] = self.integreated_mode
if self.created_at is not None:
result['CreatedAt'] = self.created_at
if self.cdn_url_redirect_flag is not None:
result['CdnUrlRedirectFlag'] = self.cdn_url_redirect_flag
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.inservice is not None:
result['Inservice'] = self.inservice
if self.realtime_monitor is not None:
result['RealtimeMonitor'] = self.realtime_monitor
if self.code is not None:
result['Code'] = self.code
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Comment') is not None:
self.comment = m.get('Comment')
if m.get('LiveMonitor') is not None:
self.live_monitor = m.get('LiveMonitor')
if m.get('Audit') is not None:
self.audit = m.get('Audit')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('IntegreatedMode') is not None:
self.integreated_mode = m.get('IntegreatedMode')
if m.get('CreatedAt') is not None:
self.created_at = m.get('CreatedAt')
if m.get('CdnUrlRedirectFlag') is not None:
self.cdn_url_redirect_flag = m.get('CdnUrlRedirectFlag')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('Inservice') is not None:
self.inservice = m.get('Inservice')
if m.get('RealtimeMonitor') is not None:
self.realtime_monitor = m.get('RealtimeMonitor')
if m.get('Code') is not None:
self.code = m.get('Code')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
return self
class GetConsumerStatusResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetConsumerStatusResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetConsumerStatusResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetControlRulesRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
page: str = None,
page_size: str = None,
):
self.security_token = security_token
self.version = version
self.page = page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.page is not None:
result['Page'] = self.page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Page') is not None:
self.page = m.get('Page')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class GetControlRulesResponseBodySettingListSetting(TeaModel):
def __init__(
self,
created_at: str = None,
client_id: str = None,
business_type: str = None,
usable: bool = None,
region: str = None,
platform_type: str = None,
market_type: str = None,
onoff: bool = None,
isp_name: str = None,
app_version: str = None,
updated_at: str = None,
name: str = None,
resource_id: str = None,
):
self.created_at = created_at
self.client_id = client_id
self.business_type = business_type
self.usable = usable
self.region = region
self.platform_type = platform_type
self.market_type = market_type
self.onoff = onoff
self.isp_name = isp_name
self.app_version = app_version
self.updated_at = updated_at
self.name = name
self.resource_id = resource_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.created_at is not None:
result['CreatedAt'] = self.created_at
if self.client_id is not None:
result['ClientId'] = self.client_id
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.usable is not None:
result['Usable'] = self.usable
if self.region is not None:
result['Region'] = self.region
if self.platform_type is not None:
result['PlatformType'] = self.platform_type
if self.market_type is not None:
result['MarketType'] = self.market_type
if self.onoff is not None:
result['Onoff'] = self.onoff
if self.isp_name is not None:
result['IspName'] = self.isp_name
if self.app_version is not None:
result['AppVersion'] = self.app_version
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.name is not None:
result['Name'] = self.name
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('CreatedAt') is not None:
self.created_at = m.get('CreatedAt')
if m.get('ClientId') is not None:
self.client_id = m.get('ClientId')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('Usable') is not None:
self.usable = m.get('Usable')
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('PlatformType') is not None:
self.platform_type = m.get('PlatformType')
if m.get('MarketType') is not None:
self.market_type = m.get('MarketType')
if m.get('Onoff') is not None:
self.onoff = m.get('Onoff')
if m.get('IspName') is not None:
self.isp_name = m.get('IspName')
if m.get('AppVersion') is not None:
self.app_version = m.get('AppVersion')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
return self
class GetControlRulesResponseBodySettingList(TeaModel):
def __init__(
self,
setting: List[GetControlRulesResponseBodySettingListSetting] = None,
):
self.setting = setting
def validate(self):
if self.setting:
for k in self.setting:
if k:
k.validate()
def to_map(self):
result = dict()
result['Setting'] = []
if self.setting is not None:
for k in self.setting:
result['Setting'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.setting = []
if m.get('Setting') is not None:
for k in m.get('Setting'):
temp_model = GetControlRulesResponseBodySettingListSetting()
self.setting.append(temp_model.from_map(k))
return self
class GetControlRulesResponseBodyPager(TeaModel):
def __init__(
self,
page_size: int = None,
total: int = None,
page: int = None,
):
self.page_size = page_size
self.total = total
self.page = page
def validate(self):
pass
def to_map(self):
result = dict()
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.total is not None:
result['Total'] = self.total
if self.page is not None:
result['Page'] = self.page
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('Total') is not None:
self.total = m.get('Total')
if m.get('Page') is not None:
self.page = m.get('Page')
return self
class GetControlRulesResponseBody(TeaModel):
def __init__(
self,
setting_list: GetControlRulesResponseBodySettingList = None,
request_id: str = None,
pager: GetControlRulesResponseBodyPager = None,
code: int = None,
):
self.setting_list = setting_list
self.request_id = request_id
self.pager = pager
self.code = code
def validate(self):
if self.setting_list:
self.setting_list.validate()
if self.pager:
self.pager.validate()
def to_map(self):
result = dict()
if self.setting_list is not None:
result['SettingList'] = self.setting_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.pager is not None:
result['Pager'] = self.pager.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SettingList') is not None:
temp_model = GetControlRulesResponseBodySettingList()
self.setting_list = temp_model.from_map(m['SettingList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Pager') is not None:
temp_model = GetControlRulesResponseBodyPager()
self.pager = temp_model.from_map(m['Pager'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetControlRulesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetControlRulesResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetControlRulesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetCoverRateDataRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
domain: str = None,
region: str = None,
isp_name: str = None,
platform_type: str = None,
business_type: str = None,
start_date: str = None,
end_date: str = None,
):
self.security_token = security_token
self.version = version
self.domain = domain
self.region = region
self.isp_name = isp_name
self.platform_type = platform_type
self.business_type = business_type
self.start_date = start_date
self.end_date = end_date
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.domain is not None:
result['Domain'] = self.domain
if self.region is not None:
result['Region'] = self.region
if self.isp_name is not None:
result['IspName'] = self.isp_name
if self.platform_type is not None:
result['PlatformType'] = self.platform_type
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.start_date is not None:
result['StartDate'] = self.start_date
if self.end_date is not None:
result['EndDate'] = self.end_date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('IspName') is not None:
self.isp_name = m.get('IspName')
if m.get('PlatformType') is not None:
self.platform_type = m.get('PlatformType')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('StartDate') is not None:
self.start_date = m.get('StartDate')
if m.get('EndDate') is not None:
self.end_date = m.get('EndDate')
return self
class GetCoverRateDataResponseBodyDataListUsageDataValues(TeaModel):
def __init__(
self,
values: List[str] = None,
):
self.values = values
def validate(self):
pass
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
self.values = m.get('Values')
return self
class GetCoverRateDataResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
values: GetCoverRateDataResponseBodyDataListUsageDataValues = None,
date: str = None,
):
self.values = values
self.date = date
def validate(self):
if self.values:
self.values.validate()
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values.to_map()
if self.date is not None:
result['Date'] = self.date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
temp_model = GetCoverRateDataResponseBodyDataListUsageDataValues()
self.values = temp_model.from_map(m['Values'])
if m.get('Date') is not None:
self.date = m.get('Date')
return self
class GetCoverRateDataResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetCoverRateDataResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetCoverRateDataResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetCoverRateDataResponseBodyLabels(TeaModel):
def __init__(
self,
label: List[str] = None,
):
self.label = label
def validate(self):
pass
def to_map(self):
result = dict()
if self.label is not None:
result['Label'] = self.label
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Label') is not None:
self.label = m.get('Label')
return self
class GetCoverRateDataResponseBody(TeaModel):
def __init__(
self,
data_list: GetCoverRateDataResponseBodyDataList = None,
request_id: str = None,
labels: GetCoverRateDataResponseBodyLabels = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.labels = labels
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
if self.labels:
self.labels.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.labels is not None:
result['Labels'] = self.labels.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetCoverRateDataResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Labels') is not None:
temp_model = GetCoverRateDataResponseBodyLabels()
self.labels = temp_model.from_map(m['Labels'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetCoverRateDataResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetCoverRateDataResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetCoverRateDataResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetCurrentModeRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
):
self.security_token = security_token
self.version = version
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class GetCurrentModeResponseBody(TeaModel):
def __init__(
self,
mode_code: int = None,
request_id: str = None,
padding_mode_code: int = None,
effective_at: int = None,
estimate_bandwidth: int = None,
code: int = None,
):
self.mode_code = mode_code
self.request_id = request_id
self.padding_mode_code = padding_mode_code
self.effective_at = effective_at
self.estimate_bandwidth = estimate_bandwidth
self.code = code
def validate(self):
pass
def to_map(self):
result = dict()
if self.mode_code is not None:
result['ModeCode'] = self.mode_code
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.padding_mode_code is not None:
result['PaddingModeCode'] = self.padding_mode_code
if self.effective_at is not None:
result['EffectiveAt'] = self.effective_at
if self.estimate_bandwidth is not None:
result['EstimateBandwidth'] = self.estimate_bandwidth
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ModeCode') is not None:
self.mode_code = m.get('ModeCode')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('PaddingModeCode') is not None:
self.padding_mode_code = m.get('PaddingModeCode')
if m.get('EffectiveAt') is not None:
self.effective_at = m.get('EffectiveAt')
if m.get('EstimateBandwidth') is not None:
self.estimate_bandwidth = m.get('EstimateBandwidth')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetCurrentModeResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetCurrentModeResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetCurrentModeResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetDomainCountRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
):
self.security_token = security_token
self.version = version
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class GetDomainCountResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
data: int = None,
code: int = None,
):
self.request_id = request_id
self.data = data
self.code = code
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.data is not None:
result['Data'] = self.data
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Data') is not None:
self.data = m.get('Data')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetDomainCountResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetDomainCountResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetDomainCountResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetDomainsRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
page: str = None,
page_size: str = None,
domain: str = None,
):
self.security_token = security_token
self.version = version
self.page = page
self.page_size = page_size
self.domain = domain
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.page is not None:
result['Page'] = self.page
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.domain is not None:
result['Domain'] = self.domain
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Page') is not None:
self.page = m.get('Page')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
return self
class GetDomainsResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
status: bool = None,
domain: str = None,
slice_format: str = None,
created_at: str = None,
updated_at: str = None,
resource_id: str = None,
business_type: str = None,
):
self.status = status
self.domain = domain
self.slice_format = slice_format
self.created_at = created_at
self.updated_at = updated_at
self.resource_id = resource_id
self.business_type = business_type
def validate(self):
pass
def to_map(self):
result = dict()
if self.status is not None:
result['Status'] = self.status
if self.domain is not None:
result['Domain'] = self.domain
if self.slice_format is not None:
result['SliceFormat'] = self.slice_format
if self.created_at is not None:
result['CreatedAt'] = self.created_at
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.business_type is not None:
result['BusinessType'] = self.business_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('SliceFormat') is not None:
self.slice_format = m.get('SliceFormat')
if m.get('CreatedAt') is not None:
self.created_at = m.get('CreatedAt')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
return self
class GetDomainsResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetDomainsResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetDomainsResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetDomainsResponseBodyPager(TeaModel):
def __init__(
self,
page_size: int = None,
total: int = None,
page: int = None,
):
self.page_size = page_size
self.total = total
self.page = page
def validate(self):
pass
def to_map(self):
result = dict()
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.total is not None:
result['Total'] = self.total
if self.page is not None:
result['Page'] = self.page
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('Total') is not None:
self.total = m.get('Total')
if m.get('Page') is not None:
self.page = m.get('Page')
return self
class GetDomainsResponseBody(TeaModel):
def __init__(
self,
data_list: GetDomainsResponseBodyDataList = None,
request_id: str = None,
pager: GetDomainsResponseBodyPager = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.pager = pager
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
if self.pager:
self.pager.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.pager is not None:
result['Pager'] = self.pager.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetDomainsResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Pager') is not None:
temp_model = GetDomainsResponseBodyPager()
self.pager = temp_model.from_map(m['Pager'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetDomainsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetDomainsResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetDomainsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetExpenseSummaryRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
start_date: str = None,
end_date: str = None,
domain: str = None,
region: str = None,
isp_name: str = None,
platform_type: str = None,
business_type: str = None,
):
self.security_token = security_token
self.version = version
self.start_date = start_date
self.end_date = end_date
self.domain = domain
self.region = region
self.isp_name = isp_name
self.platform_type = platform_type
self.business_type = business_type
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.start_date is not None:
result['StartDate'] = self.start_date
if self.end_date is not None:
result['EndDate'] = self.end_date
if self.domain is not None:
result['Domain'] = self.domain
if self.region is not None:
result['Region'] = self.region
if self.isp_name is not None:
result['IspName'] = self.isp_name
if self.platform_type is not None:
result['PlatformType'] = self.platform_type
if self.business_type is not None:
result['BusinessType'] = self.business_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('StartDate') is not None:
self.start_date = m.get('StartDate')
if m.get('EndDate') is not None:
self.end_date = m.get('EndDate')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('IspName') is not None:
self.isp_name = m.get('IspName')
if m.get('PlatformType') is not None:
self.platform_type = m.get('PlatformType')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
return self
class GetExpenseSummaryResponseBodyData(TeaModel):
def __init__(
self,
forecast_fluency: float = None,
top_bandwidth: int = None,
total_traffic: int = None,
cover_rate: float = None,
share_rate: float = None,
total_uv: int = None,
):
self.forecast_fluency = forecast_fluency
self.top_bandwidth = top_bandwidth
self.total_traffic = total_traffic
self.cover_rate = cover_rate
self.share_rate = share_rate
self.total_uv = total_uv
def validate(self):
pass
def to_map(self):
result = dict()
if self.forecast_fluency is not None:
result['ForecastFluency'] = self.forecast_fluency
if self.top_bandwidth is not None:
result['TopBandwidth'] = self.top_bandwidth
if self.total_traffic is not None:
result['TotalTraffic'] = self.total_traffic
if self.cover_rate is not None:
result['CoverRate'] = self.cover_rate
if self.share_rate is not None:
result['ShareRate'] = self.share_rate
if self.total_uv is not None:
result['TotalUV'] = self.total_uv
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ForecastFluency') is not None:
self.forecast_fluency = m.get('ForecastFluency')
if m.get('TopBandwidth') is not None:
self.top_bandwidth = m.get('TopBandwidth')
if m.get('TotalTraffic') is not None:
self.total_traffic = m.get('TotalTraffic')
if m.get('CoverRate') is not None:
self.cover_rate = m.get('CoverRate')
if m.get('ShareRate') is not None:
self.share_rate = m.get('ShareRate')
if m.get('TotalUV') is not None:
self.total_uv = m.get('TotalUV')
return self
class GetExpenseSummaryResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
data: GetExpenseSummaryResponseBodyData = None,
code: int = None,
):
self.request_id = request_id
self.data = data
self.code = code
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.data is not None:
result['Data'] = self.data.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Data') is not None:
temp_model = GetExpenseSummaryResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetExpenseSummaryResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetExpenseSummaryResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetExpenseSummaryResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetFeeHistoryRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
page: str = None,
page_size: str = None,
):
self.security_token = security_token
self.version = version
self.page = page
self.page_size = page_size
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.page is not None:
result['Page'] = self.page
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Page') is not None:
self.page = m.get('Page')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class GetFeeHistoryResponseBodyFeeListFee(TeaModel):
def __init__(
self,
end_date: str = None,
time_span: str = None,
date: str = None,
start_date: str = None,
level_three_traffic: int = None,
mode: str = None,
total_traffic: int = None,
business_type: str = None,
level_two_traffic: int = None,
level_three_bandwidth: int = None,
level_two_bandwidth: int = None,
flow_out: int = None,
resource_id: str = None,
total_bandwidth: int = None,
):
self.end_date = end_date
self.time_span = time_span
self.date = date
self.start_date = start_date
self.level_three_traffic = level_three_traffic
self.mode = mode
self.total_traffic = total_traffic
self.business_type = business_type
self.level_two_traffic = level_two_traffic
self.level_three_bandwidth = level_three_bandwidth
self.level_two_bandwidth = level_two_bandwidth
self.flow_out = flow_out
self.resource_id = resource_id
self.total_bandwidth = total_bandwidth
def validate(self):
pass
def to_map(self):
result = dict()
if self.end_date is not None:
result['EndDate'] = self.end_date
if self.time_span is not None:
result['TimeSpan'] = self.time_span
if self.date is not None:
result['Date'] = self.date
if self.start_date is not None:
result['StartDate'] = self.start_date
if self.level_three_traffic is not None:
result['LevelThreeTraffic'] = self.level_three_traffic
if self.mode is not None:
result['Mode'] = self.mode
if self.total_traffic is not None:
result['TotalTraffic'] = self.total_traffic
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.level_two_traffic is not None:
result['LevelTwoTraffic'] = self.level_two_traffic
if self.level_three_bandwidth is not None:
result['LevelThreeBandwidth'] = self.level_three_bandwidth
if self.level_two_bandwidth is not None:
result['LevelTwoBandwidth'] = self.level_two_bandwidth
if self.flow_out is not None:
result['FlowOut'] = self.flow_out
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.total_bandwidth is not None:
result['TotalBandwidth'] = self.total_bandwidth
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('EndDate') is not None:
self.end_date = m.get('EndDate')
if m.get('TimeSpan') is not None:
self.time_span = m.get('TimeSpan')
if m.get('Date') is not None:
self.date = m.get('Date')
if m.get('StartDate') is not None:
self.start_date = m.get('StartDate')
if m.get('LevelThreeTraffic') is not None:
self.level_three_traffic = m.get('LevelThreeTraffic')
if m.get('Mode') is not None:
self.mode = m.get('Mode')
if m.get('TotalTraffic') is not None:
self.total_traffic = m.get('TotalTraffic')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('LevelTwoTraffic') is not None:
self.level_two_traffic = m.get('LevelTwoTraffic')
if m.get('LevelThreeBandwidth') is not None:
self.level_three_bandwidth = m.get('LevelThreeBandwidth')
if m.get('LevelTwoBandwidth') is not None:
self.level_two_bandwidth = m.get('LevelTwoBandwidth')
if m.get('FlowOut') is not None:
self.flow_out = m.get('FlowOut')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('TotalBandwidth') is not None:
self.total_bandwidth = m.get('TotalBandwidth')
return self
class GetFeeHistoryResponseBodyFeeList(TeaModel):
def __init__(
self,
fee: List[GetFeeHistoryResponseBodyFeeListFee] = None,
):
self.fee = fee
def validate(self):
if self.fee:
for k in self.fee:
if k:
k.validate()
def to_map(self):
result = dict()
result['Fee'] = []
if self.fee is not None:
for k in self.fee:
result['Fee'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.fee = []
if m.get('Fee') is not None:
for k in m.get('Fee'):
temp_model = GetFeeHistoryResponseBodyFeeListFee()
self.fee.append(temp_model.from_map(k))
return self
class GetFeeHistoryResponseBodyPager(TeaModel):
def __init__(
self,
page_size: int = None,
total: int = None,
page: int = None,
):
self.page_size = page_size
self.total = total
self.page = page
def validate(self):
pass
def to_map(self):
result = dict()
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.total is not None:
result['Total'] = self.total
if self.page is not None:
result['Page'] = self.page
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('Total') is not None:
self.total = m.get('Total')
if m.get('Page') is not None:
self.page = m.get('Page')
return self
class GetFeeHistoryResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
fee_list: GetFeeHistoryResponseBodyFeeList = None,
pager: GetFeeHistoryResponseBodyPager = None,
code: int = None,
):
self.request_id = request_id
self.fee_list = fee_list
self.pager = pager
self.code = code
def validate(self):
if self.fee_list:
self.fee_list.validate()
if self.pager:
self.pager.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.fee_list is not None:
result['FeeList'] = self.fee_list.to_map()
if self.pager is not None:
result['Pager'] = self.pager.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('FeeList') is not None:
temp_model = GetFeeHistoryResponseBodyFeeList()
self.fee_list = temp_model.from_map(m['FeeList'])
if m.get('Pager') is not None:
temp_model = GetFeeHistoryResponseBodyPager()
self.pager = temp_model.from_map(m['Pager'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetFeeHistoryResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetFeeHistoryResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetFeeHistoryResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetFirstFrameDelayDataRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
domain: str = None,
region: str = None,
isp_name: str = None,
platform_type: str = None,
business_type: str = None,
start_date: str = None,
end_date: str = None,
):
self.security_token = security_token
self.version = version
self.domain = domain
self.region = region
self.isp_name = isp_name
self.platform_type = platform_type
self.business_type = business_type
self.start_date = start_date
self.end_date = end_date
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.domain is not None:
result['Domain'] = self.domain
if self.region is not None:
result['Region'] = self.region
if self.isp_name is not None:
result['IspName'] = self.isp_name
if self.platform_type is not None:
result['PlatformType'] = self.platform_type
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.start_date is not None:
result['StartDate'] = self.start_date
if self.end_date is not None:
result['EndDate'] = self.end_date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('IspName') is not None:
self.isp_name = m.get('IspName')
if m.get('PlatformType') is not None:
self.platform_type = m.get('PlatformType')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('StartDate') is not None:
self.start_date = m.get('StartDate')
if m.get('EndDate') is not None:
self.end_date = m.get('EndDate')
return self
class GetFirstFrameDelayDataResponseBodyDataListUsageDataValues(TeaModel):
def __init__(
self,
values: List[str] = None,
):
self.values = values
def validate(self):
pass
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
self.values = m.get('Values')
return self
class GetFirstFrameDelayDataResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
values: GetFirstFrameDelayDataResponseBodyDataListUsageDataValues = None,
date: str = None,
):
self.values = values
self.date = date
def validate(self):
if self.values:
self.values.validate()
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values.to_map()
if self.date is not None:
result['Date'] = self.date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
temp_model = GetFirstFrameDelayDataResponseBodyDataListUsageDataValues()
self.values = temp_model.from_map(m['Values'])
if m.get('Date') is not None:
self.date = m.get('Date')
return self
class GetFirstFrameDelayDataResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetFirstFrameDelayDataResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetFirstFrameDelayDataResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetFirstFrameDelayDataResponseBodyLabels(TeaModel):
def __init__(
self,
label: List[str] = None,
):
self.label = label
def validate(self):
pass
def to_map(self):
result = dict()
if self.label is not None:
result['Label'] = self.label
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Label') is not None:
self.label = m.get('Label')
return self
class GetFirstFrameDelayDataResponseBody(TeaModel):
def __init__(
self,
data_list: GetFirstFrameDelayDataResponseBodyDataList = None,
request_id: str = None,
labels: GetFirstFrameDelayDataResponseBodyLabels = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.labels = labels
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
if self.labels:
self.labels.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.labels is not None:
result['Labels'] = self.labels.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetFirstFrameDelayDataResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Labels') is not None:
temp_model = GetFirstFrameDelayDataResponseBodyLabels()
self.labels = temp_model.from_map(m['Labels'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetFirstFrameDelayDataResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetFirstFrameDelayDataResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetFirstFrameDelayDataResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetFluencyDataRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
domain: str = None,
region: str = None,
isp_name: str = None,
platform_type: str = None,
business_type: str = None,
start_date: str = None,
end_date: str = None,
):
self.security_token = security_token
self.version = version
self.domain = domain
self.region = region
self.isp_name = isp_name
self.platform_type = platform_type
self.business_type = business_type
self.start_date = start_date
self.end_date = end_date
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.domain is not None:
result['Domain'] = self.domain
if self.region is not None:
result['Region'] = self.region
if self.isp_name is not None:
result['IspName'] = self.isp_name
if self.platform_type is not None:
result['PlatformType'] = self.platform_type
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.start_date is not None:
result['StartDate'] = self.start_date
if self.end_date is not None:
result['EndDate'] = self.end_date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('IspName') is not None:
self.isp_name = m.get('IspName')
if m.get('PlatformType') is not None:
self.platform_type = m.get('PlatformType')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('StartDate') is not None:
self.start_date = m.get('StartDate')
if m.get('EndDate') is not None:
self.end_date = m.get('EndDate')
return self
class GetFluencyDataResponseBodyDataListUsageDataValues(TeaModel):
def __init__(
self,
values: List[str] = None,
):
self.values = values
def validate(self):
pass
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
self.values = m.get('Values')
return self
class GetFluencyDataResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
values: GetFluencyDataResponseBodyDataListUsageDataValues = None,
date: str = None,
):
self.values = values
self.date = date
def validate(self):
if self.values:
self.values.validate()
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values.to_map()
if self.date is not None:
result['Date'] = self.date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
temp_model = GetFluencyDataResponseBodyDataListUsageDataValues()
self.values = temp_model.from_map(m['Values'])
if m.get('Date') is not None:
self.date = m.get('Date')
return self
class GetFluencyDataResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetFluencyDataResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetFluencyDataResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetFluencyDataResponseBodyLabels(TeaModel):
def __init__(
self,
label: List[str] = None,
):
self.label = label
def validate(self):
pass
def to_map(self):
result = dict()
if self.label is not None:
result['Label'] = self.label
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Label') is not None:
self.label = m.get('Label')
return self
class GetFluencyDataResponseBody(TeaModel):
def __init__(
self,
data_list: GetFluencyDataResponseBodyDataList = None,
request_id: str = None,
labels: GetFluencyDataResponseBodyLabels = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.labels = labels
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
if self.labels:
self.labels.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.labels is not None:
result['Labels'] = self.labels.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetFluencyDataResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Labels') is not None:
temp_model = GetFluencyDataResponseBodyLabels()
self.labels = temp_model.from_map(m['Labels'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetFluencyDataResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetFluencyDataResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetFluencyDataResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetLogsListRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
domain: str = None,
date: str = None,
start_time: str = None,
end_time: str = None,
):
self.security_token = security_token
self.version = version
self.domain = domain
self.date = date
self.start_time = start_time
self.end_time = end_time
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.domain is not None:
result['Domain'] = self.domain
if self.date is not None:
result['Date'] = self.date
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.end_time is not None:
result['EndTime'] = self.end_time
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('Date') is not None:
self.date = m.get('Date')
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('EndTime') is not None:
self.end_time = m.get('EndTime')
return self
class GetLogsListResponseBodyLogListLog(TeaModel):
def __init__(
self,
end_date: str = None,
url: str = None,
start_date: str = None,
file_name: str = None,
):
self.end_date = end_date
self.url = url
self.start_date = start_date
self.file_name = file_name
def validate(self):
pass
def to_map(self):
result = dict()
if self.end_date is not None:
result['EndDate'] = self.end_date
if self.url is not None:
result['Url'] = self.url
if self.start_date is not None:
result['StartDate'] = self.start_date
if self.file_name is not None:
result['FileName'] = self.file_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('EndDate') is not None:
self.end_date = m.get('EndDate')
if m.get('Url') is not None:
self.url = m.get('Url')
if m.get('StartDate') is not None:
self.start_date = m.get('StartDate')
if m.get('FileName') is not None:
self.file_name = m.get('FileName')
return self
class GetLogsListResponseBodyLogList(TeaModel):
def __init__(
self,
log: List[GetLogsListResponseBodyLogListLog] = None,
):
self.log = log
def validate(self):
if self.log:
for k in self.log:
if k:
k.validate()
def to_map(self):
result = dict()
result['Log'] = []
if self.log is not None:
for k in self.log:
result['Log'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.log = []
if m.get('Log') is not None:
for k in m.get('Log'):
temp_model = GetLogsListResponseBodyLogListLog()
self.log.append(temp_model.from_map(k))
return self
class GetLogsListResponseBody(TeaModel):
def __init__(
self,
log_list: GetLogsListResponseBodyLogList = None,
request_id: str = None,
code: int = None,
):
self.log_list = log_list
self.request_id = request_id
self.code = code
def validate(self):
if self.log_list:
self.log_list.validate()
def to_map(self):
result = dict()
if self.log_list is not None:
result['LogList'] = self.log_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('LogList') is not None:
temp_model = GetLogsListResponseBodyLogList()
self.log_list = temp_model.from_map(m['LogList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetLogsListResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetLogsListResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetLogsListResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetShareRateDataRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
domain: str = None,
region: str = None,
isp_name: str = None,
platform_type: str = None,
business_type: str = None,
start_date: str = None,
end_date: str = None,
):
self.security_token = security_token
self.version = version
self.domain = domain
self.region = region
self.isp_name = isp_name
self.platform_type = platform_type
self.business_type = business_type
self.start_date = start_date
self.end_date = end_date
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.domain is not None:
result['Domain'] = self.domain
if self.region is not None:
result['Region'] = self.region
if self.isp_name is not None:
result['IspName'] = self.isp_name
if self.platform_type is not None:
result['PlatformType'] = self.platform_type
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.start_date is not None:
result['StartDate'] = self.start_date
if self.end_date is not None:
result['EndDate'] = self.end_date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('IspName') is not None:
self.isp_name = m.get('IspName')
if m.get('PlatformType') is not None:
self.platform_type = m.get('PlatformType')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('StartDate') is not None:
self.start_date = m.get('StartDate')
if m.get('EndDate') is not None:
self.end_date = m.get('EndDate')
return self
class GetShareRateDataResponseBodyDataListUsageDataValues(TeaModel):
def __init__(
self,
values: List[str] = None,
):
self.values = values
def validate(self):
pass
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
self.values = m.get('Values')
return self
class GetShareRateDataResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
values: GetShareRateDataResponseBodyDataListUsageDataValues = None,
date: str = None,
):
self.values = values
self.date = date
def validate(self):
if self.values:
self.values.validate()
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values.to_map()
if self.date is not None:
result['Date'] = self.date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
temp_model = GetShareRateDataResponseBodyDataListUsageDataValues()
self.values = temp_model.from_map(m['Values'])
if m.get('Date') is not None:
self.date = m.get('Date')
return self
class GetShareRateDataResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetShareRateDataResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetShareRateDataResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetShareRateDataResponseBodyLabels(TeaModel):
def __init__(
self,
label: List[str] = None,
):
self.label = label
def validate(self):
pass
def to_map(self):
result = dict()
if self.label is not None:
result['Label'] = self.label
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Label') is not None:
self.label = m.get('Label')
return self
class GetShareRateDataResponseBody(TeaModel):
def __init__(
self,
data_list: GetShareRateDataResponseBodyDataList = None,
request_id: str = None,
labels: GetShareRateDataResponseBodyLabels = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.labels = labels
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
if self.labels:
self.labels.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.labels is not None:
result['Labels'] = self.labels.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetShareRateDataResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Labels') is not None:
temp_model = GetShareRateDataResponseBodyLabels()
self.labels = temp_model.from_map(m['Labels'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetShareRateDataResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetShareRateDataResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetShareRateDataResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetTokenListRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
):
self.security_token = security_token
self.version = version
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class GetTokenListResponseBodyTokenListToken(TeaModel):
def __init__(
self,
platform_name: str = None,
token: str = None,
platform_type: str = None,
created_at: str = None,
updated_at: str = None,
resource_id: str = None,
client_id: str = None,
):
self.platform_name = platform_name
self.token = token
self.platform_type = platform_type
self.created_at = created_at
self.updated_at = updated_at
self.resource_id = resource_id
self.client_id = client_id
def validate(self):
pass
def to_map(self):
result = dict()
if self.platform_name is not None:
result['PlatformName'] = self.platform_name
if self.token is not None:
result['Token'] = self.token
if self.platform_type is not None:
result['PlatformType'] = self.platform_type
if self.created_at is not None:
result['CreatedAt'] = self.created_at
if self.updated_at is not None:
result['UpdatedAt'] = self.updated_at
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.client_id is not None:
result['ClientId'] = self.client_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('PlatformName') is not None:
self.platform_name = m.get('PlatformName')
if m.get('Token') is not None:
self.token = m.get('Token')
if m.get('PlatformType') is not None:
self.platform_type = m.get('PlatformType')
if m.get('CreatedAt') is not None:
self.created_at = m.get('CreatedAt')
if m.get('UpdatedAt') is not None:
self.updated_at = m.get('UpdatedAt')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('ClientId') is not None:
self.client_id = m.get('ClientId')
return self
class GetTokenListResponseBodyTokenList(TeaModel):
def __init__(
self,
token: List[GetTokenListResponseBodyTokenListToken] = None,
):
self.token = token
def validate(self):
if self.token:
for k in self.token:
if k:
k.validate()
def to_map(self):
result = dict()
result['Token'] = []
if self.token is not None:
for k in self.token:
result['Token'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.token = []
if m.get('Token') is not None:
for k in m.get('Token'):
temp_model = GetTokenListResponseBodyTokenListToken()
self.token.append(temp_model.from_map(k))
return self
class GetTokenListResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
token_list: GetTokenListResponseBodyTokenList = None,
code: int = None,
):
self.request_id = request_id
self.token_list = token_list
self.code = code
def validate(self):
if self.token_list:
self.token_list.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.token_list is not None:
result['TokenList'] = self.token_list.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TokenList') is not None:
temp_model = GetTokenListResponseBodyTokenList()
self.token_list = temp_model.from_map(m['TokenList'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetTokenListResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetTokenListResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetTokenListResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetTrafficByRegionRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
):
self.security_token = security_token
self.version = version
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class GetTrafficByRegionResponseBodyTrafficDataListTrafficData(TeaModel):
def __init__(
self,
traffic: int = None,
name: str = None,
):
self.traffic = traffic
self.name = name
def validate(self):
pass
def to_map(self):
result = dict()
if self.traffic is not None:
result['Traffic'] = self.traffic
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Traffic') is not None:
self.traffic = m.get('Traffic')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class GetTrafficByRegionResponseBodyTrafficDataList(TeaModel):
def __init__(
self,
traffic_data: List[GetTrafficByRegionResponseBodyTrafficDataListTrafficData] = None,
):
self.traffic_data = traffic_data
def validate(self):
if self.traffic_data:
for k in self.traffic_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['TrafficData'] = []
if self.traffic_data is not None:
for k in self.traffic_data:
result['TrafficData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.traffic_data = []
if m.get('TrafficData') is not None:
for k in m.get('TrafficData'):
temp_model = GetTrafficByRegionResponseBodyTrafficDataListTrafficData()
self.traffic_data.append(temp_model.from_map(k))
return self
class GetTrafficByRegionResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
traffic_data_list: GetTrafficByRegionResponseBodyTrafficDataList = None,
code: int = None,
):
self.request_id = request_id
self.traffic_data_list = traffic_data_list
self.code = code
def validate(self):
if self.traffic_data_list:
self.traffic_data_list.validate()
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.traffic_data_list is not None:
result['TrafficDataList'] = self.traffic_data_list.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TrafficDataList') is not None:
temp_model = GetTrafficByRegionResponseBodyTrafficDataList()
self.traffic_data_list = temp_model.from_map(m['TrafficDataList'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetTrafficByRegionResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetTrafficByRegionResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetTrafficByRegionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetTrafficDataRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
domain: str = None,
region: str = None,
isp_name: str = None,
platform_type: str = None,
business_type: str = None,
start_date: str = None,
end_date: str = None,
):
self.security_token = security_token
self.version = version
self.domain = domain
self.region = region
self.isp_name = isp_name
self.platform_type = platform_type
self.business_type = business_type
self.start_date = start_date
self.end_date = end_date
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.domain is not None:
result['Domain'] = self.domain
if self.region is not None:
result['Region'] = self.region
if self.isp_name is not None:
result['IspName'] = self.isp_name
if self.platform_type is not None:
result['PlatformType'] = self.platform_type
if self.business_type is not None:
result['BusinessType'] = self.business_type
if self.start_date is not None:
result['StartDate'] = self.start_date
if self.end_date is not None:
result['EndDate'] = self.end_date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
if m.get('Region') is not None:
self.region = m.get('Region')
if m.get('IspName') is not None:
self.isp_name = m.get('IspName')
if m.get('PlatformType') is not None:
self.platform_type = m.get('PlatformType')
if m.get('BusinessType') is not None:
self.business_type = m.get('BusinessType')
if m.get('StartDate') is not None:
self.start_date = m.get('StartDate')
if m.get('EndDate') is not None:
self.end_date = m.get('EndDate')
return self
class GetTrafficDataResponseBodyDataListUsageDataValues(TeaModel):
def __init__(
self,
values: List[str] = None,
):
self.values = values
def validate(self):
pass
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
self.values = m.get('Values')
return self
class GetTrafficDataResponseBodyDataListUsageData(TeaModel):
def __init__(
self,
values: GetTrafficDataResponseBodyDataListUsageDataValues = None,
date: str = None,
):
self.values = values
self.date = date
def validate(self):
if self.values:
self.values.validate()
def to_map(self):
result = dict()
if self.values is not None:
result['Values'] = self.values.to_map()
if self.date is not None:
result['Date'] = self.date
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Values') is not None:
temp_model = GetTrafficDataResponseBodyDataListUsageDataValues()
self.values = temp_model.from_map(m['Values'])
if m.get('Date') is not None:
self.date = m.get('Date')
return self
class GetTrafficDataResponseBodyDataList(TeaModel):
def __init__(
self,
usage_data: List[GetTrafficDataResponseBodyDataListUsageData] = None,
):
self.usage_data = usage_data
def validate(self):
if self.usage_data:
for k in self.usage_data:
if k:
k.validate()
def to_map(self):
result = dict()
result['UsageData'] = []
if self.usage_data is not None:
for k in self.usage_data:
result['UsageData'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.usage_data = []
if m.get('UsageData') is not None:
for k in m.get('UsageData'):
temp_model = GetTrafficDataResponseBodyDataListUsageData()
self.usage_data.append(temp_model.from_map(k))
return self
class GetTrafficDataResponseBodyLabels(TeaModel):
def __init__(
self,
label: List[str] = None,
):
self.label = label
def validate(self):
pass
def to_map(self):
result = dict()
if self.label is not None:
result['Label'] = self.label
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Label') is not None:
self.label = m.get('Label')
return self
class GetTrafficDataResponseBody(TeaModel):
def __init__(
self,
data_list: GetTrafficDataResponseBodyDataList = None,
request_id: str = None,
labels: GetTrafficDataResponseBodyLabels = None,
code: int = None,
):
self.data_list = data_list
self.request_id = request_id
self.labels = labels
self.code = code
def validate(self):
if self.data_list:
self.data_list.validate()
if self.labels:
self.labels.validate()
def to_map(self):
result = dict()
if self.data_list is not None:
result['DataList'] = self.data_list.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.labels is not None:
result['Labels'] = self.labels.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DataList') is not None:
temp_model = GetTrafficDataResponseBodyDataList()
self.data_list = temp_model.from_map(m['DataList'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Labels') is not None:
temp_model = GetTrafficDataResponseBodyLabels()
self.labels = temp_model.from_map(m['Labels'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class GetTrafficDataResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: GetTrafficDataResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetTrafficDataResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class StartDomainRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
domain: str = None,
):
self.security_token = security_token
self.version = version
self.domain = domain
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.domain is not None:
result['Domain'] = self.domain
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
return self
class StartDomainResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
resource_id: str = None,
code: int = None,
):
self.request_id = request_id
self.resource_id = resource_id
self.code = code
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class StartDomainResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: StartDomainResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = StartDomainResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class StopDomainRequest(TeaModel):
def __init__(
self,
security_token: str = None,
version: str = None,
domain: str = None,
):
self.security_token = security_token
self.version = version
self.domain = domain
def validate(self):
pass
def to_map(self):
result = dict()
if self.security_token is not None:
result['SecurityToken'] = self.security_token
if self.version is not None:
result['Version'] = self.version
if self.domain is not None:
result['Domain'] = self.domain
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SecurityToken') is not None:
self.security_token = m.get('SecurityToken')
if m.get('Version') is not None:
self.version = m.get('Version')
if m.get('Domain') is not None:
self.domain = m.get('Domain')
return self
class StopDomainResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
resource_id: str = None,
code: int = None,
):
self.request_id = request_id
self.resource_id = resource_id
self.code = code
def validate(self):
pass
def to_map(self):
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.resource_id is not None:
result['ResourceId'] = self.resource_id
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ResourceId') is not None:
self.resource_id = m.get('ResourceId')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class StopDomainResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
body: StopDomainResponseBody = None,
):
self.headers = headers
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = StopDomainResponseBody()
self.body = temp_model.from_map(m['body'])
return self