QueryableList (version 2.0.0)
index

# QueryableList
 
What
====
 
QueryableList allows you to "filter" a list of items of varying types, simplifing code by replacing tedious for-loops with simple chaining.
 
It uses an interface common to some ORMs like Django, Flask, and IndexedRedis.
 
You can perform single filters on lists of data, or you can build queries and execute that query on any number of arbitrary data sets.
 
QueryableList also implements the boolean logic operators for lists (AND, OR, XOR) which can simplify your code.
 
 
**What pattern does it replace?**
 
Constant loops/getters to drill down data. If you are filtering data, displaying data by criteria, etc, your code will be FULL of these.
 
QueryableList simplifies and makes generic this common pattern of filtering.
 
*Before*
 
        def getOlderThan(people, minAge):
 
                ret = []
                for person in people: 
                        if person.age and person.age > minAge:
                                ret.append(person)
                return ret
 
        ...
        people = getAllPeople() # Get your data  here
        oldEnoughToRide = getOlderThan(people, 13)
        notOldEnough =  [person for person in people if person not in oldEnoughToRide]
 
 
*After*
 
        people =  QueryableListObjs(  getAllPeople() )  # Transform data into QueryableList
        oldEnoughToRide =  people.filter(age__gt=13)
        notOldEnough =  people ^ oldEnoughToRide #  The XOR of the filtered list to the parent is the NOT of the filter criteria
 
 
No function, no loop, and list comprehensions can get very messy or impossible with a large number of complicated filters applied.
 
The above example shows a one-time filtering of a list. You can also build reusable queries, and append different criteria based on conditions or through passing the query around different functions. See "Building Reusable Queries" section below for more info.
 
 
How?
====
 
 
Types
-----
 
Perform one-time filters through one of the list-type extending classes:
 
 
**QueryableListObjs** - This assumes each item extends object [or implements \_\_getattribute\_\_].
 
**QueryableListDicts** - This assumes that each item is a dict [or implements \_\_getitem\_\_].
 
**QueryableListMixed** - QueryableList which can contain dict-like items or object-like item. (This is somewhat slower than using QueryableListObjs or QueryableListDicts directly, but use it if you need to mix, or need to support either type.)
 
 
The items within these lists do not need to be of the same type. If any fields are missing on the filtered objects, it will be assigned a value of "None" for filtering purposes.
 
 
Filter Methods
--------------
 
You can filter the data within these objects through one of the following methods:
 
*filterAnd* - returns a QueryableList where each item matches ALL of the provided criteria.
 
*filter* - Alias for filterAnd
 
*filterOr* - returns a QueryableList where each item matches ANY of the provided criteria.
 
 
The QueryableList types support all the operations of a list, and return the same QueryableList types so you can perform chaining. 
 
Additionally, you can use ADD(+), SUB(-), AND(&), OR(|), and XOR(^) operators against other QueryableLists as another powerful means of filtering.
 
 
You specify the filter operations by passing arguments of $fieldName\_\_$operation.
 
Example: e.x. results = objs.filter(name\_\_ne='Tim')  # get all objects where the 'name' field does not equal 'Tim'
 
 
For all available operations, see the "Operations" section below.
 
 
Building Reusable Queries
-------------------------
 
You can build a reusable query, out of several chains of filters (either AND or OR) by using the **QueryBuilder** class.
 
The QueryBuilder class stores a "chain" of filters, which are applied in order. Each link in the chain contains a filter type (AND or OR), and the filters themselves (same as the filter methods on the QueryableList).
 
 
Use the *addFilter(filterType, ..filters..)* method to add a link to the chain. 
 
To execute the query, call *execute(lst)* , where "lst" is your list of items. You can execute a query multiple times on any number of datasets.
 
Use the *copy* method to create a copy of the current set of filters.
 
 
If you know the type in advance, you can pass a QueryableListObjs or QueryableListDicts when calling *execute* to slightly speed up access times, otherwise a *QueryableListMixed* (supports both dict and object style access) will be used.
 
