pandagg.aggs module

class pandagg.aggs.Aggs(aggs: Union[Dict[str, Union[Dict[str, Dict[str, Any]], pandagg.node.aggs.abstract.AggClause]], Aggs, None] = None, mappings: Union[pandagg.types.MappingsDict, Mappings, None] = None, nested_autocorrect: bool = False, _groupby_ptr: Optional[str] = None)

Bases: pandagg.tree._tree.TreeReprMixin, lighttree.tree.Tree

Combination of aggregation clauses. This class provides handful methods to build an aggregation (see aggs() and groupby()), 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 or pandagg.tree.mappings.Mappings Mappings of requested indice(s). If provided, will

check 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: str, type_or_agg: Union[str, Dict[str, Dict[str, Any]], pandagg.node.aggs.abstract.AggClause, None] = None, insert_below: Optional[str] = None, at_root: bool = False, **body) → pandagg.tree.aggs.Aggs

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: Union[Dict[str, Union[Dict[str, Dict[str, Any]], pandagg.node.aggs.abstract.AggClause]], Aggs], insert_below: Optional[str] = None, at_root: bool = False) → pandagg.tree.aggs.Aggs

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: str) → Optional[str]

Return nested path applied at a clause.

Parameters:nid – clause identifier Returns:None if no nested is applied, else applied path (str)

apply_reverse_nested(nid: Optional[str] = None) → None

as_composite(size: int, after: Optional[Dict[str, Any]] = None) → pandagg.tree.aggs.Aggs

Convert current aggregation into composite aggregation. For now, simply support conversion of the root aggregation clause, and doesn’t handle multi-source.

get_composition_supporting_agg() → Tuple[str, pandagg.node.aggs.abstract.AggClause]

Return first composite-compatible aggregation clause if possible, raise an error otherwise.

groupby(name: str, type_or_agg: Union[str, Dict[str, Dict[str, Any]], pandagg.node.aggs.abstract.AggClause, None] = None, insert_below: Optional[str] = None, at_root: bool = False, **body) → pandagg.tree.aggs.Aggs

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: Optional[str] = None, deepest: bool = False) → pandagg.tree.aggs.Aggs

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.

id_from_key(key: str) → str

Find node identifier based on key. If multiple nodes have the same key, takes the first one.

Useful because of how pandagg implements lighttree.Tree. A bit of context:

ElasticSearch allows queries to contain multiple similarly named clauses (for queries and aggregations). As a consequence clauses names are not used as clauses identifier in Trees, and internally pandagg (as lighttree ) uses auto-generated uuids to distinguish them.

But for usability reasons, notably when declaring that an aggregation clause must be placed relatively to another one, the latter is identified by its name rather than its internal id. Since it is technically possible that multiple clauses share the same name (not recommended, but allowed), some pandagg features are ambiguous and not recommended in such context.

show(*args, line_max_length: int = 80, **kwargs) → str

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_: Optional[str] = None, depth: Optional[int] = None) → Dict[str, Dict[str, Dict[str, Any]]]

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

