def test_aggs(self): node = Terms(name="some_name", field="some_field", size=10) some_agg = Aggs().aggs(node, insert_below=None) self.assertEqual( some_agg.to_dict(), {"some_name": {"terms": {"field": "some_field", "size": 10}}}, ) # with parent with required nested some_agg = Aggs( {"term_workflow": {"terms": {"field": "workflow", "size": 5}}}, mapping=MAPPING, nested_autocorrect=True, ) node = Avg(name="min_local_f1", field="local_metrics.performance.test.f1_score") some_agg = some_agg.aggs(node, insert_below="term_workflow") self.assertEqual( some_agg.to_dict(), { "term_workflow": { "aggs": { "nested_below_term_workflow": { "aggs": { "min_local_f1": { "avg": { "field": "local_metrics.performance.test.f1_score" } } }, "nested": {"path": "local_metrics"}, } }, "terms": {"field": "workflow", "size": 5}, } }, )
def test_interpret_agg_string(self): some_agg = Aggs() some_agg = some_agg.aggs("some_field", insert_below=None) self.assertEqual( some_agg.to_dict(), {"some_field": {"terms": {"field": "some_field"}}} ) # with default size some_agg = Aggs() some_agg = some_agg.aggs("some_field", insert_below=None, size=10) self.assertEqual( some_agg.to_dict(), {"some_field": {"terms": {"field": "some_field", "size": 10}}}, ) # with parent some_agg = Aggs( {"root_agg_name": {"terms": {"field": "some_field", "size": 5}}} ) some_agg = some_agg.aggs("child_field", insert_below="root_agg_name") self.assertEqual( some_agg.to_dict(), { "root_agg_name": { "aggs": {"child_field": {"terms": {"field": "child_field"}}}, "terms": {"field": "some_field", "size": 5}, } }, ) # with required nested some_agg = Aggs( {"term_workflow": {"terms": {"field": "workflow", "size": 5}}}, mapping=MAPPING, nested_autocorrect=True, ) some_agg = some_agg.aggs( "local_metrics.field_class.name", insert_below="term_workflow" ) self.assertEqual( some_agg.to_dict(), { "term_workflow": { "aggs": { "nested_below_term_workflow": { "aggs": { "local_metrics.field_class.name": { "terms": {"field": "local_metrics.field_class.name"} } }, "nested": {"path": "local_metrics"}, } }, "terms": {"field": "workflow", "size": 5}, } }, )
def test_agg_insert_below(self): a1 = Aggs( Terms("A", field="A", aggs=[Terms("B", field="B"), Terms("C", field="C")]) ) self.assertEqual( a1.to_dict(), { "A": { "terms": {"field": "A"}, "aggs": { "C": {"terms": {"field": "C"}}, "B": {"terms": {"field": "B"}}, }, } }, ) self.assertEqual( a1.aggs(Terms("D", field="D"), insert_below="A").to_dict(), { "A": { "aggs": { "B": {"terms": {"field": "B"}}, "C": {"terms": {"field": "C"}}, "D": {"terms": {"field": "D"}}, }, "terms": {"field": "A"}, } }, ) self.assertEqual( a1.aggs( [Terms("D", field="D"), Terms("E", field="E")], insert_below="A" ).to_dict(), { "A": { "aggs": { "B": {"terms": {"field": "B"}}, "C": {"terms": {"field": "C"}}, "D": {"terms": {"field": "D"}}, "E": {"terms": {"field": "E"}}, }, "terms": {"field": "A"}, } }, )
def test_add_node_with_mapping(self): with_mapping = Aggs(mapping=MAPPING, nested_autocorrect=True) self.assertEqual(len(with_mapping.list()), 0) # add regular node with_mapping = with_mapping.aggs(Terms("workflow", field="workflow")) self.assertEqual( with_mapping.to_dict(), {"workflow": {"terms": {"field": "workflow"}}} ) # try to add field aggregation on non-existing field will fail with self.assertRaises(AbsentMappingFieldError): with_mapping.aggs( Terms("imaginary_agg", field="imaginary_field"), insert_below="workflow", ) self.assertEqual(len(with_mapping.list()), 1) # try to add aggregation on a non-compatible field will fail with self.assertRaises(InvalidOperationMappingFieldError): with_mapping.aggs( Avg("average_of_string", field="classification_type"), insert_below="workflow", ) self.assertEqual(len(with_mapping.list()), 1) # add field aggregation on field passing through nested will automatically add nested with_mapping = with_mapping.aggs( Avg("local_f1_score", field="local_metrics.performance.test.f1_score"), insert_below="workflow", ) self.assertEqual( with_mapping.to_dict(), { "workflow": { "aggs": { "nested_below_workflow": { "aggs": { "local_f1_score": { "avg": { "field": "local_metrics.performance.test.f1_score" } } }, "nested": {"path": "local_metrics"}, } }, "terms": {"field": "workflow"}, } }, ) self.assertIn("nested_below_workflow", with_mapping) nested_node = with_mapping.get("nested_below_workflow") self.assertEqual(nested_node.KEY, "nested") self.assertEqual(nested_node.path, "local_metrics") # add other agg requiring nested will reuse nested agg as parent with_mapping = with_mapping.aggs( Avg("local_precision", field="local_metrics.performance.test.precision"), insert_below="workflow", ) self.assertEqual( with_mapping.to_dict(), { "workflow": { "aggs": { "nested_below_workflow": { "aggs": { "local_f1_score": { "avg": { "field": "local_metrics.performance.test.f1_score" } }, "local_precision": { "avg": { "field": "local_metrics.performance.test.precision" } }, }, "nested": {"path": "local_metrics"}, } }, "terms": {"field": "workflow"}, } }, ) self.assertEqual(len(with_mapping.list()), 4) # add under a nested parent a field aggregation that requires to be located under root will automatically # add reverse-nested with_mapping = with_mapping.aggs( Terms("language_terms", field="language"), insert_below="nested_below_workflow", ) self.assertEqual(len(with_mapping.list()), 6) self.assertEqual( with_mapping.to_dict(), { "workflow": { "aggs": { "nested_below_workflow": { "aggs": { "local_f1_score": { "avg": { "field": "local_metrics.performance.test.f1_score" } }, "local_precision": { "avg": { "field": "local_metrics.performance.test.precision" } }, "reverse_nested_below_nested_below_workflow": { "aggs": { "language_terms": { "terms": {"field": "language"} } }, "reverse_nested": {}, }, }, "nested": {"path": "local_metrics"}, } }, "terms": {"field": "workflow"}, } }, )
def test_groupby_insert_above(self): a1 = Aggs( Terms("A", field="A", aggs=[Terms("B", field="B"), Terms("C", field="C")]) ) self.assertEqual( a1.to_dict(), { "A": { "terms": {"field": "A"}, "aggs": { "B": {"terms": {"field": "B"}}, "C": {"terms": {"field": "C"}}, }, } }, ) self.assertEqual( a1.groupby(Terms("D", field="D"), insert_above="B").to_dict(), { "A": { "terms": {"field": "A"}, "aggs": { "C": {"terms": {"field": "C"}}, "D": { "terms": {"field": "D"}, "aggs": {"B": {"terms": {"field": "B"}}}, }, }, } }, ) self.assertEqual( a1.groupby( [Terms("D", field="D"), Terms("E", field="E")], insert_above="B" ).to_dict(), { "A": { "terms": {"field": "A"}, "aggs": { "C": {"terms": {"field": "C"}}, "D": { "terms": {"field": "D"}, "aggs": { "E": { "terms": {"field": "E"}, "aggs": {"B": {"terms": {"field": "B"}}}, } }, }, }, } }, ) self.assertEqual( a1.groupby( Terms("D", field="D", aggs=Terms("E", field="E")), insert_above="B" ).to_dict(), { "A": { "aggs": { "C": {"terms": {"field": "C"}}, "D": { "aggs": { "E": { "aggs": {"B": {"terms": {"field": "B"}}}, "terms": {"field": "E"}, } }, "terms": {"field": "D"}, }, }, "terms": {"field": "A"}, } }, ) # above root self.assertEqual( a1.groupby( Terms("D", field="D", aggs=Terms("E", field="E")), insert_above="A" ).to_dict(), { "D": { "terms": {"field": "D"}, "aggs": { "E": { "terms": {"field": "E"}, "aggs": { "A": { "terms": {"field": "A"}, "aggs": { "B": {"terms": {"field": "B"}}, "C": {"terms": {"field": "C"}}, }, } }, } }, } }, )
def test_groupby_args_syntax(self): a = Aggs().groupby("some_name", "terms", field="some_field") self.assertEqual(a.to_dict(), {"some_name": {"terms": {"field": "some_field"}}})
def test_init_from_node_hierarchy(self): node_hierarchy = sample.get_node_hierarchy() agg = Aggs(node_hierarchy, mapping=MAPPING) self.assertEqual(agg.to_dict(), sample.EXPECTED_AGG_QUERY) # with nested node_hierarchy = DateHistogram( name="week", field="date", interval="1w", aggs=[ Terms( name="local_metrics.field_class.name", field="local_metrics.field_class.name", size=10, aggs=[ Min( name="min_f1_score", field="local_metrics.performance.test.f1_score", ) ], ) ], ) agg = Aggs(node_hierarchy, mapping=MAPPING, nested_autocorrect=True) self.assertEqual( agg.to_dict(), { "week": { "aggs": { "nested_below_week": { "aggs": { "local_metrics.field_class.name": { "aggs": { "min_f1_score": { "min": { "field": "local_metrics.performance.test.f1_score" } } }, "terms": { "field": "local_metrics.field_class.name", "size": 10, }, } }, "nested": {"path": "local_metrics"}, } }, "date_histogram": {"field": "date", "interval": "1w"}, } }, ) self.assertEqual( agg.to_dict(), { "week": { "aggs": { "nested_below_week": { "aggs": { "local_metrics.field_class.name": { "aggs": { "min_f1_score": { "min": { "field": "local_metrics.performance.test.f1_score" } } }, "terms": { "field": "local_metrics.field_class.name", "size": 10, }, } }, "nested": {"path": "local_metrics"}, } }, "date_histogram": {"field": "date", "interval": "1w"}, } }, )
def test_insert_tree_without_mapping(self): # with explicit nested initial_agg_1 = Aggs( { "week": { "date_histogram": { "field": "date", "format": "yyyy-MM-dd", "interval": "1w", } } }, ) self.assertEqual({n.identifier for n in initial_agg_1.list()}, {"week"}) pasted_agg_1 = Aggs( { "nested_below_week": { "nested": {"path": "local_metrics"}, "aggs": { "local_metrics.field_class.name": { "terms": { "field": "local_metrics.field_class.name", "size": 10, } } }, } } ) self.assertEqual( to_id_set(pasted_agg_1.list()), {"nested_below_week", "local_metrics.field_class.name"}, ) initial_agg_1.insert_tree(pasted_agg_1, "week") self.assertEqual( to_id_set(initial_agg_1.list()), {"week", "nested_below_week", "local_metrics.field_class.name"}, ) self.assertEqual( initial_agg_1.to_dict(), { "week": { "date_histogram": { "field": "date", "format": "yyyy-MM-dd", "interval": "1w", }, "aggs": { "nested_below_week": { "nested": {"path": "local_metrics"}, "aggs": { "local_metrics.field_class.name": { "terms": { "field": "local_metrics.field_class.name", "size": 10, } } }, } }, } }, )
def test_paste_tree_with_mapping(self): # with explicit nested initial_agg_1 = Aggs( { "week": { "date_histogram": { "field": "date", "format": "yyyy-MM-dd", "interval": "1w", } } }, mapping=MAPPING, ) self.assertEqual(to_id_set(initial_agg_1.list()), {"week"}) pasted_agg_1 = Aggs( { "nested_below_week": { "nested": {"path": "local_metrics"}, "aggs": { "local_metrics.field_class.name": { "terms": { "field": "local_metrics.field_class.name", "size": 10, } } }, } } ) self.assertEqual( to_id_set(pasted_agg_1.list()), {"nested_below_week", "local_metrics.field_class.name"}, ) initial_agg_1.insert_tree(pasted_agg_1, "week") self.assertEqual( to_id_set(initial_agg_1.list()), {"week", "nested_below_week", "local_metrics.field_class.name"}, ) self.assertEqual( initial_agg_1.to_dict(), { "week": { "date_histogram": { "field": "date", "format": "yyyy-MM-dd", "interval": "1w", }, "aggs": { "nested_below_week": { "nested": {"path": "local_metrics"}, "aggs": { "local_metrics.field_class.name": { "terms": { "field": "local_metrics.field_class.name", "size": 10, } } }, } }, } }, ) # without explicit nested initial_agg_2 = Aggs( { "week": { "date_histogram": { "field": "date", "format": "yyyy-MM-dd", "interval": "1w", } } }, mapping=MAPPING, nested_autocorrect=True, ) self.assertEqual(to_id_set(initial_agg_2.list()), {"week"}) pasted_agg_2 = Aggs( { "local_metrics.field_class.name": { "terms": {"field": "local_metrics.field_class.name", "size": 10} } } ) self.assertEqual( to_id_set(pasted_agg_2.list()), {"local_metrics.field_class.name"} ) initial_agg_2.insert_tree(pasted_agg_2, "week") self.assertEqual( to_id_set(initial_agg_2.list()), {"week", "nested_below_week", "local_metrics.field_class.name"}, ) self.assertEqual( initial_agg_2.to_dict(), { "week": { "date_histogram": { "field": "date", "format": "yyyy-MM-dd", "interval": "1w", }, "aggs": { "nested_below_week": { "nested": {"path": "local_metrics"}, "aggs": { "local_metrics.field_class.name": { "terms": { "field": "local_metrics.field_class.name", "size": 10, } } }, } }, } }, )