Example:
 
        myQuery = QueryBuilder()
        myQuery.addFilter(age__gt=21)  # Age must be greater than 21
        myQuery.addFilter('OR', job__ieq='Manager', numSubordinates__gt=0) # Is a manager, or has more than 0 subordinates
 
        managerPartyCompany1 = myQuery.execute(company1Persons) # Filter from all company1Persons those that meet above criteria
        managerPartyCompany2 = myQuery.execute(company2Persons) # use same filter to apply same query to company2Persons
 
 
Operations
----------
 
* eq - Test equality ( = operator )
 
* ieq - Test equality, ignoring case (must be strings, or at least implement the .lower() method)
 
* ne  - Test inequality ( != operator )
 
* ine - Test inequality, ignoring case (must be strings, or at least implement the .lower() method)
 
* lt  - The item's field value must be less than the provided value
 
* lte - The item's field value must be less than or equal to the provided value
 
* gt  - The item's field value must be greater than the provided value
 
* gte - The item's field value must be greater than or equal to the provided value
 
* isnull - Provided value must be True/False. If True, the item's field value must be None, otherwise it must not be None.
 
* is  - Test identity equality ( is operator )
 
* isnot - Test identity inequality ( is not operator )
 
* in - Test that the item's field value is contained in the provided list of items
 
* notin - Test that the item's field value is not contained in the provided list of items
 
* contains - Test that the item's field value contains the provided value ( using "in" )
 
* notcontains - Test that the item's field value does not contain the provided value ( using "not in" )
 
* containsAny - Test that the item's field value contains any of the items in the provided list ( using "in" )
 
* notcontainsAny - Test that the item's field value does not contain any of the items in the provided list ( using "not in" )
 
* splitcontains - Takes a tuple, (splitBy<str>, containsThis<str>). Use for a string that represents a list. The field will be split by the first, "splitBy", param, and the result tested that it contains an item matching the second, "containsThis", param. E.x. item\_\_splitcontains=(' ', 'someValue')
 
* splitnotcontains - Takes a tuple, (splitBy<str>, containsThis<str>). Use for a string that represents a list. The field will be split by the first, "splitBy", param, and the result tested that it does not contain an item matching the second, "containsThis", param.
 
* splitcontainsAny - Takes a tuple, (splitBy<str>, possibleMatches <list<str>>). Use for a string that represents a list. The field will be split by the first, "splitBy", param, and the result tested that it contains any of the items in the provided list.
 
* splitnotcontainsAny - Takes a tuple, (splitBy<str>, possibleMatches <list<str>>). Use for a string that represents a list. The field will be split by the first, "splitBy", param, and the result tested that it does not contains any of the items in the provided list.
 
 
 
Full PyDoc Documentation
------------------------
 
Pydoc documentation can be found at: http://htmlpreview.github.io/?https://github.com/kata198/QueryableList/blob/master/doc/QueryableList.html?vers=4

 
Package Contents
       
Base
Builder
constants

 
Classes
       
builtins.list(builtins.object)
QueryableList.Base.QueryableListBase
QueryableListDicts
QueryableListMixed
QueryableListObjs
builtins.object
QueryableList.Builder.QueryBuilder

 
class QueryBuilder(builtins.object)
    QueryBuilder - Build a reusable query that can be applied on multiple lists, or appended
    by several methods.
 
  Methods defined here:
__init__(self)
Initialize self.  See help(type(self)) for accurate signature.
addFilter(self, filterMethod='AND', **kwargs)
addFilter - Add a filter to this query.
 
@param filterMethod  <str> - The filter method to use (AND or OR), default: 'AND'
@param additional args - Filter arguments. @see QueryableListBase.filter
 
@raises ValueError if filterMethod is not one of known methods.
copy(self)
copy - Create a copy of this query.
 
