def put_execution_type(self, execution_type: metadata_store_pb2.ExecutionType, can_add_fields: bool = False, can_delete_fields: bool = False, all_fields_match: bool = True) -> int: """Inserts or updates an execution type. Similar to put artifact/context type, if no execution type exists in the database with the given name, it creates a new execution type (and a database). If an execution type with the same name already exists (let's call it old_execution_type), then the impact depends upon the other options. If execution_type == old_execution_type, then nothing happens. Otherwise, if there is a field where execution_type and old_execution_type have different types, then it fails. Otherwise, if can_add_fields is False and execution_type has a field old_execution_type is missing, then it fails. Otherwise, if all_fields_match is True and old_execution_type has a field execution_type is missing, then it fails. Otherwise, if can_delete_fields is True and old_execution_type has a field execution_type is missing, then it deletes that field. Otherwise, it does nothing. Args: execution_type: the type to add or update. can_add_fields: if true, you can add fields with this operation. If false, then if there are more fields in execution_type than in the database, the call fails. can_delete_fields: if true, you can remove fields with this operation. If false, then if there are more fields. all_fields_match: if true, all fields must match, and the method fails if they are not the same. Returns: the type id of the type. Raises: ValueError: If a constraint is violated. """ request = metadata_store_service_pb2.PutExecutionTypeRequest() request.can_add_fields = can_add_fields request.can_delete_fields = can_delete_fields request.all_fields_match = all_fields_match request.execution_type.CopyFrom(execution_type) response = metadata_store_service_pb2.PutExecutionTypeResponse() self._call('PutExecutionType', request, response) return response.type_id
def put_execution_type(self, execution_type: metadata_store_pb2.ExecutionType, can_add_fields: bool = False, can_omit_fields: bool = False) -> int: """Inserts or updates an execution type. If no type exists in the database with the given name, it creates a new type and returns the type_id. If the request type with the same name already exists (let's call it stored_type), the method enforces the stored_type can be updated only when the request type is backward compatible for the already stored instances. Backwards compatibility is violated iff: a) there is a property where the request type and stored_type have different value type (e.g., int vs. string) b) `can_add_fields = false` and the request type has a new property that is not stored. c) `can_omit_fields = false` and stored_type has an existing property that is not provided in the request type. Args: execution_type: the request type to be inserted or updated. can_add_fields: when true, new properties can be added; when false, returns ALREADY_EXISTS if the request type has properties that are not in stored_type. can_omit_fields: when true, stored properties can be omitted in the request type; when false, returns ALREADY_EXISTS if the stored_type has properties not in the request type. Returns: the type_id of the response. Raises: AlreadyExistsError: If the type is not backward compatible. InvalidArgumentError: If the request type has no name, or any property value type is unknown. """ request = metadata_store_service_pb2.PutExecutionTypeRequest( can_add_fields=can_add_fields, can_omit_fields=can_omit_fields, execution_type=execution_type) response = metadata_store_service_pb2.PutExecutionTypeResponse() self._call('PutExecutionType', request, response) return response.type_id