class pandagg.aggs.Terms(field: str, missing: Union[str, int, None] = None, size: Optional[int] = None, **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

Terms aggregation.

KEY = 'terms'

VALUE_ATTRS = ['doc_count', 'doc_count_error_upper_bound', 'sum_other_doc_count']

is_convertible_to_composite_source() → bool

class pandagg.aggs.Filters(filters: Dict[str, Dict[str, Dict[str, Any]]], other_bucket: bool = False, other_bucket_key: Optional[str] = None, **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

DEFAULT_OTHER_KEY = '_other_'

IMPLICIT_KEYED = True

KEY = 'filters'

VALUE_ATTRS = ['doc_count']

class pandagg.aggs.Histogram(field: str, interval: int, **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

KEY = 'histogram'

VALUE_ATTRS = ['doc_count']

WHITELISTED_MAPPING_TYPES = ['long', 'integer', 'short', 'byte', 'double', 'float', 'half_float', 'scaled_float', 'ip', 'token_count', 'date', 'boolean']

is_convertible_to_composite_source() → bool

class pandagg.aggs.DateHistogram(field: str, interval: str = None, calendar_interval: str = None, fixed_interval: str = None, key_as_string: bool = True, **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

KEY = 'date_histogram'

VALUE_ATTRS = ['doc_count']

WHITELISTED_MAPPING_TYPES = ['date']

is_convertible_to_composite_source() → bool

class pandagg.aggs.Range(field: str, ranges: List[pandagg.types.RangeDict], keyed: bool = False, **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

KEY = 'range'

VALUE_ATTRS = ['doc_count']

WHITELISTED_MAPPING_TYPES = ['long', 'integer', 'short', 'byte', 'double', 'float', 'half_float', 'scaled_float', 'ip', 'token_count', 'date', 'boolean']

class pandagg.aggs.Global(**body)

Bases: pandagg.node.aggs.abstract.UniqueBucketAgg

KEY = 'global'

VALUE_ATTRS = ['doc_count']

class pandagg.aggs.Filter(filter: Optional[Dict[str, Dict[str, Any]]] = None, meta: Optional[Dict[str, Any]] = None, **body)

Bases: pandagg.node.aggs.abstract.UniqueBucketAgg

KEY = 'filter'

VALUE_ATTRS = ['doc_count']

class pandagg.aggs.Missing(field: str, **body)

Bases: pandagg.node.aggs.abstract.UniqueBucketAgg

KEY = 'missing'

VALUE_ATTRS = ['doc_count']

class pandagg.aggs.Nested(path: str, **body)

Bases: pandagg.node.aggs.abstract.UniqueBucketAgg

KEY = 'nested'

VALUE_ATTRS = ['doc_count']

WHITELISTED_MAPPING_TYPES = ['nested']

class pandagg.aggs.ReverseNested(path: Optional[str] = None, **body)

Bases: pandagg.node.aggs.abstract.UniqueBucketAgg

KEY = 'reverse_nested'

VALUE_ATTRS = ['doc_count']

WHITELISTED_MAPPING_TYPES = ['nested']

class pandagg.aggs.Avg(field: Optional[str] = None, script: Optional[pandagg.types.Script] = None, **body)

Bases: pandagg.node.aggs.abstract.FieldOrScriptMetricAgg

KEY = 'avg'

VALUE_ATTRS = ['value']

WHITELISTED_MAPPING_TYPES = ['long', 'integer', 'short', 'byte', 'double', 'float', 'half_float', 'scaled_float', 'ip', 'token_count', 'date', 'boolean']

class pandagg.aggs.Max(field: Optional[str] = None, script: Optional[pandagg.types.Script] = None, **body)

Bases: pandagg.node.aggs.abstract.FieldOrScriptMetricAgg

KEY = 'max'

VALUE_ATTRS = ['value']

WHITELISTED_MAPPING_TYPES = ['long', 'integer', 'short', 'byte', 'double', 'float', 'half_float', 'scaled_float', 'ip', 'token_count', 'date', 'boolean']

class pandagg.aggs.Sum(field: Optional[str] = None, script: Optional[pandagg.types.Script] = None, **body)

Bases: pandagg.node.aggs.abstract.FieldOrScriptMetricAgg

KEY = 'sum'

VALUE_ATTRS = ['value']

WHITELISTED_MAPPING_TYPES = ['long', 'integer', 'short', 'byte', 'double', 'float', 'half_float', 'scaled_float', 'ip', 'token_count', 'date', 'boolean']

class pandagg.aggs.Min(field: Optional[str] = None, script: Optional[pandagg.types.Script] = None, **body)

Bases: pandagg.node.aggs.abstract.FieldOrScriptMetricAgg

KEY = 'min'

VALUE_ATTRS = ['value']

WHITELISTED_MAPPING_TYPES = ['long', 'integer', 'short', 'byte', 'double', 'float', 'half_float', 'scaled_float', 'ip', 'token_count', 'date', 'boolean']

class pandagg.aggs.Cardinality(field: Optional[str] = None, script: Optional[pandagg.types.Script] = None, **body)

Bases: pandagg.node.aggs.abstract.FieldOrScriptMetricAgg

KEY = 'cardinality'

VALUE_ATTRS = ['value']

class pandagg.aggs.Stats(field: Optional[str] = None, script: Optional[pandagg.types.Script] = None, **body)

Bases: pandagg.node.aggs.abstract.FieldOrScriptMetricAgg

KEY = 'stats'

VALUE_ATTRS = ['count', 'min', 'max', 'avg', 'sum']

WHITELISTED_MAPPING_TYPES = ['long', 'integer', 'short', 'byte', 'double', 'float', 'half_float', 'scaled_float', 'ip', 'token_count', 'date', 'boolean']

class pandagg.aggs.ExtendedStats(field: Optional[str] = None, script: Optional[pandagg.types.Script] = None, **body)

Bases: pandagg.node.aggs.abstract.FieldOrScriptMetricAgg

KEY = 'extended_stats'

VALUE_ATTRS = ['count', 'min', 'max', 'avg', 'sum', 'sum_of_squares', 'variance', 'std_deviation', 'std_deviation_bounds']

WHITELISTED_MAPPING_TYPES = ['long', 'integer', 'short', 'byte', 'double', 'float', 'half_float', 'scaled_float', 'ip', 'token_count', 'date', 'boolean']

class pandagg.aggs.Percentiles(field: Optional[str] = None, script: Optional[pandagg.types.Script] = None, **body)

Bases: pandagg.node.aggs.abstract.FieldOrScriptMetricAgg

Percents body argument can be passed to specify which percentiles to fetch.

KEY = 'percentiles'

VALUE_ATTRS = ['values']

WHITELISTED_MAPPING_TYPES = ['long', 'integer', 'short', 'byte', 'double', 'float', 'half_float', 'scaled_float', 'ip', 'token_count', 'date', 'boolean']

class pandagg.aggs.PercentileRanks(field: str, values: List[float], **body)

Bases: pandagg.node.aggs.abstract.FieldOrScriptMetricAgg

KEY = 'percentile_ranks'

VALUE_ATTRS = ['values']

WHITELISTED_MAPPING_TYPES = ['long', 'integer', 'short', 'byte', 'double', 'float', 'half_float', 'scaled_float', 'ip', 'token_count', 'date', 'boolean']

class pandagg.aggs.GeoBound(field: Optional[str] = None, script: Optional[pandagg.types.Script] = None, **body)

Bases: pandagg.node.aggs.abstract.FieldOrScriptMetricAgg

KEY = 'geo_bounds'

VALUE_ATTRS = ['bounds']

WHITELISTED_MAPPING_TYPES = ['geo_point']

class pandagg.aggs.GeoCentroid(field: Optional[str] = None, script: Optional[pandagg.types.Script] = None, **body)

Bases: pandagg.node.aggs.abstract.FieldOrScriptMetricAgg

KEY = 'geo_centroid'

VALUE_ATTRS = ['location']

WHITELISTED_MAPPING_TYPES = ['geo_point']

class pandagg.aggs.TopHits(meta: Optional[Dict[str, Any]] = None, identifier: Optional[str] = None, **body)

Bases: pandagg.node.aggs.abstract.MetricAgg

KEY = 'top_hits'

VALUE_ATTRS = ['hits']

class pandagg.aggs.ValueCount(field: Optional[str] = None, script: Optional[pandagg.types.Script] = None, **body)

Bases: pandagg.node.aggs.abstract.FieldOrScriptMetricAgg

KEY = 'value_count'

VALUE_ATTRS = ['value']

class pandagg.aggs.AvgBucket(buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.Pipeline

KEY = 'avg_bucket'

VALUE_ATTRS = ['value']

class pandagg.aggs.Derivative(buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.Pipeline

KEY = 'derivative'

VALUE_ATTRS = ['value']

class pandagg.aggs.MaxBucket(buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.Pipeline

KEY = 'max_bucket'

VALUE_ATTRS = ['value']

class pandagg.aggs.MinBucket(buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.Pipeline

KEY = 'min_bucket'

VALUE_ATTRS = ['value']

class pandagg.aggs.SumBucket(buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.Pipeline

KEY = 'sum_bucket'

VALUE_ATTRS = ['value']

class pandagg.aggs.StatsBucket(buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.Pipeline

KEY = 'stats_bucket'

VALUE_ATTRS = ['count', 'min', 'max', 'avg', 'sum']

class pandagg.aggs.ExtendedStatsBucket(buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.Pipeline

KEY = 'extended_stats_bucket'

VALUE_ATTRS = ['count', 'min', 'max', 'avg', 'sum', 'sum_of_squares', 'variance', 'std_deviation', 'std_deviation_bounds']

class pandagg.aggs.PercentilesBucket(buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.Pipeline

KEY = 'percentiles_bucket'

VALUE_ATTRS = ['values']

class pandagg.aggs.MovingAvg(buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.Pipeline

KEY = 'moving_avg'

VALUE_ATTRS = ['value']

class pandagg.aggs.CumulativeSum(buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.Pipeline

KEY = 'cumulative_sum'

VALUE_ATTRS = ['value']

class pandagg.aggs.BucketScript(script: pandagg.types.Script, buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.ScriptPipeline

KEY = 'bucket_script'

VALUE_ATTRS = ['value']

class pandagg.aggs.BucketSelector(script: pandagg.types.Script, buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.ScriptPipeline

KEY = 'bucket_selector'

VALUE_ATTRS = []

class pandagg.aggs.BucketSort(script: pandagg.types.Script, buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.ScriptPipeline

KEY = 'bucket_sort'

VALUE_ATTRS = []

class pandagg.aggs.SerialDiff(buckets_path: str, gap_policy: Optional[typing_extensions.Literal['skip', 'insert_zeros', 'keep_values'][skip, insert_zeros, keep_values]] = None, **body)

Bases: pandagg.node.aggs.abstract.Pipeline

KEY = 'serial_diff'

VALUE_ATTRS = ['value']

class pandagg.aggs.MatchAll(**body)

Bases: pandagg.node.aggs.bucket.Filter

class pandagg.aggs.Composite(sources: List[Dict[str, Dict[str, Dict[str, Any]]]], size: Optional[int] = None, after: Optional[Dict[str, Any]] = None, **body)

Bases: pandagg.node.aggs.abstract.BucketAggClause

KEY = 'composite'

VALUE_ATTRS = ['doc_count']

after

extract_buckets(response_value: Union[pandagg.types.BucketsWrapperDict, Dict[str, Any]]) → Iterator[Tuple[Dict[str, Union[str, float, None]], Dict[str, Any]]]

size

source_names

sources

class pandagg.aggs.GeoHashGrid(field: str, precision: Optional[int] = None, bounds: Optional[Dict[KT, VT]] = None, size: Optional[int] = None, shard_size: Optional[int] = None, **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

KEY = 'geohash_grid'

VALUE_ATTRS = ['doc_count']

WHITELISTED_MAPPING_TYPES = ['geo_point', 'geo_shape']

class pandagg.aggs.GeoDistance(field: str, origin: str, ranges: List[pandagg.types.RangeDict], unit: Optional[str] = None, distance_type: Optional[typing_extensions.Literal['arc', 'plane'][arc, plane]] = None, keyed: bool = False, **body)

Bases: pandagg.node.aggs.bucket.Range

KEY = 'geo_distance'

VALUE_ATTRS = ['doc_count']

WHITELISTED_MAPPING_TYPES = ['geo_point']

class pandagg.aggs.AdjacencyMatrix(filters: Dict[str, Dict[str, Dict[str, Any]]], separator: Optional[str] = None, **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

KEY = 'adjacency_matrix'

VALUE_ATTRS = ['doc_count']

class pandagg.aggs.AutoDateHistogram(field: str, buckets: Optional[int] = None, format: Optional[str] = None, time_zone: Optional[str] = None, minimum_interval: Optional[str] = None, missing: Optional[str] = None, key_as_string: bool = True, **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

KEY = 'auto_date_histogram'

VALUE_ATTRS = ['doc_count']

class pandagg.aggs.VariableWidthHistogram(field: str, buckets: int, **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

KEY = 'variable_width_histogram'

VALUE_ATTRS = ['doc_count', 'min', 'max']

class pandagg.aggs.SignificantTerms(field: str, **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

KEY = 'significant_terms'

VALUE_ATTRS = ['doc_count', 'score', 'bg_count']

class pandagg.aggs.RareTerms(field: str, max_doc_count: Optional[int] = None, precision: Optional[float] = None, include: Union[str, List[str], None] = None, exclude: Union[str, List[str], None] = None, missing: Optional[Any] = None, **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

KEY = 'rare_terms'

VALUE_ATTRS = ['doc_count']

class pandagg.aggs.GeoTileGrid(field: str, precision: Optional[int] = None, bounds: Optional[Dict[KT, VT]] = None, size: Optional[int] = None, shard_size: Optional[int] = None, **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

KEY = 'geotile_grid'

VALUE_ATTRS = ['doc_count']

WHITELISTED_MAPPING_TYPES = ['geo_point', 'geo_shape']

class pandagg.aggs.IPRange(field: str, ranges: List[pandagg.types.RangeDict], keyed: bool = False, **body)

Bases: pandagg.node.aggs.bucket.Range

KEY = 'ip_range'

VALUE_ATTRS = ['doc_count']

WHITELISTED_MAPPING_TYPES = ['ip']

class pandagg.aggs.Sampler(shard_size: Optional[int] = None, **body)

Bases: pandagg.node.aggs.abstract.UniqueBucketAgg

KEY = 'sampler'

VALUE_ATTRS = ['doc_count']

class pandagg.aggs.DiversifiedSampler(field: str, shard_size: Optional[int], max_docs_per_value: Optional[int] = None, execution_hint: Optional[typing_extensions.Literal['map', 'global_ordinals', 'bytes_hash'][map, global_ordinals, bytes_hash]] = None, **body)

Bases: pandagg.node.aggs.abstract.UniqueBucketAgg

KEY = 'diversified_sampler'

VALUE_ATTRS = ['doc_count']

class pandagg.aggs.Children(type: str, **body)

Bases: pandagg.node.aggs.abstract.UniqueBucketAgg

KEY = 'children'

VALUE_ATTRS = ['doc_count']

class pandagg.aggs.Parent(type: str, **body)

Bases: pandagg.node.aggs.abstract.UniqueBucketAgg

KEY = 'parent'

VALUE_ATTRS = ['doc_count']

class pandagg.aggs.SignificantText(field: str, **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

KEY = 'significant_text'

VALUE_ATTRS = ['doc_count', 'score', 'bg_count']

WHITELISTED_MAPPING_TYPES = ['text']

class pandagg.aggs.MultiTerms(terms: List[Dict[KT, VT]], **body)

Bases: pandagg.node.aggs.abstract.MultipleBucketAgg

KEY = 'multi_terms'

VALUE_ATTRS = ['doc_count', 'doc_count_error_upper_bound', 'sum_other_doc_count']