ehpc-20170714/alibabacloud_ehpc20170714/models.py (6,374 lines of code) (raw):
# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
from Tea.model import TeaModel
from typing import List, Dict
class AddNodesRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
compute_spot_price_limit: str = None,
compute_spot_strategy: str = None,
count: int = None,
image_id: str = None,
image_owner_alias: str = None,
):
self.cluster_id = cluster_id
self.compute_spot_price_limit = compute_spot_price_limit
self.compute_spot_strategy = compute_spot_strategy
self.count = count
self.image_id = image_id
self.image_owner_alias = image_owner_alias
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.compute_spot_price_limit is not None:
result['ComputeSpotPriceLimit'] = self.compute_spot_price_limit
if self.compute_spot_strategy is not None:
result['ComputeSpotStrategy'] = self.compute_spot_strategy
if self.count is not None:
result['Count'] = self.count
if self.image_id is not None:
result['ImageId'] = self.image_id
if self.image_owner_alias is not None:
result['ImageOwnerAlias'] = self.image_owner_alias
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('ComputeSpotPriceLimit') is not None:
self.compute_spot_price_limit = m.get('ComputeSpotPriceLimit')
if m.get('ComputeSpotStrategy') is not None:
self.compute_spot_strategy = m.get('ComputeSpotStrategy')
if m.get('Count') is not None:
self.count = m.get('Count')
if m.get('ImageId') is not None:
self.image_id = m.get('ImageId')
if m.get('ImageOwnerAlias') is not None:
self.image_owner_alias = m.get('ImageOwnerAlias')
return self
class AddNodesResponseBodyInstanceIds(TeaModel):
def __init__(
self,
instance_id: List[str] = None,
):
self.instance_id = instance_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.instance_id is not None:
result['InstanceId'] = self.instance_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('InstanceId') is not None:
self.instance_id = m.get('InstanceId')
return self
class AddNodesResponseBody(TeaModel):
def __init__(
self,
instance_ids: AddNodesResponseBodyInstanceIds = None,
request_id: str = None,
):
self.instance_ids = instance_ids
self.request_id = request_id
def validate(self):
if self.instance_ids:
self.instance_ids.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.instance_ids is not None:
result['InstanceIds'] = self.instance_ids.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('InstanceIds') is not None:
temp_model = AddNodesResponseBodyInstanceIds()
self.instance_ids = temp_model.from_map(m['InstanceIds'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddNodesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: AddNodesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = AddNodesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddUsersRequestUser(TeaModel):
def __init__(
self,
group: str = None,
name: str = None,
password: str = None,
):
self.group = group
self.name = name
self.password = password
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.group is not None:
result['Group'] = self.group
if self.name is not None:
result['Name'] = self.name
if self.password is not None:
result['Password'] = self.password
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Group') is not None:
self.group = m.get('Group')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Password') is not None:
self.password = m.get('Password')
return self
class AddUsersRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
release_instance: bool = None,
user: List[AddUsersRequestUser] = None,
):
self.cluster_id = cluster_id
self.release_instance = release_instance
self.user = user
def validate(self):
if self.user:
for k in self.user:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.release_instance is not None:
result['ReleaseInstance'] = self.release_instance
result['User'] = []
if self.user is not None:
for k in self.user:
result['User'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('ReleaseInstance') is not None:
self.release_instance = m.get('ReleaseInstance')
self.user = []
if m.get('User') is not None:
for k in m.get('User'):
temp_model = AddUsersRequestUser()
self.user.append(temp_model.from_map(k))
return self
class AddUsersResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddUsersResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: AddUsersResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = AddUsersResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateClusterRequestEcsOrderCompute(TeaModel):
def __init__(
self,
count: int = None,
instance_type: str = None,
):
self.count = count
self.instance_type = instance_type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.count is not None:
result['Count'] = self.count
if self.instance_type is not None:
result['InstanceType'] = self.instance_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Count') is not None:
self.count = m.get('Count')
if m.get('InstanceType') is not None:
self.instance_type = m.get('InstanceType')
return self
class CreateClusterRequestEcsOrderLogin(TeaModel):
def __init__(
self,
count: int = None,
instance_type: str = None,
):
self.count = count
self.instance_type = instance_type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.count is not None:
result['Count'] = self.count
if self.instance_type is not None:
result['InstanceType'] = self.instance_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Count') is not None:
self.count = m.get('Count')
if m.get('InstanceType') is not None:
self.instance_type = m.get('InstanceType')
return self
class CreateClusterRequestEcsOrderManager(TeaModel):
def __init__(
self,
count: int = None,
instance_type: str = None,
):
self.count = count
self.instance_type = instance_type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.count is not None:
result['Count'] = self.count
if self.instance_type is not None:
result['InstanceType'] = self.instance_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Count') is not None:
self.count = m.get('Count')
if m.get('InstanceType') is not None:
self.instance_type = m.get('InstanceType')
return self
class CreateClusterRequestEcsOrder(TeaModel):
def __init__(
self,
compute: CreateClusterRequestEcsOrderCompute = None,
login: CreateClusterRequestEcsOrderLogin = None,
manager: CreateClusterRequestEcsOrderManager = None,
):
self.compute = compute
self.login = login
self.manager = manager
def validate(self):
self.validate_required(self.compute, 'compute')
if self.compute:
self.compute.validate()
self.validate_required(self.login, 'login')
if self.login:
self.login.validate()
self.validate_required(self.manager, 'manager')
if self.manager:
self.manager.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.compute is not None:
result['Compute'] = self.compute.to_map()
if self.login is not None:
result['Login'] = self.login.to_map()
if self.manager is not None:
result['Manager'] = self.manager.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Compute') is not None:
temp_model = CreateClusterRequestEcsOrderCompute()
self.compute = temp_model.from_map(m['Compute'])
if m.get('Login') is not None:
temp_model = CreateClusterRequestEcsOrderLogin()
self.login = temp_model.from_map(m['Login'])
if m.get('Manager') is not None:
temp_model = CreateClusterRequestEcsOrderManager()
self.manager = temp_model.from_map(m['Manager'])
return self
class CreateClusterRequestApplication(TeaModel):
def __init__(
self,
tag: str = None,
):
self.tag = tag
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.tag is not None:
result['Tag'] = self.tag
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Tag') is not None:
self.tag = m.get('Tag')
return self
class CreateClusterRequest(TeaModel):
def __init__(
self,
ecs_order: CreateClusterRequestEcsOrder = None,
account_type: str = None,
application: List[CreateClusterRequestApplication] = None,
compute_spot_price_limit: str = None,
compute_spot_strategy: str = None,
description: str = None,
ecs_charge_type: str = None,
ehpc_version: str = None,
ha_enable: bool = None,
image_id: str = None,
image_owner_alias: str = None,
key_pair_name: str = None,
name: str = None,
os_tag: str = None,
password: str = None,
remote_directory: str = None,
scc_cluster_id: str = None,
scheduler_type: str = None,
security_group_id: str = None,
security_group_name: str = None,
v_switch_id: str = None,
volume_id: str = None,
volume_mountpoint: str = None,
volume_protocol: str = None,
volume_type: str = None,
vpc_id: str = None,
zone_id: str = None,
):
self.ecs_order = ecs_order
self.account_type = account_type
self.application = application
self.compute_spot_price_limit = compute_spot_price_limit
self.compute_spot_strategy = compute_spot_strategy
self.description = description
self.ecs_charge_type = ecs_charge_type
self.ehpc_version = ehpc_version
self.ha_enable = ha_enable
self.image_id = image_id
self.image_owner_alias = image_owner_alias
self.key_pair_name = key_pair_name
self.name = name
self.os_tag = os_tag
self.password = password
self.remote_directory = remote_directory
self.scc_cluster_id = scc_cluster_id
self.scheduler_type = scheduler_type
self.security_group_id = security_group_id
self.security_group_name = security_group_name
self.v_switch_id = v_switch_id
self.volume_id = volume_id
self.volume_mountpoint = volume_mountpoint
self.volume_protocol = volume_protocol
self.volume_type = volume_type
self.vpc_id = vpc_id
self.zone_id = zone_id
def validate(self):
if self.ecs_order:
self.ecs_order.validate()
if self.application:
for k in self.application:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.ecs_order is not None:
result['EcsOrder'] = self.ecs_order.to_map()
if self.account_type is not None:
result['AccountType'] = self.account_type
result['Application'] = []
if self.application is not None:
for k in self.application:
result['Application'].append(k.to_map() if k else None)
if self.compute_spot_price_limit is not None:
result['ComputeSpotPriceLimit'] = self.compute_spot_price_limit
if self.compute_spot_strategy is not None:
result['ComputeSpotStrategy'] = self.compute_spot_strategy
if self.description is not None:
result['Description'] = self.description
if self.ecs_charge_type is not None:
result['EcsChargeType'] = self.ecs_charge_type
if self.ehpc_version is not None:
result['EhpcVersion'] = self.ehpc_version
if self.ha_enable is not None:
result['HaEnable'] = self.ha_enable
if self.image_id is not None:
result['ImageId'] = self.image_id
if self.image_owner_alias is not None:
result['ImageOwnerAlias'] = self.image_owner_alias
if self.key_pair_name is not None:
result['KeyPairName'] = self.key_pair_name
if self.name is not None:
result['Name'] = self.name
if self.os_tag is not None:
result['OsTag'] = self.os_tag
if self.password is not None:
result['Password'] = self.password
if self.remote_directory is not None:
result['RemoteDirectory'] = self.remote_directory
if self.scc_cluster_id is not None:
result['SccClusterId'] = self.scc_cluster_id
if self.scheduler_type is not None:
result['SchedulerType'] = self.scheduler_type
if self.security_group_id is not None:
result['SecurityGroupId'] = self.security_group_id
if self.security_group_name is not None:
result['SecurityGroupName'] = self.security_group_name
if self.v_switch_id is not None:
result['VSwitchId'] = self.v_switch_id
if self.volume_id is not None:
result['VolumeId'] = self.volume_id
if self.volume_mountpoint is not None:
result['VolumeMountpoint'] = self.volume_mountpoint
if self.volume_protocol is not None:
result['VolumeProtocol'] = self.volume_protocol
if self.volume_type is not None:
result['VolumeType'] = self.volume_type
if self.vpc_id is not None:
result['VpcId'] = self.vpc_id
if self.zone_id is not None:
result['ZoneId'] = self.zone_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('EcsOrder') is not None:
temp_model = CreateClusterRequestEcsOrder()
self.ecs_order = temp_model.from_map(m['EcsOrder'])
if m.get('AccountType') is not None:
self.account_type = m.get('AccountType')
self.application = []
if m.get('Application') is not None:
for k in m.get('Application'):
temp_model = CreateClusterRequestApplication()
self.application.append(temp_model.from_map(k))
if m.get('ComputeSpotPriceLimit') is not None:
self.compute_spot_price_limit = m.get('ComputeSpotPriceLimit')
if m.get('ComputeSpotStrategy') is not None:
self.compute_spot_strategy = m.get('ComputeSpotStrategy')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('EcsChargeType') is not None:
self.ecs_charge_type = m.get('EcsChargeType')
if m.get('EhpcVersion') is not None:
self.ehpc_version = m.get('EhpcVersion')
if m.get('HaEnable') is not None:
self.ha_enable = m.get('HaEnable')
if m.get('ImageId') is not None:
self.image_id = m.get('ImageId')
if m.get('ImageOwnerAlias') is not None:
self.image_owner_alias = m.get('ImageOwnerAlias')
if m.get('KeyPairName') is not None:
self.key_pair_name = m.get('KeyPairName')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('OsTag') is not None:
self.os_tag = m.get('OsTag')
if m.get('Password') is not None:
self.password = m.get('Password')
if m.get('RemoteDirectory') is not None:
self.remote_directory = m.get('RemoteDirectory')
if m.get('SccClusterId') is not None:
self.scc_cluster_id = m.get('SccClusterId')
if m.get('SchedulerType') is not None:
self.scheduler_type = m.get('SchedulerType')
if m.get('SecurityGroupId') is not None:
self.security_group_id = m.get('SecurityGroupId')
if m.get('SecurityGroupName') is not None:
self.security_group_name = m.get('SecurityGroupName')
if m.get('VSwitchId') is not None:
self.v_switch_id = m.get('VSwitchId')
if m.get('VolumeId') is not None:
self.volume_id = m.get('VolumeId')
if m.get('VolumeMountpoint') is not None:
self.volume_mountpoint = m.get('VolumeMountpoint')
if m.get('VolumeProtocol') is not None:
self.volume_protocol = m.get('VolumeProtocol')
if m.get('VolumeType') is not None:
self.volume_type = m.get('VolumeType')
if m.get('VpcId') is not None:
self.vpc_id = m.get('VpcId')
if m.get('ZoneId') is not None:
self.zone_id = m.get('ZoneId')
return self
class CreateClusterResponseBody(TeaModel):
def __init__(
self,
cluster_id: str = None,
request_id: str = None,
):
self.cluster_id = cluster_id
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreateClusterResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: CreateClusterResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = CreateClusterResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateJobTemplateRequest(TeaModel):
def __init__(
self,
array_request: str = None,
command_line: str = None,
name: str = None,
package_path: str = None,
priority: int = None,
re_runable: bool = None,
region_id: str = None,
runas_user: str = None,
stderr_redirect_path: str = None,
stdout_redirect_path: str = None,
variables: str = None,
):
self.array_request = array_request
self.command_line = command_line
self.name = name
self.package_path = package_path
self.priority = priority
self.re_runable = re_runable
self.region_id = region_id
self.runas_user = runas_user
self.stderr_redirect_path = stderr_redirect_path
self.stdout_redirect_path = stdout_redirect_path
self.variables = variables
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.array_request is not None:
result['ArrayRequest'] = self.array_request
if self.command_line is not None:
result['CommandLine'] = self.command_line
if self.name is not None:
result['Name'] = self.name
if self.package_path is not None:
result['PackagePath'] = self.package_path
if self.priority is not None:
result['Priority'] = self.priority
if self.re_runable is not None:
result['ReRunable'] = self.re_runable
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.runas_user is not None:
result['RunasUser'] = self.runas_user
if self.stderr_redirect_path is not None:
result['StderrRedirectPath'] = self.stderr_redirect_path
if self.stdout_redirect_path is not None:
result['StdoutRedirectPath'] = self.stdout_redirect_path
if self.variables is not None:
result['Variables'] = self.variables
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ArrayRequest') is not None:
self.array_request = m.get('ArrayRequest')
if m.get('CommandLine') is not None:
self.command_line = m.get('CommandLine')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('PackagePath') is not None:
self.package_path = m.get('PackagePath')
if m.get('Priority') is not None:
self.priority = m.get('Priority')
if m.get('ReRunable') is not None:
self.re_runable = m.get('ReRunable')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('RunasUser') is not None:
self.runas_user = m.get('RunasUser')
if m.get('StderrRedirectPath') is not None:
self.stderr_redirect_path = m.get('StderrRedirectPath')
if m.get('StdoutRedirectPath') is not None:
self.stdout_redirect_path = m.get('StdoutRedirectPath')
if m.get('Variables') is not None:
self.variables = m.get('Variables')
return self
class CreateJobTemplateResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
template_id: str = None,
):
self.request_id = request_id
self.template_id = template_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.template_id is not None:
result['TemplateId'] = self.template_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TemplateId') is not None:
self.template_id = m.get('TemplateId')
return self
class CreateJobTemplateResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: CreateJobTemplateResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = CreateJobTemplateResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteClusterRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
release_instance: str = None,
):
self.cluster_id = cluster_id
self.release_instance = release_instance
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.release_instance is not None:
result['ReleaseInstance'] = self.release_instance
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('ReleaseInstance') is not None:
self.release_instance = m.get('ReleaseInstance')
return self
class DeleteClusterResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteClusterResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteClusterResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = DeleteClusterResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteJobTemplatesRequest(TeaModel):
def __init__(
self,
region_id: str = None,
templates: str = None,
):
self.region_id = region_id
self.templates = templates
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.templates is not None:
result['Templates'] = self.templates
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('Templates') is not None:
self.templates = m.get('Templates')
return self
class DeleteJobTemplatesResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteJobTemplatesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteJobTemplatesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = DeleteJobTemplatesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteJobsRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
jobs: str = None,
):
self.cluster_id = cluster_id
self.jobs = jobs
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.jobs is not None:
result['Jobs'] = self.jobs
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('Jobs') is not None:
self.jobs = m.get('Jobs')
return self
class DeleteJobsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteJobsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteJobsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = DeleteJobsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteNodesRequestInstance(TeaModel):
def __init__(
self,
id: str = None,
):
self.id = id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class DeleteNodesRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
instance: List[DeleteNodesRequestInstance] = None,
release_instance: bool = None,
):
self.cluster_id = cluster_id
self.instance = instance
self.release_instance = release_instance
def validate(self):
if self.instance:
for k in self.instance:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
result['Instance'] = []
if self.instance is not None:
for k in self.instance:
result['Instance'].append(k.to_map() if k else None)
if self.release_instance is not None:
result['ReleaseInstance'] = self.release_instance
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
self.instance = []
if m.get('Instance') is not None:
for k in m.get('Instance'):
temp_model = DeleteNodesRequestInstance()
self.instance.append(temp_model.from_map(k))
if m.get('ReleaseInstance') is not None:
self.release_instance = m.get('ReleaseInstance')
return self
class DeleteNodesResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteNodesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteNodesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = DeleteNodesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteUsersRequestUser(TeaModel):
def __init__(
self,
name: str = None,
):
self.name = name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class DeleteUsersRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
user: List[DeleteUsersRequestUser] = None,
):
self.cluster_id = cluster_id
self.user = user
def validate(self):
if self.user:
for k in self.user:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
result['User'] = []
if self.user is not None:
for k in self.user:
result['User'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
self.user = []
if m.get('User') is not None:
for k in m.get('User'):
temp_model = DeleteUsersRequestUser()
self.user.append(temp_model.from_map(k))
return self
class DeleteUsersResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteUsersResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteUsersResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = DeleteUsersResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DescribeClusterRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
):
self.cluster_id = cluster_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
return self
class DescribeClusterResponseBodyClusterInfoApplicationsApplicationInfo(TeaModel):
def __init__(
self,
name: str = None,
tag: str = None,
version: str = None,
):
self.name = name
self.tag = tag
self.version = version
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.name is not None:
result['Name'] = self.name
if self.tag is not None:
result['Tag'] = self.tag
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Tag') is not None:
self.tag = m.get('Tag')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class DescribeClusterResponseBodyClusterInfoApplications(TeaModel):
def __init__(
self,
application_info: List[DescribeClusterResponseBodyClusterInfoApplicationsApplicationInfo] = None,
):
self.application_info = application_info
def validate(self):
if self.application_info:
for k in self.application_info:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['ApplicationInfo'] = []
if self.application_info is not None:
for k in self.application_info:
result['ApplicationInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.application_info = []
if m.get('ApplicationInfo') is not None:
for k in m.get('ApplicationInfo'):
temp_model = DescribeClusterResponseBodyClusterInfoApplicationsApplicationInfo()
self.application_info.append(temp_model.from_map(k))
return self
class DescribeClusterResponseBodyClusterInfoEcsInfoCompute(TeaModel):
def __init__(
self,
count: int = None,
instance_type: str = None,
):
self.count = count
self.instance_type = instance_type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.count is not None:
result['Count'] = self.count
if self.instance_type is not None:
result['InstanceType'] = self.instance_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Count') is not None:
self.count = m.get('Count')
if m.get('InstanceType') is not None:
self.instance_type = m.get('InstanceType')
return self
class DescribeClusterResponseBodyClusterInfoEcsInfoLogin(TeaModel):
def __init__(
self,
count: int = None,
instance_type: str = None,
):
self.count = count
self.instance_type = instance_type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.count is not None:
result['Count'] = self.count
if self.instance_type is not None:
result['InstanceType'] = self.instance_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Count') is not None:
self.count = m.get('Count')
if m.get('InstanceType') is not None:
self.instance_type = m.get('InstanceType')
return self
class DescribeClusterResponseBodyClusterInfoEcsInfoManager(TeaModel):
def __init__(
self,
count: int = None,
instance_type: str = None,
):
self.count = count
self.instance_type = instance_type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.count is not None:
result['Count'] = self.count
if self.instance_type is not None:
result['InstanceType'] = self.instance_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Count') is not None:
self.count = m.get('Count')
if m.get('InstanceType') is not None:
self.instance_type = m.get('InstanceType')
return self
class DescribeClusterResponseBodyClusterInfoEcsInfo(TeaModel):
def __init__(
self,
compute: DescribeClusterResponseBodyClusterInfoEcsInfoCompute = None,
login: DescribeClusterResponseBodyClusterInfoEcsInfoLogin = None,
manager: DescribeClusterResponseBodyClusterInfoEcsInfoManager = None,
):
self.compute = compute
self.login = login
self.manager = manager
def validate(self):
if self.compute:
self.compute.validate()
if self.login:
self.login.validate()
if self.manager:
self.manager.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.compute is not None:
result['Compute'] = self.compute.to_map()
if self.login is not None:
result['Login'] = self.login.to_map()
if self.manager is not None:
result['Manager'] = self.manager.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Compute') is not None:
temp_model = DescribeClusterResponseBodyClusterInfoEcsInfoCompute()
self.compute = temp_model.from_map(m['Compute'])
if m.get('Login') is not None:
temp_model = DescribeClusterResponseBodyClusterInfoEcsInfoLogin()
self.login = temp_model.from_map(m['Login'])
if m.get('Manager') is not None:
temp_model = DescribeClusterResponseBodyClusterInfoEcsInfoManager()
self.manager = temp_model.from_map(m['Manager'])
return self
class DescribeClusterResponseBodyClusterInfo(TeaModel):
def __init__(
self,
account_type: str = None,
applications: DescribeClusterResponseBodyClusterInfoApplications = None,
client_version: str = None,
create_time: str = None,
description: str = None,
ecs_charge_type: str = None,
ecs_info: DescribeClusterResponseBodyClusterInfoEcsInfo = None,
ha_enable: bool = None,
id: str = None,
image_id: str = None,
image_owner_alias: str = None,
key_pair_name: str = None,
name: str = None,
os_tag: str = None,
region_id: str = None,
remote_directory: str = None,
scc_cluster_id: str = None,
scheduler_type: str = None,
security_group_id: str = None,
status: str = None,
v_switch_id: str = None,
volume_id: str = None,
volume_mountpoint: str = None,
volume_protocol: str = None,
volume_type: str = None,
):
self.account_type = account_type
self.applications = applications
self.client_version = client_version
self.create_time = create_time
self.description = description
self.ecs_charge_type = ecs_charge_type
self.ecs_info = ecs_info
self.ha_enable = ha_enable
self.id = id
self.image_id = image_id
self.image_owner_alias = image_owner_alias
self.key_pair_name = key_pair_name
self.name = name
self.os_tag = os_tag
self.region_id = region_id
self.remote_directory = remote_directory
self.scc_cluster_id = scc_cluster_id
self.scheduler_type = scheduler_type
self.security_group_id = security_group_id
self.status = status
self.v_switch_id = v_switch_id
self.volume_id = volume_id
self.volume_mountpoint = volume_mountpoint
self.volume_protocol = volume_protocol
self.volume_type = volume_type
def validate(self):
if self.applications:
self.applications.validate()
if self.ecs_info:
self.ecs_info.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.account_type is not None:
result['AccountType'] = self.account_type
if self.applications is not None:
result['Applications'] = self.applications.to_map()
if self.client_version is not None:
result['ClientVersion'] = self.client_version
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.description is not None:
result['Description'] = self.description
if self.ecs_charge_type is not None:
result['EcsChargeType'] = self.ecs_charge_type
if self.ecs_info is not None:
result['EcsInfo'] = self.ecs_info.to_map()
if self.ha_enable is not None:
result['HaEnable'] = self.ha_enable
if self.id is not None:
result['Id'] = self.id
if self.image_id is not None:
result['ImageId'] = self.image_id
if self.image_owner_alias is not None:
result['ImageOwnerAlias'] = self.image_owner_alias
if self.key_pair_name is not None:
result['KeyPairName'] = self.key_pair_name
if self.name is not None:
result['Name'] = self.name
if self.os_tag is not None:
result['OsTag'] = self.os_tag
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.remote_directory is not None:
result['RemoteDirectory'] = self.remote_directory
if self.scc_cluster_id is not None:
result['SccClusterId'] = self.scc_cluster_id
if self.scheduler_type is not None:
result['SchedulerType'] = self.scheduler_type
if self.security_group_id is not None:
result['SecurityGroupId'] = self.security_group_id
if self.status is not None:
result['Status'] = self.status
if self.v_switch_id is not None:
result['VSwitchId'] = self.v_switch_id
if self.volume_id is not None:
result['VolumeId'] = self.volume_id
if self.volume_mountpoint is not None:
result['VolumeMountpoint'] = self.volume_mountpoint
if self.volume_protocol is not None:
result['VolumeProtocol'] = self.volume_protocol
if self.volume_type is not None:
result['VolumeType'] = self.volume_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('AccountType') is not None:
self.account_type = m.get('AccountType')
if m.get('Applications') is not None:
temp_model = DescribeClusterResponseBodyClusterInfoApplications()
self.applications = temp_model.from_map(m['Applications'])
if m.get('ClientVersion') is not None:
self.client_version = m.get('ClientVersion')
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('EcsChargeType') is not None:
self.ecs_charge_type = m.get('EcsChargeType')
if m.get('EcsInfo') is not None:
temp_model = DescribeClusterResponseBodyClusterInfoEcsInfo()
self.ecs_info = temp_model.from_map(m['EcsInfo'])
if m.get('HaEnable') is not None:
self.ha_enable = m.get('HaEnable')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('ImageId') is not None:
self.image_id = m.get('ImageId')
if m.get('ImageOwnerAlias') is not None:
self.image_owner_alias = m.get('ImageOwnerAlias')
if m.get('KeyPairName') is not None:
self.key_pair_name = m.get('KeyPairName')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('OsTag') is not None:
self.os_tag = m.get('OsTag')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('RemoteDirectory') is not None:
self.remote_directory = m.get('RemoteDirectory')
if m.get('SccClusterId') is not None:
self.scc_cluster_id = m.get('SccClusterId')
if m.get('SchedulerType') is not None:
self.scheduler_type = m.get('SchedulerType')
if m.get('SecurityGroupId') is not None:
self.security_group_id = m.get('SecurityGroupId')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('VSwitchId') is not None:
self.v_switch_id = m.get('VSwitchId')
if m.get('VolumeId') is not None:
self.volume_id = m.get('VolumeId')
if m.get('VolumeMountpoint') is not None:
self.volume_mountpoint = m.get('VolumeMountpoint')
if m.get('VolumeProtocol') is not None:
self.volume_protocol = m.get('VolumeProtocol')
if m.get('VolumeType') is not None:
self.volume_type = m.get('VolumeType')
return self
class DescribeClusterResponseBody(TeaModel):
def __init__(
self,
cluster_info: DescribeClusterResponseBodyClusterInfo = None,
request_id: str = None,
):
self.cluster_info = cluster_info
self.request_id = request_id
def validate(self):
if self.cluster_info:
self.cluster_info.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_info is not None:
result['ClusterInfo'] = self.cluster_info.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterInfo') is not None:
temp_model = DescribeClusterResponseBodyClusterInfo()
self.cluster_info = temp_model.from_map(m['ClusterInfo'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DescribeClusterResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DescribeClusterResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = DescribeClusterResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class EditJobTemplateRequest(TeaModel):
def __init__(
self,
array_request: str = None,
command_line: str = None,
name: str = None,
package_path: str = None,
priority: int = None,
re_runable: bool = None,
region_id: str = None,
runas_user: str = None,
stderr_redirect_path: str = None,
stdout_redirect_path: str = None,
template_id: str = None,
variables: str = None,
):
self.array_request = array_request
self.command_line = command_line
self.name = name
self.package_path = package_path
self.priority = priority
self.re_runable = re_runable
self.region_id = region_id
self.runas_user = runas_user
self.stderr_redirect_path = stderr_redirect_path
self.stdout_redirect_path = stdout_redirect_path
self.template_id = template_id
self.variables = variables
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.array_request is not None:
result['ArrayRequest'] = self.array_request
if self.command_line is not None:
result['CommandLine'] = self.command_line
if self.name is not None:
result['Name'] = self.name
if self.package_path is not None:
result['PackagePath'] = self.package_path
if self.priority is not None:
result['Priority'] = self.priority
if self.re_runable is not None:
result['ReRunable'] = self.re_runable
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.runas_user is not None:
result['RunasUser'] = self.runas_user
if self.stderr_redirect_path is not None:
result['StderrRedirectPath'] = self.stderr_redirect_path
if self.stdout_redirect_path is not None:
result['StdoutRedirectPath'] = self.stdout_redirect_path
if self.template_id is not None:
result['TemplateId'] = self.template_id
if self.variables is not None:
result['Variables'] = self.variables
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ArrayRequest') is not None:
self.array_request = m.get('ArrayRequest')
if m.get('CommandLine') is not None:
self.command_line = m.get('CommandLine')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('PackagePath') is not None:
self.package_path = m.get('PackagePath')
if m.get('Priority') is not None:
self.priority = m.get('Priority')
if m.get('ReRunable') is not None:
self.re_runable = m.get('ReRunable')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('RunasUser') is not None:
self.runas_user = m.get('RunasUser')
if m.get('StderrRedirectPath') is not None:
self.stderr_redirect_path = m.get('StderrRedirectPath')
if m.get('StdoutRedirectPath') is not None:
self.stdout_redirect_path = m.get('StdoutRedirectPath')
if m.get('TemplateId') is not None:
self.template_id = m.get('TemplateId')
if m.get('Variables') is not None:
self.variables = m.get('Variables')
return self
class EditJobTemplateResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
template_id: str = None,
):
self.request_id = request_id
self.template_id = template_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.template_id is not None:
result['TemplateId'] = self.template_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TemplateId') is not None:
self.template_id = m.get('TemplateId')
return self
class EditJobTemplateResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: EditJobTemplateResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = EditJobTemplateResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetAutoScaleConfigRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
):
self.cluster_id = cluster_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
return self
class GetAutoScaleConfigResponseBody(TeaModel):
def __init__(
self,
cluster_id: str = None,
cluster_type: str = None,
enable_auto_grow: bool = None,
enable_auto_shrink: bool = None,
exclude_nodes: str = None,
extra_nodes_grow_ratio: int = None,
grow_interval_in_minutes: int = None,
grow_ratio: int = None,
grow_timeout_in_minutes: int = None,
max_nodes_in_cluster: int = None,
request_id: str = None,
shrink_idle_times: int = None,
shrink_interval_in_minutes: int = None,
uid: str = None,
):
self.cluster_id = cluster_id
self.cluster_type = cluster_type
self.enable_auto_grow = enable_auto_grow
self.enable_auto_shrink = enable_auto_shrink
self.exclude_nodes = exclude_nodes
self.extra_nodes_grow_ratio = extra_nodes_grow_ratio
self.grow_interval_in_minutes = grow_interval_in_minutes
self.grow_ratio = grow_ratio
self.grow_timeout_in_minutes = grow_timeout_in_minutes
self.max_nodes_in_cluster = max_nodes_in_cluster
self.request_id = request_id
self.shrink_idle_times = shrink_idle_times
self.shrink_interval_in_minutes = shrink_interval_in_minutes
self.uid = uid
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.cluster_type is not None:
result['ClusterType'] = self.cluster_type
if self.enable_auto_grow is not None:
result['EnableAutoGrow'] = self.enable_auto_grow
if self.enable_auto_shrink is not None:
result['EnableAutoShrink'] = self.enable_auto_shrink
if self.exclude_nodes is not None:
result['ExcludeNodes'] = self.exclude_nodes
if self.extra_nodes_grow_ratio is not None:
result['ExtraNodesGrowRatio'] = self.extra_nodes_grow_ratio
if self.grow_interval_in_minutes is not None:
result['GrowIntervalInMinutes'] = self.grow_interval_in_minutes
if self.grow_ratio is not None:
result['GrowRatio'] = self.grow_ratio
if self.grow_timeout_in_minutes is not None:
result['GrowTimeoutInMinutes'] = self.grow_timeout_in_minutes
if self.max_nodes_in_cluster is not None:
result['MaxNodesInCluster'] = self.max_nodes_in_cluster
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.shrink_idle_times is not None:
result['ShrinkIdleTimes'] = self.shrink_idle_times
if self.shrink_interval_in_minutes is not None:
result['ShrinkIntervalInMinutes'] = self.shrink_interval_in_minutes
if self.uid is not None:
result['Uid'] = self.uid
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('ClusterType') is not None:
self.cluster_type = m.get('ClusterType')
if m.get('EnableAutoGrow') is not None:
self.enable_auto_grow = m.get('EnableAutoGrow')
if m.get('EnableAutoShrink') is not None:
self.enable_auto_shrink = m.get('EnableAutoShrink')
if m.get('ExcludeNodes') is not None:
self.exclude_nodes = m.get('ExcludeNodes')
if m.get('ExtraNodesGrowRatio') is not None:
self.extra_nodes_grow_ratio = m.get('ExtraNodesGrowRatio')
if m.get('GrowIntervalInMinutes') is not None:
self.grow_interval_in_minutes = m.get('GrowIntervalInMinutes')
if m.get('GrowRatio') is not None:
self.grow_ratio = m.get('GrowRatio')
if m.get('GrowTimeoutInMinutes') is not None:
self.grow_timeout_in_minutes = m.get('GrowTimeoutInMinutes')
if m.get('MaxNodesInCluster') is not None:
self.max_nodes_in_cluster = m.get('MaxNodesInCluster')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('ShrinkIdleTimes') is not None:
self.shrink_idle_times = m.get('ShrinkIdleTimes')
if m.get('ShrinkIntervalInMinutes') is not None:
self.shrink_interval_in_minutes = m.get('ShrinkIntervalInMinutes')
if m.get('Uid') is not None:
self.uid = m.get('Uid')
return self
class GetAutoScaleConfigResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetAutoScaleConfigResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = GetAutoScaleConfigResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListClusterLogsRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
page_number: int = None,
page_size: int = None,
):
self.cluster_id = cluster_id
self.page_number = page_number
self.page_size = page_size
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListClusterLogsResponseBodyLogsLogInfo(TeaModel):
def __init__(
self,
create_time: str = None,
level: str = None,
message: str = None,
operation: str = None,
):
self.create_time = create_time
self.level = level
self.message = message
self.operation = operation
def validate(self):
pass
def to_map(self):
_map = super().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.level is not None:
result['Level'] = self.level
if self.message is not None:
result['Message'] = self.message
if self.operation is not None:
result['Operation'] = self.operation
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('CreateTime') is not None:
self.create_time = m.get('CreateTime')
if m.get('Level') is not None:
self.level = m.get('Level')
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('Operation') is not None:
self.operation = m.get('Operation')
return self
class ListClusterLogsResponseBodyLogs(TeaModel):
def __init__(
self,
log_info: List[ListClusterLogsResponseBodyLogsLogInfo] = None,
):
self.log_info = log_info
def validate(self):
if self.log_info:
for k in self.log_info:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['LogInfo'] = []
if self.log_info is not None:
for k in self.log_info:
result['LogInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.log_info = []
if m.get('LogInfo') is not None:
for k in m.get('LogInfo'):
temp_model = ListClusterLogsResponseBodyLogsLogInfo()
self.log_info.append(temp_model.from_map(k))
return self
class ListClusterLogsResponseBody(TeaModel):
def __init__(
self,
cluster_id: str = None,
logs: ListClusterLogsResponseBodyLogs = None,
page_number: int = None,
page_size: int = None,
request_id: str = None,
total_count: int = None,
):
self.cluster_id = cluster_id
self.logs = logs
self.page_number = page_number
self.page_size = page_size
self.request_id = request_id
self.total_count = total_count
def validate(self):
if self.logs:
self.logs.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.logs is not None:
result['Logs'] = self.logs.to_map()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
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: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('Logs') is not None:
temp_model = ListClusterLogsResponseBodyLogs()
self.logs = temp_model.from_map(m['Logs'])
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
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 ListClusterLogsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListClusterLogsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ListClusterLogsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListClustersRequest(TeaModel):
def __init__(
self,
page_number: int = None,
page_size: int = None,
):
self.page_number = page_number
self.page_size = page_size
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListClustersResponseBodyClustersClusterInfoSimpleComputes(TeaModel):
def __init__(
self,
exception_count: int = None,
normal_count: int = None,
total: int = None,
):
self.exception_count = exception_count
self.normal_count = normal_count
self.total = total
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.exception_count is not None:
result['ExceptionCount'] = self.exception_count
if self.normal_count is not None:
result['NormalCount'] = self.normal_count
if self.total is not None:
result['Total'] = self.total
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ExceptionCount') is not None:
self.exception_count = m.get('ExceptionCount')
if m.get('NormalCount') is not None:
self.normal_count = m.get('NormalCount')
if m.get('Total') is not None:
self.total = m.get('Total')
return self
class ListClustersResponseBodyClustersClusterInfoSimpleManagers(TeaModel):
def __init__(
self,
exception_count: int = None,
normal_count: int = None,
total: int = None,
):
self.exception_count = exception_count
self.normal_count = normal_count
self.total = total
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.exception_count is not None:
result['ExceptionCount'] = self.exception_count
if self.normal_count is not None:
result['NormalCount'] = self.normal_count
if self.total is not None:
result['Total'] = self.total
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ExceptionCount') is not None:
self.exception_count = m.get('ExceptionCount')
if m.get('NormalCount') is not None:
self.normal_count = m.get('NormalCount')
if m.get('Total') is not None:
self.total = m.get('Total')
return self
class ListClustersResponseBodyClustersClusterInfoSimpleTotalResources(TeaModel):
def __init__(
self,
cpu: int = None,
gpu: int = None,
memory: int = None,
):
self.cpu = cpu
self.gpu = gpu
self.memory = memory
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cpu is not None:
result['Cpu'] = self.cpu
if self.gpu is not None:
result['Gpu'] = self.gpu
if self.memory is not None:
result['Memory'] = self.memory
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Cpu') is not None:
self.cpu = m.get('Cpu')
if m.get('Gpu') is not None:
self.gpu = m.get('Gpu')
if m.get('Memory') is not None:
self.memory = m.get('Memory')
return self
class ListClustersResponseBodyClustersClusterInfoSimpleUsedResources(TeaModel):
def __init__(
self,
cpu: int = None,
gpu: int = None,
memory: int = None,
):
self.cpu = cpu
self.gpu = gpu
self.memory = memory
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cpu is not None:
result['Cpu'] = self.cpu
if self.gpu is not None:
result['Gpu'] = self.gpu
if self.memory is not None:
result['Memory'] = self.memory
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Cpu') is not None:
self.cpu = m.get('Cpu')
if m.get('Gpu') is not None:
self.gpu = m.get('Gpu')
if m.get('Memory') is not None:
self.memory = m.get('Memory')
return self
class ListClustersResponseBodyClustersClusterInfoSimple(TeaModel):
def __init__(
self,
account_type: str = None,
computes: ListClustersResponseBodyClustersClusterInfoSimpleComputes = None,
count: int = None,
create_time: str = None,
description: str = None,
id: str = None,
image_id: str = None,
image_owner_alias: str = None,
instance_type: str = None,
login_nodes: str = None,
managers: ListClustersResponseBodyClustersClusterInfoSimpleManagers = None,
name: str = None,
os_tag: str = None,
region_id: str = None,
scheduler_type: str = None,
status: str = None,
total_resources: ListClustersResponseBodyClustersClusterInfoSimpleTotalResources = None,
used_resources: ListClustersResponseBodyClustersClusterInfoSimpleUsedResources = None,
zone_id: str = None,
):
self.account_type = account_type
self.computes = computes
self.count = count
self.create_time = create_time
self.description = description
self.id = id
self.image_id = image_id
self.image_owner_alias = image_owner_alias
self.instance_type = instance_type
self.login_nodes = login_nodes
self.managers = managers
self.name = name
self.os_tag = os_tag
self.region_id = region_id
self.scheduler_type = scheduler_type
self.status = status
self.total_resources = total_resources
self.used_resources = used_resources
self.zone_id = zone_id
def validate(self):
if self.computes:
self.computes.validate()
if self.managers:
self.managers.validate()
if self.total_resources:
self.total_resources.validate()
if self.used_resources:
self.used_resources.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.account_type is not None:
result['AccountType'] = self.account_type
if self.computes is not None:
result['Computes'] = self.computes.to_map()
if self.count is not None:
result['Count'] = self.count
if self.create_time is not None:
result['CreateTime'] = self.create_time
if self.description is not None:
result['Description'] = self.description
if self.id is not None:
result['Id'] = self.id
if self.image_id is not None:
result['ImageId'] = self.image_id
if self.image_owner_alias is not None:
result['ImageOwnerAlias'] = self.image_owner_alias
if self.instance_type is not None:
result['InstanceType'] = self.instance_type
if self.login_nodes is not None:
result['LoginNodes'] = self.login_nodes
if self.managers is not None:
result['Managers'] = self.managers.to_map()
if self.name is not None:
result['Name'] = self.name
if self.os_tag is not None:
result['OsTag'] = self.os_tag
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.scheduler_type is not None:
result['SchedulerType'] = self.scheduler_type
if self.status is not None:
result['Status'] = self.status
if self.total_resources is not None:
result['TotalResources'] = self.total_resources.to_map()
if self.used_resources is not None:
result['UsedResources'] = self.used_resources.to_map()
if self.zone_id is not None:
result['ZoneId'] = self.zone_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('AccountType') is not None:
self.account_type = m.get('AccountType')
if m.get('Computes') is not None:
temp_model = ListClustersResponseBodyClustersClusterInfoSimpleComputes()
self.computes = temp_model.from_map(m['Computes'])
if m.get('Count') is not None:
self.count = m.get('Count')
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('Id') is not None:
self.id = m.get('Id')
if m.get('ImageId') is not None:
self.image_id = m.get('ImageId')
if m.get('ImageOwnerAlias') is not None:
self.image_owner_alias = m.get('ImageOwnerAlias')
if m.get('InstanceType') is not None:
self.instance_type = m.get('InstanceType')
if m.get('LoginNodes') is not None:
self.login_nodes = m.get('LoginNodes')
if m.get('Managers') is not None:
temp_model = ListClustersResponseBodyClustersClusterInfoSimpleManagers()
self.managers = temp_model.from_map(m['Managers'])
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('OsTag') is not None:
self.os_tag = m.get('OsTag')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('SchedulerType') is not None:
self.scheduler_type = m.get('SchedulerType')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('TotalResources') is not None:
temp_model = ListClustersResponseBodyClustersClusterInfoSimpleTotalResources()
self.total_resources = temp_model.from_map(m['TotalResources'])
if m.get('UsedResources') is not None:
temp_model = ListClustersResponseBodyClustersClusterInfoSimpleUsedResources()
self.used_resources = temp_model.from_map(m['UsedResources'])
if m.get('ZoneId') is not None:
self.zone_id = m.get('ZoneId')
return self
class ListClustersResponseBodyClusters(TeaModel):
def __init__(
self,
cluster_info_simple: List[ListClustersResponseBodyClustersClusterInfoSimple] = None,
):
self.cluster_info_simple = cluster_info_simple
def validate(self):
if self.cluster_info_simple:
for k in self.cluster_info_simple:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['ClusterInfoSimple'] = []
if self.cluster_info_simple is not None:
for k in self.cluster_info_simple:
result['ClusterInfoSimple'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.cluster_info_simple = []
if m.get('ClusterInfoSimple') is not None:
for k in m.get('ClusterInfoSimple'):
temp_model = ListClustersResponseBodyClustersClusterInfoSimple()
self.cluster_info_simple.append(temp_model.from_map(k))
return self
class ListClustersResponseBody(TeaModel):
def __init__(
self,
clusters: ListClustersResponseBodyClusters = None,
page_number: int = None,
page_size: int = None,
request_id: str = None,
total_count: int = None,
):
self.clusters = clusters
self.page_number = page_number
self.page_size = page_size
self.request_id = request_id
self.total_count = total_count
def validate(self):
if self.clusters:
self.clusters.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.clusters is not None:
result['Clusters'] = self.clusters.to_map()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
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: dict = None):
m = m or dict()
if m.get('Clusters') is not None:
temp_model = ListClustersResponseBodyClusters()
self.clusters = temp_model.from_map(m['Clusters'])
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
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 ListClustersResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListClustersResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ListClustersResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListCurrentClientVersionResponseBody(TeaModel):
def __init__(
self,
client_version: str = None,
request_id: str = None,
):
self.client_version = client_version
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_version is not None:
result['ClientVersion'] = self.client_version
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientVersion') is not None:
self.client_version = m.get('ClientVersion')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ListCurrentClientVersionResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListCurrentClientVersionResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ListCurrentClientVersionResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListCustomImagesRequest(TeaModel):
def __init__(
self,
base_os_tag: str = None,
image_owner_alias: str = None,
region_id: str = None,
):
self.base_os_tag = base_os_tag
self.image_owner_alias = image_owner_alias
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.base_os_tag is not None:
result['BaseOsTag'] = self.base_os_tag
if self.image_owner_alias is not None:
result['ImageOwnerAlias'] = self.image_owner_alias
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('BaseOsTag') is not None:
self.base_os_tag = m.get('BaseOsTag')
if m.get('ImageOwnerAlias') is not None:
self.image_owner_alias = m.get('ImageOwnerAlias')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class ListCustomImagesResponseBodyImagesImageInfoBaseOsTag(TeaModel):
def __init__(
self,
architecture: str = None,
os_tag: str = None,
platform: str = None,
version: str = None,
):
self.architecture = architecture
self.os_tag = os_tag
self.platform = platform
self.version = version
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.architecture is not None:
result['Architecture'] = self.architecture
if self.os_tag is not None:
result['OsTag'] = self.os_tag
if self.platform is not None:
result['Platform'] = self.platform
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Architecture') is not None:
self.architecture = m.get('Architecture')
if m.get('OsTag') is not None:
self.os_tag = m.get('OsTag')
if m.get('Platform') is not None:
self.platform = m.get('Platform')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class ListCustomImagesResponseBodyImagesImageInfo(TeaModel):
def __init__(
self,
base_os_tag: ListCustomImagesResponseBodyImagesImageInfoBaseOsTag = None,
description: str = None,
image_id: str = None,
image_name: str = None,
image_owner_alias: str = None,
):
self.base_os_tag = base_os_tag
self.description = description
self.image_id = image_id
self.image_name = image_name
self.image_owner_alias = image_owner_alias
def validate(self):
if self.base_os_tag:
self.base_os_tag.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.base_os_tag is not None:
result['BaseOsTag'] = self.base_os_tag.to_map()
if self.description is not None:
result['Description'] = self.description
if self.image_id is not None:
result['ImageId'] = self.image_id
if self.image_name is not None:
result['ImageName'] = self.image_name
if self.image_owner_alias is not None:
result['ImageOwnerAlias'] = self.image_owner_alias
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('BaseOsTag') is not None:
temp_model = ListCustomImagesResponseBodyImagesImageInfoBaseOsTag()
self.base_os_tag = temp_model.from_map(m['BaseOsTag'])
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('ImageId') is not None:
self.image_id = m.get('ImageId')
if m.get('ImageName') is not None:
self.image_name = m.get('ImageName')
if m.get('ImageOwnerAlias') is not None:
self.image_owner_alias = m.get('ImageOwnerAlias')
return self
class ListCustomImagesResponseBodyImages(TeaModel):
def __init__(
self,
image_info: List[ListCustomImagesResponseBodyImagesImageInfo] = None,
):
self.image_info = image_info
def validate(self):
if self.image_info:
for k in self.image_info:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['ImageInfo'] = []
if self.image_info is not None:
for k in self.image_info:
result['ImageInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.image_info = []
if m.get('ImageInfo') is not None:
for k in m.get('ImageInfo'):
temp_model = ListCustomImagesResponseBodyImagesImageInfo()
self.image_info.append(temp_model.from_map(k))
return self
class ListCustomImagesResponseBody(TeaModel):
def __init__(
self,
images: ListCustomImagesResponseBodyImages = None,
request_id: str = None,
):
self.images = images
self.request_id = request_id
def validate(self):
if self.images:
self.images.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.images is not None:
result['Images'] = self.images.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Images') is not None:
temp_model = ListCustomImagesResponseBodyImages()
self.images = temp_model.from_map(m['Images'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ListCustomImagesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListCustomImagesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ListCustomImagesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListImagesResponseBodyOsTagsOsInfo(TeaModel):
def __init__(
self,
architecture: str = None,
os_tag: str = None,
platform: str = None,
version: str = None,
):
self.architecture = architecture
self.os_tag = os_tag
self.platform = platform
self.version = version
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.architecture is not None:
result['Architecture'] = self.architecture
if self.os_tag is not None:
result['OsTag'] = self.os_tag
if self.platform is not None:
result['Platform'] = self.platform
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Architecture') is not None:
self.architecture = m.get('Architecture')
if m.get('OsTag') is not None:
self.os_tag = m.get('OsTag')
if m.get('Platform') is not None:
self.platform = m.get('Platform')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class ListImagesResponseBodyOsTags(TeaModel):
def __init__(
self,
os_info: List[ListImagesResponseBodyOsTagsOsInfo] = None,
):
self.os_info = os_info
def validate(self):
if self.os_info:
for k in self.os_info:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['OsInfo'] = []
if self.os_info is not None:
for k in self.os_info:
result['OsInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.os_info = []
if m.get('OsInfo') is not None:
for k in m.get('OsInfo'):
temp_model = ListImagesResponseBodyOsTagsOsInfo()
self.os_info.append(temp_model.from_map(k))
return self
class ListImagesResponseBody(TeaModel):
def __init__(
self,
os_tags: ListImagesResponseBodyOsTags = None,
request_id: str = None,
):
self.os_tags = os_tags
self.request_id = request_id
def validate(self):
if self.os_tags:
self.os_tags.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.os_tags is not None:
result['OsTags'] = self.os_tags.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('OsTags') is not None:
temp_model = ListImagesResponseBodyOsTags()
self.os_tags = temp_model.from_map(m['OsTags'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ListImagesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListImagesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ListImagesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListJobTemplatesRequest(TeaModel):
def __init__(
self,
name: str = None,
page_number: int = None,
page_size: int = None,
region_id: str = None,
):
self.name = name
self.page_number = page_number
self.page_size = page_size
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.name is not None:
result['Name'] = self.name
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class ListJobTemplatesResponseBodyTemplatesJobTemplates(TeaModel):
def __init__(
self,
array_request: str = None,
command_line: str = None,
id: str = None,
name: str = None,
package_path: str = None,
priority: int = None,
re_runable: bool = None,
runas_user: str = None,
stderr_redirect_path: str = None,
stdout_redirect_path: str = None,
variables: str = None,
):
self.array_request = array_request
self.command_line = command_line
self.id = id
self.name = name
self.package_path = package_path
self.priority = priority
self.re_runable = re_runable
self.runas_user = runas_user
self.stderr_redirect_path = stderr_redirect_path
self.stdout_redirect_path = stdout_redirect_path
self.variables = variables
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.array_request is not None:
result['ArrayRequest'] = self.array_request
if self.command_line is not None:
result['CommandLine'] = self.command_line
if self.id is not None:
result['Id'] = self.id
if self.name is not None:
result['Name'] = self.name
if self.package_path is not None:
result['PackagePath'] = self.package_path
if self.priority is not None:
result['Priority'] = self.priority
if self.re_runable is not None:
result['ReRunable'] = self.re_runable
if self.runas_user is not None:
result['RunasUser'] = self.runas_user
if self.stderr_redirect_path is not None:
result['StderrRedirectPath'] = self.stderr_redirect_path
if self.stdout_redirect_path is not None:
result['StdoutRedirectPath'] = self.stdout_redirect_path
if self.variables is not None:
result['Variables'] = self.variables
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ArrayRequest') is not None:
self.array_request = m.get('ArrayRequest')
if m.get('CommandLine') is not None:
self.command_line = m.get('CommandLine')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('PackagePath') is not None:
self.package_path = m.get('PackagePath')
if m.get('Priority') is not None:
self.priority = m.get('Priority')
if m.get('ReRunable') is not None:
self.re_runable = m.get('ReRunable')
if m.get('RunasUser') is not None:
self.runas_user = m.get('RunasUser')
if m.get('StderrRedirectPath') is not None:
self.stderr_redirect_path = m.get('StderrRedirectPath')
if m.get('StdoutRedirectPath') is not None:
self.stdout_redirect_path = m.get('StdoutRedirectPath')
if m.get('Variables') is not None:
self.variables = m.get('Variables')
return self
class ListJobTemplatesResponseBodyTemplates(TeaModel):
def __init__(
self,
job_templates: List[ListJobTemplatesResponseBodyTemplatesJobTemplates] = None,
):
self.job_templates = job_templates
def validate(self):
if self.job_templates:
for k in self.job_templates:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['JobTemplates'] = []
if self.job_templates is not None:
for k in self.job_templates:
result['JobTemplates'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.job_templates = []
if m.get('JobTemplates') is not None:
for k in m.get('JobTemplates'):
temp_model = ListJobTemplatesResponseBodyTemplatesJobTemplates()
self.job_templates.append(temp_model.from_map(k))
return self
class ListJobTemplatesResponseBody(TeaModel):
def __init__(
self,
page_number: int = None,
page_size: int = None,
request_id: str = None,
templates: ListJobTemplatesResponseBodyTemplates = None,
total_count: int = None,
):
self.page_number = page_number
self.page_size = page_size
self.request_id = request_id
self.templates = templates
self.total_count = total_count
def validate(self):
if self.templates:
self.templates.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.templates is not None:
result['Templates'] = self.templates.to_map()
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Templates') is not None:
temp_model = ListJobTemplatesResponseBodyTemplates()
self.templates = temp_model.from_map(m['Templates'])
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListJobTemplatesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListJobTemplatesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ListJobTemplatesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListJobsRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
owner: str = None,
page_number: int = None,
page_size: int = None,
rerunable: str = None,
state: str = None,
):
self.cluster_id = cluster_id
self.owner = owner
self.page_number = page_number
self.page_size = page_size
self.rerunable = rerunable
self.state = state
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.owner is not None:
result['Owner'] = self.owner
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.rerunable is not None:
result['Rerunable'] = self.rerunable
if self.state is not None:
result['State'] = self.state
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('Owner') is not None:
self.owner = m.get('Owner')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('Rerunable') is not None:
self.rerunable = m.get('Rerunable')
if m.get('State') is not None:
self.state = m.get('State')
return self
class ListJobsResponseBodyJobsJobInfoResources(TeaModel):
def __init__(
self,
cores: int = None,
nodes: int = None,
):
self.cores = cores
self.nodes = nodes
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cores is not None:
result['Cores'] = self.cores
if self.nodes is not None:
result['Nodes'] = self.nodes
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Cores') is not None:
self.cores = m.get('Cores')
if m.get('Nodes') is not None:
self.nodes = m.get('Nodes')
return self
class ListJobsResponseBodyJobsJobInfo(TeaModel):
def __init__(
self,
array_request: str = None,
comment: str = None,
id: str = None,
last_modify_time: str = None,
name: str = None,
owner: str = None,
priority: int = None,
resources: ListJobsResponseBodyJobsJobInfoResources = None,
shell_path: str = None,
start_time: str = None,
state: str = None,
stderr: str = None,
stdout: str = None,
submit_time: str = None,
):
self.array_request = array_request
self.comment = comment
self.id = id
self.last_modify_time = last_modify_time
self.name = name
self.owner = owner
self.priority = priority
self.resources = resources
self.shell_path = shell_path
self.start_time = start_time
self.state = state
self.stderr = stderr
self.stdout = stdout
self.submit_time = submit_time
def validate(self):
if self.resources:
self.resources.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.array_request is not None:
result['ArrayRequest'] = self.array_request
if self.comment is not None:
result['Comment'] = self.comment
if self.id is not None:
result['Id'] = self.id
if self.last_modify_time is not None:
result['LastModifyTime'] = self.last_modify_time
if self.name is not None:
result['Name'] = self.name
if self.owner is not None:
result['Owner'] = self.owner
if self.priority is not None:
result['Priority'] = self.priority
if self.resources is not None:
result['Resources'] = self.resources.to_map()
if self.shell_path is not None:
result['ShellPath'] = self.shell_path
if self.start_time is not None:
result['StartTime'] = self.start_time
if self.state is not None:
result['State'] = self.state
if self.stderr is not None:
result['Stderr'] = self.stderr
if self.stdout is not None:
result['Stdout'] = self.stdout
if self.submit_time is not None:
result['SubmitTime'] = self.submit_time
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ArrayRequest') is not None:
self.array_request = m.get('ArrayRequest')
if m.get('Comment') is not None:
self.comment = m.get('Comment')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('LastModifyTime') is not None:
self.last_modify_time = m.get('LastModifyTime')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Owner') is not None:
self.owner = m.get('Owner')
if m.get('Priority') is not None:
self.priority = m.get('Priority')
if m.get('Resources') is not None:
temp_model = ListJobsResponseBodyJobsJobInfoResources()
self.resources = temp_model.from_map(m['Resources'])
if m.get('ShellPath') is not None:
self.shell_path = m.get('ShellPath')
if m.get('StartTime') is not None:
self.start_time = m.get('StartTime')
if m.get('State') is not None:
self.state = m.get('State')
if m.get('Stderr') is not None:
self.stderr = m.get('Stderr')
if m.get('Stdout') is not None:
self.stdout = m.get('Stdout')
if m.get('SubmitTime') is not None:
self.submit_time = m.get('SubmitTime')
return self
class ListJobsResponseBodyJobs(TeaModel):
def __init__(
self,
job_info: List[ListJobsResponseBodyJobsJobInfo] = None,
):
self.job_info = job_info
def validate(self):
if self.job_info:
for k in self.job_info:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['JobInfo'] = []
if self.job_info is not None:
for k in self.job_info:
result['JobInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.job_info = []
if m.get('JobInfo') is not None:
for k in m.get('JobInfo'):
temp_model = ListJobsResponseBodyJobsJobInfo()
self.job_info.append(temp_model.from_map(k))
return self
class ListJobsResponseBody(TeaModel):
def __init__(
self,
jobs: ListJobsResponseBodyJobs = None,
page_number: int = None,
page_size: int = None,
request_id: str = None,
total_count: int = None,
):
self.jobs = jobs
self.page_number = page_number
self.page_size = page_size
self.request_id = request_id
self.total_count = total_count
def validate(self):
if self.jobs:
self.jobs.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.jobs is not None:
result['Jobs'] = self.jobs.to_map()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
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: dict = None):
m = m or dict()
if m.get('Jobs') is not None:
temp_model = ListJobsResponseBodyJobs()
self.jobs = temp_model.from_map(m['Jobs'])
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
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 ListJobsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListJobsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ListJobsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListNodesRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
host_name: str = None,
page_number: int = None,
page_size: int = None,
role: str = None,
):
self.cluster_id = cluster_id
self.host_name = host_name
self.page_number = page_number
self.page_size = page_size
self.role = role
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.host_name is not None:
result['HostName'] = self.host_name
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
if self.role is not None:
result['Role'] = self.role
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('HostName') is not None:
self.host_name = m.get('HostName')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
if m.get('Role') is not None:
self.role = m.get('Role')
return self
class ListNodesResponseBodyNodesNodeInfoTotalResources(TeaModel):
def __init__(
self,
cpu: int = None,
gpu: int = None,
memory: int = None,
):
self.cpu = cpu
self.gpu = gpu
self.memory = memory
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cpu is not None:
result['Cpu'] = self.cpu
if self.gpu is not None:
result['Gpu'] = self.gpu
if self.memory is not None:
result['Memory'] = self.memory
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Cpu') is not None:
self.cpu = m.get('Cpu')
if m.get('Gpu') is not None:
self.gpu = m.get('Gpu')
if m.get('Memory') is not None:
self.memory = m.get('Memory')
return self
class ListNodesResponseBodyNodesNodeInfoUsedResources(TeaModel):
def __init__(
self,
cpu: int = None,
gpu: int = None,
memory: int = None,
):
self.cpu = cpu
self.gpu = gpu
self.memory = memory
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cpu is not None:
result['Cpu'] = self.cpu
if self.gpu is not None:
result['Gpu'] = self.gpu
if self.memory is not None:
result['Memory'] = self.memory
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Cpu') is not None:
self.cpu = m.get('Cpu')
if m.get('Gpu') is not None:
self.gpu = m.get('Gpu')
if m.get('Memory') is not None:
self.memory = m.get('Memory')
return self
class ListNodesResponseBodyNodesNodeInfo(TeaModel):
def __init__(
self,
add_time: str = None,
created_by_ehpc: bool = None,
expired: bool = None,
expired_time: str = None,
id: str = None,
image_id: str = None,
image_owner_alias: str = None,
lock_reason: str = None,
region_id: str = None,
role: str = None,
spot_strategy: str = None,
status: str = None,
total_resources: ListNodesResponseBodyNodesNodeInfoTotalResources = None,
used_resources: ListNodesResponseBodyNodesNodeInfoUsedResources = None,
):
self.add_time = add_time
self.created_by_ehpc = created_by_ehpc
self.expired = expired
self.expired_time = expired_time
self.id = id
self.image_id = image_id
self.image_owner_alias = image_owner_alias
self.lock_reason = lock_reason
self.region_id = region_id
self.role = role
self.spot_strategy = spot_strategy
self.status = status
self.total_resources = total_resources
self.used_resources = used_resources
def validate(self):
if self.total_resources:
self.total_resources.validate()
if self.used_resources:
self.used_resources.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.add_time is not None:
result['AddTime'] = self.add_time
if self.created_by_ehpc is not None:
result['CreatedByEhpc'] = self.created_by_ehpc
if self.expired is not None:
result['Expired'] = self.expired
if self.expired_time is not None:
result['ExpiredTime'] = self.expired_time
if self.id is not None:
result['Id'] = self.id
if self.image_id is not None:
result['ImageId'] = self.image_id
if self.image_owner_alias is not None:
result['ImageOwnerAlias'] = self.image_owner_alias
if self.lock_reason is not None:
result['LockReason'] = self.lock_reason
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.role is not None:
result['Role'] = self.role
if self.spot_strategy is not None:
result['SpotStrategy'] = self.spot_strategy
if self.status is not None:
result['Status'] = self.status
if self.total_resources is not None:
result['TotalResources'] = self.total_resources.to_map()
if self.used_resources is not None:
result['UsedResources'] = self.used_resources.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('AddTime') is not None:
self.add_time = m.get('AddTime')
if m.get('CreatedByEhpc') is not None:
self.created_by_ehpc = m.get('CreatedByEhpc')
if m.get('Expired') is not None:
self.expired = m.get('Expired')
if m.get('ExpiredTime') is not None:
self.expired_time = m.get('ExpiredTime')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('ImageId') is not None:
self.image_id = m.get('ImageId')
if m.get('ImageOwnerAlias') is not None:
self.image_owner_alias = m.get('ImageOwnerAlias')
if m.get('LockReason') is not None:
self.lock_reason = m.get('LockReason')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('Role') is not None:
self.role = m.get('Role')
if m.get('SpotStrategy') is not None:
self.spot_strategy = m.get('SpotStrategy')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('TotalResources') is not None:
temp_model = ListNodesResponseBodyNodesNodeInfoTotalResources()
self.total_resources = temp_model.from_map(m['TotalResources'])
if m.get('UsedResources') is not None:
temp_model = ListNodesResponseBodyNodesNodeInfoUsedResources()
self.used_resources = temp_model.from_map(m['UsedResources'])
return self
class ListNodesResponseBodyNodes(TeaModel):
def __init__(
self,
node_info: List[ListNodesResponseBodyNodesNodeInfo] = None,
):
self.node_info = node_info
def validate(self):
if self.node_info:
for k in self.node_info:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['NodeInfo'] = []
if self.node_info is not None:
for k in self.node_info:
result['NodeInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.node_info = []
if m.get('NodeInfo') is not None:
for k in m.get('NodeInfo'):
temp_model = ListNodesResponseBodyNodesNodeInfo()
self.node_info.append(temp_model.from_map(k))
return self
class ListNodesResponseBody(TeaModel):
def __init__(
self,
nodes: ListNodesResponseBodyNodes = None,
page_number: int = None,
page_size: int = None,
request_id: str = None,
total_count: int = None,
):
self.nodes = nodes
self.page_number = page_number
self.page_size = page_size
self.request_id = request_id
self.total_count = total_count
def validate(self):
if self.nodes:
self.nodes.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.nodes is not None:
result['Nodes'] = self.nodes.to_map()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
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: dict = None):
m = m or dict()
if m.get('Nodes') is not None:
temp_model = ListNodesResponseBodyNodes()
self.nodes = temp_model.from_map(m['Nodes'])
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
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 ListNodesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListNodesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ListNodesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListNodesNoPagingRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
host_name: str = None,
only_detached: bool = None,
role: str = None,
):
self.cluster_id = cluster_id
self.host_name = host_name
self.only_detached = only_detached
self.role = role
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.host_name is not None:
result['HostName'] = self.host_name
if self.only_detached is not None:
result['OnlyDetached'] = self.only_detached
if self.role is not None:
result['Role'] = self.role
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('HostName') is not None:
self.host_name = m.get('HostName')
if m.get('OnlyDetached') is not None:
self.only_detached = m.get('OnlyDetached')
if m.get('Role') is not None:
self.role = m.get('Role')
return self
class ListNodesNoPagingResponseBodyNodesNodeInfoTotalResources(TeaModel):
def __init__(
self,
cpu: int = None,
gpu: int = None,
memory: int = None,
):
self.cpu = cpu
self.gpu = gpu
self.memory = memory
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cpu is not None:
result['Cpu'] = self.cpu
if self.gpu is not None:
result['Gpu'] = self.gpu
if self.memory is not None:
result['Memory'] = self.memory
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Cpu') is not None:
self.cpu = m.get('Cpu')
if m.get('Gpu') is not None:
self.gpu = m.get('Gpu')
if m.get('Memory') is not None:
self.memory = m.get('Memory')
return self
class ListNodesNoPagingResponseBodyNodesNodeInfoUsedResources(TeaModel):
def __init__(
self,
cpu: int = None,
gpu: int = None,
memory: int = None,
):
self.cpu = cpu
self.gpu = gpu
self.memory = memory
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cpu is not None:
result['Cpu'] = self.cpu
if self.gpu is not None:
result['Gpu'] = self.gpu
if self.memory is not None:
result['Memory'] = self.memory
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Cpu') is not None:
self.cpu = m.get('Cpu')
if m.get('Gpu') is not None:
self.gpu = m.get('Gpu')
if m.get('Memory') is not None:
self.memory = m.get('Memory')
return self
class ListNodesNoPagingResponseBodyNodesNodeInfo(TeaModel):
def __init__(
self,
add_time: str = None,
created_by_ehpc: bool = None,
expired: bool = None,
expired_time: str = None,
id: str = None,
image_id: str = None,
image_owner_alias: str = None,
lock_reason: str = None,
region_id: str = None,
role: str = None,
spot_strategy: str = None,
status: str = None,
total_resources: ListNodesNoPagingResponseBodyNodesNodeInfoTotalResources = None,
used_resources: ListNodesNoPagingResponseBodyNodesNodeInfoUsedResources = None,
):
self.add_time = add_time
self.created_by_ehpc = created_by_ehpc
self.expired = expired
self.expired_time = expired_time
self.id = id
self.image_id = image_id
self.image_owner_alias = image_owner_alias
self.lock_reason = lock_reason
self.region_id = region_id
self.role = role
self.spot_strategy = spot_strategy
self.status = status
self.total_resources = total_resources
self.used_resources = used_resources
def validate(self):
if self.total_resources:
self.total_resources.validate()
if self.used_resources:
self.used_resources.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.add_time is not None:
result['AddTime'] = self.add_time
if self.created_by_ehpc is not None:
result['CreatedByEhpc'] = self.created_by_ehpc
if self.expired is not None:
result['Expired'] = self.expired
if self.expired_time is not None:
result['ExpiredTime'] = self.expired_time
if self.id is not None:
result['Id'] = self.id
if self.image_id is not None:
result['ImageId'] = self.image_id
if self.image_owner_alias is not None:
result['ImageOwnerAlias'] = self.image_owner_alias
if self.lock_reason is not None:
result['LockReason'] = self.lock_reason
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.role is not None:
result['Role'] = self.role
if self.spot_strategy is not None:
result['SpotStrategy'] = self.spot_strategy
if self.status is not None:
result['Status'] = self.status
if self.total_resources is not None:
result['TotalResources'] = self.total_resources.to_map()
if self.used_resources is not None:
result['UsedResources'] = self.used_resources.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('AddTime') is not None:
self.add_time = m.get('AddTime')
if m.get('CreatedByEhpc') is not None:
self.created_by_ehpc = m.get('CreatedByEhpc')
if m.get('Expired') is not None:
self.expired = m.get('Expired')
if m.get('ExpiredTime') is not None:
self.expired_time = m.get('ExpiredTime')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('ImageId') is not None:
self.image_id = m.get('ImageId')
if m.get('ImageOwnerAlias') is not None:
self.image_owner_alias = m.get('ImageOwnerAlias')
if m.get('LockReason') is not None:
self.lock_reason = m.get('LockReason')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('Role') is not None:
self.role = m.get('Role')
if m.get('SpotStrategy') is not None:
self.spot_strategy = m.get('SpotStrategy')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('TotalResources') is not None:
temp_model = ListNodesNoPagingResponseBodyNodesNodeInfoTotalResources()
self.total_resources = temp_model.from_map(m['TotalResources'])
if m.get('UsedResources') is not None:
temp_model = ListNodesNoPagingResponseBodyNodesNodeInfoUsedResources()
self.used_resources = temp_model.from_map(m['UsedResources'])
return self
class ListNodesNoPagingResponseBodyNodes(TeaModel):
def __init__(
self,
node_info: List[ListNodesNoPagingResponseBodyNodesNodeInfo] = None,
):
self.node_info = node_info
def validate(self):
if self.node_info:
for k in self.node_info:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['NodeInfo'] = []
if self.node_info is not None:
for k in self.node_info:
result['NodeInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.node_info = []
if m.get('NodeInfo') is not None:
for k in m.get('NodeInfo'):
temp_model = ListNodesNoPagingResponseBodyNodesNodeInfo()
self.node_info.append(temp_model.from_map(k))
return self
class ListNodesNoPagingResponseBody(TeaModel):
def __init__(
self,
nodes: ListNodesNoPagingResponseBodyNodes = None,
page_number: int = None,
page_size: int = None,
request_id: str = None,
total_count: int = None,
):
self.nodes = nodes
self.page_number = page_number
self.page_size = page_size
self.request_id = request_id
self.total_count = total_count
def validate(self):
if self.nodes:
self.nodes.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.nodes is not None:
result['Nodes'] = self.nodes.to_map()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
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: dict = None):
m = m or dict()
if m.get('Nodes') is not None:
temp_model = ListNodesNoPagingResponseBodyNodes()
self.nodes = temp_model.from_map(m['Nodes'])
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
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 ListNodesNoPagingResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListNodesNoPagingResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ListNodesNoPagingResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListPreferredEcsTypesRequest(TeaModel):
def __init__(
self,
spot_strategy: str = None,
zone_id: str = None,
):
self.spot_strategy = spot_strategy
self.zone_id = zone_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.spot_strategy is not None:
result['SpotStrategy'] = self.spot_strategy
if self.zone_id is not None:
result['ZoneId'] = self.zone_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('SpotStrategy') is not None:
self.spot_strategy = m.get('SpotStrategy')
if m.get('ZoneId') is not None:
self.zone_id = m.get('ZoneId')
return self
class ListPreferredEcsTypesResponseBodySeriesSeriesInfoRolesCompute(TeaModel):
def __init__(
self,
instance_type_id: List[str] = None,
):
self.instance_type_id = instance_type_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.instance_type_id is not None:
result['InstanceTypeId'] = self.instance_type_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('InstanceTypeId') is not None:
self.instance_type_id = m.get('InstanceTypeId')
return self
class ListPreferredEcsTypesResponseBodySeriesSeriesInfoRolesLogin(TeaModel):
def __init__(
self,
instance_type_id: List[str] = None,
):
self.instance_type_id = instance_type_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.instance_type_id is not None:
result['InstanceTypeId'] = self.instance_type_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('InstanceTypeId') is not None:
self.instance_type_id = m.get('InstanceTypeId')
return self
class ListPreferredEcsTypesResponseBodySeriesSeriesInfoRolesManager(TeaModel):
def __init__(
self,
instance_type_id: List[str] = None,
):
self.instance_type_id = instance_type_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.instance_type_id is not None:
result['InstanceTypeId'] = self.instance_type_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('InstanceTypeId') is not None:
self.instance_type_id = m.get('InstanceTypeId')
return self
class ListPreferredEcsTypesResponseBodySeriesSeriesInfoRoles(TeaModel):
def __init__(
self,
compute: ListPreferredEcsTypesResponseBodySeriesSeriesInfoRolesCompute = None,
login: ListPreferredEcsTypesResponseBodySeriesSeriesInfoRolesLogin = None,
manager: ListPreferredEcsTypesResponseBodySeriesSeriesInfoRolesManager = None,
):
self.compute = compute
self.login = login
self.manager = manager
def validate(self):
if self.compute:
self.compute.validate()
if self.login:
self.login.validate()
if self.manager:
self.manager.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.compute is not None:
result['Compute'] = self.compute.to_map()
if self.login is not None:
result['Login'] = self.login.to_map()
if self.manager is not None:
result['Manager'] = self.manager.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Compute') is not None:
temp_model = ListPreferredEcsTypesResponseBodySeriesSeriesInfoRolesCompute()
self.compute = temp_model.from_map(m['Compute'])
if m.get('Login') is not None:
temp_model = ListPreferredEcsTypesResponseBodySeriesSeriesInfoRolesLogin()
self.login = temp_model.from_map(m['Login'])
if m.get('Manager') is not None:
temp_model = ListPreferredEcsTypesResponseBodySeriesSeriesInfoRolesManager()
self.manager = temp_model.from_map(m['Manager'])
return self
class ListPreferredEcsTypesResponseBodySeriesSeriesInfo(TeaModel):
def __init__(
self,
roles: ListPreferredEcsTypesResponseBodySeriesSeriesInfoRoles = None,
series_id: str = None,
series_name: str = None,
):
self.roles = roles
self.series_id = series_id
self.series_name = series_name
def validate(self):
if self.roles:
self.roles.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.roles is not None:
result['Roles'] = self.roles.to_map()
if self.series_id is not None:
result['SeriesId'] = self.series_id
if self.series_name is not None:
result['SeriesName'] = self.series_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Roles') is not None:
temp_model = ListPreferredEcsTypesResponseBodySeriesSeriesInfoRoles()
self.roles = temp_model.from_map(m['Roles'])
if m.get('SeriesId') is not None:
self.series_id = m.get('SeriesId')
if m.get('SeriesName') is not None:
self.series_name = m.get('SeriesName')
return self
class ListPreferredEcsTypesResponseBodySeries(TeaModel):
def __init__(
self,
series_info: List[ListPreferredEcsTypesResponseBodySeriesSeriesInfo] = None,
):
self.series_info = series_info
def validate(self):
if self.series_info:
for k in self.series_info:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['SeriesInfo'] = []
if self.series_info is not None:
for k in self.series_info:
result['SeriesInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.series_info = []
if m.get('SeriesInfo') is not None:
for k in m.get('SeriesInfo'):
temp_model = ListPreferredEcsTypesResponseBodySeriesSeriesInfo()
self.series_info.append(temp_model.from_map(k))
return self
class ListPreferredEcsTypesResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
series: ListPreferredEcsTypesResponseBodySeries = None,
support_spot_instance: bool = None,
):
self.request_id = request_id
self.series = series
self.support_spot_instance = support_spot_instance
def validate(self):
if self.series:
self.series.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.series is not None:
result['Series'] = self.series.to_map()
if self.support_spot_instance is not None:
result['SupportSpotInstance'] = self.support_spot_instance
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Series') is not None:
temp_model = ListPreferredEcsTypesResponseBodySeries()
self.series = temp_model.from_map(m['Series'])
if m.get('SupportSpotInstance') is not None:
self.support_spot_instance = m.get('SupportSpotInstance')
return self
class ListPreferredEcsTypesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListPreferredEcsTypesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ListPreferredEcsTypesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListRegionsResponseBodyRegionsRegionInfo(TeaModel):
def __init__(
self,
local_name: str = None,
region_id: str = None,
):
self.local_name = local_name
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().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_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('LocalName') is not None:
self.local_name = m.get('LocalName')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class ListRegionsResponseBodyRegions(TeaModel):
def __init__(
self,
region_info: List[ListRegionsResponseBodyRegionsRegionInfo] = None,
):
self.region_info = region_info
def validate(self):
if self.region_info:
for k in self.region_info:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['RegionInfo'] = []
if self.region_info is not None:
for k in self.region_info:
result['RegionInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.region_info = []
if m.get('RegionInfo') is not None:
for k in m.get('RegionInfo'):
temp_model = ListRegionsResponseBodyRegionsRegionInfo()
self.region_info.append(temp_model.from_map(k))
return self
class ListRegionsResponseBody(TeaModel):
def __init__(
self,
regions: ListRegionsResponseBodyRegions = None,
request_id: str = None,
):
self.regions = regions
self.request_id = request_id
def validate(self):
if self.regions:
self.regions.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.regions is not None:
result['Regions'] = self.regions.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Regions') is not None:
temp_model = ListRegionsResponseBodyRegions()
self.regions = temp_model.from_map(m['Regions'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ListRegionsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListRegionsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 ListSoftwaresRequest(TeaModel):
def __init__(
self,
ehpc_version: str = None,
):
self.ehpc_version = ehpc_version
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.ehpc_version is not None:
result['EhpcVersion'] = self.ehpc_version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('EhpcVersion') is not None:
self.ehpc_version = m.get('EhpcVersion')
return self
class ListSoftwaresResponseBodySoftwaresSoftwareInfoApplicationsApplicationInfo(TeaModel):
def __init__(
self,
name: str = None,
required: bool = None,
tag: str = None,
version: str = None,
):
self.name = name
self.required = required
self.tag = tag
self.version = version
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.name is not None:
result['Name'] = self.name
if self.required is not None:
result['Required'] = self.required
if self.tag is not None:
result['Tag'] = self.tag
if self.version is not None:
result['Version'] = self.version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Required') is not None:
self.required = m.get('Required')
if m.get('Tag') is not None:
self.tag = m.get('Tag')
if m.get('Version') is not None:
self.version = m.get('Version')
return self
class ListSoftwaresResponseBodySoftwaresSoftwareInfoApplications(TeaModel):
def __init__(
self,
application_info: List[ListSoftwaresResponseBodySoftwaresSoftwareInfoApplicationsApplicationInfo] = None,
):
self.application_info = application_info
def validate(self):
if self.application_info:
for k in self.application_info:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['ApplicationInfo'] = []
if self.application_info is not None:
for k in self.application_info:
result['ApplicationInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.application_info = []
if m.get('ApplicationInfo') is not None:
for k in m.get('ApplicationInfo'):
temp_model = ListSoftwaresResponseBodySoftwaresSoftwareInfoApplicationsApplicationInfo()
self.application_info.append(temp_model.from_map(k))
return self
class ListSoftwaresResponseBodySoftwaresSoftwareInfo(TeaModel):
def __init__(
self,
account_type: str = None,
account_version: str = None,
applications: ListSoftwaresResponseBodySoftwaresSoftwareInfoApplications = None,
ehpc_version: str = None,
os_tag: str = None,
scheduler_type: str = None,
scheduler_version: str = None,
):
self.account_type = account_type
self.account_version = account_version
self.applications = applications
self.ehpc_version = ehpc_version
self.os_tag = os_tag
self.scheduler_type = scheduler_type
self.scheduler_version = scheduler_version
def validate(self):
if self.applications:
self.applications.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.account_type is not None:
result['AccountType'] = self.account_type
if self.account_version is not None:
result['AccountVersion'] = self.account_version
if self.applications is not None:
result['Applications'] = self.applications.to_map()
if self.ehpc_version is not None:
result['EhpcVersion'] = self.ehpc_version
if self.os_tag is not None:
result['OsTag'] = self.os_tag
if self.scheduler_type is not None:
result['SchedulerType'] = self.scheduler_type
if self.scheduler_version is not None:
result['SchedulerVersion'] = self.scheduler_version
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('AccountType') is not None:
self.account_type = m.get('AccountType')
if m.get('AccountVersion') is not None:
self.account_version = m.get('AccountVersion')
if m.get('Applications') is not None:
temp_model = ListSoftwaresResponseBodySoftwaresSoftwareInfoApplications()
self.applications = temp_model.from_map(m['Applications'])
if m.get('EhpcVersion') is not None:
self.ehpc_version = m.get('EhpcVersion')
if m.get('OsTag') is not None:
self.os_tag = m.get('OsTag')
if m.get('SchedulerType') is not None:
self.scheduler_type = m.get('SchedulerType')
if m.get('SchedulerVersion') is not None:
self.scheduler_version = m.get('SchedulerVersion')
return self
class ListSoftwaresResponseBodySoftwares(TeaModel):
def __init__(
self,
software_info: List[ListSoftwaresResponseBodySoftwaresSoftwareInfo] = None,
):
self.software_info = software_info
def validate(self):
if self.software_info:
for k in self.software_info:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['SoftwareInfo'] = []
if self.software_info is not None:
for k in self.software_info:
result['SoftwareInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.software_info = []
if m.get('SoftwareInfo') is not None:
for k in m.get('SoftwareInfo'):
temp_model = ListSoftwaresResponseBodySoftwaresSoftwareInfo()
self.software_info.append(temp_model.from_map(k))
return self
class ListSoftwaresResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
softwares: ListSoftwaresResponseBodySoftwares = None,
):
self.request_id = request_id
self.softwares = softwares
def validate(self):
if self.softwares:
self.softwares.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.softwares is not None:
result['Softwares'] = self.softwares.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Softwares') is not None:
temp_model = ListSoftwaresResponseBodySoftwares()
self.softwares = temp_model.from_map(m['Softwares'])
return self
class ListSoftwaresResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListSoftwaresResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ListSoftwaresResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListUsersRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
page_number: int = None,
page_size: int = None,
):
self.cluster_id = cluster_id
self.page_number = page_number
self.page_size = page_size
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListUsersResponseBodyUsersUserInfo(TeaModel):
def __init__(
self,
add_time: str = None,
group: str = None,
name: str = None,
):
self.add_time = add_time
self.group = group
self.name = name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.add_time is not None:
result['AddTime'] = self.add_time
if self.group is not None:
result['Group'] = self.group
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('AddTime') is not None:
self.add_time = m.get('AddTime')
if m.get('Group') is not None:
self.group = m.get('Group')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class ListUsersResponseBodyUsers(TeaModel):
def __init__(
self,
user_info: List[ListUsersResponseBodyUsersUserInfo] = None,
):
self.user_info = user_info
def validate(self):
if self.user_info:
for k in self.user_info:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['UserInfo'] = []
if self.user_info is not None:
for k in self.user_info:
result['UserInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.user_info = []
if m.get('UserInfo') is not None:
for k in m.get('UserInfo'):
temp_model = ListUsersResponseBodyUsersUserInfo()
self.user_info.append(temp_model.from_map(k))
return self
class ListUsersResponseBody(TeaModel):
def __init__(
self,
page_number: int = None,
page_size: int = None,
request_id: str = None,
total_count: int = None,
users: ListUsersResponseBodyUsers = None,
):
self.page_number = page_number
self.page_size = page_size
self.request_id = request_id
self.total_count = total_count
self.users = users
def validate(self):
if self.users:
self.users.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
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.users is not None:
result['Users'] = self.users.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
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('Users') is not None:
temp_model = ListUsersResponseBodyUsers()
self.users = temp_model.from_map(m['Users'])
return self
class ListUsersResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListUsersResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ListUsersResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListVolumesRequest(TeaModel):
def __init__(
self,
page_number: int = None,
page_size: int = None,
):
self.page_number = page_number
self.page_size = page_size
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
return self
class ListVolumesResponseBodyVolumesVolumeInfo(TeaModel):
def __init__(
self,
cluster_id: str = None,
cluster_name: str = None,
region_id: str = None,
remote_directory: str = None,
volume_id: str = None,
volume_mountpoint: str = None,
volume_protocol: str = None,
volume_type: str = None,
):
self.cluster_id = cluster_id
self.cluster_name = cluster_name
self.region_id = region_id
self.remote_directory = remote_directory
self.volume_id = volume_id
self.volume_mountpoint = volume_mountpoint
self.volume_protocol = volume_protocol
self.volume_type = volume_type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.cluster_name is not None:
result['ClusterName'] = self.cluster_name
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.remote_directory is not None:
result['RemoteDirectory'] = self.remote_directory
if self.volume_id is not None:
result['VolumeId'] = self.volume_id
if self.volume_mountpoint is not None:
result['VolumeMountpoint'] = self.volume_mountpoint
if self.volume_protocol is not None:
result['VolumeProtocol'] = self.volume_protocol
if self.volume_type is not None:
result['VolumeType'] = self.volume_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('ClusterName') is not None:
self.cluster_name = m.get('ClusterName')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('RemoteDirectory') is not None:
self.remote_directory = m.get('RemoteDirectory')
if m.get('VolumeId') is not None:
self.volume_id = m.get('VolumeId')
if m.get('VolumeMountpoint') is not None:
self.volume_mountpoint = m.get('VolumeMountpoint')
if m.get('VolumeProtocol') is not None:
self.volume_protocol = m.get('VolumeProtocol')
if m.get('VolumeType') is not None:
self.volume_type = m.get('VolumeType')
return self
class ListVolumesResponseBodyVolumes(TeaModel):
def __init__(
self,
volume_info: List[ListVolumesResponseBodyVolumesVolumeInfo] = None,
):
self.volume_info = volume_info
def validate(self):
if self.volume_info:
for k in self.volume_info:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['VolumeInfo'] = []
if self.volume_info is not None:
for k in self.volume_info:
result['VolumeInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.volume_info = []
if m.get('VolumeInfo') is not None:
for k in m.get('VolumeInfo'):
temp_model = ListVolumesResponseBodyVolumesVolumeInfo()
self.volume_info.append(temp_model.from_map(k))
return self
class ListVolumesResponseBody(TeaModel):
def __init__(
self,
page_number: int = None,
page_size: int = None,
request_id: str = None,
total_count: int = None,
volumes: ListVolumesResponseBodyVolumes = None,
):
self.page_number = page_number
self.page_size = page_size
self.request_id = request_id
self.total_count = total_count
self.volumes = volumes
def validate(self):
if self.volumes:
self.volumes.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.page_number is not None:
result['PageNumber'] = self.page_number
if self.page_size is not None:
result['PageSize'] = self.page_size
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.volumes is not None:
result['Volumes'] = self.volumes.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('PageNumber') is not None:
self.page_number = m.get('PageNumber')
if m.get('PageSize') is not None:
self.page_size = m.get('PageSize')
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('Volumes') is not None:
temp_model = ListVolumesResponseBodyVolumes()
self.volumes = temp_model.from_map(m['Volumes'])
return self
class ListVolumesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListVolumesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ListVolumesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ModifyClusterAttributesRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
description: str = None,
name: str = None,
):
self.cluster_id = cluster_id
self.description = description
self.name = name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.description is not None:
result['Description'] = self.description
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class ModifyClusterAttributesResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ModifyClusterAttributesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ModifyClusterAttributesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ModifyClusterAttributesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ModifyUserGroupsRequestUser(TeaModel):
def __init__(
self,
group: str = None,
name: str = None,
):
self.group = group
self.name = name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.group is not None:
result['Group'] = self.group
if self.name is not None:
result['Name'] = self.name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Group') is not None:
self.group = m.get('Group')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class ModifyUserGroupsRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
user: List[ModifyUserGroupsRequestUser] = None,
):
self.cluster_id = cluster_id
self.user = user
def validate(self):
if self.user:
for k in self.user:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
result['User'] = []
if self.user is not None:
for k in self.user:
result['User'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
self.user = []
if m.get('User') is not None:
for k in m.get('User'):
temp_model = ModifyUserGroupsRequestUser()
self.user.append(temp_model.from_map(k))
return self
class ModifyUserGroupsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ModifyUserGroupsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ModifyUserGroupsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ModifyUserGroupsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ModifyUserPasswordsRequestUser(TeaModel):
def __init__(
self,
name: str = None,
password: str = None,
):
self.name = name
self.password = password
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.name is not None:
result['Name'] = self.name
if self.password is not None:
result['Password'] = self.password
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Password') is not None:
self.password = m.get('Password')
return self
class ModifyUserPasswordsRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
user: List[ModifyUserPasswordsRequestUser] = None,
):
self.cluster_id = cluster_id
self.user = user
def validate(self):
if self.user:
for k in self.user:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
result['User'] = []
if self.user is not None:
for k in self.user:
result['User'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
self.user = []
if m.get('User') is not None:
for k in m.get('User'):
temp_model = ModifyUserPasswordsRequestUser()
self.user.append(temp_model.from_map(k))
return self
class ModifyUserPasswordsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ModifyUserPasswordsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ModifyUserPasswordsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ModifyUserPasswordsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RerunJobsRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
jobs: str = None,
):
self.cluster_id = cluster_id
self.jobs = jobs
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.jobs is not None:
result['Jobs'] = self.jobs
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('Jobs') is not None:
self.jobs = m.get('Jobs')
return self
class RerunJobsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RerunJobsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: RerunJobsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = RerunJobsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ResetNodesRequestInstance(TeaModel):
def __init__(
self,
id: str = None,
):
self.id = id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.id is not None:
result['Id'] = self.id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Id') is not None:
self.id = m.get('Id')
return self
class ResetNodesRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
instance: List[ResetNodesRequestInstance] = None,
):
self.cluster_id = cluster_id
self.instance = instance
def validate(self):
if self.instance:
for k in self.instance:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
result['Instance'] = []
if self.instance is not None:
for k in self.instance:
result['Instance'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
self.instance = []
if m.get('Instance') is not None:
for k in m.get('Instance'):
temp_model = ResetNodesRequestInstance()
self.instance.append(temp_model.from_map(k))
return self
class ResetNodesResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ResetNodesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ResetNodesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = ResetNodesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class SetAutoScaleConfigRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
enable_auto_grow: bool = None,
enable_auto_shrink: bool = None,
exclude_nodes: str = None,
extra_nodes_grow_ratio: int = None,
grow_interval_in_minutes: int = None,
grow_ratio: int = None,
grow_timeout_in_minutes: int = None,
max_nodes_in_cluster: int = None,
shrink_idle_times: int = None,
shrink_interval_in_minutes: int = None,
):
self.cluster_id = cluster_id
self.enable_auto_grow = enable_auto_grow
self.enable_auto_shrink = enable_auto_shrink
self.exclude_nodes = exclude_nodes
self.extra_nodes_grow_ratio = extra_nodes_grow_ratio
self.grow_interval_in_minutes = grow_interval_in_minutes
self.grow_ratio = grow_ratio
self.grow_timeout_in_minutes = grow_timeout_in_minutes
self.max_nodes_in_cluster = max_nodes_in_cluster
self.shrink_idle_times = shrink_idle_times
self.shrink_interval_in_minutes = shrink_interval_in_minutes
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.enable_auto_grow is not None:
result['EnableAutoGrow'] = self.enable_auto_grow
if self.enable_auto_shrink is not None:
result['EnableAutoShrink'] = self.enable_auto_shrink
if self.exclude_nodes is not None:
result['ExcludeNodes'] = self.exclude_nodes
if self.extra_nodes_grow_ratio is not None:
result['ExtraNodesGrowRatio'] = self.extra_nodes_grow_ratio
if self.grow_interval_in_minutes is not None:
result['GrowIntervalInMinutes'] = self.grow_interval_in_minutes
if self.grow_ratio is not None:
result['GrowRatio'] = self.grow_ratio
if self.grow_timeout_in_minutes is not None:
result['GrowTimeoutInMinutes'] = self.grow_timeout_in_minutes
if self.max_nodes_in_cluster is not None:
result['MaxNodesInCluster'] = self.max_nodes_in_cluster
if self.shrink_idle_times is not None:
result['ShrinkIdleTimes'] = self.shrink_idle_times
if self.shrink_interval_in_minutes is not None:
result['ShrinkIntervalInMinutes'] = self.shrink_interval_in_minutes
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('EnableAutoGrow') is not None:
self.enable_auto_grow = m.get('EnableAutoGrow')
if m.get('EnableAutoShrink') is not None:
self.enable_auto_shrink = m.get('EnableAutoShrink')
if m.get('ExcludeNodes') is not None:
self.exclude_nodes = m.get('ExcludeNodes')
if m.get('ExtraNodesGrowRatio') is not None:
self.extra_nodes_grow_ratio = m.get('ExtraNodesGrowRatio')
if m.get('GrowIntervalInMinutes') is not None:
self.grow_interval_in_minutes = m.get('GrowIntervalInMinutes')
if m.get('GrowRatio') is not None:
self.grow_ratio = m.get('GrowRatio')
if m.get('GrowTimeoutInMinutes') is not None:
self.grow_timeout_in_minutes = m.get('GrowTimeoutInMinutes')
if m.get('MaxNodesInCluster') is not None:
self.max_nodes_in_cluster = m.get('MaxNodesInCluster')
if m.get('ShrinkIdleTimes') is not None:
self.shrink_idle_times = m.get('ShrinkIdleTimes')
if m.get('ShrinkIntervalInMinutes') is not None:
self.shrink_interval_in_minutes = m.get('ShrinkIntervalInMinutes')
return self
class SetAutoScaleConfigResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class SetAutoScaleConfigResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: SetAutoScaleConfigResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = SetAutoScaleConfigResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class SetJobUserRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
runas_user: str = None,
runas_user_password: str = None,
):
self.cluster_id = cluster_id
self.runas_user = runas_user
self.runas_user_password = runas_user_password
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.runas_user is not None:
result['RunasUser'] = self.runas_user
if self.runas_user_password is not None:
result['RunasUserPassword'] = self.runas_user_password
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('RunasUser') is not None:
self.runas_user = m.get('RunasUser')
if m.get('RunasUserPassword') is not None:
self.runas_user_password = m.get('RunasUserPassword')
return self
class SetJobUserResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class SetJobUserResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: SetJobUserResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = SetJobUserResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class StopJobsRequest(TeaModel):
def __init__(
self,
cluster_id: str = None,
jobs: str = None,
):
self.cluster_id = cluster_id
self.jobs = jobs
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.jobs is not None:
result['Jobs'] = self.jobs
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('Jobs') is not None:
self.jobs = m.get('Jobs')
return self
class StopJobsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class StopJobsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: StopJobsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = StopJobsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class SubmitJobRequest(TeaModel):
def __init__(
self,
array_request: str = None,
cluster_id: str = None,
command_line: str = None,
name: str = None,
package_path: str = None,
priority: int = None,
re_runable: bool = None,
runas_user: str = None,
runas_user_password: str = None,
stderr_redirect_path: str = None,
stdout_redirect_path: str = None,
variables: str = None,
):
self.array_request = array_request
self.cluster_id = cluster_id
self.command_line = command_line
self.name = name
self.package_path = package_path
self.priority = priority
self.re_runable = re_runable
self.runas_user = runas_user
self.runas_user_password = runas_user_password
self.stderr_redirect_path = stderr_redirect_path
self.stdout_redirect_path = stdout_redirect_path
self.variables = variables
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.array_request is not None:
result['ArrayRequest'] = self.array_request
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
if self.command_line is not None:
result['CommandLine'] = self.command_line
if self.name is not None:
result['Name'] = self.name
if self.package_path is not None:
result['PackagePath'] = self.package_path
if self.priority is not None:
result['Priority'] = self.priority
if self.re_runable is not None:
result['ReRunable'] = self.re_runable
if self.runas_user is not None:
result['RunasUser'] = self.runas_user
if self.runas_user_password is not None:
result['RunasUserPassword'] = self.runas_user_password
if self.stderr_redirect_path is not None:
result['StderrRedirectPath'] = self.stderr_redirect_path
if self.stdout_redirect_path is not None:
result['StdoutRedirectPath'] = self.stdout_redirect_path
if self.variables is not None:
result['Variables'] = self.variables
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ArrayRequest') is not None:
self.array_request = m.get('ArrayRequest')
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
if m.get('CommandLine') is not None:
self.command_line = m.get('CommandLine')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('PackagePath') is not None:
self.package_path = m.get('PackagePath')
if m.get('Priority') is not None:
self.priority = m.get('Priority')
if m.get('ReRunable') is not None:
self.re_runable = m.get('ReRunable')
if m.get('RunasUser') is not None:
self.runas_user = m.get('RunasUser')
if m.get('RunasUserPassword') is not None:
self.runas_user_password = m.get('RunasUserPassword')
if m.get('StderrRedirectPath') is not None:
self.stderr_redirect_path = m.get('StderrRedirectPath')
if m.get('StdoutRedirectPath') is not None:
self.stdout_redirect_path = m.get('StdoutRedirectPath')
if m.get('Variables') is not None:
self.variables = m.get('Variables')
return self
class SubmitJobResponseBody(TeaModel):
def __init__(
self,
job_id: str = None,
request_id: str = None,
):
self.job_id = job_id
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.job_id is not None:
result['JobId'] = self.job_id
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('JobId') is not None:
self.job_id = m.get('JobId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class SubmitJobResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: SubmitJobResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = SubmitJobResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpgradeClientRequest(TeaModel):
def __init__(
self,
client_version: str = None,
cluster_id: str = None,
):
self.client_version = client_version
self.cluster_id = cluster_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_version is not None:
result['ClientVersion'] = self.client_version
if self.cluster_id is not None:
result['ClusterId'] = self.cluster_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientVersion') is not None:
self.client_version = m.get('ClientVersion')
if m.get('ClusterId') is not None:
self.cluster_id = m.get('ClusterId')
return self
class UpgradeClientResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class UpgradeClientResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: UpgradeClientResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.status_code, 'status_code')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super().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: dict = 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 = UpgradeClientResponseBody()
self.body = temp_model.from_map(m['body'])
return self