def test_metadata_format(self):
"""Tests that metadata content must be passed as a serialized
string."""
with six.assertRaisesRegex(
self, TypeError, r"Content type must be bytes."
):
metadata.parse_plugin_metadata(123)
def test_metadata_version(self):
"""Tests that only the latest version of metadata is supported."""
self._create_metadata()
# Change the version.
with patch.object(metadata, 'get_current_version', return_value=100):
# Try to parse metadata from a prior version.
with self.assertRaises(ValueError):
metadata.parse_plugin_metadata(
self.summary_metadata.plugin_data.content)
def test_op(self):
"""Tests merged summary with different types of data."""
name = "my_mesh"
tensor_data = test_utils.get_random_mesh(
100, add_faces=True, add_colors=True
)
config_dict = {"foo": 1}
with tf.compat.v1.Graph().as_default():
tensor_summary = summary.op(
name,
tensor_data.vertices,
faces=tensor_data.faces,
colors=tensor_data.colors,
config_dict=config_dict,
)
with self.test_session() as sess:
proto = self.pb_via_op(tensor_summary)
self.verify_proto(proto, name)
plugin_metadata = metadata.parse_plugin_metadata(
proto.value[0].metadata.plugin_data.content
)
self.assertEqual(
json.dumps(config_dict, sort_keys=True),
plugin_metadata.json_config,
)
def test_default_components(self):
"""Tests that defult components are added when necessary."""
self._create_metadata()
stored_metadata = plugin_data_pb2.MeshPluginData(
version=metadata.get_current_version(), components=0)
parsed_metadata = metadata.parse_plugin_metadata(
stored_metadata.SerializeToString())
self.assertGreater(parsed_metadata.components, 0)
def _instance_tags(self, run, tag):
"""Gets the instance tag names for a user-facing tag."""
index = self._multiplexer.GetAccumulator(run).PluginTagToContent(
metadata.PLUGIN_NAME)
return [
instance_tag for (instance_tag, content) in six.iteritems(index)
if tag == metadata.parse_plugin_metadata(content).name
]
def test_parse_plugin_metadata(self):
"""Tests parsing of saved plugin metadata."""
self._create_metadata()
parsed_metadata = metadata.parse_plugin_metadata(
self.summary_metadata.plugin_data.content)
self.assertEqual(self.name, parsed_metadata.name)
self.assertEqual(plugin_data_pb2.MeshPluginData.ContentType.Value('VERTEX'),
parsed_metadata.content_type)
self.assertEqual(self.shape, parsed_metadata.shape)
self.assertEqual(self.json_config, parsed_metadata.json_config)
def _instance_tag_metadata(self, ctx, experiment, run, instance_tag):
"""Gets the `MeshPluginData` proto for an instance tag."""
results = self._data_provider.list_tensors(
ctx,
experiment_id=experiment,
plugin_name=metadata.PLUGIN_NAME,
run_tag_filter=provider.RunTagFilter(runs=[run],
tags=[instance_tag]),
)
content = results[run][instance_tag].plugin_content
return metadata.parse_plugin_metadata(content)
def _instance_tags(self, ctx, experiment, run, tag):
"""Gets the instance tag names for a user-facing tag."""
index = self._data_provider.list_tensors(
ctx,
experiment_id=experiment,
plugin_name=metadata.PLUGIN_NAME,
run_tag_filter=provider.RunTagFilter(runs=[run]),
)
return [
instance_tag for (instance_tag, ts) in index.get(run, {}).items()
if tag == metadata.parse_plugin_metadata(ts.plugin_content).name
]
def test_pb(self):
"""Tests ProtoBuf interface."""
name = "my_mesh"
tensor_data = test_utils.get_random_mesh(100,
add_faces=True,
add_colors=True)
config_dict = {"foo": 1}
proto = summary.mesh_pb(name,
tensor_data.vertices,
faces=tensor_data.faces,
colors=tensor_data.colors,
config_dict=config_dict)
plugin_metadata = metadata.parse_plugin_metadata(
proto.value[0].metadata.plugin_data.content)
self.assertEqual(json.dumps(config_dict, sort_keys=True),
plugin_metadata.json_config)
def test_pb(self):
"""Tests merged summary protobuf with different types of data."""
name = "my_mesh"
tensor_data = test_utils.get_random_mesh(100,
add_faces=True,
add_colors=True)
config_dict = {"foo": 1}
proto = summary.pb(name,
tensor_data.vertices,
faces=tensor_data.faces,
colors=tensor_data.colors,
config_dict=config_dict)
self.verify_proto(proto, name)
plugin_metadata = metadata.parse_plugin_metadata(
proto.value[0].metadata.plugin_data.content)
self.assertEqual(json.dumps(config_dict, sort_keys=True),
plugin_metadata.json_config)
def prepare_metadata(self):
"""Processes all tags and caches metadata for each."""
if self._tag_to_instance_tags:
return
# This is a dictionary mapping from run to (tag to string content).
# To be clear, the values of the dictionary are dictionaries.
all_runs = self._multiplexer.PluginRunToTagToContent(MeshPlugin.plugin_name)
# tagToContent is itself a dictionary mapping tag name to string
# SummaryMetadata.plugin_data.content. Retrieve the keys of that dictionary
# to obtain a list of tags associated with each run. For each tag, estimate
# the number of samples.
self._tag_to_instance_tags = collections.defaultdict(list)
self._instance_tag_to_metadata = dict()
for run, tag_to_content in six.iteritems(all_runs):
for tag, content in six.iteritems(tag_to_content):
meta = metadata.parse_plugin_metadata(content)
self._instance_tag_to_metadata[(run, tag)] = meta
# Remember instance_name (instance_tag) for future reference.
self._tag_to_instance_tags[(run, meta.name)].append(tag)
self._instance_tag_to_tag[(run, tag)] = meta.name
def _serve_tags(self, request):
"""A route (HTTP handler) that returns a response with tags.
Args:
request: The werkzeug.Request object.
Returns:
A response that contains a JSON object. The keys of the object
are all the runs. Each run is mapped to a (potentially empty)
list of all tags that are relevant to this plugin.
"""
ctx = plugin_util.context(request.environ)
experiment = plugin_util.experiment_id(request.environ)
all_runs = self._data_provider.list_tensors(
ctx,
experiment_id=experiment,
plugin_name=metadata.PLUGIN_NAME,
)
# tagToContent is itself a dictionary mapping tag name to string
# SummaryMetadata.plugin_data.content. Retrieve the keys of that dictionary
# to obtain a list of tags associated with each run. For each tag estimate
# number of samples.
response = dict()
for run, tags in all_runs.items():
response[run] = dict()
for (instance_tag, metadatum) in tags.items():
md = metadata.parse_plugin_metadata(metadatum.plugin_content)
if not self._version_checker.ok(md.version, run, instance_tag):
continue
# Make sure we only operate on user-defined tags here.
tag = self._tag(ctx, experiment, run, instance_tag)
meta = self._instance_tag_metadata(
ctx, experiment, run, instance_tag
)
# Batch size must be defined, otherwise we don't know how many
# samples were there.
response[run][tag] = {"samples": meta.shape[0]}
return http_util.Respond(request, response, "application/json")
def get_components(self, proto):
return metadata.parse_plugin_metadata(
proto.metadata.plugin_data.content).components
def get_metadata(self, event):
return metadata.parse_plugin_metadata(
event.summary.value[0].metadata.plugin_data.content)
def _instance_tag_metadata(self, run, instance_tag):
"""Gets the `MeshPluginData` proto for an instance tag."""
summary_metadata = self._multiplexer.SummaryMetadata(run, instance_tag)
content = summary_metadata.plugin_data.content
return metadata.parse_plugin_metadata(content)
