Python: package IndexedRedis

IndexedRedis (version 4.0.0) | index

`# Copyright (c) 2014, 2015, 2016 Timothy Savannah under LGPL version 2.1. See LICENSE for more information.
# IndexedRedis A redis-backed very very fast ORM-style framework that supports indexes, and searches with O(1) efficency.
# It has syntax similar to Django and Flask and other ORMs, but is itself unique in many ways.`

Package Contents
`` |  |
IRQueryableList | compat_str | deprecated | fields (package)

Classes
`` |  | builtins.Exception(builtins.BaseException) InvalidModelException builtins.object IndexedRedisHelper IndexedRedisDelete IndexedRedisQuery IndexedRedisSave IndexedRedisModel builtins.str(builtins.object) IndexedRedis.fields.IRField IndexedRedis.fields.chain.IRFieldChain
class IRField(builtins.str)
`` | `IRField - An advanced field @param name <str> - The field name @param valueType <None/type> - The type to use for the value of this field. Default is str (str/unicode will both be unicode). If on python3 and bytes are passed, will be decoded to bytes using default encoding. Using None, the raw data will be used (bytes) on retrieval and for storage. Can be a basic type (like int). Use BINARY_FIELDS array on the model to have value be "bytes" If a type is defined other than default/str/bytes/None , an empty value (empty string in Redis) will be assigned to the IRNullType instance provided in this module, irNull. irNull does not equal anything except irNull (or another IRNullType). Use this to check if a value has been assigned for other types. BE VERY CAREFUL ABOUT USING "float" as a type! It is an inprecise field and can vary from system to system. Instead of using a float, consider using fields.IRFixedPointField, which is indexable.`
| Method resolution order: IRField builtins.str builtins.object Methods defined here: __init__(self, name='', valueType=<class 'str'>) convert(self, value) `convert - Convert the value from storage (string) to the value type. @return - The converted value, or "irNull" if no value was defined (and field type is not default/string)` toStorage(self, value) `toStorage - Convert the value to a string representation for storage. The default implementation will work here for basic types. @param value - The value of the item to convert @return A string value suitable for storing.` Static methods defined here: __new__(self, name='', valueType=None) Data descriptors defined here: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)` Data and other attributes defined here: CAN_INDEX = False Methods inherited from builtins.str: __add__(self, value, /) `Return self+value.` __contains__(self, key, /) `Return key in self.` __eq__(self, value, /) `Return self==value.` __format__(...) `S.__format__(format_spec) -> str Return a formatted version of S as described by format_spec.` __ge__(self, value, /) `Return self>=value.` __getattribute__(self, name, /) `Return getattr(self, name).` __getitem__(self, key, /) `Return self[key].` __getnewargs__(...) __gt__(self, value, /) `Return self>value.` __hash__(self, /) `Return hash(self).` __iter__(self, /) `Implement iter(self).` __le__(self, value, /) `Return self<=value.` __len__(self, /) `Return len(self).` __lt__(self, value, /) `Return self<value.` __mod__(self, value, /) `Return self%value.` __mul__(self, value, /) `Return self*value.n` __ne__(self, value, /) `Return self!=value.` __repr__(self, /) `Return repr(self).` __rmod__(self, value, /) `Return value%self.` __rmul__(self, value, /) `Return self*value.` __sizeof__(...) `S.__sizeof__() -> size of S in memory, in bytes` __str__(self, /) `Return str(self).` capitalize(...) `S.capitalize() -> str Return a capitalized version of S, i.e. make the first character have upper case and the rest lower case.` casefold(...) `S.casefold() -> str Return a version of S suitable for caseless comparisons.` center(...) `S.center(width[, fillchar]) -> str Return S centered in a string of length width. Padding is done using the specified fill character (default is a space)` count(...) `S.count(sub[, start[, end]]) -> int Return the number of non-overlapping occurrences of substring sub in string S[start:end]. Optional arguments start and end are interpreted as in slice notation.` encode(...) `S.encode(encoding='utf-8', errors='strict') -> bytes Encode S using the codec registered for encoding. Default encoding is 'utf-8'. errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors raise a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and 'xmlcharrefreplace' as well as any other name registered with codecs.register_error that can handle UnicodeEncodeErrors.` endswith(...) `S.endswith(suffix[, start[, end]]) -> bool Return True if S ends with the specified suffix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. suffix can also be a tuple of strings to try.` expandtabs(...) `S.expandtabs(tabsize=8) -> str Return a copy of S where all tab characters are expanded using spaces. If tabsize is not given, a tab size of 8 characters is assumed.` find(...) `S.find(sub[, start[, end]]) -> int Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure.` format(...) `S.format(*args, **kwargs) -> str Return a formatted version of S, using substitutions from args and kwargs. The substitutions are identified by braces ('{' and '}').` format_map(...) `S.format_map(mapping) -> str Return a formatted version of S, using substitutions from mapping. The substitutions are identified by braces ('{' and '}').` index(...) `S.index(sub[, start[, end]]) -> int Like S.find() but raise ValueError when the substring is not found.` isalnum(...) `S.isalnum() -> bool Return True if all characters in S are alphanumeric and there is at least one character in S, False otherwise.` isalpha(...) `S.isalpha() -> bool Return True if all characters in S are alphabetic and there is at least one character in S, False otherwise.` isdecimal(...) `S.isdecimal() -> bool Return True if there are only decimal characters in S, False otherwise.` isdigit(...) `S.isdigit() -> bool Return True if all characters in S are digits and there is at least one character in S, False otherwise.` isidentifier(...) `S.isidentifier() -> bool Return True if S is a valid identifier according to the language definition. Use keyword.iskeyword() to test for reserved identifiers such as "def" and "class".` islower(...) `S.islower() -> bool Return True if all cased characters in S are lowercase and there is at least one cased character in S, False otherwise.` isnumeric(...) `S.isnumeric() -> bool Return True if there are only numeric characters in S, False otherwise.` isprintable(...) `S.isprintable() -> bool Return True if all characters in S are considered printable in repr() or S is empty, False otherwise.` isspace(...) `S.isspace() -> bool Return True if all characters in S are whitespace and there is at least one character in S, False otherwise.` istitle(...) `S.istitle() -> bool Return True if S is a titlecased string and there is at least one character in S, i.e. upper- and titlecase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise.` isupper(...) `S.isupper() -> bool Return True if all cased characters in S are uppercase and there is at least one cased character in S, False otherwise.` join(...) `S.join(iterable) -> str Return a string which is the concatenation of the strings in the iterable. The separator between elements is S.` ljust(...) `S.ljust(width[, fillchar]) -> str Return S left-justified in a Unicode string of length width. Padding is done using the specified fill character (default is a space).` lower(...) `S.lower() -> str Return a copy of the string S converted to lowercase.` lstrip(...) `S.lstrip([chars]) -> str Return a copy of the string S with leading whitespace removed. If chars is given and not None, remove characters in chars instead.` partition(...) `S.partition(sep) -> (head, sep, tail) Search for the separator sep in S, and return the part before it, the separator itself, and the part after it. If the separator is not found, return S and two empty strings.` replace(...) `S.replace(old, new[, count]) -> str Return a copy of S with all occurrences of substring old replaced by new. If the optional argument count is given, only the first count occurrences are replaced.` rfind(...) `S.rfind(sub[, start[, end]]) -> int Return the highest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure.` rindex(...) `S.rindex(sub[, start[, end]]) -> int Like S.rfind() but raise ValueError when the substring is not found.` rjust(...) `S.rjust(width[, fillchar]) -> str Return S right-justified in a string of length width. Padding is done using the specified fill character (default is a space).` rpartition(...) `S.rpartition(sep) -> (head, sep, tail) Search for the separator sep in S, starting at the end of S, and return the part before it, the separator itself, and the part after it. If the separator is not found, return two empty strings and S.` rsplit(...) `S.rsplit(sep=None, maxsplit=-1) -> list of strings Return a list of the words in S, using sep as the delimiter string, starting at the end of the string and working to the front. If maxsplit is given, at most maxsplit splits are done. If sep is not specified, any whitespace string is a separator.` rstrip(...) `S.rstrip([chars]) -> str Return a copy of the string S with trailing whitespace removed. If chars is given and not None, remove characters in chars instead.` split(...) `S.split(sep=None, maxsplit=-1) -> list of strings Return a list of the words in S, using sep as the delimiter string. If maxsplit is given, at most maxsplit splits are done. If sep is not specified or is None, any whitespace string is a separator and empty strings are removed from the result.` splitlines(...) `S.splitlines([keepends]) -> list of strings Return a list of the lines in S, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends is given and true.` startswith(...) `S.startswith(prefix[, start[, end]]) -> bool Return True if S starts with the specified prefix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. prefix can also be a tuple of strings to try.` strip(...) `S.strip([chars]) -> str Return a copy of the string S with leading and trailing whitespace removed. If chars is given and not None, remove characters in chars instead.` swapcase(...) `S.swapcase() -> str Return a copy of S with uppercase characters converted to lowercase and vice versa.` title(...) `S.title() -> str Return a titlecased version of S, i.e. words start with title case characters, all remaining cased characters have lower case.` translate(...) `S.translate(table) -> str Return a copy of the string S in which each character has been mapped through the given translation table. The table must implement lookup/indexing via __getitem__, for instance a dictionary or list, mapping Unicode ordinals to Unicode ordinals, strings, or None. If this operation raises LookupError, the character is left untouched. Characters mapped to None are deleted.` upper(...) `S.upper() -> str Return a copy of S converted to uppercase.` zfill(...) `S.zfill(width) -> str Pad a numeric string S with zeros on the left, to fill a field of the specified width. The string S is never truncated.` Static methods inherited from builtins.str: maketrans(x, y=None, z=None, /) `Return a translation table usable for str.translate(). If there is only one argument, it must be a dictionary mapping Unicode ordinals (integers) or characters to Unicode ordinals, strings or None. Character keys will be then converted to ordinals. If there are two arguments, they must be strings of equal length, and in the resulting dictionary, each character in x will be mapped to the character at the same position in y. If there is a third argument, it must be a string, whose characters will be mapped to None in the result.`
class IRFieldChain(IndexedRedis.fields.IRField)
`` |  | Method resolution order: IRFieldChain IndexedRedis.fields.IRField builtins.str builtins.object Methods defined here: __init__(self, name, chainedFields) convert(self, value) `convert - Convert the value from storage (string) to the value type. @return - The converted value, or "irNull" if no value was defined (and field type is not default/string)` toStorage(self, value) `toStorage - Convert the value to a string representation for storage. The default implementation will work here for basic types. @param value - The value of the item to convert @return A string value suitable for storing.` Static methods defined here: __new__(self, name, chainedFields=None) Data and other attributes defined here: CAN_INDEX = False Data descriptors inherited from IndexedRedis.fields.IRField: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)` Methods inherited from builtins.str: __add__(self, value, /) `Return self+value.` __contains__(self, key, /) `Return key in self.` __eq__(self, value, /) `Return self==value.` __format__(...) `S.__format__(format_spec) -> str Return a formatted version of S as described by format_spec.` __ge__(self, value, /) `Return self>=value.` __getattribute__(self, name, /) `Return getattr(self, name).` __getitem__(self, key, /) `Return self[key].` __getnewargs__(...) __gt__(self, value, /) `Return self>value.` __hash__(self, /) `Return hash(self).` __iter__(self, /) `Implement iter(self).` __le__(self, value, /) `Return self<=value.` __len__(self, /) `Return len(self).` __lt__(self, value, /) `Return self<value.` __mod__(self, value, /) `Return self%value.` __mul__(self, value, /) `Return self*value.n` __ne__(self, value, /) `Return self!=value.` __repr__(self, /) `Return repr(self).` __rmod__(self, value, /) `Return value%self.` __rmul__(self, value, /) `Return self*value.` __sizeof__(...) `S.__sizeof__() -> size of S in memory, in bytes` __str__(self, /) `Return str(self).` capitalize(...) `S.capitalize() -> str Return a capitalized version of S, i.e. make the first character have upper case and the rest lower case.` casefold(...) `S.casefold() -> str Return a version of S suitable for caseless comparisons.` center(...) `S.center(width[, fillchar]) -> str Return S centered in a string of length width. Padding is done using the specified fill character (default is a space)` count(...) `S.count(sub[, start[, end]]) -> int Return the number of non-overlapping occurrences of substring sub in string S[start:end]. Optional arguments start and end are interpreted as in slice notation.` encode(...) `S.encode(encoding='utf-8', errors='strict') -> bytes Encode S using the codec registered for encoding. Default encoding is 'utf-8'. errors may be given to set a different error handling scheme. Default is 'strict' meaning that encoding errors raise a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and 'xmlcharrefreplace' as well as any other name registered with codecs.register_error that can handle UnicodeEncodeErrors.` endswith(...) `S.endswith(suffix[, start[, end]]) -> bool Return True if S ends with the specified suffix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. suffix can also be a tuple of strings to try.` expandtabs(...) `S.expandtabs(tabsize=8) -> str Return a copy of S where all tab characters are expanded using spaces. If tabsize is not given, a tab size of 8 characters is assumed.` find(...) `S.find(sub[, start[, end]]) -> int Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure.` format(...) `S.format(*args, **kwargs) -> str Return a formatted version of S, using substitutions from args and kwargs. The substitutions are identified by braces ('{' and '}').` format_map(...) `S.format_map(mapping) -> str Return a formatted version of S, using substitutions from mapping. The substitutions are identified by braces ('{' and '}').` index(...) `S.index(sub[, start[, end]]) -> int Like S.find() but raise ValueError when the substring is not found.` isalnum(...) `S.isalnum() -> bool Return True if all characters in S are alphanumeric and there is at least one character in S, False otherwise.` isalpha(...) `S.isalpha() -> bool Return True if all characters in S are alphabetic and there is at least one character in S, False otherwise.` isdecimal(...) `S.isdecimal() -> bool Return True if there are only decimal characters in S, False otherwise.` isdigit(...) `S.isdigit() -> bool Return True if all characters in S are digits and there is at least one character in S, False otherwise.` isidentifier(...) `S.isidentifier() -> bool Return True if S is a valid identifier according to the language definition. Use keyword.iskeyword() to test for reserved identifiers such as "def" and "class".` islower(...) `S.islower() -> bool Return True if all cased characters in S are lowercase and there is at least one cased character in S, False otherwise.` isnumeric(...) `S.isnumeric() -> bool Return True if there are only numeric characters in S, False otherwise.` isprintable(...) `S.isprintable() -> bool Return True if all characters in S are considered printable in repr() or S is empty, False otherwise.` isspace(...) `S.isspace() -> bool Return True if all characters in S are whitespace and there is at least one character in S, False otherwise.` istitle(...) `S.istitle() -> bool Return True if S is a titlecased string and there is at least one character in S, i.e. upper- and titlecase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise.` isupper(...) `S.isupper() -> bool Return True if all cased characters in S are uppercase and there is at least one cased character in S, False otherwise.` join(...) `S.join(iterable) -> str Return a string which is the concatenation of the strings in the iterable. The separator between elements is S.` ljust(...) `S.ljust(width[, fillchar]) -> str Return S left-justified in a Unicode string of length width. Padding is done using the specified fill character (default is a space).` lower(...) `S.lower() -> str Return a copy of the string S converted to lowercase.` lstrip(...) `S.lstrip([chars]) -> str Return a copy of the string S with leading whitespace removed. If chars is given and not None, remove characters in chars instead.` partition(...) `S.partition(sep) -> (head, sep, tail) Search for the separator sep in S, and return the part before it, the separator itself, and the part after it. If the separator is not found, return S and two empty strings.` replace(...) `S.replace(old, new[, count]) -> str Return a copy of S with all occurrences of substring old replaced by new. If the optional argument count is given, only the first count occurrences are replaced.` rfind(...) `S.rfind(sub[, start[, end]]) -> int Return the highest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure.` rindex(...) `S.rindex(sub[, start[, end]]) -> int Like S.rfind() but raise ValueError when the substring is not found.` rjust(...) `S.rjust(width[, fillchar]) -> str Return S right-justified in a string of length width. Padding is done using the specified fill character (default is a space).` rpartition(...) `S.rpartition(sep) -> (head, sep, tail) Search for the separator sep in S, starting at the end of S, and return the part before it, the separator itself, and the part after it. If the separator is not found, return two empty strings and S.` rsplit(...) `S.rsplit(sep=None, maxsplit=-1) -> list of strings Return a list of the words in S, using sep as the delimiter string, starting at the end of the string and working to the front. If maxsplit is given, at most maxsplit splits are done. If sep is not specified, any whitespace string is a separator.` rstrip(...) `S.rstrip([chars]) -> str Return a copy of the string S with trailing whitespace removed. If chars is given and not None, remove characters in chars instead.` split(...) `S.split(sep=None, maxsplit=-1) -> list of strings Return a list of the words in S, using sep as the delimiter string. If maxsplit is given, at most maxsplit splits are done. If sep is not specified or is None, any whitespace string is a separator and empty strings are removed from the result.` splitlines(...) `S.splitlines([keepends]) -> list of strings Return a list of the lines in S, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends is given and true.` startswith(...) `S.startswith(prefix[, start[, end]]) -> bool Return True if S starts with the specified prefix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. prefix can also be a tuple of strings to try.` strip(...) `S.strip([chars]) -> str Return a copy of the string S with leading and trailing whitespace removed. If chars is given and not None, remove characters in chars instead.` swapcase(...) `S.swapcase() -> str Return a copy of S with uppercase characters converted to lowercase and vice versa.` title(...) `S.title() -> str Return a titlecased version of S, i.e. words start with title case characters, all remaining cased characters have lower case.` translate(...) `S.translate(table) -> str Return a copy of the string S in which each character has been mapped through the given translation table. The table must implement lookup/indexing via __getitem__, for instance a dictionary or list, mapping Unicode ordinals to Unicode ordinals, strings, or None. If this operation raises LookupError, the character is left untouched. Characters mapped to None are deleted.` upper(...) `S.upper() -> str Return a copy of S converted to uppercase.` zfill(...) `S.zfill(width) -> str Pad a numeric string S with zeros on the left, to fill a field of the specified width. The string S is never truncated.` Static methods inherited from builtins.str: maketrans(x, y=None, z=None, /) `Return a translation table usable for str.translate(). If there is only one argument, it must be a dictionary mapping Unicode ordinals (integers) or characters to Unicode ordinals, strings or None. Character keys will be then converted to ordinals. If there are two arguments, they must be strings of equal length, and in the resulting dictionary, each character in x will be mapped to the character at the same position in y. If there is a third argument, it must be a string, whose characters will be mapped to None in the result.`
class IndexedRedisDelete(IndexedRedisHelper)
`` | `IndexedRedisDelete - Used for removing objects. Called when Model.delete is used. Except for advanced usage, this is probably for internal only.`
| Method resolution order: IndexedRedisDelete IndexedRedisHelper builtins.object Methods defined here: deleteByPk(self, pk) `deleteByPk - Delete object associated with given primary key` deleteMultiple(self, objs) `deleteMultiple - Delete multiple objects @param objs - List of objects @return - Number of objects deleted` deleteMultipleByPks(self, pks) `deleteMultipleByPks - Delete multiple objects given their primary keys @param pks - List of primary keys @return - Number of objects deleted` deleteOne(self, obj, conn=None) `deleteOne - Delete one object @param obj - object to delete @param conn - Connection to reuse, or None @return - number of items deleted (0 or 1)` destroyModel(self) `destroyModel - Destroy everything related to this model in one swoop. Same effect as Model.reset([]) - Except slightly more efficient. This function is called if you do Model.objects.delete() with no filters set. @return - Number of keys deleted. Note, this is NOT number of models deleted, but total keys.` Methods inherited from IndexedRedisHelper: __init__(self, mdl) `Internal constructor @param mdl - IndexedRedisModel implementer` Data descriptors inherited from IndexedRedisHelper: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)`
class IndexedRedisHelper(builtins.object)
`` | `IndexedRedisHelper - internal helper class which ties together all the actions`
| Methods defined here: __init__(self, mdl) `Internal constructor @param mdl - IndexedRedisModel implementer` Data descriptors defined here: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)`
class IndexedRedisModel(builtins.object)
`` | `IndexedRedisModel - This is the model you should extend. **Required Fields:** *FIELDS* - REQUIRED. a list of strings which name the fields that can be used for storage. Can also be IRField or an implementing type (see AdvancedFields below) Example: ['Name', 'Description', 'Model', 'Price'] *INDEXED_FIELDS* - a list of strings containing the names of fields that will be indexed. Can only filter on indexed fields. Adds insert/delete time. Contents must also be in FIELDS. Example: ['Name', 'Model'] *BASE64_FIELDS* - A list of strings which name the fields that will be stored as base64-encoded strings. All entries must also be present in FIELDS. Example: ['data', 'blob'] *BINARY_FIELDS* - A list of strings which name the fields that will be stored as unencoded binary data. All entries must also be present in FIELDS. *KEY_NAME* - REQUIRED. A unique name name that represents this model. Think of it like a table name. Example: 'Items' *REDIS_CONNECTION_PARAMS* - provides the arguments to pass into "redis.Redis", to construct a redis object. Usage ----- Usage is very similar to Django or Flask. **Query:** Calling .filter or .filterInline builds a query/filter set. Use one of the *Fetch* methods described below to execute a query. objects = SomeModel.objects.filter(param1=val).filter(param2=val).all() **Save:** obj = SomeModel(field1='value', field2='value') obj.save() **Delete Using Filters:** SomeModel.objects.filter(name='Bad Man').delete() **Delete Individual Objects:** obj.delete() **Atomic Dataset Replacement:** There is also a powerful method called "reset" which will **atomically** replace all elements belonging to a model. This is useful for cache-replacement, etc. lst = [SomeModel(...), SomeModel(..)] SomeModel.reset(lst) For example, you could have a SQL backend and a cron job that does complex queries (or just fetches the same models) and does an atomic replace every 5 minutes to get massive performance boosts in your application. Filter objects by SomeModel.objects.filter(key=val, key2=val2) and get objects with .all Example: SomeModel.objects.filter(name='Tim', colour='purple').filter(number=5).all() **Fetch Functions**: Building filtersets do not actually fetch any data until one of these are called (see API for a complete list). All of these functions act on current filterset. Example: matchingObjects = SomeModel.objects.filter(...).all() all - Return all objects matching this filter allOnlyFields - Takes a list of fields and only fetches those fields, using current filterset delete - Delete objects matching this filter count - Get the count of objects matching this filter first - Get the oldest record with current filters last - Get the newest record with current filters random - Get a random element with current filters getPrimaryKeys - Gets primary keys associated with current filters **Filter Functions** These functions add filters to the current set. "filter" returns a copy, "filterInline" acts on that object. filter - Add additional filters, returning a copy of the filter object (moreFiltered = filtered.filter(key2=val2)) filterInline - Add additional filters to current filter object. **Global Fetch functions** These functions are available on SomeModel.objects and don't use any filters (they get specific objects): get - Get a single object by pk getMultiple - Get multiple objects by a list of pks **Model Functions** Actual objects contain methods including: save - Save this object (create if not exist, otherwise update) delete - Delete this object getUpdatedFields - See changes since last fetch Advanced Fields --------------- IndexedRedis since version 4.0 allows you to pass elements of type IRField (extends str) in the FIELDS element. Doing so allows you to specify certain properties about the field. Example: FIELDS = [ 'name', IRField('age', valueType=int), 'birthday' ] **Field Name** The first argument is the string of the field name. **Type** You can have a value automatically cast to a certain type (which saves a step if you need to filter further through the QueryableList results, like age__gt=15) by passing that type as "valueType". (e.x. IRField('age', valueType=int)) If you use "bool", the values 0 and case insensitive string 'false' will result in False, and 1 or 'true' will result in True. Be careful using floats, different hosts will have different floating point representations for the same value. Don't expect floats to work cross-platform. Use a fixed point number as the string type ( like myFixedPoint = '%2.5f' %( 10.12345 ) ) ** Null Values ** For any type except strings (including the default type, string), a null value is assigned irNull (of type IRNullType). irNull does not equal empty string, or anything except another irNull. This is to destinguish say, no int assigned vs int(0) You can check a typed field against the "irNull" variable found in the IndexedRedis or IndexedRedis.fields. from IndexedRedis import irNull .. e.x. notDangerFive = myResults.filter(dangerLevel__ne=irNull).filter(dangerLevel__ne=5) or even notDangerFive = MyModel.objects.filter(dangerLevel__ne=irNull).filter(dangerLevel__ne=5).all() Encodings --------- IndexedRedis will use by default your system default encoding (sys.getdefaultencoding), unless it is ascii (python2) in which case it will default to utf-8. You may change this via IndexedRedis.setDefaultIREncoding`
| Methods defined here: __getstate__(self) `pickle uses this` __init__(self, *args, **kwargs) `__init__ - Set the values on this object. MAKE SURE YOU CALL THE SUPER HERE, or else things will not work.` __repr__(self) `__repr__ - Returns a string of the constructor/params to recreate this object. Example: objCopy = eval(repr(obj)) @return - String of python init call to recreate this object` __setstate__(self, stateDict) `pickle uses this` __str__(self) `__str__ - Returns a string representation of this object's state. See implementation. @return <str>- Some samples: (Pdb) str(z) '<Song obj _id=24 at 0x7f3c6a3a4490>' (Pdb) z.artist = 'New Artist' (Pdb) str(z) '<Song obj _id=24 (Unsaved Changes) at 0x7f3c6a3a4490>'` asDict(self, includeMeta=False, forStorage=False) `toDict / asDict - Get a dictionary representation of this model. @param includeMeta - Include metadata in return. For now, this is only pk stored as "_id" @param convertValueTypes <bool> - default True. If False, fields with fieldValue defined will be converted to that type. Use True when saving, etc, as native type is always either str or bytes. @return - Dictionary reprensetation of this object and all fields` copy(self, copyPrimaryKey=False) `copy - Copies this object. @param copyPrimaryKey <bool> default False - If True, any changes to the copy will save over-top the existing entry in Redis. If False, only the data is copied, and nothing is saved.` delete(self) `delete - Delete this object` getPk(self) `getPk - Gets the internal primary key associated with this object` getUpdatedFields(self) `getUpdatedFields - See changed fields. @return - a dictionary of fieldName : tuple(old, new). fieldName may be a string or may implement IRField (which implements string, and can be used just like a string)` hasUnsavedChanges(self) `hasUnsavedChanges - Check if any unsaved changes are present in this model, or if it has never been saved. @return <bool> - True if any fields have changed since last fetch, or if never saved. Otherwise, False` objects reload(self) `reload - Reload this object from the database, overriding any local changes and merging in any updates. @raises KeyError - if this object has not been saved (no primary key) @return - Dict with the keys that were updated. Key is field name that was updated, and value is tuple of (old value, new value).` save(self) `save - Save this object` saveToExternal(self, redisCon) `saveToExternal - Saves this object to a different Redis than that specified by REDIS_CONNECTION_PARAMS on this model. @param redisCon <dict/redis.Redis> - Either a dict of connection params, a la REDIS_CONNECTION_PARAMS, or an existing Redis connection. If you are doing a lot of bulk copies, it is recommended that you create a Redis connection and pass it in rather than establish a new connection with each call. @note - You will generate a new primary key relative to the external Redis environment. If you need to reference a "shared" primary key, it is better to use an indexed field than the internal pk.` toDict = asDict(self, includeMeta=False, forStorage=False) Class methods defined here: connect(redisConnectionParams) from builtins.type `connect - Create a class of this model which will use an alternate connection than the one specified by REDIS_CONNECTION_PARAMS on this model. @param redisConnectionParams <dict> - Dictionary of arguments to redis.Redis, same as REDIS_CONNECTION_PARAMS. @return - A class that can be used in all the same ways as the existing IndexedRedisModel, but that connects to a different instance.` reset(newValues) from builtins.type validateModel() from builtins.type `validateModel - Class method that validates a given model is implemented correctly. Will only be validated once, on first model instantiation. @param model - Implicit of own class @return - True @raises - InvalidModelException if there is a problem with the model, and the message contains relevant information.` Data descriptors defined here: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)` Data and other attributes defined here: BASE64_FIELDS = [] BINARY_FIELDS = [] FIELDS = [] INDEXED_FIELDS = [] KEY_NAME = None REDIS_CONNECTION_PARAMS = {} deleter = <IndexedRedis.IndexedRedisDelete object> saver = <IndexedRedis.IndexedRedisSave object>
class IndexedRedisQuery(IndexedRedisHelper)
`` | `IndexedRedisQuery - The query object. This is the return of "Model.objects" and "Model.objects.filter"`
| Method resolution order: IndexedRedisQuery IndexedRedisHelper builtins.object Methods defined here: __init__(self, *args, **kwargs) all(self) `all - Get the underlying objects which match the filter criteria. Example: objs = Model.objects.filter(field1='value', field2='value2').all() @return - Objects of the Model instance associated with this query.` allByAge(self) `allByAge - Get the underlying objects which match the filter criteria, ordered oldest -> newest If you are doing a queue or just need the head/tail, consider .first() and .last() instead. @return - Objects of the Model instance associated with this query, sorted oldest->newest` allOnlyFields(self, fields) `allOnlyFields - Get the objects which match the filter criteria, only fetching given fields. @param fields - List of fields to fetch @return - Partial objects with only the given fields fetched` allOnlyIndexedFields(self) `allOnlyIndexedFields - Get the objects which match the filter criteria, only fetching indexed fields. @return - Partial objects with only the indexed fields fetched` count(self) `count - gets the number of records matching the filter criteria Example: theCount = Model.objects.filter(field1='value').count()` delete(self) `delete - Deletes all entries matching the filter criteria` exists(self, pk) `exists - Tests whether a record holding the given primary key exists. @param pk - Primary key (see getPk method) Example usage: Waiting for an object to be deleted without fetching the object or running a filter. This is a very cheap operation. @return <bool> - True if object with given pk exists, otherwise False` filter(self, **kwargs) `filter - Add filters based on INDEXED_FIELDS having or not having a value. Note, no objects are actually fetched until .all() is called Use the field name [ model.objects.filter(some_field='value')] to filter on items containing that value. Use the field name suffxed with '__ne' for a negation filter [ model.objects.filter(some_field__ne='value') ] Example: query = Model.objects.filter(field1='value', field2='othervalue') objs1 = query.filter(something__ne='value').all() objs2 = query.filter(something__ne=7).all() @returns - A copy of this object, with the additional filters. If you want to work inline on this object instead, use the filterInline method.` filterInline(self, **kwargs) `filterInline - @see IndexedRedisQuery.filter. This is the same as filter, but works inline on this object instead of creating a copy. Use this is you do not need to retain the previous filter object.` first(self) `First - Returns the oldest record (lowerst primary key) with current filters. This makes an efficient queue, as it only fetches a single object. @return - Instance of Model object, or None if no items match current filters` get(self, pk) `get - Get a single value with the internal primary key. @param pk - internal primary key (can be found via .getPk() on an item)` getMultiple(self, pks) `getMultiple - Gets multiple objects with a single atomic operation @param pks - list of internal keys` getMultipleOnlyFields(self, pks, fields) `getMultipleOnlyFields - Gets only certain fields from a list of primary keys. For working on entire filter set, see allOnlyFields pks list<str> - Primary Keys fields list<str> - List of fields return - List of partial objects with only fields applied` getMultipleOnlyIndexedFields(self, pks) `getMultipleOnlyIndexedFields - Get only the indexed fields on an object. This is the minimum to delete. @param pks - List of primary keys @return - List of objects with only indexed fields fetched` getOnlyFields(self, pk, fields) `getOnlyFields - Gets only certain fields from a paticular primary key. For working on entire filter set, see allOnlyFields pk - Primary Key fields list<str> - List of fields return - Partial objects with only fields applied` getOnlyIndexedFields(self, pk) `getOnlyIndexedFields - Get only the indexed fields on an object. This is the minimum to delete. @param pk - Primary key @return - Object with only indexed fields fetched.` getPrimaryKeys(self, sortByAge=False) `getPrimaryKeys - Returns all primary keys matching current filterset. @param sortByAge <bool> - If False, return will be a set and may not be ordered. If True, return will be a list and is guarenteed to represent objects oldest->newest @return <set> - A set of all primary keys associated with current filters.` last(self) `Last - Returns the newest record (highest primary key) with current filters. This makes an efficient queue, as it only fetches a single object. @return - Instance of Model object, or None if no items match current filters` random(self) `Random - Returns a random record in current filterset. @return - Instance of Model object, or None if no items math current filters` reindex(self) `reindex - Reindexes the objects matching current filterset. Use this if you add/remove a field to INDEXED_FIELDS` Data descriptors inherited from IndexedRedisHelper: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)`
class IndexedRedisSave(IndexedRedisHelper)
`` | `IndexedRedisClass - Class used to save objects. Used with Model.save is called. Except for advanced usage, this is probably for internal only.`
| Method resolution order: IndexedRedisSave IndexedRedisHelper builtins.object Methods defined here: reindex(self, objs, conn=None) `reindex - Reindexes a given list of objects. Probably you want to do Model.objects.reindex() instead of this directly. @param objs list<IndexedRedisModel> - List of objects to reindex @param conn <redis.Redis or None> - Specific Redis connection or None to reuse` save(self, obj, usePipeline=True, forceID=False, conn=None) `save - Save an object associated with this model. **Interal Function!!** You probably want to just do object.save() instead of this. @param obj <IndexedRedisModel or list<IndexedRedisModel> - The object to save, or a list of objects to save @param usePipeline - Use a pipeline for saving. You should always want this, unless you are calling this function from within an existing pipeline. @param forceID - if not False, force ID to this. If obj is list, this is also list. Forcing IDs also forces insert. Up to you to ensure ID will not clash. @param conn - A connection or None @note - if no ID is specified @return - List of pks` saveMultiple(self, objs) `saveMultiple - Save a list of objects using a pipeline. @param objs < list<IndexedRedisModel> > - List of objects to save` Methods inherited from IndexedRedisHelper: __init__(self, mdl) `Internal constructor @param mdl - IndexedRedisModel implementer` Data descriptors inherited from IndexedRedisHelper: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)`
class InvalidModelException(builtins.Exception)
`` | `InvalidModelException - Raised if a model fails validation (not valid)`
| Method resolution order: InvalidModelException builtins.Exception builtins.BaseException builtins.object Data descriptors defined here: __weakref__ `list of weak references to the object (if defined)` Methods inherited from builtins.Exception: __init__(self, /, *args, **kwargs) `Initialize self. See help(type(self)) for accurate signature.` __new__(*args, **kwargs) from builtins.type `Create and return a new object. See help(type) for accurate signature.` Methods inherited from builtins.BaseException: __delattr__(self, name, /) `Implement delattr(self, name).` __getattribute__(self, name, /) `Return getattr(self, name).` __reduce__(...) __repr__(self, /) `Return repr(self).` __setattr__(self, name, value, /) `Implement setattr(self, name, value).` __setstate__(...) __str__(self, /) `Return str(self).` with_traceback(...) `Exception.with_traceback(tb) -- set self.__traceback__ to tb and return self.` Data descriptors inherited from builtins.BaseException: __cause__ `exception cause` __context__ `exception context` __dict__ __suppress_context__ __traceback__ args

Functions
`` |  | getDefaultIREncoding() `getEncoding - Get the default encoding that IndexedRedis will use for all field data. You can override this on a per-field basis by using an IRField (such as IRUnicodeField or IRRawField) @return <str> - Default encoding string` isIndexedRedisModel(model) setDefaultIREncoding(encoding) `setDefaultIREncoding - Sets the default encoding used by IndexedRedis. This will be the default encoding used for field data. You can override this on a per-field basis by using an IRField (such as IRUnicodeField or IRRawField) @param encoding - An encoding (like utf-8)` toggleDeprecatedMessages(enabled) `toggleDeprecatedMessages - Normally, a deprecated message will log up to once per message. Call toggleDeprecatedMessages(False) to turn them off altogether (like on a Production codebase) @param enabled <bool> - False to disable deprecated messages, otherwise True.`

Data
`` |  | INDEXED_REDIS_PREFIX = '_ir_|' INDEXED_REDIS_VERSION = (4, 0, 0) INDEXED_REDIS_VERSION_STR = '4.0.0' __all__ = ('INDEXED_REDIS_PREFIX', 'INDEXED_REDIS_VERSION', 'INDEXED_REDIS_VERSION_STR', 'IndexedRedisDelete', 'IndexedRedisHelper', 'IndexedRedisModel', 'IndexedRedisQuery', 'IndexedRedisSave', 'isIndexedRedisModel', 'setIndexedRedisEncoding', 'getIndexedRedisEncoding', 'InvalidModelException', 'fields', 'IRField', 'IRFieldChain', 'irNull', 'setDefaultIREncoding', 'getDefaultIREncoding', 'toggleDeprecatedMessages') irNull = IRNullType()