paifeaturestore-20230621/alibabacloud_paifeaturestore20230621/models.py (7,782 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 FeatureViewConfigValuePartitionsValue(TeaModel):
def __init__(
self,
value: str = None,
values: List[str] = None,
start_value: str = None,
end_value: str = None,
):
self.value = value
self.values = values
self.start_value = start_value
self.end_value = end_value
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.value is not None:
result['Value'] = self.value
if self.values is not None:
result['Values'] = self.values
if self.start_value is not None:
result['StartValue'] = self.start_value
if self.end_value is not None:
result['EndValue'] = self.end_value
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Value') is not None:
self.value = m.get('Value')
if m.get('Values') is not None:
self.values = m.get('Values')
if m.get('StartValue') is not None:
self.start_value = m.get('StartValue')
if m.get('EndValue') is not None:
self.end_value = m.get('EndValue')
return self
class FeatureViewConfigValue(TeaModel):
def __init__(
self,
partitions: Dict[str, FeatureViewConfigValuePartitionsValue] = None,
event_time: str = None,
equal: bool = None,
use_mock: bool = None,
):
self.partitions = partitions
self.event_time = event_time
self.equal = equal
self.use_mock = use_mock
def validate(self):
if self.partitions:
for v in self.partitions.values():
if v:
v.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['Partitions'] = {}
if self.partitions is not None:
for k, v in self.partitions.items():
result['Partitions'][k] = v.to_map()
if self.event_time is not None:
result['EventTime'] = self.event_time
if self.equal is not None:
result['Equal'] = self.equal
if self.use_mock is not None:
result['UseMock'] = self.use_mock
return result
def from_map(self, m: dict = None):
m = m or dict()
self.partitions = {}
if m.get('Partitions') is not None:
for k, v in m.get('Partitions').items():
temp_model = FeatureViewConfigValuePartitionsValue()
self.partitions[k] = temp_model.from_map(v)
if m.get('EventTime') is not None:
self.event_time = m.get('EventTime')
if m.get('Equal') is not None:
self.equal = m.get('Equal')
if m.get('UseMock') is not None:
self.use_mock = m.get('UseMock')
return self
class CheckInstanceDatasourceRequest(TeaModel):
def __init__(
self,
config: str = None,
type: str = None,
uri: str = None,
):
self.config = config
# This parameter is required.
self.type = type
# This parameter is required.
self.uri = uri
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.config is not None:
result['Config'] = self.config
if self.type is not None:
result['Type'] = self.type
if self.uri is not None:
result['Uri'] = self.uri
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Config') is not None:
self.config = m.get('Config')
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('Uri') is not None:
self.uri = m.get('Uri')
return self
class CheckInstanceDatasourceResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
status: str = None,
):
self.request_id = request_id
self.status = status
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.status is not None:
result['Status'] = self.status
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('Status') is not None:
self.status = m.get('Status')
return self
class CheckInstanceDatasourceResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: CheckInstanceDatasourceResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = CheckInstanceDatasourceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateDatasourceRequest(TeaModel):
def __init__(
self,
config: str = None,
name: str = None,
type: str = None,
uri: str = None,
workspace_id: str = None,
):
self.config = config
# This parameter is required.
self.name = name
# This parameter is required.
self.type = type
# This parameter is required.
self.uri = uri
# This parameter is required.
self.workspace_id = workspace_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.config is not None:
result['Config'] = self.config
if self.name is not None:
result['Name'] = self.name
if self.type is not None:
result['Type'] = self.type
if self.uri is not None:
result['Uri'] = self.uri
if self.workspace_id is not None:
result['WorkspaceId'] = self.workspace_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Config') is not None:
self.config = m.get('Config')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('Uri') is not None:
self.uri = m.get('Uri')
if m.get('WorkspaceId') is not None:
self.workspace_id = m.get('WorkspaceId')
return self
class CreateDatasourceResponseBody(TeaModel):
def __init__(
self,
datasource_id: str = None,
request_id: str = None,
):
self.datasource_id = datasource_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.datasource_id is not None:
result['DatasourceId'] = self.datasource_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('DatasourceId') is not None:
self.datasource_id = m.get('DatasourceId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreateDatasourceResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: CreateDatasourceResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = CreateDatasourceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateFeatureEntityRequest(TeaModel):
def __init__(
self,
join_id: str = None,
name: str = None,
project_id: str = None,
):
# This parameter is required.
self.join_id = join_id
# This parameter is required.
self.name = name
# This parameter is required.
self.project_id = project_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.join_id is not None:
result['JoinId'] = self.join_id
if self.name is not None:
result['Name'] = self.name
if self.project_id is not None:
result['ProjectId'] = self.project_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('JoinId') is not None:
self.join_id = m.get('JoinId')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('ProjectId') is not None:
self.project_id = m.get('ProjectId')
return self
class CreateFeatureEntityResponseBody(TeaModel):
def __init__(
self,
feature_entity_id: str = None,
request_id: str = None,
):
self.feature_entity_id = feature_entity_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.feature_entity_id is not None:
result['FeatureEntityId'] = self.feature_entity_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('FeatureEntityId') is not None:
self.feature_entity_id = m.get('FeatureEntityId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreateFeatureEntityResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: CreateFeatureEntityResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = CreateFeatureEntityResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateFeatureViewRequestFieldsTransformInput(TeaModel):
def __init__(
self,
name: str = None,
type: str = None,
):
self.name = name
self.type = type
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.type is not None:
result['Type'] = self.type
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('Type') is not None:
self.type = m.get('Type')
return self
class CreateFeatureViewRequestFieldsTransform(TeaModel):
def __init__(
self,
input: List[CreateFeatureViewRequestFieldsTransformInput] = None,
llmconfig_id: int = None,
type: str = None,
):
self.input = input
self.llmconfig_id = llmconfig_id
self.type = type
def validate(self):
if self.input:
for k in self.input:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['Input'] = []
if self.input is not None:
for k in self.input:
result['Input'].append(k.to_map() if k else None)
if self.llmconfig_id is not None:
result['LLMConfigId'] = self.llmconfig_id
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
self.input = []
if m.get('Input') is not None:
for k in m.get('Input'):
temp_model = CreateFeatureViewRequestFieldsTransformInput()
self.input.append(temp_model.from_map(k))
if m.get('LLMConfigId') is not None:
self.llmconfig_id = m.get('LLMConfigId')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class CreateFeatureViewRequestFields(TeaModel):
def __init__(
self,
attributes: List[str] = None,
name: str = None,
transform: List[CreateFeatureViewRequestFieldsTransform] = None,
type: str = None,
):
self.attributes = attributes
self.name = name
self.transform = transform
self.type = type
def validate(self):
if self.transform:
for k in self.transform:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.attributes is not None:
result['Attributes'] = self.attributes
if self.name is not None:
result['Name'] = self.name
result['Transform'] = []
if self.transform is not None:
for k in self.transform:
result['Transform'].append(k.to_map() if k else None)
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Attributes') is not None:
self.attributes = m.get('Attributes')
if m.get('Name') is not None:
self.name = m.get('Name')
self.transform = []
if m.get('Transform') is not None:
for k in m.get('Transform'):
temp_model = CreateFeatureViewRequestFieldsTransform()
self.transform.append(temp_model.from_map(k))
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class CreateFeatureViewRequest(TeaModel):
def __init__(
self,
config: str = None,
feature_entity_id: str = None,
fields: List[CreateFeatureViewRequestFields] = None,
name: str = None,
project_id: str = None,
register_datasource_id: str = None,
register_table: str = None,
sync_online_table: bool = None,
ttl: int = None,
tags: List[str] = None,
type: str = None,
write_method: str = None,
write_to_feature_db: bool = None,
):
self.config = config
self.feature_entity_id = feature_entity_id
self.fields = fields
# This parameter is required.
self.name = name
# This parameter is required.
self.project_id = project_id
self.register_datasource_id = register_datasource_id
self.register_table = register_table
# This parameter is required.
self.sync_online_table = sync_online_table
self.ttl = ttl
self.tags = tags
# This parameter is required.
self.type = type
# This parameter is required.
self.write_method = write_method
self.write_to_feature_db = write_to_feature_db
def validate(self):
if self.fields:
for k in self.fields:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.config is not None:
result['Config'] = self.config
if self.feature_entity_id is not None:
result['FeatureEntityId'] = self.feature_entity_id
result['Fields'] = []
if self.fields is not None:
for k in self.fields:
result['Fields'].append(k.to_map() if k else None)
if self.name is not None:
result['Name'] = self.name
if self.project_id is not None:
result['ProjectId'] = self.project_id
if self.register_datasource_id is not None:
result['RegisterDatasourceId'] = self.register_datasource_id
if self.register_table is not None:
result['RegisterTable'] = self.register_table
if self.sync_online_table is not None:
result['SyncOnlineTable'] = self.sync_online_table
if self.ttl is not None:
result['TTL'] = self.ttl
if self.tags is not None:
result['Tags'] = self.tags
if self.type is not None:
result['Type'] = self.type
if self.write_method is not None:
result['WriteMethod'] = self.write_method
if self.write_to_feature_db is not None:
result['WriteToFeatureDB'] = self.write_to_feature_db
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Config') is not None:
self.config = m.get('Config')
if m.get('FeatureEntityId') is not None:
self.feature_entity_id = m.get('FeatureEntityId')
self.fields = []
if m.get('Fields') is not None:
for k in m.get('Fields'):
temp_model = CreateFeatureViewRequestFields()
self.fields.append(temp_model.from_map(k))
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('RegisterDatasourceId') is not None:
self.register_datasource_id = m.get('RegisterDatasourceId')
if m.get('RegisterTable') is not None:
self.register_table = m.get('RegisterTable')
if m.get('SyncOnlineTable') is not None:
self.sync_online_table = m.get('SyncOnlineTable')
if m.get('TTL') is not None:
self.ttl = m.get('TTL')
if m.get('Tags') is not None:
self.tags = m.get('Tags')
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('WriteMethod') is not None:
self.write_method = m.get('WriteMethod')
if m.get('WriteToFeatureDB') is not None:
self.write_to_feature_db = m.get('WriteToFeatureDB')
return self
class CreateFeatureViewResponseBody(TeaModel):
def __init__(
self,
feature_view_id: str = None,
request_id: str = None,
):
self.feature_view_id = feature_view_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.feature_view_id is not None:
result['FeatureViewId'] = self.feature_view_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('FeatureViewId') is not None:
self.feature_view_id = m.get('FeatureViewId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreateFeatureViewResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: CreateFeatureViewResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = CreateFeatureViewResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateInstanceRequest(TeaModel):
def __init__(
self,
type: str = None,
):
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class CreateInstanceResponseBody(TeaModel):
def __init__(
self,
code: str = None,
instance_id: str = None,
request_id: str = None,
):
self.code = code
self.instance_id = instance_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.code is not None:
result['Code'] = self.code
if self.instance_id is not None:
result['InstanceId'] = self.instance_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('Code') is not None:
self.code = m.get('Code')
if m.get('InstanceId') is not None:
self.instance_id = m.get('InstanceId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreateInstanceResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: CreateInstanceResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = CreateInstanceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateLabelTableRequestFields(TeaModel):
def __init__(
self,
attributes: List[str] = None,
name: str = None,
type: str = None,
):
# This parameter is required.
self.attributes = attributes
# This parameter is required.
self.name = name
# This parameter is required.
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.attributes is not None:
result['Attributes'] = self.attributes
if self.name is not None:
result['Name'] = self.name
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Attributes') is not None:
self.attributes = m.get('Attributes')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class CreateLabelTableRequest(TeaModel):
def __init__(
self,
datasource_id: str = None,
fields: List[CreateLabelTableRequestFields] = None,
name: str = None,
project_id: str = None,
):
# This parameter is required.
self.datasource_id = datasource_id
# This parameter is required.
self.fields = fields
# This parameter is required.
self.name = name
# This parameter is required.
self.project_id = project_id
def validate(self):
if self.fields:
for k in self.fields:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.datasource_id is not None:
result['DatasourceId'] = self.datasource_id
result['Fields'] = []
if self.fields is not None:
for k in self.fields:
result['Fields'].append(k.to_map() if k else None)
if self.name is not None:
result['Name'] = self.name
if self.project_id is not None:
result['ProjectId'] = self.project_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DatasourceId') is not None:
self.datasource_id = m.get('DatasourceId')
self.fields = []
if m.get('Fields') is not None:
for k in m.get('Fields'):
temp_model = CreateLabelTableRequestFields()
self.fields.append(temp_model.from_map(k))
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('ProjectId') is not None:
self.project_id = m.get('ProjectId')
return self
class CreateLabelTableResponseBody(TeaModel):
def __init__(
self,
label_table_id: str = None,
request_id: str = None,
):
self.label_table_id = label_table_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.label_table_id is not None:
result['LabelTableId'] = self.label_table_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('LabelTableId') is not None:
self.label_table_id = m.get('LabelTableId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreateLabelTableResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: CreateLabelTableResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = CreateLabelTableResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateModelFeatureRequestFeatures(TeaModel):
def __init__(
self,
alias_name: str = None,
feature_view_id: str = None,
name: str = None,
type: str = None,
):
self.alias_name = alias_name
# This parameter is required.
self.feature_view_id = feature_view_id
# This parameter is required.
self.name = name
# This parameter is required.
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.alias_name is not None:
result['AliasName'] = self.alias_name
if self.feature_view_id is not None:
result['FeatureViewId'] = self.feature_view_id
if self.name is not None:
result['Name'] = self.name
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('AliasName') is not None:
self.alias_name = m.get('AliasName')
if m.get('FeatureViewId') is not None:
self.feature_view_id = m.get('FeatureViewId')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class CreateModelFeatureRequest(TeaModel):
def __init__(
self,
features: List[CreateModelFeatureRequestFeatures] = None,
label_priority_level: int = None,
label_table_id: str = None,
name: str = None,
project_id: str = None,
sequence_feature_view_ids: List[str] = None,
):
# This parameter is required.
self.features = features
self.label_priority_level = label_priority_level
# This parameter is required.
self.label_table_id = label_table_id
# This parameter is required.
self.name = name
# This parameter is required.
self.project_id = project_id
self.sequence_feature_view_ids = sequence_feature_view_ids
def validate(self):
if self.features:
for k in self.features:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['Features'] = []
if self.features is not None:
for k in self.features:
result['Features'].append(k.to_map() if k else None)
if self.label_priority_level is not None:
result['LabelPriorityLevel'] = self.label_priority_level
if self.label_table_id is not None:
result['LabelTableId'] = self.label_table_id
if self.name is not None:
result['Name'] = self.name
if self.project_id is not None:
result['ProjectId'] = self.project_id
if self.sequence_feature_view_ids is not None:
result['SequenceFeatureViewIds'] = self.sequence_feature_view_ids
return result
def from_map(self, m: dict = None):
m = m or dict()
self.features = []
if m.get('Features') is not None:
for k in m.get('Features'):
temp_model = CreateModelFeatureRequestFeatures()
self.features.append(temp_model.from_map(k))
if m.get('LabelPriorityLevel') is not None:
self.label_priority_level = m.get('LabelPriorityLevel')
if m.get('LabelTableId') is not None:
self.label_table_id = m.get('LabelTableId')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('SequenceFeatureViewIds') is not None:
self.sequence_feature_view_ids = m.get('SequenceFeatureViewIds')
return self
class CreateModelFeatureResponseBody(TeaModel):
def __init__(
self,
model_feature_id: str = None,
request_id: str = None,
):
self.model_feature_id = model_feature_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.model_feature_id is not None:
result['ModelFeatureId'] = self.model_feature_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('ModelFeatureId') is not None:
self.model_feature_id = m.get('ModelFeatureId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreateModelFeatureResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: CreateModelFeatureResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = CreateModelFeatureResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateProjectRequest(TeaModel):
def __init__(
self,
description: str = None,
name: str = None,
offline_datasource_id: str = None,
offline_life_cycle: int = None,
online_datasource_id: str = None,
workspace_id: str = None,
):
self.description = description
# This parameter is required.
self.name = name
# This parameter is required.
self.offline_datasource_id = offline_datasource_id
self.offline_life_cycle = offline_life_cycle
# This parameter is required.
self.online_datasource_id = online_datasource_id
# This parameter is required.
self.workspace_id = workspace_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.description is not None:
result['Description'] = self.description
if self.name is not None:
result['Name'] = self.name
if self.offline_datasource_id is not None:
result['OfflineDatasourceId'] = self.offline_datasource_id
if self.offline_life_cycle is not None:
result['OfflineLifeCycle'] = self.offline_life_cycle
if self.online_datasource_id is not None:
result['OnlineDatasourceId'] = self.online_datasource_id
if self.workspace_id is not None:
result['WorkspaceId'] = self.workspace_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('OfflineDatasourceId') is not None:
self.offline_datasource_id = m.get('OfflineDatasourceId')
if m.get('OfflineLifeCycle') is not None:
self.offline_life_cycle = m.get('OfflineLifeCycle')
if m.get('OnlineDatasourceId') is not None:
self.online_datasource_id = m.get('OnlineDatasourceId')
if m.get('WorkspaceId') is not None:
self.workspace_id = m.get('WorkspaceId')
return self
class CreateProjectResponseBody(TeaModel):
def __init__(
self,
project_id: str = None,
request_id: str = None,
):
self.project_id = project_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.project_id is not None:
result['ProjectId'] = self.project_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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class CreateProjectResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: CreateProjectResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = CreateProjectResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class CreateServiceIdentityRoleRequest(TeaModel):
def __init__(
self,
role_name: str = None,
):
# This parameter is required.
self.role_name = role_name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.role_name is not None:
result['RoleName'] = self.role_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
return self
class CreateServiceIdentityRoleResponseBody(TeaModel):
def __init__(
self,
code: str = None,
request_id: str = None,
role_name: str = None,
):
self.code = code
self.request_id = request_id
self.role_name = role_name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.code is not None:
result['Code'] = self.code
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.role_name is not None:
result['RoleName'] = self.role_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Code') is not None:
self.code = m.get('Code')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
return self
class CreateServiceIdentityRoleResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: CreateServiceIdentityRoleResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = CreateServiceIdentityRoleResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteDatasourceResponseBody(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 DeleteDatasourceResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteDatasourceResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = DeleteDatasourceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteFeatureEntityResponseBody(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 DeleteFeatureEntityResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteFeatureEntityResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = DeleteFeatureEntityResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteFeatureViewResponseBody(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 DeleteFeatureViewResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteFeatureViewResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = DeleteFeatureViewResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteLabelTableResponseBody(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 DeleteLabelTableResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteLabelTableResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = DeleteLabelTableResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteModelFeatureResponseBody(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 DeleteModelFeatureResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteModelFeatureResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = DeleteModelFeatureResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteProjectResponseBody(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 DeleteProjectResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteProjectResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = DeleteProjectResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ExportModelFeatureTrainingSetTableRequestLabelInputConfig(TeaModel):
def __init__(
self,
event_time: str = None,
partitions: Dict[str, dict] = None,
):
self.event_time = event_time
self.partitions = partitions
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.event_time is not None:
result['EventTime'] = self.event_time
if self.partitions is not None:
result['Partitions'] = self.partitions
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('EventTime') is not None:
self.event_time = m.get('EventTime')
if m.get('Partitions') is not None:
self.partitions = m.get('Partitions')
return self
class ExportModelFeatureTrainingSetTableRequestTrainingSetConfig(TeaModel):
def __init__(
self,
partitions: Dict[str, dict] = None,
):
self.partitions = partitions
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.partitions is not None:
result['Partitions'] = self.partitions
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Partitions') is not None:
self.partitions = m.get('Partitions')
return self
class ExportModelFeatureTrainingSetTableRequest(TeaModel):
def __init__(
self,
feature_view_config: Dict[str, FeatureViewConfigValue] = None,
label_input_config: ExportModelFeatureTrainingSetTableRequestLabelInputConfig = None,
real_time_iterate_interval: int = None,
real_time_partition_count_value: int = None,
training_set_config: ExportModelFeatureTrainingSetTableRequestTrainingSetConfig = None,
):
self.feature_view_config = feature_view_config
self.label_input_config = label_input_config
self.real_time_iterate_interval = real_time_iterate_interval
self.real_time_partition_count_value = real_time_partition_count_value
self.training_set_config = training_set_config
def validate(self):
if self.feature_view_config:
for v in self.feature_view_config.values():
if v:
v.validate()
if self.label_input_config:
self.label_input_config.validate()
if self.training_set_config:
self.training_set_config.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['FeatureViewConfig'] = {}
if self.feature_view_config is not None:
for k, v in self.feature_view_config.items():
result['FeatureViewConfig'][k] = v.to_map()
if self.label_input_config is not None:
result['LabelInputConfig'] = self.label_input_config.to_map()
if self.real_time_iterate_interval is not None:
result['RealTimeIterateInterval'] = self.real_time_iterate_interval
if self.real_time_partition_count_value is not None:
result['RealTimePartitionCountValue'] = self.real_time_partition_count_value
if self.training_set_config is not None:
result['TrainingSetConfig'] = self.training_set_config.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
self.feature_view_config = {}
if m.get('FeatureViewConfig') is not None:
for k, v in m.get('FeatureViewConfig').items():
temp_model = FeatureViewConfigValue()
self.feature_view_config[k] = temp_model.from_map(v)
if m.get('LabelInputConfig') is not None:
temp_model = ExportModelFeatureTrainingSetTableRequestLabelInputConfig()
self.label_input_config = temp_model.from_map(m['LabelInputConfig'])
if m.get('RealTimeIterateInterval') is not None:
self.real_time_iterate_interval = m.get('RealTimeIterateInterval')
if m.get('RealTimePartitionCountValue') is not None:
self.real_time_partition_count_value = m.get('RealTimePartitionCountValue')
if m.get('TrainingSetConfig') is not None:
temp_model = ExportModelFeatureTrainingSetTableRequestTrainingSetConfig()
self.training_set_config = temp_model.from_map(m['TrainingSetConfig'])
return self
class ExportModelFeatureTrainingSetTableResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
task_id: str = None,
):
self.request_id = request_id
self.task_id = task_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.task_id is not None:
result['TaskId'] = self.task_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('TaskId') is not None:
self.task_id = m.get('TaskId')
return self
class ExportModelFeatureTrainingSetTableResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ExportModelFeatureTrainingSetTableResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ExportModelFeatureTrainingSetTableResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetDatasourceResponseBody(TeaModel):
def __init__(
self,
config: str = None,
datasource_id: str = None,
gmt_create_time: str = None,
gmt_modified_time: str = None,
name: str = None,
request_id: str = None,
type: str = None,
uri: str = None,
workspace_id: str = None,
):
self.config = config
self.datasource_id = datasource_id
self.gmt_create_time = gmt_create_time
self.gmt_modified_time = gmt_modified_time
self.name = name
self.request_id = request_id
self.type = type
self.uri = uri
self.workspace_id = workspace_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.config is not None:
result['Config'] = self.config
if self.datasource_id is not None:
result['DatasourceId'] = self.datasource_id
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_modified_time is not None:
result['GmtModifiedTime'] = self.gmt_modified_time
if self.name is not None:
result['Name'] = self.name
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.type is not None:
result['Type'] = self.type
if self.uri is not None:
result['Uri'] = self.uri
if self.workspace_id is not None:
result['WorkspaceId'] = self.workspace_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Config') is not None:
self.config = m.get('Config')
if m.get('DatasourceId') is not None:
self.datasource_id = m.get('DatasourceId')
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtModifiedTime') is not None:
self.gmt_modified_time = m.get('GmtModifiedTime')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('Uri') is not None:
self.uri = m.get('Uri')
if m.get('WorkspaceId') is not None:
self.workspace_id = m.get('WorkspaceId')
return self
class GetDatasourceResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetDatasourceResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = GetDatasourceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetDatasourceTableResponseBodyFields(TeaModel):
def __init__(
self,
attributes: List[str] = None,
name: str = None,
type: str = None,
):
self.attributes = attributes
self.name = name
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.attributes is not None:
result['Attributes'] = self.attributes
if self.name is not None:
result['Name'] = self.name
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Attributes') is not None:
self.attributes = m.get('Attributes')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class GetDatasourceTableResponseBody(TeaModel):
def __init__(
self,
fields: List[GetDatasourceTableResponseBodyFields] = None,
request_id: str = None,
table_name: str = None,
):
self.fields = fields
self.request_id = request_id
self.table_name = table_name
def validate(self):
if self.fields:
for k in self.fields:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['Fields'] = []
if self.fields is not None:
for k in self.fields:
result['Fields'].append(k.to_map() if k else None)
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.table_name is not None:
result['TableName'] = self.table_name
return result
def from_map(self, m: dict = None):
m = m or dict()
self.fields = []
if m.get('Fields') is not None:
for k in m.get('Fields'):
temp_model = GetDatasourceTableResponseBodyFields()
self.fields.append(temp_model.from_map(k))
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TableName') is not None:
self.table_name = m.get('TableName')
return self
class GetDatasourceTableResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetDatasourceTableResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = GetDatasourceTableResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetFeatureEntityResponseBody(TeaModel):
def __init__(
self,
gmt_create_time: str = None,
join_id: str = None,
name: str = None,
owner: str = None,
project_id: str = None,
project_name: str = None,
request_id: str = None,
):
self.gmt_create_time = gmt_create_time
self.join_id = join_id
self.name = name
self.owner = owner
self.project_id = project_id
self.project_name = project_name
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.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.join_id is not None:
result['JoinId'] = self.join_id
if self.name is not None:
result['Name'] = self.name
if self.owner is not None:
result['Owner'] = self.owner
if self.project_id is not None:
result['ProjectId'] = self.project_id
if self.project_name is not None:
result['ProjectName'] = self.project_name
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('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('JoinId') is not None:
self.join_id = m.get('JoinId')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('ProjectName') is not None:
self.project_name = m.get('ProjectName')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetFeatureEntityResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetFeatureEntityResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = GetFeatureEntityResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetFeatureViewResponseBodyFieldsTransformInput(TeaModel):
def __init__(
self,
name: str = None,
type: str = None,
):
self.name = name
self.type = type
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.type is not None:
result['Type'] = self.type
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('Type') is not None:
self.type = m.get('Type')
return self
class GetFeatureViewResponseBodyFieldsTransform(TeaModel):
def __init__(
self,
input: List[GetFeatureViewResponseBodyFieldsTransformInput] = None,
llmconfig_id: int = None,
type: str = None,
):
self.input = input
self.llmconfig_id = llmconfig_id
self.type = type
def validate(self):
if self.input:
for k in self.input:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['Input'] = []
if self.input is not None:
for k in self.input:
result['Input'].append(k.to_map() if k else None)
if self.llmconfig_id is not None:
result['LLMConfigId'] = self.llmconfig_id
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
self.input = []
if m.get('Input') is not None:
for k in m.get('Input'):
temp_model = GetFeatureViewResponseBodyFieldsTransformInput()
self.input.append(temp_model.from_map(k))
if m.get('LLMConfigId') is not None:
self.llmconfig_id = m.get('LLMConfigId')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class GetFeatureViewResponseBodyFields(TeaModel):
def __init__(
self,
attributes: List[str] = None,
name: str = None,
transform: GetFeatureViewResponseBodyFieldsTransform = None,
type: str = None,
):
self.attributes = attributes
self.name = name
self.transform = transform
self.type = type
def validate(self):
if self.transform:
self.transform.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.attributes is not None:
result['Attributes'] = self.attributes
if self.name is not None:
result['Name'] = self.name
if self.transform is not None:
result['Transform'] = self.transform.to_map()
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Attributes') is not None:
self.attributes = m.get('Attributes')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Transform') is not None:
temp_model = GetFeatureViewResponseBodyFieldsTransform()
self.transform = temp_model.from_map(m['Transform'])
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class GetFeatureViewResponseBody(TeaModel):
def __init__(
self,
config: str = None,
feature_entity_id: str = None,
feature_entity_name: str = None,
fields: List[GetFeatureViewResponseBodyFields] = None,
gmt_create_time: str = None,
gmt_modified_time: str = None,
gmt_sync_time: str = None,
join_id: str = None,
last_sync_config: str = None,
mock_table_name: str = None,
name: str = None,
owner: str = None,
project_id: str = None,
project_name: str = None,
publish_table_script: str = None,
register_datasource_id: str = None,
register_datasource_name: str = None,
register_table: str = None,
request_id: str = None,
sync_online_table: bool = None,
ttl: int = None,
tags: List[str] = None,
type: str = None,
write_method: str = None,
write_to_feature_db: bool = None,
):
self.config = config
self.feature_entity_id = feature_entity_id
self.feature_entity_name = feature_entity_name
self.fields = fields
self.gmt_create_time = gmt_create_time
self.gmt_modified_time = gmt_modified_time
self.gmt_sync_time = gmt_sync_time
self.join_id = join_id
self.last_sync_config = last_sync_config
self.mock_table_name = mock_table_name
self.name = name
self.owner = owner
self.project_id = project_id
self.project_name = project_name
self.publish_table_script = publish_table_script
self.register_datasource_id = register_datasource_id
self.register_datasource_name = register_datasource_name
self.register_table = register_table
self.request_id = request_id
self.sync_online_table = sync_online_table
self.ttl = ttl
self.tags = tags
self.type = type
self.write_method = write_method
self.write_to_feature_db = write_to_feature_db
def validate(self):
if self.fields:
for k in self.fields:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.config is not None:
result['Config'] = self.config
if self.feature_entity_id is not None:
result['FeatureEntityId'] = self.feature_entity_id
if self.feature_entity_name is not None:
result['FeatureEntityName'] = self.feature_entity_name
result['Fields'] = []
if self.fields is not None:
for k in self.fields:
result['Fields'].append(k.to_map() if k else None)
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_modified_time is not None:
result['GmtModifiedTime'] = self.gmt_modified_time
if self.gmt_sync_time is not None:
result['GmtSyncTime'] = self.gmt_sync_time
if self.join_id is not None:
result['JoinId'] = self.join_id
if self.last_sync_config is not None:
result['LastSyncConfig'] = self.last_sync_config
if self.mock_table_name is not None:
result['MockTableName'] = self.mock_table_name
if self.name is not None:
result['Name'] = self.name
if self.owner is not None:
result['Owner'] = self.owner
if self.project_id is not None:
result['ProjectId'] = self.project_id
if self.project_name is not None:
result['ProjectName'] = self.project_name
if self.publish_table_script is not None:
result['PublishTableScript'] = self.publish_table_script
if self.register_datasource_id is not None:
result['RegisterDatasourceId'] = self.register_datasource_id
if self.register_datasource_name is not None:
result['RegisterDatasourceName'] = self.register_datasource_name
if self.register_table is not None:
result['RegisterTable'] = self.register_table
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.sync_online_table is not None:
result['SyncOnlineTable'] = self.sync_online_table
if self.ttl is not None:
result['TTL'] = self.ttl
if self.tags is not None:
result['Tags'] = self.tags
if self.type is not None:
result['Type'] = self.type
if self.write_method is not None:
result['WriteMethod'] = self.write_method
if self.write_to_feature_db is not None:
result['WriteToFeatureDB'] = self.write_to_feature_db
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Config') is not None:
self.config = m.get('Config')
if m.get('FeatureEntityId') is not None:
self.feature_entity_id = m.get('FeatureEntityId')
if m.get('FeatureEntityName') is not None:
self.feature_entity_name = m.get('FeatureEntityName')
self.fields = []
if m.get('Fields') is not None:
for k in m.get('Fields'):
temp_model = GetFeatureViewResponseBodyFields()
self.fields.append(temp_model.from_map(k))
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtModifiedTime') is not None:
self.gmt_modified_time = m.get('GmtModifiedTime')
if m.get('GmtSyncTime') is not None:
self.gmt_sync_time = m.get('GmtSyncTime')
if m.get('JoinId') is not None:
self.join_id = m.get('JoinId')
if m.get('LastSyncConfig') is not None:
self.last_sync_config = m.get('LastSyncConfig')
if m.get('MockTableName') is not None:
self.mock_table_name = m.get('MockTableName')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('ProjectName') is not None:
self.project_name = m.get('ProjectName')
if m.get('PublishTableScript') is not None:
self.publish_table_script = m.get('PublishTableScript')
if m.get('RegisterDatasourceId') is not None:
self.register_datasource_id = m.get('RegisterDatasourceId')
if m.get('RegisterDatasourceName') is not None:
self.register_datasource_name = m.get('RegisterDatasourceName')
if m.get('RegisterTable') is not None:
self.register_table = m.get('RegisterTable')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('SyncOnlineTable') is not None:
self.sync_online_table = m.get('SyncOnlineTable')
if m.get('TTL') is not None:
self.ttl = m.get('TTL')
if m.get('Tags') is not None:
self.tags = m.get('Tags')
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('WriteMethod') is not None:
self.write_method = m.get('WriteMethod')
if m.get('WriteToFeatureDB') is not None:
self.write_to_feature_db = m.get('WriteToFeatureDB')
return self
class GetFeatureViewResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetFeatureViewResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = GetFeatureViewResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetInstanceResponseBodyFeatureDBInstanceInfo(TeaModel):
def __init__(
self,
status: str = None,
):
self.status = status
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.status is not None:
result['Status'] = self.status
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Status') is not None:
self.status = m.get('Status')
return self
class GetInstanceResponseBody(TeaModel):
def __init__(
self,
feature_dbinstance_info: GetInstanceResponseBodyFeatureDBInstanceInfo = None,
gmt_create_time: str = None,
gmt_modified_time: str = None,
message: str = None,
progress: float = None,
region_id: str = None,
request_id: str = None,
status: str = None,
type: str = None,
):
self.feature_dbinstance_info = feature_dbinstance_info
self.gmt_create_time = gmt_create_time
self.gmt_modified_time = gmt_modified_time
self.message = message
self.progress = progress
self.region_id = region_id
self.request_id = request_id
self.status = status
self.type = type
def validate(self):
if self.feature_dbinstance_info:
self.feature_dbinstance_info.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_dbinstance_info is not None:
result['FeatureDBInstanceInfo'] = self.feature_dbinstance_info.to_map()
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_modified_time is not None:
result['GmtModifiedTime'] = self.gmt_modified_time
if self.message is not None:
result['Message'] = self.message
if self.progress is not None:
result['Progress'] = self.progress
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.status is not None:
result['Status'] = self.status
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureDBInstanceInfo') is not None:
temp_model = GetInstanceResponseBodyFeatureDBInstanceInfo()
self.feature_dbinstance_info = temp_model.from_map(m['FeatureDBInstanceInfo'])
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtModifiedTime') is not None:
self.gmt_modified_time = m.get('GmtModifiedTime')
if m.get('Message') is not None:
self.message = m.get('Message')
if m.get('Progress') is not None:
self.progress = m.get('Progress')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class GetInstanceResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetInstanceResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = GetInstanceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetLabelTableResponseBodyFields(TeaModel):
def __init__(
self,
attributes: List[str] = None,
name: str = None,
type: str = None,
):
self.attributes = attributes
self.name = name
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.attributes is not None:
result['Attributes'] = self.attributes
if self.name is not None:
result['Name'] = self.name
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Attributes') is not None:
self.attributes = m.get('Attributes')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class GetLabelTableResponseBody(TeaModel):
def __init__(
self,
datasource_id: str = None,
datasource_name: str = None,
fields: List[GetLabelTableResponseBodyFields] = None,
gmt_create_time: str = None,
gmt_modified_time: str = None,
name: str = None,
owner: str = None,
project_id: str = None,
project_name: str = None,
related_model_features: List[str] = None,
request_id: str = None,
):
self.datasource_id = datasource_id
self.datasource_name = datasource_name
self.fields = fields
self.gmt_create_time = gmt_create_time
self.gmt_modified_time = gmt_modified_time
self.name = name
self.owner = owner
self.project_id = project_id
self.project_name = project_name
self.related_model_features = related_model_features
self.request_id = request_id
def validate(self):
if self.fields:
for k in self.fields:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.datasource_id is not None:
result['DatasourceId'] = self.datasource_id
if self.datasource_name is not None:
result['DatasourceName'] = self.datasource_name
result['Fields'] = []
if self.fields is not None:
for k in self.fields:
result['Fields'].append(k.to_map() if k else None)
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_modified_time is not None:
result['GmtModifiedTime'] = self.gmt_modified_time
if self.name is not None:
result['Name'] = self.name
if self.owner is not None:
result['Owner'] = self.owner
if self.project_id is not None:
result['ProjectId'] = self.project_id
if self.project_name is not None:
result['ProjectName'] = self.project_name
if self.related_model_features is not None:
result['RelatedModelFeatures'] = self.related_model_features
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('DatasourceId') is not None:
self.datasource_id = m.get('DatasourceId')
if m.get('DatasourceName') is not None:
self.datasource_name = m.get('DatasourceName')
self.fields = []
if m.get('Fields') is not None:
for k in m.get('Fields'):
temp_model = GetLabelTableResponseBodyFields()
self.fields.append(temp_model.from_map(k))
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtModifiedTime') is not None:
self.gmt_modified_time = m.get('GmtModifiedTime')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('ProjectName') is not None:
self.project_name = m.get('ProjectName')
if m.get('RelatedModelFeatures') is not None:
self.related_model_features = m.get('RelatedModelFeatures')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetLabelTableResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetLabelTableResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = GetLabelTableResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetModelFeatureResponseBodyFeatures(TeaModel):
def __init__(
self,
alias_name: str = None,
feature_view_id: str = None,
feature_view_name: str = None,
name: str = None,
type: str = None,
):
self.alias_name = alias_name
self.feature_view_id = feature_view_id
self.feature_view_name = feature_view_name
self.name = name
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.alias_name is not None:
result['AliasName'] = self.alias_name
if self.feature_view_id is not None:
result['FeatureViewId'] = self.feature_view_id
if self.feature_view_name is not None:
result['FeatureViewName'] = self.feature_view_name
if self.name is not None:
result['Name'] = self.name
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('AliasName') is not None:
self.alias_name = m.get('AliasName')
if m.get('FeatureViewId') is not None:
self.feature_view_id = m.get('FeatureViewId')
if m.get('FeatureViewName') is not None:
self.feature_view_name = m.get('FeatureViewName')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class GetModelFeatureResponseBodyRelationsDomains(TeaModel):
def __init__(
self,
domain_type: str = None,
id: str = None,
name: str = None,
):
self.domain_type = domain_type
# Domain ID。
self.id = id
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.domain_type is not None:
result['DomainType'] = self.domain_type
if self.id is not None:
result['Id'] = self.id
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('DomainType') is not None:
self.domain_type = m.get('DomainType')
if m.get('Id') is not None:
self.id = m.get('Id')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class GetModelFeatureResponseBodyRelationsLinks(TeaModel):
def __init__(
self,
from_: str = None,
link: str = None,
to: str = None,
):
self.from_ = from_
self.link = link
self.to = to
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.from_ is not None:
result['From'] = self.from_
if self.link is not None:
result['Link'] = self.link
if self.to is not None:
result['To'] = self.to
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('From') is not None:
self.from_ = m.get('From')
if m.get('Link') is not None:
self.link = m.get('Link')
if m.get('To') is not None:
self.to = m.get('To')
return self
class GetModelFeatureResponseBodyRelations(TeaModel):
def __init__(
self,
domains: List[GetModelFeatureResponseBodyRelationsDomains] = None,
links: List[GetModelFeatureResponseBodyRelationsLinks] = None,
):
self.domains = domains
self.links = links
def validate(self):
if self.domains:
for k in self.domains:
if k:
k.validate()
if self.links:
for k in self.links:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['Domains'] = []
if self.domains is not None:
for k in self.domains:
result['Domains'].append(k.to_map() if k else None)
result['Links'] = []
if self.links is not None:
for k in self.links:
result['Links'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.domains = []
if m.get('Domains') is not None:
for k in m.get('Domains'):
temp_model = GetModelFeatureResponseBodyRelationsDomains()
self.domains.append(temp_model.from_map(k))
self.links = []
if m.get('Links') is not None:
for k in m.get('Links'):
temp_model = GetModelFeatureResponseBodyRelationsLinks()
self.links.append(temp_model.from_map(k))
return self
class GetModelFeatureResponseBody(TeaModel):
def __init__(
self,
export_training_set_table_script: str = None,
features: List[GetModelFeatureResponseBodyFeatures] = None,
gmt_create_time: str = None,
gmt_modified_time: str = None,
label_priority_level: int = None,
label_table_id: str = None,
label_table_name: str = None,
name: str = None,
owner: str = None,
project_id: str = None,
project_name: str = None,
relations: GetModelFeatureResponseBodyRelations = None,
request_id: str = None,
training_set_fgtable: str = None,
training_set_table: str = None,
):
self.export_training_set_table_script = export_training_set_table_script
self.features = features
self.gmt_create_time = gmt_create_time
self.gmt_modified_time = gmt_modified_time
self.label_priority_level = label_priority_level
self.label_table_id = label_table_id
self.label_table_name = label_table_name
self.name = name
self.owner = owner
self.project_id = project_id
self.project_name = project_name
self.relations = relations
self.request_id = request_id
self.training_set_fgtable = training_set_fgtable
self.training_set_table = training_set_table
def validate(self):
if self.features:
for k in self.features:
if k:
k.validate()
if self.relations:
self.relations.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.export_training_set_table_script is not None:
result['ExportTrainingSetTableScript'] = self.export_training_set_table_script
result['Features'] = []
if self.features is not None:
for k in self.features:
result['Features'].append(k.to_map() if k else None)
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_modified_time is not None:
result['GmtModifiedTime'] = self.gmt_modified_time
if self.label_priority_level is not None:
result['LabelPriorityLevel'] = self.label_priority_level
if self.label_table_id is not None:
result['LabelTableId'] = self.label_table_id
if self.label_table_name is not None:
result['LabelTableName'] = self.label_table_name
if self.name is not None:
result['Name'] = self.name
if self.owner is not None:
result['Owner'] = self.owner
if self.project_id is not None:
result['ProjectId'] = self.project_id
if self.project_name is not None:
result['ProjectName'] = self.project_name
if self.relations is not None:
result['Relations'] = self.relations.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.training_set_fgtable is not None:
result['TrainingSetFGTable'] = self.training_set_fgtable
if self.training_set_table is not None:
result['TrainingSetTable'] = self.training_set_table
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ExportTrainingSetTableScript') is not None:
self.export_training_set_table_script = m.get('ExportTrainingSetTableScript')
self.features = []
if m.get('Features') is not None:
for k in m.get('Features'):
temp_model = GetModelFeatureResponseBodyFeatures()
self.features.append(temp_model.from_map(k))
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtModifiedTime') is not None:
self.gmt_modified_time = m.get('GmtModifiedTime')
if m.get('LabelPriorityLevel') is not None:
self.label_priority_level = m.get('LabelPriorityLevel')
if m.get('LabelTableId') is not None:
self.label_table_id = m.get('LabelTableId')
if m.get('LabelTableName') is not None:
self.label_table_name = m.get('LabelTableName')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('ProjectName') is not None:
self.project_name = m.get('ProjectName')
if m.get('Relations') is not None:
temp_model = GetModelFeatureResponseBodyRelations()
self.relations = temp_model.from_map(m['Relations'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('TrainingSetFGTable') is not None:
self.training_set_fgtable = m.get('TrainingSetFGTable')
if m.get('TrainingSetTable') is not None:
self.training_set_table = m.get('TrainingSetTable')
return self
class GetModelFeatureResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetModelFeatureResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = GetModelFeatureResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetModelFeatureFGFeatureResponseBodyLookupFeatures(TeaModel):
def __init__(
self,
default_value: str = None,
feature_name: str = None,
key_feature_domain: str = None,
key_feature_name: str = None,
map_feature_domain: str = None,
map_feature_name: str = None,
value_type: str = None,
):
self.default_value = default_value
self.feature_name = feature_name
self.key_feature_domain = key_feature_domain
self.key_feature_name = key_feature_name
self.map_feature_domain = map_feature_domain
self.map_feature_name = map_feature_name
self.value_type = value_type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.default_value is not None:
result['DefaultValue'] = self.default_value
if self.feature_name is not None:
result['FeatureName'] = self.feature_name
if self.key_feature_domain is not None:
result['KeyFeatureDomain'] = self.key_feature_domain
if self.key_feature_name is not None:
result['KeyFeatureName'] = self.key_feature_name
if self.map_feature_domain is not None:
result['MapFeatureDomain'] = self.map_feature_domain
if self.map_feature_name is not None:
result['MapFeatureName'] = self.map_feature_name
if self.value_type is not None:
result['ValueType'] = self.value_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DefaultValue') is not None:
self.default_value = m.get('DefaultValue')
if m.get('FeatureName') is not None:
self.feature_name = m.get('FeatureName')
if m.get('KeyFeatureDomain') is not None:
self.key_feature_domain = m.get('KeyFeatureDomain')
if m.get('KeyFeatureName') is not None:
self.key_feature_name = m.get('KeyFeatureName')
if m.get('MapFeatureDomain') is not None:
self.map_feature_domain = m.get('MapFeatureDomain')
if m.get('MapFeatureName') is not None:
self.map_feature_name = m.get('MapFeatureName')
if m.get('ValueType') is not None:
self.value_type = m.get('ValueType')
return self
class GetModelFeatureFGFeatureResponseBodyRawFeatures(TeaModel):
def __init__(
self,
default_value: str = None,
feature_domain: str = None,
feature_name: str = None,
feature_type: str = None,
input_feature_name: str = None,
value_type: str = None,
):
self.default_value = default_value
self.feature_domain = feature_domain
self.feature_name = feature_name
self.feature_type = feature_type
self.input_feature_name = input_feature_name
self.value_type = value_type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.default_value is not None:
result['DefaultValue'] = self.default_value
if self.feature_domain is not None:
result['FeatureDomain'] = self.feature_domain
if self.feature_name is not None:
result['FeatureName'] = self.feature_name
if self.feature_type is not None:
result['FeatureType'] = self.feature_type
if self.input_feature_name is not None:
result['InputFeatureName'] = self.input_feature_name
if self.value_type is not None:
result['ValueType'] = self.value_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DefaultValue') is not None:
self.default_value = m.get('DefaultValue')
if m.get('FeatureDomain') is not None:
self.feature_domain = m.get('FeatureDomain')
if m.get('FeatureName') is not None:
self.feature_name = m.get('FeatureName')
if m.get('FeatureType') is not None:
self.feature_type = m.get('FeatureType')
if m.get('InputFeatureName') is not None:
self.input_feature_name = m.get('InputFeatureName')
if m.get('ValueType') is not None:
self.value_type = m.get('ValueType')
return self
class GetModelFeatureFGFeatureResponseBodySequenceFeaturesSubFeatures(TeaModel):
def __init__(
self,
default_value: str = None,
feature_domain: str = None,
feature_name: str = None,
feature_type: str = None,
input_feature_name: str = None,
value_type: str = None,
):
self.default_value = default_value
self.feature_domain = feature_domain
self.feature_name = feature_name
self.feature_type = feature_type
self.input_feature_name = input_feature_name
self.value_type = value_type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.default_value is not None:
result['DefaultValue'] = self.default_value
if self.feature_domain is not None:
result['FeatureDomain'] = self.feature_domain
if self.feature_name is not None:
result['FeatureName'] = self.feature_name
if self.feature_type is not None:
result['FeatureType'] = self.feature_type
if self.input_feature_name is not None:
result['InputFeatureName'] = self.input_feature_name
if self.value_type is not None:
result['ValueType'] = self.value_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DefaultValue') is not None:
self.default_value = m.get('DefaultValue')
if m.get('FeatureDomain') is not None:
self.feature_domain = m.get('FeatureDomain')
if m.get('FeatureName') is not None:
self.feature_name = m.get('FeatureName')
if m.get('FeatureType') is not None:
self.feature_type = m.get('FeatureType')
if m.get('InputFeatureName') is not None:
self.input_feature_name = m.get('InputFeatureName')
if m.get('ValueType') is not None:
self.value_type = m.get('ValueType')
return self
class GetModelFeatureFGFeatureResponseBodySequenceFeatures(TeaModel):
def __init__(
self,
attribute_delim: str = None,
feature_name: str = None,
sequence_delim: str = None,
sequence_length: int = None,
sub_features: List[GetModelFeatureFGFeatureResponseBodySequenceFeaturesSubFeatures] = None,
):
self.attribute_delim = attribute_delim
self.feature_name = feature_name
self.sequence_delim = sequence_delim
self.sequence_length = sequence_length
self.sub_features = sub_features
def validate(self):
if self.sub_features:
for k in self.sub_features:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.attribute_delim is not None:
result['AttributeDelim'] = self.attribute_delim
if self.feature_name is not None:
result['FeatureName'] = self.feature_name
if self.sequence_delim is not None:
result['SequenceDelim'] = self.sequence_delim
if self.sequence_length is not None:
result['SequenceLength'] = self.sequence_length
result['SubFeatures'] = []
if self.sub_features is not None:
for k in self.sub_features:
result['SubFeatures'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('AttributeDelim') is not None:
self.attribute_delim = m.get('AttributeDelim')
if m.get('FeatureName') is not None:
self.feature_name = m.get('FeatureName')
if m.get('SequenceDelim') is not None:
self.sequence_delim = m.get('SequenceDelim')
if m.get('SequenceLength') is not None:
self.sequence_length = m.get('SequenceLength')
self.sub_features = []
if m.get('SubFeatures') is not None:
for k in m.get('SubFeatures'):
temp_model = GetModelFeatureFGFeatureResponseBodySequenceFeaturesSubFeatures()
self.sub_features.append(temp_model.from_map(k))
return self
class GetModelFeatureFGFeatureResponseBody(TeaModel):
def __init__(
self,
lookup_features: List[GetModelFeatureFGFeatureResponseBodyLookupFeatures] = None,
raw_features: List[GetModelFeatureFGFeatureResponseBodyRawFeatures] = None,
request_id: str = None,
reserves: List[str] = None,
sequence_features: List[GetModelFeatureFGFeatureResponseBodySequenceFeatures] = None,
):
self.lookup_features = lookup_features
self.raw_features = raw_features
self.request_id = request_id
self.reserves = reserves
self.sequence_features = sequence_features
def validate(self):
if self.lookup_features:
for k in self.lookup_features:
if k:
k.validate()
if self.raw_features:
for k in self.raw_features:
if k:
k.validate()
if self.sequence_features:
for k in self.sequence_features:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['LookupFeatures'] = []
if self.lookup_features is not None:
for k in self.lookup_features:
result['LookupFeatures'].append(k.to_map() if k else None)
result['RawFeatures'] = []
if self.raw_features is not None:
for k in self.raw_features:
result['RawFeatures'].append(k.to_map() if k else None)
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.reserves is not None:
result['Reserves'] = self.reserves
result['SequenceFeatures'] = []
if self.sequence_features is not None:
for k in self.sequence_features:
result['SequenceFeatures'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.lookup_features = []
if m.get('LookupFeatures') is not None:
for k in m.get('LookupFeatures'):
temp_model = GetModelFeatureFGFeatureResponseBodyLookupFeatures()
self.lookup_features.append(temp_model.from_map(k))
self.raw_features = []
if m.get('RawFeatures') is not None:
for k in m.get('RawFeatures'):
temp_model = GetModelFeatureFGFeatureResponseBodyRawFeatures()
self.raw_features.append(temp_model.from_map(k))
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Reserves') is not None:
self.reserves = m.get('Reserves')
self.sequence_features = []
if m.get('SequenceFeatures') is not None:
for k in m.get('SequenceFeatures'):
temp_model = GetModelFeatureFGFeatureResponseBodySequenceFeatures()
self.sequence_features.append(temp_model.from_map(k))
return self
class GetModelFeatureFGFeatureResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetModelFeatureFGFeatureResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = GetModelFeatureFGFeatureResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetModelFeatureFGInfoResponseBody(TeaModel):
def __init__(
self,
content: str = None,
request_id: str = None,
):
self.content = content
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.content is not None:
result['Content'] = self.content
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('Content') is not None:
self.content = m.get('Content')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetModelFeatureFGInfoResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetModelFeatureFGInfoResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = GetModelFeatureFGInfoResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetProjectResponseBody(TeaModel):
def __init__(
self,
description: str = None,
feature_entity_count: int = None,
feature_view_count: int = None,
gmt_create_time: str = None,
gmt_modified_time: str = None,
model_count: int = None,
name: str = None,
offline_datasource_id: str = None,
offline_datasource_name: str = None,
offline_datasource_type: str = None,
offline_lifecycle: int = None,
online_datasource_id: str = None,
online_datasource_name: str = None,
online_datasource_type: str = None,
owner: str = None,
request_id: str = None,
):
self.description = description
self.feature_entity_count = feature_entity_count
self.feature_view_count = feature_view_count
self.gmt_create_time = gmt_create_time
self.gmt_modified_time = gmt_modified_time
self.model_count = model_count
self.name = name
self.offline_datasource_id = offline_datasource_id
self.offline_datasource_name = offline_datasource_name
self.offline_datasource_type = offline_datasource_type
self.offline_lifecycle = offline_lifecycle
self.online_datasource_id = online_datasource_id
self.online_datasource_name = online_datasource_name
self.online_datasource_type = online_datasource_type
self.owner = owner
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.description is not None:
result['Description'] = self.description
if self.feature_entity_count is not None:
result['FeatureEntityCount'] = self.feature_entity_count
if self.feature_view_count is not None:
result['FeatureViewCount'] = self.feature_view_count
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_modified_time is not None:
result['GmtModifiedTime'] = self.gmt_modified_time
if self.model_count is not None:
result['ModelCount'] = self.model_count
if self.name is not None:
result['Name'] = self.name
if self.offline_datasource_id is not None:
result['OfflineDatasourceId'] = self.offline_datasource_id
if self.offline_datasource_name is not None:
result['OfflineDatasourceName'] = self.offline_datasource_name
if self.offline_datasource_type is not None:
result['OfflineDatasourceType'] = self.offline_datasource_type
if self.offline_lifecycle is not None:
result['OfflineLifecycle'] = self.offline_lifecycle
if self.online_datasource_id is not None:
result['OnlineDatasourceId'] = self.online_datasource_id
if self.online_datasource_name is not None:
result['OnlineDatasourceName'] = self.online_datasource_name
if self.online_datasource_type is not None:
result['OnlineDatasourceType'] = self.online_datasource_type
if self.owner is not None:
result['Owner'] = self.owner
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('Description') is not None:
self.description = m.get('Description')
if m.get('FeatureEntityCount') is not None:
self.feature_entity_count = m.get('FeatureEntityCount')
if m.get('FeatureViewCount') is not None:
self.feature_view_count = m.get('FeatureViewCount')
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtModifiedTime') is not None:
self.gmt_modified_time = m.get('GmtModifiedTime')
if m.get('ModelCount') is not None:
self.model_count = m.get('ModelCount')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('OfflineDatasourceId') is not None:
self.offline_datasource_id = m.get('OfflineDatasourceId')
if m.get('OfflineDatasourceName') is not None:
self.offline_datasource_name = m.get('OfflineDatasourceName')
if m.get('OfflineDatasourceType') is not None:
self.offline_datasource_type = m.get('OfflineDatasourceType')
if m.get('OfflineLifecycle') is not None:
self.offline_lifecycle = m.get('OfflineLifecycle')
if m.get('OnlineDatasourceId') is not None:
self.online_datasource_id = m.get('OnlineDatasourceId')
if m.get('OnlineDatasourceName') is not None:
self.online_datasource_name = m.get('OnlineDatasourceName')
if m.get('OnlineDatasourceType') is not None:
self.online_datasource_type = m.get('OnlineDatasourceType')
if m.get('Owner') is not None:
self.owner = m.get('Owner')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetProjectResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetProjectResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = GetProjectResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetProjectFeatureEntityResponseBody(TeaModel):
def __init__(
self,
feature_entity_id: str = None,
join_id: str = None,
name: str = None,
project_name: str = None,
request_id: str = None,
workspace_id: str = None,
):
self.feature_entity_id = feature_entity_id
self.join_id = join_id
self.name = name
self.project_name = project_name
self.request_id = request_id
self.workspace_id = workspace_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_entity_id is not None:
result['FeatureEntityId'] = self.feature_entity_id
if self.join_id is not None:
result['JoinId'] = self.join_id
if self.name is not None:
result['Name'] = self.name
if self.project_name is not None:
result['ProjectName'] = self.project_name
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.workspace_id is not None:
result['WorkspaceId'] = self.workspace_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureEntityId') is not None:
self.feature_entity_id = m.get('FeatureEntityId')
if m.get('JoinId') is not None:
self.join_id = m.get('JoinId')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('ProjectName') is not None:
self.project_name = m.get('ProjectName')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('WorkspaceId') is not None:
self.workspace_id = m.get('WorkspaceId')
return self
class GetProjectFeatureEntityResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetProjectFeatureEntityResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = GetProjectFeatureEntityResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetServiceIdentityRoleResponseBody(TeaModel):
def __init__(
self,
policy: str = None,
request_id: str = None,
role_name: str = None,
):
self.policy = policy
self.request_id = request_id
self.role_name = role_name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.policy is not None:
result['Policy'] = self.policy
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.role_name is not None:
result['RoleName'] = self.role_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Policy') is not None:
self.policy = m.get('Policy')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('RoleName') is not None:
self.role_name = m.get('RoleName')
return self
class GetServiceIdentityRoleResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetServiceIdentityRoleResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = GetServiceIdentityRoleResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetTaskResponseBody(TeaModel):
def __init__(
self,
config: str = None,
gmt_create_time: str = None,
gmt_executed_time: str = None,
gmt_finished_time: str = None,
gmt_modified_time: str = None,
object_id: str = None,
object_type: str = None,
project_id: str = None,
project_name: str = None,
request_id: str = None,
running_config: str = None,
status: str = None,
type: str = None,
):
self.config = config
self.gmt_create_time = gmt_create_time
self.gmt_executed_time = gmt_executed_time
self.gmt_finished_time = gmt_finished_time
self.gmt_modified_time = gmt_modified_time
self.object_id = object_id
self.object_type = object_type
self.project_id = project_id
self.project_name = project_name
self.request_id = request_id
self.running_config = running_config
self.status = status
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.config is not None:
result['Config'] = self.config
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_executed_time is not None:
result['GmtExecutedTime'] = self.gmt_executed_time
if self.gmt_finished_time is not None:
result['GmtFinishedTime'] = self.gmt_finished_time
if self.gmt_modified_time is not None:
result['GmtModifiedTime'] = self.gmt_modified_time
if self.object_id is not None:
result['ObjectId'] = self.object_id
if self.object_type is not None:
result['ObjectType'] = self.object_type
if self.project_id is not None:
result['ProjectId'] = self.project_id
if self.project_name is not None:
result['ProjectName'] = self.project_name
if self.request_id is not None:
result['RequestId'] = self.request_id
if self.running_config is not None:
result['RunningConfig'] = self.running_config
if self.status is not None:
result['Status'] = self.status
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Config') is not None:
self.config = m.get('Config')
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtExecutedTime') is not None:
self.gmt_executed_time = m.get('GmtExecutedTime')
if m.get('GmtFinishedTime') is not None:
self.gmt_finished_time = m.get('GmtFinishedTime')
if m.get('GmtModifiedTime') is not None:
self.gmt_modified_time = m.get('GmtModifiedTime')
if m.get('ObjectId') is not None:
self.object_id = m.get('ObjectId')
if m.get('ObjectType') is not None:
self.object_type = m.get('ObjectType')
if m.get('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('ProjectName') is not None:
self.project_name = m.get('ProjectName')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('RunningConfig') is not None:
self.running_config = m.get('RunningConfig')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class GetTaskResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetTaskResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = GetTaskResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListDatasourceTablesRequest(TeaModel):
def __init__(
self,
table_name: str = None,
):
self.table_name = table_name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.table_name is not None:
result['TableName'] = self.table_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('TableName') is not None:
self.table_name = m.get('TableName')
return self
class ListDatasourceTablesResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
tables: List[str] = None,
total_count: int = None,
):
self.request_id = request_id
self.tables = tables
self.total_count = total_count
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.tables is not None:
result['Tables'] = self.tables
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('RequestId') is not None:
self.request_id = m.get('RequestId')
if m.get('Tables') is not None:
self.tables = m.get('Tables')
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListDatasourceTablesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListDatasourceTablesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListDatasourceTablesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListDatasourcesRequest(TeaModel):
def __init__(
self,
name: str = None,
order: str = None,
page_number: int = None,
page_size: int = None,
sort_by: str = None,
type: str = None,
workspace_id: str = None,
):
self.name = name
self.order = order
self.page_number = page_number
self.page_size = page_size
self.sort_by = sort_by
self.type = type
self.workspace_id = workspace_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.order is not None:
result['Order'] = self.order
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.sort_by is not None:
result['SortBy'] = self.sort_by
if self.type is not None:
result['Type'] = self.type
if self.workspace_id is not None:
result['WorkspaceId'] = self.workspace_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('Order') is not None:
self.order = m.get('Order')
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('SortBy') is not None:
self.sort_by = m.get('SortBy')
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('WorkspaceId') is not None:
self.workspace_id = m.get('WorkspaceId')
return self
class ListDatasourcesResponseBodyDatasources(TeaModel):
def __init__(
self,
config: str = None,
datasource_id: str = None,
gmt_create_time: str = None,
gmt_modified_time: str = None,
name: str = None,
type: str = None,
uri: str = None,
workspace_id: str = None,
):
self.config = config
self.datasource_id = datasource_id
self.gmt_create_time = gmt_create_time
self.gmt_modified_time = gmt_modified_time
self.name = name
self.type = type
self.uri = uri
self.workspace_id = workspace_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.config is not None:
result['Config'] = self.config
if self.datasource_id is not None:
result['DatasourceId'] = self.datasource_id
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_modified_time is not None:
result['GmtModifiedTime'] = self.gmt_modified_time
if self.name is not None:
result['Name'] = self.name
if self.type is not None:
result['Type'] = self.type
if self.uri is not None:
result['Uri'] = self.uri
if self.workspace_id is not None:
result['WorkspaceId'] = self.workspace_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Config') is not None:
self.config = m.get('Config')
if m.get('DatasourceId') is not None:
self.datasource_id = m.get('DatasourceId')
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtModifiedTime') is not None:
self.gmt_modified_time = m.get('GmtModifiedTime')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('Uri') is not None:
self.uri = m.get('Uri')
if m.get('WorkspaceId') is not None:
self.workspace_id = m.get('WorkspaceId')
return self
class ListDatasourcesResponseBody(TeaModel):
def __init__(
self,
datasources: List[ListDatasourcesResponseBodyDatasources] = None,
request_id: str = None,
total_count: int = None,
):
self.datasources = datasources
self.request_id = request_id
self.total_count = total_count
def validate(self):
if self.datasources:
for k in self.datasources:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['Datasources'] = []
if self.datasources is not None:
for k in self.datasources:
result['Datasources'].append(k.to_map() if k else None)
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()
self.datasources = []
if m.get('Datasources') is not None:
for k in m.get('Datasources'):
temp_model = ListDatasourcesResponseBodyDatasources()
self.datasources.append(temp_model.from_map(k))
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 ListDatasourcesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListDatasourcesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListDatasourcesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListFeatureEntitiesRequest(TeaModel):
def __init__(
self,
feature_entity_ids: List[str] = None,
name: str = None,
order: str = None,
owner: str = None,
page_number: int = None,
page_size: int = None,
project_id: str = None,
sort_by: str = None,
):
self.feature_entity_ids = feature_entity_ids
self.name = name
self.order = order
self.owner = owner
self.page_number = page_number
self.page_size = page_size
self.project_id = project_id
self.sort_by = sort_by
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_entity_ids is not None:
result['FeatureEntityIds'] = self.feature_entity_ids
if self.name is not None:
result['Name'] = self.name
if self.order is not None:
result['Order'] = self.order
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.project_id is not None:
result['ProjectId'] = self.project_id
if self.sort_by is not None:
result['SortBy'] = self.sort_by
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureEntityIds') is not None:
self.feature_entity_ids = m.get('FeatureEntityIds')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Order') is not None:
self.order = m.get('Order')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('SortBy') is not None:
self.sort_by = m.get('SortBy')
return self
class ListFeatureEntitiesShrinkRequest(TeaModel):
def __init__(
self,
feature_entity_ids_shrink: str = None,
name: str = None,
order: str = None,
owner: str = None,
page_number: int = None,
page_size: int = None,
project_id: str = None,
sort_by: str = None,
):
self.feature_entity_ids_shrink = feature_entity_ids_shrink
self.name = name
self.order = order
self.owner = owner
self.page_number = page_number
self.page_size = page_size
self.project_id = project_id
self.sort_by = sort_by
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_entity_ids_shrink is not None:
result['FeatureEntityIds'] = self.feature_entity_ids_shrink
if self.name is not None:
result['Name'] = self.name
if self.order is not None:
result['Order'] = self.order
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.project_id is not None:
result['ProjectId'] = self.project_id
if self.sort_by is not None:
result['SortBy'] = self.sort_by
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureEntityIds') is not None:
self.feature_entity_ids_shrink = m.get('FeatureEntityIds')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Order') is not None:
self.order = m.get('Order')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('SortBy') is not None:
self.sort_by = m.get('SortBy')
return self
class ListFeatureEntitiesResponseBodyFeatureEntities(TeaModel):
def __init__(
self,
feature_entity_id: str = None,
gmt_create_time: str = None,
join_id: str = None,
name: str = None,
owner: str = None,
project_id: str = None,
project_name: str = None,
):
self.feature_entity_id = feature_entity_id
self.gmt_create_time = gmt_create_time
self.join_id = join_id
self.name = name
self.owner = owner
self.project_id = project_id
self.project_name = project_name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_entity_id is not None:
result['FeatureEntityId'] = self.feature_entity_id
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.join_id is not None:
result['JoinId'] = self.join_id
if self.name is not None:
result['Name'] = self.name
if self.owner is not None:
result['Owner'] = self.owner
if self.project_id is not None:
result['ProjectId'] = self.project_id
if self.project_name is not None:
result['ProjectName'] = self.project_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureEntityId') is not None:
self.feature_entity_id = m.get('FeatureEntityId')
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('JoinId') is not None:
self.join_id = m.get('JoinId')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('ProjectName') is not None:
self.project_name = m.get('ProjectName')
return self
class ListFeatureEntitiesResponseBody(TeaModel):
def __init__(
self,
feature_entities: List[ListFeatureEntitiesResponseBodyFeatureEntities] = None,
request_id: str = None,
total_count: int = None,
):
self.feature_entities = feature_entities
self.request_id = request_id
self.total_count = total_count
def validate(self):
if self.feature_entities:
for k in self.feature_entities:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['FeatureEntities'] = []
if self.feature_entities is not None:
for k in self.feature_entities:
result['FeatureEntities'].append(k.to_map() if k else None)
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()
self.feature_entities = []
if m.get('FeatureEntities') is not None:
for k in m.get('FeatureEntities'):
temp_model = ListFeatureEntitiesResponseBodyFeatureEntities()
self.feature_entities.append(temp_model.from_map(k))
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 ListFeatureEntitiesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListFeatureEntitiesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListFeatureEntitiesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListFeatureViewFieldRelationshipsResponseBodyRelationshipsModels(TeaModel):
def __init__(
self,
feature_alias_name: str = None,
model_id: str = None,
model_name: str = None,
):
self.feature_alias_name = feature_alias_name
self.model_id = model_id
self.model_name = model_name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_alias_name is not None:
result['FeatureAliasName'] = self.feature_alias_name
if self.model_id is not None:
result['ModelId'] = self.model_id
if self.model_name is not None:
result['ModelName'] = self.model_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureAliasName') is not None:
self.feature_alias_name = m.get('FeatureAliasName')
if m.get('ModelId') is not None:
self.model_id = m.get('ModelId')
if m.get('ModelName') is not None:
self.model_name = m.get('ModelName')
return self
class ListFeatureViewFieldRelationshipsResponseBodyRelationships(TeaModel):
def __init__(
self,
feature_name: str = None,
models: List[ListFeatureViewFieldRelationshipsResponseBodyRelationshipsModels] = None,
offline_table_name: str = None,
online_table_name: str = None,
):
self.feature_name = feature_name
self.models = models
self.offline_table_name = offline_table_name
self.online_table_name = online_table_name
def validate(self):
if self.models:
for k in self.models:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_name is not None:
result['FeatureName'] = self.feature_name
result['Models'] = []
if self.models is not None:
for k in self.models:
result['Models'].append(k.to_map() if k else None)
if self.offline_table_name is not None:
result['OfflineTableName'] = self.offline_table_name
if self.online_table_name is not None:
result['OnlineTableName'] = self.online_table_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureName') is not None:
self.feature_name = m.get('FeatureName')
self.models = []
if m.get('Models') is not None:
for k in m.get('Models'):
temp_model = ListFeatureViewFieldRelationshipsResponseBodyRelationshipsModels()
self.models.append(temp_model.from_map(k))
if m.get('OfflineTableName') is not None:
self.offline_table_name = m.get('OfflineTableName')
if m.get('OnlineTableName') is not None:
self.online_table_name = m.get('OnlineTableName')
return self
class ListFeatureViewFieldRelationshipsResponseBody(TeaModel):
def __init__(
self,
relationships: List[ListFeatureViewFieldRelationshipsResponseBodyRelationships] = None,
request_id: str = None,
):
self.relationships = relationships
self.request_id = request_id
def validate(self):
if self.relationships:
for k in self.relationships:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['Relationships'] = []
if self.relationships is not None:
for k in self.relationships:
result['Relationships'].append(k.to_map() if k else None)
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
self.relationships = []
if m.get('Relationships') is not None:
for k in m.get('Relationships'):
temp_model = ListFeatureViewFieldRelationshipsResponseBodyRelationships()
self.relationships.append(temp_model.from_map(k))
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ListFeatureViewFieldRelationshipsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListFeatureViewFieldRelationshipsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListFeatureViewFieldRelationshipsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListFeatureViewOnlineFeaturesRequest(TeaModel):
def __init__(
self,
join_ids: List[str] = None,
):
# This parameter is required.
self.join_ids = join_ids
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.join_ids is not None:
result['JoinIds'] = self.join_ids
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('JoinIds') is not None:
self.join_ids = m.get('JoinIds')
return self
class ListFeatureViewOnlineFeaturesShrinkRequest(TeaModel):
def __init__(
self,
join_ids_shrink: str = None,
):
# This parameter is required.
self.join_ids_shrink = join_ids_shrink
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.join_ids_shrink is not None:
result['JoinIds'] = self.join_ids_shrink
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('JoinIds') is not None:
self.join_ids_shrink = m.get('JoinIds')
return self
class ListFeatureViewOnlineFeaturesResponseBody(TeaModel):
def __init__(
self,
online_features: List[str] = None,
request_id: str = None,
):
self.online_features = online_features
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.online_features is not None:
result['OnlineFeatures'] = self.online_features
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('OnlineFeatures') is not None:
self.online_features = m.get('OnlineFeatures')
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ListFeatureViewOnlineFeaturesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListFeatureViewOnlineFeaturesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListFeatureViewOnlineFeaturesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListFeatureViewRelationshipsResponseBodyRelationshipsModels(TeaModel):
def __init__(
self,
model_id: str = None,
model_name: str = None,
):
self.model_id = model_id
self.model_name = model_name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.model_id is not None:
result['ModelId'] = self.model_id
if self.model_name is not None:
result['ModelName'] = self.model_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ModelId') is not None:
self.model_id = m.get('ModelId')
if m.get('ModelName') is not None:
self.model_name = m.get('ModelName')
return self
class ListFeatureViewRelationshipsResponseBodyRelationships(TeaModel):
def __init__(
self,
feature_view_name: str = None,
models: List[ListFeatureViewRelationshipsResponseBodyRelationshipsModels] = None,
project_name: str = None,
):
self.feature_view_name = feature_view_name
self.models = models
self.project_name = project_name
def validate(self):
if self.models:
for k in self.models:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_view_name is not None:
result['FeatureViewName'] = self.feature_view_name
result['Models'] = []
if self.models is not None:
for k in self.models:
result['Models'].append(k.to_map() if k else None)
if self.project_name is not None:
result['ProjectName'] = self.project_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureViewName') is not None:
self.feature_view_name = m.get('FeatureViewName')
self.models = []
if m.get('Models') is not None:
for k in m.get('Models'):
temp_model = ListFeatureViewRelationshipsResponseBodyRelationshipsModels()
self.models.append(temp_model.from_map(k))
if m.get('ProjectName') is not None:
self.project_name = m.get('ProjectName')
return self
class ListFeatureViewRelationshipsResponseBody(TeaModel):
def __init__(
self,
relationships: List[ListFeatureViewRelationshipsResponseBodyRelationships] = None,
request_id: str = None,
):
self.relationships = relationships
self.request_id = request_id
def validate(self):
if self.relationships:
for k in self.relationships:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['Relationships'] = []
if self.relationships is not None:
for k in self.relationships:
result['Relationships'].append(k.to_map() if k else None)
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
self.relationships = []
if m.get('Relationships') is not None:
for k in m.get('Relationships'):
temp_model = ListFeatureViewRelationshipsResponseBodyRelationships()
self.relationships.append(temp_model.from_map(k))
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ListFeatureViewRelationshipsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListFeatureViewRelationshipsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListFeatureViewRelationshipsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListFeatureViewsRequest(TeaModel):
def __init__(
self,
feature_name: str = None,
feature_view_ids: List[str] = None,
name: str = None,
order: str = None,
owner: str = None,
page_number: int = None,
page_size: int = None,
project_id: str = None,
sort_by: str = None,
tag: str = None,
type: str = None,
):
self.feature_name = feature_name
self.feature_view_ids = feature_view_ids
self.name = name
self.order = order
self.owner = owner
self.page_number = page_number
self.page_size = page_size
self.project_id = project_id
self.sort_by = sort_by
self.tag = tag
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_name is not None:
result['FeatureName'] = self.feature_name
if self.feature_view_ids is not None:
result['FeatureViewIds'] = self.feature_view_ids
if self.name is not None:
result['Name'] = self.name
if self.order is not None:
result['Order'] = self.order
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.project_id is not None:
result['ProjectId'] = self.project_id
if self.sort_by is not None:
result['SortBy'] = self.sort_by
if self.tag is not None:
result['Tag'] = self.tag
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureName') is not None:
self.feature_name = m.get('FeatureName')
if m.get('FeatureViewIds') is not None:
self.feature_view_ids = m.get('FeatureViewIds')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Order') is not None:
self.order = m.get('Order')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('SortBy') is not None:
self.sort_by = m.get('SortBy')
if m.get('Tag') is not None:
self.tag = m.get('Tag')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class ListFeatureViewsShrinkRequest(TeaModel):
def __init__(
self,
feature_name: str = None,
feature_view_ids_shrink: str = None,
name: str = None,
order: str = None,
owner: str = None,
page_number: int = None,
page_size: int = None,
project_id: str = None,
sort_by: str = None,
tag: str = None,
type: str = None,
):
self.feature_name = feature_name
self.feature_view_ids_shrink = feature_view_ids_shrink
self.name = name
self.order = order
self.owner = owner
self.page_number = page_number
self.page_size = page_size
self.project_id = project_id
self.sort_by = sort_by
self.tag = tag
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_name is not None:
result['FeatureName'] = self.feature_name
if self.feature_view_ids_shrink is not None:
result['FeatureViewIds'] = self.feature_view_ids_shrink
if self.name is not None:
result['Name'] = self.name
if self.order is not None:
result['Order'] = self.order
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.project_id is not None:
result['ProjectId'] = self.project_id
if self.sort_by is not None:
result['SortBy'] = self.sort_by
if self.tag is not None:
result['Tag'] = self.tag
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureName') is not None:
self.feature_name = m.get('FeatureName')
if m.get('FeatureViewIds') is not None:
self.feature_view_ids_shrink = m.get('FeatureViewIds')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Order') is not None:
self.order = m.get('Order')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('SortBy') is not None:
self.sort_by = m.get('SortBy')
if m.get('Tag') is not None:
self.tag = m.get('Tag')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class ListFeatureViewsResponseBodyFeatureViews(TeaModel):
def __init__(
self,
feature_entity_name: str = None,
feature_view_id: str = None,
gmt_create_time: str = None,
gmt_modified_time: str = None,
name: str = None,
owner: str = None,
project_id: str = None,
project_name: str = None,
register_datasource_id: str = None,
register_datasource_name: str = None,
register_table: str = None,
ttl: int = None,
type: str = None,
write_to_feature_db: bool = None,
):
self.feature_entity_name = feature_entity_name
self.feature_view_id = feature_view_id
self.gmt_create_time = gmt_create_time
self.gmt_modified_time = gmt_modified_time
self.name = name
self.owner = owner
self.project_id = project_id
self.project_name = project_name
self.register_datasource_id = register_datasource_id
self.register_datasource_name = register_datasource_name
self.register_table = register_table
self.ttl = ttl
self.type = type
self.write_to_feature_db = write_to_feature_db
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_entity_name is not None:
result['FeatureEntityName'] = self.feature_entity_name
if self.feature_view_id is not None:
result['FeatureViewId'] = self.feature_view_id
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_modified_time is not None:
result['GmtModifiedTime'] = self.gmt_modified_time
if self.name is not None:
result['Name'] = self.name
if self.owner is not None:
result['Owner'] = self.owner
if self.project_id is not None:
result['ProjectId'] = self.project_id
if self.project_name is not None:
result['ProjectName'] = self.project_name
if self.register_datasource_id is not None:
result['RegisterDatasourceId'] = self.register_datasource_id
if self.register_datasource_name is not None:
result['RegisterDatasourceName'] = self.register_datasource_name
if self.register_table is not None:
result['RegisterTable'] = self.register_table
if self.ttl is not None:
result['TTL'] = self.ttl
if self.type is not None:
result['Type'] = self.type
if self.write_to_feature_db is not None:
result['WriteToFeatureDB'] = self.write_to_feature_db
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureEntityName') is not None:
self.feature_entity_name = m.get('FeatureEntityName')
if m.get('FeatureViewId') is not None:
self.feature_view_id = m.get('FeatureViewId')
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtModifiedTime') is not None:
self.gmt_modified_time = m.get('GmtModifiedTime')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('ProjectName') is not None:
self.project_name = m.get('ProjectName')
if m.get('RegisterDatasourceId') is not None:
self.register_datasource_id = m.get('RegisterDatasourceId')
if m.get('RegisterDatasourceName') is not None:
self.register_datasource_name = m.get('RegisterDatasourceName')
if m.get('RegisterTable') is not None:
self.register_table = m.get('RegisterTable')
if m.get('TTL') is not None:
self.ttl = m.get('TTL')
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('WriteToFeatureDB') is not None:
self.write_to_feature_db = m.get('WriteToFeatureDB')
return self
class ListFeatureViewsResponseBody(TeaModel):
def __init__(
self,
feature_views: List[ListFeatureViewsResponseBodyFeatureViews] = None,
request_id: str = None,
total_count: int = None,
):
self.feature_views = feature_views
self.request_id = request_id
self.total_count = total_count
def validate(self):
if self.feature_views:
for k in self.feature_views:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['FeatureViews'] = []
if self.feature_views is not None:
for k in self.feature_views:
result['FeatureViews'].append(k.to_map() if k else None)
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()
self.feature_views = []
if m.get('FeatureViews') is not None:
for k in m.get('FeatureViews'):
temp_model = ListFeatureViewsResponseBodyFeatureViews()
self.feature_views.append(temp_model.from_map(k))
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 ListFeatureViewsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListFeatureViewsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListFeatureViewsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListInstancesRequest(TeaModel):
def __init__(
self,
order: str = None,
page_number: int = None,
page_size: int = None,
sort_by: str = None,
status: str = None,
):
self.order = order
self.page_number = page_number
self.page_size = page_size
self.sort_by = sort_by
self.status = status
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.order is not None:
result['Order'] = self.order
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.sort_by is not None:
result['SortBy'] = self.sort_by
if self.status is not None:
result['Status'] = self.status
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Order') is not None:
self.order = m.get('Order')
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('SortBy') is not None:
self.sort_by = m.get('SortBy')
if m.get('Status') is not None:
self.status = m.get('Status')
return self
class ListInstancesResponseBodyInstancesFeatureDBInstanceInfo(TeaModel):
def __init__(
self,
status: str = None,
):
self.status = status
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.status is not None:
result['Status'] = self.status
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Status') is not None:
self.status = m.get('Status')
return self
class ListInstancesResponseBodyInstances(TeaModel):
def __init__(
self,
feature_dbinstance_info: ListInstancesResponseBodyInstancesFeatureDBInstanceInfo = None,
gmt_create_time: str = None,
gmt_modified_time: str = None,
instance_id: str = None,
region_id: str = None,
status: str = None,
type: str = None,
):
self.feature_dbinstance_info = feature_dbinstance_info
self.gmt_create_time = gmt_create_time
self.gmt_modified_time = gmt_modified_time
self.instance_id = instance_id
self.region_id = region_id
self.status = status
self.type = type
def validate(self):
if self.feature_dbinstance_info:
self.feature_dbinstance_info.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_dbinstance_info is not None:
result['FeatureDBInstanceInfo'] = self.feature_dbinstance_info.to_map()
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_modified_time is not None:
result['GmtModifiedTime'] = self.gmt_modified_time
if self.instance_id is not None:
result['InstanceId'] = self.instance_id
if self.region_id is not None:
result['RegionId'] = self.region_id
if self.status is not None:
result['Status'] = self.status
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureDBInstanceInfo') is not None:
temp_model = ListInstancesResponseBodyInstancesFeatureDBInstanceInfo()
self.feature_dbinstance_info = temp_model.from_map(m['FeatureDBInstanceInfo'])
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtModifiedTime') is not None:
self.gmt_modified_time = m.get('GmtModifiedTime')
if m.get('InstanceId') is not None:
self.instance_id = m.get('InstanceId')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class ListInstancesResponseBody(TeaModel):
def __init__(
self,
instances: List[ListInstancesResponseBodyInstances] = None,
request_id: str = None,
total_count: int = None,
):
self.instances = instances
self.request_id = request_id
self.total_count = total_count
def validate(self):
if self.instances:
for k in self.instances:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['Instances'] = []
if self.instances is not None:
for k in self.instances:
result['Instances'].append(k.to_map() if k else None)
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()
self.instances = []
if m.get('Instances') is not None:
for k in m.get('Instances'):
temp_model = ListInstancesResponseBodyInstances()
self.instances.append(temp_model.from_map(k))
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 ListInstancesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListInstancesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListInstancesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListLabelTablesRequest(TeaModel):
def __init__(
self,
label_table_ids: List[str] = None,
name: str = None,
order: str = None,
owner: str = None,
page_number: int = None,
page_size: int = None,
project_id: str = None,
sort_by: str = None,
):
self.label_table_ids = label_table_ids
self.name = name
self.order = order
self.owner = owner
self.page_number = page_number
self.page_size = page_size
self.project_id = project_id
self.sort_by = sort_by
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.label_table_ids is not None:
result['LabelTableIds'] = self.label_table_ids
if self.name is not None:
result['Name'] = self.name
if self.order is not None:
result['Order'] = self.order
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.project_id is not None:
result['ProjectId'] = self.project_id
if self.sort_by is not None:
result['SortBy'] = self.sort_by
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('LabelTableIds') is not None:
self.label_table_ids = m.get('LabelTableIds')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Order') is not None:
self.order = m.get('Order')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('SortBy') is not None:
self.sort_by = m.get('SortBy')
return self
class ListLabelTablesShrinkRequest(TeaModel):
def __init__(
self,
label_table_ids_shrink: str = None,
name: str = None,
order: str = None,
owner: str = None,
page_number: int = None,
page_size: int = None,
project_id: str = None,
sort_by: str = None,
):
self.label_table_ids_shrink = label_table_ids_shrink
self.name = name
self.order = order
self.owner = owner
self.page_number = page_number
self.page_size = page_size
self.project_id = project_id
self.sort_by = sort_by
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.label_table_ids_shrink is not None:
result['LabelTableIds'] = self.label_table_ids_shrink
if self.name is not None:
result['Name'] = self.name
if self.order is not None:
result['Order'] = self.order
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.project_id is not None:
result['ProjectId'] = self.project_id
if self.sort_by is not None:
result['SortBy'] = self.sort_by
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('LabelTableIds') is not None:
self.label_table_ids_shrink = m.get('LabelTableIds')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Order') is not None:
self.order = m.get('Order')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('SortBy') is not None:
self.sort_by = m.get('SortBy')
return self
class ListLabelTablesResponseBodyLabelTables(TeaModel):
def __init__(
self,
datasource_id: str = None,
datasource_name: str = None,
gmt_create_time: str = None,
gmt_modified_time: str = None,
label_table_id: str = None,
name: str = None,
owner: str = None,
project_id: str = None,
project_name: str = None,
):
self.datasource_id = datasource_id
self.datasource_name = datasource_name
self.gmt_create_time = gmt_create_time
self.gmt_modified_time = gmt_modified_time
self.label_table_id = label_table_id
self.name = name
self.owner = owner
self.project_id = project_id
self.project_name = project_name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.datasource_id is not None:
result['DatasourceId'] = self.datasource_id
if self.datasource_name is not None:
result['DatasourceName'] = self.datasource_name
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_modified_time is not None:
result['GmtModifiedTime'] = self.gmt_modified_time
if self.label_table_id is not None:
result['LabelTableId'] = self.label_table_id
if self.name is not None:
result['Name'] = self.name
if self.owner is not None:
result['Owner'] = self.owner
if self.project_id is not None:
result['ProjectId'] = self.project_id
if self.project_name is not None:
result['ProjectName'] = self.project_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DatasourceId') is not None:
self.datasource_id = m.get('DatasourceId')
if m.get('DatasourceName') is not None:
self.datasource_name = m.get('DatasourceName')
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtModifiedTime') is not None:
self.gmt_modified_time = m.get('GmtModifiedTime')
if m.get('LabelTableId') is not None:
self.label_table_id = m.get('LabelTableId')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('ProjectName') is not None:
self.project_name = m.get('ProjectName')
return self
class ListLabelTablesResponseBody(TeaModel):
def __init__(
self,
label_tables: List[ListLabelTablesResponseBodyLabelTables] = None,
request_id: str = None,
total_count: int = None,
):
self.label_tables = label_tables
self.request_id = request_id
self.total_count = total_count
def validate(self):
if self.label_tables:
for k in self.label_tables:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['LabelTables'] = []
if self.label_tables is not None:
for k in self.label_tables:
result['LabelTables'].append(k.to_map() if k else None)
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()
self.label_tables = []
if m.get('LabelTables') is not None:
for k in m.get('LabelTables'):
temp_model = ListLabelTablesResponseBodyLabelTables()
self.label_tables.append(temp_model.from_map(k))
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 ListLabelTablesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListLabelTablesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListLabelTablesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListModelFeatureAvailableFeaturesRequest(TeaModel):
def __init__(
self,
feature_name: str = None,
):
self.feature_name = feature_name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_name is not None:
result['FeatureName'] = self.feature_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureName') is not None:
self.feature_name = m.get('FeatureName')
return self
class ListModelFeatureAvailableFeaturesResponseBodyAvaliableFeatures(TeaModel):
def __init__(
self,
name: str = None,
source_name: str = None,
source_type: str = None,
type: str = None,
):
self.name = name
self.source_name = source_name
self.source_type = source_type
self.type = type
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.source_name is not None:
result['SourceName'] = self.source_name
if self.source_type is not None:
result['SourceType'] = self.source_type
if self.type is not None:
result['Type'] = self.type
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('SourceName') is not None:
self.source_name = m.get('SourceName')
if m.get('SourceType') is not None:
self.source_type = m.get('SourceType')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class ListModelFeatureAvailableFeaturesResponseBody(TeaModel):
def __init__(
self,
avaliable_features: List[ListModelFeatureAvailableFeaturesResponseBodyAvaliableFeatures] = None,
total_count: int = None,
request_id: str = None,
):
self.avaliable_features = avaliable_features
self.total_count = total_count
self.request_id = request_id
def validate(self):
if self.avaliable_features:
for k in self.avaliable_features:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['AvaliableFeatures'] = []
if self.avaliable_features is not None:
for k in self.avaliable_features:
result['AvaliableFeatures'].append(k.to_map() if k else None)
if self.total_count is not None:
result['TotalCount'] = self.total_count
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()
self.avaliable_features = []
if m.get('AvaliableFeatures') is not None:
for k in m.get('AvaliableFeatures'):
temp_model = ListModelFeatureAvailableFeaturesResponseBodyAvaliableFeatures()
self.avaliable_features.append(temp_model.from_map(k))
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
if m.get('requestId') is not None:
self.request_id = m.get('requestId')
return self
class ListModelFeatureAvailableFeaturesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListModelFeatureAvailableFeaturesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListModelFeatureAvailableFeaturesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListModelFeaturesRequest(TeaModel):
def __init__(
self,
model_feature_ids: List[str] = None,
name: str = None,
order: str = None,
owner: str = None,
page_number: int = None,
page_size: int = None,
project_id: str = None,
sort_by: str = None,
):
self.model_feature_ids = model_feature_ids
self.name = name
self.order = order
self.owner = owner
self.page_number = page_number
self.page_size = page_size
self.project_id = project_id
self.sort_by = sort_by
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.model_feature_ids is not None:
result['ModelFeatureIds'] = self.model_feature_ids
if self.name is not None:
result['Name'] = self.name
if self.order is not None:
result['Order'] = self.order
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.project_id is not None:
result['ProjectId'] = self.project_id
if self.sort_by is not None:
result['SortBy'] = self.sort_by
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ModelFeatureIds') is not None:
self.model_feature_ids = m.get('ModelFeatureIds')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Order') is not None:
self.order = m.get('Order')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('SortBy') is not None:
self.sort_by = m.get('SortBy')
return self
class ListModelFeaturesShrinkRequest(TeaModel):
def __init__(
self,
model_feature_ids_shrink: str = None,
name: str = None,
order: str = None,
owner: str = None,
page_number: int = None,
page_size: int = None,
project_id: str = None,
sort_by: str = None,
):
self.model_feature_ids_shrink = model_feature_ids_shrink
self.name = name
self.order = order
self.owner = owner
self.page_number = page_number
self.page_size = page_size
self.project_id = project_id
self.sort_by = sort_by
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.model_feature_ids_shrink is not None:
result['ModelFeatureIds'] = self.model_feature_ids_shrink
if self.name is not None:
result['Name'] = self.name
if self.order is not None:
result['Order'] = self.order
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.project_id is not None:
result['ProjectId'] = self.project_id
if self.sort_by is not None:
result['SortBy'] = self.sort_by
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ModelFeatureIds') is not None:
self.model_feature_ids_shrink = m.get('ModelFeatureIds')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Order') is not None:
self.order = m.get('Order')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('SortBy') is not None:
self.sort_by = m.get('SortBy')
return self
class ListModelFeaturesResponseBodyModelFeatures(TeaModel):
def __init__(
self,
gmt_create_time: str = None,
gmt_modified_time: str = None,
label_table_name: str = None,
model_feature_id: str = None,
name: str = None,
owner: str = None,
project_id: str = None,
project_name: str = None,
):
self.gmt_create_time = gmt_create_time
self.gmt_modified_time = gmt_modified_time
self.label_table_name = label_table_name
self.model_feature_id = model_feature_id
self.name = name
self.owner = owner
self.project_id = project_id
self.project_name = project_name
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_modified_time is not None:
result['GmtModifiedTime'] = self.gmt_modified_time
if self.label_table_name is not None:
result['LabelTableName'] = self.label_table_name
if self.model_feature_id is not None:
result['ModelFeatureId'] = self.model_feature_id
if self.name is not None:
result['Name'] = self.name
if self.owner is not None:
result['Owner'] = self.owner
if self.project_id is not None:
result['ProjectId'] = self.project_id
if self.project_name is not None:
result['ProjectName'] = self.project_name
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtModifiedTime') is not None:
self.gmt_modified_time = m.get('GmtModifiedTime')
if m.get('LabelTableName') is not None:
self.label_table_name = m.get('LabelTableName')
if m.get('ModelFeatureId') is not None:
self.model_feature_id = m.get('ModelFeatureId')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('ProjectName') is not None:
self.project_name = m.get('ProjectName')
return self
class ListModelFeaturesResponseBody(TeaModel):
def __init__(
self,
model_features: List[ListModelFeaturesResponseBodyModelFeatures] = None,
request_id: str = None,
total_count: int = None,
):
self.model_features = model_features
self.request_id = request_id
self.total_count = total_count
def validate(self):
if self.model_features:
for k in self.model_features:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['ModelFeatures'] = []
if self.model_features is not None:
for k in self.model_features:
result['ModelFeatures'].append(k.to_map() if k else None)
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()
self.model_features = []
if m.get('ModelFeatures') is not None:
for k in m.get('ModelFeatures'):
temp_model = ListModelFeaturesResponseBodyModelFeatures()
self.model_features.append(temp_model.from_map(k))
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 ListModelFeaturesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListModelFeaturesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListModelFeaturesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListProjectFeatureViewsResponseBodyFeatureViewsFeatures(TeaModel):
def __init__(
self,
attributes: List[str] = None,
name: str = None,
type: str = None,
):
self.attributes = attributes
self.name = name
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.attributes is not None:
result['Attributes'] = self.attributes
if self.name is not None:
result['Name'] = self.name
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Attributes') is not None:
self.attributes = m.get('Attributes')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class ListProjectFeatureViewsResponseBodyFeatureViews(TeaModel):
def __init__(
self,
feature_view_id: str = None,
features: List[ListProjectFeatureViewsResponseBodyFeatureViewsFeatures] = None,
name: str = None,
type: str = None,
):
self.feature_view_id = feature_view_id
self.features = features
self.name = name
self.type = type
def validate(self):
if self.features:
for k in self.features:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.feature_view_id is not None:
result['FeatureViewId'] = self.feature_view_id
result['Features'] = []
if self.features is not None:
for k in self.features:
result['Features'].append(k.to_map() if k else None)
if self.name is not None:
result['Name'] = self.name
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('FeatureViewId') is not None:
self.feature_view_id = m.get('FeatureViewId')
self.features = []
if m.get('Features') is not None:
for k in m.get('Features'):
temp_model = ListProjectFeatureViewsResponseBodyFeatureViewsFeatures()
self.features.append(temp_model.from_map(k))
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class ListProjectFeatureViewsResponseBody(TeaModel):
def __init__(
self,
feature_views: List[ListProjectFeatureViewsResponseBodyFeatureViews] = None,
request_id: str = None,
total_count: int = None,
):
self.feature_views = feature_views
self.request_id = request_id
self.total_count = total_count
def validate(self):
if self.feature_views:
for k in self.feature_views:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['FeatureViews'] = []
if self.feature_views is not None:
for k in self.feature_views:
result['FeatureViews'].append(k.to_map() if k else None)
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()
self.feature_views = []
if m.get('FeatureViews') is not None:
for k in m.get('FeatureViews'):
temp_model = ListProjectFeatureViewsResponseBodyFeatureViews()
self.feature_views.append(temp_model.from_map(k))
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 ListProjectFeatureViewsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListProjectFeatureViewsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListProjectFeatureViewsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListProjectsRequest(TeaModel):
def __init__(
self,
name: str = None,
order: str = None,
owner: str = None,
page_number: int = None,
page_size: int = None,
project_ids: List[str] = None,
sort_by: str = None,
workspace_id: str = None,
):
self.name = name
self.order = order
self.owner = owner
self.page_number = page_number
self.page_size = page_size
self.project_ids = project_ids
self.sort_by = sort_by
self.workspace_id = workspace_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.order is not None:
result['Order'] = self.order
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.project_ids is not None:
result['ProjectIds'] = self.project_ids
if self.sort_by is not None:
result['SortBy'] = self.sort_by
if self.workspace_id is not None:
result['WorkspaceId'] = self.workspace_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('Order') is not None:
self.order = m.get('Order')
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('ProjectIds') is not None:
self.project_ids = m.get('ProjectIds')
if m.get('SortBy') is not None:
self.sort_by = m.get('SortBy')
if m.get('WorkspaceId') is not None:
self.workspace_id = m.get('WorkspaceId')
return self
class ListProjectsShrinkRequest(TeaModel):
def __init__(
self,
name: str = None,
order: str = None,
owner: str = None,
page_number: int = None,
page_size: int = None,
project_ids_shrink: str = None,
sort_by: str = None,
workspace_id: str = None,
):
self.name = name
self.order = order
self.owner = owner
self.page_number = page_number
self.page_size = page_size
self.project_ids_shrink = project_ids_shrink
self.sort_by = sort_by
self.workspace_id = workspace_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.order is not None:
result['Order'] = self.order
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.project_ids_shrink is not None:
result['ProjectIds'] = self.project_ids_shrink
if self.sort_by is not None:
result['SortBy'] = self.sort_by
if self.workspace_id is not None:
result['WorkspaceId'] = self.workspace_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('Order') is not None:
self.order = m.get('Order')
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('ProjectIds') is not None:
self.project_ids_shrink = m.get('ProjectIds')
if m.get('SortBy') is not None:
self.sort_by = m.get('SortBy')
if m.get('WorkspaceId') is not None:
self.workspace_id = m.get('WorkspaceId')
return self
class ListProjectsResponseBodyProjects(TeaModel):
def __init__(
self,
description: str = None,
feature_entity_count: int = None,
feature_view_count: int = None,
gmt_create_time: str = None,
gmt_modified_time: str = None,
model_count: int = None,
name: str = None,
offline_datasource_id: str = None,
offline_datasource_name: str = None,
offline_datasource_type: str = None,
offline_lifecycle: int = None,
online_datasource_id: str = None,
online_datasource_name: str = None,
online_datasource_type: str = None,
owner: str = None,
project_id: str = None,
):
self.description = description
self.feature_entity_count = feature_entity_count
self.feature_view_count = feature_view_count
self.gmt_create_time = gmt_create_time
self.gmt_modified_time = gmt_modified_time
self.model_count = model_count
self.name = name
self.offline_datasource_id = offline_datasource_id
self.offline_datasource_name = offline_datasource_name
self.offline_datasource_type = offline_datasource_type
self.offline_lifecycle = offline_lifecycle
self.online_datasource_id = online_datasource_id
self.online_datasource_name = online_datasource_name
self.online_datasource_type = online_datasource_type
self.owner = owner
self.project_id = project_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.description is not None:
result['Description'] = self.description
if self.feature_entity_count is not None:
result['FeatureEntityCount'] = self.feature_entity_count
if self.feature_view_count is not None:
result['FeatureViewCount'] = self.feature_view_count
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_modified_time is not None:
result['GmtModifiedTime'] = self.gmt_modified_time
if self.model_count is not None:
result['ModelCount'] = self.model_count
if self.name is not None:
result['Name'] = self.name
if self.offline_datasource_id is not None:
result['OfflineDatasourceId'] = self.offline_datasource_id
if self.offline_datasource_name is not None:
result['OfflineDatasourceName'] = self.offline_datasource_name
if self.offline_datasource_type is not None:
result['OfflineDatasourceType'] = self.offline_datasource_type
if self.offline_lifecycle is not None:
result['OfflineLifecycle'] = self.offline_lifecycle
if self.online_datasource_id is not None:
result['OnlineDatasourceId'] = self.online_datasource_id
if self.online_datasource_name is not None:
result['OnlineDatasourceName'] = self.online_datasource_name
if self.online_datasource_type is not None:
result['OnlineDatasourceType'] = self.online_datasource_type
if self.owner is not None:
result['Owner'] = self.owner
if self.project_id is not None:
result['ProjectId'] = self.project_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Description') is not None:
self.description = m.get('Description')
if m.get('FeatureEntityCount') is not None:
self.feature_entity_count = m.get('FeatureEntityCount')
if m.get('FeatureViewCount') is not None:
self.feature_view_count = m.get('FeatureViewCount')
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtModifiedTime') is not None:
self.gmt_modified_time = m.get('GmtModifiedTime')
if m.get('ModelCount') is not None:
self.model_count = m.get('ModelCount')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('OfflineDatasourceId') is not None:
self.offline_datasource_id = m.get('OfflineDatasourceId')
if m.get('OfflineDatasourceName') is not None:
self.offline_datasource_name = m.get('OfflineDatasourceName')
if m.get('OfflineDatasourceType') is not None:
self.offline_datasource_type = m.get('OfflineDatasourceType')
if m.get('OfflineLifecycle') is not None:
self.offline_lifecycle = m.get('OfflineLifecycle')
if m.get('OnlineDatasourceId') is not None:
self.online_datasource_id = m.get('OnlineDatasourceId')
if m.get('OnlineDatasourceName') is not None:
self.online_datasource_name = m.get('OnlineDatasourceName')
if m.get('OnlineDatasourceType') is not None:
self.online_datasource_type = m.get('OnlineDatasourceType')
if m.get('Owner') is not None:
self.owner = m.get('Owner')
if m.get('ProjectId') is not None:
self.project_id = m.get('ProjectId')
return self
class ListProjectsResponseBody(TeaModel):
def __init__(
self,
projects: List[ListProjectsResponseBodyProjects] = None,
request_id: str = None,
total_count: int = None,
):
self.projects = projects
self.request_id = request_id
self.total_count = total_count
def validate(self):
if self.projects:
for k in self.projects:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['Projects'] = []
if self.projects is not None:
for k in self.projects:
result['Projects'].append(k.to_map() if k else None)
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()
self.projects = []
if m.get('Projects') is not None:
for k in m.get('Projects'):
temp_model = ListProjectsResponseBodyProjects()
self.projects.append(temp_model.from_map(k))
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 ListProjectsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListProjectsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListProjectsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListTaskLogsRequest(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 ListTaskLogsResponseBody(TeaModel):
def __init__(
self,
logs: List[str] = None,
request_id: str = None,
total_count: int = None,
):
self.logs = logs
self.request_id = request_id
self.total_count = total_count
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.logs is not None:
result['Logs'] = self.logs
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('Logs') is not None:
self.logs = m.get('Logs')
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 ListTaskLogsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListTaskLogsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListTaskLogsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListTasksRequest(TeaModel):
def __init__(
self,
object_id: str = None,
object_type: str = None,
page_number: int = None,
page_size: int = None,
project_id: str = None,
status: str = None,
task_ids: List[str] = None,
type: str = None,
):
self.object_id = object_id
self.object_type = object_type
self.page_number = page_number
self.page_size = page_size
self.project_id = project_id
self.status = status
self.task_ids = task_ids
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.object_id is not None:
result['ObjectId'] = self.object_id
if self.object_type is not None:
result['ObjectType'] = self.object_type
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.project_id is not None:
result['ProjectId'] = self.project_id
if self.status is not None:
result['Status'] = self.status
if self.task_ids is not None:
result['TaskIds'] = self.task_ids
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ObjectId') is not None:
self.object_id = m.get('ObjectId')
if m.get('ObjectType') is not None:
self.object_type = m.get('ObjectType')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('TaskIds') is not None:
self.task_ids = m.get('TaskIds')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class ListTasksShrinkRequest(TeaModel):
def __init__(
self,
object_id: str = None,
object_type: str = None,
page_number: int = None,
page_size: int = None,
project_id: str = None,
status: str = None,
task_ids_shrink: str = None,
type: str = None,
):
self.object_id = object_id
self.object_type = object_type
self.page_number = page_number
self.page_size = page_size
self.project_id = project_id
self.status = status
self.task_ids_shrink = task_ids_shrink
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.object_id is not None:
result['ObjectId'] = self.object_id
if self.object_type is not None:
result['ObjectType'] = self.object_type
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.project_id is not None:
result['ProjectId'] = self.project_id
if self.status is not None:
result['Status'] = self.status
if self.task_ids_shrink is not None:
result['TaskIds'] = self.task_ids_shrink
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ObjectId') is not None:
self.object_id = m.get('ObjectId')
if m.get('ObjectType') is not None:
self.object_type = m.get('ObjectType')
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('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('TaskIds') is not None:
self.task_ids_shrink = m.get('TaskIds')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class ListTasksResponseBodyTasks(TeaModel):
def __init__(
self,
gmt_create_time: str = None,
gmt_executed_time: str = None,
gmt_finished_time: str = None,
object_id: str = None,
object_type: str = None,
project_id: str = None,
project_name: str = None,
status: str = None,
task_id: str = None,
type: str = None,
):
self.gmt_create_time = gmt_create_time
self.gmt_executed_time = gmt_executed_time
self.gmt_finished_time = gmt_finished_time
self.object_id = object_id
self.object_type = object_type
self.project_id = project_id
self.project_name = project_name
self.status = status
self.task_id = task_id
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.gmt_create_time is not None:
result['GmtCreateTime'] = self.gmt_create_time
if self.gmt_executed_time is not None:
result['GmtExecutedTime'] = self.gmt_executed_time
if self.gmt_finished_time is not None:
result['GmtFinishedTime'] = self.gmt_finished_time
if self.object_id is not None:
result['ObjectId'] = self.object_id
if self.object_type is not None:
result['ObjectType'] = self.object_type
if self.project_id is not None:
result['ProjectId'] = self.project_id
if self.project_name is not None:
result['ProjectName'] = self.project_name
if self.status is not None:
result['Status'] = self.status
if self.task_id is not None:
result['TaskId'] = self.task_id
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('GmtCreateTime') is not None:
self.gmt_create_time = m.get('GmtCreateTime')
if m.get('GmtExecutedTime') is not None:
self.gmt_executed_time = m.get('GmtExecutedTime')
if m.get('GmtFinishedTime') is not None:
self.gmt_finished_time = m.get('GmtFinishedTime')
if m.get('ObjectId') is not None:
self.object_id = m.get('ObjectId')
if m.get('ObjectType') is not None:
self.object_type = m.get('ObjectType')
if m.get('ProjectId') is not None:
self.project_id = m.get('ProjectId')
if m.get('ProjectName') is not None:
self.project_name = m.get('ProjectName')
if m.get('Status') is not None:
self.status = m.get('Status')
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class ListTasksResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
tasks: List[ListTasksResponseBodyTasks] = None,
total_count: int = None,
):
self.request_id = request_id
self.tasks = tasks
self.total_count = total_count
def validate(self):
if self.tasks:
for k in self.tasks:
if k:
k.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
result['Tasks'] = []
if self.tasks is not None:
for k in self.tasks:
result['Tasks'].append(k.to_map() if k else None)
if self.total_count is not None:
result['TotalCount'] = self.total_count
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
self.tasks = []
if m.get('Tasks') is not None:
for k in m.get('Tasks'):
temp_model = ListTasksResponseBodyTasks()
self.tasks.append(temp_model.from_map(k))
if m.get('TotalCount') is not None:
self.total_count = m.get('TotalCount')
return self
class ListTasksResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListTasksResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = ListTasksResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class PublishFeatureViewTableRequest(TeaModel):
def __init__(
self,
config: str = None,
event_time: str = None,
mode: str = None,
offline_to_online: bool = None,
partitions: Dict[str, dict] = None,
):
self.config = config
self.event_time = event_time
# This parameter is required.
self.mode = mode
# This parameter is required.
self.offline_to_online = offline_to_online
self.partitions = partitions
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.config is not None:
result['Config'] = self.config
if self.event_time is not None:
result['EventTime'] = self.event_time
if self.mode is not None:
result['Mode'] = self.mode
if self.offline_to_online is not None:
result['OfflineToOnline'] = self.offline_to_online
if self.partitions is not None:
result['Partitions'] = self.partitions
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Config') is not None:
self.config = m.get('Config')
if m.get('EventTime') is not None:
self.event_time = m.get('EventTime')
if m.get('Mode') is not None:
self.mode = m.get('Mode')
if m.get('OfflineToOnline') is not None:
self.offline_to_online = m.get('OfflineToOnline')
if m.get('Partitions') is not None:
self.partitions = m.get('Partitions')
return self
class PublishFeatureViewTableResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
task_id: str = None,
):
self.request_id = request_id
self.task_id = task_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.task_id is not None:
result['TaskId'] = self.task_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('TaskId') is not None:
self.task_id = m.get('TaskId')
return self
class PublishFeatureViewTableResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: PublishFeatureViewTableResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = PublishFeatureViewTableResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateDatasourceRequest(TeaModel):
def __init__(
self,
config: str = None,
name: str = None,
uri: str = None,
):
self.config = config
# This parameter is required.
self.name = name
# This parameter is required.
self.uri = uri
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.config is not None:
result['Config'] = self.config
if self.name is not None:
result['Name'] = self.name
if self.uri is not None:
result['Uri'] = self.uri
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Config') is not None:
self.config = m.get('Config')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Uri') is not None:
self.uri = m.get('Uri')
return self
class UpdateDatasourceResponseBody(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 UpdateDatasourceResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: UpdateDatasourceResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = UpdateDatasourceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateLabelTableRequestFields(TeaModel):
def __init__(
self,
attributes: List[str] = None,
name: str = None,
type: str = None,
):
# This parameter is required.
self.attributes = attributes
# This parameter is required.
self.name = name
# This parameter is required.
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.attributes is not None:
result['Attributes'] = self.attributes
if self.name is not None:
result['Name'] = self.name
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Attributes') is not None:
self.attributes = m.get('Attributes')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class UpdateLabelTableRequest(TeaModel):
def __init__(
self,
datasource_id: str = None,
fields: List[UpdateLabelTableRequestFields] = None,
name: str = None,
):
self.datasource_id = datasource_id
# This parameter is required.
self.fields = fields
self.name = name
def validate(self):
if self.fields:
for k in self.fields:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.datasource_id is not None:
result['DatasourceId'] = self.datasource_id
result['Fields'] = []
if self.fields is not None:
for k in self.fields:
result['Fields'].append(k.to_map() if k else None)
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('DatasourceId') is not None:
self.datasource_id = m.get('DatasourceId')
self.fields = []
if m.get('Fields') is not None:
for k in m.get('Fields'):
temp_model = UpdateLabelTableRequestFields()
self.fields.append(temp_model.from_map(k))
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class UpdateLabelTableResponseBody(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 UpdateLabelTableResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: UpdateLabelTableResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = UpdateLabelTableResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateModelFeatureRequestFeatures(TeaModel):
def __init__(
self,
alias_name: str = None,
feature_view_id: str = None,
name: str = None,
type: str = None,
):
self.alias_name = alias_name
# This parameter is required.
self.feature_view_id = feature_view_id
# This parameter is required.
self.name = name
# This parameter is required.
self.type = type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.alias_name is not None:
result['AliasName'] = self.alias_name
if self.feature_view_id is not None:
result['FeatureViewId'] = self.feature_view_id
if self.name is not None:
result['Name'] = self.name
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('AliasName') is not None:
self.alias_name = m.get('AliasName')
if m.get('FeatureViewId') is not None:
self.feature_view_id = m.get('FeatureViewId')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class UpdateModelFeatureRequest(TeaModel):
def __init__(
self,
features: List[UpdateModelFeatureRequestFeatures] = None,
label_priority_level: int = None,
label_table_id: str = None,
sequence_feature_view_ids: List[str] = None,
):
self.features = features
self.label_priority_level = label_priority_level
self.label_table_id = label_table_id
self.sequence_feature_view_ids = sequence_feature_view_ids
def validate(self):
if self.features:
for k in self.features:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['Features'] = []
if self.features is not None:
for k in self.features:
result['Features'].append(k.to_map() if k else None)
if self.label_priority_level is not None:
result['LabelPriorityLevel'] = self.label_priority_level
if self.label_table_id is not None:
result['LabelTableId'] = self.label_table_id
if self.sequence_feature_view_ids is not None:
result['SequenceFeatureViewIds'] = self.sequence_feature_view_ids
return result
def from_map(self, m: dict = None):
m = m or dict()
self.features = []
if m.get('Features') is not None:
for k in m.get('Features'):
temp_model = UpdateModelFeatureRequestFeatures()
self.features.append(temp_model.from_map(k))
if m.get('LabelPriorityLevel') is not None:
self.label_priority_level = m.get('LabelPriorityLevel')
if m.get('LabelTableId') is not None:
self.label_table_id = m.get('LabelTableId')
if m.get('SequenceFeatureViewIds') is not None:
self.sequence_feature_view_ids = m.get('SequenceFeatureViewIds')
return self
class UpdateModelFeatureResponseBody(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 UpdateModelFeatureResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: UpdateModelFeatureResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = UpdateModelFeatureResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateModelFeatureFGFeatureRequestLookupFeatures(TeaModel):
def __init__(
self,
default_value: str = None,
feature_name: str = None,
key_feature_domain: str = None,
key_feature_name: str = None,
map_feature_domain: str = None,
map_feature_name: str = None,
value_type: str = None,
):
# This parameter is required.
self.default_value = default_value
# This parameter is required.
self.feature_name = feature_name
# This parameter is required.
self.key_feature_domain = key_feature_domain
# This parameter is required.
self.key_feature_name = key_feature_name
# This parameter is required.
self.map_feature_domain = map_feature_domain
# This parameter is required.
self.map_feature_name = map_feature_name
# This parameter is required.
self.value_type = value_type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.default_value is not None:
result['DefaultValue'] = self.default_value
if self.feature_name is not None:
result['FeatureName'] = self.feature_name
if self.key_feature_domain is not None:
result['KeyFeatureDomain'] = self.key_feature_domain
if self.key_feature_name is not None:
result['KeyFeatureName'] = self.key_feature_name
if self.map_feature_domain is not None:
result['MapFeatureDomain'] = self.map_feature_domain
if self.map_feature_name is not None:
result['MapFeatureName'] = self.map_feature_name
if self.value_type is not None:
result['ValueType'] = self.value_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DefaultValue') is not None:
self.default_value = m.get('DefaultValue')
if m.get('FeatureName') is not None:
self.feature_name = m.get('FeatureName')
if m.get('KeyFeatureDomain') is not None:
self.key_feature_domain = m.get('KeyFeatureDomain')
if m.get('KeyFeatureName') is not None:
self.key_feature_name = m.get('KeyFeatureName')
if m.get('MapFeatureDomain') is not None:
self.map_feature_domain = m.get('MapFeatureDomain')
if m.get('MapFeatureName') is not None:
self.map_feature_name = m.get('MapFeatureName')
if m.get('ValueType') is not None:
self.value_type = m.get('ValueType')
return self
class UpdateModelFeatureFGFeatureRequestRawFeatures(TeaModel):
def __init__(
self,
default_value: str = None,
feature_domain: str = None,
feature_name: str = None,
feature_type: str = None,
input_feature_name: str = None,
value_type: str = None,
):
# This parameter is required.
self.default_value = default_value
# This parameter is required.
self.feature_domain = feature_domain
# This parameter is required.
self.feature_name = feature_name
# This parameter is required.
self.feature_type = feature_type
# This parameter is required.
self.input_feature_name = input_feature_name
# This parameter is required.
self.value_type = value_type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.default_value is not None:
result['DefaultValue'] = self.default_value
if self.feature_domain is not None:
result['FeatureDomain'] = self.feature_domain
if self.feature_name is not None:
result['FeatureName'] = self.feature_name
if self.feature_type is not None:
result['FeatureType'] = self.feature_type
if self.input_feature_name is not None:
result['InputFeatureName'] = self.input_feature_name
if self.value_type is not None:
result['ValueType'] = self.value_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DefaultValue') is not None:
self.default_value = m.get('DefaultValue')
if m.get('FeatureDomain') is not None:
self.feature_domain = m.get('FeatureDomain')
if m.get('FeatureName') is not None:
self.feature_name = m.get('FeatureName')
if m.get('FeatureType') is not None:
self.feature_type = m.get('FeatureType')
if m.get('InputFeatureName') is not None:
self.input_feature_name = m.get('InputFeatureName')
if m.get('ValueType') is not None:
self.value_type = m.get('ValueType')
return self
class UpdateModelFeatureFGFeatureRequestSequenceFeaturesSubFeatures(TeaModel):
def __init__(
self,
default_value: str = None,
feature_domain: str = None,
feature_name: str = None,
feature_type: str = None,
input_feature_name: str = None,
value_type: str = None,
):
# This parameter is required.
self.default_value = default_value
# This parameter is required.
self.feature_domain = feature_domain
# This parameter is required.
self.feature_name = feature_name
# This parameter is required.
self.feature_type = feature_type
# This parameter is required.
self.input_feature_name = input_feature_name
# This parameter is required.
self.value_type = value_type
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.default_value is not None:
result['DefaultValue'] = self.default_value
if self.feature_domain is not None:
result['FeatureDomain'] = self.feature_domain
if self.feature_name is not None:
result['FeatureName'] = self.feature_name
if self.feature_type is not None:
result['FeatureType'] = self.feature_type
if self.input_feature_name is not None:
result['InputFeatureName'] = self.input_feature_name
if self.value_type is not None:
result['ValueType'] = self.value_type
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('DefaultValue') is not None:
self.default_value = m.get('DefaultValue')
if m.get('FeatureDomain') is not None:
self.feature_domain = m.get('FeatureDomain')
if m.get('FeatureName') is not None:
self.feature_name = m.get('FeatureName')
if m.get('FeatureType') is not None:
self.feature_type = m.get('FeatureType')
if m.get('InputFeatureName') is not None:
self.input_feature_name = m.get('InputFeatureName')
if m.get('ValueType') is not None:
self.value_type = m.get('ValueType')
return self
class UpdateModelFeatureFGFeatureRequestSequenceFeatures(TeaModel):
def __init__(
self,
attribute_delim: str = None,
feature_name: str = None,
sequence_delim: str = None,
sequence_length: int = None,
sub_features: List[UpdateModelFeatureFGFeatureRequestSequenceFeaturesSubFeatures] = None,
):
# This parameter is required.
self.attribute_delim = attribute_delim
# This parameter is required.
self.feature_name = feature_name
# This parameter is required.
self.sequence_delim = sequence_delim
# This parameter is required.
self.sequence_length = sequence_length
self.sub_features = sub_features
def validate(self):
if self.sub_features:
for k in self.sub_features:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.attribute_delim is not None:
result['AttributeDelim'] = self.attribute_delim
if self.feature_name is not None:
result['FeatureName'] = self.feature_name
if self.sequence_delim is not None:
result['SequenceDelim'] = self.sequence_delim
if self.sequence_length is not None:
result['SequenceLength'] = self.sequence_length
result['SubFeatures'] = []
if self.sub_features is not None:
for k in self.sub_features:
result['SubFeatures'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('AttributeDelim') is not None:
self.attribute_delim = m.get('AttributeDelim')
if m.get('FeatureName') is not None:
self.feature_name = m.get('FeatureName')
if m.get('SequenceDelim') is not None:
self.sequence_delim = m.get('SequenceDelim')
if m.get('SequenceLength') is not None:
self.sequence_length = m.get('SequenceLength')
self.sub_features = []
if m.get('SubFeatures') is not None:
for k in m.get('SubFeatures'):
temp_model = UpdateModelFeatureFGFeatureRequestSequenceFeaturesSubFeatures()
self.sub_features.append(temp_model.from_map(k))
return self
class UpdateModelFeatureFGFeatureRequest(TeaModel):
def __init__(
self,
lookup_features: List[UpdateModelFeatureFGFeatureRequestLookupFeatures] = None,
raw_features: List[UpdateModelFeatureFGFeatureRequestRawFeatures] = None,
reserves: List[str] = None,
sequence_features: List[UpdateModelFeatureFGFeatureRequestSequenceFeatures] = None,
):
self.lookup_features = lookup_features
self.raw_features = raw_features
self.reserves = reserves
self.sequence_features = sequence_features
def validate(self):
if self.lookup_features:
for k in self.lookup_features:
if k:
k.validate()
if self.raw_features:
for k in self.raw_features:
if k:
k.validate()
if self.sequence_features:
for k in self.sequence_features:
if k:
k.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
result['LookupFeatures'] = []
if self.lookup_features is not None:
for k in self.lookup_features:
result['LookupFeatures'].append(k.to_map() if k else None)
result['RawFeatures'] = []
if self.raw_features is not None:
for k in self.raw_features:
result['RawFeatures'].append(k.to_map() if k else None)
if self.reserves is not None:
result['Reserves'] = self.reserves
result['SequenceFeatures'] = []
if self.sequence_features is not None:
for k in self.sequence_features:
result['SequenceFeatures'].append(k.to_map() if k else None)
return result
def from_map(self, m: dict = None):
m = m or dict()
self.lookup_features = []
if m.get('LookupFeatures') is not None:
for k in m.get('LookupFeatures'):
temp_model = UpdateModelFeatureFGFeatureRequestLookupFeatures()
self.lookup_features.append(temp_model.from_map(k))
self.raw_features = []
if m.get('RawFeatures') is not None:
for k in m.get('RawFeatures'):
temp_model = UpdateModelFeatureFGFeatureRequestRawFeatures()
self.raw_features.append(temp_model.from_map(k))
if m.get('Reserves') is not None:
self.reserves = m.get('Reserves')
self.sequence_features = []
if m.get('SequenceFeatures') is not None:
for k in m.get('SequenceFeatures'):
temp_model = UpdateModelFeatureFGFeatureRequestSequenceFeatures()
self.sequence_features.append(temp_model.from_map(k))
return self
class UpdateModelFeatureFGFeatureResponseBody(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 UpdateModelFeatureFGFeatureResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: UpdateModelFeatureFGFeatureResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = UpdateModelFeatureFGFeatureResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UpdateProjectRequest(TeaModel):
def __init__(
self,
description: str = None,
name: str = None,
):
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.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('Description') is not None:
self.description = m.get('Description')
if m.get('Name') is not None:
self.name = m.get('Name')
return self
class UpdateProjectResponseBody(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 UpdateProjectResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: UpdateProjectResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = UpdateProjectResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class WriteFeatureViewTableRequestUrlDatasource(TeaModel):
def __init__(
self,
delimiter: str = None,
omit_header: bool = None,
path: str = None,
):
self.delimiter = delimiter
self.omit_header = omit_header
self.path = path
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.delimiter is not None:
result['Delimiter'] = self.delimiter
if self.omit_header is not None:
result['OmitHeader'] = self.omit_header
if self.path is not None:
result['Path'] = self.path
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Delimiter') is not None:
self.delimiter = m.get('Delimiter')
if m.get('OmitHeader') is not None:
self.omit_header = m.get('OmitHeader')
if m.get('Path') is not None:
self.path = m.get('Path')
return self
class WriteFeatureViewTableRequest(TeaModel):
def __init__(
self,
mode: str = None,
partitions: Dict[str, dict] = None,
url_datasource: WriteFeatureViewTableRequestUrlDatasource = None,
):
# This parameter is required.
self.mode = mode
self.partitions = partitions
self.url_datasource = url_datasource
def validate(self):
if self.url_datasource:
self.url_datasource.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.mode is not None:
result['Mode'] = self.mode
if self.partitions is not None:
result['Partitions'] = self.partitions
if self.url_datasource is not None:
result['UrlDatasource'] = self.url_datasource.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('Mode') is not None:
self.mode = m.get('Mode')
if m.get('Partitions') is not None:
self.partitions = m.get('Partitions')
if m.get('UrlDatasource') is not None:
temp_model = WriteFeatureViewTableRequestUrlDatasource()
self.url_datasource = temp_model.from_map(m['UrlDatasource'])
return self
class WriteFeatureViewTableResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
task_id: str = None,
):
self.request_id = request_id
self.task_id = task_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.task_id is not None:
result['TaskId'] = self.task_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('TaskId') is not None:
self.task_id = m.get('TaskId')
return self
class WriteFeatureViewTableResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: WriteFeatureViewTableResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
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 = WriteFeatureViewTableResponseBody()
self.body = temp_model.from_map(m['body'])
return self