pandagg.query module

class pandagg.query.Query(q: Union[str, Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, Query, None] = None, mappings: Union[pandagg.types.MappingsDict, pandagg.tree.mappings.Mappings, None] = None, nested_autocorrect: bool = False)

Bases: lighttree.tree.Tree

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)

bool(must: Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, List[Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause]], None] = None, should: Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, List[Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause]], None] = None, must_not: Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, List[Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause]], None] = None, filter: Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, List[Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause]], None] = None, insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', **body) → pandagg.tree.query.Query

>>> Query().bool(must={"term": {"some_field": "yolo"}})

boosting(positive: Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, None] = None, negative: Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, None] = None, insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', **body) → pandagg.tree.query.Query

constant_score(filter: Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, None] = None, boost: Optional[float] = None, insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', **body) → pandagg.tree.query.Query

dis_max(queries: List[Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause]], insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', **body) → pandagg.tree.query.Query

filter(type_or_query: Union[str, Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, Query], insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', bool_body: Dict[str, Any] = None, **body) → pandagg.tree.query.Query

function_score(query: Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, None], insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', **body) → pandagg.tree.query.Query

has_child(query: Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, None], insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', **body) → pandagg.tree.query.Query

has_parent(query: Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, None], insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', **body) → pandagg.tree.query.Query

must(type_or_query: Union[str, Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, Query], insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', bool_body: Optional[Dict[str, Any]] = None, **body) → pandagg.tree.query.Query

Create copy of initial Query and insert provided clause under “bool” query “must”.

>>> Query().must('term', some_field=1)
>>> Query().must({'term': {'some_field': 1}})
>>> from pandagg.query import Term
>>> Query().must(Term(some_field=1))

Keyword Arguments:  

• insert_below (str) – named query clause under which the inserted clauses should be placed.
• compound_param (str) – param under which inserted clause will be placed in compound query
• on (str) – named compound query clause on which the inserted compound clause should be merged.
• mode (str one of ‘add’, ‘replace’, ‘replace_all’) – merging strategy when inserting clauses on a existing compound clause.
  • ‘add’ (default) : adds new clauses keeping initial ones
  • ‘replace’ : for each parameter (for instance in ‘bool’ case : ‘filter’, ‘must’, ‘must_not’, ‘should’), replace existing clauses under this parameter, by new ones only if declared in inserted compound query
  • ‘replace_all’ : existing compound clause is completely replaced by the new one

must_not(type_or_query: Union[str, Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, Query], insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', bool_body: Dict[str, Any] = None, **body) → pandagg.tree.query.Query

nested(path: str, query: Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, None] = None, insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', **body) → pandagg.tree.query.Query

pinned_query(organic: Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, None], insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', **body) → pandagg.tree.query.Query

query(type_or_query: Union[str, Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, Query], insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', compound_param: str = None, **body) → pandagg.tree.query.Query

Insert provided clause in copy of initial Query.

>>> from pandagg.query import Query
>>> Query().query('term', some_field=23)
{'term': {'some_field': 23}}

>>> from pandagg.query import Term
>>> Query()\
>>> .query({'term': {'some_field': 23})\
>>> .query(Term(other_field=24))\
{'bool': {'must': [{'term': {'some_field': 23}}, {'term': {'other_field': 24}}]}}

Keyword Arguments:  

• insert_below (str) – named query clause under which the inserted clauses should be placed.
• compound_param (str) – param under which inserted clause will be placed in compound query
• on (str) – named compound query clause on which the inserted compound clause should be merged.
• mode (str one of ‘add’, ‘replace’, ‘replace_all’) – merging strategy when inserting clauses on a existing compound clause.
  • ‘add’ (default) : adds new clauses keeping initial ones
  • ‘replace’ : for each parameter (for instance in ‘bool’ case : ‘filter’, ‘must’, ‘must_not’, ‘should’), replace existing clauses under this parameter, by new ones only if declared in inserted compound query
  • ‘replace_all’ : existing compound clause is completely replaced by the new one

script_score(query: Union[Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, None], insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', **body) → pandagg.tree.query.Query

should(type_or_query: Union[str, Dict[str, Dict[str, Any]], pandagg.node.query.abstract.QueryClause, Query], insert_below: Optional[str] = None, on: Optional[str] = None, mode: typing_extensions.Literal['add', 'replace', 'replace_all'][add, replace, replace_all] = 'add', bool_body: Optional[Dict[str, Any]] = None, **body) → pandagg.tree.query.Query

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

Return compact representation of Query.

>>> Query()        >>> .must({"exists": {"field": "some_field"}})        >>> .must({"term": {"other_field": {"value": 5}}})        >>> .show()
<Query>
bool
└── must
    ├── exists                                                  field=some_field
    └── term                                          field=other_field, value=5

All *args and **kwargs are propagated to lighttree.Tree.show method.

to_dict(from_: Optional[str] = None) → Optional[Dict[str, Dict[str, Any]]]

class pandagg.query.Exists(field: str, _name: Optional[str] = None)

Bases: pandagg.node.query.abstract.LeafQueryClause

KEY = 'exists'

line_repr(depth: int, **kwargs) → Tuple[str, str]

Control how node is displayed in tree representation. First returned string is how node is represented on left, second string is how node is represented on right.

MyTree ├── one OneEnd │ └── two twoEnd └── three threeEnd

class pandagg.query.Fuzzy(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'fuzzy'

class pandagg.query.Ids(values: List[Union[str, int]], _name: Optional[str] = None)

Bases: pandagg.node.query.abstract.LeafQueryClause

KEY = 'ids'

line_repr(depth: int, **kwargs) → Tuple[str, str]

Control how node is displayed in tree representation. First returned string is how node is represented on left, second string is how node is represented on right.

MyTree ├── one OneEnd │ └── two twoEnd └── three threeEnd

class pandagg.query.Prefix(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'prefix'

class pandagg.query.Range(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'range'

class pandagg.query.Regexp(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'regexp'

class pandagg.query.Term(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'term'

class pandagg.query.Terms(**body)

Bases: pandagg.node.query.abstract.AbstractSingleFieldQueryClause

KEY = 'terms'

class pandagg.query.TermsSet(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'terms_set'

class pandagg.query.Type(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'type'

class pandagg.query.Wildcard(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'wildcard'

class pandagg.query.Intervals(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'intervals'

class pandagg.query.Match(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'match'

class pandagg.query.MatchBoolPrefix(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'match_bool_prefix'

class pandagg.query.MatchPhrase(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'match_phrase'

class pandagg.query.MatchPhrasePrefix(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'match_phrase_prefix'

class pandagg.query.MultiMatch(fields: List[str], _name: Optional[str] = None, **body)

Bases: pandagg.node.query.abstract.MultiFieldsQueryClause

KEY = 'multi_match'

class pandagg.query.Common(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'common'

class pandagg.query.QueryString(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.abstract.LeafQueryClause

KEY = 'query_string'

class pandagg.query.SimpleQueryString(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.abstract.LeafQueryClause

KEY = 'simple_string'

class pandagg.query.Bool(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.compound.CompoundClause

>>> Bool(must=[], should=[], filter=[], must_not=[], boost=1.2)

KEY = 'bool'

class pandagg.query.Boosting(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.compound.CompoundClause

KEY = 'boosting'

class pandagg.query.ConstantScore(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.compound.CompoundClause

KEY = 'constant_score'

class pandagg.query.FunctionScore(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.compound.CompoundClause

KEY = 'function_score'

class pandagg.query.DisMax(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.compound.CompoundClause

KEY = 'dis_max'

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

Bases: pandagg.node.query.compound.CompoundClause

KEY = 'nested'

class pandagg.query.HasParent(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.compound.CompoundClause

KEY = 'has_parent'

class pandagg.query.HasChild(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.compound.CompoundClause

KEY = 'has_child'

class pandagg.query.ParentId(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.abstract.LeafQueryClause

KEY = 'parent_id'

class pandagg.query.Shape(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.abstract.LeafQueryClause

KEY = 'shape'

class pandagg.query.GeoShape(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'geo_shape'

class pandagg.query.GeoPolygone(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'geo_polygon'

class pandagg.query.GeoDistance(distance: str, **body)

Bases: pandagg.node.query.abstract.AbstractSingleFieldQueryClause

KEY = 'geo_distance'

line_repr(depth: int, **kwargs) → Tuple[str, str]

Control how node is displayed in tree representation. First returned string is how node is represented on left, second string is how node is represented on right.

MyTree ├── one OneEnd │ └── two twoEnd └── three threeEnd

class pandagg.query.GeoBoundingBox(field: Optional[str] = None, _name: Optional[str] = None, _expand__to_dot: bool = True, **params)

Bases: pandagg.node.query.abstract.KeyFieldQueryClause

KEY = 'geo_bounding_box'

class pandagg.query.DistanceFeature(field: str, _name: Optional[str] = None, **body)

Bases: pandagg.node.query.abstract.FlatFieldQueryClause

KEY = 'distance_feature'

class pandagg.query.MoreLikeThis(fields: List[str], _name: Optional[str] = None, **body)

Bases: pandagg.node.query.abstract.MultiFieldsQueryClause

KEY = 'more_like_this'

class pandagg.query.Percolate(field: str, _name: Optional[str] = None, **body)

Bases: pandagg.node.query.abstract.FlatFieldQueryClause

KEY = 'percolate'

class pandagg.query.RankFeature(field: str, _name: Optional[str] = None, **body)

Bases: pandagg.node.query.abstract.FlatFieldQueryClause

KEY = 'rank_feature'

class pandagg.query.Script(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.abstract.LeafQueryClause

KEY = 'script'

class pandagg.query.Wrapper(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.abstract.LeafQueryClause

KEY = 'wrapper'

class pandagg.query.ScriptScore(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.compound.CompoundClause

KEY = 'script_score'

class pandagg.query.PinnedQuery(_name: Optional[str] = None, **body)

Bases: pandagg.node.query.compound.CompoundClause

KEY = 'pinned'