@return <QueryBuilder> - a copy of this query
execute(self, lst)
execute - Execute the series of filters, in order, on the provided list.
 
@param lst <list/ A QueryableList type> - The list to filter. If you already know the types of items within
    the list, you can pick a QueryableList implementing class to get faster results. Otherwise, if a list type that does
    not extend QueryableListBase is provided, QueryableListMixed will be used (Supports both object-like and dict-like items)
 
@return - QueryableList of results. If you provided #lst as a QueryableList type already, that same type will be returned.
    Otherwise, a QueryableListMixed will be returned.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class QueryableListBase(builtins.list)
    QueryableListBase - The base implementation of a QueryableList. 
 
Any implementing classes should only have to implement the "_get_item_value(item, fieldName)" method, to return the value of a given field on an item.
 
You cannot use this directly, instead use one of the implementing classes (like QueryableListDicts or QueryableListObjs), or your own implementing class.
 
 
Method resolution order:
QueryableListBase
builtins.list
builtins.object

Methods defined here:
__add__(self, other)
Return self+value.
__and__(self, other)
__getslice__(self, start, end)
__iadd__(self, other)
Implement self+=value.
__or__(self, other)
__repr__(self)
Return repr(self).
__sub__(self, other)
__xor__(self, other)
all(self)
filter = filterAnd(self, **kwargs)
filterAnd(self, **kwargs)
filter/filterAnd - Performs a filter and returns a QueryableList object of the same type.
 
    All the provided filters must match for the item to be returned.
 
@params are in the format of fieldName__operation=value  where fieldName is the name of the field on any given item, "operation" is one of the given operations (@see main documentation) (e.x. eq, ne, isnull), and value is what is used in the operation.
 
@return - A QueryableList object of the same type, with only the matching objects returned.
filterOr(self, **kwargs)
filterOr - Performs a filter and returns a QueryableList object of the same type.
 
    Anythe provided filters can match for the item to be returned.
 
@params are in the format of fieldName__operation=value  where fieldName is the name of the field on any given item, "operation" is one of the given operations (@see main documentation) (e.x. eq, ne, isnull), and value is what is used in the operation.
 
@return - A QueryableList object of the same type, with only the matching objects returned.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from builtins.list:
__contains__(self, key, /)
Return key in self.
__delitem__(self, key, /)
Delete self[key].
__eq__(self, value, /)
Return self==value.
__ge__(self, value, /)
Return self>=value.
__getattribute__(self, name, /)
Return getattr(self, name).
__getitem__(...)
x.__getitem__(y) <==> x[y]
__gt__(self, value, /)
Return self>value.
__imul__(self, value, /)
Implement self*=value.
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__iter__(self, /)
Implement iter(self).
__le__(self, value, /)
Return self<=value.
__len__(self, /)
Return len(self).
__lt__(self, value, /)
Return self<value.
__mul__(self, value, /)
Return self*value.n
__ne__(self, value, /)
Return self!=value.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__reversed__(...)
L.__reversed__() -- return a reverse iterator over the list
__rmul__(self, value, /)
Return self*value.
__setitem__(self, key, value, /)
Set self[key] to value.
__sizeof__(...)
L.__sizeof__() -- size of L in memory, in bytes
append(...)
L.append(object) -> None -- append object to end
clear(...)
L.clear() -> None -- remove all items from L
copy(...)
L.copy() -> list -- a shallow copy of L
count(...)
L.count(value) -> integer -- return number of occurrences of value
extend(...)
L.extend(iterable) -> None -- extend list by appending elements from the iterable
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
insert(...)
L.insert(index, object) -- insert object before index
pop(...)
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
remove(...)
L.remove(value) -> None -- remove first occurrence of value.
Raises ValueError if the value is not present.
reverse(...)
L.reverse() -- reverse *IN PLACE*
sort(...)
L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*

Data and other attributes inherited from builtins.list:
__hash__ = None

 
class QueryableListDicts(QueryableList.Base.QueryableListBase)
    QueryableListDicts - QueryableList where each item is or extends dict (or implements __getitem__ and __contains__)
 
 
