def json_to_seldon_model_metadata( metadata_json: Dict, ) -> prediction_pb2.SeldonModelMetadata: """ Parses JSON input to SeldonModelMetadata proto Parameters ---------- metadata_json JSON input Returns ------- SeldonModelMetadata """ if metadata_json is None: metadata_json = {} metadata_proto = prediction_pb2.SeldonModelMetadata() try: json_format.ParseDict(metadata_json, metadata_proto, ignore_unknown_fields=True) return metadata_proto except json_format.ParseError as pbExc: raise SeldonMicroserviceException(f"Invalid metadata: {pbExc}")
def parse_from_mongo(mongo_dict, proto): """Parse a Protobuf from a dict coming from MongoDB. Args: mongo_dict: a dict coming from MongoDB, or None. This dict will be modified by the function: it removes all the keys prefixed by "_" and convert datetime objects to iso strings. proto: a protobuffer to merge data into. Returns: a boolean indicating whether the input had actual data. """ if mongo_dict is None: return False to_delete = [k for k in mongo_dict if k.startswith('_')] for key in to_delete: del mongo_dict[key] _convert_datetimes_to_string(mongo_dict) try: json_format.ParseDict(mongo_dict, proto, ignore_unknown_fields=True) except json_format.ParseError as error: logging.warning( 'Error %s while parsing a JSON dict for proto type %s:\n%s', error, proto.__class__.__name__, mongo_dict) return False return True
def parse_from_mongo(mongo_dict: Optional[dict[str, Any]], proto: message.Message, id_field: Optional[str] = None) -> bool: """Parse a Protobuf from a dict coming from MongoDB. Args: mongo_dict: a dict coming from MongoDB, or None. This dict will be modified by the function: it removes all the keys prefixed by "_" and convert datetime objects to iso strings. proto: a protobuffer to merge data into. id_field (optional): a field in the proto where we wish to put the mongo ID. It must be a string field. Returns: a boolean indicating whether the input had actual data. """ if mongo_dict is None: return False message_id = str(mongo_dict.pop('_id', '')) to_delete = [k for k in mongo_dict if k.startswith('_')] for key in to_delete: del mongo_dict[key] _convert_datetimes_to_string(mongo_dict) try: json_format.ParseDict(mongo_dict, proto, ignore_unknown_fields=not _IS_TEST_ENV) except json_format.ParseError as error: if _IS_TEST_ENV: raise error logging.warning( 'Error %s while parsing a JSON dict for proto type %s:\n%s', error, proto.__class__.__name__, mongo_dict) return False if message_id and id_field: setattr(proto, id_field, message_id) return True
def create_data_labeling_job_sample( project: str, display_name: str, dataset_name: str, instruction_uri: str, inputs_schema_uri: str, annotation_spec: str, location: str = "us-central1", api_endpoint: str = "us-central1-aiplatform.googleapis.com", ): # The AI Platform services require regional API endpoints. client_options = {"api_endpoint": api_endpoint} # Initialize client that will be used to create and send requests. # This client only needs to be created once, and can be reused for multiple requests. client = aiplatform.gapic.JobServiceClient(client_options=client_options) inputs_dict = {"annotation_specs": [annotation_spec]} inputs = json_format.ParseDict(inputs_dict, Value()) data_labeling_job = { "display_name": display_name, # Full resource name: projects/{project_id}/locations/{location}/datasets/{dataset_id} "datasets": [dataset_name], # labeler_count must be 1, 3, or 5 "labeler_count": 1, "instruction_uri": instruction_uri, "inputs_schema_uri": inputs_schema_uri, "inputs": inputs, "annotation_labels": { "aiplatform.googleapis.com/annotation_set_name": "my_test_saved_query" }, } parent = f"projects/{project}/locations/{location}" response = client.create_data_labeling_job( parent=parent, data_labeling_job=data_labeling_job ) print("response:", response)
def to_proto(self): d = { 'sync_interval': self.train_options.sync_interval, 'do_monitoring': self.train_options.do_monitoring, 'replace_model': self.train_options.replace_model, 'training_data_uri': self.training_data_uri, 'training_output_uri': self.training_output_uri, 'model_uri': self.model_uri, 'debug': self.debug, 'kc_config': self.kc_config } conf = json_format.ParseDict( d, BackendConfigMsg.KerasClassificationConfig()) msg = BackendConfigMsg(backend_type=rv.KERAS_CLASSIFICATION, keras_classification_config=conf) if self.pretrained_model_uri: msg.MergeFrom( BackendConfigMsg( pretrained_model_uri=self.pretrained_model_uri)) return msg
def __init__( self, job_file='test_job.yaml', client=None, config=None, pool=None, job_config=None, options=[], ): self.config = config or IntegrationTestConfig() self.client = client or Client() self.pool = pool or Pool(self.config, self.client) self.job_id = None if job_config is None: job_config_dump = load_test_config(job_file) job_config = job.JobConfig() json_format.ParseDict(job_config_dump, job_config) # apply options for o in options: o(job_config) self.job_config = job_config
def test_auto_rollback_reduce_instances(stateless_job): stateless_job.create() stateless_job.wait_for_state(goal_state="RUNNING") job_spec_dump = load_test_config( UPDATE_STATELESS_JOB_BAD_HEALTH_CHECK_SPEC) updated_job_spec = JobSpec() json_format.ParseDict(job_spec_dump, updated_job_spec) # increase the instance count updated_job_spec.instance_count = stateless_job.job_spec.instance_count + 3 update = StatelessUpdate( stateless_job, updated_job_spec=updated_job_spec, roll_back_on_failure=True, max_instance_attempts=1, max_failure_instances=1, batch_size=1, ) update.create() update.wait_for_state(goal_state="ROLLED_BACK") assert (len( stateless_job.query_pods()) == stateless_job.job_spec.instance_count)
def update(self, new_job_file): """ updates a job :param new_job_file: The job config file used for updating """ # wait for job manager leader self.wait_for_jobmgr_available() job_config_dump = load_test_config(new_job_file) new_job_config = job.JobConfig() json_format.ParseDict(job_config_dump, new_job_config) request = job.UpdateRequest( id=peloton.JobID(value=self.job_id), config=new_job_config ) resp = self.client.job_svc.Update( request, metadata=self.client.jobmgr_metadata, timeout=self.config.rpc_timeout_sec, ) assert not resp.HasField("error") # update the config self.job_config = new_job_config log.info("updated job %s", self.job_id)
def TransformInput(self, request, context): if hasattr(self.user_model, "transform_input_grpc"): return self.user_model.transform_input_grpc(request) else: features = get_data_from_proto(request) datadef = request.data data_type = request.WhichOneof("data_oneof") transformed = transform_input(self.user_model, features, datadef.names) # Construct meta data meta = prediction_pb2.Meta() metaJson = {} tags = get_custom_tags(self.user_model) if tags: metaJson["tags"] = tags metrics = get_custom_metrics(self.user_model) if metrics: metaJson["metrics"] = metrics json_format.ParseDict(metaJson, meta) if isinstance(transformed, np.ndarray) or data_type == "data": transformed = np.array(transformed) feature_names = get_feature_names(self.user_model, datadef.names) if data_type == "data": default_data_type = request.data.WhichOneof("data_oneof") else: default_data_type = "tensor" data = array_to_grpc_datadef(transformed, feature_names, default_data_type) return prediction_pb2.SeldonMessage(data=data, meta=meta) else: return prediction_pb2.SeldonMessage(binData=transformed, meta=meta)
def test__create_update_add_instances_with_bad_config(stateless_job): stateless_job.create() stateless_job.wait_for_state(goal_state="RUNNING") job_spec_dump = load_test_config(UPDATE_STATELESS_JOB_BAD_SPEC) updated_job_spec = JobSpec() json_format.ParseDict(job_spec_dump, updated_job_spec) updated_job_spec.instance_count = stateless_job.job_spec.instance_count + 3 update = StatelessUpdate( stateless_job, batch_size=1, updated_job_spec=updated_job_spec, max_failure_instances=1, max_instance_attempts=1, ) update.create() update.wait_for_state(goal_state="FAILED", failed_state="SUCCEEDED") # only one instance should be added assert (len( stateless_job.query_pods()) == stateless_job.job_spec.instance_count + 1)
def post(self): """Add dependent concept to database.""" request, error_message = flask_request_response.message_request( _api_intput_pb2.AddDependentConcept, ADD_DEPENDENT_CONCEPT_API, POST_REQUEST) if error_message is not None: return flask_request_response.error_response( [error_message['err_message']], ADD_DEPENDENT_CONCEPT_API, POST_REQUEST) try: dependent_concept_response = add_dependent_concept_query_response( request.concept_key, request.dependent_concept_name, request.dependent_concept_key, request.created_by) response = _api_output_pb2.AddDependentConcept() dependent_concept_result = _json_format.ParseDict( dependent_concept_response, response) return flask_request_response.message_response( dependent_concept_result, ADD_DEPENDENT_CONCEPT_API, POST_REQUEST, 200) except Exception as err: return flask_request_response.error_response( [str(err)], ADD_DEPENDENT_CONCEPT_API, POST_REQUEST)
def with_template(self, template): """Use a template as the base for configuring Keras Classification. Args: template: dict, string or uri """ template_json = None if type(template) is dict: msg = json_format.ParseDict(template, PipelineConfig()) template_json = json_format.MessageToDict(msg) else: # Try parsing the string as a message, on fail assume it's a URI msg = None try: msg = json_format.Parse(template, PipelineConfig()) except json_format.ParseError: msg = json_format.Parse(file_to_str(template), PipelineConfig()) template_json = json_format.MessageToDict(msg) b = deepcopy(self) b.config['kc_config'] = template_json return b
def test_proto_gets_meta(): user_object = UserObject(ret_meta=True) app = SeldonModelGRPC(user_object) arr = np.array([1, 2]) datadef = prediction_pb2.DefaultData( tensor=prediction_pb2.Tensor( shape=(2, 1), values=arr ) ) meta = prediction_pb2.Meta() metaJson = {"puid":"abc"} json_format.ParseDict(metaJson, meta) request = prediction_pb2.SeldonMessage(data=datadef, meta=meta) resp = app.Predict(request, None) jStr = json_format.MessageToJson(resp) j = json.loads(jStr) print(j) assert j["meta"]["tags"] == {"inc_meta":{"puid":"abc"}} # add default type j["meta"]["metrics"][0]["type"] = "COUNTER" assert j["meta"]["metrics"] == user_object.metrics() assert j["data"]["tensor"]["shape"] == [2, 1] assert j["data"]["tensor"]["values"] == [1, 2]
def to_entry(self): if self.is_raw_entry(): return RawEntry( entryname=self.entryname, type_url='', raw_bytes=self.msg_dict['protobag_raw_entry_bytes'], serdes=self.serdes) else: if self.descriptor_data: # Maybe use this data to facilitate messsage parsing below self.serdes.register_descriptor_data( self.type_url, self.descriptor_data) msg_cls = self.serdes.get_msg_cls_for_type(self.type_url) msg = msg_cls() json_format.ParseDict(self.msg_dict, msg) if self.is_stamped_entry(): return StampedEntry( entryname=self.entryname, type_url=self.type_url, msg=msg, topic=self.topic, timestamp=self.timestamp, serdes=self.serdes, descriptor_data=self.descriptor_data) else: return MessageEntry( entryname=self.entryname, type_url=self.type_url, msg=msg, serdes=self.serdes, descriptor_data=self.descriptor_data)
def test_model_tftensor_ok(): user_object = UserObject() seldon_metrics = SeldonMetrics() app = get_rest_microservice(user_object, seldon_metrics) client = app.test_client() arr = np.array([1, 2]) datadef = prediction_pb2.DefaultData(tftensor=tf.make_tensor_proto(arr)) request = prediction_pb2.SeldonMessage(data=datadef) jStr = json_format.MessageToJson(request) rv = client.get("/predict?json=" + jStr) j = json.loads(rv.data) logging.info(j) assert rv.status_code == 200 assert j["meta"]["tags"] == {"mytag": 1} assert j["meta"]["metrics"][0]["key"] == user_object.metrics()[0]["key"] assert j["meta"]["metrics"][0]["value"] == user_object.metrics( )[0]["value"] assert "tftensor" in j["data"] tfp = TensorProto() json_format.ParseDict(j["data"].get("tftensor"), tfp, ignore_unknown_fields=False) arr2 = tf.make_ndarray(tfp) assert np.array_equal(arr, arr2)
def convert_record_to_proto(self, airtable_record: airtable.Record[Mapping[str, Any]]) \ -> Tuple[message.Message, str]: """Convert an airtable record to an actual proto message. Also runs all the necessary checks on it. """ fields = self.convert_record(airtable_record) proto = self.proto_type() _id = fields.pop('_id', None) try: json_format.ParseDict(fields, proto) except json_format.ParseError as error: raise ValueError( f'Error while parsing:\n{json.dumps(fields, indent=2)}' ) from error if _has_any_check_error(proto, _id, self.checkers, _BEFORE_TRANSLATION_CHECKERS, locale='fr'): # Errors messages are already logged in the function. raise ValueError() return proto, _id
def testParseDict(self): expected = 12345 js_dict = {'int32Value': expected} message = json_format_proto3_pb2.TestMessage() json_format.ParseDict(js_dict, message) self.assertEqual(expected, message.int32_value)
_TEST_MODEL_TYPE_MOBILE = "MOBILE_TF_LOW_LATENCY_1" _TEST_PREDICTION_TYPE_ICN = "classification" _TEST_PREDICTION_TYPE_IOD = "object_detection" _TEST_DATASET_NAME = "test-dataset-name" _TEST_MODEL_DISPLAY_NAME = "model-display-name" _TEST_MODEL_ID = "98777645321" _TEST_LABELS = {"key": "value"} _TEST_MODEL_LABELS = {"model_key": "model_value"} _TEST_TRAINING_TASK_INPUTS = json_format.ParseDict( { "modelType": "CLOUD", "budgetMilliNodeHours": _TEST_TRAINING_BUDGET_MILLI_NODE_HOURS, "multiLabel": False, "disableEarlyStopping": _TEST_TRAINING_DISABLE_EARLY_STOPPING, }, struct_pb2.Value(), ) _TEST_TRAINING_TASK_INPUTS_WITH_BASE_MODEL = json_format.ParseDict( { "modelType": "CLOUD", "budgetMilliNodeHours": _TEST_TRAINING_BUDGET_MILLI_NODE_HOURS, "multiLabel": False, "disableEarlyStopping": _TEST_TRAINING_DISABLE_EARLY_STOPPING, "baseModelId": _TEST_MODEL_ID, }, struct_pb2.Value(), )
def op_proto(json_dict: Dict) -> v2.program_pb2.Operation: op = v2.program_pb2.Operation() json_format.ParseDict(json_dict, op) return op
def _from_json_dict_(cls, metrics: str, **kwargs) -> 'Calibration': """Magic method for the JSON serialization protocol.""" metric_proto = v2.metrics_pb2.MetricsSnapshot() return cls(json_format.ParseDict(metrics, metric_proto))
def construct_response( user_model: SeldonComponent, is_request: bool, client_request: prediction_pb2.SeldonMessage, client_raw_response: Union[np.ndarray, str, bytes, dict], meta: dict = None, custom_metrics: List[Dict] = None, ) -> prediction_pb2.SeldonMessage: """ Parameters ---------- user_model Client user class is_request Whether this is part of the request flow as opposed to the response flow client_request The request received client_raw_response The raw client response from their model Returns ------- A SeldonMessage proto response """ data_type = client_request.WhichOneof("data_oneof") meta_pb = prediction_pb2.Meta() meta_json: Dict = {} if meta: tags = meta.get("tags", {}) metrics = meta.get("metrics", []) else: tags = {} metrics = [] custom_tags = client_custom_tags(user_model) if custom_tags: tags.update(custom_tags) if custom_metrics: metrics.extend(custom_metrics) if tags: meta_json["tags"] = tags if metrics: meta_json["metrics"] = metrics if client_request.meta: if client_request.meta.puid: meta_json["puid"] = client_request.meta.puid json_format.ParseDict(meta_json, meta_pb) if isinstance(client_raw_response, np.ndarray) or isinstance( client_raw_response, list): client_raw_response = np.array(client_raw_response) if is_request: names = client_feature_names(user_model, client_request.data.names) else: names = client_class_names(user_model, client_raw_response) if ( data_type == "data" ): # If request is using defaultdata then return what was sent if is numeric response else ndarray if np.issubdtype(client_raw_response.dtype, np.number): default_data_type = client_request.data.WhichOneof( "data_oneof") else: default_data_type = "ndarray" else: # If numeric response return as tensor else return as ndarray if np.issubdtype(client_raw_response.dtype, np.number): default_data_type = "tensor" else: default_data_type = "ndarray" data = array_to_grpc_datadef(default_data_type, client_raw_response, names) return prediction_pb2.SeldonMessage(data=data, meta=meta_pb) elif isinstance(client_raw_response, str): return prediction_pb2.SeldonMessage(strData=client_raw_response, meta=meta_pb) elif isinstance(client_raw_response, dict): jsonDataResponse = ParseDict(client_raw_response, prediction_pb2.SeldonMessage().jsonData) return prediction_pb2.SeldonMessage(jsonData=jsonDataResponse, meta=meta_pb) elif isinstance(client_raw_response, (bytes, bytearray)): return prediction_pb2.SeldonMessage(binData=client_raw_response, meta=meta_pb) else: raise SeldonMicroserviceException( "Unknown data type returned as payload:" + client_raw_response)
def _create_serving_spec(payload: Dict[Text, Any]): result = infra_validator_pb2.ServingSpec() json_format.ParseDict(payload, result) return result
}, { "numeric": { "column_name": "PhotoAmt" } }, ] MODEL_ID = os.environ.get("MODEL_ID", "test-model-id") MODEL_ARTIFACT_URI = os.environ.get("MODEL_ARTIFACT_URI", "path_to_folder_with_model_artifacts") MODEL_NAME = f"projects/{PROJECT_ID}/locations/{REGION}/models/{MODEL_ID}" JOB_DISPLAY_NAME = f"temp_create_batch_prediction_job_test_{uuid4()}" BIGQUERY_SOURCE = f"bq://{PROJECT_ID}.test_iowa_liquor_sales_forecasting_us.2021_sales_predict" GCS_DESTINATION_PREFIX = "gs://test-vertex-ai-bucket-us/output" MODEL_PARAMETERS = json_format.ParseDict({}, Value()) ENDPOINT_CONF = { "display_name": f"endpoint_test_{uuid4()}", } DEPLOYED_MODEL = { # format: 'projects/{project}/locations/{location}/models/{model}' 'model': f"projects/{PROJECT_ID}/locations/{REGION}/models/{MODEL_ID}", 'display_name': f"temp_endpoint_test_{uuid4()}", "dedicated_resources": { "machine_spec": { "machine_type": "n1-standard-2", "accelerator_type": aiplatform.gapic.AcceleratorType.NVIDIA_TESLA_K80, "accelerator_count": 1, },
def _create_local_docker_config(payload: Dict[Text, Any]): config = LocalDockerConfig() json_format.ParseDict(payload, config) return config
def __init__(self, document: Optional[DocumentSourceType] = None, field_resolver: Dict[str, str] = None, copy: bool = False, **kwargs): """ :param document: the document to construct from. If ``bytes`` is given then deserialize a :class:`DocumentProto`; ``dict`` is given then parse a :class:`DocumentProto` from it; ``str`` is given, then consider it as a JSON string and parse a :class:`DocumentProto` from it; finally, one can also give `DocumentProto` directly, then depending on the ``copy``, it builds a view or a copy from it. :param copy: when ``document`` is given as a :class:`DocumentProto` object, build a view (i.e. weak reference) from it or a deep copy from it. :param field_resolver: a map from field names defined in ``document`` (JSON, dict) to the field names defined in Protobuf. This is only used when the given ``document`` is a JSON string or a Python dict. :param kwargs: other parameters to be set _after_ the document is constructed .. note:: When ``document`` is a JSON string or Python dictionary object, the constructor will only map the values from known fields defined in Protobuf, all unknown fields are mapped to ``document.tags``. For example, .. highlight:: python .. code-block:: python d = Document({'id': '123', 'hello': 'world', 'tags': {'good': 'bye'}}) assert d.id == '123' # true assert d.tags['hello'] == 'world' # true assert d.tags['good'] == 'bye' # true """ self._pb_body = jina_pb2.DocumentProto() try: if isinstance(document, jina_pb2.DocumentProto): if copy: self._pb_body.CopyFrom(document) else: self._pb_body = document elif isinstance(document, (dict, str)): if isinstance(document, str): document = json.loads(document) if field_resolver: document = { field_resolver.get(k, k): v for k, v in document.items() } user_fields = set(document.keys()) if _document_fields.issuperset(user_fields): json_format.ParseDict(document, self._pb_body) else: _intersect = _document_fields.intersection(user_fields) _remainder = user_fields.difference(_intersect) if _intersect: json_format.ParseDict( {k: document[k] for k in _intersect}, self._pb_body) if _remainder: self._pb_body.tags.update( {k: document[k] for k in _remainder}) elif isinstance(document, bytes): # directly parsing from binary string gives large false-positive # fortunately protobuf throws a warning when the parsing seems go wrong # the context manager below converts this warning into exception and throw it # properly with warnings.catch_warnings(): warnings.filterwarnings('error', 'Unexpected end-group tag', category=RuntimeWarning) try: self._pb_body.ParseFromString(document) except RuntimeWarning as ex: raise BadDocType( f'fail to construct a document from {document}' ) from ex elif isinstance(document, Document): if copy: self._pb_body.CopyFrom(document.proto) else: self._pb_body = document.proto elif document is not None: # note ``None`` is not considered as a bad type raise ValueError(f'{typename(document)} is not recognizable') except Exception as ex: raise BadDocType( f'fail to construct a document from {document}, ' f'if you are trying to set the content ' f'you may use "Document(content=your_content)"') from ex if self._pb_body.id is None or not self._pb_body.id: self.id = random_identity(use_uuid1=True) self.set_attrs(**kwargs) self._mermaid_id = random_identity() #: for mermaid visualize id
def parse_vulnerability_from_dict(data, key_path=None): """Parse vulnerability from dict.""" data = _get_nested_vulnerability(data, key_path) vulnerability = vulnerability_pb2.Vulnerability() json_format.ParseDict(data, vulnerability, ignore_unknown_fields=True) return vulnerability
def dict_to_struct(dict_obj): return json_format.ParseDict(dict_obj, struct_pb2.Struct())
def from_proto_dict(self, proto: Dict) -> ops.GateOperation: """Turns a cirq.api.google.v2.Operation proto into a GateOperation.""" msg = v2.program_pb2.Operation() json_format.ParseDict(proto, msg) return self.from_proto(msg)
def op_proto(json): """Json to proto.""" op = program_pb2.Operation() json_format.ParseDict(json, op) return op
def init(cls, request, context, rest_only=None): time_created = datetime.datetime.now() metadata = None if context is not None: metadata = request.bucket else: metadata, rest_only = cls.__preprocess_rest( json.loads(request.data)) metadata = json_format.ParseDict(metadata, resources_pb2.Bucket()) cls.__validate_bucket_name(metadata.name, context) default_projection = CommonEnums.Projection.NO_ACL if len(metadata.acl) != 0 or len(metadata.default_object_acl) != 0: default_projection = CommonEnums.Projection.FULL is_uniform = metadata.iam_configuration.uniform_bucket_level_access.enabled metadata.iam_configuration.uniform_bucket_level_access.enabled = False if len(metadata.acl) == 0: predefined_acl = utils.acl.extract_predefined_acl( request, False, context) if (predefined_acl == CommonEnums.PredefinedBucketAcl. PREDEFINED_BUCKET_ACL_UNSPECIFIED): predefined_acl = ( CommonEnums.PredefinedBucketAcl.BUCKET_ACL_PROJECT_PRIVATE) elif predefined_acl == "": predefined_acl = "projectPrivate" elif is_uniform: utils.error.invalid( "Predefined ACL with uniform bucket level access enabled", context) cls.__insert_predefined_acl(metadata, predefined_acl, context) if len(metadata.default_object_acl) == 0: predefined_default_object_acl = utils.acl.extract_predefined_default_object_acl( request, context) if (predefined_default_object_acl == CommonEnums. PredefinedObjectAcl.PREDEFINED_OBJECT_ACL_UNSPECIFIED): predefined_default_object_acl = ( CommonEnums.PredefinedObjectAcl.OBJECT_ACL_PROJECT_PRIVATE) elif predefined_default_object_acl == "": predefined_default_object_acl = "projectPrivate" elif is_uniform: utils.error.invalid( "Predefined Default Object ACL with uniform bucket level access enabled", context, ) cls.__insert_predefined_default_object_acl( metadata, predefined_default_object_acl, context) cls.__enrich_acl(metadata) metadata.iam_configuration.uniform_bucket_level_access.enabled = is_uniform metadata.id = metadata.name metadata.project_number = int(utils.acl.PROJECT_NUMBER) metadata.metageneration = 0 metadata.etag = hashlib.md5(metadata.name.encode("utf-8")).hexdigest() metadata.time_created.FromDatetime(time_created) metadata.updated.FromDatetime(time_created) metadata.owner.entity = utils.acl.get_project_entity("owners", context) metadata.owner.entity_id = hashlib.md5( metadata.owner.entity.encode("utf-8")).hexdigest() if rest_only is None: rest_only = {} return ( cls(metadata, {}, cls.__init_iam_policy(metadata, context), rest_only), utils.common.extract_projection(request, default_projection, context), )