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,
}
}
},
}
},
}
},
)