Method resolution order:
QueryableListDicts
QueryableList.Base.QueryableListBase
builtins.list
builtins.object

Methods inherited from QueryableList.Base.QueryableListBase:
__add__(self, other)
Return self+value.
__and__(self, other)
__getslice__(self, start, end)
__iadd__(self, other)
Implement self+=value.
__or__(self, other)
__repr__(self)
Return repr(self).
__sub__(self, other)
__xor__(self, other)
all(self)
filter = filterAnd(self, **kwargs)
filter/filterAnd - Performs a filter and returns a QueryableList object of the same type.
 
    All the provided filters must match for the item to be returned.
 
@params are in the format of fieldName__operation=value  where fieldName is the name of the field on any given item, "operation" is one of the given operations (@see main documentation) (e.x. eq, ne, isnull), and value is what is used in the operation.
 
@return - A QueryableList object of the same type, with only the matching objects returned.
filterAnd(self, **kwargs)
filter/filterAnd - Performs a filter and returns a QueryableList object of the same type.
 
    All the provided filters must match for the item to be returned.
 
@params are in the format of fieldName__operation=value  where fieldName is the name of the field on any given item, "operation" is one of the given operations (@see main documentation) (e.x. eq, ne, isnull), and value is what is used in the operation.
 
@return - A QueryableList object of the same type, with only the matching objects returned.
filterOr(self, **kwargs)
filterOr - Performs a filter and returns a QueryableList object of the same type.
 
    Anythe provided filters can match for the item to be returned.
 
@params are in the format of fieldName__operation=value  where fieldName is the name of the field on any given item, "operation" is one of the given operations (@see main documentation) (e.x. eq, ne, isnull), and value is what is used in the operation.
 
@return - A QueryableList object of the same type, with only the matching objects returned.

Data descriptors inherited from QueryableList.Base.QueryableListBase:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from builtins.list:
__contains__(self, key, /)
Return key in self.
__delitem__(self, key, /)
Delete self[key].
__eq__(self, value, /)
Return self==value.
__ge__(self, value, /)
Return self>=value.
__getattribute__(self, name, /)
Return getattr(self, name).
__getitem__(...)
x.__getitem__(y) <==> x[y]
__gt__(self, value, /)
Return self>value.
__imul__(self, value, /)
Implement self*=value.
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__iter__(self, /)
Implement iter(self).
__le__(self, value, /)
Return self<=value.
__len__(self, /)
Return len(self).
__lt__(self, value, /)
Return self<value.
__mul__(self, value, /)
Return self*value.n
__ne__(self, value, /)
Return self!=value.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__reversed__(...)
L.__reversed__() -- return a reverse iterator over the list
__rmul__(self, value, /)
Return self*value.
__setitem__(self, key, value, /)
Set self[key] to value.
__sizeof__(...)
L.__sizeof__() -- size of L in memory, in bytes
append(...)
L.append(object) -> None -- append object to end
clear(...)
L.clear() -> None -- remove all items from L
copy(...)
L.copy() -> list -- a shallow copy of L
count(...)
L.count(value) -> integer -- return number of occurrences of value
extend(...)
L.extend(iterable) -> None -- extend list by appending elements from the iterable
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
insert(...)
L.insert(index, object) -- insert object before index
pop(...)
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
remove(...)
L.remove(value) -> None -- remove first occurrence of value.
Raises ValueError if the value is not present.
reverse(...)
L.reverse() -- reverse *IN PLACE*
sort(...)
L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*

Data and other attributes inherited from builtins.list:
__hash__ = None

 
class QueryableListMixed(QueryableList.Base.QueryableListBase)
    QueryableListMixed - QueryableList which can contain dict-like items or object-like items 
 
    This is somewhat slower than using QueryableListObjs or QueryableListDicts directly, but use it if you need to mix, or need to support either type.
 
 
