easygene-20210315/alibabacloud_easygene20210315/models.py (8,450 lines of code) (raw):
# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
from Tea.model import TeaModel
class AbortRunRequest(TeaModel):
def __init__(self, run_id=None, workspace=None):
self.run_id = run_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(AbortRunRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.run_id is not None:
result['RunId'] = self.run_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RunId') is not None:
self.run_id = m.get('RunId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class AbortRunResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(AbortRunResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AbortRunResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: AbortRunResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(AbortRunResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = AbortRunResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AbortSubmissionRequest(TeaModel):
def __init__(self, submission_id=None, workspace=None):
self.submission_id = submission_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(AbortSubmissionRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.submission_id is not None:
result['SubmissionId'] = self.submission_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('SubmissionId') is not None:
self.submission_id = m.get('SubmissionId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class AbortSubmissionResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(AbortSubmissionResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AbortSubmissionResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: AbortSubmissionResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(AbortSubmissionResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = AbortSubmissionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CopyPublicEntityRequest(TeaModel):
def __init__(self, dataset=None, entity_type=None, workspace=None):
self.dataset = dataset # type: str
self.entity_type = entity_type # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CopyPublicEntityRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.dataset is not None:
result['Dataset'] = self.dataset
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Dataset') is not None:
self.dataset = m.get('Dataset')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CopyPublicEntityResponseBody(TeaModel):
def __init__(self, entity_type=None, host_id=None, request_id=None, workspace=None):
self.entity_type = entity_type # type: str
self.host_id = host_id # type: str
self.request_id = request_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CopyPublicEntityResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CopyPublicEntityResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CopyPublicEntityResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(CopyPublicEntityResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CopyPublicEntityResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateAppRequestConfigs(TeaModel):
def __init__(self, content=None, path=None):
self.content = content # type: str
self.path = path # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateAppRequestConfigs, self).to_map()
if _map is not None:
return _map
result = dict()
if self.content is not None:
result['Content'] = self.content
if self.path is not None:
result['Path'] = self.path
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Content') is not None:
self.content = m.get('Content')
if m.get('Path') is not None:
self.path = m.get('Path')
return self
class CreateAppRequestDependencies(TeaModel):
def __init__(self, content=None, path=None):
self.content = content # type: str
self.path = path # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateAppRequestDependencies, self).to_map()
if _map is not None:
return _map
result = dict()
if self.content is not None:
result['Content'] = self.content
if self.path is not None:
result['Path'] = self.path
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Content') is not None:
self.content = m.get('Content')
if m.get('Path') is not None:
self.path = m.get('Path')
return self
class CreateAppRequest(TeaModel):
def __init__(self, app_name=None, app_type=None, client_token=None, configs=None, definition=None,
dependencies=None, description=None, documentation=None, labels=None, language=None, language_version=None,
path=None, revision_comment=None, revision_tag=None, workspace=None):
self.app_name = app_name # type: str
self.app_type = app_type # type: str
self.client_token = client_token # type: str
self.configs = configs # type: list[CreateAppRequestConfigs]
self.definition = definition # type: str
self.dependencies = dependencies # type: list[CreateAppRequestDependencies]
self.description = description # type: str
self.documentation = documentation # type: str
self.labels = labels # type: str
self.language = language # type: str
self.language_version = language_version # type: str
self.path = path # type: str
self.revision_comment = revision_comment # type: str
self.revision_tag = revision_tag # type: str
self.workspace = workspace # type: str
def validate(self):
if self.configs:
for k in self.configs:
if k:
k.validate()
if self.dependencies:
for k in self.dependencies:
if k:
k.validate()
def to_map(self):
_map = super(CreateAppRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_type is not None:
result['AppType'] = self.app_type
if self.client_token is not None:
result['ClientToken'] = self.client_token
result['Configs'] = []
if self.configs is not None:
for k in self.configs:
result['Configs'].append(k.to_map() if k else None)
if self.definition is not None:
result['Definition'] = self.definition
result['Dependencies'] = []
if self.dependencies is not None:
for k in self.dependencies:
result['Dependencies'].append(k.to_map() if k else None)
if self.description is not None:
result['Description'] = self.description
if self.documentation is not None:
result['Documentation'] = self.documentation
if self.labels is not None:
result['Labels'] = self.labels
if self.language is not None:
result['Language'] = self.language
if self.language_version is not None:
result['LanguageVersion'] = self.language_version
if self.path is not None:
result['Path'] = self.path
if self.revision_comment is not None:
result['RevisionComment'] = self.revision_comment
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppType') is not None:
self.app_type = m.get('AppType')
if m.get('ClientToken') is not None:
self.client_token = m.get('ClientToken')
self.configs = []
if m.get('Configs') is not None:
for k in m.get('Configs'):
temp_model = CreateAppRequestConfigs()
self.configs.append(temp_model.from_map(k))
if m.get('Definition') is not None:
self.definition = m.get('Definition')
self.dependencies = []
if m.get('Dependencies') is not None:
for k in m.get('Dependencies'):
temp_model = CreateAppRequestDependencies()
self.dependencies.append(temp_model.from_map(k))
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('Documentation') is not None:
self.documentation = m.get('Documentation')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('Language') is not None:
self.language = m.get('Language')
if m.get('LanguageVersion') is not None:
self.language_version = m.get('LanguageVersion')
if m.get('Path') is not None:
self.path = m.get('Path')
if m.get('RevisionComment') is not None:
self.revision_comment = m.get('RevisionComment')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateAppShrinkRequest(TeaModel):
def __init__(self, app_name=None, app_type=None, client_token=None, configs_shrink=None, definition=None,
dependencies_shrink=None, description=None, documentation=None, labels=None, language=None, language_version=None,
path=None, revision_comment=None, revision_tag=None, workspace=None):
self.app_name = app_name # type: str
self.app_type = app_type # type: str
self.client_token = client_token # type: str
self.configs_shrink = configs_shrink # type: str
self.definition = definition # type: str
self.dependencies_shrink = dependencies_shrink # type: str
self.description = description # type: str
self.documentation = documentation # type: str
self.labels = labels # type: str
self.language = language # type: str
self.language_version = language_version # type: str
self.path = path # type: str
self.revision_comment = revision_comment # type: str
self.revision_tag = revision_tag # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateAppShrinkRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_type is not None:
result['AppType'] = self.app_type
if self.client_token is not None:
result['ClientToken'] = self.client_token
if self.configs_shrink is not None:
result['Configs'] = self.configs_shrink
if self.definition is not None:
result['Definition'] = self.definition
if self.dependencies_shrink is not None:
result['Dependencies'] = self.dependencies_shrink
if self.description is not None:
result['Description'] = self.description
if self.documentation is not None:
result['Documentation'] = self.documentation
if self.labels is not None:
result['Labels'] = self.labels
if self.language is not None:
result['Language'] = self.language
if self.language_version is not None:
result['LanguageVersion'] = self.language_version
if self.path is not None:
result['Path'] = self.path
if self.revision_comment is not None:
result['RevisionComment'] = self.revision_comment
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppType') is not None:
self.app_type = m.get('AppType')
if m.get('ClientToken') is not None:
self.client_token = m.get('ClientToken')
if m.get('Configs') is not None:
self.configs_shrink = m.get('Configs')
if m.get('Definition') is not None:
self.definition = m.get('Definition')
if m.get('Dependencies') is not None:
self.dependencies_shrink = m.get('Dependencies')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('Documentation') is not None:
self.documentation = m.get('Documentation')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('Language') is not None:
self.language = m.get('Language')
if m.get('LanguageVersion') is not None:
self.language_version = m.get('LanguageVersion')
if m.get('Path') is not None:
self.path = m.get('Path')
if m.get('RevisionComment') is not None:
self.revision_comment = m.get('RevisionComment')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateAppResponseBody(TeaModel):
def __init__(self, app_name=None, host_id=None, request_id=None, revision=None, revision_tag=None,
workspace=None):
self.app_name = app_name # type: str
self.host_id = host_id # type: str
self.request_id = request_id # type: str
self.revision = revision # type: str
self.revision_tag = revision_tag # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateAppResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.revision is not None:
result['Revision'] = self.revision
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.workspace is not None:
result['Workspace'] = self.workspace
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('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Revision') is not None:
self.revision = m.get('Revision')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateAppResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreateAppResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreateAppResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreateAppResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateEntityRequestEntityItems(TeaModel):
def __init__(self, entity_data=None, entity_name=None):
self.entity_data = entity_data # type: dict[str, str]
self.entity_name = entity_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateEntityRequestEntityItems, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_data is not None:
result['EntityData'] = self.entity_data
if self.entity_name is not None:
result['EntityName'] = self.entity_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityData') is not None:
self.entity_data = m.get('EntityData')
if m.get('EntityName') is not None:
self.entity_name = m.get('EntityName')
return self
class CreateEntityRequest(TeaModel):
def __init__(self, client_token=None, entity_items=None, entity_type=None, workspace=None):
self.client_token = client_token # type: str
self.entity_items = entity_items # type: list[CreateEntityRequestEntityItems]
self.entity_type = entity_type # type: str
self.workspace = workspace # type: str
def validate(self):
if self.entity_items:
for k in self.entity_items:
if k:
k.validate()
def to_map(self):
_map = super(CreateEntityRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.client_token is not None:
result['ClientToken'] = self.client_token
result['EntityItems'] = []
if self.entity_items is not None:
for k in self.entity_items:
result['EntityItems'].append(k.to_map() if k else None)
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ClientToken') is not None:
self.client_token = m.get('ClientToken')
self.entity_items = []
if m.get('EntityItems') is not None:
for k in m.get('EntityItems'):
temp_model = CreateEntityRequestEntityItems()
self.entity_items.append(temp_model.from_map(k))
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateEntityShrinkRequest(TeaModel):
def __init__(self, client_token=None, entity_items_shrink=None, entity_type=None, workspace=None):
self.client_token = client_token # type: str
self.entity_items_shrink = entity_items_shrink # type: str
self.entity_type = entity_type # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateEntityShrinkRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.client_token is not None:
result['ClientToken'] = self.client_token
if self.entity_items_shrink is not None:
result['EntityItems'] = self.entity_items_shrink
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ClientToken') is not None:
self.client_token = m.get('ClientToken')
if m.get('EntityItems') is not None:
self.entity_items_shrink = m.get('EntityItems')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateEntityResponseBody(TeaModel):
def __init__(self, entity_type=None, host_id=None, request_id=None, workspace=None):
self.entity_type = entity_type # type: str
self.host_id = host_id # type: str
self.request_id = request_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateEntityResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateEntityResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreateEntityResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreateEntityResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreateEntityResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateRunRequestExecuteOptions(TeaModel):
def __init__(self, call_caching=None, delete_intermediate_results=None, failure_mode=None,
use_relative_output_paths=None):
self.call_caching = call_caching # type: bool
self.delete_intermediate_results = delete_intermediate_results # type: bool
self.failure_mode = failure_mode # type: str
self.use_relative_output_paths = use_relative_output_paths # type: bool
def validate(self):
pass
def to_map(self):
_map = super(CreateRunRequestExecuteOptions, self).to_map()
if _map is not None:
return _map
result = dict()
if self.call_caching is not None:
result['CallCaching'] = self.call_caching
if self.delete_intermediate_results is not None:
result['DeleteIntermediateResults'] = self.delete_intermediate_results
if self.failure_mode is not None:
result['FailureMode'] = self.failure_mode
if self.use_relative_output_paths is not None:
result['UseRelativeOutputPaths'] = self.use_relative_output_paths
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CallCaching') is not None:
self.call_caching = m.get('CallCaching')
if m.get('DeleteIntermediateResults') is not None:
self.delete_intermediate_results = m.get('DeleteIntermediateResults')
if m.get('FailureMode') is not None:
self.failure_mode = m.get('FailureMode')
if m.get('UseRelativeOutputPaths') is not None:
self.use_relative_output_paths = m.get('UseRelativeOutputPaths')
return self
class CreateRunRequest(TeaModel):
def __init__(self, app_name=None, app_revision=None, client_token=None, default_runtime=None, description=None,
execute_directory=None, execute_options=None, inputs=None, labels=None, output_folder=None, revision_tag=None,
role=None, run_name=None, workspace=None):
self.app_name = app_name # type: str
self.app_revision = app_revision # type: str
self.client_token = client_token # type: str
self.default_runtime = default_runtime # type: str
self.description = description # type: str
self.execute_directory = execute_directory # type: str
self.execute_options = execute_options # type: CreateRunRequestExecuteOptions
self.inputs = inputs # type: str
self.labels = labels # type: str
self.output_folder = output_folder # type: str
self.revision_tag = revision_tag # type: str
self.role = role # type: str
self.run_name = run_name # type: str
self.workspace = workspace # type: str
def validate(self):
if self.execute_options:
self.execute_options.validate()
def to_map(self):
_map = super(CreateRunRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_revision is not None:
result['AppRevision'] = self.app_revision
if self.client_token is not None:
result['ClientToken'] = self.client_token
if self.default_runtime is not None:
result['DefaultRuntime'] = self.default_runtime
if self.description is not None:
result['Description'] = self.description
if self.execute_directory is not None:
result['ExecuteDirectory'] = self.execute_directory
if self.execute_options is not None:
result['ExecuteOptions'] = self.execute_options.to_map()
if self.inputs is not None:
result['Inputs'] = self.inputs
if self.labels is not None:
result['Labels'] = self.labels
if self.output_folder is not None:
result['OutputFolder'] = self.output_folder
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.role is not None:
result['Role'] = self.role
if self.run_name is not None:
result['RunName'] = self.run_name
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppRevision') is not None:
self.app_revision = m.get('AppRevision')
if m.get('ClientToken') is not None:
self.client_token = m.get('ClientToken')
if m.get('DefaultRuntime') is not None:
self.default_runtime = m.get('DefaultRuntime')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('ExecuteDirectory') is not None:
self.execute_directory = m.get('ExecuteDirectory')
if m.get('ExecuteOptions') is not None:
temp_model = CreateRunRequestExecuteOptions()
self.execute_options = temp_model.from_map(m['ExecuteOptions'])
if m.get('Inputs') is not None:
self.inputs = m.get('Inputs')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('OutputFolder') is not None:
self.output_folder = m.get('OutputFolder')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('Role') is not None:
self.role = m.get('Role')
if m.get('RunName') is not None:
self.run_name = m.get('RunName')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateRunShrinkRequest(TeaModel):
def __init__(self, app_name=None, app_revision=None, client_token=None, default_runtime=None, description=None,
execute_directory=None, execute_options_shrink=None, inputs=None, labels=None, output_folder=None, revision_tag=None,
role=None, run_name=None, workspace=None):
self.app_name = app_name # type: str
self.app_revision = app_revision # type: str
self.client_token = client_token # type: str
self.default_runtime = default_runtime # type: str
self.description = description # type: str
self.execute_directory = execute_directory # type: str
self.execute_options_shrink = execute_options_shrink # type: str
self.inputs = inputs # type: str
self.labels = labels # type: str
self.output_folder = output_folder # type: str
self.revision_tag = revision_tag # type: str
self.role = role # type: str
self.run_name = run_name # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateRunShrinkRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_revision is not None:
result['AppRevision'] = self.app_revision
if self.client_token is not None:
result['ClientToken'] = self.client_token
if self.default_runtime is not None:
result['DefaultRuntime'] = self.default_runtime
if self.description is not None:
result['Description'] = self.description
if self.execute_directory is not None:
result['ExecuteDirectory'] = self.execute_directory
if self.execute_options_shrink is not None:
result['ExecuteOptions'] = self.execute_options_shrink
if self.inputs is not None:
result['Inputs'] = self.inputs
if self.labels is not None:
result['Labels'] = self.labels
if self.output_folder is not None:
result['OutputFolder'] = self.output_folder
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.role is not None:
result['Role'] = self.role
if self.run_name is not None:
result['RunName'] = self.run_name
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppRevision') is not None:
self.app_revision = m.get('AppRevision')
if m.get('ClientToken') is not None:
self.client_token = m.get('ClientToken')
if m.get('DefaultRuntime') is not None:
self.default_runtime = m.get('DefaultRuntime')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('ExecuteDirectory') is not None:
self.execute_directory = m.get('ExecuteDirectory')
if m.get('ExecuteOptions') is not None:
self.execute_options_shrink = m.get('ExecuteOptions')
if m.get('Inputs') is not None:
self.inputs = m.get('Inputs')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('OutputFolder') is not None:
self.output_folder = m.get('OutputFolder')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('Role') is not None:
self.role = m.get('Role')
if m.get('RunName') is not None:
self.run_name = m.get('RunName')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateRunResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None, run_id=None, workspace=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
self.run_id = run_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateRunResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.run_id is not None:
result['RunId'] = self.run_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('RunId') is not None:
self.run_id = m.get('RunId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateRunResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreateRunResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreateRunResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreateRunResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateSubmissionRequest(TeaModel):
def __init__(self, app_name=None, client_token=None, default_runtime=None, entity_names=None, entity_type=None,
execute_directory=None, execute_options=None, inputs=None, output_folder=None, outputs=None, revision=None,
revision_tag=None, workspace=None):
self.app_name = app_name # type: str
self.client_token = client_token # type: str
self.default_runtime = default_runtime # type: str
self.entity_names = entity_names # type: list[str]
self.entity_type = entity_type # type: str
self.execute_directory = execute_directory # type: str
self.execute_options = execute_options # type: str
self.inputs = inputs # type: str
self.output_folder = output_folder # type: str
self.outputs = outputs # type: str
self.revision = revision # type: str
self.revision_tag = revision_tag # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateSubmissionRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.client_token is not None:
result['ClientToken'] = self.client_token
if self.default_runtime is not None:
result['DefaultRuntime'] = self.default_runtime
if self.entity_names is not None:
result['EntityNames'] = self.entity_names
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.execute_directory is not None:
result['ExecuteDirectory'] = self.execute_directory
if self.execute_options is not None:
result['ExecuteOptions'] = self.execute_options
if self.inputs is not None:
result['Inputs'] = self.inputs
if self.output_folder is not None:
result['OutputFolder'] = self.output_folder
if self.outputs is not None:
result['Outputs'] = self.outputs
if self.revision is not None:
result['Revision'] = self.revision
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.workspace is not None:
result['Workspace'] = self.workspace
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('ClientToken') is not None:
self.client_token = m.get('ClientToken')
if m.get('DefaultRuntime') is not None:
self.default_runtime = m.get('DefaultRuntime')
if m.get('EntityNames') is not None:
self.entity_names = m.get('EntityNames')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('ExecuteDirectory') is not None:
self.execute_directory = m.get('ExecuteDirectory')
if m.get('ExecuteOptions') is not None:
self.execute_options = m.get('ExecuteOptions')
if m.get('Inputs') is not None:
self.inputs = m.get('Inputs')
if m.get('OutputFolder') is not None:
self.output_folder = m.get('OutputFolder')
if m.get('Outputs') is not None:
self.outputs = m.get('Outputs')
if m.get('Revision') is not None:
self.revision = m.get('Revision')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateSubmissionShrinkRequest(TeaModel):
def __init__(self, app_name=None, client_token=None, default_runtime=None, entity_names_shrink=None,
entity_type=None, execute_directory=None, execute_options=None, inputs=None, output_folder=None, outputs=None,
revision=None, revision_tag=None, workspace=None):
self.app_name = app_name # type: str
self.client_token = client_token # type: str
self.default_runtime = default_runtime # type: str
self.entity_names_shrink = entity_names_shrink # type: str
self.entity_type = entity_type # type: str
self.execute_directory = execute_directory # type: str
self.execute_options = execute_options # type: str
self.inputs = inputs # type: str
self.output_folder = output_folder # type: str
self.outputs = outputs # type: str
self.revision = revision # type: str
self.revision_tag = revision_tag # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateSubmissionShrinkRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.client_token is not None:
result['ClientToken'] = self.client_token
if self.default_runtime is not None:
result['DefaultRuntime'] = self.default_runtime
if self.entity_names_shrink is not None:
result['EntityNames'] = self.entity_names_shrink
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.execute_directory is not None:
result['ExecuteDirectory'] = self.execute_directory
if self.execute_options is not None:
result['ExecuteOptions'] = self.execute_options
if self.inputs is not None:
result['Inputs'] = self.inputs
if self.output_folder is not None:
result['OutputFolder'] = self.output_folder
if self.outputs is not None:
result['Outputs'] = self.outputs
if self.revision is not None:
result['Revision'] = self.revision
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.workspace is not None:
result['Workspace'] = self.workspace
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('ClientToken') is not None:
self.client_token = m.get('ClientToken')
if m.get('DefaultRuntime') is not None:
self.default_runtime = m.get('DefaultRuntime')
if m.get('EntityNames') is not None:
self.entity_names_shrink = m.get('EntityNames')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('ExecuteDirectory') is not None:
self.execute_directory = m.get('ExecuteDirectory')
if m.get('ExecuteOptions') is not None:
self.execute_options = m.get('ExecuteOptions')
if m.get('Inputs') is not None:
self.inputs = m.get('Inputs')
if m.get('OutputFolder') is not None:
self.output_folder = m.get('OutputFolder')
if m.get('Outputs') is not None:
self.outputs = m.get('Outputs')
if m.get('Revision') is not None:
self.revision = m.get('Revision')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateSubmissionResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None, submission_id=None, workspace=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
self.submission_id = submission_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateSubmissionResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.submission_id is not None:
result['SubmissionId'] = self.submission_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('SubmissionId') is not None:
self.submission_id = m.get('SubmissionId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateSubmissionResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreateSubmissionResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreateSubmissionResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreateSubmissionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateTemplateRequestInputsExpression(TeaModel):
def __init__(self, help=None, required=None, step_order=None, task_name=None, variable_name=None,
variable_type=None, variable_value=None):
self.help = help # type: str
self.required = required # type: bool
self.step_order = step_order # type: int
self.task_name = task_name # type: str
self.variable_name = variable_name # type: str
self.variable_type = variable_type # type: str
self.variable_value = variable_value # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateTemplateRequestInputsExpression, self).to_map()
if _map is not None:
return _map
result = dict()
if self.help is not None:
result['Help'] = self.help
if self.required is not None:
result['Required'] = self.required
if self.step_order is not None:
result['StepOrder'] = self.step_order
if self.task_name is not None:
result['TaskName'] = self.task_name
if self.variable_name is not None:
result['VariableName'] = self.variable_name
if self.variable_type is not None:
result['VariableType'] = self.variable_type
if self.variable_value is not None:
result['VariableValue'] = self.variable_value
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Help') is not None:
self.help = m.get('Help')
if m.get('Required') is not None:
self.required = m.get('Required')
if m.get('StepOrder') is not None:
self.step_order = m.get('StepOrder')
if m.get('TaskName') is not None:
self.task_name = m.get('TaskName')
if m.get('VariableName') is not None:
self.variable_name = m.get('VariableName')
if m.get('VariableType') is not None:
self.variable_type = m.get('VariableType')
if m.get('VariableValue') is not None:
self.variable_value = m.get('VariableValue')
return self
class CreateTemplateRequestOutputsExpression(TeaModel):
def __init__(self, help=None, required=None, step_order=None, task_name=None, variable_name=None,
variable_type=None, variable_value=None):
self.help = help # type: str
self.required = required # type: bool
self.step_order = step_order # type: int
self.task_name = task_name # type: str
self.variable_name = variable_name # type: str
self.variable_type = variable_type # type: str
self.variable_value = variable_value # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateTemplateRequestOutputsExpression, self).to_map()
if _map is not None:
return _map
result = dict()
if self.help is not None:
result['Help'] = self.help
if self.required is not None:
result['Required'] = self.required
if self.step_order is not None:
result['StepOrder'] = self.step_order
if self.task_name is not None:
result['TaskName'] = self.task_name
if self.variable_name is not None:
result['VariableName'] = self.variable_name
if self.variable_type is not None:
result['VariableType'] = self.variable_type
if self.variable_value is not None:
result['VariableValue'] = self.variable_value
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Help') is not None:
self.help = m.get('Help')
if m.get('Required') is not None:
self.required = m.get('Required')
if m.get('StepOrder') is not None:
self.step_order = m.get('StepOrder')
if m.get('TaskName') is not None:
self.task_name = m.get('TaskName')
if m.get('VariableName') is not None:
self.variable_name = m.get('VariableName')
if m.get('VariableType') is not None:
self.variable_type = m.get('VariableType')
if m.get('VariableValue') is not None:
self.variable_value = m.get('VariableValue')
return self
class CreateTemplateRequest(TeaModel):
def __init__(self, app_name=None, app_revision=None, client_token=None, description=None,
inputs_expression=None, labels=None, outputs_expression=None, revision_tag=None, root_entity=None,
template_name=None, workspace=None):
self.app_name = app_name # type: str
self.app_revision = app_revision # type: str
self.client_token = client_token # type: str
self.description = description # type: str
self.inputs_expression = inputs_expression # type: list[CreateTemplateRequestInputsExpression]
self.labels = labels # type: str
self.outputs_expression = outputs_expression # type: list[CreateTemplateRequestOutputsExpression]
self.revision_tag = revision_tag # type: str
self.root_entity = root_entity # type: str
self.template_name = template_name # type: str
self.workspace = workspace # type: str
def validate(self):
if self.inputs_expression:
for k in self.inputs_expression:
if k:
k.validate()
if self.outputs_expression:
for k in self.outputs_expression:
if k:
k.validate()
def to_map(self):
_map = super(CreateTemplateRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_revision is not None:
result['AppRevision'] = self.app_revision
if self.client_token is not None:
result['ClientToken'] = self.client_token
if self.description is not None:
result['Description'] = self.description
result['InputsExpression'] = []
if self.inputs_expression is not None:
for k in self.inputs_expression:
result['InputsExpression'].append(k.to_map() if k else None)
if self.labels is not None:
result['Labels'] = self.labels
result['OutputsExpression'] = []
if self.outputs_expression is not None:
for k in self.outputs_expression:
result['OutputsExpression'].append(k.to_map() if k else None)
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.root_entity is not None:
result['RootEntity'] = self.root_entity
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppRevision') is not None:
self.app_revision = m.get('AppRevision')
if m.get('ClientToken') is not None:
self.client_token = m.get('ClientToken')
if m.get('Description') is not None:
self.description = m.get('Description')
self.inputs_expression = []
if m.get('InputsExpression') is not None:
for k in m.get('InputsExpression'):
temp_model = CreateTemplateRequestInputsExpression()
self.inputs_expression.append(temp_model.from_map(k))
if m.get('Labels') is not None:
self.labels = m.get('Labels')
self.outputs_expression = []
if m.get('OutputsExpression') is not None:
for k in m.get('OutputsExpression'):
temp_model = CreateTemplateRequestOutputsExpression()
self.outputs_expression.append(temp_model.from_map(k))
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('RootEntity') is not None:
self.root_entity = m.get('RootEntity')
if m.get('TemplateName') is not None:
self.template_name = m.get('TemplateName')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateTemplateShrinkRequest(TeaModel):
def __init__(self, app_name=None, app_revision=None, client_token=None, description=None,
inputs_expression_shrink=None, labels=None, outputs_expression_shrink=None, revision_tag=None, root_entity=None,
template_name=None, workspace=None):
self.app_name = app_name # type: str
self.app_revision = app_revision # type: str
self.client_token = client_token # type: str
self.description = description # type: str
self.inputs_expression_shrink = inputs_expression_shrink # type: str
self.labels = labels # type: str
self.outputs_expression_shrink = outputs_expression_shrink # type: str
self.revision_tag = revision_tag # type: str
self.root_entity = root_entity # type: str
self.template_name = template_name # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateTemplateShrinkRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_revision is not None:
result['AppRevision'] = self.app_revision
if self.client_token is not None:
result['ClientToken'] = self.client_token
if self.description is not None:
result['Description'] = self.description
if self.inputs_expression_shrink is not None:
result['InputsExpression'] = self.inputs_expression_shrink
if self.labels is not None:
result['Labels'] = self.labels
if self.outputs_expression_shrink is not None:
result['OutputsExpression'] = self.outputs_expression_shrink
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.root_entity is not None:
result['RootEntity'] = self.root_entity
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppRevision') is not None:
self.app_revision = m.get('AppRevision')
if m.get('ClientToken') is not None:
self.client_token = m.get('ClientToken')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('InputsExpression') is not None:
self.inputs_expression_shrink = m.get('InputsExpression')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('OutputsExpression') is not None:
self.outputs_expression_shrink = m.get('OutputsExpression')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('RootEntity') is not None:
self.root_entity = m.get('RootEntity')
if m.get('TemplateName') is not None:
self.template_name = m.get('TemplateName')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateTemplateResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None, template_name=None, workspace=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
self.template_name = template_name # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateTemplateResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TemplateName') is not None:
self.template_name = m.get('TemplateName')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateTemplateResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreateTemplateResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreateTemplateResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreateTemplateResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateWorkspaceRequest(TeaModel):
def __init__(self, client_token=None, description=None, job_lifecycle=None, labels=None, role=None, storage=None,
workspace=None):
self.client_token = client_token # type: str
self.description = description # type: str
self.job_lifecycle = job_lifecycle # type: int
self.labels = labels # type: str
self.role = role # type: str
self.storage = storage # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateWorkspaceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.client_token is not None:
result['ClientToken'] = self.client_token
if self.description is not None:
result['Description'] = self.description
if self.job_lifecycle is not None:
result['JobLifecycle'] = self.job_lifecycle
if self.labels is not None:
result['Labels'] = self.labels
if self.role is not None:
result['Role'] = self.role
if self.storage is not None:
result['Storage'] = self.storage
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ClientToken') is not None:
self.client_token = m.get('ClientToken')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('JobLifecycle') is not None:
self.job_lifecycle = m.get('JobLifecycle')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('Role') is not None:
self.role = m.get('Role')
if m.get('Storage') is not None:
self.storage = m.get('Storage')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateWorkspaceResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None, workspace=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(CreateWorkspaceResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class CreateWorkspaceResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: CreateWorkspaceResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(CreateWorkspaceResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = CreateWorkspaceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteAppRequest(TeaModel):
def __init__(self, app_name=None, revision=None, workspace=None):
self.app_name = app_name # type: str
self.revision = revision # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteAppRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.revision is not None:
result['Revision'] = self.revision
if self.workspace is not None:
result['Workspace'] = self.workspace
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('Revision') is not None:
self.revision = m.get('Revision')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class DeleteAppResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteAppResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteAppResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeleteAppResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeleteAppResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteAppResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteEntityRequest(TeaModel):
def __init__(self, entity_type=None, workspace=None):
self.entity_type = entity_type # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteEntityRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class DeleteEntityResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteEntityResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteEntityResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeleteEntityResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeleteEntityResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteEntityResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteEntityItemsRequest(TeaModel):
def __init__(self, entity_names=None, entity_type=None, workspace=None):
self.entity_names = entity_names # type: list[str]
self.entity_type = entity_type # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteEntityItemsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_names is not None:
result['EntityNames'] = self.entity_names
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityNames') is not None:
self.entity_names = m.get('EntityNames')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class DeleteEntityItemsShrinkRequest(TeaModel):
def __init__(self, entity_names_shrink=None, entity_type=None, workspace=None):
self.entity_names_shrink = entity_names_shrink # type: str
self.entity_type = entity_type # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteEntityItemsShrinkRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_names_shrink is not None:
result['EntityNames'] = self.entity_names_shrink
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityNames') is not None:
self.entity_names_shrink = m.get('EntityNames')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class DeleteEntityItemsResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteEntityItemsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteEntityItemsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeleteEntityItemsResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeleteEntityItemsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteEntityItemsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteRunRequest(TeaModel):
def __init__(self, run_id=None, workspace=None):
self.run_id = run_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteRunRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.run_id is not None:
result['RunId'] = self.run_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RunId') is not None:
self.run_id = m.get('RunId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class DeleteRunResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteRunResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteRunResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeleteRunResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeleteRunResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteRunResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteSubmissionRequest(TeaModel):
def __init__(self, submission_id=None, workspace=None):
self.submission_id = submission_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteSubmissionRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.submission_id is not None:
result['SubmissionId'] = self.submission_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('SubmissionId') is not None:
self.submission_id = m.get('SubmissionId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class DeleteSubmissionResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteSubmissionResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteSubmissionResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeleteSubmissionResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeleteSubmissionResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteSubmissionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteTemplateRequest(TeaModel):
def __init__(self, template_name=None, workspace=None):
self.template_name = template_name # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteTemplateRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.workspace is not None:
result['Workspace'] = self.workspace
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('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class DeleteTemplateResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteTemplateResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteTemplateResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeleteTemplateResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeleteTemplateResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteTemplateResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteWorkspaceRequest(TeaModel):
def __init__(self, workspace=None):
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteWorkspaceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class DeleteWorkspaceResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DeleteWorkspaceResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteWorkspaceResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DeleteWorkspaceResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(DeleteWorkspaceResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteWorkspaceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DownloadEntityRequest(TeaModel):
def __init__(self, entity_names=None, entity_type=None, workspace=None):
self.entity_names = entity_names # type: list[str]
self.entity_type = entity_type # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(DownloadEntityRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_names is not None:
result['EntityNames'] = self.entity_names
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityNames') is not None:
self.entity_names = m.get('EntityNames')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class DownloadEntityShrinkRequest(TeaModel):
def __init__(self, entity_names_shrink=None, entity_type=None, workspace=None):
self.entity_names_shrink = entity_names_shrink # type: str
self.entity_type = entity_type # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(DownloadEntityShrinkRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_names_shrink is not None:
result['EntityNames'] = self.entity_names_shrink
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityNames') is not None:
self.entity_names_shrink = m.get('EntityNames')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class DownloadEntityResponseBody(TeaModel):
def __init__(self, entity_csvfile=None, host_id=None, request_id=None):
self.entity_csvfile = entity_csvfile # type: str
self.host_id = host_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(DownloadEntityResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_csvfile is not None:
result['EntityCSVFile'] = self.entity_csvfile
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityCSVFile') is not None:
self.entity_csvfile = m.get('EntityCSVFile')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DownloadEntityResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: DownloadEntityResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(DownloadEntityResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DownloadEntityResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetAppRequest(TeaModel):
def __init__(self, app_name=None, revision=None, revision_tag=None, workspace=None):
self.app_name = app_name # type: str
self.revision = revision # type: str
self.revision_tag = revision_tag # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetAppRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.revision is not None:
result['Revision'] = self.revision
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.workspace is not None:
result['Workspace'] = self.workspace
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('Revision') is not None:
self.revision = m.get('Revision')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class GetAppResponseBodyConfigs(TeaModel):
def __init__(self, content=None, path=None):
self.content = content # type: str
self.path = path # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetAppResponseBodyConfigs, self).to_map()
if _map is not None:
return _map
result = dict()
if self.content is not None:
result['Content'] = self.content
if self.path is not None:
result['Path'] = self.path
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Content') is not None:
self.content = m.get('Content')
if m.get('Path') is not None:
self.path = m.get('Path')
return self
class GetAppResponseBodyDependencies(TeaModel):
def __init__(self, content=None, path=None):
self.content = content # type: str
self.path = path # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetAppResponseBodyDependencies, self).to_map()
if _map is not None:
return _map
result = dict()
if self.content is not None:
result['Content'] = self.content
if self.path is not None:
result['Path'] = self.path
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Content') is not None:
self.content = m.get('Content')
if m.get('Path') is not None:
self.path = m.get('Path')
return self
class GetAppResponseBodyInputs(TeaModel):
def __init__(self, help=None, required=None, step_order=None, task_name=None, variable_name=None,
variable_type=None, variable_value=None):
self.help = help # type: str
self.required = required # type: bool
self.step_order = step_order # type: long
self.task_name = task_name # type: str
self.variable_name = variable_name # type: str
self.variable_type = variable_type # type: str
self.variable_value = variable_value # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetAppResponseBodyInputs, self).to_map()
if _map is not None:
return _map
result = dict()
if self.help is not None:
result['Help'] = self.help
if self.required is not None:
result['Required'] = self.required
if self.step_order is not None:
result['StepOrder'] = self.step_order
if self.task_name is not None:
result['TaskName'] = self.task_name
if self.variable_name is not None:
result['VariableName'] = self.variable_name
if self.variable_type is not None:
result['VariableType'] = self.variable_type
if self.variable_value is not None:
result['VariableValue'] = self.variable_value
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Help') is not None:
self.help = m.get('Help')
if m.get('Required') is not None:
self.required = m.get('Required')
if m.get('StepOrder') is not None:
self.step_order = m.get('StepOrder')
if m.get('TaskName') is not None:
self.task_name = m.get('TaskName')
if m.get('VariableName') is not None:
self.variable_name = m.get('VariableName')
if m.get('VariableType') is not None:
self.variable_type = m.get('VariableType')
if m.get('VariableValue') is not None:
self.variable_value = m.get('VariableValue')
return self
class GetAppResponseBodyOutputs(TeaModel):
def __init__(self, help=None, required=None, step_order=None, task_name=None, variable_name=None,
variable_type=None, variable_value=None):
self.help = help # type: str
self.required = required # type: bool
self.step_order = step_order # type: long
self.task_name = task_name # type: str
self.variable_name = variable_name # type: str
self.variable_type = variable_type # type: str
self.variable_value = variable_value # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetAppResponseBodyOutputs, self).to_map()
if _map is not None:
return _map
result = dict()
if self.help is not None:
result['Help'] = self.help
if self.required is not None:
result['Required'] = self.required
if self.step_order is not None:
result['StepOrder'] = self.step_order
if self.task_name is not None:
result['TaskName'] = self.task_name
if self.variable_name is not None:
result['VariableName'] = self.variable_name
if self.variable_type is not None:
result['VariableType'] = self.variable_type
if self.variable_value is not None:
result['VariableValue'] = self.variable_value
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Help') is not None:
self.help = m.get('Help')
if m.get('Required') is not None:
self.required = m.get('Required')
if m.get('StepOrder') is not None:
self.step_order = m.get('StepOrder')
if m.get('TaskName') is not None:
self.task_name = m.get('TaskName')
if m.get('VariableName') is not None:
self.variable_name = m.get('VariableName')
if m.get('VariableType') is not None:
self.variable_type = m.get('VariableType')
if m.get('VariableValue') is not None:
self.variable_value = m.get('VariableValue')
return self
class GetAppResponseBodyRevisions(TeaModel):
def __init__(self, create_time=None, revision=None, revision_comment=None, revision_tag=None):
self.create_time = create_time # type: str
self.revision = revision # type: str
self.revision_comment = revision_comment # type: str
self.revision_tag = revision_tag # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetAppResponseBodyRevisions, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.revision is not None:
result['Revision'] = self.revision
if self.revision_comment is not None:
result['RevisionComment'] = self.revision_comment
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('Revision') is not None:
self.revision = m.get('Revision')
if m.get('RevisionComment') is not None:
self.revision_comment = m.get('RevisionComment')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
return self
class GetAppResponseBody(TeaModel):
def __init__(self, app_name=None, app_type=None, configs=None, create_time=None, definition=None,
dependencies=None, description=None, documentation=None, host_id=None, inputs=None, labels=None, language=None,
language_version=None, last_modified_time=None, outputs=None, path=None, request_id=None, revision=None,
revision_comment=None, revision_tag=None, revisions=None, scope=None, source=None, url=None, workflow_name=None,
workspace=None):
self.app_name = app_name # type: str
self.app_type = app_type # type: str
self.configs = configs # type: list[GetAppResponseBodyConfigs]
self.create_time = create_time # type: str
self.definition = definition # type: str
self.dependencies = dependencies # type: list[GetAppResponseBodyDependencies]
self.description = description # type: str
self.documentation = documentation # type: str
self.host_id = host_id # type: str
self.inputs = inputs # type: list[GetAppResponseBodyInputs]
self.labels = labels # type: dict[str, str]
self.language = language # type: str
self.language_version = language_version # type: str
self.last_modified_time = last_modified_time # type: str
self.outputs = outputs # type: list[GetAppResponseBodyOutputs]
self.path = path # type: str
self.request_id = request_id # type: str
self.revision = revision # type: str
self.revision_comment = revision_comment # type: str
self.revision_tag = revision_tag # type: str
self.revisions = revisions # type: list[GetAppResponseBodyRevisions]
self.scope = scope # type: str
self.source = source # type: str
self.url = url # type: str
self.workflow_name = workflow_name # type: str
self.workspace = workspace # type: str
def validate(self):
if self.configs:
for k in self.configs:
if k:
k.validate()
if self.dependencies:
for k in self.dependencies:
if k:
k.validate()
if self.inputs:
for k in self.inputs:
if k:
k.validate()
if self.outputs:
for k in self.outputs:
if k:
k.validate()
if self.revisions:
for k in self.revisions:
if k:
k.validate()
def to_map(self):
_map = super(GetAppResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_type is not None:
result['AppType'] = self.app_type
result['Configs'] = []
if self.configs is not None:
for k in self.configs:
result['Configs'].append(k.to_map() if k else None)
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.definition is not None:
result['Definition'] = self.definition
result['Dependencies'] = []
if self.dependencies is not None:
for k in self.dependencies:
result['Dependencies'].append(k.to_map() if k else None)
if self.description is not None:
result['Description'] = self.description
if self.documentation is not None:
result['Documentation'] = self.documentation
if self.host_id is not None:
result['HostId'] = self.host_id
result['Inputs'] = []
if self.inputs is not None:
for k in self.inputs:
result['Inputs'].append(k.to_map() if k else None)
if self.labels is not None:
result['Labels'] = self.labels
if self.language is not None:
result['Language'] = self.language
if self.language_version is not None:
result['LanguageVersion'] = self.language_version
if self.last_modified_time is not None:
result['LastModifiedTime'] = self.last_modified_time
result['Outputs'] = []
if self.outputs is not None:
for k in self.outputs:
result['Outputs'].append(k.to_map() if k else None)
if self.path is not None:
result['Path'] = self.path
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.revision is not None:
result['Revision'] = self.revision
if self.revision_comment is not None:
result['RevisionComment'] = self.revision_comment
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
result['Revisions'] = []
if self.revisions is not None:
for k in self.revisions:
result['Revisions'].append(k.to_map() if k else None)
if self.scope is not None:
result['Scope'] = self.scope
if self.source is not None:
result['Source'] = self.source
if self.url is not None:
result['URL'] = self.url
if self.workflow_name is not None:
result['WorkflowName'] = self.workflow_name
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppType') is not None:
self.app_type = m.get('AppType')
self.configs = []
if m.get('Configs') is not None:
for k in m.get('Configs'):
temp_model = GetAppResponseBodyConfigs()
self.configs.append(temp_model.from_map(k))
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('Definition') is not None:
self.definition = m.get('Definition')
self.dependencies = []
if m.get('Dependencies') is not None:
for k in m.get('Dependencies'):
temp_model = GetAppResponseBodyDependencies()
self.dependencies.append(temp_model.from_map(k))
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('Documentation') is not None:
self.documentation = m.get('Documentation')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
self.inputs = []
if m.get('Inputs') is not None:
for k in m.get('Inputs'):
temp_model = GetAppResponseBodyInputs()
self.inputs.append(temp_model.from_map(k))
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('Language') is not None:
self.language = m.get('Language')
if m.get('LanguageVersion') is not None:
self.language_version = m.get('LanguageVersion')
if m.get('LastModifiedTime') is not None:
self.last_modified_time = m.get('LastModifiedTime')
self.outputs = []
if m.get('Outputs') is not None:
for k in m.get('Outputs'):
temp_model = GetAppResponseBodyOutputs()
self.outputs.append(temp_model.from_map(k))
if m.get('Path') is not None:
self.path = m.get('Path')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Revision') is not None:
self.revision = m.get('Revision')
if m.get('RevisionComment') is not None:
self.revision_comment = m.get('RevisionComment')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
self.revisions = []
if m.get('Revisions') is not None:
for k in m.get('Revisions'):
temp_model = GetAppResponseBodyRevisions()
self.revisions.append(temp_model.from_map(k))
if m.get('Scope') is not None:
self.scope = m.get('Scope')
if m.get('Source') is not None:
self.source = m.get('Source')
if m.get('URL') is not None:
self.url = m.get('URL')
if m.get('WorkflowName') is not None:
self.workflow_name = m.get('WorkflowName')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class GetAppResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetAppResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetAppResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetAppResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetEntityRequest(TeaModel):
def __init__(self, entity_type=None, workspace=None):
self.entity_type = entity_type # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetEntityRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class GetEntityResponseBody(TeaModel):
def __init__(self, attributes=None, entity_type=None, host_id=None, request_id=None, total_count=None,
workspace=None):
self.attributes = attributes # type: list[str]
self.entity_type = entity_type # type: str
self.host_id = host_id # type: str
self.request_id = request_id # type: str
self.total_count = total_count # type: int
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetEntityResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.attributes is not None:
result['Attributes'] = self.attributes
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Attributes') is not None:
self.attributes = m.get('Attributes')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class GetEntityResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetEntityResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetEntityResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetEntityResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetGlobalAppRequest(TeaModel):
def __init__(self, app_name=None, app_version=None, attributes=None, location=None, namespace_name=None):
self.app_name = app_name # type: str
self.app_version = app_version # type: str
self.attributes = attributes # type: list[str]
self.location = location # type: str
self.namespace_name = namespace_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetGlobalAppRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_version is not None:
result['AppVersion'] = self.app_version
if self.attributes is not None:
result['Attributes'] = self.attributes
if self.location is not None:
result['Location'] = self.location
if self.namespace_name is not None:
result['NamespaceName'] = self.namespace_name
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('AppVersion') is not None:
self.app_version = m.get('AppVersion')
if m.get('Attributes') is not None:
self.attributes = m.get('Attributes')
if m.get('Location') is not None:
self.location = m.get('Location')
if m.get('NamespaceName') is not None:
self.namespace_name = m.get('NamespaceName')
return self
class GetGlobalAppShrinkRequest(TeaModel):
def __init__(self, app_name=None, app_version=None, attributes_shrink=None, location=None, namespace_name=None):
self.app_name = app_name # type: str
self.app_version = app_version # type: str
self.attributes_shrink = attributes_shrink # type: str
self.location = location # type: str
self.namespace_name = namespace_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetGlobalAppShrinkRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_version is not None:
result['AppVersion'] = self.app_version
if self.attributes_shrink is not None:
result['Attributes'] = self.attributes_shrink
if self.location is not None:
result['Location'] = self.location
if self.namespace_name is not None:
result['NamespaceName'] = self.namespace_name
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('AppVersion') is not None:
self.app_version = m.get('AppVersion')
if m.get('Attributes') is not None:
self.attributes_shrink = m.get('Attributes')
if m.get('Location') is not None:
self.location = m.get('Location')
if m.get('NamespaceName') is not None:
self.namespace_name = m.get('NamespaceName')
return self
class GetGlobalAppResponseBodyAppDescriptorFiles(TeaModel):
def __init__(self, checksum=None, content=None, file_type=None, path=None, url=None):
self.checksum = checksum # type: str
self.content = content # type: str
self.file_type = file_type # type: str
self.path = path # type: str
self.url = url # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetGlobalAppResponseBodyAppDescriptorFiles, self).to_map()
if _map is not None:
return _map
result = dict()
if self.checksum is not None:
result['Checksum'] = self.checksum
if self.content is not None:
result['Content'] = self.content
if self.file_type is not None:
result['FileType'] = self.file_type
if self.path is not None:
result['Path'] = self.path
if self.url is not None:
result['Url'] = self.url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Checksum') is not None:
self.checksum = m.get('Checksum')
if m.get('Content') is not None:
self.content = m.get('Content')
if m.get('FileType') is not None:
self.file_type = m.get('FileType')
if m.get('Path') is not None:
self.path = m.get('Path')
if m.get('Url') is not None:
self.url = m.get('Url')
return self
class GetGlobalAppResponseBodyAppVersions(TeaModel):
def __init__(self, app_version=None, comment=None, last_modified=None):
self.app_version = app_version # type: str
self.comment = comment # type: str
self.last_modified = last_modified # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetGlobalAppResponseBodyAppVersions, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_version is not None:
result['AppVersion'] = self.app_version
if self.comment is not None:
result['Comment'] = self.comment
if self.last_modified is not None:
result['LastModified'] = self.last_modified
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppVersion') is not None:
self.app_version = m.get('AppVersion')
if m.get('Comment') is not None:
self.comment = m.get('Comment')
if m.get('LastModified') is not None:
self.last_modified = m.get('LastModified')
return self
class GetGlobalAppResponseBody(TeaModel):
def __init__(self, app_default_version=None, app_description=None, app_descriptor_files=None,
app_descriptor_type=None, app_fee=None, app_name=None, app_scope=None, app_type=None, app_version=None,
app_versions=None, categories=None, comment=None, contact=None, dag=None, document=None, host_id=None,
last_modified=None, links=None, locations=None, namespace_name=None, pinned=None, request_id=None, toolkit=None):
self.app_default_version = app_default_version # type: str
self.app_description = app_description # type: str
self.app_descriptor_files = app_descriptor_files # type: list[GetGlobalAppResponseBodyAppDescriptorFiles]
self.app_descriptor_type = app_descriptor_type # type: str
self.app_fee = app_fee # type: str
self.app_name = app_name # type: str
self.app_scope = app_scope # type: str
self.app_type = app_type # type: str
self.app_version = app_version # type: str
self.app_versions = app_versions # type: list[GetGlobalAppResponseBodyAppVersions]
self.categories = categories # type: list[str]
self.comment = comment # type: str
self.contact = contact # type: str
self.dag = dag # type: str
self.document = document # type: str
self.host_id = host_id # type: str
self.last_modified = last_modified # type: str
self.links = links # type: list[str]
self.locations = locations # type: list[str]
self.namespace_name = namespace_name # type: str
self.pinned = pinned # type: bool
self.request_id = request_id # type: str
self.toolkit = toolkit # type: str
def validate(self):
if self.app_descriptor_files:
for k in self.app_descriptor_files:
if k:
k.validate()
if self.app_versions:
for k in self.app_versions:
if k:
k.validate()
def to_map(self):
_map = super(GetGlobalAppResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_default_version is not None:
result['AppDefaultVersion'] = self.app_default_version
if self.app_description is not None:
result['AppDescription'] = self.app_description
result['AppDescriptorFiles'] = []
if self.app_descriptor_files is not None:
for k in self.app_descriptor_files:
result['AppDescriptorFiles'].append(k.to_map() if k else None)
if self.app_descriptor_type is not None:
result['AppDescriptorType'] = self.app_descriptor_type
if self.app_fee is not None:
result['AppFee'] = self.app_fee
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_scope is not None:
result['AppScope'] = self.app_scope
if self.app_type is not None:
result['AppType'] = self.app_type
if self.app_version is not None:
result['AppVersion'] = self.app_version
result['AppVersions'] = []
if self.app_versions is not None:
for k in self.app_versions:
result['AppVersions'].append(k.to_map() if k else None)
if self.categories is not None:
result['Categories'] = self.categories
if self.comment is not None:
result['Comment'] = self.comment
if self.contact is not None:
result['Contact'] = self.contact
if self.dag is not None:
result['DAG'] = self.dag
if self.document is not None:
result['Document'] = self.document
if self.host_id is not None:
result['HostId'] = self.host_id
if self.last_modified is not None:
result['LastModified'] = self.last_modified
if self.links is not None:
result['Links'] = self.links
if self.locations is not None:
result['Locations'] = self.locations
if self.namespace_name is not None:
result['NamespaceName'] = self.namespace_name
if self.pinned is not None:
result['Pinned'] = self.pinned
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.toolkit is not None:
result['Toolkit'] = self.toolkit
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppDefaultVersion') is not None:
self.app_default_version = m.get('AppDefaultVersion')
if m.get('AppDescription') is not None:
self.app_description = m.get('AppDescription')
self.app_descriptor_files = []
if m.get('AppDescriptorFiles') is not None:
for k in m.get('AppDescriptorFiles'):
temp_model = GetGlobalAppResponseBodyAppDescriptorFiles()
self.app_descriptor_files.append(temp_model.from_map(k))
if m.get('AppDescriptorType') is not None:
self.app_descriptor_type = m.get('AppDescriptorType')
if m.get('AppFee') is not None:
self.app_fee = m.get('AppFee')
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('AppScope') is not None:
self.app_scope = m.get('AppScope')
if m.get('AppType') is not None:
self.app_type = m.get('AppType')
if m.get('AppVersion') is not None:
self.app_version = m.get('AppVersion')
self.app_versions = []
if m.get('AppVersions') is not None:
for k in m.get('AppVersions'):
temp_model = GetGlobalAppResponseBodyAppVersions()
self.app_versions.append(temp_model.from_map(k))
if m.get('Categories') is not None:
self.categories = m.get('Categories')
if m.get('Comment') is not None:
self.comment = m.get('Comment')
if m.get('Contact') is not None:
self.contact = m.get('Contact')
if m.get('DAG') is not None:
self.dag = m.get('DAG')
if m.get('Document') is not None:
self.document = m.get('Document')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('LastModified') is not None:
self.last_modified = m.get('LastModified')
if m.get('Links') is not None:
self.links = m.get('Links')
if m.get('Locations') is not None:
self.locations = m.get('Locations')
if m.get('NamespaceName') is not None:
self.namespace_name = m.get('NamespaceName')
if m.get('Pinned') is not None:
self.pinned = m.get('Pinned')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Toolkit') is not None:
self.toolkit = m.get('Toolkit')
return self
class GetGlobalAppResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetGlobalAppResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetGlobalAppResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetGlobalAppResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetPublicDatasetRequest(TeaModel):
def __init__(self, attributes=None, dataset_name=None):
self.attributes = attributes # type: list[str]
self.dataset_name = dataset_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetPublicDatasetRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.attributes is not None:
result['Attributes'] = self.attributes
if self.dataset_name is not None:
result['DatasetName'] = self.dataset_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Attributes') is not None:
self.attributes = m.get('Attributes')
if m.get('DatasetName') is not None:
self.dataset_name = m.get('DatasetName')
return self
class GetPublicDatasetShrinkRequest(TeaModel):
def __init__(self, attributes_shrink=None, dataset_name=None):
self.attributes_shrink = attributes_shrink # type: str
self.dataset_name = dataset_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetPublicDatasetShrinkRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.attributes_shrink is not None:
result['Attributes'] = self.attributes_shrink
if self.dataset_name is not None:
result['DatasetName'] = self.dataset_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Attributes') is not None:
self.attributes_shrink = m.get('Attributes')
if m.get('DatasetName') is not None:
self.dataset_name = m.get('DatasetName')
return self
class GetPublicDatasetResponseBody(TeaModel):
def __init__(self, about=None, access_requirements=None, copyright=None, dataset_description=None,
dataset_name=None, host_id=None, last_modified=None, locations=None, request_id=None, tags=None,
update_frequency=None):
self.about = about # type: str
self.access_requirements = access_requirements # type: str
self.copyright = copyright # type: str
self.dataset_description = dataset_description # type: str
self.dataset_name = dataset_name # type: str
self.host_id = host_id # type: str
self.last_modified = last_modified # type: str
self.locations = locations # type: list[str]
self.request_id = request_id # type: str
self.tags = tags # type: list[str]
self.update_frequency = update_frequency # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetPublicDatasetResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.about is not None:
result['About'] = self.about
if self.access_requirements is not None:
result['AccessRequirements'] = self.access_requirements
if self.copyright is not None:
result['Copyright'] = self.copyright
if self.dataset_description is not None:
result['DatasetDescription'] = self.dataset_description
if self.dataset_name is not None:
result['DatasetName'] = self.dataset_name
if self.host_id is not None:
result['HostId'] = self.host_id
if self.last_modified is not None:
result['LastModified'] = self.last_modified
if self.locations is not None:
result['Locations'] = self.locations
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.tags is not None:
result['Tags'] = self.tags
if self.update_frequency is not None:
result['UpdateFrequency'] = self.update_frequency
return result
def from_map(self, m=None):
m = m or dict()
if m.get('About') is not None:
self.about = m.get('About')
if m.get('AccessRequirements') is not None:
self.access_requirements = m.get('AccessRequirements')
if m.get('Copyright') is not None:
self.copyright = m.get('Copyright')
if m.get('DatasetDescription') is not None:
self.dataset_description = m.get('DatasetDescription')
if m.get('DatasetName') is not None:
self.dataset_name = m.get('DatasetName')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('LastModified') is not None:
self.last_modified = m.get('LastModified')
if m.get('Locations') is not None:
self.locations = m.get('Locations')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Tags') is not None:
self.tags = m.get('Tags')
if m.get('UpdateFrequency') is not None:
self.update_frequency = m.get('UpdateFrequency')
return self
class GetPublicDatasetResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetPublicDatasetResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetPublicDatasetResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetPublicDatasetResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetPublicDatasetEntityRequest(TeaModel):
def __init__(self, dataset_name=None, entity_type=None, location=None):
self.dataset_name = dataset_name # type: str
self.entity_type = entity_type # type: str
self.location = location # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetPublicDatasetEntityRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.dataset_name is not None:
result['DatasetName'] = self.dataset_name
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.location is not None:
result['Location'] = self.location
return result
def from_map(self, m=None):
m = m or dict()
if m.get('DatasetName') is not None:
self.dataset_name = m.get('DatasetName')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Location') is not None:
self.location = m.get('Location')
return self
class GetPublicDatasetEntityResponseBody(TeaModel):
def __init__(self, attributes=None, dataset_name=None, entity_type=None, host_id=None, request_id=None,
total_count=None):
self.attributes = attributes # type: list[str]
self.dataset_name = dataset_name # type: str
self.entity_type = entity_type # type: str
self.host_id = host_id # type: str
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
pass
def to_map(self):
_map = super(GetPublicDatasetEntityResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.attributes is not None:
result['Attributes'] = self.attributes
if self.dataset_name is not None:
result['DatasetName'] = self.dataset_name
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Attributes') is not None:
self.attributes = m.get('Attributes')
if m.get('DatasetName') is not None:
self.dataset_name = m.get('DatasetName')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class GetPublicDatasetEntityResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetPublicDatasetEntityResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetPublicDatasetEntityResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetPublicDatasetEntityResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetRunRequest(TeaModel):
def __init__(self, run_id=None, workspace=None):
self.run_id = run_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetRunRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.run_id is not None:
result['RunId'] = self.run_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('RunId') is not None:
self.run_id = m.get('RunId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class GetRunResponseBodyExecuteOptions(TeaModel):
def __init__(self, call_caching=None, delete_intermediate_results=None, failure_mode=None,
use_relative_output_paths=None):
self.call_caching = call_caching # type: bool
self.delete_intermediate_results = delete_intermediate_results # type: bool
self.failure_mode = failure_mode # type: str
self.use_relative_output_paths = use_relative_output_paths # type: bool
def validate(self):
pass
def to_map(self):
_map = super(GetRunResponseBodyExecuteOptions, self).to_map()
if _map is not None:
return _map
result = dict()
if self.call_caching is not None:
result['CallCaching'] = self.call_caching
if self.delete_intermediate_results is not None:
result['DeleteIntermediateResults'] = self.delete_intermediate_results
if self.failure_mode is not None:
result['FailureMode'] = self.failure_mode
if self.use_relative_output_paths is not None:
result['UseRelativeOutputPaths'] = self.use_relative_output_paths
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CallCaching') is not None:
self.call_caching = m.get('CallCaching')
if m.get('DeleteIntermediateResults') is not None:
self.delete_intermediate_results = m.get('DeleteIntermediateResults')
if m.get('FailureMode') is not None:
self.failure_mode = m.get('FailureMode')
if m.get('UseRelativeOutputPaths') is not None:
self.use_relative_output_paths = m.get('UseRelativeOutputPaths')
return self
class GetRunResponseBody(TeaModel):
def __init__(self, app_name=None, app_revision=None, billing_instance_ids=None, calls=None, create_time=None,
default_runtime=None, description=None, end_time=None, entity_name=None, entity_type=None, execute_directory=None,
execute_options=None, failures=None, host_id=None, inputs=None, labels=None, output_folder=None, outputs=None,
request_id=None, run_id=None, run_name=None, source=None, start_time=None, status=None, submission_id=None,
timing=None, user=None, workspace=None):
self.app_name = app_name # type: str
self.app_revision = app_revision # type: str
self.billing_instance_ids = billing_instance_ids # type: list[str]
self.calls = calls # type: str
self.create_time = create_time # type: str
self.default_runtime = default_runtime # type: str
self.description = description # type: str
self.end_time = end_time # type: str
self.entity_name = entity_name # type: str
self.entity_type = entity_type # type: str
self.execute_directory = execute_directory # type: str
self.execute_options = execute_options # type: GetRunResponseBodyExecuteOptions
self.failures = failures # type: str
self.host_id = host_id # type: str
self.inputs = inputs # type: str
self.labels = labels # type: dict[str, str]
self.output_folder = output_folder # type: str
self.outputs = outputs # type: str
self.request_id = request_id # type: str
self.run_id = run_id # type: str
self.run_name = run_name # type: str
self.source = source # type: str
self.start_time = start_time # type: str
self.status = status # type: str
self.submission_id = submission_id # type: str
self.timing = timing # type: str
self.user = user # type: str
self.workspace = workspace # type: str
def validate(self):
if self.execute_options:
self.execute_options.validate()
def to_map(self):
_map = super(GetRunResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_revision is not None:
result['AppRevision'] = self.app_revision
if self.billing_instance_ids is not None:
result['BillingInstanceIds'] = self.billing_instance_ids
if self.calls is not None:
result['Calls'] = self.calls
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.default_runtime is not None:
result['DefaultRuntime'] = self.default_runtime
if self.description is not None:
result['Description'] = self.description
if self.end_time is not None:
result['EndTime'] = self.end_time
if self.entity_name is not None:
result['EntityName'] = self.entity_name
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.execute_directory is not None:
result['ExecuteDirectory'] = self.execute_directory
if self.execute_options is not None:
result['ExecuteOptions'] = self.execute_options.to_map()
if self.failures is not None:
result['Failures'] = self.failures
if self.host_id is not None:
result['HostId'] = self.host_id
if self.inputs is not None:
result['Inputs'] = self.inputs
if self.labels is not None:
result['Labels'] = self.labels
if self.output_folder is not None:
result['OutputFolder'] = self.output_folder
if self.outputs is not None:
result['Outputs'] = self.outputs
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.run_id is not None:
result['RunId'] = self.run_id
if self.run_name is not None:
result['RunName'] = self.run_name
if self.source is not None:
result['Source'] = self.source
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.status is not None:
result['Status'] = self.status
if self.submission_id is not None:
result['SubmissionId'] = self.submission_id
if self.timing is not None:
result['Timing'] = self.timing
if self.user is not None:
result['User'] = self.user
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppRevision') is not None:
self.app_revision = m.get('AppRevision')
if m.get('BillingInstanceIds') is not None:
self.billing_instance_ids = m.get('BillingInstanceIds')
if m.get('Calls') is not None:
self.calls = m.get('Calls')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('DefaultRuntime') is not None:
self.default_runtime = m.get('DefaultRuntime')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('EndTime') is not None:
self.end_time = m.get('EndTime')
if m.get('EntityName') is not None:
self.entity_name = m.get('EntityName')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('ExecuteDirectory') is not None:
self.execute_directory = m.get('ExecuteDirectory')
if m.get('ExecuteOptions') is not None:
temp_model = GetRunResponseBodyExecuteOptions()
self.execute_options = temp_model.from_map(m['ExecuteOptions'])
if m.get('Failures') is not None:
self.failures = m.get('Failures')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('Inputs') is not None:
self.inputs = m.get('Inputs')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('OutputFolder') is not None:
self.output_folder = m.get('OutputFolder')
if m.get('Outputs') is not None:
self.outputs = m.get('Outputs')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('RunId') is not None:
self.run_id = m.get('RunId')
if m.get('RunName') is not None:
self.run_name = m.get('RunName')
if m.get('Source') is not None:
self.source = m.get('Source')
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('SubmissionId') is not None:
self.submission_id = m.get('SubmissionId')
if m.get('Timing') is not None:
self.timing = m.get('Timing')
if m.get('User') is not None:
self.user = m.get('User')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class GetRunResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetRunResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetRunResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetRunResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetSubmissionRequest(TeaModel):
def __init__(self, submission_id=None, workspace=None):
self.submission_id = submission_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetSubmissionRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.submission_id is not None:
result['SubmissionId'] = self.submission_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('SubmissionId') is not None:
self.submission_id = m.get('SubmissionId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class GetSubmissionResponseBodySubmissionRunStats(TeaModel):
def __init__(self, aborted=None, aborting=None, failed=None, pending=None, running=None, submitted=None,
succeeded=None):
self.aborted = aborted # type: long
self.aborting = aborting # type: long
self.failed = failed # type: long
self.pending = pending # type: long
self.running = running # type: long
self.submitted = submitted # type: long
self.succeeded = succeeded # type: long
def validate(self):
pass
def to_map(self):
_map = super(GetSubmissionResponseBodySubmissionRunStats, self).to_map()
if _map is not None:
return _map
result = dict()
if self.aborted is not None:
result['Aborted'] = self.aborted
if self.aborting is not None:
result['Aborting'] = self.aborting
if self.failed is not None:
result['Failed'] = self.failed
if self.pending is not None:
result['Pending'] = self.pending
if self.running is not None:
result['Running'] = self.running
if self.submitted is not None:
result['Submitted'] = self.submitted
if self.succeeded is not None:
result['Succeeded'] = self.succeeded
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Aborted') is not None:
self.aborted = m.get('Aborted')
if m.get('Aborting') is not None:
self.aborting = m.get('Aborting')
if m.get('Failed') is not None:
self.failed = m.get('Failed')
if m.get('Pending') is not None:
self.pending = m.get('Pending')
if m.get('Running') is not None:
self.running = m.get('Running')
if m.get('Submitted') is not None:
self.submitted = m.get('Submitted')
if m.get('Succeeded') is not None:
self.succeeded = m.get('Succeeded')
return self
class GetSubmissionResponseBodySubmission(TeaModel):
def __init__(self, create_time=None, end_time=None, entity_type=None, run_stats=None, start_time=None,
status=None, submission_id=None, workspace=None):
self.create_time = create_time # type: str
self.end_time = end_time # type: str
self.entity_type = entity_type # type: str
self.run_stats = run_stats # type: GetSubmissionResponseBodySubmissionRunStats
self.start_time = start_time # type: str
self.status = status # type: str
self.submission_id = submission_id # type: str
self.workspace = workspace # type: str
def validate(self):
if self.run_stats:
self.run_stats.validate()
def to_map(self):
_map = super(GetSubmissionResponseBodySubmission, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.end_time is not None:
result['EndTime'] = self.end_time
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.run_stats is not None:
result['RunStats'] = self.run_stats.to_map()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.status is not None:
result['Status'] = self.status
if self.submission_id is not None:
result['SubmissionId'] = self.submission_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('EndTime') is not None:
self.end_time = m.get('EndTime')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('RunStats') is not None:
temp_model = GetSubmissionResponseBodySubmissionRunStats()
self.run_stats = temp_model.from_map(m['RunStats'])
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('SubmissionId') is not None:
self.submission_id = m.get('SubmissionId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class GetSubmissionResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None, submission=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
self.submission = submission # type: GetSubmissionResponseBodySubmission
def validate(self):
if self.submission:
self.submission.validate()
def to_map(self):
_map = super(GetSubmissionResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.submission is not None:
result['Submission'] = self.submission.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Submission') is not None:
temp_model = GetSubmissionResponseBodySubmission()
self.submission = temp_model.from_map(m['Submission'])
return self
class GetSubmissionResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetSubmissionResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetSubmissionResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetSubmissionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetTemplateRequest(TeaModel):
def __init__(self, template_name=None, workspace=None):
self.template_name = template_name # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetTemplateRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.workspace is not None:
result['Workspace'] = self.workspace
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('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class GetTemplateResponseBodyInputsExpression(TeaModel):
def __init__(self, help=None, required=None, step_order=None, task_name=None, variable_name=None,
variable_type=None, variable_value=None):
self.help = help # type: str
self.required = required # type: bool
self.step_order = step_order # type: long
self.task_name = task_name # type: str
self.variable_name = variable_name # type: str
self.variable_type = variable_type # type: str
self.variable_value = variable_value # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetTemplateResponseBodyInputsExpression, self).to_map()
if _map is not None:
return _map
result = dict()
if self.help is not None:
result['Help'] = self.help
if self.required is not None:
result['Required'] = self.required
if self.step_order is not None:
result['StepOrder'] = self.step_order
if self.task_name is not None:
result['TaskName'] = self.task_name
if self.variable_name is not None:
result['VariableName'] = self.variable_name
if self.variable_type is not None:
result['VariableType'] = self.variable_type
if self.variable_value is not None:
result['VariableValue'] = self.variable_value
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Help') is not None:
self.help = m.get('Help')
if m.get('Required') is not None:
self.required = m.get('Required')
if m.get('StepOrder') is not None:
self.step_order = m.get('StepOrder')
if m.get('TaskName') is not None:
self.task_name = m.get('TaskName')
if m.get('VariableName') is not None:
self.variable_name = m.get('VariableName')
if m.get('VariableType') is not None:
self.variable_type = m.get('VariableType')
if m.get('VariableValue') is not None:
self.variable_value = m.get('VariableValue')
return self
class GetTemplateResponseBodyOutputsExpression(TeaModel):
def __init__(self, help=None, required=None, step_order=None, task_name=None, variable_name=None,
variable_type=None, variable_value=None):
self.help = help # type: str
self.required = required # type: bool
self.step_order = step_order # type: long
self.task_name = task_name # type: str
self.variable_name = variable_name # type: str
self.variable_type = variable_type # type: str
self.variable_value = variable_value # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetTemplateResponseBodyOutputsExpression, self).to_map()
if _map is not None:
return _map
result = dict()
if self.help is not None:
result['Help'] = self.help
if self.required is not None:
result['Required'] = self.required
if self.step_order is not None:
result['StepOrder'] = self.step_order
if self.task_name is not None:
result['TaskName'] = self.task_name
if self.variable_name is not None:
result['VariableName'] = self.variable_name
if self.variable_type is not None:
result['VariableType'] = self.variable_type
if self.variable_value is not None:
result['VariableValue'] = self.variable_value
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Help') is not None:
self.help = m.get('Help')
if m.get('Required') is not None:
self.required = m.get('Required')
if m.get('StepOrder') is not None:
self.step_order = m.get('StepOrder')
if m.get('TaskName') is not None:
self.task_name = m.get('TaskName')
if m.get('VariableName') is not None:
self.variable_name = m.get('VariableName')
if m.get('VariableType') is not None:
self.variable_type = m.get('VariableType')
if m.get('VariableValue') is not None:
self.variable_value = m.get('VariableValue')
return self
class GetTemplateResponseBody(TeaModel):
def __init__(self, app_name=None, app_revision=None, create_time=None, description=None, host_id=None,
inputs_expression=None, labels=None, last_modified_time=None, outputs_expression=None, request_id=None,
revision_tag=None, root_entity=None, source=None, template_name=None, workspace=None):
self.app_name = app_name # type: str
self.app_revision = app_revision # type: str
self.create_time = create_time # type: str
self.description = description # type: str
self.host_id = host_id # type: str
self.inputs_expression = inputs_expression # type: list[GetTemplateResponseBodyInputsExpression]
self.labels = labels # type: dict[str, str]
self.last_modified_time = last_modified_time # type: str
self.outputs_expression = outputs_expression # type: list[GetTemplateResponseBodyOutputsExpression]
self.request_id = request_id # type: str
self.revision_tag = revision_tag # type: str
self.root_entity = root_entity # type: str
self.source = source # type: str
self.template_name = template_name # type: str
self.workspace = workspace # type: str
def validate(self):
if self.inputs_expression:
for k in self.inputs_expression:
if k:
k.validate()
if self.outputs_expression:
for k in self.outputs_expression:
if k:
k.validate()
def to_map(self):
_map = super(GetTemplateResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_revision is not None:
result['AppRevision'] = self.app_revision
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.description is not None:
result['Description'] = self.description
if self.host_id is not None:
result['HostId'] = self.host_id
result['InputsExpression'] = []
if self.inputs_expression is not None:
for k in self.inputs_expression:
result['InputsExpression'].append(k.to_map() if k else None)
if self.labels is not None:
result['Labels'] = self.labels
if self.last_modified_time is not None:
result['LastModifiedTime'] = self.last_modified_time
result['OutputsExpression'] = []
if self.outputs_expression is not None:
for k in self.outputs_expression:
result['OutputsExpression'].append(k.to_map() if k else None)
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.root_entity is not None:
result['RootEntity'] = self.root_entity
if self.source is not None:
result['Source'] = self.source
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppRevision') is not None:
self.app_revision = m.get('AppRevision')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
self.inputs_expression = []
if m.get('InputsExpression') is not None:
for k in m.get('InputsExpression'):
temp_model = GetTemplateResponseBodyInputsExpression()
self.inputs_expression.append(temp_model.from_map(k))
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('LastModifiedTime') is not None:
self.last_modified_time = m.get('LastModifiedTime')
self.outputs_expression = []
if m.get('OutputsExpression') is not None:
for k in m.get('OutputsExpression'):
temp_model = GetTemplateResponseBodyOutputsExpression()
self.outputs_expression.append(temp_model.from_map(k))
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('RootEntity') is not None:
self.root_entity = m.get('RootEntity')
if m.get('Source') is not None:
self.source = m.get('Source')
if m.get('TemplateName') is not None:
self.template_name = m.get('TemplateName')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class GetTemplateResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetTemplateResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetTemplateResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetTemplateResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetWorkspaceRequest(TeaModel):
def __init__(self, workspace=None):
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetWorkspaceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class GetWorkspaceResponseBody(TeaModel):
def __init__(self, bucket_name=None, create_time=None, description=None, host_id=None, job_lifecycle=None,
labels=None, last_modified_time=None, location=None, request_id=None, role=None, status=None, storage=None,
workspace=None):
self.bucket_name = bucket_name # type: str
self.create_time = create_time # type: str
self.description = description # type: str
self.host_id = host_id # type: str
self.job_lifecycle = job_lifecycle # type: int
self.labels = labels # type: dict[str, str]
self.last_modified_time = last_modified_time # type: str
self.location = location # type: str
self.request_id = request_id # type: str
self.role = role # type: str
self.status = status # type: str
self.storage = storage # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetWorkspaceResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.bucket_name is not None:
result['BucketName'] = self.bucket_name
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.description is not None:
result['Description'] = self.description
if self.host_id is not None:
result['HostId'] = self.host_id
if self.job_lifecycle is not None:
result['JobLifecycle'] = self.job_lifecycle
if self.labels is not None:
result['Labels'] = self.labels
if self.last_modified_time is not None:
result['LastModifiedTime'] = self.last_modified_time
if self.location is not None:
result['Location'] = self.location
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.role is not None:
result['Role'] = self.role
if self.status is not None:
result['Status'] = self.status
if self.storage is not None:
result['Storage'] = self.storage
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('BucketName') is not None:
self.bucket_name = m.get('BucketName')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('JobLifecycle') is not None:
self.job_lifecycle = m.get('JobLifecycle')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('LastModifiedTime') is not None:
self.last_modified_time = m.get('LastModifiedTime')
if m.get('Location') is not None:
self.location = m.get('Location')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Role') is not None:
self.role = m.get('Role')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Storage') is not None:
self.storage = m.get('Storage')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class GetWorkspaceResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: GetWorkspaceResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetWorkspaceResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetWorkspaceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ImportAppRequest(TeaModel):
def __init__(self, app_name=None, source=None, workspace=None):
self.app_name = app_name # type: str
self.source = source # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(ImportAppRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.source is not None:
result['Source'] = self.source
if self.workspace is not None:
result['Workspace'] = self.workspace
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('Source') is not None:
self.source = m.get('Source')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ImportAppResponseBody(TeaModel):
def __init__(self, app_name=None, host_id=None, region_id=None, request_id=None, workspace=None):
self.app_name = app_name # type: str
self.host_id = host_id # type: str
self.region_id = region_id # type: str
self.request_id = request_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(ImportAppResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.host_id is not None:
result['HostId'] = self.host_id
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.workspace is not None:
result['Workspace'] = self.workspace
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('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ImportAppResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ImportAppResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ImportAppResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ImportAppResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class InstallGlobalAppRequest(TeaModel):
def __init__(self, app_name=None, installed_app_name=None, namespace_name=None, source=None, workspace=None):
self.app_name = app_name # type: str
self.installed_app_name = installed_app_name # type: str
self.namespace_name = namespace_name # type: str
self.source = source # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(InstallGlobalAppRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.installed_app_name is not None:
result['InstalledAppName'] = self.installed_app_name
if self.namespace_name is not None:
result['NamespaceName'] = self.namespace_name
if self.source is not None:
result['Source'] = self.source
if self.workspace is not None:
result['Workspace'] = self.workspace
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('InstalledAppName') is not None:
self.installed_app_name = m.get('InstalledAppName')
if m.get('NamespaceName') is not None:
self.namespace_name = m.get('NamespaceName')
if m.get('Source') is not None:
self.source = m.get('Source')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class InstallGlobalAppResponseBody(TeaModel):
def __init__(self, host_id=None, installed_app_name=None, region_id=None, request_id=None, workspace=None):
self.host_id = host_id # type: str
self.installed_app_name = installed_app_name # type: str
self.region_id = region_id # type: str
self.request_id = request_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(InstallGlobalAppResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.installed_app_name is not None:
result['InstalledAppName'] = self.installed_app_name
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('InstalledAppName') is not None:
self.installed_app_name = m.get('InstalledAppName')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class InstallGlobalAppResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: InstallGlobalAppResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(InstallGlobalAppResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = InstallGlobalAppResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListAppsRequest(TeaModel):
def __init__(self, app_type=None, is_reversed=None, label_selector=None, language=None, max_results=None,
next_token=None, order_by=None, scope=None, search=None, workspace=None):
self.app_type = app_type # type: str
self.is_reversed = is_reversed # type: bool
self.label_selector = label_selector # type: str
self.language = language # type: str
self.max_results = max_results # type: int
# Next Token
self.next_token = next_token # type: str
self.order_by = order_by # type: str
self.scope = scope # type: str
self.search = search # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListAppsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_type is not None:
result['AppType'] = self.app_type
if self.is_reversed is not None:
result['IsReversed'] = self.is_reversed
if self.label_selector is not None:
result['LabelSelector'] = self.label_selector
if self.language is not None:
result['Language'] = self.language
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.order_by is not None:
result['OrderBy'] = self.order_by
if self.scope is not None:
result['Scope'] = self.scope
if self.search is not None:
result['Search'] = self.search
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppType') is not None:
self.app_type = m.get('AppType')
if m.get('IsReversed') is not None:
self.is_reversed = m.get('IsReversed')
if m.get('LabelSelector') is not None:
self.label_selector = m.get('LabelSelector')
if m.get('Language') is not None:
self.language = m.get('Language')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('OrderBy') is not None:
self.order_by = m.get('OrderBy')
if m.get('Scope') is not None:
self.scope = m.get('Scope')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ListAppsResponseBodyApps(TeaModel):
def __init__(self, app_default_version=None, app_name=None, app_type=None, create_time=None, description=None,
labels=None, language=None, scope=None, source=None, workspace=None):
self.app_default_version = app_default_version # type: str
self.app_name = app_name # type: str
self.app_type = app_type # type: str
self.create_time = create_time # type: str
self.description = description # type: str
self.labels = labels # type: dict[str, str]
self.language = language # type: str
self.scope = scope # type: str
self.source = source # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListAppsResponseBodyApps, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_default_version is not None:
result['AppDefaultVersion'] = self.app_default_version
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_type is not None:
result['AppType'] = self.app_type
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.description is not None:
result['Description'] = self.description
if self.labels is not None:
result['Labels'] = self.labels
if self.language is not None:
result['Language'] = self.language
if self.scope is not None:
result['Scope'] = self.scope
if self.source is not None:
result['Source'] = self.source
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppDefaultVersion') is not None:
self.app_default_version = m.get('AppDefaultVersion')
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('AppType') is not None:
self.app_type = m.get('AppType')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('Language') is not None:
self.language = m.get('Language')
if m.get('Scope') is not None:
self.scope = m.get('Scope')
if m.get('Source') is not None:
self.source = m.get('Source')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ListAppsResponseBody(TeaModel):
def __init__(self, apps=None, host_id=None, max_results=None, next_token=None, request_id=None, total_count=None):
self.apps = apps # type: list[ListAppsResponseBodyApps]
self.host_id = host_id # type: str
self.max_results = max_results # type: int
# Next Token
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.apps:
for k in self.apps:
if k:
k.validate()
def to_map(self):
_map = super(ListAppsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
result['Apps'] = []
if self.apps is not None:
for k in self.apps:
result['Apps'].append(k.to_map() if k else None)
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
self.apps = []
if m.get('Apps') is not None:
for k in m.get('Apps'):
temp_model = ListAppsResponseBodyApps()
self.apps.append(temp_model.from_map(k))
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListAppsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListAppsResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListAppsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListAppsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListAuthorizedSoftwareRequest(TeaModel):
def __init__(self, is_reversed=None, location=None, max_results=None, next_token=None, order_by=None,
search=None):
self.is_reversed = is_reversed # type: bool
self.location = location # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.order_by = order_by # type: str
self.search = search # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListAuthorizedSoftwareRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.is_reversed is not None:
result['IsReversed'] = self.is_reversed
if self.location is not None:
result['Location'] = self.location
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.order_by is not None:
result['OrderBy'] = self.order_by
if self.search is not None:
result['Search'] = self.search
return result
def from_map(self, m=None):
m = m or dict()
if m.get('IsReversed') is not None:
self.is_reversed = m.get('IsReversed')
if m.get('Location') is not None:
self.location = m.get('Location')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('OrderBy') is not None:
self.order_by = m.get('OrderBy')
if m.get('Search') is not None:
self.search = m.get('Search')
return self
class ListAuthorizedSoftwareResponseBodySoftwares(TeaModel):
def __init__(self, help_link=None, last_modified=None, locations=None, promotion=None,
software_default_version=None, software_description=None, software_icon=None, software_license_fee=None,
software_long_name=None, software_name=None, software_versions=None):
self.help_link = help_link # type: str
self.last_modified = last_modified # type: str
self.locations = locations # type: list[str]
self.promotion = promotion # type: str
self.software_default_version = software_default_version # type: str
self.software_description = software_description # type: str
self.software_icon = software_icon # type: str
self.software_license_fee = software_license_fee # type: float
self.software_long_name = software_long_name # type: str
self.software_name = software_name # type: str
self.software_versions = software_versions # type: list[str]
def validate(self):
pass
def to_map(self):
_map = super(ListAuthorizedSoftwareResponseBodySoftwares, self).to_map()
if _map is not None:
return _map
result = dict()
if self.help_link is not None:
result['HelpLink'] = self.help_link
if self.last_modified is not None:
result['LastModified'] = self.last_modified
if self.locations is not None:
result['Locations'] = self.locations
if self.promotion is not None:
result['Promotion'] = self.promotion
if self.software_default_version is not None:
result['SoftwareDefaultVersion'] = self.software_default_version
if self.software_description is not None:
result['SoftwareDescription'] = self.software_description
if self.software_icon is not None:
result['SoftwareIcon'] = self.software_icon
if self.software_license_fee is not None:
result['SoftwareLicenseFee'] = self.software_license_fee
if self.software_long_name is not None:
result['SoftwareLongName'] = self.software_long_name
if self.software_name is not None:
result['SoftwareName'] = self.software_name
if self.software_versions is not None:
result['SoftwareVersions'] = self.software_versions
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HelpLink') is not None:
self.help_link = m.get('HelpLink')
if m.get('LastModified') is not None:
self.last_modified = m.get('LastModified')
if m.get('Locations') is not None:
self.locations = m.get('Locations')
if m.get('Promotion') is not None:
self.promotion = m.get('Promotion')
if m.get('SoftwareDefaultVersion') is not None:
self.software_default_version = m.get('SoftwareDefaultVersion')
if m.get('SoftwareDescription') is not None:
self.software_description = m.get('SoftwareDescription')
if m.get('SoftwareIcon') is not None:
self.software_icon = m.get('SoftwareIcon')
if m.get('SoftwareLicenseFee') is not None:
self.software_license_fee = m.get('SoftwareLicenseFee')
if m.get('SoftwareLongName') is not None:
self.software_long_name = m.get('SoftwareLongName')
if m.get('SoftwareName') is not None:
self.software_name = m.get('SoftwareName')
if m.get('SoftwareVersions') is not None:
self.software_versions = m.get('SoftwareVersions')
return self
class ListAuthorizedSoftwareResponseBody(TeaModel):
def __init__(self, host_id=None, max_results=None, next_token=None, request_id=None, softwares=None,
total_count=None):
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.softwares = softwares # type: list[ListAuthorizedSoftwareResponseBodySoftwares]
self.total_count = total_count # type: int
def validate(self):
if self.softwares:
for k in self.softwares:
if k:
k.validate()
def to_map(self):
_map = super(ListAuthorizedSoftwareResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
result['Softwares'] = []
if self.softwares is not None:
for k in self.softwares:
result['Softwares'].append(k.to_map() if k else None)
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
self.softwares = []
if m.get('Softwares') is not None:
for k in m.get('Softwares'):
temp_model = ListAuthorizedSoftwareResponseBodySoftwares()
self.softwares.append(temp_model.from_map(k))
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListAuthorizedSoftwareResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListAuthorizedSoftwareResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListAuthorizedSoftwareResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListAuthorizedSoftwareResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListContainerImagesRequest(TeaModel):
def __init__(self, location=None, max_results=None, next_token=None):
self.location = location # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListContainerImagesRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.location is not None:
result['Location'] = self.location
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Location') is not None:
self.location = m.get('Location')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
return self
class ListContainerImagesResponseBodyContainerImages(TeaModel):
def __init__(self, container_image_description=None, container_image_name=None,
container_image_namespace=None, container_image_versions=None, container_registry=None, last_modified=None, location=None):
self.container_image_description = container_image_description # type: str
self.container_image_name = container_image_name # type: str
self.container_image_namespace = container_image_namespace # type: str
self.container_image_versions = container_image_versions # type: list[str]
self.container_registry = container_registry # type: str
self.last_modified = last_modified # type: str
self.location = location # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListContainerImagesResponseBodyContainerImages, self).to_map()
if _map is not None:
return _map
result = dict()
if self.container_image_description is not None:
result['ContainerImageDescription'] = self.container_image_description
if self.container_image_name is not None:
result['ContainerImageName'] = self.container_image_name
if self.container_image_namespace is not None:
result['ContainerImageNamespace'] = self.container_image_namespace
if self.container_image_versions is not None:
result['ContainerImageVersions'] = self.container_image_versions
if self.container_registry is not None:
result['ContainerRegistry'] = self.container_registry
if self.last_modified is not None:
result['LastModified'] = self.last_modified
if self.location is not None:
result['Location'] = self.location
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ContainerImageDescription') is not None:
self.container_image_description = m.get('ContainerImageDescription')
if m.get('ContainerImageName') is not None:
self.container_image_name = m.get('ContainerImageName')
if m.get('ContainerImageNamespace') is not None:
self.container_image_namespace = m.get('ContainerImageNamespace')
if m.get('ContainerImageVersions') is not None:
self.container_image_versions = m.get('ContainerImageVersions')
if m.get('ContainerRegistry') is not None:
self.container_registry = m.get('ContainerRegistry')
if m.get('LastModified') is not None:
self.last_modified = m.get('LastModified')
if m.get('Location') is not None:
self.location = m.get('Location')
return self
class ListContainerImagesResponseBody(TeaModel):
def __init__(self, container_images=None, host_id=None, max_results=None, next_token=None, request_id=None,
total_count=None):
self.container_images = container_images # type: list[ListContainerImagesResponseBodyContainerImages]
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.container_images:
for k in self.container_images:
if k:
k.validate()
def to_map(self):
_map = super(ListContainerImagesResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
result['ContainerImages'] = []
if self.container_images is not None:
for k in self.container_images:
result['ContainerImages'].append(k.to_map() if k else None)
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
self.container_images = []
if m.get('ContainerImages') is not None:
for k in m.get('ContainerImages'):
temp_model = ListContainerImagesResponseBodyContainerImages()
self.container_images.append(temp_model.from_map(k))
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListContainerImagesResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListContainerImagesResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListContainerImagesResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListContainerImagesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListEntitiesRequest(TeaModel):
def __init__(self, is_reversed=None, max_results=None, next_token=None, order_by=None, workspace=None):
self.is_reversed = is_reversed # type: bool
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.order_by = order_by # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListEntitiesRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.is_reversed is not None:
result['IsReversed'] = self.is_reversed
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.order_by is not None:
result['OrderBy'] = self.order_by
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('IsReversed') is not None:
self.is_reversed = m.get('IsReversed')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('OrderBy') is not None:
self.order_by = m.get('OrderBy')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ListEntitiesResponseBodyEntities(TeaModel):
def __init__(self, entity_type=None):
self.entity_type = entity_type # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListEntitiesResponseBodyEntities, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_type is not None:
result['EntityType'] = self.entity_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
return self
class ListEntitiesResponseBody(TeaModel):
def __init__(self, entities=None, host_id=None, max_results=None, next_token=None, request_id=None,
total_count=None):
self.entities = entities # type: list[ListEntitiesResponseBodyEntities]
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.entities:
for k in self.entities:
if k:
k.validate()
def to_map(self):
_map = super(ListEntitiesResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
result['Entities'] = []
if self.entities is not None:
for k in self.entities:
result['Entities'].append(k.to_map() if k else None)
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
self.entities = []
if m.get('Entities') is not None:
for k in m.get('Entities'):
temp_model = ListEntitiesResponseBodyEntities()
self.entities.append(temp_model.from_map(k))
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListEntitiesResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListEntitiesResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListEntitiesResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListEntitiesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListEntityItemsRequest(TeaModel):
def __init__(self, entity_type=None, is_reversed=None, max_results=None, next_token=None, order_by=None,
search=None, workspace=None):
self.entity_type = entity_type # type: str
self.is_reversed = is_reversed # type: bool
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.order_by = order_by # type: str
self.search = search # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListEntityItemsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.is_reversed is not None:
result['IsReversed'] = self.is_reversed
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.order_by is not None:
result['OrderBy'] = self.order_by
if self.search is not None:
result['Search'] = self.search
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('IsReversed') is not None:
self.is_reversed = m.get('IsReversed')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('OrderBy') is not None:
self.order_by = m.get('OrderBy')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ListEntityItemsResponseBodyEntityItems(TeaModel):
def __init__(self, entity_data=None, entity_name=None):
self.entity_data = entity_data # type: dict[str, str]
self.entity_name = entity_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListEntityItemsResponseBodyEntityItems, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_data is not None:
result['EntityData'] = self.entity_data
if self.entity_name is not None:
result['EntityName'] = self.entity_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityData') is not None:
self.entity_data = m.get('EntityData')
if m.get('EntityName') is not None:
self.entity_name = m.get('EntityName')
return self
class ListEntityItemsResponseBody(TeaModel):
def __init__(self, entity_items=None, host_id=None, max_results=None, next_token=None, request_id=None,
total_count=None):
self.entity_items = entity_items # type: list[ListEntityItemsResponseBodyEntityItems]
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.entity_items:
for k in self.entity_items:
if k:
k.validate()
def to_map(self):
_map = super(ListEntityItemsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
result['EntityItems'] = []
if self.entity_items is not None:
for k in self.entity_items:
result['EntityItems'].append(k.to_map() if k else None)
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
self.entity_items = []
if m.get('EntityItems') is not None:
for k in m.get('EntityItems'):
temp_model = ListEntityItemsResponseBodyEntityItems()
self.entity_items.append(temp_model.from_map(k))
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListEntityItemsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListEntityItemsResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListEntityItemsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListEntityItemsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListGlobalAppsRequest(TeaModel):
def __init__(self, app_scope=None, category=None, is_reversed=None, location=None, max_results=None,
next_token=None, order_by=None, search=None, toolkit=None):
self.app_scope = app_scope # type: str
self.category = category # type: str
self.is_reversed = is_reversed # type: bool
self.location = location # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.order_by = order_by # type: str
self.search = search # type: str
self.toolkit = toolkit # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListGlobalAppsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_scope is not None:
result['AppScope'] = self.app_scope
if self.category is not None:
result['Category'] = self.category
if self.is_reversed is not None:
result['IsReversed'] = self.is_reversed
if self.location is not None:
result['Location'] = self.location
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.order_by is not None:
result['OrderBy'] = self.order_by
if self.search is not None:
result['Search'] = self.search
if self.toolkit is not None:
result['Toolkit'] = self.toolkit
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppScope') is not None:
self.app_scope = m.get('AppScope')
if m.get('Category') is not None:
self.category = m.get('Category')
if m.get('IsReversed') is not None:
self.is_reversed = m.get('IsReversed')
if m.get('Location') is not None:
self.location = m.get('Location')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('OrderBy') is not None:
self.order_by = m.get('OrderBy')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('Toolkit') is not None:
self.toolkit = m.get('Toolkit')
return self
class ListGlobalAppsResponseBodyGlobalApps(TeaModel):
def __init__(self, app_default_version=None, app_description=None, app_fee=None, app_name=None, app_scope=None,
categories=None, last_modified=None, locations=None, namespace_name=None, pinned=None, toolkit=None):
self.app_default_version = app_default_version # type: str
self.app_description = app_description # type: str
self.app_fee = app_fee # type: str
self.app_name = app_name # type: str
self.app_scope = app_scope # type: str
self.categories = categories # type: list[str]
self.last_modified = last_modified # type: str
self.locations = locations # type: list[str]
self.namespace_name = namespace_name # type: str
self.pinned = pinned # type: bool
self.toolkit = toolkit # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListGlobalAppsResponseBodyGlobalApps, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_default_version is not None:
result['AppDefaultVersion'] = self.app_default_version
if self.app_description is not None:
result['AppDescription'] = self.app_description
if self.app_fee is not None:
result['AppFee'] = self.app_fee
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_scope is not None:
result['AppScope'] = self.app_scope
if self.categories is not None:
result['Categories'] = self.categories
if self.last_modified is not None:
result['LastModified'] = self.last_modified
if self.locations is not None:
result['Locations'] = self.locations
if self.namespace_name is not None:
result['NamespaceName'] = self.namespace_name
if self.pinned is not None:
result['Pinned'] = self.pinned
if self.toolkit is not None:
result['Toolkit'] = self.toolkit
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AppDefaultVersion') is not None:
self.app_default_version = m.get('AppDefaultVersion')
if m.get('AppDescription') is not None:
self.app_description = m.get('AppDescription')
if m.get('AppFee') is not None:
self.app_fee = m.get('AppFee')
if m.get('AppName') is not None:
self.app_name = m.get('AppName')
if m.get('AppScope') is not None:
self.app_scope = m.get('AppScope')
if m.get('Categories') is not None:
self.categories = m.get('Categories')
if m.get('LastModified') is not None:
self.last_modified = m.get('LastModified')
if m.get('Locations') is not None:
self.locations = m.get('Locations')
if m.get('NamespaceName') is not None:
self.namespace_name = m.get('NamespaceName')
if m.get('Pinned') is not None:
self.pinned = m.get('Pinned')
if m.get('Toolkit') is not None:
self.toolkit = m.get('Toolkit')
return self
class ListGlobalAppsResponseBody(TeaModel):
def __init__(self, global_apps=None, host_id=None, max_results=None, next_token=None, request_id=None,
total_count=None):
self.global_apps = global_apps # type: list[ListGlobalAppsResponseBodyGlobalApps]
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.total_count = total_count # type: long
def validate(self):
if self.global_apps:
for k in self.global_apps:
if k:
k.validate()
def to_map(self):
_map = super(ListGlobalAppsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
result['GlobalApps'] = []
if self.global_apps is not None:
for k in self.global_apps:
result['GlobalApps'].append(k.to_map() if k else None)
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
self.global_apps = []
if m.get('GlobalApps') is not None:
for k in m.get('GlobalApps'):
temp_model = ListGlobalAppsResponseBodyGlobalApps()
self.global_apps.append(temp_model.from_map(k))
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListGlobalAppsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListGlobalAppsResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListGlobalAppsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListGlobalAppsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListPublicDatasetRequest(TeaModel):
def __init__(self, is_reversed=None, max_results=None, next_token=None, order_by=None, search=None, tag=None):
self.is_reversed = is_reversed # type: bool
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.order_by = order_by # type: str
self.search = search # type: str
self.tag = tag # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListPublicDatasetRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.is_reversed is not None:
result['IsReversed'] = self.is_reversed
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.order_by is not None:
result['OrderBy'] = self.order_by
if self.search is not None:
result['Search'] = self.search
if self.tag is not None:
result['Tag'] = self.tag
return result
def from_map(self, m=None):
m = m or dict()
if m.get('IsReversed') is not None:
self.is_reversed = m.get('IsReversed')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('OrderBy') is not None:
self.order_by = m.get('OrderBy')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('Tag') is not None:
self.tag = m.get('Tag')
return self
class ListPublicDatasetResponseBodyDatasets(TeaModel):
def __init__(self, about=None, access_requirements=None, copyright=None, dataset_description=None,
dataset_id=None, dataset_name=None, last_modified=None, locations=None, tags=None, update_frequency=None):
self.about = about # type: str
self.access_requirements = access_requirements # type: str
self.copyright = copyright # type: str
self.dataset_description = dataset_description # type: str
self.dataset_id = dataset_id # type: str
self.dataset_name = dataset_name # type: str
self.last_modified = last_modified # type: str
self.locations = locations # type: list[str]
self.tags = tags # type: list[str]
self.update_frequency = update_frequency # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListPublicDatasetResponseBodyDatasets, self).to_map()
if _map is not None:
return _map
result = dict()
if self.about is not None:
result['About'] = self.about
if self.access_requirements is not None:
result['AccessRequirements'] = self.access_requirements
if self.copyright is not None:
result['Copyright'] = self.copyright
if self.dataset_description is not None:
result['DatasetDescription'] = self.dataset_description
if self.dataset_id is not None:
result['DatasetId'] = self.dataset_id
if self.dataset_name is not None:
result['DatasetName'] = self.dataset_name
if self.last_modified is not None:
result['LastModified'] = self.last_modified
if self.locations is not None:
result['Locations'] = self.locations
if self.tags is not None:
result['Tags'] = self.tags
if self.update_frequency is not None:
result['UpdateFrequency'] = self.update_frequency
return result
def from_map(self, m=None):
m = m or dict()
if m.get('About') is not None:
self.about = m.get('About')
if m.get('AccessRequirements') is not None:
self.access_requirements = m.get('AccessRequirements')
if m.get('Copyright') is not None:
self.copyright = m.get('Copyright')
if m.get('DatasetDescription') is not None:
self.dataset_description = m.get('DatasetDescription')
if m.get('DatasetId') is not None:
self.dataset_id = m.get('DatasetId')
if m.get('DatasetName') is not None:
self.dataset_name = m.get('DatasetName')
if m.get('LastModified') is not None:
self.last_modified = m.get('LastModified')
if m.get('Locations') is not None:
self.locations = m.get('Locations')
if m.get('Tags') is not None:
self.tags = m.get('Tags')
if m.get('UpdateFrequency') is not None:
self.update_frequency = m.get('UpdateFrequency')
return self
class ListPublicDatasetResponseBody(TeaModel):
def __init__(self, datasets=None, host_id=None, max_results=None, next_token=None, request_id=None,
total_count=None):
self.datasets = datasets # type: list[ListPublicDatasetResponseBodyDatasets]
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.datasets:
for k in self.datasets:
if k:
k.validate()
def to_map(self):
_map = super(ListPublicDatasetResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
result['Datasets'] = []
if self.datasets is not None:
for k in self.datasets:
result['Datasets'].append(k.to_map() if k else None)
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
self.datasets = []
if m.get('Datasets') is not None:
for k in m.get('Datasets'):
temp_model = ListPublicDatasetResponseBodyDatasets()
self.datasets.append(temp_model.from_map(k))
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListPublicDatasetResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListPublicDatasetResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListPublicDatasetResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListPublicDatasetResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListPublicDatasetEntitiesRequest(TeaModel):
def __init__(self, dataset_name=None, is_reversed=None, location=None, max_results=None, next_token=None,
order_by=None):
self.dataset_name = dataset_name # type: str
self.is_reversed = is_reversed # type: bool
self.location = location # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.order_by = order_by # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListPublicDatasetEntitiesRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.dataset_name is not None:
result['DatasetName'] = self.dataset_name
if self.is_reversed is not None:
result['IsReversed'] = self.is_reversed
if self.location is not None:
result['Location'] = self.location
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.order_by is not None:
result['OrderBy'] = self.order_by
return result
def from_map(self, m=None):
m = m or dict()
if m.get('DatasetName') is not None:
self.dataset_name = m.get('DatasetName')
if m.get('IsReversed') is not None:
self.is_reversed = m.get('IsReversed')
if m.get('Location') is not None:
self.location = m.get('Location')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('OrderBy') is not None:
self.order_by = m.get('OrderBy')
return self
class ListPublicDatasetEntitiesResponseBodyEntities(TeaModel):
def __init__(self, entity_type=None):
self.entity_type = entity_type # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListPublicDatasetEntitiesResponseBodyEntities, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_type is not None:
result['EntityType'] = self.entity_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
return self
class ListPublicDatasetEntitiesResponseBody(TeaModel):
def __init__(self, dataset_name=None, entities=None, host_id=None, max_results=None, next_token=None,
request_id=None, total_count=None):
self.dataset_name = dataset_name # type: str
self.entities = entities # type: list[ListPublicDatasetEntitiesResponseBodyEntities]
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.entities:
for k in self.entities:
if k:
k.validate()
def to_map(self):
_map = super(ListPublicDatasetEntitiesResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.dataset_name is not None:
result['DatasetName'] = self.dataset_name
result['Entities'] = []
if self.entities is not None:
for k in self.entities:
result['Entities'].append(k.to_map() if k else None)
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('DatasetName') is not None:
self.dataset_name = m.get('DatasetName')
self.entities = []
if m.get('Entities') is not None:
for k in m.get('Entities'):
temp_model = ListPublicDatasetEntitiesResponseBodyEntities()
self.entities.append(temp_model.from_map(k))
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListPublicDatasetEntitiesResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListPublicDatasetEntitiesResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListPublicDatasetEntitiesResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListPublicDatasetEntitiesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListPublicDatasetEntityItemsRequest(TeaModel):
def __init__(self, dataset_name=None, entity_type=None, is_reversed=None, location=None, max_results=None,
next_token=None, order_by=None, search=None):
self.dataset_name = dataset_name # type: str
self.entity_type = entity_type # type: str
self.is_reversed = is_reversed # type: bool
self.location = location # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.order_by = order_by # type: str
self.search = search # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListPublicDatasetEntityItemsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.dataset_name is not None:
result['DatasetName'] = self.dataset_name
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.is_reversed is not None:
result['IsReversed'] = self.is_reversed
if self.location is not None:
result['Location'] = self.location
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.order_by is not None:
result['OrderBy'] = self.order_by
if self.search is not None:
result['Search'] = self.search
return result
def from_map(self, m=None):
m = m or dict()
if m.get('DatasetName') is not None:
self.dataset_name = m.get('DatasetName')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('IsReversed') is not None:
self.is_reversed = m.get('IsReversed')
if m.get('Location') is not None:
self.location = m.get('Location')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('OrderBy') is not None:
self.order_by = m.get('OrderBy')
if m.get('Search') is not None:
self.search = m.get('Search')
return self
class ListPublicDatasetEntityItemsResponseBodyEntityItems(TeaModel):
def __init__(self, entity_data=None, entity_name=None):
self.entity_data = entity_data # type: dict[str, str]
self.entity_name = entity_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListPublicDatasetEntityItemsResponseBodyEntityItems, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_data is not None:
result['EntityData'] = self.entity_data
if self.entity_name is not None:
result['EntityName'] = self.entity_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityData') is not None:
self.entity_data = m.get('EntityData')
if m.get('EntityName') is not None:
self.entity_name = m.get('EntityName')
return self
class ListPublicDatasetEntityItemsResponseBody(TeaModel):
def __init__(self, dataset_name=None, entity_items=None, host_id=None, max_results=None, next_token=None,
request_id=None, total_count=None):
self.dataset_name = dataset_name # type: str
self.entity_items = entity_items # type: list[ListPublicDatasetEntityItemsResponseBodyEntityItems]
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.total_count = total_count # type: int
def validate(self):
if self.entity_items:
for k in self.entity_items:
if k:
k.validate()
def to_map(self):
_map = super(ListPublicDatasetEntityItemsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.dataset_name is not None:
result['DatasetName'] = self.dataset_name
result['EntityItems'] = []
if self.entity_items is not None:
for k in self.entity_items:
result['EntityItems'].append(k.to_map() if k else None)
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('DatasetName') is not None:
self.dataset_name = m.get('DatasetName')
self.entity_items = []
if m.get('EntityItems') is not None:
for k in m.get('EntityItems'):
temp_model = ListPublicDatasetEntityItemsResponseBodyEntityItems()
self.entity_items.append(temp_model.from_map(k))
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListPublicDatasetEntityItemsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListPublicDatasetEntityItemsResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListPublicDatasetEntityItemsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListPublicDatasetEntityItemsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListPublicDatasetTagsRequest(TeaModel):
def __init__(self, is_reversed=None, max_results=None, next_token=None, order_by=None, search=None):
self.is_reversed = is_reversed # type: bool
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.order_by = order_by # type: str
self.search = search # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListPublicDatasetTagsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.is_reversed is not None:
result['IsReversed'] = self.is_reversed
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.order_by is not None:
result['OrderBy'] = self.order_by
if self.search is not None:
result['Search'] = self.search
return result
def from_map(self, m=None):
m = m or dict()
if m.get('IsReversed') is not None:
self.is_reversed = m.get('IsReversed')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('OrderBy') is not None:
self.order_by = m.get('OrderBy')
if m.get('Search') is not None:
self.search = m.get('Search')
return self
class ListPublicDatasetTagsResponseBody(TeaModel):
def __init__(self, host_id=None, max_results=None, next_token=None, request_id=None, tags=None, total_count=None):
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.tags = tags # type: list[str]
self.total_count = total_count # type: int
def validate(self):
pass
def to_map(self):
_map = super(ListPublicDatasetTagsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.tags is not None:
result['Tags'] = self.tags
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Tags') is not None:
self.tags = m.get('Tags')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListPublicDatasetTagsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListPublicDatasetTagsResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListPublicDatasetTagsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListPublicDatasetTagsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListRegionsResponseBodyRegions(TeaModel):
def __init__(self, local_name=None, region_endpoint=None, region_id=None):
self.local_name = local_name # type: str
self.region_endpoint = region_endpoint # type: str
self.region_id = region_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListRegionsResponseBodyRegions, self).to_map()
if _map is not None:
return _map
result = dict()
if self.local_name is not None:
result['LocalName'] = self.local_name
if self.region_endpoint is not None:
result['RegionEndpoint'] = self.region_endpoint
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('LocalName') is not None:
self.local_name = m.get('LocalName')
if m.get('RegionEndpoint') is not None:
self.region_endpoint = m.get('RegionEndpoint')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class ListRegionsResponseBody(TeaModel):
def __init__(self, host_id=None, regions=None, request_id=None):
self.host_id = host_id # type: str
self.regions = regions # type: list[ListRegionsResponseBodyRegions]
self.request_id = request_id # type: str
def validate(self):
if self.regions:
for k in self.regions:
if k:
k.validate()
def to_map(self):
_map = super(ListRegionsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
result['Regions'] = []
if self.regions is not None:
for k in self.regions:
result['Regions'].append(k.to_map() if k else None)
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
self.regions = []
if m.get('Regions') is not None:
for k in m.get('Regions'):
temp_model = ListRegionsResponseBodyRegions()
self.regions.append(temp_model.from_map(k))
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ListRegionsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListRegionsResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListRegionsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListRegionsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListRunsRequest(TeaModel):
def __init__(self, app_name=None, app_revision=None, entity_name=None, entity_type=None, get_total=None,
is_reversed=None, label_selector=None, max_results=None, next_token=None, order_by=None, search=None,
status=None, submission_id=None, workspace=None):
self.app_name = app_name # type: str
self.app_revision = app_revision # type: str
self.entity_name = entity_name # type: str
self.entity_type = entity_type # type: str
self.get_total = get_total # type: bool
self.is_reversed = is_reversed # type: bool
self.label_selector = label_selector # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.order_by = order_by # type: str
self.search = search # type: str
self.status = status # type: str
self.submission_id = submission_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListRunsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_revision is not None:
result['AppRevision'] = self.app_revision
if self.entity_name is not None:
result['EntityName'] = self.entity_name
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.get_total is not None:
result['GetTotal'] = self.get_total
if self.is_reversed is not None:
result['IsReversed'] = self.is_reversed
if self.label_selector is not None:
result['LabelSelector'] = self.label_selector
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.order_by is not None:
result['OrderBy'] = self.order_by
if self.search is not None:
result['Search'] = self.search
if self.status is not None:
result['Status'] = self.status
if self.submission_id is not None:
result['SubmissionId'] = self.submission_id
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppRevision') is not None:
self.app_revision = m.get('AppRevision')
if m.get('EntityName') is not None:
self.entity_name = m.get('EntityName')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('GetTotal') is not None:
self.get_total = m.get('GetTotal')
if m.get('IsReversed') is not None:
self.is_reversed = m.get('IsReversed')
if m.get('LabelSelector') is not None:
self.label_selector = m.get('LabelSelector')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('OrderBy') is not None:
self.order_by = m.get('OrderBy')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('SubmissionId') is not None:
self.submission_id = m.get('SubmissionId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ListRunsResponseBodyRunsExecuteOptions(TeaModel):
def __init__(self, call_caching=None, delete_intermediate_results=None, failure_mode=None,
use_relative_output_paths=None):
self.call_caching = call_caching # type: bool
self.delete_intermediate_results = delete_intermediate_results # type: bool
self.failure_mode = failure_mode # type: str
self.use_relative_output_paths = use_relative_output_paths # type: bool
def validate(self):
pass
def to_map(self):
_map = super(ListRunsResponseBodyRunsExecuteOptions, self).to_map()
if _map is not None:
return _map
result = dict()
if self.call_caching is not None:
result['CallCaching'] = self.call_caching
if self.delete_intermediate_results is not None:
result['DeleteIntermediateResults'] = self.delete_intermediate_results
if self.failure_mode is not None:
result['FailureMode'] = self.failure_mode
if self.use_relative_output_paths is not None:
result['UseRelativeOutputPaths'] = self.use_relative_output_paths
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CallCaching') is not None:
self.call_caching = m.get('CallCaching')
if m.get('DeleteIntermediateResults') is not None:
self.delete_intermediate_results = m.get('DeleteIntermediateResults')
if m.get('FailureMode') is not None:
self.failure_mode = m.get('FailureMode')
if m.get('UseRelativeOutputPaths') is not None:
self.use_relative_output_paths = m.get('UseRelativeOutputPaths')
return self
class ListRunsResponseBodyRuns(TeaModel):
def __init__(self, app_name=None, app_revision=None, create_time=None, default_runtime=None, end_time=None,
entity_name=None, entity_type=None, execute_directory=None, execute_options=None, inputs=None, labels=None,
region_id=None, run_id=None, run_name=None, source=None, start_time=None, status=None, submission_id=None,
workspace=None):
self.app_name = app_name # type: str
self.app_revision = app_revision # type: str
self.create_time = create_time # type: str
self.default_runtime = default_runtime # type: str
self.end_time = end_time # type: str
self.entity_name = entity_name # type: str
self.entity_type = entity_type # type: str
self.execute_directory = execute_directory # type: str
self.execute_options = execute_options # type: ListRunsResponseBodyRunsExecuteOptions
self.inputs = inputs # type: str
self.labels = labels # type: dict[str, str]
self.region_id = region_id # type: str
self.run_id = run_id # type: str
self.run_name = run_name # type: str
self.source = source # type: str
self.start_time = start_time # type: str
self.status = status # type: str
self.submission_id = submission_id # type: str
self.workspace = workspace # type: str
def validate(self):
if self.execute_options:
self.execute_options.validate()
def to_map(self):
_map = super(ListRunsResponseBodyRuns, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_revision is not None:
result['AppRevision'] = self.app_revision
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.default_runtime is not None:
result['DefaultRuntime'] = self.default_runtime
if self.end_time is not None:
result['EndTime'] = self.end_time
if self.entity_name is not None:
result['EntityName'] = self.entity_name
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.execute_directory is not None:
result['ExecuteDirectory'] = self.execute_directory
if self.execute_options is not None:
result['ExecuteOptions'] = self.execute_options.to_map()
if self.inputs is not None:
result['Inputs'] = self.inputs
if self.labels is not None:
result['Labels'] = self.labels
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.run_id is not None:
result['RunId'] = self.run_id
if self.run_name is not None:
result['RunName'] = self.run_name
if self.source is not None:
result['Source'] = self.source
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.status is not None:
result['Status'] = self.status
if self.submission_id is not None:
result['SubmissionId'] = self.submission_id
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppRevision') is not None:
self.app_revision = m.get('AppRevision')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('DefaultRuntime') is not None:
self.default_runtime = m.get('DefaultRuntime')
if m.get('EndTime') is not None:
self.end_time = m.get('EndTime')
if m.get('EntityName') is not None:
self.entity_name = m.get('EntityName')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('ExecuteDirectory') is not None:
self.execute_directory = m.get('ExecuteDirectory')
if m.get('ExecuteOptions') is not None:
temp_model = ListRunsResponseBodyRunsExecuteOptions()
self.execute_options = temp_model.from_map(m['ExecuteOptions'])
if m.get('Inputs') is not None:
self.inputs = m.get('Inputs')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('RunId') is not None:
self.run_id = m.get('RunId')
if m.get('RunName') is not None:
self.run_name = m.get('RunName')
if m.get('Source') is not None:
self.source = m.get('Source')
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('SubmissionId') is not None:
self.submission_id = m.get('SubmissionId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ListRunsResponseBody(TeaModel):
def __init__(self, host_id=None, max_results=None, next_token=None, request_id=None, runs=None, total_count=None):
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.runs = runs # type: list[ListRunsResponseBodyRuns]
self.total_count = total_count # type: int
def validate(self):
if self.runs:
for k in self.runs:
if k:
k.validate()
def to_map(self):
_map = super(ListRunsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
result['Runs'] = []
if self.runs is not None:
for k in self.runs:
result['Runs'].append(k.to_map() if k else None)
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
self.runs = []
if m.get('Runs') is not None:
for k in m.get('Runs'):
temp_model = ListRunsResponseBodyRuns()
self.runs.append(temp_model.from_map(k))
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListRunsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListRunsResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListRunsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListRunsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListSubmissionsRequest(TeaModel):
def __init__(self, is_reversed=None, max_results=None, next_token=None, order_by=None, search=None, status=None,
workspace=None):
self.is_reversed = is_reversed # type: bool
self.max_results = max_results # type: int
# Next Token
self.next_token = next_token # type: str
self.order_by = order_by # type: str
self.search = search # type: str
self.status = status # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListSubmissionsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.is_reversed is not None:
result['IsReversed'] = self.is_reversed
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.order_by is not None:
result['OrderBy'] = self.order_by
if self.search is not None:
result['Search'] = self.search
if self.status is not None:
result['Status'] = self.status
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('IsReversed') is not None:
self.is_reversed = m.get('IsReversed')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('OrderBy') is not None:
self.order_by = m.get('OrderBy')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ListSubmissionsResponseBodySubmissionsRunStats(TeaModel):
def __init__(self, aborted=None, aborting=None, failed=None, pending=None, running=None, submitted=None,
succeeded=None):
self.aborted = aborted # type: long
self.aborting = aborting # type: long
self.failed = failed # type: long
self.pending = pending # type: long
self.running = running # type: long
self.submitted = submitted # type: long
self.succeeded = succeeded # type: long
def validate(self):
pass
def to_map(self):
_map = super(ListSubmissionsResponseBodySubmissionsRunStats, self).to_map()
if _map is not None:
return _map
result = dict()
if self.aborted is not None:
result['Aborted'] = self.aborted
if self.aborting is not None:
result['Aborting'] = self.aborting
if self.failed is not None:
result['Failed'] = self.failed
if self.pending is not None:
result['Pending'] = self.pending
if self.running is not None:
result['Running'] = self.running
if self.submitted is not None:
result['Submitted'] = self.submitted
if self.succeeded is not None:
result['Succeeded'] = self.succeeded
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Aborted') is not None:
self.aborted = m.get('Aborted')
if m.get('Aborting') is not None:
self.aborting = m.get('Aborting')
if m.get('Failed') is not None:
self.failed = m.get('Failed')
if m.get('Pending') is not None:
self.pending = m.get('Pending')
if m.get('Running') is not None:
self.running = m.get('Running')
if m.get('Submitted') is not None:
self.submitted = m.get('Submitted')
if m.get('Succeeded') is not None:
self.succeeded = m.get('Succeeded')
return self
class ListSubmissionsResponseBodySubmissions(TeaModel):
def __init__(self, create_time=None, end_time=None, entity_type=None, run_stats=None, start_time=None,
status=None, submission_id=None, workspace=None):
self.create_time = create_time # type: str
self.end_time = end_time # type: str
self.entity_type = entity_type # type: str
self.run_stats = run_stats # type: ListSubmissionsResponseBodySubmissionsRunStats
self.start_time = start_time # type: str
self.status = status # type: str
self.submission_id = submission_id # type: str
self.workspace = workspace # type: str
def validate(self):
if self.run_stats:
self.run_stats.validate()
def to_map(self):
_map = super(ListSubmissionsResponseBodySubmissions, self).to_map()
if _map is not None:
return _map
result = dict()
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.end_time is not None:
result['EndTime'] = self.end_time
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.run_stats is not None:
result['RunStats'] = self.run_stats.to_map()
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.status is not None:
result['Status'] = self.status
if self.submission_id is not None:
result['SubmissionId'] = self.submission_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('EndTime') is not None:
self.end_time = m.get('EndTime')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('RunStats') is not None:
temp_model = ListSubmissionsResponseBodySubmissionsRunStats()
self.run_stats = temp_model.from_map(m['RunStats'])
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('SubmissionId') is not None:
self.submission_id = m.get('SubmissionId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ListSubmissionsResponseBody(TeaModel):
def __init__(self, host_id=None, max_results=None, next_token=None, request_id=None, submissions=None,
total_count=None):
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.submissions = submissions # type: list[ListSubmissionsResponseBodySubmissions]
self.total_count = total_count # type: int
def validate(self):
if self.submissions:
for k in self.submissions:
if k:
k.validate()
def to_map(self):
_map = super(ListSubmissionsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
result['Submissions'] = []
if self.submissions is not None:
for k in self.submissions:
result['Submissions'].append(k.to_map() if k else None)
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
self.submissions = []
if m.get('Submissions') is not None:
for k in m.get('Submissions'):
temp_model = ListSubmissionsResponseBodySubmissions()
self.submissions.append(temp_model.from_map(k))
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListSubmissionsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListSubmissionsResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListSubmissionsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListSubmissionsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListTemplatesRequest(TeaModel):
def __init__(self, is_reversed=None, label_selector=None, max_results=None, next_token=None, order_by=None,
search=None, workspace=None):
self.is_reversed = is_reversed # type: bool
self.label_selector = label_selector # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.order_by = order_by # type: str
self.search = search # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListTemplatesRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.is_reversed is not None:
result['IsReversed'] = self.is_reversed
if self.label_selector is not None:
result['LabelSelector'] = self.label_selector
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.order_by is not None:
result['OrderBy'] = self.order_by
if self.search is not None:
result['Search'] = self.search
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('IsReversed') is not None:
self.is_reversed = m.get('IsReversed')
if m.get('LabelSelector') is not None:
self.label_selector = m.get('LabelSelector')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('OrderBy') is not None:
self.order_by = m.get('OrderBy')
if m.get('Search') is not None:
self.search = m.get('Search')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ListTemplatesResponseBodyTemplatesInputsExpression(TeaModel):
def __init__(self, help=None, required=None, step_order=None, task_name=None, variable_name=None,
variable_type=None, variable_value=None):
self.help = help # type: str
self.required = required # type: bool
self.step_order = step_order # type: long
self.task_name = task_name # type: str
self.variable_name = variable_name # type: str
self.variable_type = variable_type # type: str
self.variable_value = variable_value # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListTemplatesResponseBodyTemplatesInputsExpression, self).to_map()
if _map is not None:
return _map
result = dict()
if self.help is not None:
result['Help'] = self.help
if self.required is not None:
result['Required'] = self.required
if self.step_order is not None:
result['StepOrder'] = self.step_order
if self.task_name is not None:
result['TaskName'] = self.task_name
if self.variable_name is not None:
result['VariableName'] = self.variable_name
if self.variable_type is not None:
result['VariableType'] = self.variable_type
if self.variable_value is not None:
result['VariableValue'] = self.variable_value
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Help') is not None:
self.help = m.get('Help')
if m.get('Required') is not None:
self.required = m.get('Required')
if m.get('StepOrder') is not None:
self.step_order = m.get('StepOrder')
if m.get('TaskName') is not None:
self.task_name = m.get('TaskName')
if m.get('VariableName') is not None:
self.variable_name = m.get('VariableName')
if m.get('VariableType') is not None:
self.variable_type = m.get('VariableType')
if m.get('VariableValue') is not None:
self.variable_value = m.get('VariableValue')
return self
class ListTemplatesResponseBodyTemplatesOutputsExpression(TeaModel):
def __init__(self, help=None, required=None, step_order=None, task_name=None, variable_name=None,
variable_type=None, variable_value=None):
self.help = help # type: str
self.required = required # type: bool
self.step_order = step_order # type: long
self.task_name = task_name # type: str
self.variable_name = variable_name # type: str
self.variable_type = variable_type # type: str
self.variable_value = variable_value # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListTemplatesResponseBodyTemplatesOutputsExpression, self).to_map()
if _map is not None:
return _map
result = dict()
if self.help is not None:
result['Help'] = self.help
if self.required is not None:
result['Required'] = self.required
if self.step_order is not None:
result['StepOrder'] = self.step_order
if self.task_name is not None:
result['TaskName'] = self.task_name
if self.variable_name is not None:
result['VariableName'] = self.variable_name
if self.variable_type is not None:
result['VariableType'] = self.variable_type
if self.variable_value is not None:
result['VariableValue'] = self.variable_value
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Help') is not None:
self.help = m.get('Help')
if m.get('Required') is not None:
self.required = m.get('Required')
if m.get('StepOrder') is not None:
self.step_order = m.get('StepOrder')
if m.get('TaskName') is not None:
self.task_name = m.get('TaskName')
if m.get('VariableName') is not None:
self.variable_name = m.get('VariableName')
if m.get('VariableType') is not None:
self.variable_type = m.get('VariableType')
if m.get('VariableValue') is not None:
self.variable_value = m.get('VariableValue')
return self
class ListTemplatesResponseBodyTemplates(TeaModel):
def __init__(self, app_name=None, app_revision=None, create_time=None, description=None, inputs_expression=None,
labels=None, last_modified_time=None, outputs_expression=None, revision_tag=None, root_entity=None,
template_name=None, workspace=None):
self.app_name = app_name # type: str
self.app_revision = app_revision # type: str
self.create_time = create_time # type: str
self.description = description # type: str
self.inputs_expression = inputs_expression # type: list[ListTemplatesResponseBodyTemplatesInputsExpression]
self.labels = labels # type: dict[str, str]
self.last_modified_time = last_modified_time # type: str
self.outputs_expression = outputs_expression # type: list[ListTemplatesResponseBodyTemplatesOutputsExpression]
self.revision_tag = revision_tag # type: str
self.root_entity = root_entity # type: str
self.template_name = template_name # type: str
self.workspace = workspace # type: str
def validate(self):
if self.inputs_expression:
for k in self.inputs_expression:
if k:
k.validate()
if self.outputs_expression:
for k in self.outputs_expression:
if k:
k.validate()
def to_map(self):
_map = super(ListTemplatesResponseBodyTemplates, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_revision is not None:
result['AppRevision'] = self.app_revision
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.description is not None:
result['Description'] = self.description
result['InputsExpression'] = []
if self.inputs_expression is not None:
for k in self.inputs_expression:
result['InputsExpression'].append(k.to_map() if k else None)
if self.labels is not None:
result['Labels'] = self.labels
if self.last_modified_time is not None:
result['LastModifiedTime'] = self.last_modified_time
result['OutputsExpression'] = []
if self.outputs_expression is not None:
for k in self.outputs_expression:
result['OutputsExpression'].append(k.to_map() if k else None)
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.root_entity is not None:
result['RootEntity'] = self.root_entity
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppRevision') is not None:
self.app_revision = m.get('AppRevision')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('Description') is not None:
self.description = m.get('Description')
self.inputs_expression = []
if m.get('InputsExpression') is not None:
for k in m.get('InputsExpression'):
temp_model = ListTemplatesResponseBodyTemplatesInputsExpression()
self.inputs_expression.append(temp_model.from_map(k))
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('LastModifiedTime') is not None:
self.last_modified_time = m.get('LastModifiedTime')
self.outputs_expression = []
if m.get('OutputsExpression') is not None:
for k in m.get('OutputsExpression'):
temp_model = ListTemplatesResponseBodyTemplatesOutputsExpression()
self.outputs_expression.append(temp_model.from_map(k))
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('RootEntity') is not None:
self.root_entity = m.get('RootEntity')
if m.get('TemplateName') is not None:
self.template_name = m.get('TemplateName')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ListTemplatesResponseBody(TeaModel):
def __init__(self, host_id=None, max_results=None, next_token=None, request_id=None, templates=None,
total_count=None):
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.templates = templates # type: list[ListTemplatesResponseBodyTemplates]
self.total_count = total_count # type: int
def validate(self):
if self.templates:
for k in self.templates:
if k:
k.validate()
def to_map(self):
_map = super(ListTemplatesResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
result['Templates'] = []
if self.templates is not None:
for k in self.templates:
result['Templates'].append(k.to_map() if k else None)
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
self.templates = []
if m.get('Templates') is not None:
for k in m.get('Templates'):
temp_model = ListTemplatesResponseBodyTemplates()
self.templates.append(temp_model.from_map(k))
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListTemplatesResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListTemplatesResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListTemplatesResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListTemplatesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListUserActiveRunsRequest(TeaModel):
def __init__(self, max_results=None):
self.max_results = max_results # type: int
def validate(self):
pass
def to_map(self):
_map = super(ListUserActiveRunsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.max_results is not None:
result['MaxResults'] = self.max_results
return result
def from_map(self, m=None):
m = m or dict()
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
return self
class ListUserActiveRunsResponseBodyRunsExecuteOptions(TeaModel):
def __init__(self, call_caching=None, delete_intermediate_results=None, failure_mode=None,
use_relative_output_paths=None):
self.call_caching = call_caching # type: bool
self.delete_intermediate_results = delete_intermediate_results # type: bool
self.failure_mode = failure_mode # type: str
self.use_relative_output_paths = use_relative_output_paths # type: bool
def validate(self):
pass
def to_map(self):
_map = super(ListUserActiveRunsResponseBodyRunsExecuteOptions, self).to_map()
if _map is not None:
return _map
result = dict()
if self.call_caching is not None:
result['CallCaching'] = self.call_caching
if self.delete_intermediate_results is not None:
result['DeleteIntermediateResults'] = self.delete_intermediate_results
if self.failure_mode is not None:
result['FailureMode'] = self.failure_mode
if self.use_relative_output_paths is not None:
result['UseRelativeOutputPaths'] = self.use_relative_output_paths
return result
def from_map(self, m=None):
m = m or dict()
if m.get('CallCaching') is not None:
self.call_caching = m.get('CallCaching')
if m.get('DeleteIntermediateResults') is not None:
self.delete_intermediate_results = m.get('DeleteIntermediateResults')
if m.get('FailureMode') is not None:
self.failure_mode = m.get('FailureMode')
if m.get('UseRelativeOutputPaths') is not None:
self.use_relative_output_paths = m.get('UseRelativeOutputPaths')
return self
class ListUserActiveRunsResponseBodyRuns(TeaModel):
def __init__(self, app_name=None, app_revision=None, create_time=None, default_runtime=None, end_time=None,
entity_name=None, entity_type=None, execute_directory=None, execute_options=None, inputs=None, labels=None,
region_id=None, run_id=None, run_name=None, source=None, start_time=None, status=None, submission_id=None,
workspace=None):
self.app_name = app_name # type: str
self.app_revision = app_revision # type: str
self.create_time = create_time # type: str
self.default_runtime = default_runtime # type: str
self.end_time = end_time # type: str
self.entity_name = entity_name # type: str
self.entity_type = entity_type # type: str
self.execute_directory = execute_directory # type: str
self.execute_options = execute_options # type: ListUserActiveRunsResponseBodyRunsExecuteOptions
self.inputs = inputs # type: str
self.labels = labels # type: dict[str, str]
self.region_id = region_id # type: str
self.run_id = run_id # type: str
self.run_name = run_name # type: str
self.source = source # type: str
self.start_time = start_time # type: str
self.status = status # type: str
self.submission_id = submission_id # type: str
self.workspace = workspace # type: str
def validate(self):
if self.execute_options:
self.execute_options.validate()
def to_map(self):
_map = super(ListUserActiveRunsResponseBodyRuns, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_revision is not None:
result['AppRevision'] = self.app_revision
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.default_runtime is not None:
result['DefaultRuntime'] = self.default_runtime
if self.end_time is not None:
result['EndTime'] = self.end_time
if self.entity_name is not None:
result['EntityName'] = self.entity_name
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.execute_directory is not None:
result['ExecuteDirectory'] = self.execute_directory
if self.execute_options is not None:
result['ExecuteOptions'] = self.execute_options.to_map()
if self.inputs is not None:
result['Inputs'] = self.inputs
if self.labels is not None:
result['Labels'] = self.labels
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.run_id is not None:
result['RunId'] = self.run_id
if self.run_name is not None:
result['RunName'] = self.run_name
if self.source is not None:
result['Source'] = self.source
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.status is not None:
result['Status'] = self.status
if self.submission_id is not None:
result['SubmissionId'] = self.submission_id
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppRevision') is not None:
self.app_revision = m.get('AppRevision')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('DefaultRuntime') is not None:
self.default_runtime = m.get('DefaultRuntime')
if m.get('EndTime') is not None:
self.end_time = m.get('EndTime')
if m.get('EntityName') is not None:
self.entity_name = m.get('EntityName')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('ExecuteDirectory') is not None:
self.execute_directory = m.get('ExecuteDirectory')
if m.get('ExecuteOptions') is not None:
temp_model = ListUserActiveRunsResponseBodyRunsExecuteOptions()
self.execute_options = temp_model.from_map(m['ExecuteOptions'])
if m.get('Inputs') is not None:
self.inputs = m.get('Inputs')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('RunId') is not None:
self.run_id = m.get('RunId')
if m.get('RunName') is not None:
self.run_name = m.get('RunName')
if m.get('Source') is not None:
self.source = m.get('Source')
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('SubmissionId') is not None:
self.submission_id = m.get('SubmissionId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ListUserActiveRunsResponseBody(TeaModel):
def __init__(self, host_id=None, max_results=None, next_token=None, request_id=None, runs=None, total_count=None):
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.runs = runs # type: list[ListUserActiveRunsResponseBodyRuns]
self.total_count = total_count # type: int
def validate(self):
if self.runs:
for k in self.runs:
if k:
k.validate()
def to_map(self):
_map = super(ListUserActiveRunsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
result['Runs'] = []
if self.runs is not None:
for k in self.runs:
result['Runs'].append(k.to_map() if k else None)
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
self.runs = []
if m.get('Runs') is not None:
for k in m.get('Runs'):
temp_model = ListUserActiveRunsResponseBodyRuns()
self.runs.append(temp_model.from_map(k))
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListUserActiveRunsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListUserActiveRunsResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListUserActiveRunsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListUserActiveRunsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListWorkspacesRequest(TeaModel):
def __init__(self, is_reversed=None, label_selector=None, max_results=None, next_token=None, order_by=None,
search=None):
self.is_reversed = is_reversed # type: bool
self.label_selector = label_selector # type: str
self.max_results = max_results # type: int
# NextToken
self.next_token = next_token # type: str
self.order_by = order_by # type: str
self.search = search # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListWorkspacesRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.is_reversed is not None:
result['IsReversed'] = self.is_reversed
if self.label_selector is not None:
result['LabelSelector'] = self.label_selector
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.order_by is not None:
result['OrderBy'] = self.order_by
if self.search is not None:
result['Search'] = self.search
return result
def from_map(self, m=None):
m = m or dict()
if m.get('IsReversed') is not None:
self.is_reversed = m.get('IsReversed')
if m.get('LabelSelector') is not None:
self.label_selector = m.get('LabelSelector')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('OrderBy') is not None:
self.order_by = m.get('OrderBy')
if m.get('Search') is not None:
self.search = m.get('Search')
return self
class ListWorkspacesResponseBodyWorkspaces(TeaModel):
def __init__(self, bucket_name=None, create_time=None, description=None, job_lifecycle=None, labels=None,
last_modified_time=None, location=None, role=None, status=None, storage=None, workspace=None):
self.bucket_name = bucket_name # type: str
self.create_time = create_time # type: str
self.description = description # type: str
self.job_lifecycle = job_lifecycle # type: int
self.labels = labels # type: dict[str, str]
self.last_modified_time = last_modified_time # type: str
self.location = location # type: str
# RAM Role
self.role = role # type: str
self.status = status # type: str
self.storage = storage # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(ListWorkspacesResponseBodyWorkspaces, self).to_map()
if _map is not None:
return _map
result = dict()
if self.bucket_name is not None:
result['BucketName'] = self.bucket_name
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.description is not None:
result['Description'] = self.description
if self.job_lifecycle is not None:
result['JobLifecycle'] = self.job_lifecycle
if self.labels is not None:
result['Labels'] = self.labels
if self.last_modified_time is not None:
result['LastModifiedTime'] = self.last_modified_time
if self.location is not None:
result['Location'] = self.location
if self.role is not None:
result['Role'] = self.role
if self.status is not None:
result['Status'] = self.status
if self.storage is not None:
result['Storage'] = self.storage
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('BucketName') is not None:
self.bucket_name = m.get('BucketName')
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('JobLifecycle') is not None:
self.job_lifecycle = m.get('JobLifecycle')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('LastModifiedTime') is not None:
self.last_modified_time = m.get('LastModifiedTime')
if m.get('Location') is not None:
self.location = m.get('Location')
if m.get('Role') is not None:
self.role = m.get('Role')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Storage') is not None:
self.storage = m.get('Storage')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ListWorkspacesResponseBody(TeaModel):
def __init__(self, host_id=None, max_results=None, next_token=None, request_id=None, total_count=None,
workspaces=None):
self.host_id = host_id # type: str
self.max_results = max_results # type: int
self.next_token = next_token # type: str
self.request_id = request_id # type: str
self.total_count = total_count # type: int
self.workspaces = workspaces # type: list[ListWorkspacesResponseBodyWorkspaces]
def validate(self):
if self.workspaces:
for k in self.workspaces:
if k:
k.validate()
def to_map(self):
_map = super(ListWorkspacesResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.max_results is not None:
result['MaxResults'] = self.max_results
if self.next_token is not None:
result['NextToken'] = self.next_token
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.total_count is not None:
result['TotalCount'] = self.total_count
result['Workspaces'] = []
if self.workspaces is not None:
for k in self.workspaces:
result['Workspaces'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('MaxResults') is not None:
self.max_results = m.get('MaxResults')
if m.get('NextToken') is not None:
self.next_token = m.get('NextToken')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
self.workspaces = []
if m.get('Workspaces') is not None:
for k in m.get('Workspaces'):
temp_model = ListWorkspacesResponseBodyWorkspaces()
self.workspaces.append(temp_model.from_map(k))
return self
class ListWorkspacesResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ListWorkspacesResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ListWorkspacesResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListWorkspacesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ResumeSubmissionRequest(TeaModel):
def __init__(self, submission_id=None, workspace=None):
self.submission_id = submission_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(ResumeSubmissionRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.submission_id is not None:
result['SubmissionId'] = self.submission_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('SubmissionId') is not None:
self.submission_id = m.get('SubmissionId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class ResumeSubmissionResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(ResumeSubmissionResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ResumeSubmissionResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: ResumeSubmissionResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(ResumeSubmissionResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ResumeSubmissionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class TagAppRequest(TeaModel):
def __init__(self, app_name=None, app_revision=None, revision_tag=None, workspace=None):
self.app_name = app_name # type: str
self.app_revision = app_revision # type: str
self.revision_tag = revision_tag # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(TagAppRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_revision is not None:
result['AppRevision'] = self.app_revision
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppRevision') is not None:
self.app_revision = m.get('AppRevision')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class TagAppResponseBody(TeaModel):
def __init__(self, app_name=None, app_revision=None, former_revision=None, former_tag=None, request_id=None,
revision_tag=None, workspace=None):
self.app_name = app_name # type: str
self.app_revision = app_revision # type: str
self.former_revision = former_revision # type: str
self.former_tag = former_tag # type: str
self.request_id = request_id # type: str
self.revision_tag = revision_tag # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(TagAppResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.app_name is not None:
result['AppName'] = self.app_name
if self.app_revision is not None:
result['AppRevision'] = self.app_revision
if self.former_revision is not None:
result['FormerRevision'] = self.former_revision
if self.former_tag is not None:
result['FormerTag'] = self.former_tag
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.revision_tag is not None:
result['RevisionTag'] = self.revision_tag
if self.workspace is not None:
result['Workspace'] = self.workspace
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('AppRevision') is not None:
self.app_revision = m.get('AppRevision')
if m.get('FormerRevision') is not None:
self.former_revision = m.get('FormerRevision')
if m.get('FormerTag') is not None:
self.former_tag = m.get('FormerTag')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('RevisionTag') is not None:
self.revision_tag = m.get('RevisionTag')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class TagAppResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: TagAppResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(TagAppResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = TagAppResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateEntityRequestEntityItems(TeaModel):
def __init__(self, entity_data=None, entity_name=None):
self.entity_data = entity_data # type: dict[str, str]
self.entity_name = entity_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateEntityRequestEntityItems, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_data is not None:
result['EntityData'] = self.entity_data
if self.entity_name is not None:
result['EntityName'] = self.entity_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityData') is not None:
self.entity_data = m.get('EntityData')
if m.get('EntityName') is not None:
self.entity_name = m.get('EntityName')
return self
class UpdateEntityRequest(TeaModel):
def __init__(self, entity_items=None, entity_type=None, workspace=None):
self.entity_items = entity_items # type: list[UpdateEntityRequestEntityItems]
self.entity_type = entity_type # type: str
self.workspace = workspace # type: str
def validate(self):
if self.entity_items:
for k in self.entity_items:
if k:
k.validate()
def to_map(self):
_map = super(UpdateEntityRequest, self).to_map()
if _map is not None:
return _map
result = dict()
result['EntityItems'] = []
if self.entity_items is not None:
for k in self.entity_items:
result['EntityItems'].append(k.to_map() if k else None)
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
self.entity_items = []
if m.get('EntityItems') is not None:
for k in m.get('EntityItems'):
temp_model = UpdateEntityRequestEntityItems()
self.entity_items.append(temp_model.from_map(k))
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class UpdateEntityShrinkRequest(TeaModel):
def __init__(self, entity_items_shrink=None, entity_type=None, workspace=None):
self.entity_items_shrink = entity_items_shrink # type: str
self.entity_type = entity_type # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateEntityShrinkRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_items_shrink is not None:
result['EntityItems'] = self.entity_items_shrink
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityItems') is not None:
self.entity_items_shrink = m.get('EntityItems')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class UpdateEntityResponseBody(TeaModel):
def __init__(self, entity_type=None, host_id=None, request_id=None, workspace=None):
self.entity_type = entity_type # type: str
self.host_id = host_id # type: str
self.request_id = request_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateEntityResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class UpdateEntityResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: UpdateEntityResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(UpdateEntityResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = UpdateEntityResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateEntityItemsRequestEntityItems(TeaModel):
def __init__(self, entity_data=None, entity_name=None):
self.entity_data = entity_data # type: dict[str, str]
self.entity_name = entity_name # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateEntityItemsRequestEntityItems, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_data is not None:
result['EntityData'] = self.entity_data
if self.entity_name is not None:
result['EntityName'] = self.entity_name
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityData') is not None:
self.entity_data = m.get('EntityData')
if m.get('EntityName') is not None:
self.entity_name = m.get('EntityName')
return self
class UpdateEntityItemsRequest(TeaModel):
def __init__(self, entity_items=None, entity_type=None, workspace=None):
self.entity_items = entity_items # type: list[UpdateEntityItemsRequestEntityItems]
self.entity_type = entity_type # type: str
self.workspace = workspace # type: str
def validate(self):
if self.entity_items:
for k in self.entity_items:
if k:
k.validate()
def to_map(self):
_map = super(UpdateEntityItemsRequest, self).to_map()
if _map is not None:
return _map
result = dict()
result['EntityItems'] = []
if self.entity_items is not None:
for k in self.entity_items:
result['EntityItems'].append(k.to_map() if k else None)
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
self.entity_items = []
if m.get('EntityItems') is not None:
for k in m.get('EntityItems'):
temp_model = UpdateEntityItemsRequestEntityItems()
self.entity_items.append(temp_model.from_map(k))
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class UpdateEntityItemsShrinkRequest(TeaModel):
def __init__(self, entity_items_shrink=None, entity_type=None, workspace=None):
self.entity_items_shrink = entity_items_shrink # type: str
self.entity_type = entity_type # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateEntityItemsShrinkRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_items_shrink is not None:
result['EntityItems'] = self.entity_items_shrink
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityItems') is not None:
self.entity_items_shrink = m.get('EntityItems')
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class UpdateEntityItemsResponseBody(TeaModel):
def __init__(self, entity_type=None, host_id=None, request_id=None, workspace=None):
self.entity_type = entity_type # type: str
self.host_id = host_id # type: str
self.request_id = request_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateEntityItemsResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class UpdateEntityItemsResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: UpdateEntityItemsResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(UpdateEntityItemsResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = UpdateEntityItemsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateTemplateRequestInputsExpression(TeaModel):
def __init__(self, help=None, required=None, step_order=None, task_name=None, variable_name=None,
variable_type=None, variable_value=None):
self.help = help # type: str
self.required = required # type: bool
self.step_order = step_order # type: int
self.task_name = task_name # type: str
self.variable_name = variable_name # type: str
self.variable_type = variable_type # type: str
self.variable_value = variable_value # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateTemplateRequestInputsExpression, self).to_map()
if _map is not None:
return _map
result = dict()
if self.help is not None:
result['Help'] = self.help
if self.required is not None:
result['Required'] = self.required
if self.step_order is not None:
result['StepOrder'] = self.step_order
if self.task_name is not None:
result['TaskName'] = self.task_name
if self.variable_name is not None:
result['VariableName'] = self.variable_name
if self.variable_type is not None:
result['VariableType'] = self.variable_type
if self.variable_value is not None:
result['VariableValue'] = self.variable_value
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Help') is not None:
self.help = m.get('Help')
if m.get('Required') is not None:
self.required = m.get('Required')
if m.get('StepOrder') is not None:
self.step_order = m.get('StepOrder')
if m.get('TaskName') is not None:
self.task_name = m.get('TaskName')
if m.get('VariableName') is not None:
self.variable_name = m.get('VariableName')
if m.get('VariableType') is not None:
self.variable_type = m.get('VariableType')
if m.get('VariableValue') is not None:
self.variable_value = m.get('VariableValue')
return self
class UpdateTemplateRequestOutputsExpression(TeaModel):
def __init__(self, help=None, required=None, step_order=None, task_name=None, variable_name=None,
variable_type=None, variable_value=None):
self.help = help # type: str
self.required = required # type: bool
self.step_order = step_order # type: int
self.task_name = task_name # type: str
self.variable_name = variable_name # type: str
self.variable_type = variable_type # type: str
self.variable_value = variable_value # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateTemplateRequestOutputsExpression, self).to_map()
if _map is not None:
return _map
result = dict()
if self.help is not None:
result['Help'] = self.help
if self.required is not None:
result['Required'] = self.required
if self.step_order is not None:
result['StepOrder'] = self.step_order
if self.task_name is not None:
result['TaskName'] = self.task_name
if self.variable_name is not None:
result['VariableName'] = self.variable_name
if self.variable_type is not None:
result['VariableType'] = self.variable_type
if self.variable_value is not None:
result['VariableValue'] = self.variable_value
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Help') is not None:
self.help = m.get('Help')
if m.get('Required') is not None:
self.required = m.get('Required')
if m.get('StepOrder') is not None:
self.step_order = m.get('StepOrder')
if m.get('TaskName') is not None:
self.task_name = m.get('TaskName')
if m.get('VariableName') is not None:
self.variable_name = m.get('VariableName')
if m.get('VariableType') is not None:
self.variable_type = m.get('VariableType')
if m.get('VariableValue') is not None:
self.variable_value = m.get('VariableValue')
return self
class UpdateTemplateRequest(TeaModel):
def __init__(self, description=None, inputs_expression=None, labels=None, outputs_expression=None,
root_entity=None, template_name=None, workspace=None):
self.description = description # type: str
self.inputs_expression = inputs_expression # type: list[UpdateTemplateRequestInputsExpression]
self.labels = labels # type: str
self.outputs_expression = outputs_expression # type: list[UpdateTemplateRequestOutputsExpression]
self.root_entity = root_entity # type: str
self.template_name = template_name # type: str
self.workspace = workspace # type: str
def validate(self):
if self.inputs_expression:
for k in self.inputs_expression:
if k:
k.validate()
if self.outputs_expression:
for k in self.outputs_expression:
if k:
k.validate()
def to_map(self):
_map = super(UpdateTemplateRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.description is not None:
result['Description'] = self.description
result['InputsExpression'] = []
if self.inputs_expression is not None:
for k in self.inputs_expression:
result['InputsExpression'].append(k.to_map() if k else None)
if self.labels is not None:
result['Labels'] = self.labels
result['OutputsExpression'] = []
if self.outputs_expression is not None:
for k in self.outputs_expression:
result['OutputsExpression'].append(k.to_map() if k else None)
if self.root_entity is not None:
result['RootEntity'] = self.root_entity
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Description') is not None:
self.description = m.get('Description')
self.inputs_expression = []
if m.get('InputsExpression') is not None:
for k in m.get('InputsExpression'):
temp_model = UpdateTemplateRequestInputsExpression()
self.inputs_expression.append(temp_model.from_map(k))
if m.get('Labels') is not None:
self.labels = m.get('Labels')
self.outputs_expression = []
if m.get('OutputsExpression') is not None:
for k in m.get('OutputsExpression'):
temp_model = UpdateTemplateRequestOutputsExpression()
self.outputs_expression.append(temp_model.from_map(k))
if m.get('RootEntity') is not None:
self.root_entity = m.get('RootEntity')
if m.get('TemplateName') is not None:
self.template_name = m.get('TemplateName')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class UpdateTemplateShrinkRequest(TeaModel):
def __init__(self, description=None, inputs_expression_shrink=None, labels=None,
outputs_expression_shrink=None, root_entity=None, template_name=None, workspace=None):
self.description = description # type: str
self.inputs_expression_shrink = inputs_expression_shrink # type: str
self.labels = labels # type: str
self.outputs_expression_shrink = outputs_expression_shrink # type: str
self.root_entity = root_entity # type: str
self.template_name = template_name # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateTemplateShrinkRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.description is not None:
result['Description'] = self.description
if self.inputs_expression_shrink is not None:
result['InputsExpression'] = self.inputs_expression_shrink
if self.labels is not None:
result['Labels'] = self.labels
if self.outputs_expression_shrink is not None:
result['OutputsExpression'] = self.outputs_expression_shrink
if self.root_entity is not None:
result['RootEntity'] = self.root_entity
if self.template_name is not None:
result['TemplateName'] = self.template_name
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('InputsExpression') is not None:
self.inputs_expression_shrink = m.get('InputsExpression')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('OutputsExpression') is not None:
self.outputs_expression_shrink = m.get('OutputsExpression')
if m.get('RootEntity') is not None:
self.root_entity = m.get('RootEntity')
if m.get('TemplateName') is not None:
self.template_name = m.get('TemplateName')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class UpdateTemplateResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateTemplateResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class UpdateTemplateResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: UpdateTemplateResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(UpdateTemplateResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = UpdateTemplateResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateWorkspaceRequest(TeaModel):
def __init__(self, description=None, job_lifecycle=None, labels=None, role=None, workspace=None):
self.description = description # type: str
self.job_lifecycle = job_lifecycle # type: int
self.labels = labels # type: str
self.role = role # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateWorkspaceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.description is not None:
result['Description'] = self.description
if self.job_lifecycle is not None:
result['JobLifecycle'] = self.job_lifecycle
if self.labels is not None:
result['Labels'] = self.labels
if self.role is not None:
result['Role'] = self.role
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('JobLifecycle') is not None:
self.job_lifecycle = m.get('JobLifecycle')
if m.get('Labels') is not None:
self.labels = m.get('Labels')
if m.get('Role') is not None:
self.role = m.get('Role')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class UpdateWorkspaceResponseBody(TeaModel):
def __init__(self, host_id=None, request_id=None):
self.host_id = host_id # type: str
self.request_id = request_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(UpdateWorkspaceResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class UpdateWorkspaceResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: UpdateWorkspaceResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(UpdateWorkspaceResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = UpdateWorkspaceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UploadEntityRequest(TeaModel):
def __init__(self, entity_csvfile=None, workspace=None):
self.entity_csvfile = entity_csvfile # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(UploadEntityRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_csvfile is not None:
result['EntityCSVFile'] = self.entity_csvfile
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityCSVFile') is not None:
self.entity_csvfile = m.get('EntityCSVFile')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class UploadEntityResponseBody(TeaModel):
def __init__(self, entity_type=None, host_id=None, request_id=None, workspace=None):
self.entity_type = entity_type # type: str
self.host_id = host_id # type: str
self.request_id = request_id # type: str
self.workspace = workspace # type: str
def validate(self):
pass
def to_map(self):
_map = super(UploadEntityResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.entity_type is not None:
result['EntityType'] = self.entity_type
if self.host_id is not None:
result['HostId'] = self.host_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.workspace is not None:
result['Workspace'] = self.workspace
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EntityType') is not None:
self.entity_type = m.get('EntityType')
if m.get('HostId') is not None:
self.host_id = m.get('HostId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Workspace') is not None:
self.workspace = m.get('Workspace')
return self
class UploadEntityResponse(TeaModel):
def __init__(self, headers=None, status_code=None, body=None):
self.headers = headers # type: dict[str, str]
self.status_code = status_code # type: int
self.body = body # type: UploadEntityResponseBody
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super(UploadEntityResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
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('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = UploadEntityResponseBody()
self.body = temp_model.from_map(m['body'])
return self