pandagg.tree.aggs module¶
-
class
pandagg.tree.aggs.
Aggs
(aggs=None, mappings=None, nested_autocorrect=None, _groupby_ptr=None)[source]¶ Bases:
pandagg.tree._tree.Tree
Combination of aggregation clauses. This class provides handful methods to build an aggregation (see
aggs()
andgroupby()
), and is used as well to parse aggregations response in easy to manipulate formats.Mappings declaration is optional, but doing so validates aggregation validity and automatically handles missing nested clauses.
Accept following syntaxes:
from a dict: >>> Aggs({“per_user”: {“terms”: {“field”: “user”}}})
from an other Aggs instance: >>> Aggs(Aggs({“per_user”: {“terms”: {“field”: “user”}}}))
dict with AggClause instances as values: >>> from pandagg.aggs import Terms, Avg >>> Aggs({‘per_user’: Terms(field=’user’)})
Parameters: mappings – dict
orpandagg.tree.mappings.Mappings
Mappings of requested indice(s). If provided, willcheck aggregations validity. :param nested_autocorrect:
bool
In case of missing nested clauses in aggregation, if True, automatically add missing nested clauses, else raise error. Ignored if mappings are not provided. :param _groupby_ptr:str
identifier of aggregation clause used as grouping element (used by clone method).-
agg
(name, type_or_agg=None, insert_below=None, at_root=False, **body)[source]¶ Insert provided agg clause in copy of initial Aggs.
Accept following syntaxes for type_or_agg argument:
string, with body provided in kwargs >>> Aggs().agg(name=’some_agg’, type_or_agg=’terms’, field=’some_field’)
python dict format: >>> Aggs().agg(name=’some_agg’, type_or_agg={‘terms’: {‘field’: ‘some_field’})
AggClause instance: >>> from pandagg.aggs import Terms >>> Aggs().agg(name=’some_agg’, type_or_agg=Terms(field=’some_field’))
Parameters: - name – inserted agg clause name
- type_or_agg – either agg type (str), or agg clause of dict format, or AggClause instance
- insert_below – name of aggregation below which provided aggs should be inserted
- at_root – if True, aggregation is inserted at root
- body – aggregation clause body when providing string type_of_agg (remaining kwargs)
Returns: copy of initial Aggs with provided agg inserted
-
aggs
(aggs, insert_below=None, at_root=False)[source]¶ Insert provided aggs in copy of initial Aggs.
Accept following syntaxes for provided aggs:
python dict format: >>> Aggs().aggs({‘some_agg’: {‘terms’: {‘field’: ‘some_field’}}, ‘other_agg’: {‘avg’: {‘field’: ‘age’}}})
Aggs instance: >>> Aggs().aggs(Aggs({‘some_agg’: {‘terms’: {‘field’: ‘some_field’}}, ‘other_agg’: {‘avg’: {‘field’: ‘age’}}}))
dict with Agg clauses values: >>> from pandagg.aggs import Terms, Avg >>> Aggs().aggs({‘some_agg’: Terms(field=’some_field’), ‘other_agg’: Avg(field=’age’)})
Parameters: - aggs – aggregations to insert into existing aggregation
- insert_below – name of aggregation below which provided aggs should be inserted
- at_root – if True, aggregation is inserted at root
Returns: copy of initial Aggs with provided aggs inserted
-
applied_nested_path_at_node
(nid)[source]¶ Return nested path applied at a clause.
Parameters: nid – clause identifier Returns: None if no nested is applied, else applied path (str)
-
groupby
(name, type_or_agg=None, insert_below=None, at_root=None, **body)[source]¶ Insert provided aggregation clause in copy of initial Aggs.
Given the initial aggregation:
A──> B └──> C
If insert_below = ‘A’:
A──> new──> B └──> C
>>> Aggs().groupby('per_user_id', 'terms', field='user_id') {"per_user_id":{"terms":{"field":"user_id"}}}
>>> Aggs().groupby('per_user_id', {'terms': {"field": "user_id"}}) {"per_user_id":{"terms":{"field":"user_id"}}}
>>> from pandagg.aggs import Terms >>> Aggs().groupby('per_user_id', Terms(field="user_id")) {"per_user_id":{"terms":{"field":"user_id"}}}
Return type: pandagg.aggs.Aggs
-
grouped_by
(agg_name=None, deepest=False)[source]¶ Define which aggregation will be used as grouping pointer.
Either provide an aggregation name, either specify ‘deepest=True’ to consider deepest linear eligible aggregation node as pointer.
-
node_class
¶ alias of
pandagg.node.aggs.abstract.AggClause
-
show
(*args, line_max_length=80, **kwargs)[source]¶ Return compact representation of Aggs.
>>> Aggs({ >>> "genres": { >>> "terms": {"field": "genres", "size": 3}, >>> "aggs": { >>> "movie_decade": { >>> "date_histogram": {"field": "year", "fixed_interval": "3650d"} >>> } >>> }, >>> } >>> }).show() <Aggregations> genres <terms, field="genres", size=3> └── movie_decade <date_histogram, field="year", fixed_interval="3650d">
All *args and **kwargs are propagated to lighttree.Tree.show method. :return: str
-
to_dict
(from_=None, depth=None)[source]¶ Serialize Aggs as dict.
Parameters: from – identifier of aggregation clause, if provided, limits serialization to this clause and its children (used for recursion, shouldn’t be useful) :param depth: integer, if provided, limit the serialization to a given depth :return: dict
-