Method resolution order:
QueryableListMixed
QueryableList.Base.QueryableListBase
builtins.list
builtins.object

Methods inherited from QueryableList.Base.QueryableListBase:
__add__(self, other)
Return self+value.
__and__(self, other)
__getslice__(self, start, end)
__iadd__(self, other)
Implement self+=value.
__or__(self, other)
__repr__(self)
Return repr(self).
__sub__(self, other)
__xor__(self, other)
all(self)
filter = filterAnd(self, **kwargs)
filter/filterAnd - Performs a filter and returns a QueryableList object of the same type.
 
    All the provided filters must match for the item to be returned.
 
@params are in the format of fieldName__operation=value  where fieldName is the name of the field on any given item, "operation" is one of the given operations (@see main documentation) (e.x. eq, ne, isnull), and value is what is used in the operation.
 
@return - A QueryableList object of the same type, with only the matching objects returned.
filterAnd(self, **kwargs)
filter/filterAnd - Performs a filter and returns a QueryableList object of the same type.
 
    All the provided filters must match for the item to be returned.
 
@params are in the format of fieldName__operation=value  where fieldName is the name of the field on any given item, "operation" is one of the given operations (@see main documentation) (e.x. eq, ne, isnull), and value is what is used in the operation.
 
@return - A QueryableList object of the same type, with only the matching objects returned.
filterOr(self, **kwargs)
filterOr - Performs a filter and returns a QueryableList object of the same type.
 
    Anythe provided filters can match for the item to be returned.
 
@params are in the format of fieldName__operation=value  where fieldName is the name of the field on any given item, "operation" is one of the given operations (@see main documentation) (e.x. eq, ne, isnull), and value is what is used in the operation.
 
@return - A QueryableList object of the same type, with only the matching objects returned.

Data descriptors inherited from QueryableList.Base.QueryableListBase:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from builtins.list:
__contains__(self, key, /)
Return key in self.
__delitem__(self, key, /)
Delete self[key].
__eq__(self, value, /)
Return self==value.
__ge__(self, value, /)
Return self>=value.
__getattribute__(self, name, /)
Return getattr(self, name).
__getitem__(...)
x.__getitem__(y) <==> x[y]
__gt__(self, value, /)
Return self>value.
__imul__(self, value, /)
Implement self*=value.
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__iter__(self, /)
Implement iter(self).
__le__(self, value, /)
Return self<=value.
__len__(self, /)
Return len(self).
__lt__(self, value, /)
Return self<value.
__mul__(self, value, /)
Return self*value.n
__ne__(self, value, /)
Return self!=value.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__reversed__(...)
L.__reversed__() -- return a reverse iterator over the list
__rmul__(self, value, /)
Return self*value.
__setitem__(self, key, value, /)
Set self[key] to value.
__sizeof__(...)
L.__sizeof__() -- size of L in memory, in bytes
append(...)
L.append(object) -> None -- append object to end
clear(...)
L.clear() -> None -- remove all items from L
copy(...)
L.copy() -> list -- a shallow copy of L
count(...)
L.count(value) -> integer -- return number of occurrences of value
extend(...)
L.extend(iterable) -> None -- extend list by appending elements from the iterable
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
insert(...)
L.insert(index, object) -- insert object before index
pop(...)
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
remove(...)
L.remove(value) -> None -- remove first occurrence of value.
Raises ValueError if the value is not present.
reverse(...)
L.reverse() -- reverse *IN PLACE*
sort(...)
L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*

Data and other attributes inherited from builtins.list:
__hash__ = None

 
class QueryableListObjs(QueryableList.Base.QueryableListBase)
    QueryableListObjs - QueryableList where each item extends object (or implements __getattribute__)
 
 
Method resolution order:
QueryableListObjs
QueryableList.Base.QueryableListBase
builtins.list
builtins.object

