def model_version_relation_meta_to_proto(
model_version_relation: ModelVersionRelationMeta
) -> ModelVersionRelationProto:
if model_version_relation is None:
return None
else:
return ModelVersionRelationProto(
version=stringValue(model_version_relation.version),
model_id=int64Value(model_version_relation.model_id),
workflow_execution_id=int64Value(
model_version_relation.workflow_execution_id))
def artifact_meta_to_proto(artifact_meta: ArtifactMeta) -> ArtifactProto:
if artifact_meta is None:
return None
else:
return ArtifactProto(
uuid=artifact_meta.uuid,
name=artifact_meta.name,
properties=artifact_meta.properties,
data_format=stringValue(artifact_meta.data_format),
description=stringValue(artifact_meta.description),
batch_uri=stringValue(artifact_meta.batch_uri),
stream_uri=stringValue(artifact_meta.stream_uri),
create_time=int64Value(artifact_meta.create_time),
update_time=int64Value(artifact_meta.update_time))
def model_version_meta_to_proto(model_version_relation,
model_center_detail) -> ModelVersionProto:
if model_version_relation is not None and model_center_detail is not None:
return ModelVersionProto(
version=stringValue(model_version_relation.version),
model_id=int64Value(model_version_relation.model_id),
workflow_execution_id=int64Value(
model_version_relation.workflow_execution_id),
model_path=stringValue(model_center_detail.model_path),
model_metric=stringValue(model_center_detail.model_metric),
model_flavor=stringValue(model_center_detail.model_flavor),
version_desc=stringValue(model_center_detail.version_desc),
current_stage=model_center_detail.current_stage)
else:
return None
def metric_summary_to_proto(
metric_summary: MetricSummary) -> MetricSummaryProto:
return MetricSummaryProto(
uuid=metric_summary.uuid,
metric_id=int64Value(metric_summary.metric_id),
metric_key=stringValue(metric_summary.metric_key),
metric_value=stringValue(metric_summary.metric_value))
def job_meta_to_proto(job_meta: JobMeta) -> JobProto:
if job_meta is None:
return None
else:
job_state = StateProto.Value(job_meta.job_state)
return JobProto(uuid=job_meta.uuid,
name=job_meta.name,
workflow_execution_id=int64Value(
job_meta.workflow_execution_id),
job_state=job_state,
properties=job_meta.properties,
job_id=stringValue(job_meta.job_id),
start_time=int64Value(job_meta.start_time),
end_time=int64Value(job_meta.end_time),
log_uri=stringValue(job_meta.log_uri),
signature=stringValue(job_meta.signature))
def workflow_execution_meta_to_proto(
execution_meta: WorkflowExecutionMeta) -> WorkflowExecutionProto:
if execution_meta is None:
return None
else:
execution_state = StateProto.Value(execution_meta.execution_state)
return WorkflowExecutionProto(
uuid=execution_meta.uuid,
name=execution_meta.name,
execution_state=execution_state,
project_id=int64Value(execution_meta.project_id),
properties=execution_meta.properties,
start_time=int64Value(execution_meta.start_time),
end_time=int64Value(execution_meta.end_time),
workflow_json=stringValue(execution_meta.workflow_json),
log_uri=stringValue(execution_meta.log_uri),
signature=stringValue(execution_meta.signature))
def model_relation_meta_to_proto(
model_relation_meta: ModelRelationMeta) -> ModelRelationProto:
if model_relation_meta is None:
return None
else:
return ModelRelationProto(uuid=model_relation_meta.uuid,
name=model_relation_meta.name,
project_id=int64Value(
model_relation_meta.project_id))
def model_meta_to_proto(model_relation, model_center_detail) -> ModelProto:
if model_relation is not None and model_center_detail is not None:
return ModelProto(uuid=model_relation.uuid,
name=model_relation.name,
project_id=int64Value(model_relation.project_id),
model_type=model_center_detail.model_type,
model_desc=stringValue(
model_center_detail.model_desc))
else:
return None
def metric_meta_to_proto(metric_meta: MetricMeta) -> MetricMetaProto:
if metric_meta.metric_type == MetricType.DATASET:
metric_type = MetricTypeProto.DATASET
else:
metric_type = MetricTypeProto.MODEL
return MetricMetaProto(
uuid=metric_meta.uuid,
name=stringValue(metric_meta.name),
dataset_id=int64Value(metric_meta.dataset_id),
model_name=stringValue(metric_meta.model_name),
model_version=stringValue(metric_meta.model_version),
job_id=int64Value(metric_meta.job_id),
start_time=int64Value(metric_meta.start_time),
end_time=int64Value(metric_meta.end_time),
metric_type=metric_type,
uri=stringValue(metric_meta.uri),
tags=stringValue(metric_meta.tags),
metric_description=stringValue(metric_meta.metric_description),
properties=metric_meta.properties)
def update_metric_meta(self,
uuid: int,
name: Text = None,
dataset_id: int = None,
model_name: Optional[Text] = None,
model_version: Optional[Text] = None,
job_id: int = None,
start_time: int = None,
end_time: int = None,
metric_type: MetricType = MetricType.DATASET,
uri: Text = None,
tags: Text = None,
metric_description: Text = None,
properties: Properties = None,
) -> Tuple[int, Text, Optional[MetricMeta]]:
pb_metric_type = message_pb2.MetricTypeProto.Value(metric_type.value)
request = metric_service_pb2.MetricMetaRequest(
metric_meta=message_pb2.MetricMetaProto(
uuid=uuid,
name=stringValue(name),
dataset_id=int64Value(dataset_id),
model_name=stringValue(model_name),
model_version=stringValue(model_version),
job_id=int64Value(job_id),
start_time=int64Value(start_time),
end_time=int64Value(end_time),
metric_type=pb_metric_type,
uri=stringValue(uri),
tags=stringValue(tags),
metric_description=stringValue(metric_description),
properties=properties)
)
response = self.metric_stub.updateMetricMeta(request)
if 0 == response.return_code:
metric_meta_proto = response.metric_meta
metric_meta = proto_to_metric_meta(metric_meta_proto)
return response.return_code, response.return_msg, metric_meta
else:
return response.return_code, response.return_msg, None
def example_meta_to_proto(example_mata) -> ExampleProto:
if example_mata is None:
return None
else:
example_support_type = ExampleSupportTypeProto.Value(
example_mata.support_type)
if example_mata.schema is not None:
name_list = example_mata.schema.name_list
type_list = example_mata.schema.type_list
data_type_list = []
if type_list is not None:
for data_type in type_list:
data_type_list.append(DataTypeProto.Value(data_type))
else:
data_type_list = None
else:
name_list = None
data_type_list = None
schema = SchemaProto(name_list=name_list, type_list=data_type_list)
return ExampleProto(
uuid=example_mata.uuid,
name=example_mata.name,
support_type=example_support_type,
properties=example_mata.properties,
data_type=stringValue(example_mata.data_type),
data_format=stringValue(example_mata.data_format),
description=stringValue(example_mata.description),
batch_uri=stringValue(example_mata.batch_uri),
stream_uri=stringValue(example_mata.stream_uri),
create_time=int64Value(example_mata.create_time),
update_time=int64Value(example_mata.update_time),
schema=schema,
catalog_name=stringValue(example_mata.catalog_name),
catalog_type=stringValue(example_mata.catalog_type),
catalog_database=stringValue(example_mata.catalog_database),
catalog_connection_uri=stringValue(
example_mata.catalog_connection_uri),
catalog_version=stringValue(example_mata.catalog_version),
catalog_table=stringValue(example_mata.catalog_table))
def register_metric_summary(self,
metric_id: int,
metric_key: Text,
metric_value: Text
) -> Tuple[int, Text, Optional[MetricSummary]]:
request = metric_service_pb2.MetricSummaryRequest(
metric_summary=message_pb2.MetricSummaryProto(
metric_id=int64Value(metric_id),
metric_key=stringValue(metric_key),
metric_value=stringValue(metric_value))
)
response = self.metric_stub.registerMetricSummary(request)
if 0 == response.return_code:
metric_summary_proto = response.metric_summary
metric_summary = proto_to_metric_summary(metric_summary_proto)
return response.return_code, response.return_msg, metric_summary
else:
return response.return_code, response.return_msg, None
