def test_calculate_prensors_with_source_paths_with_multiple_transforms(
self):
"""Tests get_sparse_tensors on a deep tree with a transformed field."""
expr = proto_test_util._get_expression_from_session_empty_user_info()
# Let's make it non-trivial by transforming the data.
def _reverse(parent_indices, values):
return parent_indices, tf.reverse(values, axis=[-1])
expr = proto.create_transformed_field(expr, path.Path(["event"]),
"reversed_event", _reverse)
expr = proto.create_transformed_field(expr,
path.Path(["reversed_event"]),
"reversed_reversed_event",
_reverse)
new_root = promote.promote(
expr, path.Path(["reversed_reversed_event", "action", "doc_id"]),
"action_doc_ids")
# A poor-man's reroot.
new_field = new_root.get_descendant_or_error(
path.Path(["reversed_reversed_event", "action_doc_ids"]))
result = calculate_with_source_paths.calculate_prensors_with_source_paths(
[new_field])
prensor_result, proto_summary_result = result
self.assertLen(prensor_result, 1)
self.assertLen(proto_summary_result, 1)
leaf_node = prensor_result[0].node
self.assertAllEqual(leaf_node.parent_index,
[0, 0, 1, 2, 2, 3, 4, 4, 4])
self.assertAllEqual(
leaf_node.values,
[b"a", b"b", b"c", b"e", b"f", b"g", b"h", b"i", b"j"])
list_of_paths = proto_summary_result[0].paths
expected = [path.Path(["event", "action", "doc_id"])]
self.equal_ignore_order(list_of_paths, expected)
def test_transformed_field_values_with_transformed_parent(self):
expr = proto_test_util._get_expression_from_session_empty_user_info()
first_reversed_expr = proto.create_transformed_field(
expr, path.Path(["event"]), "reversed_event", _reverse_values)
second_reversed_expr = proto.create_transformed_field(
first_reversed_expr, path.Path(["reversed_event", "action"]),
"reversed_action", _reverse_values)
result = expression_test_util.calculate_list_map(
second_reversed_expr.project(
["reversed_event.reversed_action.doc_id"]), self)
self.assertAllEqual(result["reversed_event.reversed_action.doc_id"],
[[[[b"b"], [b"a"], []], [[b"c"]], [[b"f"], [b"e"]]
], [[[b"g"], [b"j"]], [[b"i"], [b"h"]]]])
def test_create_reversed_field_nested(self):
expr = proto_test_util._get_expression_from_session_empty_user_info()
first_reverse = proto.create_transformed_field(expr, path.Path(["event"]),
"reversed_event",
_reverse_values)
second_reverse = proto.create_transformed_field(
first_reverse, path.Path(["reversed_event", "action"]),
"reversed_action", _reverse_values)
leaf_expr = second_reverse.get_descendant_or_error(
path.Path(["reversed_event", "reversed_action", "doc_id"]))
leaf_tensor = expression_test_util.calculate_value_slowly(leaf_expr)
self.assertEqual(leaf_tensor.parent_index.dtype, tf.int64)
self.assertEqual(leaf_tensor.values.dtype, tf.string)
def test_transformed_field_values_with_multiple_transforms(
self, use_string_view):
expr = proto_test_util._get_expression_from_session_empty_user_info()
reversed_events_expr = proto.create_transformed_field(
expr, path.Path(["event"]), "reversed_event", _reverse_values)
reversed_events_again_expr = proto.create_transformed_field(
reversed_events_expr, path.Path(["reversed_event"]),
"reversed_reversed_event", _reverse_values)
result = expression_test_util.calculate_list_map(
reversed_events_again_expr.project(
["reversed_reversed_event.action.doc_id"]),
self,
options=self._get_calculate_options(use_string_view))
self.assertAllEqual(result["reversed_reversed_event.action.doc_id"],
[[[[b"a"], [b"b"]], [[b"c"], []], [[b"e"], [b"f"]]],
[[[b"g"]], [[b"h"], [b"i"], [b"j"]]]])
if use_string_view:
self._check_string_view()
def test_create_transformed_field(self):
expr = proto_test_util._get_expression_from_session_empty_user_info()
reversed_events_expr = proto.create_transformed_field(
expr, path.Path(["event"]), "reversed_event", _reverse_values)
source_events = expr.get_child_or_error("event")
dest_events = reversed_events_expr.get_child_or_error("reversed_event")
self.assertTrue(dest_events.is_repeated)
self.assertFalse(dest_events.is_leaf)
self.assertEqual(source_events.type, dest_events.type)
leaf_expr = reversed_events_expr.get_descendant_or_error(
path.Path(["reversed_event", "action", "doc_id"]))
leaf_tensor = expression_test_util.calculate_value_slowly(leaf_expr)
self.assertEqual(leaf_tensor.parent_index.dtype, tf.int64)
self.assertEqual(leaf_tensor.values.dtype, tf.string)