Methods inherited from QueryableList.Base.QueryableListBase:
__add__(self, other)
Return self+value.
__and__(self, other)
__getslice__(self, start, end)
__iadd__(self, other)
Implement self+=value.
__or__(self, other)
__repr__(self)
Return repr(self).
__sub__(self, other)
__xor__(self, other)
all(self)
filter = filterAnd(self, **kwargs)
filter/filterAnd - Performs a filter and returns a QueryableList object of the same type.
 
    All the provided filters must match for the item to be returned.
 
@params are in the format of fieldName__operation=value  where fieldName is the name of the field on any given item, "operation" is one of the given operations (@see main documentation) (e.x. eq, ne, isnull), and value is what is used in the operation.
 
@return - A QueryableList object of the same type, with only the matching objects returned.
filterAnd(self, **kwargs)
filter/filterAnd - Performs a filter and returns a QueryableList object of the same type.
 
    All the provided filters must match for the item to be returned.
 
@params are in the format of fieldName__operation=value  where fieldName is the name of the field on any given item, "operation" is one of the given operations (@see main documentation) (e.x. eq, ne, isnull), and value is what is used in the operation.
 
@return - A QueryableList object of the same type, with only the matching objects returned.
filterOr(self, **kwargs)
filterOr - Performs a filter and returns a QueryableList object of the same type.
 
    Anythe provided filters can match for the item to be returned.
 
@params are in the format of fieldName__operation=value  where fieldName is the name of the field on any given item, "operation" is one of the given operations (@see main documentation) (e.x. eq, ne, isnull), and value is what is used in the operation.
 
@return - A QueryableList object of the same type, with only the matching objects returned.

Data descriptors inherited from QueryableList.Base.QueryableListBase:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from builtins.list:
__contains__(self, key, /)
Return key in self.
__delitem__(self, key, /)
Delete self[key].
__eq__(self, value, /)
Return self==value.
__ge__(self, value, /)
Return self>=value.
__getattribute__(self, name, /)
Return getattr(self, name).
__getitem__(...)
x.__getitem__(y) <==> x[y]
__gt__(self, value, /)
Return self>value.
__imul__(self, value, /)
Implement self*=value.
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__iter__(self, /)
Implement iter(self).
__le__(self, value, /)
Return self<=value.
__len__(self, /)
Return len(self).
__lt__(self, value, /)
Return self<value.
__mul__(self, value, /)
Return self*value.n
__ne__(self, value, /)
Return self!=value.
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.
__reversed__(...)
L.__reversed__() -- return a reverse iterator over the list
__rmul__(self, value, /)
Return self*value.
__setitem__(self, key, value, /)
Set self[key] to value.
__sizeof__(...)
L.__sizeof__() -- size of L in memory, in bytes
append(...)
L.append(object) -> None -- append object to end
clear(...)
L.clear() -> None -- remove all items from L
copy(...)
L.copy() -> list -- a shallow copy of L
count(...)
L.count(value) -> integer -- return number of occurrences of value
extend(...)
L.extend(iterable) -> None -- extend list by appending elements from the iterable
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
insert(...)
L.insert(index, object) -- insert object before index
pop(...)
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
remove(...)
L.remove(value) -> None -- remove first occurrence of value.
Raises ValueError if the value is not present.
reverse(...)
L.reverse() -- reverse *IN PLACE*
sort(...)
L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*

Data and other attributes inherited from builtins.list:
__hash__ = None

 
Data
        FILTER_METHODS = ('AND', 'OR')
FILTER_METHOD_OR = 'OR'
FILTER_TYPES = {'contains', 'containsAny', 'eq', 'gt', 'gte', 'ieq', ...}
__all__ = ('FILTER_TYPES', 'FILTER_METHOD_OR', 'FILTER_METHOD_OR', 'FILTER_METHODS', 'QueryableListObjs', 'QueryableListDicts', 'QueryableListBase', 'QueryableListMixed', 'QueryBuilder')
__version_tuple__ = (2, 0, 0)