webplus-20190320/alibabacloud_webplus20190320/models.py (7,758 lines of code) (raw):
# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
from Tea.model import TeaModel
from Tea.converter import TeaConverter
class AbortChangeRequest(TeaModel):
def __init__(self, change_id=None, region_id=None):
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class AbortChangeResponseBodyEnvChange(TeaModel):
def __init__(self, start_time=None, change_id=None, env_id=None):
self.start_time = TeaConverter.to_unicode(start_time) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.env_id is not None:
result['EnvId'] = self.env_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
return self
class AbortChangeResponseBody(TeaModel):
def __init__(self, env_change=None, message=None, request_id=None, code=None):
self.env_change = env_change # type: AbortChangeResponseBodyEnvChange
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_change:
self.env_change.validate()
def to_map(self):
result = dict()
if self.env_change is not None:
result['EnvChange'] = self.env_change.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('EnvChange') is not None:
temp_model = AbortChangeResponseBodyEnvChange()
self.env_change = temp_model.from_map(m['EnvChange'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 AbortChangeResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: AbortChangeResponseBody
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=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 = AbortChangeResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateAppEnvRequest(TeaModel):
def __init__(self, env_name=None, env_description=None, stack_id=None, app_id=None, pkg_version_id=None,
option_settings=None, profile_name=None, source_env_id=None, template_id=None, dry_run=None, extra_properties=None,
region_id=None):
self.env_name = TeaConverter.to_unicode(env_name) # type: unicode
self.env_description = TeaConverter.to_unicode(env_description) # type: unicode
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.pkg_version_id = TeaConverter.to_unicode(pkg_version_id) # type: unicode
self.option_settings = TeaConverter.to_unicode(option_settings) # type: unicode
self.profile_name = TeaConverter.to_unicode(profile_name) # type: unicode
self.source_env_id = TeaConverter.to_unicode(source_env_id) # type: unicode
self.template_id = TeaConverter.to_unicode(template_id) # type: unicode
self.dry_run = dry_run # type: bool
self.extra_properties = TeaConverter.to_unicode(extra_properties) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_name is not None:
result['EnvName'] = self.env_name
if self.env_description is not None:
result['EnvDescription'] = self.env_description
if self.stack_id is not None:
result['StackId'] = self.stack_id
if self.app_id is not None:
result['AppId'] = self.app_id
if self.pkg_version_id is not None:
result['PkgVersionId'] = self.pkg_version_id
if self.option_settings is not None:
result['OptionSettings'] = self.option_settings
if self.profile_name is not None:
result['ProfileName'] = self.profile_name
if self.source_env_id is not None:
result['SourceEnvId'] = self.source_env_id
if self.template_id is not None:
result['TemplateId'] = self.template_id
if self.dry_run is not None:
result['DryRun'] = self.dry_run
if self.extra_properties is not None:
result['ExtraProperties'] = self.extra_properties
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvName') is not None:
self.env_name = m.get('EnvName')
if m.get('EnvDescription') is not None:
self.env_description = m.get('EnvDescription')
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('PkgVersionId') is not None:
self.pkg_version_id = m.get('PkgVersionId')
if m.get('OptionSettings') is not None:
self.option_settings = m.get('OptionSettings')
if m.get('ProfileName') is not None:
self.profile_name = m.get('ProfileName')
if m.get('SourceEnvId') is not None:
self.source_env_id = m.get('SourceEnvId')
if m.get('TemplateId') is not None:
self.template_id = m.get('TemplateId')
if m.get('DryRun') is not None:
self.dry_run = m.get('DryRun')
if m.get('ExtraProperties') is not None:
self.extra_properties = m.get('ExtraProperties')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class CreateAppEnvResponseBodyEnvChangeDetailOperationsOperation(TeaModel):
def __init__(self, operation_description=None, operation_type=None):
self.operation_description = TeaConverter.to_unicode(operation_description) # type: unicode
self.operation_type = TeaConverter.to_unicode(operation_type) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.operation_description is not None:
result['OperationDescription'] = self.operation_description
if self.operation_type is not None:
result['OperationType'] = self.operation_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('OperationDescription') is not None:
self.operation_description = m.get('OperationDescription')
if m.get('OperationType') is not None:
self.operation_type = m.get('OperationType')
return self
class CreateAppEnvResponseBodyEnvChangeDetailOperations(TeaModel):
def __init__(self, operation=None):
self.operation = operation # type: list[CreateAppEnvResponseBodyEnvChangeDetailOperationsOperation]
def validate(self):
if self.operation:
for k in self.operation:
if k:
k.validate()
def to_map(self):
result = dict()
result['Operation'] = []
if self.operation is not None:
for k in self.operation:
result['Operation'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.operation = []
if m.get('Operation') is not None:
for k in m.get('Operation'):
temp_model = CreateAppEnvResponseBodyEnvChangeDetailOperationsOperation()
self.operation.append(temp_model.from_map(k))
return self
class CreateAppEnvResponseBodyEnvChangeDetail(TeaModel):
def __init__(self, start_time=None, change_id=None, env_id=None, operations=None):
self.start_time = TeaConverter.to_unicode(start_time) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.operations = operations # type: CreateAppEnvResponseBodyEnvChangeDetailOperations
def validate(self):
if self.operations:
self.operations.validate()
def to_map(self):
result = dict()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.operations is not None:
result['Operations'] = self.operations.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('Operations') is not None:
temp_model = CreateAppEnvResponseBodyEnvChangeDetailOperations()
self.operations = temp_model.from_map(m['Operations'])
return self
class CreateAppEnvResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, env_change_detail=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.env_change_detail = env_change_detail # type: CreateAppEnvResponseBodyEnvChangeDetail
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_change_detail:
self.env_change_detail.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.env_change_detail is not None:
result['EnvChangeDetail'] = self.env_change_detail.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('EnvChangeDetail') is not None:
temp_model = CreateAppEnvResponseBodyEnvChangeDetail()
self.env_change_detail = temp_model.from_map(m['EnvChangeDetail'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class CreateAppEnvResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: CreateAppEnvResponseBody
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=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 = CreateAppEnvResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateApplicationRequest(TeaModel):
def __init__(self, app_name=None, app_description=None, category_name=None, using_shared_storage=None,
region_id=None):
self.app_name = TeaConverter.to_unicode(app_name) # type: unicode
self.app_description = TeaConverter.to_unicode(app_description) # type: unicode
self.category_name = TeaConverter.to_unicode(category_name) # type: unicode
self.using_shared_storage = using_shared_storage # type: bool
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_description is not None:
result['AppDescription'] = self.app_description
if self.category_name is not None:
result['CategoryName'] = self.category_name
if self.using_shared_storage is not None:
result['UsingSharedStorage'] = self.using_shared_storage
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('AppDescription') is not None:
self.app_description = m.get('AppDescription')
if m.get('CategoryName') is not None:
self.category_name = m.get('CategoryName')
if m.get('UsingSharedStorage') is not None:
self.using_shared_storage = m.get('UsingSharedStorage')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class CreateApplicationResponseBodyApplication(TeaModel):
def __init__(self, create_username=None, app_name=None, update_time=None, update_username=None,
create_time=None, app_id=None, category_name=None, using_shared_storage=None, app_description=None):
self.create_username = TeaConverter.to_unicode(create_username) # type: unicode
self.app_name = TeaConverter.to_unicode(app_name) # type: unicode
self.update_time = update_time # type: long
self.update_username = TeaConverter.to_unicode(update_username) # type: unicode
self.create_time = create_time # type: long
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.category_name = TeaConverter.to_unicode(category_name) # type: unicode
self.using_shared_storage = using_shared_storage # type: bool
self.app_description = TeaConverter.to_unicode(app_description) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.create_username is not None:
result['CreateUsername'] = self.create_username
if self.app_name is not None:
result['AppName'] = self.app_name
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.update_username is not None:
result['UpdateUsername'] = self.update_username
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.app_id is not None:
result['AppId'] = self.app_id
if self.category_name is not None:
result['CategoryName'] = self.category_name
if self.using_shared_storage is not None:
result['UsingSharedStorage'] = self.using_shared_storage
if self.app_description is not None:
result['AppDescription'] = self.app_description
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateUsername') is not None:
self.create_username = m.get('CreateUsername')
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('UpdateUsername') is not None:
self.update_username = m.get('UpdateUsername')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('CategoryName') is not None:
self.category_name = m.get('CategoryName')
if m.get('UsingSharedStorage') is not None:
self.using_shared_storage = m.get('UsingSharedStorage')
if m.get('AppDescription') is not None:
self.app_description = m.get('AppDescription')
return self
class CreateApplicationResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, code=None, application=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
self.application = application # type: CreateApplicationResponseBodyApplication
def validate(self):
if self.application:
self.application.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.code is not None:
result['Code'] = self.code
if self.application is not None:
result['Application'] = self.application.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
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')
if m.get('Application') is not None:
temp_model = CreateApplicationResponseBodyApplication()
self.application = temp_model.from_map(m['Application'])
return self
class CreateApplicationResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: CreateApplicationResponseBody
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=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 = CreateApplicationResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateConfigTemplateRequest(TeaModel):
def __init__(self, template_name=None, template_description=None, app_id=None, stack_id=None,
source_template_id=None, source_env_id=None, profile_name=None, pkg_version_id=None, option_settings=None,
region_id=None):
self.template_name = TeaConverter.to_unicode(template_name) # type: unicode
self.template_description = TeaConverter.to_unicode(template_description) # type: unicode
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
self.source_template_id = TeaConverter.to_unicode(source_template_id) # type: unicode
self.source_env_id = TeaConverter.to_unicode(source_env_id) # type: unicode
self.profile_name = TeaConverter.to_unicode(profile_name) # type: unicode
self.pkg_version_id = TeaConverter.to_unicode(pkg_version_id) # type: unicode
self.option_settings = TeaConverter.to_unicode(option_settings) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.template_description is not None:
result['TemplateDescription'] = self.template_description
if self.app_id is not None:
result['AppId'] = self.app_id
if self.stack_id is not None:
result['StackId'] = self.stack_id
if self.source_template_id is not None:
result['SourceTemplateId'] = self.source_template_id
if self.source_env_id is not None:
result['SourceEnvId'] = self.source_env_id
if self.profile_name is not None:
result['ProfileName'] = self.profile_name
if self.pkg_version_id is not None:
result['PkgVersionId'] = self.pkg_version_id
if self.option_settings is not None:
result['OptionSettings'] = self.option_settings
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TemplateName') is not None:
self.template_name = m.get('TemplateName')
if m.get('TemplateDescription') is not None:
self.template_description = m.get('TemplateDescription')
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
if m.get('SourceTemplateId') is not None:
self.source_template_id = m.get('SourceTemplateId')
if m.get('SourceEnvId') is not None:
self.source_env_id = m.get('SourceEnvId')
if m.get('ProfileName') is not None:
self.profile_name = m.get('ProfileName')
if m.get('PkgVersionId') is not None:
self.pkg_version_id = m.get('PkgVersionId')
if m.get('OptionSettings') is not None:
self.option_settings = m.get('OptionSettings')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class CreateConfigTemplateResponseBodyConfigTemplate(TeaModel):
def __init__(self, update_time=None, create_time=None, template_type=None, stack_name=None, pkg_version_id=None,
template_name=None, template_description=None, app_name=None, stack_id=None, pkg_version_label=None, app_id=None,
template_id=None):
self.update_time = update_time # type: long
self.create_time = create_time # type: long
self.template_type = TeaConverter.to_unicode(template_type) # type: unicode
self.stack_name = TeaConverter.to_unicode(stack_name) # type: unicode
self.pkg_version_id = TeaConverter.to_unicode(pkg_version_id) # type: unicode
self.template_name = TeaConverter.to_unicode(template_name) # type: unicode
self.template_description = TeaConverter.to_unicode(template_description) # type: unicode
self.app_name = TeaConverter.to_unicode(app_name) # type: unicode
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
self.pkg_version_label = TeaConverter.to_unicode(pkg_version_label) # type: unicode
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.template_id = TeaConverter.to_unicode(template_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.template_type is not None:
result['TemplateType'] = self.template_type
if self.stack_name is not None:
result['StackName'] = self.stack_name
if self.pkg_version_id is not None:
result['PkgVersionId'] = self.pkg_version_id
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.template_description is not None:
result['TemplateDescription'] = self.template_description
if self.app_name is not None:
result['AppName'] = self.app_name
if self.stack_id is not None:
result['StackId'] = self.stack_id
if self.pkg_version_label is not None:
result['PkgVersionLabel'] = self.pkg_version_label
if self.app_id is not None:
result['AppId'] = self.app_id
if self.template_id is not None:
result['TemplateId'] = self.template_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('TemplateType') is not None:
self.template_type = m.get('TemplateType')
if m.get('StackName') is not None:
self.stack_name = m.get('StackName')
if m.get('PkgVersionId') is not None:
self.pkg_version_id = m.get('PkgVersionId')
if m.get('TemplateName') is not None:
self.template_name = m.get('TemplateName')
if m.get('TemplateDescription') is not None:
self.template_description = m.get('TemplateDescription')
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
if m.get('PkgVersionLabel') is not None:
self.pkg_version_label = m.get('PkgVersionLabel')
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('TemplateId') is not None:
self.template_id = m.get('TemplateId')
return self
class CreateConfigTemplateResponseBody(TeaModel):
def __init__(self, config_template=None, message=None, request_id=None, code=None):
self.config_template = config_template # type: CreateConfigTemplateResponseBodyConfigTemplate
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.config_template:
self.config_template.validate()
def to_map(self):
result = dict()
if self.config_template is not None:
result['ConfigTemplate'] = self.config_template.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('ConfigTemplate') is not None:
temp_model = CreateConfigTemplateResponseBodyConfigTemplate()
self.config_template = temp_model.from_map(m['ConfigTemplate'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 CreateConfigTemplateResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: CreateConfigTemplateResponseBody
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=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 = CreateConfigTemplateResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateOrderRequest(TeaModel):
def __init__(self, product_name=None, region_id=None):
self.product_name = TeaConverter.to_unicode(product_name) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.product_name is not None:
result['ProductName'] = self.product_name
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ProductName') is not None:
self.product_name = m.get('ProductName')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class CreateOrderResponseBodyOrderDetail(TeaModel):
def __init__(self, data=None, request_id=None, success=None, code=None, message=None):
self.data = TeaConverter.to_unicode(data) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.success = success # type: bool
self.code = TeaConverter.to_unicode(code) # type: unicode
self.message = TeaConverter.to_unicode(message) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.data is not None:
result['Data'] = self.data
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.success is not None:
result['Success'] = self.success
if self.code is not None:
result['Code'] = self.code
if self.message is not None:
result['Message'] = self.message
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
self.data = m.get('Data')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Success') is not None:
self.success = m.get('Success')
if m.get('Code') is not None:
self.code = m.get('Code')
if m.get('Message') is not None:
self.message = m.get('Message')
return self
class CreateOrderResponseBody(TeaModel):
def __init__(self, order_detail=None, message=None, request_id=None, code=None):
self.order_detail = order_detail # type: CreateOrderResponseBodyOrderDetail
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.order_detail:
self.order_detail.validate()
def to_map(self):
result = dict()
if self.order_detail is not None:
result['OrderDetail'] = self.order_detail.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('OrderDetail') is not None:
temp_model = CreateOrderResponseBodyOrderDetail()
self.order_detail = temp_model.from_map(m['OrderDetail'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 CreateOrderResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: CreateOrderResponseBody
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=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 = CreateOrderResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreatePkgVersionRequest(TeaModel):
def __init__(self, pkg_version_label=None, pkg_version_description=None, app_id=None, package_source=None,
region_id=None):
self.pkg_version_label = TeaConverter.to_unicode(pkg_version_label) # type: unicode
self.pkg_version_description = TeaConverter.to_unicode(pkg_version_description) # type: unicode
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.package_source = TeaConverter.to_unicode(package_source) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.pkg_version_label is not None:
result['PkgVersionLabel'] = self.pkg_version_label
if self.pkg_version_description is not None:
result['PkgVersionDescription'] = self.pkg_version_description
if self.app_id is not None:
result['AppId'] = self.app_id
if self.package_source is not None:
result['PackageSource'] = self.package_source
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PkgVersionLabel') is not None:
self.pkg_version_label = m.get('PkgVersionLabel')
if m.get('PkgVersionDescription') is not None:
self.pkg_version_description = m.get('PkgVersionDescription')
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('PackageSource') is not None:
self.package_source = m.get('PackageSource')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class CreatePkgVersionResponseBodyPkgVersion(TeaModel):
def __init__(self, app_name=None, update_time=None, pkg_version_label=None, create_time=None, app_id=None,
package_source=None, pkg_version_id=None, pkg_version_description=None):
self.app_name = TeaConverter.to_unicode(app_name) # type: unicode
self.update_time = update_time # type: long
self.pkg_version_label = TeaConverter.to_unicode(pkg_version_label) # type: unicode
self.create_time = create_time # type: long
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.package_source = TeaConverter.to_unicode(package_source) # type: unicode
self.pkg_version_id = TeaConverter.to_unicode(pkg_version_id) # type: unicode
self.pkg_version_description = TeaConverter.to_unicode(pkg_version_description) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.pkg_version_label is not None:
result['PkgVersionLabel'] = self.pkg_version_label
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.app_id is not None:
result['AppId'] = self.app_id
if self.package_source is not None:
result['PackageSource'] = self.package_source
if self.pkg_version_id is not None:
result['PkgVersionId'] = self.pkg_version_id
if self.pkg_version_description is not None:
result['PkgVersionDescription'] = self.pkg_version_description
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('PkgVersionLabel') is not None:
self.pkg_version_label = m.get('PkgVersionLabel')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('PackageSource') is not None:
self.package_source = m.get('PackageSource')
if m.get('PkgVersionId') is not None:
self.pkg_version_id = m.get('PkgVersionId')
if m.get('PkgVersionDescription') is not None:
self.pkg_version_description = m.get('PkgVersionDescription')
return self
class CreatePkgVersionResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, pkg_version=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.pkg_version = pkg_version # type: CreatePkgVersionResponseBodyPkgVersion
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.pkg_version:
self.pkg_version.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.pkg_version is not None:
result['PkgVersion'] = self.pkg_version.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('PkgVersion') is not None:
temp_model = CreatePkgVersionResponseBodyPkgVersion()
self.pkg_version = temp_model.from_map(m['PkgVersion'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class CreatePkgVersionResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: CreatePkgVersionResponseBody
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=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 = CreatePkgVersionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateStorageRequest(TeaModel):
def __init__(self, region_id=None):
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class CreateStorageResponseBodyStorage(TeaModel):
def __init__(self, update_time=None, create_time=None, bucket_name=None):
self.update_time = update_time # type: long
self.create_time = create_time # type: long
self.bucket_name = TeaConverter.to_unicode(bucket_name) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.bucket_name is not None:
result['BucketName'] = self.bucket_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('BucketName') is not None:
self.bucket_name = m.get('BucketName')
return self
class CreateStorageResponseBody(TeaModel):
def __init__(self, storage=None, message=None, request_id=None, code=None):
self.storage = storage # type: CreateStorageResponseBodyStorage
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.storage:
self.storage.validate()
def to_map(self):
result = dict()
if self.storage is not None:
result['Storage'] = self.storage.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('Storage') is not None:
temp_model = CreateStorageResponseBodyStorage()
self.storage = temp_model.from_map(m['Storage'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 CreateStorageResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: CreateStorageResponseBody
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=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 = CreateStorageResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteAppEnvRequest(TeaModel):
def __init__(self, env_id=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DeleteAppEnvResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
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 DeleteAppEnvResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DeleteAppEnvResponseBody
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=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 = DeleteAppEnvResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteApplicationRequest(TeaModel):
def __init__(self, app_id=None, region_id=None):
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.app_id is not None:
result['AppId'] = self.app_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DeleteApplicationResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
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 DeleteApplicationResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DeleteApplicationResponseBody
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=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 = DeleteApplicationResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteChangeRequest(TeaModel):
def __init__(self, change_id=None, region_id=None):
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DeleteChangeResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
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 DeleteChangeResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DeleteChangeResponseBody
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=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 = DeleteChangeResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteConfigTemplateRequest(TeaModel):
def __init__(self, template_id=None, region_id=None):
self.template_id = TeaConverter.to_unicode(template_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.template_id is not None:
result['TemplateId'] = self.template_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TemplateId') is not None:
self.template_id = m.get('TemplateId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DeleteConfigTemplateResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
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 DeleteConfigTemplateResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DeleteConfigTemplateResponseBody
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=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 = DeleteConfigTemplateResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeletePkgVersionRequest(TeaModel):
def __init__(self, pkg_version_id=None, region_id=None):
self.pkg_version_id = TeaConverter.to_unicode(pkg_version_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.pkg_version_id is not None:
result['PkgVersionId'] = self.pkg_version_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PkgVersionId') is not None:
self.pkg_version_id = m.get('PkgVersionId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DeletePkgVersionResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
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 DeletePkgVersionResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DeletePkgVersionResponseBody
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=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 = DeletePkgVersionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeployAppEnvRequest(TeaModel):
def __init__(self, env_id=None, batch_size=None, batch_percent=None, batch_interval=None,
pause_between_batches=None, pkg_version_id=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.batch_size = batch_size # type: int
self.batch_percent = batch_percent # type: int
self.batch_interval = batch_interval # type: int
self.pause_between_batches = pause_between_batches # type: bool
self.pkg_version_id = TeaConverter.to_unicode(pkg_version_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.batch_size is not None:
result['BatchSize'] = self.batch_size
if self.batch_percent is not None:
result['BatchPercent'] = self.batch_percent
if self.batch_interval is not None:
result['BatchInterval'] = self.batch_interval
if self.pause_between_batches is not None:
result['PauseBetweenBatches'] = self.pause_between_batches
if self.pkg_version_id is not None:
result['PkgVersionId'] = self.pkg_version_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('BatchSize') is not None:
self.batch_size = m.get('BatchSize')
if m.get('BatchPercent') is not None:
self.batch_percent = m.get('BatchPercent')
if m.get('BatchInterval') is not None:
self.batch_interval = m.get('BatchInterval')
if m.get('PauseBetweenBatches') is not None:
self.pause_between_batches = m.get('PauseBetweenBatches')
if m.get('PkgVersionId') is not None:
self.pkg_version_id = m.get('PkgVersionId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DeployAppEnvResponseBodyEnvChange(TeaModel):
def __init__(self, start_time=None, change_id=None, env_id=None):
self.start_time = TeaConverter.to_unicode(start_time) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.env_id is not None:
result['EnvId'] = self.env_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
return self
class DeployAppEnvResponseBody(TeaModel):
def __init__(self, env_change=None, message=None, request_id=None, code=None):
self.env_change = env_change # type: DeployAppEnvResponseBodyEnvChange
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_change:
self.env_change.validate()
def to_map(self):
result = dict()
if self.env_change is not None:
result['EnvChange'] = self.env_change.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('EnvChange') is not None:
temp_model = DeployAppEnvResponseBodyEnvChange()
self.env_change = temp_model.from_map(m['EnvChange'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 DeployAppEnvResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DeployAppEnvResponseBody
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=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 = DeployAppEnvResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeAppEnvInstanceHealthRequest(TeaModel):
def __init__(self, env_id=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeAppEnvInstanceHealthResponseBodyEnvInstanceHealthInstanceHealthListInstanceHealth(TeaModel):
def __init__(self, app_status=None, instance_id=None, disconnected_time=None, agent_status=None):
self.app_status = TeaConverter.to_unicode(app_status) # type: unicode
self.instance_id = TeaConverter.to_unicode(instance_id) # type: unicode
self.disconnected_time = TeaConverter.to_unicode(disconnected_time) # type: unicode
self.agent_status = TeaConverter.to_unicode(agent_status) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.app_status is not None:
result['AppStatus'] = self.app_status
if self.instance_id is not None:
result['InstanceId'] = self.instance_id
if self.disconnected_time is not None:
result['DisconnectedTime'] = self.disconnected_time
if self.agent_status is not None:
result['AgentStatus'] = self.agent_status
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppStatus') is not None:
self.app_status = m.get('AppStatus')
if m.get('InstanceId') is not None:
self.instance_id = m.get('InstanceId')
if m.get('DisconnectedTime') is not None:
self.disconnected_time = m.get('DisconnectedTime')
if m.get('AgentStatus') is not None:
self.agent_status = m.get('AgentStatus')
return self
class DescribeAppEnvInstanceHealthResponseBodyEnvInstanceHealthInstanceHealthList(TeaModel):
def __init__(self, instance_health=None):
self.instance_health = instance_health # type: list[DescribeAppEnvInstanceHealthResponseBodyEnvInstanceHealthInstanceHealthListInstanceHealth]
def validate(self):
if self.instance_health:
for k in self.instance_health:
if k:
k.validate()
def to_map(self):
result = dict()
result['InstanceHealth'] = []
if self.instance_health is not None:
for k in self.instance_health:
result['InstanceHealth'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.instance_health = []
if m.get('InstanceHealth') is not None:
for k in m.get('InstanceHealth'):
temp_model = DescribeAppEnvInstanceHealthResponseBodyEnvInstanceHealthInstanceHealthListInstanceHealth()
self.instance_health.append(temp_model.from_map(k))
return self
class DescribeAppEnvInstanceHealthResponseBodyEnvInstanceHealth(TeaModel):
def __init__(self, enable_health_check=None, env_name=None, env_id=None, instance_health_list=None):
self.enable_health_check = enable_health_check # type: bool
self.env_name = TeaConverter.to_unicode(env_name) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.instance_health_list = instance_health_list # type: DescribeAppEnvInstanceHealthResponseBodyEnvInstanceHealthInstanceHealthList
def validate(self):
if self.instance_health_list:
self.instance_health_list.validate()
def to_map(self):
result = dict()
if self.enable_health_check is not None:
result['EnableHealthCheck'] = self.enable_health_check
if self.env_name is not None:
result['EnvName'] = self.env_name
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.instance_health_list is not None:
result['InstanceHealthList'] = self.instance_health_list.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnableHealthCheck') is not None:
self.enable_health_check = m.get('EnableHealthCheck')
if m.get('EnvName') is not None:
self.env_name = m.get('EnvName')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('InstanceHealthList') is not None:
temp_model = DescribeAppEnvInstanceHealthResponseBodyEnvInstanceHealthInstanceHealthList()
self.instance_health_list = temp_model.from_map(m['InstanceHealthList'])
return self
class DescribeAppEnvInstanceHealthResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, code=None, env_instance_health=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
self.env_instance_health = env_instance_health # type: DescribeAppEnvInstanceHealthResponseBodyEnvInstanceHealth
def validate(self):
if self.env_instance_health:
self.env_instance_health.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.code is not None:
result['Code'] = self.code
if self.env_instance_health is not None:
result['EnvInstanceHealth'] = self.env_instance_health.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
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')
if m.get('EnvInstanceHealth') is not None:
temp_model = DescribeAppEnvInstanceHealthResponseBodyEnvInstanceHealth()
self.env_instance_health = temp_model.from_map(m['EnvInstanceHealth'])
return self
class DescribeAppEnvInstanceHealthResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeAppEnvInstanceHealthResponseBody
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=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 = DescribeAppEnvInstanceHealthResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeAppEnvsRequest(TeaModel):
def __init__(self, env_id=None, app_id=None, include_terminated=None, page_size=None, page_number=None,
env_name=None, env_search=None, recent_updated=None, stack_search=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.include_terminated = include_terminated # type: bool
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.env_name = TeaConverter.to_unicode(env_name) # type: unicode
self.env_search = TeaConverter.to_unicode(env_search) # type: unicode
self.recent_updated = recent_updated # type: bool
self.stack_search = TeaConverter.to_unicode(stack_search) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.app_id is not None:
result['AppId'] = self.app_id
if self.include_terminated is not None:
result['IncludeTerminated'] = self.include_terminated
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.env_name is not None:
result['EnvName'] = self.env_name
if self.env_search is not None:
result['EnvSearch'] = self.env_search
if self.recent_updated is not None:
result['RecentUpdated'] = self.recent_updated
if self.stack_search is not None:
result['StackSearch'] = self.stack_search
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('IncludeTerminated') is not None:
self.include_terminated = m.get('IncludeTerminated')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('EnvName') is not None:
self.env_name = m.get('EnvName')
if m.get('EnvSearch') is not None:
self.env_search = m.get('EnvSearch')
if m.get('RecentUpdated') is not None:
self.recent_updated = m.get('RecentUpdated')
if m.get('StackSearch') is not None:
self.stack_search = m.get('StackSearch')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeAppEnvsResponseBodyAppEnvsAppEnv(TeaModel):
def __init__(self, update_time=None, total_instances=None, pkg_version_storage_key=None, latest_change_id=None,
env_status=None, create_time=None, last_env_status=None, pkg_version_id=None, env_description=None,
applying_change=None, env_type=None, app_name=None, create_username=None, app_id=None, data_root=None,
storage_base=None, update_username=None, env_name=None, log_base=None, stack_name=None, category_name=None,
using_shared_storage=None, change_banner=None, stack_id=None, pkg_version_label=None, env_id=None, aborting_change=None):
self.update_time = update_time # type: long
self.total_instances = total_instances # type: long
self.pkg_version_storage_key = TeaConverter.to_unicode(pkg_version_storage_key) # type: unicode
self.latest_change_id = TeaConverter.to_unicode(latest_change_id) # type: unicode
self.env_status = TeaConverter.to_unicode(env_status) # type: unicode
self.create_time = create_time # type: long
self.last_env_status = TeaConverter.to_unicode(last_env_status) # type: unicode
self.pkg_version_id = TeaConverter.to_unicode(pkg_version_id) # type: unicode
self.env_description = TeaConverter.to_unicode(env_description) # type: unicode
self.applying_change = applying_change # type: bool
self.env_type = TeaConverter.to_unicode(env_type) # type: unicode
self.app_name = TeaConverter.to_unicode(app_name) # type: unicode
self.create_username = TeaConverter.to_unicode(create_username) # type: unicode
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.data_root = TeaConverter.to_unicode(data_root) # type: unicode
self.storage_base = TeaConverter.to_unicode(storage_base) # type: unicode
self.update_username = TeaConverter.to_unicode(update_username) # type: unicode
self.env_name = TeaConverter.to_unicode(env_name) # type: unicode
self.log_base = TeaConverter.to_unicode(log_base) # type: unicode
self.stack_name = TeaConverter.to_unicode(stack_name) # type: unicode
self.category_name = TeaConverter.to_unicode(category_name) # type: unicode
self.using_shared_storage = using_shared_storage # type: bool
self.change_banner = TeaConverter.to_unicode(change_banner) # type: unicode
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
self.pkg_version_label = TeaConverter.to_unicode(pkg_version_label) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.aborting_change = aborting_change # type: bool
def validate(self):
pass
def to_map(self):
result = dict()
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.total_instances is not None:
result['TotalInstances'] = self.total_instances
if self.pkg_version_storage_key is not None:
result['PkgVersionStorageKey'] = self.pkg_version_storage_key
if self.latest_change_id is not None:
result['LatestChangeId'] = self.latest_change_id
if self.env_status is not None:
result['EnvStatus'] = self.env_status
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.last_env_status is not None:
result['LastEnvStatus'] = self.last_env_status
if self.pkg_version_id is not None:
result['PkgVersionId'] = self.pkg_version_id
if self.env_description is not None:
result['EnvDescription'] = self.env_description
if self.applying_change is not None:
result['ApplyingChange'] = self.applying_change
if self.env_type is not None:
result['EnvType'] = self.env_type
if self.app_name is not None:
result['AppName'] = self.app_name
if self.create_username is not None:
result['CreateUsername'] = self.create_username
if self.app_id is not None:
result['AppId'] = self.app_id
if self.data_root is not None:
result['DataRoot'] = self.data_root
if self.storage_base is not None:
result['StorageBase'] = self.storage_base
if self.update_username is not None:
result['UpdateUsername'] = self.update_username
if self.env_name is not None:
result['EnvName'] = self.env_name
if self.log_base is not None:
result['LogBase'] = self.log_base
if self.stack_name is not None:
result['StackName'] = self.stack_name
if self.category_name is not None:
result['CategoryName'] = self.category_name
if self.using_shared_storage is not None:
result['UsingSharedStorage'] = self.using_shared_storage
if self.change_banner is not None:
result['ChangeBanner'] = self.change_banner
if self.stack_id is not None:
result['StackId'] = self.stack_id
if self.pkg_version_label is not None:
result['PkgVersionLabel'] = self.pkg_version_label
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.aborting_change is not None:
result['AbortingChange'] = self.aborting_change
return result
def from_map(self, m=None):
m = m or dict()
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('TotalInstances') is not None:
self.total_instances = m.get('TotalInstances')
if m.get('PkgVersionStorageKey') is not None:
self.pkg_version_storage_key = m.get('PkgVersionStorageKey')
if m.get('LatestChangeId') is not None:
self.latest_change_id = m.get('LatestChangeId')
if m.get('EnvStatus') is not None:
self.env_status = m.get('EnvStatus')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('LastEnvStatus') is not None:
self.last_env_status = m.get('LastEnvStatus')
if m.get('PkgVersionId') is not None:
self.pkg_version_id = m.get('PkgVersionId')
if m.get('EnvDescription') is not None:
self.env_description = m.get('EnvDescription')
if m.get('ApplyingChange') is not None:
self.applying_change = m.get('ApplyingChange')
if m.get('EnvType') is not None:
self.env_type = m.get('EnvType')
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('CreateUsername') is not None:
self.create_username = m.get('CreateUsername')
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('DataRoot') is not None:
self.data_root = m.get('DataRoot')
if m.get('StorageBase') is not None:
self.storage_base = m.get('StorageBase')
if m.get('UpdateUsername') is not None:
self.update_username = m.get('UpdateUsername')
if m.get('EnvName') is not None:
self.env_name = m.get('EnvName')
if m.get('LogBase') is not None:
self.log_base = m.get('LogBase')
if m.get('StackName') is not None:
self.stack_name = m.get('StackName')
if m.get('CategoryName') is not None:
self.category_name = m.get('CategoryName')
if m.get('UsingSharedStorage') is not None:
self.using_shared_storage = m.get('UsingSharedStorage')
if m.get('ChangeBanner') is not None:
self.change_banner = m.get('ChangeBanner')
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
if m.get('PkgVersionLabel') is not None:
self.pkg_version_label = m.get('PkgVersionLabel')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('AbortingChange') is not None:
self.aborting_change = m.get('AbortingChange')
return self
class DescribeAppEnvsResponseBodyAppEnvs(TeaModel):
def __init__(self, app_env=None):
self.app_env = app_env # type: list[DescribeAppEnvsResponseBodyAppEnvsAppEnv]
def validate(self):
if self.app_env:
for k in self.app_env:
if k:
k.validate()
def to_map(self):
result = dict()
result['AppEnv'] = []
if self.app_env is not None:
for k in self.app_env:
result['AppEnv'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.app_env = []
if m.get('AppEnv') is not None:
for k in m.get('AppEnv'):
temp_model = DescribeAppEnvsResponseBodyAppEnvsAppEnv()
self.app_env.append(temp_model.from_map(k))
return self
class DescribeAppEnvsResponseBody(TeaModel):
def __init__(self, total_count=None, request_id=None, message=None, page_size=None, page_number=None,
app_envs=None, code=None):
self.total_count = total_count # type: int
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.message = TeaConverter.to_unicode(message) # type: unicode
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.app_envs = app_envs # type: DescribeAppEnvsResponseBodyAppEnvs
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.app_envs:
self.app_envs.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.message is not None:
result['Message'] = self.message
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.app_envs is not None:
result['AppEnvs'] = self.app_envs.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('AppEnvs') is not None:
temp_model = DescribeAppEnvsResponseBodyAppEnvs()
self.app_envs = temp_model.from_map(m['AppEnvs'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DescribeAppEnvsResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeAppEnvsResponseBody
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=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 = DescribeAppEnvsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeAppEnvStatusRequest(TeaModel):
def __init__(self, env_id=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeAppEnvStatusResponseBodyEnvStatusInstanceAgentStatus(TeaModel):
def __init__(self, connected_instances=None, disconnected_instances=None):
self.connected_instances = connected_instances # type: int
self.disconnected_instances = disconnected_instances # type: int
def validate(self):
pass
def to_map(self):
result = dict()
if self.connected_instances is not None:
result['ConnectedInstances'] = self.connected_instances
if self.disconnected_instances is not None:
result['DisconnectedInstances'] = self.disconnected_instances
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ConnectedInstances') is not None:
self.connected_instances = m.get('ConnectedInstances')
if m.get('DisconnectedInstances') is not None:
self.disconnected_instances = m.get('DisconnectedInstances')
return self
class DescribeAppEnvStatusResponseBodyEnvStatusInstanceAppStatus(TeaModel):
def __init__(self, healthy_instances=None, stopped_instances=None, unhealthy_instances=None,
unknown_instances=None):
self.healthy_instances = healthy_instances # type: int
self.stopped_instances = stopped_instances # type: int
self.unhealthy_instances = unhealthy_instances # type: int
self.unknown_instances = unknown_instances # type: int
def validate(self):
pass
def to_map(self):
result = dict()
if self.healthy_instances is not None:
result['HealthyInstances'] = self.healthy_instances
if self.stopped_instances is not None:
result['StoppedInstances'] = self.stopped_instances
if self.unhealthy_instances is not None:
result['UnhealthyInstances'] = self.unhealthy_instances
if self.unknown_instances is not None:
result['UnknownInstances'] = self.unknown_instances
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HealthyInstances') is not None:
self.healthy_instances = m.get('HealthyInstances')
if m.get('StoppedInstances') is not None:
self.stopped_instances = m.get('StoppedInstances')
if m.get('UnhealthyInstances') is not None:
self.unhealthy_instances = m.get('UnhealthyInstances')
if m.get('UnknownInstances') is not None:
self.unknown_instances = m.get('UnknownInstances')
return self
class DescribeAppEnvStatusResponseBodyEnvStatus(TeaModel):
def __init__(self, change_banner=None, latest_change_id=None, env_status=None, env_name=None,
instance_agent_status=None, last_env_status=None, instance_app_status=None, env_id=None, aborting_change=None,
applying_change=None):
self.change_banner = TeaConverter.to_unicode(change_banner) # type: unicode
self.latest_change_id = TeaConverter.to_unicode(latest_change_id) # type: unicode
self.env_status = TeaConverter.to_unicode(env_status) # type: unicode
self.env_name = TeaConverter.to_unicode(env_name) # type: unicode
self.instance_agent_status = instance_agent_status # type: DescribeAppEnvStatusResponseBodyEnvStatusInstanceAgentStatus
self.last_env_status = TeaConverter.to_unicode(last_env_status) # type: unicode
self.instance_app_status = instance_app_status # type: DescribeAppEnvStatusResponseBodyEnvStatusInstanceAppStatus
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.aborting_change = aborting_change # type: bool
self.applying_change = applying_change # type: bool
def validate(self):
if self.instance_agent_status:
self.instance_agent_status.validate()
if self.instance_app_status:
self.instance_app_status.validate()
def to_map(self):
result = dict()
if self.change_banner is not None:
result['ChangeBanner'] = self.change_banner
if self.latest_change_id is not None:
result['LatestChangeId'] = self.latest_change_id
if self.env_status is not None:
result['EnvStatus'] = self.env_status
if self.env_name is not None:
result['EnvName'] = self.env_name
if self.instance_agent_status is not None:
result['InstanceAgentStatus'] = self.instance_agent_status.to_map()
if self.last_env_status is not None:
result['LastEnvStatus'] = self.last_env_status
if self.instance_app_status is not None:
result['InstanceAppStatus'] = self.instance_app_status.to_map()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.aborting_change is not None:
result['AbortingChange'] = self.aborting_change
if self.applying_change is not None:
result['ApplyingChange'] = self.applying_change
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ChangeBanner') is not None:
self.change_banner = m.get('ChangeBanner')
if m.get('LatestChangeId') is not None:
self.latest_change_id = m.get('LatestChangeId')
if m.get('EnvStatus') is not None:
self.env_status = m.get('EnvStatus')
if m.get('EnvName') is not None:
self.env_name = m.get('EnvName')
if m.get('InstanceAgentStatus') is not None:
temp_model = DescribeAppEnvStatusResponseBodyEnvStatusInstanceAgentStatus()
self.instance_agent_status = temp_model.from_map(m['InstanceAgentStatus'])
if m.get('LastEnvStatus') is not None:
self.last_env_status = m.get('LastEnvStatus')
if m.get('InstanceAppStatus') is not None:
temp_model = DescribeAppEnvStatusResponseBodyEnvStatusInstanceAppStatus()
self.instance_app_status = temp_model.from_map(m['InstanceAppStatus'])
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('AbortingChange') is not None:
self.aborting_change = m.get('AbortingChange')
if m.get('ApplyingChange') is not None:
self.applying_change = m.get('ApplyingChange')
return self
class DescribeAppEnvStatusResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, env_status=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.env_status = env_status # type: DescribeAppEnvStatusResponseBodyEnvStatus
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_status:
self.env_status.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.env_status is not None:
result['EnvStatus'] = self.env_status.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('EnvStatus') is not None:
temp_model = DescribeAppEnvStatusResponseBodyEnvStatus()
self.env_status = temp_model.from_map(m['EnvStatus'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DescribeAppEnvStatusResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeAppEnvStatusResponseBody
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=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 = DescribeAppEnvStatusResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeApplicationsRequest(TeaModel):
def __init__(self, app_id=None, page_size=None, page_number=None, app_name=None, app_search=None,
env_search=None, stack_search=None, category_search=None, region_id=None):
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.app_name = TeaConverter.to_unicode(app_name) # type: unicode
self.app_search = TeaConverter.to_unicode(app_search) # type: unicode
self.env_search = TeaConverter.to_unicode(env_search) # type: unicode
self.stack_search = TeaConverter.to_unicode(stack_search) # type: unicode
self.category_search = TeaConverter.to_unicode(category_search) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.app_id is not None:
result['AppId'] = self.app_id
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_search is not None:
result['AppSearch'] = self.app_search
if self.env_search is not None:
result['EnvSearch'] = self.env_search
if self.stack_search is not None:
result['StackSearch'] = self.stack_search
if self.category_search is not None:
result['CategorySearch'] = self.category_search
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('AppSearch') is not None:
self.app_search = m.get('AppSearch')
if m.get('EnvSearch') is not None:
self.env_search = m.get('EnvSearch')
if m.get('StackSearch') is not None:
self.stack_search = m.get('StackSearch')
if m.get('CategorySearch') is not None:
self.category_search = m.get('CategorySearch')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeApplicationsResponseBodyApplicationsApplication(TeaModel):
def __init__(self, total_envs=None, update_time=None, update_username=None, running_envs=None, create_time=None,
category_name=None, using_shared_storage=None, create_username=None, app_name=None, app_id=None,
terminated_envs=None, app_description=None):
self.total_envs = total_envs # type: int
self.update_time = update_time # type: long
self.update_username = TeaConverter.to_unicode(update_username) # type: unicode
self.running_envs = running_envs # type: int
self.create_time = create_time # type: long
self.category_name = TeaConverter.to_unicode(category_name) # type: unicode
self.using_shared_storage = TeaConverter.to_unicode(using_shared_storage) # type: unicode
self.create_username = TeaConverter.to_unicode(create_username) # type: unicode
self.app_name = TeaConverter.to_unicode(app_name) # type: unicode
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.terminated_envs = terminated_envs # type: int
self.app_description = TeaConverter.to_unicode(app_description) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.total_envs is not None:
result['TotalEnvs'] = self.total_envs
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.update_username is not None:
result['UpdateUsername'] = self.update_username
if self.running_envs is not None:
result['RunningEnvs'] = self.running_envs
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.category_name is not None:
result['CategoryName'] = self.category_name
if self.using_shared_storage is not None:
result['UsingSharedStorage'] = self.using_shared_storage
if self.create_username is not None:
result['CreateUsername'] = self.create_username
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_id is not None:
result['AppId'] = self.app_id
if self.terminated_envs is not None:
result['TerminatedEnvs'] = self.terminated_envs
if self.app_description is not None:
result['AppDescription'] = self.app_description
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TotalEnvs') is not None:
self.total_envs = m.get('TotalEnvs')
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('UpdateUsername') is not None:
self.update_username = m.get('UpdateUsername')
if m.get('RunningEnvs') is not None:
self.running_envs = m.get('RunningEnvs')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('CategoryName') is not None:
self.category_name = m.get('CategoryName')
if m.get('UsingSharedStorage') is not None:
self.using_shared_storage = m.get('UsingSharedStorage')
if m.get('CreateUsername') is not None:
self.create_username = m.get('CreateUsername')
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('TerminatedEnvs') is not None:
self.terminated_envs = m.get('TerminatedEnvs')
if m.get('AppDescription') is not None:
self.app_description = m.get('AppDescription')
return self
class DescribeApplicationsResponseBodyApplications(TeaModel):
def __init__(self, application=None):
self.application = application # type: list[DescribeApplicationsResponseBodyApplicationsApplication]
def validate(self):
if self.application:
for k in self.application:
if k:
k.validate()
def to_map(self):
result = dict()
result['Application'] = []
if self.application is not None:
for k in self.application:
result['Application'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.application = []
if m.get('Application') is not None:
for k in m.get('Application'):
temp_model = DescribeApplicationsResponseBodyApplicationsApplication()
self.application.append(temp_model.from_map(k))
return self
class DescribeApplicationsResponseBody(TeaModel):
def __init__(self, total_count=None, request_id=None, message=None, page_size=None, applications=None,
page_number=None, code=None):
self.total_count = total_count # type: int
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.message = TeaConverter.to_unicode(message) # type: unicode
self.page_size = page_size # type: int
self.applications = applications # type: DescribeApplicationsResponseBodyApplications
self.page_number = page_number # type: int
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.applications:
self.applications.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.message is not None:
result['Message'] = self.message
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.applications is not None:
result['Applications'] = self.applications.to_map()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('Applications') is not None:
temp_model = DescribeApplicationsResponseBodyApplications()
self.applications = temp_model.from_map(m['Applications'])
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DescribeApplicationsResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeApplicationsResponseBody
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=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 = DescribeApplicationsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeCategoriesRequest(TeaModel):
def __init__(self, region_id=None):
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeCategoriesResponseBodyCategoriesCategoryDemoProjectsDemoProject(TeaModel):
def __init__(self, source_url=None, package_download_url=None, package_url=None, region_id=None):
self.source_url = TeaConverter.to_unicode(source_url) # type: unicode
self.package_download_url = TeaConverter.to_unicode(package_download_url) # type: unicode
self.package_url = TeaConverter.to_unicode(package_url) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.source_url is not None:
result['SourceUrl'] = self.source_url
if self.package_download_url is not None:
result['PackageDownloadUrl'] = self.package_download_url
if self.package_url is not None:
result['PackageUrl'] = self.package_url
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('SourceUrl') is not None:
self.source_url = m.get('SourceUrl')
if m.get('PackageDownloadUrl') is not None:
self.package_download_url = m.get('PackageDownloadUrl')
if m.get('PackageUrl') is not None:
self.package_url = m.get('PackageUrl')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeCategoriesResponseBodyCategoriesCategoryDemoProjects(TeaModel):
def __init__(self, demo_project=None):
self.demo_project = demo_project # type: list[DescribeCategoriesResponseBodyCategoriesCategoryDemoProjectsDemoProject]
def validate(self):
if self.demo_project:
for k in self.demo_project:
if k:
k.validate()
def to_map(self):
result = dict()
result['DemoProject'] = []
if self.demo_project is not None:
for k in self.demo_project:
result['DemoProject'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.demo_project = []
if m.get('DemoProject') is not None:
for k in m.get('DemoProject'):
temp_model = DescribeCategoriesResponseBodyCategoriesCategoryDemoProjectsDemoProject()
self.demo_project.append(temp_model.from_map(k))
return self
class DescribeCategoriesResponseBodyCategoriesCategory(TeaModel):
def __init__(self, category_logo=None, update_time=None, demo_projects=None, create_time=None, category_id=None,
category_name=None, category_description=None):
self.category_logo = TeaConverter.to_unicode(category_logo) # type: unicode
self.update_time = TeaConverter.to_unicode(update_time) # type: unicode
self.demo_projects = demo_projects # type: DescribeCategoriesResponseBodyCategoriesCategoryDemoProjects
self.create_time = TeaConverter.to_unicode(create_time) # type: unicode
self.category_id = TeaConverter.to_unicode(category_id) # type: unicode
self.category_name = TeaConverter.to_unicode(category_name) # type: unicode
self.category_description = TeaConverter.to_unicode(category_description) # type: unicode
def validate(self):
if self.demo_projects:
self.demo_projects.validate()
def to_map(self):
result = dict()
if self.category_logo is not None:
result['CategoryLogo'] = self.category_logo
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.demo_projects is not None:
result['DemoProjects'] = self.demo_projects.to_map()
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.category_id is not None:
result['CategoryId'] = self.category_id
if self.category_name is not None:
result['CategoryName'] = self.category_name
if self.category_description is not None:
result['CategoryDescription'] = self.category_description
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CategoryLogo') is not None:
self.category_logo = m.get('CategoryLogo')
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('DemoProjects') is not None:
temp_model = DescribeCategoriesResponseBodyCategoriesCategoryDemoProjects()
self.demo_projects = temp_model.from_map(m['DemoProjects'])
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('CategoryId') is not None:
self.category_id = m.get('CategoryId')
if m.get('CategoryName') is not None:
self.category_name = m.get('CategoryName')
if m.get('CategoryDescription') is not None:
self.category_description = m.get('CategoryDescription')
return self
class DescribeCategoriesResponseBodyCategories(TeaModel):
def __init__(self, category=None):
self.category = category # type: list[DescribeCategoriesResponseBodyCategoriesCategory]
def validate(self):
if self.category:
for k in self.category:
if k:
k.validate()
def to_map(self):
result = dict()
result['Category'] = []
if self.category is not None:
for k in self.category:
result['Category'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.category = []
if m.get('Category') is not None:
for k in m.get('Category'):
temp_model = DescribeCategoriesResponseBodyCategoriesCategory()
self.category.append(temp_model.from_map(k))
return self
class DescribeCategoriesResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, categories=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.categories = categories # type: DescribeCategoriesResponseBodyCategories
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.categories:
self.categories.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.categories is not None:
result['Categories'] = self.categories.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Categories') is not None:
temp_model = DescribeCategoriesResponseBodyCategories()
self.categories = temp_model.from_map(m['Categories'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DescribeCategoriesResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeCategoriesResponseBody
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=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 = DescribeCategoriesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeChangeRequest(TeaModel):
def __init__(self, env_id=None, change_id=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeChangeResponseBodyChange(TeaModel):
def __init__(self, change_paused=None, change_description=None, finish_time=None, update_time=None,
change_timedout=None, create_time=None, change_message=None, action_name=None, change_finished=None,
create_username=None, change_id=None, change_aborted=None, change_succeed=None, env_id=None, change_name=None):
self.change_paused = change_paused # type: bool
self.change_description = TeaConverter.to_unicode(change_description) # type: unicode
self.finish_time = finish_time # type: long
self.update_time = update_time # type: long
self.change_timedout = change_timedout # type: bool
self.create_time = create_time # type: long
self.change_message = TeaConverter.to_unicode(change_message) # type: unicode
self.action_name = TeaConverter.to_unicode(action_name) # type: unicode
self.change_finished = change_finished # type: bool
self.create_username = TeaConverter.to_unicode(create_username) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.change_aborted = change_aborted # type: bool
self.change_succeed = change_succeed # type: bool
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.change_name = TeaConverter.to_unicode(change_name) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.change_paused is not None:
result['ChangePaused'] = self.change_paused
if self.change_description is not None:
result['ChangeDescription'] = self.change_description
if self.finish_time is not None:
result['FinishTime'] = self.finish_time
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.change_timedout is not None:
result['ChangeTimedout'] = self.change_timedout
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.change_message is not None:
result['ChangeMessage'] = self.change_message
if self.action_name is not None:
result['ActionName'] = self.action_name
if self.change_finished is not None:
result['ChangeFinished'] = self.change_finished
if self.create_username is not None:
result['CreateUsername'] = self.create_username
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.change_aborted is not None:
result['ChangeAborted'] = self.change_aborted
if self.change_succeed is not None:
result['ChangeSucceed'] = self.change_succeed
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.change_name is not None:
result['ChangeName'] = self.change_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ChangePaused') is not None:
self.change_paused = m.get('ChangePaused')
if m.get('ChangeDescription') is not None:
self.change_description = m.get('ChangeDescription')
if m.get('FinishTime') is not None:
self.finish_time = m.get('FinishTime')
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('ChangeTimedout') is not None:
self.change_timedout = m.get('ChangeTimedout')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('ChangeMessage') is not None:
self.change_message = m.get('ChangeMessage')
if m.get('ActionName') is not None:
self.action_name = m.get('ActionName')
if m.get('ChangeFinished') is not None:
self.change_finished = m.get('ChangeFinished')
if m.get('CreateUsername') is not None:
self.create_username = m.get('CreateUsername')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('ChangeAborted') is not None:
self.change_aborted = m.get('ChangeAborted')
if m.get('ChangeSucceed') is not None:
self.change_succeed = m.get('ChangeSucceed')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('ChangeName') is not None:
self.change_name = m.get('ChangeName')
return self
class DescribeChangeResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, change=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.change = change # type: DescribeChangeResponseBodyChange
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.change:
self.change.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.change is not None:
result['Change'] = self.change.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Change') is not None:
temp_model = DescribeChangeResponseBodyChange()
self.change = temp_model.from_map(m['Change'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DescribeChangeResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeChangeResponseBody
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=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 = DescribeChangeResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeChangesRequest(TeaModel):
def __init__(self, env_id=None, action_name=None, page_size=None, page_number=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.action_name = TeaConverter.to_unicode(action_name) # type: unicode
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.action_name is not None:
result['ActionName'] = self.action_name
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('ActionName') is not None:
self.action_name = m.get('ActionName')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeChangesResponseBodyChangesChange(TeaModel):
def __init__(self, change_paused=None, change_description=None, finish_time=None, update_time=None,
change_timedout=None, create_time=None, change_message=None, action_name=None, change_finished=None,
create_username=None, change_id=None, change_aborted=None, change_succeed=None, env_id=None, change_name=None):
self.change_paused = change_paused # type: bool
self.change_description = TeaConverter.to_unicode(change_description) # type: unicode
self.finish_time = finish_time # type: long
self.update_time = update_time # type: long
self.change_timedout = change_timedout # type: bool
self.create_time = create_time # type: long
self.change_message = TeaConverter.to_unicode(change_message) # type: unicode
self.action_name = TeaConverter.to_unicode(action_name) # type: unicode
self.change_finished = change_finished # type: bool
self.create_username = TeaConverter.to_unicode(create_username) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.change_aborted = change_aborted # type: bool
self.change_succeed = change_succeed # type: bool
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.change_name = TeaConverter.to_unicode(change_name) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.change_paused is not None:
result['ChangePaused'] = self.change_paused
if self.change_description is not None:
result['ChangeDescription'] = self.change_description
if self.finish_time is not None:
result['FinishTime'] = self.finish_time
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.change_timedout is not None:
result['ChangeTimedout'] = self.change_timedout
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.change_message is not None:
result['ChangeMessage'] = self.change_message
if self.action_name is not None:
result['ActionName'] = self.action_name
if self.change_finished is not None:
result['ChangeFinished'] = self.change_finished
if self.create_username is not None:
result['CreateUsername'] = self.create_username
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.change_aborted is not None:
result['ChangeAborted'] = self.change_aborted
if self.change_succeed is not None:
result['ChangeSucceed'] = self.change_succeed
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.change_name is not None:
result['ChangeName'] = self.change_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ChangePaused') is not None:
self.change_paused = m.get('ChangePaused')
if m.get('ChangeDescription') is not None:
self.change_description = m.get('ChangeDescription')
if m.get('FinishTime') is not None:
self.finish_time = m.get('FinishTime')
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('ChangeTimedout') is not None:
self.change_timedout = m.get('ChangeTimedout')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('ChangeMessage') is not None:
self.change_message = m.get('ChangeMessage')
if m.get('ActionName') is not None:
self.action_name = m.get('ActionName')
if m.get('ChangeFinished') is not None:
self.change_finished = m.get('ChangeFinished')
if m.get('CreateUsername') is not None:
self.create_username = m.get('CreateUsername')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('ChangeAborted') is not None:
self.change_aborted = m.get('ChangeAborted')
if m.get('ChangeSucceed') is not None:
self.change_succeed = m.get('ChangeSucceed')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('ChangeName') is not None:
self.change_name = m.get('ChangeName')
return self
class DescribeChangesResponseBodyChanges(TeaModel):
def __init__(self, change=None):
self.change = change # type: list[DescribeChangesResponseBodyChangesChange]
def validate(self):
if self.change:
for k in self.change:
if k:
k.validate()
def to_map(self):
result = dict()
result['Change'] = []
if self.change is not None:
for k in self.change:
result['Change'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.change = []
if m.get('Change') is not None:
for k in m.get('Change'):
temp_model = DescribeChangesResponseBodyChangesChange()
self.change.append(temp_model.from_map(k))
return self
class DescribeChangesResponseBody(TeaModel):
def __init__(self, changes=None, total_count=None, request_id=None, message=None, page_size=None,
page_number=None, code=None):
self.changes = changes # type: DescribeChangesResponseBodyChanges
self.total_count = total_count # type: int
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.message = TeaConverter.to_unicode(message) # type: unicode
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.changes:
self.changes.validate()
def to_map(self):
result = dict()
if self.changes is not None:
result['Changes'] = self.changes.to_map()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.message is not None:
result['Message'] = self.message
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Changes') is not None:
temp_model = DescribeChangesResponseBodyChanges()
self.changes = temp_model.from_map(m['Changes'])
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DescribeChangesResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeChangesResponseBody
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=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 = DescribeChangesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeConfigIndexRequest(TeaModel):
def __init__(self, stack_id=None, env_id=None, profile_name=None, template_id=None, region_id=None):
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.profile_name = TeaConverter.to_unicode(profile_name) # type: unicode
self.template_id = TeaConverter.to_unicode(template_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.stack_id is not None:
result['StackId'] = self.stack_id
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.profile_name is not None:
result['ProfileName'] = self.profile_name
if self.template_id is not None:
result['TemplateId'] = self.template_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('ProfileName') is not None:
self.profile_name = m.get('ProfileName')
if m.get('TemplateId') is not None:
self.template_id = m.get('TemplateId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeConfigIndexResponseBodyConfigGroupsConfigGroupConfigPathsConfigPathConfigOptionsConfigOption(TeaModel):
def __init__(self, regex_desc=None, max_value=None, editor_type=None, min_value=None, option_label=None,
default_value=None, max_length=None, regex_pattern=None, change_severity=None, option_description=None,
option_name=None, path_name=None, hidden_option=None, value_type=None, min_length=None, value_options=None,
readonly_option=None):
self.regex_desc = TeaConverter.to_unicode(regex_desc) # type: unicode
self.max_value = max_value # type: long
self.editor_type = TeaConverter.to_unicode(editor_type) # type: unicode
self.min_value = min_value # type: long
self.option_label = TeaConverter.to_unicode(option_label) # type: unicode
self.default_value = TeaConverter.to_unicode(default_value) # type: unicode
self.max_length = max_length # type: int
self.regex_pattern = TeaConverter.to_unicode(regex_pattern) # type: unicode
self.change_severity = TeaConverter.to_unicode(change_severity) # type: unicode
self.option_description = TeaConverter.to_unicode(option_description) # type: unicode
self.option_name = TeaConverter.to_unicode(option_name) # type: unicode
self.path_name = TeaConverter.to_unicode(path_name) # type: unicode
self.hidden_option = hidden_option # type: bool
self.value_type = TeaConverter.to_unicode(value_type) # type: unicode
self.min_length = min_length # type: int
self.value_options = TeaConverter.to_unicode(value_options) # type: unicode
self.readonly_option = readonly_option # type: bool
def validate(self):
pass
def to_map(self):
result = dict()
if self.regex_desc is not None:
result['RegexDesc'] = self.regex_desc
if self.max_value is not None:
result['MaxValue'] = self.max_value
if self.editor_type is not None:
result['EditorType'] = self.editor_type
if self.min_value is not None:
result['MinValue'] = self.min_value
if self.option_label is not None:
result['OptionLabel'] = self.option_label
if self.default_value is not None:
result['DefaultValue'] = self.default_value
if self.max_length is not None:
result['MaxLength'] = self.max_length
if self.regex_pattern is not None:
result['RegexPattern'] = self.regex_pattern
if self.change_severity is not None:
result['ChangeSeverity'] = self.change_severity
if self.option_description is not None:
result['OptionDescription'] = self.option_description
if self.option_name is not None:
result['OptionName'] = self.option_name
if self.path_name is not None:
result['PathName'] = self.path_name
if self.hidden_option is not None:
result['HiddenOption'] = self.hidden_option
if self.value_type is not None:
result['ValueType'] = self.value_type
if self.min_length is not None:
result['MinLength'] = self.min_length
if self.value_options is not None:
result['ValueOptions'] = self.value_options
if self.readonly_option is not None:
result['ReadonlyOption'] = self.readonly_option
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RegexDesc') is not None:
self.regex_desc = m.get('RegexDesc')
if m.get('MaxValue') is not None:
self.max_value = m.get('MaxValue')
if m.get('EditorType') is not None:
self.editor_type = m.get('EditorType')
if m.get('MinValue') is not None:
self.min_value = m.get('MinValue')
if m.get('OptionLabel') is not None:
self.option_label = m.get('OptionLabel')
if m.get('DefaultValue') is not None:
self.default_value = m.get('DefaultValue')
if m.get('MaxLength') is not None:
self.max_length = m.get('MaxLength')
if m.get('RegexPattern') is not None:
self.regex_pattern = m.get('RegexPattern')
if m.get('ChangeSeverity') is not None:
self.change_severity = m.get('ChangeSeverity')
if m.get('OptionDescription') is not None:
self.option_description = m.get('OptionDescription')
if m.get('OptionName') is not None:
self.option_name = m.get('OptionName')
if m.get('PathName') is not None:
self.path_name = m.get('PathName')
if m.get('HiddenOption') is not None:
self.hidden_option = m.get('HiddenOption')
if m.get('ValueType') is not None:
self.value_type = m.get('ValueType')
if m.get('MinLength') is not None:
self.min_length = m.get('MinLength')
if m.get('ValueOptions') is not None:
self.value_options = m.get('ValueOptions')
if m.get('ReadonlyOption') is not None:
self.readonly_option = m.get('ReadonlyOption')
return self
class DescribeConfigIndexResponseBodyConfigGroupsConfigGroupConfigPathsConfigPathConfigOptions(TeaModel):
def __init__(self, config_option=None):
self.config_option = config_option # type: list[DescribeConfigIndexResponseBodyConfigGroupsConfigGroupConfigPathsConfigPathConfigOptionsConfigOption]
def validate(self):
if self.config_option:
for k in self.config_option:
if k:
k.validate()
def to_map(self):
result = dict()
result['ConfigOption'] = []
if self.config_option is not None:
for k in self.config_option:
result['ConfigOption'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.config_option = []
if m.get('ConfigOption') is not None:
for k in m.get('ConfigOption'):
temp_model = DescribeConfigIndexResponseBodyConfigGroupsConfigGroupConfigPathsConfigPathConfigOptionsConfigOption()
self.config_option.append(temp_model.from_map(k))
return self
class DescribeConfigIndexResponseBodyConfigGroupsConfigGroupConfigPathsConfigPath(TeaModel):
def __init__(self, path_name=None, hidden_path=None, config_options=None, path_label=None):
self.path_name = TeaConverter.to_unicode(path_name) # type: unicode
self.hidden_path = hidden_path # type: bool
self.config_options = config_options # type: DescribeConfigIndexResponseBodyConfigGroupsConfigGroupConfigPathsConfigPathConfigOptions
self.path_label = TeaConverter.to_unicode(path_label) # type: unicode
def validate(self):
if self.config_options:
self.config_options.validate()
def to_map(self):
result = dict()
if self.path_name is not None:
result['PathName'] = self.path_name
if self.hidden_path is not None:
result['HiddenPath'] = self.hidden_path
if self.config_options is not None:
result['ConfigOptions'] = self.config_options.to_map()
if self.path_label is not None:
result['PathLabel'] = self.path_label
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PathName') is not None:
self.path_name = m.get('PathName')
if m.get('HiddenPath') is not None:
self.hidden_path = m.get('HiddenPath')
if m.get('ConfigOptions') is not None:
temp_model = DescribeConfigIndexResponseBodyConfigGroupsConfigGroupConfigPathsConfigPathConfigOptions()
self.config_options = temp_model.from_map(m['ConfigOptions'])
if m.get('PathLabel') is not None:
self.path_label = m.get('PathLabel')
return self
class DescribeConfigIndexResponseBodyConfigGroupsConfigGroupConfigPaths(TeaModel):
def __init__(self, config_path=None):
self.config_path = config_path # type: list[DescribeConfigIndexResponseBodyConfigGroupsConfigGroupConfigPathsConfigPath]
def validate(self):
if self.config_path:
for k in self.config_path:
if k:
k.validate()
def to_map(self):
result = dict()
result['ConfigPath'] = []
if self.config_path is not None:
for k in self.config_path:
result['ConfigPath'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.config_path = []
if m.get('ConfigPath') is not None:
for k in m.get('ConfigPath'):
temp_model = DescribeConfigIndexResponseBodyConfigGroupsConfigGroupConfigPathsConfigPath()
self.config_path.append(temp_model.from_map(k))
return self
class DescribeConfigIndexResponseBodyConfigGroupsConfigGroup(TeaModel):
def __init__(self, config_paths=None, group_name=None, group_label=None):
self.config_paths = config_paths # type: DescribeConfigIndexResponseBodyConfigGroupsConfigGroupConfigPaths
self.group_name = TeaConverter.to_unicode(group_name) # type: unicode
self.group_label = TeaConverter.to_unicode(group_label) # type: unicode
def validate(self):
if self.config_paths:
self.config_paths.validate()
def to_map(self):
result = dict()
if self.config_paths is not None:
result['ConfigPaths'] = self.config_paths.to_map()
if self.group_name is not None:
result['GroupName'] = self.group_name
if self.group_label is not None:
result['GroupLabel'] = self.group_label
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ConfigPaths') is not None:
temp_model = DescribeConfigIndexResponseBodyConfigGroupsConfigGroupConfigPaths()
self.config_paths = temp_model.from_map(m['ConfigPaths'])
if m.get('GroupName') is not None:
self.group_name = m.get('GroupName')
if m.get('GroupLabel') is not None:
self.group_label = m.get('GroupLabel')
return self
class DescribeConfigIndexResponseBodyConfigGroups(TeaModel):
def __init__(self, config_group=None):
self.config_group = config_group # type: list[DescribeConfigIndexResponseBodyConfigGroupsConfigGroup]
def validate(self):
if self.config_group:
for k in self.config_group:
if k:
k.validate()
def to_map(self):
result = dict()
result['ConfigGroup'] = []
if self.config_group is not None:
for k in self.config_group:
result['ConfigGroup'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.config_group = []
if m.get('ConfigGroup') is not None:
for k in m.get('ConfigGroup'):
temp_model = DescribeConfigIndexResponseBodyConfigGroupsConfigGroup()
self.config_group.append(temp_model.from_map(k))
return self
class DescribeConfigIndexResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, config_groups=None, code=None, stack_name=None, stack_id=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.config_groups = config_groups # type: DescribeConfigIndexResponseBodyConfigGroups
self.code = TeaConverter.to_unicode(code) # type: unicode
self.stack_name = TeaConverter.to_unicode(stack_name) # type: unicode
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
def validate(self):
if self.config_groups:
self.config_groups.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.config_groups is not None:
result['ConfigGroups'] = self.config_groups.to_map()
if self.code is not None:
result['Code'] = self.code
if self.stack_name is not None:
result['StackName'] = self.stack_name
if self.stack_id is not None:
result['StackId'] = self.stack_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ConfigGroups') is not None:
temp_model = DescribeConfigIndexResponseBodyConfigGroups()
self.config_groups = temp_model.from_map(m['ConfigGroups'])
if m.get('Code') is not None:
self.code = m.get('Code')
if m.get('StackName') is not None:
self.stack_name = m.get('StackName')
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
return self
class DescribeConfigIndexResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeConfigIndexResponseBody
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=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 = DescribeConfigIndexResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeConfigOptionsRequest(TeaModel):
def __init__(self, stack_id=None, env_id=None, profile_name=None, region_id=None):
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.profile_name = TeaConverter.to_unicode(profile_name) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.stack_id is not None:
result['StackId'] = self.stack_id
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.profile_name is not None:
result['ProfileName'] = self.profile_name
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('ProfileName') is not None:
self.profile_name = m.get('ProfileName')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeConfigOptionsResponseBodyStackConfigOptionConfigOptionsConfigOption(TeaModel):
def __init__(self, regex_desc=None, max_value=None, editor_type=None, min_value=None, default_value=None,
max_length=None, option_label=None, regex_pattern=None, change_severity=None, option_description=None,
option_name=None, path_name=None, hidden_option=None, value_type=None, min_length=None, value_options=None,
readonly_option=None):
self.regex_desc = TeaConverter.to_unicode(regex_desc) # type: unicode
self.max_value = max_value # type: long
self.editor_type = TeaConverter.to_unicode(editor_type) # type: unicode
self.min_value = min_value # type: long
self.default_value = TeaConverter.to_unicode(default_value) # type: unicode
self.max_length = max_length # type: int
self.option_label = TeaConverter.to_unicode(option_label) # type: unicode
self.regex_pattern = TeaConverter.to_unicode(regex_pattern) # type: unicode
self.change_severity = TeaConverter.to_unicode(change_severity) # type: unicode
self.option_description = TeaConverter.to_unicode(option_description) # type: unicode
self.option_name = TeaConverter.to_unicode(option_name) # type: unicode
self.path_name = TeaConverter.to_unicode(path_name) # type: unicode
self.hidden_option = hidden_option # type: bool
self.value_type = TeaConverter.to_unicode(value_type) # type: unicode
self.min_length = min_length # type: int
self.value_options = TeaConverter.to_unicode(value_options) # type: unicode
self.readonly_option = readonly_option # type: bool
def validate(self):
pass
def to_map(self):
result = dict()
if self.regex_desc is not None:
result['RegexDesc'] = self.regex_desc
if self.max_value is not None:
result['MaxValue'] = self.max_value
if self.editor_type is not None:
result['EditorType'] = self.editor_type
if self.min_value is not None:
result['MinValue'] = self.min_value
if self.default_value is not None:
result['DefaultValue'] = self.default_value
if self.max_length is not None:
result['MaxLength'] = self.max_length
if self.option_label is not None:
result['OptionLabel'] = self.option_label
if self.regex_pattern is not None:
result['RegexPattern'] = self.regex_pattern
if self.change_severity is not None:
result['ChangeSeverity'] = self.change_severity
if self.option_description is not None:
result['OptionDescription'] = self.option_description
if self.option_name is not None:
result['OptionName'] = self.option_name
if self.path_name is not None:
result['PathName'] = self.path_name
if self.hidden_option is not None:
result['HiddenOption'] = self.hidden_option
if self.value_type is not None:
result['ValueType'] = self.value_type
if self.min_length is not None:
result['MinLength'] = self.min_length
if self.value_options is not None:
result['ValueOptions'] = self.value_options
if self.readonly_option is not None:
result['ReadonlyOption'] = self.readonly_option
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RegexDesc') is not None:
self.regex_desc = m.get('RegexDesc')
if m.get('MaxValue') is not None:
self.max_value = m.get('MaxValue')
if m.get('EditorType') is not None:
self.editor_type = m.get('EditorType')
if m.get('MinValue') is not None:
self.min_value = m.get('MinValue')
if m.get('DefaultValue') is not None:
self.default_value = m.get('DefaultValue')
if m.get('MaxLength') is not None:
self.max_length = m.get('MaxLength')
if m.get('OptionLabel') is not None:
self.option_label = m.get('OptionLabel')
if m.get('RegexPattern') is not None:
self.regex_pattern = m.get('RegexPattern')
if m.get('ChangeSeverity') is not None:
self.change_severity = m.get('ChangeSeverity')
if m.get('OptionDescription') is not None:
self.option_description = m.get('OptionDescription')
if m.get('OptionName') is not None:
self.option_name = m.get('OptionName')
if m.get('PathName') is not None:
self.path_name = m.get('PathName')
if m.get('HiddenOption') is not None:
self.hidden_option = m.get('HiddenOption')
if m.get('ValueType') is not None:
self.value_type = m.get('ValueType')
if m.get('MinLength') is not None:
self.min_length = m.get('MinLength')
if m.get('ValueOptions') is not None:
self.value_options = m.get('ValueOptions')
if m.get('ReadonlyOption') is not None:
self.readonly_option = m.get('ReadonlyOption')
return self
class DescribeConfigOptionsResponseBodyStackConfigOptionConfigOptions(TeaModel):
def __init__(self, config_option=None):
self.config_option = config_option # type: list[DescribeConfigOptionsResponseBodyStackConfigOptionConfigOptionsConfigOption]
def validate(self):
if self.config_option:
for k in self.config_option:
if k:
k.validate()
def to_map(self):
result = dict()
result['ConfigOption'] = []
if self.config_option is not None:
for k in self.config_option:
result['ConfigOption'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.config_option = []
if m.get('ConfigOption') is not None:
for k in m.get('ConfigOption'):
temp_model = DescribeConfigOptionsResponseBodyStackConfigOptionConfigOptionsConfigOption()
self.config_option.append(temp_model.from_map(k))
return self
class DescribeConfigOptionsResponseBodyStackConfigOption(TeaModel):
def __init__(self, stack_id=None, config_options=None, stack_name=None):
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
self.config_options = config_options # type: DescribeConfigOptionsResponseBodyStackConfigOptionConfigOptions
self.stack_name = TeaConverter.to_unicode(stack_name) # type: unicode
def validate(self):
if self.config_options:
self.config_options.validate()
def to_map(self):
result = dict()
if self.stack_id is not None:
result['StackId'] = self.stack_id
if self.config_options is not None:
result['ConfigOptions'] = self.config_options.to_map()
if self.stack_name is not None:
result['StackName'] = self.stack_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
if m.get('ConfigOptions') is not None:
temp_model = DescribeConfigOptionsResponseBodyStackConfigOptionConfigOptions()
self.config_options = temp_model.from_map(m['ConfigOptions'])
if m.get('StackName') is not None:
self.stack_name = m.get('StackName')
return self
class DescribeConfigOptionsResponseBody(TeaModel):
def __init__(self, stack_config_option=None, message=None, request_id=None, code=None):
self.stack_config_option = stack_config_option # type: DescribeConfigOptionsResponseBodyStackConfigOption
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.stack_config_option:
self.stack_config_option.validate()
def to_map(self):
result = dict()
if self.stack_config_option is not None:
result['StackConfigOption'] = self.stack_config_option.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('StackConfigOption') is not None:
temp_model = DescribeConfigOptionsResponseBodyStackConfigOption()
self.stack_config_option = temp_model.from_map(m['StackConfigOption'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 DescribeConfigOptionsResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeConfigOptionsResponseBody
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=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 = DescribeConfigOptionsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeConfigSettingsRequest(TeaModel):
def __init__(self, env_id=None, template_id=None, path_name=None, option_name=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.template_id = TeaConverter.to_unicode(template_id) # type: unicode
self.path_name = TeaConverter.to_unicode(path_name) # type: unicode
self.option_name = TeaConverter.to_unicode(option_name) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.template_id is not None:
result['TemplateId'] = self.template_id
if self.path_name is not None:
result['PathName'] = self.path_name
if self.option_name is not None:
result['OptionName'] = self.option_name
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('TemplateId') is not None:
self.template_id = m.get('TemplateId')
if m.get('PathName') is not None:
self.path_name = m.get('PathName')
if m.get('OptionName') is not None:
self.option_name = m.get('OptionName')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeConfigSettingsResponseBodyConfigSettingsConfigSetting(TeaModel):
def __init__(self, option_name=None, path_name=None, setting_value=None):
self.option_name = TeaConverter.to_unicode(option_name) # type: unicode
self.path_name = TeaConverter.to_unicode(path_name) # type: unicode
self.setting_value = TeaConverter.to_unicode(setting_value) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.option_name is not None:
result['OptionName'] = self.option_name
if self.path_name is not None:
result['PathName'] = self.path_name
if self.setting_value is not None:
result['SettingValue'] = self.setting_value
return result
def from_map(self, m=None):
m = m or dict()
if m.get('OptionName') is not None:
self.option_name = m.get('OptionName')
if m.get('PathName') is not None:
self.path_name = m.get('PathName')
if m.get('SettingValue') is not None:
self.setting_value = m.get('SettingValue')
return self
class DescribeConfigSettingsResponseBodyConfigSettings(TeaModel):
def __init__(self, config_setting=None):
self.config_setting = config_setting # type: list[DescribeConfigSettingsResponseBodyConfigSettingsConfigSetting]
def validate(self):
if self.config_setting:
for k in self.config_setting:
if k:
k.validate()
def to_map(self):
result = dict()
result['ConfigSetting'] = []
if self.config_setting is not None:
for k in self.config_setting:
result['ConfigSetting'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.config_setting = []
if m.get('ConfigSetting') is not None:
for k in m.get('ConfigSetting'):
temp_model = DescribeConfigSettingsResponseBodyConfigSettingsConfigSetting()
self.config_setting.append(temp_model.from_map(k))
return self
class DescribeConfigSettingsResponseBody(TeaModel):
def __init__(self, config_settings=None, message=None, request_id=None, code=None):
self.config_settings = config_settings # type: DescribeConfigSettingsResponseBodyConfigSettings
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.config_settings:
self.config_settings.validate()
def to_map(self):
result = dict()
if self.config_settings is not None:
result['ConfigSettings'] = self.config_settings.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('ConfigSettings') is not None:
temp_model = DescribeConfigSettingsResponseBodyConfigSettings()
self.config_settings = temp_model.from_map(m['ConfigSettings'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 DescribeConfigSettingsResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeConfigSettingsResponseBody
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=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 = DescribeConfigSettingsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeConfigTemplatesRequest(TeaModel):
def __init__(self, app_id=None, template_name=None, template_search=None, page_size=None, page_number=None,
region_id=None):
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.template_name = TeaConverter.to_unicode(template_name) # type: unicode
self.template_search = TeaConverter.to_unicode(template_search) # type: unicode
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.app_id is not None:
result['AppId'] = self.app_id
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.template_search is not None:
result['TemplateSearch'] = self.template_search
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('TemplateName') is not None:
self.template_name = m.get('TemplateName')
if m.get('TemplateSearch') is not None:
self.template_search = m.get('TemplateSearch')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeConfigTemplatesResponseBodyConfigTemplatesConfigTemplate(TeaModel):
def __init__(self, template_description=None, app_name=None, update_time=None, stack_id=None,
pkg_version_label=None, create_time=None, app_id=None, stack_name=None, pkg_version_id=None, template_name=None,
template_id=None):
self.template_description = TeaConverter.to_unicode(template_description) # type: unicode
self.app_name = TeaConverter.to_unicode(app_name) # type: unicode
self.update_time = update_time # type: long
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
self.pkg_version_label = TeaConverter.to_unicode(pkg_version_label) # type: unicode
self.create_time = create_time # type: long
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.stack_name = TeaConverter.to_unicode(stack_name) # type: unicode
self.pkg_version_id = TeaConverter.to_unicode(pkg_version_id) # type: unicode
self.template_name = TeaConverter.to_unicode(template_name) # type: unicode
self.template_id = TeaConverter.to_unicode(template_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.template_description is not None:
result['TemplateDescription'] = self.template_description
if self.app_name is not None:
result['AppName'] = self.app_name
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.stack_id is not None:
result['StackId'] = self.stack_id
if self.pkg_version_label is not None:
result['PkgVersionLabel'] = self.pkg_version_label
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.app_id is not None:
result['AppId'] = self.app_id
if self.stack_name is not None:
result['StackName'] = self.stack_name
if self.pkg_version_id is not None:
result['PkgVersionId'] = self.pkg_version_id
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.template_id is not None:
result['TemplateId'] = self.template_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TemplateDescription') is not None:
self.template_description = m.get('TemplateDescription')
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
if m.get('PkgVersionLabel') is not None:
self.pkg_version_label = m.get('PkgVersionLabel')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('StackName') is not None:
self.stack_name = m.get('StackName')
if m.get('PkgVersionId') is not None:
self.pkg_version_id = m.get('PkgVersionId')
if m.get('TemplateName') is not None:
self.template_name = m.get('TemplateName')
if m.get('TemplateId') is not None:
self.template_id = m.get('TemplateId')
return self
class DescribeConfigTemplatesResponseBodyConfigTemplates(TeaModel):
def __init__(self, config_template=None):
self.config_template = config_template # type: list[DescribeConfigTemplatesResponseBodyConfigTemplatesConfigTemplate]
def validate(self):
if self.config_template:
for k in self.config_template:
if k:
k.validate()
def to_map(self):
result = dict()
result['ConfigTemplate'] = []
if self.config_template is not None:
for k in self.config_template:
result['ConfigTemplate'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.config_template = []
if m.get('ConfigTemplate') is not None:
for k in m.get('ConfigTemplate'):
temp_model = DescribeConfigTemplatesResponseBodyConfigTemplatesConfigTemplate()
self.config_template.append(temp_model.from_map(k))
return self
class DescribeConfigTemplatesResponseBody(TeaModel):
def __init__(self, config_templates=None, total_count=None, request_id=None, message=None, page_size=None,
page_number=None, code=None):
self.config_templates = config_templates # type: DescribeConfigTemplatesResponseBodyConfigTemplates
self.total_count = total_count # type: int
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.message = TeaConverter.to_unicode(message) # type: unicode
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.config_templates:
self.config_templates.validate()
def to_map(self):
result = dict()
if self.config_templates is not None:
result['ConfigTemplates'] = self.config_templates.to_map()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.message is not None:
result['Message'] = self.message
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ConfigTemplates') is not None:
temp_model = DescribeConfigTemplatesResponseBodyConfigTemplates()
self.config_templates = temp_model.from_map(m['ConfigTemplates'])
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DescribeConfigTemplatesResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeConfigTemplatesResponseBody
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=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 = DescribeConfigTemplatesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeEnvResourceRequest(TeaModel):
def __init__(self, env_id=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeEnvResourceResponseBodyEnvResourceVSwitchesVSwitch(TeaModel):
def __init__(self, id=None):
self.id = TeaConverter.to_unicode(id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class DescribeEnvResourceResponseBodyEnvResourceVSwitches(TeaModel):
def __init__(self, v_switch=None):
self.v_switch = v_switch # type: list[DescribeEnvResourceResponseBodyEnvResourceVSwitchesVSwitch]
def validate(self):
if self.v_switch:
for k in self.v_switch:
if k:
k.validate()
def to_map(self):
result = dict()
result['VSwitch'] = []
if self.v_switch is not None:
for k in self.v_switch:
result['VSwitch'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.v_switch = []
if m.get('VSwitch') is not None:
for k in m.get('VSwitch'):
temp_model = DescribeEnvResourceResponseBodyEnvResourceVSwitchesVSwitch()
self.v_switch.append(temp_model.from_map(k))
return self
class DescribeEnvResourceResponseBodyEnvResourceVpc(TeaModel):
def __init__(self, id=None):
self.id = TeaConverter.to_unicode(id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class DescribeEnvResourceResponseBodyEnvResourceMonitorGroup(TeaModel):
def __init__(self, id=None):
self.id = TeaConverter.to_unicode(id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class DescribeEnvResourceResponseBodyEnvResourceLoadBalancersLoadBalancerListenersListener(TeaModel):
def __init__(self, protocol=None, port=None):
self.protocol = TeaConverter.to_unicode(protocol) # type: unicode
self.port = port # type: int
def validate(self):
pass
def to_map(self):
result = dict()
if self.protocol is not None:
result['Protocol'] = self.protocol
if self.port is not None:
result['Port'] = self.port
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Protocol') is not None:
self.protocol = m.get('Protocol')
if m.get('Port') is not None:
self.port = m.get('Port')
return self
class DescribeEnvResourceResponseBodyEnvResourceLoadBalancersLoadBalancerListeners(TeaModel):
def __init__(self, listener=None):
self.listener = listener # type: list[DescribeEnvResourceResponseBodyEnvResourceLoadBalancersLoadBalancerListenersListener]
def validate(self):
if self.listener:
for k in self.listener:
if k:
k.validate()
def to_map(self):
result = dict()
result['Listener'] = []
if self.listener is not None:
for k in self.listener:
result['Listener'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.listener = []
if m.get('Listener') is not None:
for k in m.get('Listener'):
temp_model = DescribeEnvResourceResponseBodyEnvResourceLoadBalancersLoadBalancerListenersListener()
self.listener.append(temp_model.from_map(k))
return self
class DescribeEnvResourceResponseBodyEnvResourceLoadBalancersLoadBalancer(TeaModel):
def __init__(self, imported=None, protocol=None, address_type=None, listeners=None, port=None, id=None):
self.imported = imported # type: bool
self.protocol = TeaConverter.to_unicode(protocol) # type: unicode
self.address_type = TeaConverter.to_unicode(address_type) # type: unicode
self.listeners = listeners # type: DescribeEnvResourceResponseBodyEnvResourceLoadBalancersLoadBalancerListeners
self.port = port # type: int
self.id = TeaConverter.to_unicode(id) # type: unicode
def validate(self):
if self.listeners:
self.listeners.validate()
def to_map(self):
result = dict()
if self.imported is not None:
result['Imported'] = self.imported
if self.protocol is not None:
result['Protocol'] = self.protocol
if self.address_type is not None:
result['AddressType'] = self.address_type
if self.listeners is not None:
result['Listeners'] = self.listeners.to_map()
if self.port is not None:
result['Port'] = self.port
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Imported') is not None:
self.imported = m.get('Imported')
if m.get('Protocol') is not None:
self.protocol = m.get('Protocol')
if m.get('AddressType') is not None:
self.address_type = m.get('AddressType')
if m.get('Listeners') is not None:
temp_model = DescribeEnvResourceResponseBodyEnvResourceLoadBalancersLoadBalancerListeners()
self.listeners = temp_model.from_map(m['Listeners'])
if m.get('Port') is not None:
self.port = m.get('Port')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class DescribeEnvResourceResponseBodyEnvResourceLoadBalancers(TeaModel):
def __init__(self, load_balancer=None):
self.load_balancer = load_balancer # type: list[DescribeEnvResourceResponseBodyEnvResourceLoadBalancersLoadBalancer]
def validate(self):
if self.load_balancer:
for k in self.load_balancer:
if k:
k.validate()
def to_map(self):
result = dict()
result['LoadBalancer'] = []
if self.load_balancer is not None:
for k in self.load_balancer:
result['LoadBalancer'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.load_balancer = []
if m.get('LoadBalancer') is not None:
for k in m.get('LoadBalancer'):
temp_model = DescribeEnvResourceResponseBodyEnvResourceLoadBalancersLoadBalancer()
self.load_balancer.append(temp_model.from_map(k))
return self
class DescribeEnvResourceResponseBodyEnvResourceInstancesInstance(TeaModel):
def __init__(self, imported=None, id=None):
self.imported = imported # type: bool
self.id = TeaConverter.to_unicode(id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.imported is not None:
result['Imported'] = self.imported
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Imported') is not None:
self.imported = m.get('Imported')
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class DescribeEnvResourceResponseBodyEnvResourceInstances(TeaModel):
def __init__(self, instance=None):
self.instance = instance # type: list[DescribeEnvResourceResponseBodyEnvResourceInstancesInstance]
def validate(self):
if self.instance:
for k in self.instance:
if k:
k.validate()
def to_map(self):
result = dict()
result['Instance'] = []
if self.instance is not None:
for k in self.instance:
result['Instance'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.instance = []
if m.get('Instance') is not None:
for k in m.get('Instance'):
temp_model = DescribeEnvResourceResponseBodyEnvResourceInstancesInstance()
self.instance.append(temp_model.from_map(k))
return self
class DescribeEnvResourceResponseBodyEnvResourceDefaultSecurityGroupsSecurityGroup(TeaModel):
def __init__(self, id=None):
self.id = TeaConverter.to_unicode(id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class DescribeEnvResourceResponseBodyEnvResourceDefaultSecurityGroups(TeaModel):
def __init__(self, security_group=None):
self.security_group = security_group # type: list[DescribeEnvResourceResponseBodyEnvResourceDefaultSecurityGroupsSecurityGroup]
def validate(self):
if self.security_group:
for k in self.security_group:
if k:
k.validate()
def to_map(self):
result = dict()
result['SecurityGroup'] = []
if self.security_group is not None:
for k in self.security_group:
result['SecurityGroup'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.security_group = []
if m.get('SecurityGroup') is not None:
for k in m.get('SecurityGroup'):
temp_model = DescribeEnvResourceResponseBodyEnvResourceDefaultSecurityGroupsSecurityGroup()
self.security_group.append(temp_model.from_map(k))
return self
class DescribeEnvResourceResponseBodyEnvResourceScalingGroup(TeaModel):
def __init__(self, id=None):
self.id = TeaConverter.to_unicode(id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class DescribeEnvResourceResponseBodyEnvResourceDomainsDomain(TeaModel):
def __init__(self, is_default=None, hosted_by=None, sub_domain=None, domain_name=None, managed_by=None):
self.is_default = is_default # type: bool
self.hosted_by = TeaConverter.to_unicode(hosted_by) # type: unicode
self.sub_domain = TeaConverter.to_unicode(sub_domain) # type: unicode
self.domain_name = TeaConverter.to_unicode(domain_name) # type: unicode
self.managed_by = TeaConverter.to_unicode(managed_by) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.is_default is not None:
result['IsDefault'] = self.is_default
if self.hosted_by is not None:
result['HostedBy'] = self.hosted_by
if self.sub_domain is not None:
result['SubDomain'] = self.sub_domain
if self.domain_name is not None:
result['DomainName'] = self.domain_name
if self.managed_by is not None:
result['ManagedBy'] = self.managed_by
return result
def from_map(self, m=None):
m = m or dict()
if m.get('IsDefault') is not None:
self.is_default = m.get('IsDefault')
if m.get('HostedBy') is not None:
self.hosted_by = m.get('HostedBy')
if m.get('SubDomain') is not None:
self.sub_domain = m.get('SubDomain')
if m.get('DomainName') is not None:
self.domain_name = m.get('DomainName')
if m.get('ManagedBy') is not None:
self.managed_by = m.get('ManagedBy')
return self
class DescribeEnvResourceResponseBodyEnvResourceDomains(TeaModel):
def __init__(self, domain=None):
self.domain = domain # type: list[DescribeEnvResourceResponseBodyEnvResourceDomainsDomain]
def validate(self):
if self.domain:
for k in self.domain:
if k:
k.validate()
def to_map(self):
result = dict()
result['Domain'] = []
if self.domain is not None:
for k in self.domain:
result['Domain'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.domain = []
if m.get('Domain') is not None:
for k in m.get('Domain'):
temp_model = DescribeEnvResourceResponseBodyEnvResourceDomainsDomain()
self.domain.append(temp_model.from_map(k))
return self
class DescribeEnvResourceResponseBodyEnvResourceRdsInstancesRdsInstance(TeaModel):
def __init__(self, imported=None, database_name=None, id=None, account_name=None):
self.imported = imported # type: bool
self.database_name = TeaConverter.to_unicode(database_name) # type: unicode
self.id = TeaConverter.to_unicode(id) # type: unicode
self.account_name = TeaConverter.to_unicode(account_name) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.imported is not None:
result['Imported'] = self.imported
if self.database_name is not None:
result['DatabaseName'] = self.database_name
if self.id is not None:
result['Id'] = self.id
if self.account_name is not None:
result['AccountName'] = self.account_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Imported') is not None:
self.imported = m.get('Imported')
if m.get('DatabaseName') is not None:
self.database_name = m.get('DatabaseName')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('AccountName') is not None:
self.account_name = m.get('AccountName')
return self
class DescribeEnvResourceResponseBodyEnvResourceRdsInstances(TeaModel):
def __init__(self, rds_instance=None):
self.rds_instance = rds_instance # type: list[DescribeEnvResourceResponseBodyEnvResourceRdsInstancesRdsInstance]
def validate(self):
if self.rds_instance:
for k in self.rds_instance:
if k:
k.validate()
def to_map(self):
result = dict()
result['RdsInstance'] = []
if self.rds_instance is not None:
for k in self.rds_instance:
result['RdsInstance'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.rds_instance = []
if m.get('RdsInstance') is not None:
for k in m.get('RdsInstance'):
temp_model = DescribeEnvResourceResponseBodyEnvResourceRdsInstancesRdsInstance()
self.rds_instance.append(temp_model.from_map(k))
return self
class DescribeEnvResourceResponseBodyEnvResource(TeaModel):
def __init__(self, launch_template_id=None, env_name=None, v_switches=None, vpc=None, monitor_group=None,
launch_configuration_id=None, load_balancers=None, instances=None, default_security_groups=None, scaling_group=None,
domains=None, rds_instances=None, env_id=None):
self.launch_template_id = TeaConverter.to_unicode(launch_template_id) # type: unicode
self.env_name = TeaConverter.to_unicode(env_name) # type: unicode
self.v_switches = v_switches # type: DescribeEnvResourceResponseBodyEnvResourceVSwitches
self.vpc = vpc # type: DescribeEnvResourceResponseBodyEnvResourceVpc
self.monitor_group = monitor_group # type: DescribeEnvResourceResponseBodyEnvResourceMonitorGroup
self.launch_configuration_id = TeaConverter.to_unicode(launch_configuration_id) # type: unicode
self.load_balancers = load_balancers # type: DescribeEnvResourceResponseBodyEnvResourceLoadBalancers
self.instances = instances # type: DescribeEnvResourceResponseBodyEnvResourceInstances
self.default_security_groups = default_security_groups # type: DescribeEnvResourceResponseBodyEnvResourceDefaultSecurityGroups
self.scaling_group = scaling_group # type: DescribeEnvResourceResponseBodyEnvResourceScalingGroup
self.domains = domains # type: DescribeEnvResourceResponseBodyEnvResourceDomains
self.rds_instances = rds_instances # type: DescribeEnvResourceResponseBodyEnvResourceRdsInstances
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
def validate(self):
if self.v_switches:
self.v_switches.validate()
if self.vpc:
self.vpc.validate()
if self.monitor_group:
self.monitor_group.validate()
if self.load_balancers:
self.load_balancers.validate()
if self.instances:
self.instances.validate()
if self.default_security_groups:
self.default_security_groups.validate()
if self.scaling_group:
self.scaling_group.validate()
if self.domains:
self.domains.validate()
if self.rds_instances:
self.rds_instances.validate()
def to_map(self):
result = dict()
if self.launch_template_id is not None:
result['LaunchTemplateId'] = self.launch_template_id
if self.env_name is not None:
result['EnvName'] = self.env_name
if self.v_switches is not None:
result['VSwitches'] = self.v_switches.to_map()
if self.vpc is not None:
result['Vpc'] = self.vpc.to_map()
if self.monitor_group is not None:
result['MonitorGroup'] = self.monitor_group.to_map()
if self.launch_configuration_id is not None:
result['LaunchConfigurationId'] = self.launch_configuration_id
if self.load_balancers is not None:
result['LoadBalancers'] = self.load_balancers.to_map()
if self.instances is not None:
result['Instances'] = self.instances.to_map()
if self.default_security_groups is not None:
result['DefaultSecurityGroups'] = self.default_security_groups.to_map()
if self.scaling_group is not None:
result['ScalingGroup'] = self.scaling_group.to_map()
if self.domains is not None:
result['Domains'] = self.domains.to_map()
if self.rds_instances is not None:
result['RdsInstances'] = self.rds_instances.to_map()
if self.env_id is not None:
result['EnvId'] = self.env_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('LaunchTemplateId') is not None:
self.launch_template_id = m.get('LaunchTemplateId')
if m.get('EnvName') is not None:
self.env_name = m.get('EnvName')
if m.get('VSwitches') is not None:
temp_model = DescribeEnvResourceResponseBodyEnvResourceVSwitches()
self.v_switches = temp_model.from_map(m['VSwitches'])
if m.get('Vpc') is not None:
temp_model = DescribeEnvResourceResponseBodyEnvResourceVpc()
self.vpc = temp_model.from_map(m['Vpc'])
if m.get('MonitorGroup') is not None:
temp_model = DescribeEnvResourceResponseBodyEnvResourceMonitorGroup()
self.monitor_group = temp_model.from_map(m['MonitorGroup'])
if m.get('LaunchConfigurationId') is not None:
self.launch_configuration_id = m.get('LaunchConfigurationId')
if m.get('LoadBalancers') is not None:
temp_model = DescribeEnvResourceResponseBodyEnvResourceLoadBalancers()
self.load_balancers = temp_model.from_map(m['LoadBalancers'])
if m.get('Instances') is not None:
temp_model = DescribeEnvResourceResponseBodyEnvResourceInstances()
self.instances = temp_model.from_map(m['Instances'])
if m.get('DefaultSecurityGroups') is not None:
temp_model = DescribeEnvResourceResponseBodyEnvResourceDefaultSecurityGroups()
self.default_security_groups = temp_model.from_map(m['DefaultSecurityGroups'])
if m.get('ScalingGroup') is not None:
temp_model = DescribeEnvResourceResponseBodyEnvResourceScalingGroup()
self.scaling_group = temp_model.from_map(m['ScalingGroup'])
if m.get('Domains') is not None:
temp_model = DescribeEnvResourceResponseBodyEnvResourceDomains()
self.domains = temp_model.from_map(m['Domains'])
if m.get('RdsInstances') is not None:
temp_model = DescribeEnvResourceResponseBodyEnvResourceRdsInstances()
self.rds_instances = temp_model.from_map(m['RdsInstances'])
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
return self
class DescribeEnvResourceResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, code=None, env_resource=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
self.env_resource = env_resource # type: DescribeEnvResourceResponseBodyEnvResource
def validate(self):
if self.env_resource:
self.env_resource.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.code is not None:
result['Code'] = self.code
if self.env_resource is not None:
result['EnvResource'] = self.env_resource.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
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')
if m.get('EnvResource') is not None:
temp_model = DescribeEnvResourceResponseBodyEnvResource()
self.env_resource = temp_model.from_map(m['EnvResource'])
return self
class DescribeEnvResourceResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeEnvResourceResponseBody
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=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 = DescribeEnvResourceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeEventsRequest(TeaModel):
def __init__(self, env_id=None, start_time=None, end_time=None, page_size=None, page_number=None, change_id=None,
last_change_events=None, reverse_by_timestamp=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.start_time = start_time # type: long
self.end_time = end_time # type: long
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.last_change_events = last_change_events # type: bool
self.reverse_by_timestamp = reverse_by_timestamp # type: bool
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.end_time is not None:
result['EndTime'] = self.end_time
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.last_change_events is not None:
result['LastChangeEvents'] = self.last_change_events
if self.reverse_by_timestamp is not None:
result['ReverseByTimestamp'] = self.reverse_by_timestamp
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
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')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('LastChangeEvents') is not None:
self.last_change_events = m.get('LastChangeEvents')
if m.get('ReverseByTimestamp') is not None:
self.reverse_by_timestamp = m.get('ReverseByTimestamp')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeEventsResponseBodyEventsEventObjectAttrsObjectAttr(TeaModel):
def __init__(self, attribute_name=None, attribute_value=None):
self.attribute_name = TeaConverter.to_unicode(attribute_name) # type: unicode
self.attribute_value = TeaConverter.to_unicode(attribute_value) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.attribute_name is not None:
result['AttributeName'] = self.attribute_name
if self.attribute_value is not None:
result['AttributeValue'] = self.attribute_value
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AttributeName') is not None:
self.attribute_name = m.get('AttributeName')
if m.get('AttributeValue') is not None:
self.attribute_value = m.get('AttributeValue')
return self
class DescribeEventsResponseBodyEventsEventObjectAttrs(TeaModel):
def __init__(self, object_attr=None):
self.object_attr = object_attr # type: list[DescribeEventsResponseBodyEventsEventObjectAttrsObjectAttr]
def validate(self):
if self.object_attr:
for k in self.object_attr:
if k:
k.validate()
def to_map(self):
result = dict()
result['ObjectAttr'] = []
if self.object_attr is not None:
for k in self.object_attr:
result['ObjectAttr'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.object_attr = []
if m.get('ObjectAttr') is not None:
for k in m.get('ObjectAttr'):
temp_model = DescribeEventsResponseBodyEventsEventObjectAttrsObjectAttr()
self.object_attr.append(temp_model.from_map(k))
return self
class DescribeEventsResponseBodyEventsEventMsgParams(TeaModel):
def __init__(self, msg_param=None):
self.msg_param = msg_param # type: list[unicode]
def validate(self):
pass
def to_map(self):
result = dict()
if self.msg_param is not None:
result['MsgParam'] = self.msg_param
return result
def from_map(self, m=None):
m = m or dict()
if m.get('MsgParam') is not None:
self.msg_param = m.get('MsgParam')
return self
class DescribeEventsResponseBodyEventsEvent(TeaModel):
def __init__(self, primary_user_name=None, object_type=None, envent_name=None, event_timestamp=None,
second_user_name=None, msg_code=None, object_name=None, event_message=None, event_id=None, object_attrs=None,
app_id=None, event_level=None, object_id=None, msg_params=None, primary_user_id=None, env_id=None,
trace_id=None, second_user_id=None):
self.primary_user_name = TeaConverter.to_unicode(primary_user_name) # type: unicode
self.object_type = TeaConverter.to_unicode(object_type) # type: unicode
self.envent_name = TeaConverter.to_unicode(envent_name) # type: unicode
self.event_timestamp = event_timestamp # type: long
self.second_user_name = TeaConverter.to_unicode(second_user_name) # type: unicode
self.msg_code = TeaConverter.to_unicode(msg_code) # type: unicode
self.object_name = TeaConverter.to_unicode(object_name) # type: unicode
self.event_message = TeaConverter.to_unicode(event_message) # type: unicode
self.event_id = TeaConverter.to_unicode(event_id) # type: unicode
self.object_attrs = object_attrs # type: DescribeEventsResponseBodyEventsEventObjectAttrs
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.event_level = TeaConverter.to_unicode(event_level) # type: unicode
self.object_id = TeaConverter.to_unicode(object_id) # type: unicode
self.msg_params = msg_params # type: DescribeEventsResponseBodyEventsEventMsgParams
self.primary_user_id = TeaConverter.to_unicode(primary_user_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.trace_id = TeaConverter.to_unicode(trace_id) # type: unicode
self.second_user_id = TeaConverter.to_unicode(second_user_id) # type: unicode
def validate(self):
if self.object_attrs:
self.object_attrs.validate()
if self.msg_params:
self.msg_params.validate()
def to_map(self):
result = dict()
if self.primary_user_name is not None:
result['PrimaryUserName'] = self.primary_user_name
if self.object_type is not None:
result['ObjectType'] = self.object_type
if self.envent_name is not None:
result['EnventName'] = self.envent_name
if self.event_timestamp is not None:
result['EventTimestamp'] = self.event_timestamp
if self.second_user_name is not None:
result['SecondUserName'] = self.second_user_name
if self.msg_code is not None:
result['MsgCode'] = self.msg_code
if self.object_name is not None:
result['ObjectName'] = self.object_name
if self.event_message is not None:
result['EventMessage'] = self.event_message
if self.event_id is not None:
result['EventId'] = self.event_id
if self.object_attrs is not None:
result['ObjectAttrs'] = self.object_attrs.to_map()
if self.app_id is not None:
result['AppId'] = self.app_id
if self.event_level is not None:
result['EventLevel'] = self.event_level
if self.object_id is not None:
result['ObjectId'] = self.object_id
if self.msg_params is not None:
result['MsgParams'] = self.msg_params.to_map()
if self.primary_user_id is not None:
result['PrimaryUserId'] = self.primary_user_id
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.trace_id is not None:
result['TraceId'] = self.trace_id
if self.second_user_id is not None:
result['SecondUserId'] = self.second_user_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('PrimaryUserName') is not None:
self.primary_user_name = m.get('PrimaryUserName')
if m.get('ObjectType') is not None:
self.object_type = m.get('ObjectType')
if m.get('EnventName') is not None:
self.envent_name = m.get('EnventName')
if m.get('EventTimestamp') is not None:
self.event_timestamp = m.get('EventTimestamp')
if m.get('SecondUserName') is not None:
self.second_user_name = m.get('SecondUserName')
if m.get('MsgCode') is not None:
self.msg_code = m.get('MsgCode')
if m.get('ObjectName') is not None:
self.object_name = m.get('ObjectName')
if m.get('EventMessage') is not None:
self.event_message = m.get('EventMessage')
if m.get('EventId') is not None:
self.event_id = m.get('EventId')
if m.get('ObjectAttrs') is not None:
temp_model = DescribeEventsResponseBodyEventsEventObjectAttrs()
self.object_attrs = temp_model.from_map(m['ObjectAttrs'])
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('EventLevel') is not None:
self.event_level = m.get('EventLevel')
if m.get('ObjectId') is not None:
self.object_id = m.get('ObjectId')
if m.get('MsgParams') is not None:
temp_model = DescribeEventsResponseBodyEventsEventMsgParams()
self.msg_params = temp_model.from_map(m['MsgParams'])
if m.get('PrimaryUserId') is not None:
self.primary_user_id = m.get('PrimaryUserId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('TraceId') is not None:
self.trace_id = m.get('TraceId')
if m.get('SecondUserId') is not None:
self.second_user_id = m.get('SecondUserId')
return self
class DescribeEventsResponseBodyEvents(TeaModel):
def __init__(self, event=None):
self.event = event # type: list[DescribeEventsResponseBodyEventsEvent]
def validate(self):
if self.event:
for k in self.event:
if k:
k.validate()
def to_map(self):
result = dict()
result['Event'] = []
if self.event is not None:
for k in self.event:
result['Event'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.event = []
if m.get('Event') is not None:
for k in m.get('Event'):
temp_model = DescribeEventsResponseBodyEventsEvent()
self.event.append(temp_model.from_map(k))
return self
class DescribeEventsResponseBody(TeaModel):
def __init__(self, total_count=None, request_id=None, message=None, page_size=None, page_number=None,
events=None, code=None):
self.total_count = total_count # type: int
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.message = TeaConverter.to_unicode(message) # type: unicode
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.events = events # type: DescribeEventsResponseBodyEvents
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.events:
self.events.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.message is not None:
result['Message'] = self.message
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.events is not None:
result['Events'] = self.events.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('Events') is not None:
temp_model = DescribeEventsResponseBodyEvents()
self.events = temp_model.from_map(m['Events'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DescribeEventsResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeEventsResponseBody
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=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 = DescribeEventsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeGatherLogResultRequest(TeaModel):
def __init__(self, change_id=None, region_id=None):
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeGatherLogResultResponseBodyGatherLogResultChange(TeaModel):
def __init__(self, change_paused=None, change_description=None, finish_time=None, update_time=None,
change_timedout=None, create_time=None, change_message=None, action_name=None, change_finished=None,
create_username=None, change_succeeded=None, change_id=None, change_aborted=None, env_id=None, change_name=None):
self.change_paused = change_paused # type: bool
self.change_description = TeaConverter.to_unicode(change_description) # type: unicode
self.finish_time = finish_time # type: long
self.update_time = update_time # type: long
self.change_timedout = change_timedout # type: bool
self.create_time = create_time # type: long
self.change_message = TeaConverter.to_unicode(change_message) # type: unicode
self.action_name = TeaConverter.to_unicode(action_name) # type: unicode
self.change_finished = change_finished # type: bool
self.create_username = TeaConverter.to_unicode(create_username) # type: unicode
self.change_succeeded = change_succeeded # type: bool
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.change_aborted = change_aborted # type: bool
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.change_name = TeaConverter.to_unicode(change_name) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.change_paused is not None:
result['ChangePaused'] = self.change_paused
if self.change_description is not None:
result['ChangeDescription'] = self.change_description
if self.finish_time is not None:
result['FinishTime'] = self.finish_time
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.change_timedout is not None:
result['ChangeTimedout'] = self.change_timedout
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.change_message is not None:
result['ChangeMessage'] = self.change_message
if self.action_name is not None:
result['ActionName'] = self.action_name
if self.change_finished is not None:
result['ChangeFinished'] = self.change_finished
if self.create_username is not None:
result['CreateUsername'] = self.create_username
if self.change_succeeded is not None:
result['ChangeSucceeded'] = self.change_succeeded
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.change_aborted is not None:
result['ChangeAborted'] = self.change_aborted
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.change_name is not None:
result['ChangeName'] = self.change_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ChangePaused') is not None:
self.change_paused = m.get('ChangePaused')
if m.get('ChangeDescription') is not None:
self.change_description = m.get('ChangeDescription')
if m.get('FinishTime') is not None:
self.finish_time = m.get('FinishTime')
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('ChangeTimedout') is not None:
self.change_timedout = m.get('ChangeTimedout')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('ChangeMessage') is not None:
self.change_message = m.get('ChangeMessage')
if m.get('ActionName') is not None:
self.action_name = m.get('ActionName')
if m.get('ChangeFinished') is not None:
self.change_finished = m.get('ChangeFinished')
if m.get('CreateUsername') is not None:
self.create_username = m.get('CreateUsername')
if m.get('ChangeSucceeded') is not None:
self.change_succeeded = m.get('ChangeSucceeded')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('ChangeAborted') is not None:
self.change_aborted = m.get('ChangeAborted')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('ChangeName') is not None:
self.change_name = m.get('ChangeName')
return self
class DescribeGatherLogResultResponseBodyGatherLogResultInstanceResultsInstanceResult(TeaModel):
def __init__(self, task_message=None, storage_key=None, instance_id=None, task_succeeded=None):
self.task_message = TeaConverter.to_unicode(task_message) # type: unicode
self.storage_key = TeaConverter.to_unicode(storage_key) # type: unicode
self.instance_id = TeaConverter.to_unicode(instance_id) # type: unicode
self.task_succeeded = task_succeeded # type: bool
def validate(self):
pass
def to_map(self):
result = dict()
if self.task_message is not None:
result['TaskMessage'] = self.task_message
if self.storage_key is not None:
result['StorageKey'] = self.storage_key
if self.instance_id is not None:
result['InstanceId'] = self.instance_id
if self.task_succeeded is not None:
result['TaskSucceeded'] = self.task_succeeded
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TaskMessage') is not None:
self.task_message = m.get('TaskMessage')
if m.get('StorageKey') is not None:
self.storage_key = m.get('StorageKey')
if m.get('InstanceId') is not None:
self.instance_id = m.get('InstanceId')
if m.get('TaskSucceeded') is not None:
self.task_succeeded = m.get('TaskSucceeded')
return self
class DescribeGatherLogResultResponseBodyGatherLogResultInstanceResults(TeaModel):
def __init__(self, instance_result=None):
self.instance_result = instance_result # type: list[DescribeGatherLogResultResponseBodyGatherLogResultInstanceResultsInstanceResult]
def validate(self):
if self.instance_result:
for k in self.instance_result:
if k:
k.validate()
def to_map(self):
result = dict()
result['InstanceResult'] = []
if self.instance_result is not None:
for k in self.instance_result:
result['InstanceResult'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.instance_result = []
if m.get('InstanceResult') is not None:
for k in m.get('InstanceResult'):
temp_model = DescribeGatherLogResultResponseBodyGatherLogResultInstanceResultsInstanceResult()
self.instance_result.append(temp_model.from_map(k))
return self
class DescribeGatherLogResultResponseBodyGatherLogResult(TeaModel):
def __init__(self, log_path=None, change=None, instance_results=None):
self.log_path = TeaConverter.to_unicode(log_path) # type: unicode
self.change = change # type: DescribeGatherLogResultResponseBodyGatherLogResultChange
self.instance_results = instance_results # type: DescribeGatherLogResultResponseBodyGatherLogResultInstanceResults
def validate(self):
if self.change:
self.change.validate()
if self.instance_results:
self.instance_results.validate()
def to_map(self):
result = dict()
if self.log_path is not None:
result['LogPath'] = self.log_path
if self.change is not None:
result['Change'] = self.change.to_map()
if self.instance_results is not None:
result['InstanceResults'] = self.instance_results.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('LogPath') is not None:
self.log_path = m.get('LogPath')
if m.get('Change') is not None:
temp_model = DescribeGatherLogResultResponseBodyGatherLogResultChange()
self.change = temp_model.from_map(m['Change'])
if m.get('InstanceResults') is not None:
temp_model = DescribeGatherLogResultResponseBodyGatherLogResultInstanceResults()
self.instance_results = temp_model.from_map(m['InstanceResults'])
return self
class DescribeGatherLogResultResponseBody(TeaModel):
def __init__(self, gather_log_result=None, message=None, request_id=None, code=None):
self.gather_log_result = gather_log_result # type: DescribeGatherLogResultResponseBodyGatherLogResult
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.gather_log_result:
self.gather_log_result.validate()
def to_map(self):
result = dict()
if self.gather_log_result is not None:
result['GatherLogResult'] = self.gather_log_result.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('GatherLogResult') is not None:
temp_model = DescribeGatherLogResultResponseBodyGatherLogResult()
self.gather_log_result = temp_model.from_map(m['GatherLogResult'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 DescribeGatherLogResultResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeGatherLogResultResponseBody
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=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 = DescribeGatherLogResultResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeGatherStatsResultRequest(TeaModel):
def __init__(self, change_id=None, region_id=None):
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeGatherStatsResultResponseBodyGatherStatsResultChange(TeaModel):
def __init__(self, change_paused=None, change_description=None, finish_time=None, update_time=None,
change_timedout=None, create_time=None, change_message=None, action_name=None, change_finished=None,
create_username=None, change_succeeded=None, change_id=None, change_aborted=None, env_id=None, change_name=None):
self.change_paused = change_paused # type: bool
self.change_description = TeaConverter.to_unicode(change_description) # type: unicode
self.finish_time = finish_time # type: long
self.update_time = update_time # type: long
self.change_timedout = change_timedout # type: bool
self.create_time = create_time # type: long
self.change_message = TeaConverter.to_unicode(change_message) # type: unicode
self.action_name = TeaConverter.to_unicode(action_name) # type: unicode
self.change_finished = change_finished # type: bool
self.create_username = TeaConverter.to_unicode(create_username) # type: unicode
self.change_succeeded = change_succeeded # type: bool
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.change_aborted = change_aborted # type: bool
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.change_name = TeaConverter.to_unicode(change_name) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.change_paused is not None:
result['ChangePaused'] = self.change_paused
if self.change_description is not None:
result['ChangeDescription'] = self.change_description
if self.finish_time is not None:
result['FinishTime'] = self.finish_time
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.change_timedout is not None:
result['ChangeTimedout'] = self.change_timedout
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.change_message is not None:
result['ChangeMessage'] = self.change_message
if self.action_name is not None:
result['ActionName'] = self.action_name
if self.change_finished is not None:
result['ChangeFinished'] = self.change_finished
if self.create_username is not None:
result['CreateUsername'] = self.create_username
if self.change_succeeded is not None:
result['ChangeSucceeded'] = self.change_succeeded
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.change_aborted is not None:
result['ChangeAborted'] = self.change_aborted
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.change_name is not None:
result['ChangeName'] = self.change_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ChangePaused') is not None:
self.change_paused = m.get('ChangePaused')
if m.get('ChangeDescription') is not None:
self.change_description = m.get('ChangeDescription')
if m.get('FinishTime') is not None:
self.finish_time = m.get('FinishTime')
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('ChangeTimedout') is not None:
self.change_timedout = m.get('ChangeTimedout')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('ChangeMessage') is not None:
self.change_message = m.get('ChangeMessage')
if m.get('ActionName') is not None:
self.action_name = m.get('ActionName')
if m.get('ChangeFinished') is not None:
self.change_finished = m.get('ChangeFinished')
if m.get('CreateUsername') is not None:
self.create_username = m.get('CreateUsername')
if m.get('ChangeSucceeded') is not None:
self.change_succeeded = m.get('ChangeSucceeded')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('ChangeAborted') is not None:
self.change_aborted = m.get('ChangeAborted')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('ChangeName') is not None:
self.change_name = m.get('ChangeName')
return self
class DescribeGatherStatsResultResponseBodyGatherStatsResultInstanceResultsInstanceResult(TeaModel):
def __init__(self, task_message=None, storage_key=None, instance_id=None, task_succeeded=None):
self.task_message = TeaConverter.to_unicode(task_message) # type: unicode
self.storage_key = TeaConverter.to_unicode(storage_key) # type: unicode
self.instance_id = TeaConverter.to_unicode(instance_id) # type: unicode
self.task_succeeded = task_succeeded # type: bool
def validate(self):
pass
def to_map(self):
result = dict()
if self.task_message is not None:
result['TaskMessage'] = self.task_message
if self.storage_key is not None:
result['StorageKey'] = self.storage_key
if self.instance_id is not None:
result['InstanceId'] = self.instance_id
if self.task_succeeded is not None:
result['TaskSucceeded'] = self.task_succeeded
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TaskMessage') is not None:
self.task_message = m.get('TaskMessage')
if m.get('StorageKey') is not None:
self.storage_key = m.get('StorageKey')
if m.get('InstanceId') is not None:
self.instance_id = m.get('InstanceId')
if m.get('TaskSucceeded') is not None:
self.task_succeeded = m.get('TaskSucceeded')
return self
class DescribeGatherStatsResultResponseBodyGatherStatsResultInstanceResults(TeaModel):
def __init__(self, instance_result=None):
self.instance_result = instance_result # type: list[DescribeGatherStatsResultResponseBodyGatherStatsResultInstanceResultsInstanceResult]
def validate(self):
if self.instance_result:
for k in self.instance_result:
if k:
k.validate()
def to_map(self):
result = dict()
result['InstanceResult'] = []
if self.instance_result is not None:
for k in self.instance_result:
result['InstanceResult'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.instance_result = []
if m.get('InstanceResult') is not None:
for k in m.get('InstanceResult'):
temp_model = DescribeGatherStatsResultResponseBodyGatherStatsResultInstanceResultsInstanceResult()
self.instance_result.append(temp_model.from_map(k))
return self
class DescribeGatherStatsResultResponseBodyGatherStatsResult(TeaModel):
def __init__(self, change=None, instance_results=None):
self.change = change # type: DescribeGatherStatsResultResponseBodyGatherStatsResultChange
self.instance_results = instance_results # type: DescribeGatherStatsResultResponseBodyGatherStatsResultInstanceResults
def validate(self):
if self.change:
self.change.validate()
if self.instance_results:
self.instance_results.validate()
def to_map(self):
result = dict()
if self.change is not None:
result['Change'] = self.change.to_map()
if self.instance_results is not None:
result['InstanceResults'] = self.instance_results.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Change') is not None:
temp_model = DescribeGatherStatsResultResponseBodyGatherStatsResultChange()
self.change = temp_model.from_map(m['Change'])
if m.get('InstanceResults') is not None:
temp_model = DescribeGatherStatsResultResponseBodyGatherStatsResultInstanceResults()
self.instance_results = temp_model.from_map(m['InstanceResults'])
return self
class DescribeGatherStatsResultResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, gather_stats_result=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.gather_stats_result = gather_stats_result # type: DescribeGatherStatsResultResponseBodyGatherStatsResult
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.gather_stats_result:
self.gather_stats_result.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.gather_stats_result is not None:
result['GatherStatsResult'] = self.gather_stats_result.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('GatherStatsResult') is not None:
temp_model = DescribeGatherStatsResultResponseBodyGatherStatsResult()
self.gather_stats_result = temp_model.from_map(m['GatherStatsResult'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DescribeGatherStatsResultResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeGatherStatsResultResponseBody
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=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 = DescribeGatherStatsResultResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeInstanceHealthRequest(TeaModel):
def __init__(self, instance_id=None, region_id=None):
self.instance_id = TeaConverter.to_unicode(instance_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.instance_id is not None:
result['InstanceId'] = self.instance_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('InstanceId') is not None:
self.instance_id = m.get('InstanceId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeInstanceHealthResponseBodyInstanceHealth(TeaModel):
def __init__(self, app_status=None, instance_id=None, disconnected_time=None, agent_status=None):
self.app_status = TeaConverter.to_unicode(app_status) # type: unicode
self.instance_id = TeaConverter.to_unicode(instance_id) # type: unicode
self.disconnected_time = disconnected_time # type: long
self.agent_status = TeaConverter.to_unicode(agent_status) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.app_status is not None:
result['AppStatus'] = self.app_status
if self.instance_id is not None:
result['InstanceId'] = self.instance_id
if self.disconnected_time is not None:
result['DisconnectedTime'] = self.disconnected_time
if self.agent_status is not None:
result['AgentStatus'] = self.agent_status
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppStatus') is not None:
self.app_status = m.get('AppStatus')
if m.get('InstanceId') is not None:
self.instance_id = m.get('InstanceId')
if m.get('DisconnectedTime') is not None:
self.disconnected_time = m.get('DisconnectedTime')
if m.get('AgentStatus') is not None:
self.agent_status = m.get('AgentStatus')
return self
class DescribeInstanceHealthResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, instance_health=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.instance_health = instance_health # type: DescribeInstanceHealthResponseBodyInstanceHealth
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.instance_health:
self.instance_health.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.instance_health is not None:
result['InstanceHealth'] = self.instance_health.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('InstanceHealth') is not None:
temp_model = DescribeInstanceHealthResponseBodyInstanceHealth()
self.instance_health = temp_model.from_map(m['InstanceHealth'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DescribeInstanceHealthResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeInstanceHealthResponseBody
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=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 = DescribeInstanceHealthResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribePkgVersionsRequest(TeaModel):
def __init__(self, app_id=None, page_size=None, page_number=None, pkg_version_label=None,
pkg_version_search=None, region_id=None):
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.pkg_version_label = TeaConverter.to_unicode(pkg_version_label) # type: unicode
self.pkg_version_search = TeaConverter.to_unicode(pkg_version_search) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.app_id is not None:
result['AppId'] = self.app_id
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.pkg_version_label is not None:
result['PkgVersionLabel'] = self.pkg_version_label
if self.pkg_version_search is not None:
result['PkgVersionSearch'] = self.pkg_version_search
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PkgVersionLabel') is not None:
self.pkg_version_label = m.get('PkgVersionLabel')
if m.get('PkgVersionSearch') is not None:
self.pkg_version_search = m.get('PkgVersionSearch')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribePkgVersionsResponseBodyPkgVersionsPkgVersion(TeaModel):
def __init__(self, create_username=None, app_name=None, update_time=None, pkg_version_label=None,
create_time=None, package_source=None, app_id=None, package_etag=None, pkg_version_id=None,
pkg_version_description=None):
self.create_username = TeaConverter.to_unicode(create_username) # type: unicode
self.app_name = TeaConverter.to_unicode(app_name) # type: unicode
self.update_time = update_time # type: long
self.pkg_version_label = TeaConverter.to_unicode(pkg_version_label) # type: unicode
self.create_time = create_time # type: long
self.package_source = TeaConverter.to_unicode(package_source) # type: unicode
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.package_etag = TeaConverter.to_unicode(package_etag) # type: unicode
self.pkg_version_id = TeaConverter.to_unicode(pkg_version_id) # type: unicode
self.pkg_version_description = TeaConverter.to_unicode(pkg_version_description) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.create_username is not None:
result['CreateUsername'] = self.create_username
if self.app_name is not None:
result['AppName'] = self.app_name
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.pkg_version_label is not None:
result['PkgVersionLabel'] = self.pkg_version_label
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.package_source is not None:
result['PackageSource'] = self.package_source
if self.app_id is not None:
result['AppId'] = self.app_id
if self.package_etag is not None:
result['PackageETag'] = self.package_etag
if self.pkg_version_id is not None:
result['PkgVersionId'] = self.pkg_version_id
if self.pkg_version_description is not None:
result['PkgVersionDescription'] = self.pkg_version_description
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateUsername') is not None:
self.create_username = m.get('CreateUsername')
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('PkgVersionLabel') is not None:
self.pkg_version_label = m.get('PkgVersionLabel')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('PackageSource') is not None:
self.package_source = m.get('PackageSource')
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('PackageETag') is not None:
self.package_etag = m.get('PackageETag')
if m.get('PkgVersionId') is not None:
self.pkg_version_id = m.get('PkgVersionId')
if m.get('PkgVersionDescription') is not None:
self.pkg_version_description = m.get('PkgVersionDescription')
return self
class DescribePkgVersionsResponseBodyPkgVersions(TeaModel):
def __init__(self, pkg_version=None):
self.pkg_version = pkg_version # type: list[DescribePkgVersionsResponseBodyPkgVersionsPkgVersion]
def validate(self):
if self.pkg_version:
for k in self.pkg_version:
if k:
k.validate()
def to_map(self):
result = dict()
result['PkgVersion'] = []
if self.pkg_version is not None:
for k in self.pkg_version:
result['PkgVersion'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.pkg_version = []
if m.get('PkgVersion') is not None:
for k in m.get('PkgVersion'):
temp_model = DescribePkgVersionsResponseBodyPkgVersionsPkgVersion()
self.pkg_version.append(temp_model.from_map(k))
return self
class DescribePkgVersionsResponseBody(TeaModel):
def __init__(self, total_count=None, request_id=None, message=None, page_size=None, page_number=None,
pkg_versions=None, code=None):
self.total_count = total_count # type: int
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.message = TeaConverter.to_unicode(message) # type: unicode
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.pkg_versions = pkg_versions # type: DescribePkgVersionsResponseBodyPkgVersions
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.pkg_versions:
self.pkg_versions.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.message is not None:
result['Message'] = self.message
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.pkg_versions is not None:
result['PkgVersions'] = self.pkg_versions.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PkgVersions') is not None:
temp_model = DescribePkgVersionsResponseBodyPkgVersions()
self.pkg_versions = temp_model.from_map(m['PkgVersions'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DescribePkgVersionsResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribePkgVersionsResponseBody
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=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 = DescribePkgVersionsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribePublicConfigTemplatesRequest(TeaModel):
def __init__(self, category_name=None, page_size=None, page_number=None, region_id=None):
self.category_name = TeaConverter.to_unicode(category_name) # type: unicode
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.category_name is not None:
result['CategoryName'] = self.category_name
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CategoryName') is not None:
self.category_name = m.get('CategoryName')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribePublicConfigTemplatesResponseBodyPublicConfigTemplatesPublicConfigTemplate(TeaModel):
def __init__(self, template_description=None, update_time=None, stack_id=None, template_logo=None,
create_time=None, package_source=None, stack_name=None, template_name=None, category_name=None,
template_id=None):
self.template_description = TeaConverter.to_unicode(template_description) # type: unicode
self.update_time = update_time # type: long
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
self.template_logo = TeaConverter.to_unicode(template_logo) # type: unicode
self.create_time = create_time # type: long
self.package_source = TeaConverter.to_unicode(package_source) # type: unicode
self.stack_name = TeaConverter.to_unicode(stack_name) # type: unicode
self.template_name = TeaConverter.to_unicode(template_name) # type: unicode
self.category_name = TeaConverter.to_unicode(category_name) # type: unicode
self.template_id = TeaConverter.to_unicode(template_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.template_description is not None:
result['TemplateDescription'] = self.template_description
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.stack_id is not None:
result['StackId'] = self.stack_id
if self.template_logo is not None:
result['TemplateLogo'] = self.template_logo
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.package_source is not None:
result['PackageSource'] = self.package_source
if self.stack_name is not None:
result['StackName'] = self.stack_name
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.category_name is not None:
result['CategoryName'] = self.category_name
if self.template_id is not None:
result['TemplateId'] = self.template_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TemplateDescription') is not None:
self.template_description = m.get('TemplateDescription')
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
if m.get('TemplateLogo') is not None:
self.template_logo = m.get('TemplateLogo')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('PackageSource') is not None:
self.package_source = m.get('PackageSource')
if m.get('StackName') is not None:
self.stack_name = m.get('StackName')
if m.get('TemplateName') is not None:
self.template_name = m.get('TemplateName')
if m.get('CategoryName') is not None:
self.category_name = m.get('CategoryName')
if m.get('TemplateId') is not None:
self.template_id = m.get('TemplateId')
return self
class DescribePublicConfigTemplatesResponseBodyPublicConfigTemplates(TeaModel):
def __init__(self, public_config_template=None):
self.public_config_template = public_config_template # type: list[DescribePublicConfigTemplatesResponseBodyPublicConfigTemplatesPublicConfigTemplate]
def validate(self):
if self.public_config_template:
for k in self.public_config_template:
if k:
k.validate()
def to_map(self):
result = dict()
result['PublicConfigTemplate'] = []
if self.public_config_template is not None:
for k in self.public_config_template:
result['PublicConfigTemplate'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.public_config_template = []
if m.get('PublicConfigTemplate') is not None:
for k in m.get('PublicConfigTemplate'):
temp_model = DescribePublicConfigTemplatesResponseBodyPublicConfigTemplatesPublicConfigTemplate()
self.public_config_template.append(temp_model.from_map(k))
return self
class DescribePublicConfigTemplatesResponseBody(TeaModel):
def __init__(self, total_count=None, request_id=None, message=None, page_size=None, page_number=None,
public_config_templates=None, code=None):
self.total_count = total_count # type: int
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.message = TeaConverter.to_unicode(message) # type: unicode
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.public_config_templates = public_config_templates # type: DescribePublicConfigTemplatesResponseBodyPublicConfigTemplates
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.public_config_templates:
self.public_config_templates.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.message is not None:
result['Message'] = self.message
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.public_config_templates is not None:
result['PublicConfigTemplates'] = self.public_config_templates.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PublicConfigTemplates') is not None:
temp_model = DescribePublicConfigTemplatesResponseBodyPublicConfigTemplates()
self.public_config_templates = temp_model.from_map(m['PublicConfigTemplates'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DescribePublicConfigTemplatesResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribePublicConfigTemplatesResponseBody
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=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 = DescribePublicConfigTemplatesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeStacksRequest(TeaModel):
def __init__(self, recommended_only=None, category_name=None, page_size=None, page_number=None, region_id=None):
self.recommended_only = recommended_only # type: bool
self.category_name = TeaConverter.to_unicode(category_name) # type: unicode
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.recommended_only is not None:
result['RecommendedOnly'] = self.recommended_only
if self.category_name is not None:
result['CategoryName'] = self.category_name
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RecommendedOnly') is not None:
self.recommended_only = m.get('RecommendedOnly')
if m.get('CategoryName') is not None:
self.category_name = m.get('CategoryName')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeStacksResponseBodyStacksStack(TeaModel):
def __init__(self, update_time=None, stack_id=None, create_time=None, recommended_stack=None, stack_name=None,
category_name=None, version_code=None, latest_stack=None):
self.update_time = update_time # type: long
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
self.create_time = create_time # type: long
self.recommended_stack = recommended_stack # type: bool
self.stack_name = TeaConverter.to_unicode(stack_name) # type: unicode
self.category_name = TeaConverter.to_unicode(category_name) # type: unicode
self.version_code = version_code # type: int
self.latest_stack = latest_stack # type: bool
def validate(self):
pass
def to_map(self):
result = dict()
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.stack_id is not None:
result['StackId'] = self.stack_id
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.recommended_stack is not None:
result['RecommendedStack'] = self.recommended_stack
if self.stack_name is not None:
result['StackName'] = self.stack_name
if self.category_name is not None:
result['CategoryName'] = self.category_name
if self.version_code is not None:
result['VersionCode'] = self.version_code
if self.latest_stack is not None:
result['LatestStack'] = self.latest_stack
return result
def from_map(self, m=None):
m = m or dict()
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('RecommendedStack') is not None:
self.recommended_stack = m.get('RecommendedStack')
if m.get('StackName') is not None:
self.stack_name = m.get('StackName')
if m.get('CategoryName') is not None:
self.category_name = m.get('CategoryName')
if m.get('VersionCode') is not None:
self.version_code = m.get('VersionCode')
if m.get('LatestStack') is not None:
self.latest_stack = m.get('LatestStack')
return self
class DescribeStacksResponseBodyStacks(TeaModel):
def __init__(self, stack=None):
self.stack = stack # type: list[DescribeStacksResponseBodyStacksStack]
def validate(self):
if self.stack:
for k in self.stack:
if k:
k.validate()
def to_map(self):
result = dict()
result['Stack'] = []
if self.stack is not None:
for k in self.stack:
result['Stack'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.stack = []
if m.get('Stack') is not None:
for k in m.get('Stack'):
temp_model = DescribeStacksResponseBodyStacksStack()
self.stack.append(temp_model.from_map(k))
return self
class DescribeStacksResponseBody(TeaModel):
def __init__(self, total_count=None, request_id=None, message=None, page_size=None, page_number=None,
stacks=None, code=None):
self.total_count = total_count # type: int
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.message = TeaConverter.to_unicode(message) # type: unicode
self.page_size = page_size # type: int
self.page_number = page_number # type: int
self.stacks = stacks # type: DescribeStacksResponseBodyStacks
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.stacks:
self.stacks.validate()
def to_map(self):
result = dict()
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.message is not None:
result['Message'] = self.message
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.stacks is not None:
result['Stacks'] = self.stacks.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('Stacks') is not None:
temp_model = DescribeStacksResponseBodyStacks()
self.stacks = temp_model.from_map(m['Stacks'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class DescribeStacksResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeStacksResponseBody
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=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 = DescribeStacksResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeStorageRequest(TeaModel):
def __init__(self, using_shared_storage=None, region_id=None):
self.using_shared_storage = using_shared_storage # type: bool
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.using_shared_storage is not None:
result['UsingSharedStorage'] = self.using_shared_storage
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('UsingSharedStorage') is not None:
self.using_shared_storage = m.get('UsingSharedStorage')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DescribeStorageResponseBodyStorage(TeaModel):
def __init__(self, update_time=None, key_prefix=None, pkg_key_prefix=None, create_time=None, bucket_name=None):
self.update_time = update_time # type: long
self.key_prefix = TeaConverter.to_unicode(key_prefix) # type: unicode
self.pkg_key_prefix = TeaConverter.to_unicode(pkg_key_prefix) # type: unicode
self.create_time = create_time # type: long
self.bucket_name = TeaConverter.to_unicode(bucket_name) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.key_prefix is not None:
result['KeyPrefix'] = self.key_prefix
if self.pkg_key_prefix is not None:
result['PkgKeyPrefix'] = self.pkg_key_prefix
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.bucket_name is not None:
result['BucketName'] = self.bucket_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('KeyPrefix') is not None:
self.key_prefix = m.get('KeyPrefix')
if m.get('PkgKeyPrefix') is not None:
self.pkg_key_prefix = m.get('PkgKeyPrefix')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('BucketName') is not None:
self.bucket_name = m.get('BucketName')
return self
class DescribeStorageResponseBody(TeaModel):
def __init__(self, storage=None, message=None, request_id=None, code=None):
self.storage = storage # type: DescribeStorageResponseBodyStorage
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.storage:
self.storage.validate()
def to_map(self):
result = dict()
if self.storage is not None:
result['Storage'] = self.storage.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('Storage') is not None:
temp_model = DescribeStorageResponseBodyStorage()
self.storage = temp_model.from_map(m['Storage'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 DescribeStorageResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: DescribeStorageResponseBody
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=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 = DescribeStorageResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GatherAppEnvLogRequest(TeaModel):
def __init__(self, env_id=None, target_instances=None, log_path=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.target_instances = TeaConverter.to_unicode(target_instances) # type: unicode
self.log_path = TeaConverter.to_unicode(log_path) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.target_instances is not None:
result['TargetInstances'] = self.target_instances
if self.log_path is not None:
result['LogPath'] = self.log_path
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('TargetInstances') is not None:
self.target_instances = m.get('TargetInstances')
if m.get('LogPath') is not None:
self.log_path = m.get('LogPath')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class GatherAppEnvLogResponseBodyEnvChange(TeaModel):
def __init__(self, start_time=None, change_id=None, env_id=None):
self.start_time = TeaConverter.to_unicode(start_time) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.env_id is not None:
result['EnvId'] = self.env_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
return self
class GatherAppEnvLogResponseBody(TeaModel):
def __init__(self, env_change=None, message=None, request_id=None, code=None):
self.env_change = env_change # type: GatherAppEnvLogResponseBodyEnvChange
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_change:
self.env_change.validate()
def to_map(self):
result = dict()
if self.env_change is not None:
result['EnvChange'] = self.env_change.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('EnvChange') is not None:
temp_model = GatherAppEnvLogResponseBodyEnvChange()
self.env_change = temp_model.from_map(m['EnvChange'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 GatherAppEnvLogResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: GatherAppEnvLogResponseBody
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=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 = GatherAppEnvLogResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GatherAppEnvStatsRequest(TeaModel):
def __init__(self, env_id=None, target_instances=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.target_instances = TeaConverter.to_unicode(target_instances) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.target_instances is not None:
result['TargetInstances'] = self.target_instances
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('TargetInstances') is not None:
self.target_instances = m.get('TargetInstances')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class GatherAppEnvStatsResponseBodyEnvChange(TeaModel):
def __init__(self, start_time=None, change_id=None, env_id=None):
self.start_time = TeaConverter.to_unicode(start_time) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.env_id is not None:
result['EnvId'] = self.env_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
return self
class GatherAppEnvStatsResponseBody(TeaModel):
def __init__(self, env_change=None, message=None, request_id=None, code=None):
self.env_change = env_change # type: GatherAppEnvStatsResponseBodyEnvChange
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_change:
self.env_change.validate()
def to_map(self):
result = dict()
if self.env_change is not None:
result['EnvChange'] = self.env_change.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('EnvChange') is not None:
temp_model = GatherAppEnvStatsResponseBodyEnvChange()
self.env_change = temp_model.from_map(m['EnvChange'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 GatherAppEnvStatsResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: GatherAppEnvStatsResponseBody
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=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 = GatherAppEnvStatsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class PauseChangeRequest(TeaModel):
def __init__(self, change_id=None, region_id=None):
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class PauseChangeResponseBodyEnvChange(TeaModel):
def __init__(self, start_time=None, change_id=None, env_id=None):
self.start_time = TeaConverter.to_unicode(start_time) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.env_id is not None:
result['EnvId'] = self.env_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
return self
class PauseChangeResponseBody(TeaModel):
def __init__(self, env_change=None, message=None, request_id=None, code=None):
self.env_change = env_change # type: PauseChangeResponseBodyEnvChange
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_change:
self.env_change.validate()
def to_map(self):
result = dict()
if self.env_change is not None:
result['EnvChange'] = self.env_change.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('EnvChange') is not None:
temp_model = PauseChangeResponseBodyEnvChange()
self.env_change = temp_model.from_map(m['EnvChange'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 PauseChangeResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: PauseChangeResponseBody
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=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 = PauseChangeResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RebuildAppEnvRequest(TeaModel):
def __init__(self, env_id=None, dry_run=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.dry_run = dry_run # type: bool
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.dry_run is not None:
result['DryRun'] = self.dry_run
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('DryRun') is not None:
self.dry_run = m.get('DryRun')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class RebuildAppEnvResponseBodyEnvChangeDetailOperationsOperation(TeaModel):
def __init__(self, operation_description=None, operation_type=None):
self.operation_description = TeaConverter.to_unicode(operation_description) # type: unicode
self.operation_type = TeaConverter.to_unicode(operation_type) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.operation_description is not None:
result['OperationDescription'] = self.operation_description
if self.operation_type is not None:
result['OperationType'] = self.operation_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('OperationDescription') is not None:
self.operation_description = m.get('OperationDescription')
if m.get('OperationType') is not None:
self.operation_type = m.get('OperationType')
return self
class RebuildAppEnvResponseBodyEnvChangeDetailOperations(TeaModel):
def __init__(self, operation=None):
self.operation = operation # type: list[RebuildAppEnvResponseBodyEnvChangeDetailOperationsOperation]
def validate(self):
if self.operation:
for k in self.operation:
if k:
k.validate()
def to_map(self):
result = dict()
result['Operation'] = []
if self.operation is not None:
for k in self.operation:
result['Operation'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.operation = []
if m.get('Operation') is not None:
for k in m.get('Operation'):
temp_model = RebuildAppEnvResponseBodyEnvChangeDetailOperationsOperation()
self.operation.append(temp_model.from_map(k))
return self
class RebuildAppEnvResponseBodyEnvChangeDetail(TeaModel):
def __init__(self, start_time=None, change_id=None, env_id=None, operations=None):
self.start_time = TeaConverter.to_unicode(start_time) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.operations = operations # type: RebuildAppEnvResponseBodyEnvChangeDetailOperations
def validate(self):
if self.operations:
self.operations.validate()
def to_map(self):
result = dict()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.operations is not None:
result['Operations'] = self.operations.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('Operations') is not None:
temp_model = RebuildAppEnvResponseBodyEnvChangeDetailOperations()
self.operations = temp_model.from_map(m['Operations'])
return self
class RebuildAppEnvResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, env_change_detail=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.env_change_detail = env_change_detail # type: RebuildAppEnvResponseBodyEnvChangeDetail
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_change_detail:
self.env_change_detail.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.env_change_detail is not None:
result['EnvChangeDetail'] = self.env_change_detail.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('EnvChangeDetail') is not None:
temp_model = RebuildAppEnvResponseBodyEnvChangeDetail()
self.env_change_detail = temp_model.from_map(m['EnvChangeDetail'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class RebuildAppEnvResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: RebuildAppEnvResponseBody
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=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 = RebuildAppEnvResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RestartAppEnvRequest(TeaModel):
def __init__(self, env_id=None, batch_size=None, batch_percent=None, batch_interval=None,
pause_between_batches=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.batch_size = batch_size # type: int
self.batch_percent = batch_percent # type: int
self.batch_interval = batch_interval # type: int
self.pause_between_batches = pause_between_batches # type: bool
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.batch_size is not None:
result['BatchSize'] = self.batch_size
if self.batch_percent is not None:
result['BatchPercent'] = self.batch_percent
if self.batch_interval is not None:
result['BatchInterval'] = self.batch_interval
if self.pause_between_batches is not None:
result['PauseBetweenBatches'] = self.pause_between_batches
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('BatchSize') is not None:
self.batch_size = m.get('BatchSize')
if m.get('BatchPercent') is not None:
self.batch_percent = m.get('BatchPercent')
if m.get('BatchInterval') is not None:
self.batch_interval = m.get('BatchInterval')
if m.get('PauseBetweenBatches') is not None:
self.pause_between_batches = m.get('PauseBetweenBatches')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class RestartAppEnvResponseBodyEnvChange(TeaModel):
def __init__(self, start_time=None, change_id=None, env_id=None):
self.start_time = TeaConverter.to_unicode(start_time) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.env_id is not None:
result['EnvId'] = self.env_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
return self
class RestartAppEnvResponseBody(TeaModel):
def __init__(self, env_change=None, message=None, request_id=None, code=None):
self.env_change = env_change # type: RestartAppEnvResponseBodyEnvChange
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_change:
self.env_change.validate()
def to_map(self):
result = dict()
if self.env_change is not None:
result['EnvChange'] = self.env_change.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('EnvChange') is not None:
temp_model = RestartAppEnvResponseBodyEnvChange()
self.env_change = temp_model.from_map(m['EnvChange'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 RestartAppEnvResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: RestartAppEnvResponseBody
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=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 = RestartAppEnvResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ResumeChangeRequest(TeaModel):
def __init__(self, change_id=None, region_id=None):
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class ResumeChangeResponseBodyEnvChange(TeaModel):
def __init__(self, start_time=None, change_id=None, env_id=None):
self.start_time = TeaConverter.to_unicode(start_time) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.env_id is not None:
result['EnvId'] = self.env_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
return self
class ResumeChangeResponseBody(TeaModel):
def __init__(self, env_change=None, message=None, request_id=None, code=None):
self.env_change = env_change # type: ResumeChangeResponseBodyEnvChange
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_change:
self.env_change.validate()
def to_map(self):
result = dict()
if self.env_change is not None:
result['EnvChange'] = self.env_change.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('EnvChange') is not None:
temp_model = ResumeChangeResponseBodyEnvChange()
self.env_change = temp_model.from_map(m['EnvChange'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 ResumeChangeResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: ResumeChangeResponseBody
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=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 = ResumeChangeResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class StartAppEnvRequest(TeaModel):
def __init__(self, env_id=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class StartAppEnvResponseBodyEnvChange(TeaModel):
def __init__(self, start_time=None, change_id=None, env_id=None):
self.start_time = TeaConverter.to_unicode(start_time) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.env_id is not None:
result['EnvId'] = self.env_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
return self
class StartAppEnvResponseBody(TeaModel):
def __init__(self, env_change=None, message=None, request_id=None, code=None):
self.env_change = env_change # type: StartAppEnvResponseBodyEnvChange
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_change:
self.env_change.validate()
def to_map(self):
result = dict()
if self.env_change is not None:
result['EnvChange'] = self.env_change.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('EnvChange') is not None:
temp_model = StartAppEnvResponseBodyEnvChange()
self.env_change = temp_model.from_map(m['EnvChange'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 StartAppEnvResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: StartAppEnvResponseBody
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=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 = StartAppEnvResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class StopAppEnvRequest(TeaModel):
def __init__(self, env_id=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class StopAppEnvResponseBodyEnvChange(TeaModel):
def __init__(self, start_time=None, change_id=None, env_id=None):
self.start_time = TeaConverter.to_unicode(start_time) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.env_id is not None:
result['EnvId'] = self.env_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
return self
class StopAppEnvResponseBody(TeaModel):
def __init__(self, env_change=None, message=None, request_id=None, code=None):
self.env_change = env_change # type: StopAppEnvResponseBodyEnvChange
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_change:
self.env_change.validate()
def to_map(self):
result = dict()
if self.env_change is not None:
result['EnvChange'] = self.env_change.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('EnvChange') is not None:
temp_model = StopAppEnvResponseBodyEnvChange()
self.env_change = temp_model.from_map(m['EnvChange'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 StopAppEnvResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: StopAppEnvResponseBody
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=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 = StopAppEnvResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class TerminateAppEnvRequest(TeaModel):
def __init__(self, env_id=None, dry_run=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.dry_run = TeaConverter.to_unicode(dry_run) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.dry_run is not None:
result['DryRun'] = self.dry_run
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('DryRun') is not None:
self.dry_run = m.get('DryRun')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class TerminateAppEnvResponseBodyEnvChangeDetailOperationsOperation(TeaModel):
def __init__(self, operation_description=None, operation_type=None):
self.operation_description = TeaConverter.to_unicode(operation_description) # type: unicode
self.operation_type = TeaConverter.to_unicode(operation_type) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.operation_description is not None:
result['OperationDescription'] = self.operation_description
if self.operation_type is not None:
result['OperationType'] = self.operation_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('OperationDescription') is not None:
self.operation_description = m.get('OperationDescription')
if m.get('OperationType') is not None:
self.operation_type = m.get('OperationType')
return self
class TerminateAppEnvResponseBodyEnvChangeDetailOperations(TeaModel):
def __init__(self, operation=None):
self.operation = operation # type: list[TerminateAppEnvResponseBodyEnvChangeDetailOperationsOperation]
def validate(self):
if self.operation:
for k in self.operation:
if k:
k.validate()
def to_map(self):
result = dict()
result['Operation'] = []
if self.operation is not None:
for k in self.operation:
result['Operation'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.operation = []
if m.get('Operation') is not None:
for k in m.get('Operation'):
temp_model = TerminateAppEnvResponseBodyEnvChangeDetailOperationsOperation()
self.operation.append(temp_model.from_map(k))
return self
class TerminateAppEnvResponseBodyEnvChangeDetail(TeaModel):
def __init__(self, start_time=None, change_id=None, env_id=None, operations=None):
self.start_time = TeaConverter.to_unicode(start_time) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.operations = operations # type: TerminateAppEnvResponseBodyEnvChangeDetailOperations
def validate(self):
if self.operations:
self.operations.validate()
def to_map(self):
result = dict()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.operations is not None:
result['Operations'] = self.operations.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('Operations') is not None:
temp_model = TerminateAppEnvResponseBodyEnvChangeDetailOperations()
self.operations = temp_model.from_map(m['Operations'])
return self
class TerminateAppEnvResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, env_change_detail=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.env_change_detail = env_change_detail # type: TerminateAppEnvResponseBodyEnvChangeDetail
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_change_detail:
self.env_change_detail.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.env_change_detail is not None:
result['EnvChangeDetail'] = self.env_change_detail.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('EnvChangeDetail') is not None:
temp_model = TerminateAppEnvResponseBodyEnvChangeDetail()
self.env_change_detail = temp_model.from_map(m['EnvChangeDetail'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class TerminateAppEnvResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: TerminateAppEnvResponseBody
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=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 = TerminateAppEnvResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateAppEnvRequest(TeaModel):
def __init__(self, env_description=None, env_id=None, pkg_version_id=None, option_settings=None, stack_id=None,
dry_run=None, extra_properties=None, batch_size=None, batch_percent=None, batch_interval=None,
pause_between_batches=None, region_id=None):
self.env_description = TeaConverter.to_unicode(env_description) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.pkg_version_id = TeaConverter.to_unicode(pkg_version_id) # type: unicode
self.option_settings = TeaConverter.to_unicode(option_settings) # type: unicode
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
self.dry_run = dry_run # type: bool
self.extra_properties = TeaConverter.to_unicode(extra_properties) # type: unicode
self.batch_size = TeaConverter.to_unicode(batch_size) # type: unicode
self.batch_percent = TeaConverter.to_unicode(batch_percent) # type: unicode
self.batch_interval = TeaConverter.to_unicode(batch_interval) # type: unicode
self.pause_between_batches = pause_between_batches # type: bool
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_description is not None:
result['EnvDescription'] = self.env_description
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.pkg_version_id is not None:
result['PkgVersionId'] = self.pkg_version_id
if self.option_settings is not None:
result['OptionSettings'] = self.option_settings
if self.stack_id is not None:
result['StackId'] = self.stack_id
if self.dry_run is not None:
result['DryRun'] = self.dry_run
if self.extra_properties is not None:
result['ExtraProperties'] = self.extra_properties
if self.batch_size is not None:
result['BatchSize'] = self.batch_size
if self.batch_percent is not None:
result['BatchPercent'] = self.batch_percent
if self.batch_interval is not None:
result['BatchInterval'] = self.batch_interval
if self.pause_between_batches is not None:
result['PauseBetweenBatches'] = self.pause_between_batches
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvDescription') is not None:
self.env_description = m.get('EnvDescription')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('PkgVersionId') is not None:
self.pkg_version_id = m.get('PkgVersionId')
if m.get('OptionSettings') is not None:
self.option_settings = m.get('OptionSettings')
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
if m.get('DryRun') is not None:
self.dry_run = m.get('DryRun')
if m.get('ExtraProperties') is not None:
self.extra_properties = m.get('ExtraProperties')
if m.get('BatchSize') is not None:
self.batch_size = m.get('BatchSize')
if m.get('BatchPercent') is not None:
self.batch_percent = m.get('BatchPercent')
if m.get('BatchInterval') is not None:
self.batch_interval = m.get('BatchInterval')
if m.get('PauseBetweenBatches') is not None:
self.pause_between_batches = m.get('PauseBetweenBatches')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class UpdateAppEnvResponseBodyEnvChangeDetailOperationsOperation(TeaModel):
def __init__(self, operation_description=None, operation_type=None):
self.operation_description = TeaConverter.to_unicode(operation_description) # type: unicode
self.operation_type = TeaConverter.to_unicode(operation_type) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.operation_description is not None:
result['OperationDescription'] = self.operation_description
if self.operation_type is not None:
result['OperationType'] = self.operation_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('OperationDescription') is not None:
self.operation_description = m.get('OperationDescription')
if m.get('OperationType') is not None:
self.operation_type = m.get('OperationType')
return self
class UpdateAppEnvResponseBodyEnvChangeDetailOperations(TeaModel):
def __init__(self, operation=None):
self.operation = operation # type: list[UpdateAppEnvResponseBodyEnvChangeDetailOperationsOperation]
def validate(self):
if self.operation:
for k in self.operation:
if k:
k.validate()
def to_map(self):
result = dict()
result['Operation'] = []
if self.operation is not None:
for k in self.operation:
result['Operation'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.operation = []
if m.get('Operation') is not None:
for k in m.get('Operation'):
temp_model = UpdateAppEnvResponseBodyEnvChangeDetailOperationsOperation()
self.operation.append(temp_model.from_map(k))
return self
class UpdateAppEnvResponseBodyEnvChangeDetail(TeaModel):
def __init__(self, start_time=None, change_id=None, env_id=None, operations=None):
self.start_time = TeaConverter.to_unicode(start_time) # type: unicode
self.change_id = TeaConverter.to_unicode(change_id) # type: unicode
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.operations = operations # type: UpdateAppEnvResponseBodyEnvChangeDetailOperations
def validate(self):
if self.operations:
self.operations.validate()
def to_map(self):
result = dict()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.change_id is not None:
result['ChangeId'] = self.change_id
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.operations is not None:
result['Operations'] = self.operations.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('ChangeId') is not None:
self.change_id = m.get('ChangeId')
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('Operations') is not None:
temp_model = UpdateAppEnvResponseBodyEnvChangeDetailOperations()
self.operations = temp_model.from_map(m['Operations'])
return self
class UpdateAppEnvResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, env_change_detail=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.env_change_detail = env_change_detail # type: UpdateAppEnvResponseBodyEnvChangeDetail
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.env_change_detail:
self.env_change_detail.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.env_change_detail is not None:
result['EnvChangeDetail'] = self.env_change_detail.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('EnvChangeDetail') is not None:
temp_model = UpdateAppEnvResponseBodyEnvChangeDetail()
self.env_change_detail = temp_model.from_map(m['EnvChangeDetail'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class UpdateAppEnvResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: UpdateAppEnvResponseBody
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=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 = UpdateAppEnvResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateApplicationRequest(TeaModel):
def __init__(self, app_id=None, app_description=None, region_id=None):
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.app_description = TeaConverter.to_unicode(app_description) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.app_id is not None:
result['AppId'] = self.app_id
if self.app_description is not None:
result['AppDescription'] = self.app_description
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('AppDescription') is not None:
self.app_description = m.get('AppDescription')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class UpdateApplicationResponseBodyApplication(TeaModel):
def __init__(self, app_name=None, create_username=None, update_time=None, update_username=None,
create_time=None, app_id=None, category_name=None, app_description=None):
self.app_name = TeaConverter.to_unicode(app_name) # type: unicode
self.create_username = TeaConverter.to_unicode(create_username) # type: unicode
self.update_time = update_time # type: long
self.update_username = TeaConverter.to_unicode(update_username) # type: unicode
self.create_time = create_time # type: long
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.category_name = TeaConverter.to_unicode(category_name) # type: unicode
self.app_description = TeaConverter.to_unicode(app_description) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.create_username is not None:
result['CreateUsername'] = self.create_username
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.update_username is not None:
result['UpdateUsername'] = self.update_username
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.app_id is not None:
result['AppId'] = self.app_id
if self.category_name is not None:
result['CategoryName'] = self.category_name
if self.app_description is not None:
result['AppDescription'] = self.app_description
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('CreateUsername') is not None:
self.create_username = m.get('CreateUsername')
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('UpdateUsername') is not None:
self.update_username = m.get('UpdateUsername')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('CategoryName') is not None:
self.category_name = m.get('CategoryName')
if m.get('AppDescription') is not None:
self.app_description = m.get('AppDescription')
return self
class UpdateApplicationResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, code=None, application=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
self.application = application # type: UpdateApplicationResponseBodyApplication
def validate(self):
if self.application:
self.application.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.code is not None:
result['Code'] = self.code
if self.application is not None:
result['Application'] = self.application.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
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')
if m.get('Application') is not None:
temp_model = UpdateApplicationResponseBodyApplication()
self.application = temp_model.from_map(m['Application'])
return self
class UpdateApplicationResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: UpdateApplicationResponseBody
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=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 = UpdateApplicationResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateConfigTemplateRequest(TeaModel):
def __init__(self, template_description=None, template_id=None, option_settings=None, region_id=None):
self.template_description = TeaConverter.to_unicode(template_description) # type: unicode
self.template_id = TeaConverter.to_unicode(template_id) # type: unicode
self.option_settings = TeaConverter.to_unicode(option_settings) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.template_description is not None:
result['TemplateDescription'] = self.template_description
if self.template_id is not None:
result['TemplateId'] = self.template_id
if self.option_settings is not None:
result['OptionSettings'] = self.option_settings
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('TemplateDescription') is not None:
self.template_description = m.get('TemplateDescription')
if m.get('TemplateId') is not None:
self.template_id = m.get('TemplateId')
if m.get('OptionSettings') is not None:
self.option_settings = m.get('OptionSettings')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class UpdateConfigTemplateResponseBodyConfigTemplate(TeaModel):
def __init__(self, app_name=None, update_time=None, stack_id=None, create_time=None, app_id=None,
stack_name=None, template_name=None, template_id=None):
self.app_name = TeaConverter.to_unicode(app_name) # type: unicode
self.update_time = update_time # type: long
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
self.create_time = create_time # type: long
self.app_id = TeaConverter.to_unicode(app_id) # type: unicode
self.stack_name = TeaConverter.to_unicode(stack_name) # type: unicode
self.template_name = TeaConverter.to_unicode(template_name) # type: unicode
self.template_id = TeaConverter.to_unicode(template_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.update_time is not None:
result['UpdateTime'] = self.update_time
if self.stack_id is not None:
result['StackId'] = self.stack_id
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.app_id is not None:
result['AppId'] = self.app_id
if self.stack_name is not None:
result['StackName'] = self.stack_name
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.template_id is not None:
result['TemplateId'] = self.template_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('UpdateTime') is not None:
self.update_time = m.get('UpdateTime')
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('AppId') is not None:
self.app_id = m.get('AppId')
if m.get('StackName') is not None:
self.stack_name = m.get('StackName')
if m.get('TemplateName') is not None:
self.template_name = m.get('TemplateName')
if m.get('TemplateId') is not None:
self.template_id = m.get('TemplateId')
return self
class UpdateConfigTemplateResponseBody(TeaModel):
def __init__(self, config_template=None, message=None, request_id=None, code=None):
self.config_template = config_template # type: UpdateConfigTemplateResponseBodyConfigTemplate
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.config_template:
self.config_template.validate()
def to_map(self):
result = dict()
if self.config_template is not None:
result['ConfigTemplate'] = self.config_template.to_map()
if self.message is not None:
result['Message'] = self.message
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=None):
m = m or dict()
if m.get('ConfigTemplate') is not None:
temp_model = UpdateConfigTemplateResponseBodyConfigTemplate()
self.config_template = temp_model.from_map(m['ConfigTemplate'])
if m.get('Message') is not None:
self.message = m.get('Message')
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 UpdateConfigTemplateResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: UpdateConfigTemplateResponseBody
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=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 = UpdateConfigTemplateResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ValidateConfigSettingRequest(TeaModel):
def __init__(self, env_id=None, template_id=None, stack_id=None, option_settings=None, region_id=None):
self.env_id = TeaConverter.to_unicode(env_id) # type: unicode
self.template_id = TeaConverter.to_unicode(template_id) # type: unicode
self.stack_id = TeaConverter.to_unicode(stack_id) # type: unicode
self.option_settings = TeaConverter.to_unicode(option_settings) # type: unicode
self.region_id = TeaConverter.to_unicode(region_id) # type: unicode
def validate(self):
pass
def to_map(self):
result = dict()
if self.env_id is not None:
result['EnvId'] = self.env_id
if self.template_id is not None:
result['TemplateId'] = self.template_id
if self.stack_id is not None:
result['StackId'] = self.stack_id
if self.option_settings is not None:
result['OptionSettings'] = self.option_settings
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EnvId') is not None:
self.env_id = m.get('EnvId')
if m.get('TemplateId') is not None:
self.template_id = m.get('TemplateId')
if m.get('StackId') is not None:
self.stack_id = m.get('StackId')
if m.get('OptionSettings') is not None:
self.option_settings = m.get('OptionSettings')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class ValidateConfigSettingResponseBodyConfigValidationResultsConfigValidationResultConfigOption(TeaModel):
def __init__(self, regex_desc=None, max_value=None, editor_type=None, min_value=None, default_value=None,
max_length=None, option_label=None, regex_pattern=None, change_severity=None, option_description=None,
option_name=None, path_name=None, hidden_option=None, value_type=None, min_length=None, value_options=None,
readonly_option=None):
self.regex_desc = TeaConverter.to_unicode(regex_desc) # type: unicode
self.max_value = max_value # type: long
self.editor_type = TeaConverter.to_unicode(editor_type) # type: unicode
self.min_value = min_value # type: long
self.default_value = TeaConverter.to_unicode(default_value) # type: unicode
self.max_length = max_length # type: int
self.option_label = TeaConverter.to_unicode(option_label) # type: unicode
self.regex_pattern = TeaConverter.to_unicode(regex_pattern) # type: unicode
self.change_severity = TeaConverter.to_unicode(change_severity) # type: unicode
self.option_description = TeaConverter.to_unicode(option_description) # type: unicode
self.option_name = TeaConverter.to_unicode(option_name) # type: unicode
self.path_name = TeaConverter.to_unicode(path_name) # type: unicode
self.hidden_option = hidden_option # type: bool
self.value_type = TeaConverter.to_unicode(value_type) # type: unicode
self.min_length = min_length # type: int
self.value_options = TeaConverter.to_unicode(value_options) # type: unicode
self.readonly_option = readonly_option # type: bool
def validate(self):
pass
def to_map(self):
result = dict()
if self.regex_desc is not None:
result['RegexDesc'] = self.regex_desc
if self.max_value is not None:
result['MaxValue'] = self.max_value
if self.editor_type is not None:
result['EditorType'] = self.editor_type
if self.min_value is not None:
result['MinValue'] = self.min_value
if self.default_value is not None:
result['DefaultValue'] = self.default_value
if self.max_length is not None:
result['MaxLength'] = self.max_length
if self.option_label is not None:
result['OptionLabel'] = self.option_label
if self.regex_pattern is not None:
result['RegexPattern'] = self.regex_pattern
if self.change_severity is not None:
result['ChangeSeverity'] = self.change_severity
if self.option_description is not None:
result['OptionDescription'] = self.option_description
if self.option_name is not None:
result['OptionName'] = self.option_name
if self.path_name is not None:
result['PathName'] = self.path_name
if self.hidden_option is not None:
result['HiddenOption'] = self.hidden_option
if self.value_type is not None:
result['ValueType'] = self.value_type
if self.min_length is not None:
result['MinLength'] = self.min_length
if self.value_options is not None:
result['ValueOptions'] = self.value_options
if self.readonly_option is not None:
result['ReadonlyOption'] = self.readonly_option
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RegexDesc') is not None:
self.regex_desc = m.get('RegexDesc')
if m.get('MaxValue') is not None:
self.max_value = m.get('MaxValue')
if m.get('EditorType') is not None:
self.editor_type = m.get('EditorType')
if m.get('MinValue') is not None:
self.min_value = m.get('MinValue')
if m.get('DefaultValue') is not None:
self.default_value = m.get('DefaultValue')
if m.get('MaxLength') is not None:
self.max_length = m.get('MaxLength')
if m.get('OptionLabel') is not None:
self.option_label = m.get('OptionLabel')
if m.get('RegexPattern') is not None:
self.regex_pattern = m.get('RegexPattern')
if m.get('ChangeSeverity') is not None:
self.change_severity = m.get('ChangeSeverity')
if m.get('OptionDescription') is not None:
self.option_description = m.get('OptionDescription')
if m.get('OptionName') is not None:
self.option_name = m.get('OptionName')
if m.get('PathName') is not None:
self.path_name = m.get('PathName')
if m.get('HiddenOption') is not None:
self.hidden_option = m.get('HiddenOption')
if m.get('ValueType') is not None:
self.value_type = m.get('ValueType')
if m.get('MinLength') is not None:
self.min_length = m.get('MinLength')
if m.get('ValueOptions') is not None:
self.value_options = m.get('ValueOptions')
if m.get('ReadonlyOption') is not None:
self.readonly_option = m.get('ReadonlyOption')
return self
class ValidateConfigSettingResponseBodyConfigValidationResultsConfigValidationResult(TeaModel):
def __init__(self, option_name=None, path_name=None, result_message=None, result_severity=None,
config_option=None):
self.option_name = TeaConverter.to_unicode(option_name) # type: unicode
self.path_name = TeaConverter.to_unicode(path_name) # type: unicode
self.result_message = TeaConverter.to_unicode(result_message) # type: unicode
self.result_severity = TeaConverter.to_unicode(result_severity) # type: unicode
self.config_option = config_option # type: ValidateConfigSettingResponseBodyConfigValidationResultsConfigValidationResultConfigOption
def validate(self):
if self.config_option:
self.config_option.validate()
def to_map(self):
result = dict()
if self.option_name is not None:
result['OptionName'] = self.option_name
if self.path_name is not None:
result['PathName'] = self.path_name
if self.result_message is not None:
result['ResultMessage'] = self.result_message
if self.result_severity is not None:
result['ResultSeverity'] = self.result_severity
if self.config_option is not None:
result['ConfigOption'] = self.config_option.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('OptionName') is not None:
self.option_name = m.get('OptionName')
if m.get('PathName') is not None:
self.path_name = m.get('PathName')
if m.get('ResultMessage') is not None:
self.result_message = m.get('ResultMessage')
if m.get('ResultSeverity') is not None:
self.result_severity = m.get('ResultSeverity')
if m.get('ConfigOption') is not None:
temp_model = ValidateConfigSettingResponseBodyConfigValidationResultsConfigValidationResultConfigOption()
self.config_option = temp_model.from_map(m['ConfigOption'])
return self
class ValidateConfigSettingResponseBodyConfigValidationResults(TeaModel):
def __init__(self, config_validation_result=None):
self.config_validation_result = config_validation_result # type: list[ValidateConfigSettingResponseBodyConfigValidationResultsConfigValidationResult]
def validate(self):
if self.config_validation_result:
for k in self.config_validation_result:
if k:
k.validate()
def to_map(self):
result = dict()
result['ConfigValidationResult'] = []
if self.config_validation_result is not None:
for k in self.config_validation_result:
result['ConfigValidationResult'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.config_validation_result = []
if m.get('ConfigValidationResult') is not None:
for k in m.get('ConfigValidationResult'):
temp_model = ValidateConfigSettingResponseBodyConfigValidationResultsConfigValidationResult()
self.config_validation_result.append(temp_model.from_map(k))
return self
class ValidateConfigSettingResponseBody(TeaModel):
def __init__(self, message=None, request_id=None, config_validation_results=None, code=None):
self.message = TeaConverter.to_unicode(message) # type: unicode
self.request_id = TeaConverter.to_unicode(request_id) # type: unicode
self.config_validation_results = config_validation_results # type: ValidateConfigSettingResponseBodyConfigValidationResults
self.code = TeaConverter.to_unicode(code) # type: unicode
def validate(self):
if self.config_validation_results:
self.config_validation_results.validate()
def to_map(self):
result = dict()
if self.message is not None:
result['Message'] = self.message
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.config_validation_results is not None:
result['ConfigValidationResults'] = self.config_validation_results.to_map()
if self.code is not None:
result['Code'] = self.code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ConfigValidationResults') is not None:
temp_model = ValidateConfigSettingResponseBodyConfigValidationResults()
self.config_validation_results = temp_model.from_map(m['ConfigValidationResults'])
if m.get('Code') is not None:
self.code = m.get('Code')
return self
class ValidateConfigSettingResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[unicode, unicode]
self.body = body # type: ValidateConfigSettingResponseBody
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=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 = ValidateConfigSettingResponseBody()
self.body = temp_model.from_map(m['body'])
return self