IndexedRedis.IRQueryableList = class IRQueryableList(QueryableList.QueryableListObjs)
    IRQueryableList - A QueryableList for IndexedRedis models.
 
Only supports models of one type. Preferably, you should pass "mdl" to init, otherwise
  it will infer from the first object.
 
For performance, there is NOT type checking that all models provided are of the same type,
this is your responsibility. 
 
IndexedRedis will only ever return an IRQueryableList that follow these constraints (always have model defined,
  and only one type of model ever contained), but if you explicitly append objects you need to make sure they
  are of the correct type.
 
 
Method resolution order:
IRQueryableList
QueryableList.QueryableListObjs
QueryableList.Base.QueryableListBase
builtins.list
builtins.object

Methods defined here:
__init__(self, val=None, mdl=None)
__init__ - Create this object
 
@param val - None for empty list, IndexedRedisModel for a one-item list, or a list/tuple or subclass of initial values.
@param mdl - The IndexedRedisModel that this list will contain. Provide this now if you can, otherwise it will be inferred from
  the first item added or present in the list.
 
@raises ValueError if "mdl" is not an IndexedRedisModel
delete(self)
delete - Delete all objects in this list.
 
@return <int> - Number of objects deleted
getModel(self)
getModel - get the IndexedRedisModel associated with this list. If one was not provided in constructor,
  it will be inferred from the first item in the list (if present)
 
  @return <None/IndexedRedisModel> - None if none could be found, otherwise the IndexedRedisModel type of the items in this list.
 
@raises ValueError if first item is not the expected type.
pprint(self, stream=None)
refetch(self)
refetch - Fetch a fresh copy of all items in this list.
        Returns a new list. To update in-place, use "reload".
 
@return IRQueryableList<IndexedRedisModel> - List of fetched items
reload(self)
reload - Reload all objects in this list. 
        Updates in-place. To just fetch all these objects again, use "refetch"
 
@return - List (same order as current objects) of either exception (KeyError) if operation failed,
  or a dict of fields changed -> (old, new)
save(self)
save - Save all objects in this list

Methods inherited from QueryableList.Base.QueryableListBase:
__add__(self, other)
__add__ - Append all items in #other to the tail of #self
 
    + operator
 
  Returns a copy, does not modify this item.
__and__(self, other)
__and__ - Return a QueryableList (of this type) which contains all the elements in #self that are also in #other
 
  Returns a copy
__copy__(self)
__copy__ - Make a copy of this collection
__getslice__(self, start, end)
__getslice__ - Return a "slice" (subset) of the current collection.
 
Returns a copy
__iadd__(self, other)
__iadd__ - Append all items in #other to the tail of #self
 
  += operator
 
  Modifies original
__iand__(self, other)
__ior__(self, other)
__isub__(self, other)
__isub__ - Implement subtract-equals. Removes any items from #self that are present in #other
 
Works inline and modifies #self
__ixor__(self, other)
__or__(self, other)
__or__ - Append any items found in #other which are not already present in #self
 
    Returns a copy
__repr__(self)
__repr__ - Return a code representation of this class
__sub__(self, other)
__sub__ - Implement subtract. Removes any items from #self that are present in #other
 
  Returns a copy, does not modify inline
__xor__(self, other)
__xor__ - Return a QueryableList (of this type) which contains all the elements
  that appear in either #self or #other, but not both.
 
  Returns a copy
all(self)
all - Returns all items in this collection, as the collection type (aka returns a copy of "self").
 
  This method is provided for method parity with ORMs that build a filter set with filter calls,
    and then execute with ".all" (like django or IndexedRedis).
 
  That way you can filter and call ".all()" after, and it doesn't matter if you're hitting the db
    or filtering already-fetched objects, the usage remains the same.
 
@return <self.__class__> - self
count(self)
count - Returns the number of items in this collection.
 
    This is the same as len(...), but is added to be compatible with many server-side ORMs which implement "count" as a function.
 
  @return <int> - Number of items in this collection
customFilter(self, filterFunc)
customFilter - Apply a custom filter to elements and return a QueryableList of matches
 
@param filterFunc <lambda/function< - A lambda/function that is passed an item, and
   returns True if the item matches (will be returned), otherwise False.
 
@return - A QueryableList object of the same type, with only the matching objects returned.
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.
sort_by(self, fieldName, reverse=False)
sort_by - Return a copy of this collection, sorted by the given fieldName.
 
  The fieldName is accessed the same way as other filtering, so it supports custom properties, etc.
 
  @param fieldName <str> - The name of the field on which to sort by
 
  @param reverse <bool> Default False - If True, list will be in reverse order.
 
  @return <QueryableList> - A QueryableList of the same type with the elements sorted based on arguments.

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.
__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
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