6.0.4 - ??? ??? ?? ???? - Update runTests.py from 2.1.0 to 3.0.5. See https://github.com/kata198/GoodTests for more details. 6.0.3 - Tue May 23 2017 - Try to make deepcopy, if possible, when setting/fetching values to _origData (that is used to determine if a field has changed and needs to be updated on a save). An example would be a stored json with a inside. If it was updated externally, it would not be seen as an update. Now it will. 6.0.2 - Wed May 17 2017 - Update a bunch of docstrings - Fix "valueType" missing on IRForeign*LinkField .copy and .getReprProperties methods 6.0.1 - Wed May 17 2017 - Fix IRForeignLinkField not showing up in __all__ in fields.foreign, which caused that field to not show up in pydoc 6.0.0 - Tue May 16 2017 Foreign Link Support! (Link/Fetch/Save objects related to other objects, like foreign keys) Also, if upgrading from <5.0.0, see CONVERTING_TO_5.0.0 and ChangeLog for possibly backwards-incompatible changes made in 5.0.0. This release has no backwards incompatible changes. - Add an IRForeignLinkField which allows linking another object by primary key. You can assign it an instance of another model or a primary key, and upon access if not already fetched the parent model will fetch the foreign object and return it. - Add IRForeignMultiLinkField which links one object to a list of other objects. ^ Now that foreign fields are enabled, you can do a 1:1 conversion of your SQL models into IndexedRedis and use them the same way. You CAN get better by designing it for IR, but you WILL get about 5 to 15 times the performance at least just by switching the engine. - Add "cascadeSave" option to saving functions. This flag (default True) will cause all foreign link objects to be saved (inserted or updated), recursively. - Add "cascadeFetch" option to fetching functions. This flag (default False) will cause all foreign link objects to be fetched right away, recursively. By default, they are fetched on first-access. - Add "cascadeObjects" to comparison functions. This controls whether the values on the foreign objects are considered, or if just the pk relationship is considered. - Add "cascadeObjects" to reload function. This controls whether if any foreign objects have changed values, we reload them, or only if the pk was changed. ^ See "Foreign Links" section in README for details now. - Some performance improvements - Add "diff" method to IndexedRedisModel, to compare the values on two objects, and return a dict of "changedField" : ( valueOnFirstObj, valueOnSecondObj ) - Introduce "optional patches", as root-dir "patches" folder. These are optional patches which may match your situation, but won't be included in mainline for some reason. There's a README in that dir which will list a brief explanation of each optional patch, with a more descript in the comment field of the unified diff in the same directory. 5.0.2 - Sat May 13 2017 - Fix where PyDoc could fail to create docs for projects importing IndexedRedis in some circumstances - Ensure that getPrimaryKeys function always returns a list and not sometimes a set (because of upstream Redis package) 5.0.1 - Mon May 1 2017 A conversion document has been created, CONVERTING_TO_5.0.0 in the main directory of this package. Also available online, at https://github.com/kata198/indexedredis/blob/5.0branch/CONVERTING_TO_5.0.0 Use this document to prepare your code for the changes in IndexedRedis 5.0.0. Also please review this Changelog to see new features, bug fixes, etc which will not be listed in the conversion document. - Improve IRPickleField to work with ALL types (including now, strings and bytes) THIS WAS PREVIOUSLY BACKWARDS-INCOMPATIBLE, BUT HAS BEEN MADE COMPATIBLE WITHOUT CHANGES TO YOUR CODE. **DO NOT RUN THE COMPAT FUNCTION SHIPPED WITH 4.1.3 - 4.1.4** - Fixup the way connecting to Redis works. Now, instead of having to define REDIS_CONNECTION_PARAMS on each model, you can call "setDefaultRedisConnectionParams" to set a default connection configuration. This configuration will be used on all models unless REDIS_CONNECTION_PARAMS has been defined and is not empty. - Rename "connect" method to "connectAlt" on IndexedRedisModel (to better convey what it does). Also fix it up to better support multiple alternate connection models - Remove formerly deprecated IndexedRedisModel.BASE64_FIELDS - You've been warned for a while now to use fields.IRField.IRBase64Field **BACKWARDS INCOMPATIBLE** To convert, remove the BASE64_FIELDS array from your model. For any items that are in it, change it in the FIELDS array to be: IRBase64Field as found in from IndexedRedis.fields import IRBase64Field If you already have a type, and were using it to base64 encode that type (like maybe you are compressing then base64 encoding), use a IRFieldChain with base64 as the last element to retain same functionality. Like: IRFieldChain('fieldName', [IRUnicodeField(encoding='utf-16'), IRBase64Field()]) Models with BASE64_FIELDS defined will generate an error upon validation. - Remove IndexedRedis.BINARY_FIELDS - Use the new IRBytesField to act the same way as a BINARY_FIELD did on python3 or python2, use IRField(valueType=bytes) [python 3 only], or use IRRawField for no encoding/decoding at all. You can combine these in a chain just like IRBase64Field. **BACKWARDS INCOMPATIBLE** Models with BINARY_FIELDS defined will generate an error upon validation. - Make copy.copy and copy.deepcopy on an IndexedRedisModel call IndexedRedisModel.copy(False), in order to copy the data, but NOT to have the copy be linked to the database. A save on the copy will be an insert, the parent will remain an update. **BACKWARDS INCOMPATIBLE** - Removed the old, deprecated, compat global "defaultEncoding", retaining just defaultIREncoding. Also, removed deprecated getEncoding and setEncoding, use getDefaultIREncoding and setDefaultIREncoding **BACKWARDS INCOMPATIBLE** You shouldn't notice this. You should be using setDefaultIREncoding or getDefaultIREncoding for default encodings - Introduce a new IRField method called "fromInput", which is like "convert", but is used when the input is guarenteed to NOT come from storage. This will simplify a lot of things, remove some conditional and weird garbage, etc. Constructing objects is now a lot cheapear. - Store "was validated" result for model by the class itself. This allows models with the same keyname (like for conversion, tests, etc) to be validated for each unique class. - Add IRClassicField as a replacement for the plain-string name in FIELDS array. validateModel will automatically convert these to IRClassicField and warn you that these may go away. I have not yet decided if 5.0.0 will generate error or just warning for now. - Default IRField's which have not been set to irNull (instead of empty string). Classic string fields (just a string name, not an IRField object) will retain the empty string. This allows there to be a difference from not-set and empty-string value items (which can be meaningful in several contexts). You can override this by setting defaultValue='something else' (like empty string for previous default on some types, irNull was previous default on others) **BACKWARDS INCOMPATIBLE** Consider if you are testing like if myObj.someField == '' that this will stop working on newly created objects if you aren't setting the value, and expecting that to test such a condition. You can use: if not myObj.someField or if (myObj.someField in ('', b'', irNull) to support both. There is no "compat convert" method for this, because it's unknown if an item was set to default string, or empty value. It's on you to make sure your code either handles both, or you convert your datasets accordingly. You can override the defaultValue by passing defaultValue=X to any IRField or subclass, so to retain old behaviour set defaultValue='' on your fields. - Allow specifying a defaultValue on IRFields. This specifies what the default value will be (was not set) for each field. Every IRField type (Except IRClassicField) supports specifying a default value. - repr on FIELDS now shows the field type and any properties specific to that object. asDict now takes a new param, (strKeys, default False), which will str the keys instead of using the IRField (so if you are pretty-printing the asDict repr, you'll want to use this to prevent the field types from creeping into the printout) - Use "fromInput" every time a field is set on an IndexedRedisModel ( via myModel.xfield = someVal ), same as if it were done via the constructor. This ensures that everything always has an expected type, and can fix some weird issues when folks set unconverted values. ** Backwards Incompatible, if you were doing it wrong before... ;) ** - Rename "convert" to "fromStorage" on IRField. Instead of implementing convert/toStorage/fromInput, the subclasses should implement the underscore-prefixed version, * _fromStorage * _fromInput * _toStorage The non-underscore prefixed versions have been reworked to handle irNull and such. - Change the way irNull is handled, pull pretty well all of the work and flip-flopping out of IndexedRedisModel and make it part of IRField - Ensure that "toIndex" is ALWAYS called when setting indexes. This fixes some issues with hashIndex=True (like that irNull would not previously hash). - Fix some cases where irNull would equal empty string on indexes - Work around a strange "bug" in python that could cause some builtin types to be overriden within the "fields.__init__" module - Make IRBytesField able to index (by hashing the bytes) - Force IRUnicodeField to always have a hashed index, when used as an index **BACKWARDS INCOMPATIBLE** If you were using an IRUnicodeField as an index before, you will need to reindex your data. This is because without hasing, there are issues with many codecs at obtaining the index key. But it's okay, it's simple to reindex and move forward. For any model that has an index on an IRUnicodeField, you must call: MyModel.objects.compat_convertHashedIndexes() This existing method will take care of ensuring that ALL fields are using the proper index format, be it hashed or unhashed, and even takes care of if you accidently let your application run and have a mix of both hashed and unhashed values within the index. Please ensure that your application is offline before executing this function, for each model that may need index conversion. - Update runTests.py to the latest provided with the new version of GoodTests.py - Some minor to moderate cleanups/fixups/optimizations - Add pprint method to both IndexedRedisModel and IRQueryableList. This will pretty-print a dict representation of the model/collection of models, to a given stream (default sys.stdout) - Add __eq__ and __ne__ to IndexedRedisModel, to test if the models are equal (including ID). - Add "hasSameValues" method to IndexedRedisModel, to test if two objects have the same field values, even if the _id primary key is different (i.e. different objects in the database) - Fix where on insert the forStorage data would be put in _origData instead of the converted data, which would cause that field to be listed as needing to be updated if that same object was saved again - Fix a strange bug where some builtin types could be overriden in the IndexedRedis.fields.__init__.py file - Allow specifying an explicit encoding on IRBytesField, to use an alternative than the default encoding - Make IRField's copyable - Add "copyModel" method to IndexedRedisModel as a class method which will return a copy of the model class. This way when converting field types etc you can easily have the same model, copy it, and change one. - Add "name" property to IRField to make it more obvious how to access ( you can still use str(fieldObj) ) - Improve compat_convertHashedIndexes method to work with all field types, and to only touch fields which can both hash and not hash - Update IRFixedPointField to ensure the value is always rounded to #decimalPlaces property, not just after fetch from storage. - Ensure IRRawField always actually does no encoding/decoding, does not support irNull (well, it just treats it same as empty string) - Ensure that IRBytesField always encodes to bytes as soon as you set the value on the object - Ensure that every field type converts the value to its consumable form (so same before-save and after-fetch) when setting the attribute through the dot-operator (myobj.value = X ) or constructor. - Fix bug where toIndex could be calling toStorage twice on a value (which affected things like base64 fields, which could be base64-of-base64 on index). Didn't matter before because base64 fields couldn't index before, but maybe some case hit this bug. - Allow IRFieldChain to index if the right-most field in the chain supports indexing - Added many more tests, like for each field type, lots more usage scenarios, etc. - Make IRCompressedField indexable. The only non-indexable fields now are IRPickleField (Different py2 vs py3 repr), IRRawField (because, no encoding/decoding), and IRField(valueType= (float or dict or json) ) (float because floats are machine-dependent, use IRFixedPointField to define a precision and support indexes. And dicts are not ordered. And json has too many nesting issues. ) - Support "lzma" ( aka "xz" ) compression in IRCompressedField. This is provided by the core in python3. For python2, IndexedRedis also supports backports.lzma and lzmaffi as alternative implementations. You can also explicitly set IndexedRedis.fields.compressed._lzmaMod if you have some other external implementation for python2 - Some cleanups, refactoring, optimizations, simplifications - Rename the fields.bytes fields.unicode and fields.pickle module names to not conflict with builtins. You should be inheriting all your fields like: from IndexedRedis.fields import IRPickleField anyway, so should not notice this change. - More updates on the way Redis connection parameters work. Now -- instead of using the "fixed" defaults of host="127.0.0.1", port=6379, db=0 for connections, IndexedRedis will use what you set through setDefaultRedisConnectionParams. The old defaults remain the initial version of the defaultRedisConnectionParams, so existing code will not break. This means now that models that define their own REDIS_CONNECTION_PARAMS are filled in by the defaultRedisConnectionParams for any missing slots, rather than the aforementioned hard defaults. So for example, for the following: setDefaultRedisConnectionParams( { 'host' : '192.168.1.1' , 'port' : 15000, 'db' : 0 } ) class MySpecialModel(IndexedRedisModel): ... REDIS_CONNECTION_PARAMS = { 'db' : 1 } The default connection for everything will use the first dict (host='192.168.1.1', port=15000, db=0 ). MySpecialModel will override the db portion, but inherit host and port, so MySpecialModel will use (host='192.168.1.1', port=15000, db=1) This only affects connection pools that IndexedRedis manages. If you define your own (by setting the 'connection_pool' key on your connection params), as before you will not get any of the inheritance, connect/disconnect, size management, etc that IndexedRedis would otherwise provide. Some other changes because of this: - getDefaultRedisConnectionParams will return a COPY of the default params, to prevent updates (such that IndexedRedis can track and apply them properly). setDefaultRedisConnectionParams already made copies of the values and set them on the global instance. - Introduce as "clearRedisPools" method which will disconnect and clear the connection_pool ConnectionPools off of all non-managed connections. - Calling setDefaultRedisConnectionParams will now call clearRedisPools, disconnecting any active managed connections and clearing the cached connection_pool associated with each model (except managed pools). This allows inheritance to happen again with the new properties, for example on the above example code, if 'host' was changed in the global, MySpecialModel on next connection will inherit that value (and cache the inherited settings and connection pool). 4.1.4 - Sat Apr 15 2017 - Update READMEs a bit 4.1.3 - Wed Apr 12 2017 ** IMPORTANT -- UPGRADE TO THIS, ADJUST YOUR CODE IN DEV TO PREPARE FOR 5.0.0 ** - Add IRBytesField to work the same as BINARY_FIELDS on both python2 and 3. BINARY_FIELDS is going away in python 5.0.0 - Add the new Pickle field implementation from 5.0.0 (which supports pickling ALL types, but is not compatible). This is named IRNewPickleField and can be found in from IndexedRedis.fields.new_pickle import IRNewPickleField You can change your models to use this field, then on each model call myModel.compat_convertPickleFields() to convert the data form the old form to the new form. Please see the 5.0.0 preview release also released today. At 4.1.3 you can make all your code forwards-compatible (with the exception of pickle fields, which need to be converted post-update) Several things are changing backwards-incompatible, but if you start making changes now, you can run on 4.1.3 and then upgrade to 5.0.0 without issue. 4.1.2 - Wed Apr 12 2017 - Fix some potential encoding issues on python2 - Fixup some potential issues with IRBase64Field on python2 ( keep in mind, BASE64_FIELDS is going away in IndexedRedis 5.0.0! ) - Some minor performance updates in encoding/decoding paths 4.1.1 - Wed Apr 12 2017 - Ensure that the "origData" structure gets updated after a save which performs an insert. It was previously only updated after an "update", but not an insert. This prevents those fields as being seen as changed and updated again if you save the inserted object. - Update "runTests.py" to be version 1.2.3 from GoodTests.py 4.1.0 - Mon Jan 9 2017 - Fix issue where fields that implemented toStorage (complex IRFields) would sometimes have problems doing updates - Fix issue where field values that work as-reference (like lists) would be seen to not update. We now make a copy in the "_origData" dict, if possible. If doesn't support copy.copy, we fallback to value assignment. - Add tests, specifically for IRPickleField with lists where these issues came up 4.0.2 - Fri Nov 18 2016 - Update link to pypi to be pythonhosted.org 4.0.1 - Fri Nov 18 2016 - Update pydoc 4.0.0 - Fri Nov 18 2016 INCOMPLETE CHANGELOG - TODO UPDATE NOTE - This is not a complete changelog, but I haven't had time, and IndexedRedis 4.0 has sat stable and idle for 8 months! It is completely backwards compatible with IndexedRedis 3.0, and there are plenty of code examples in the "tests" directory to get you started on indulging in all the great new features. <3 <3 - Introduce "IRField" as a type, wherein you can define field properties within the field itself. See examples.py track_number as example. - Implement basic client-side type conversion after fetching. The IRField has a valueType, which, when provided with a type, will convert the value to that type. When "bool" is provided, it will accept "1", "True" (case insensitive) as true, and "0", "False" (case insensitive) as false, and raise exception for other values. - Add IRNullType which will be used for non-string null values (like if a valueType=int field has never been set, it will be returned as irNull. irNull only equals other IRNullTypes, so it can be filtered out and is different from int(0) for int fields. IRNull != '' or any other False type, except another IRNull. So like: from IndexedRedis import irNull ... reallyZero = myObjs.filter(age__ne=irNull).filter(age__eq=0) - Split up some functionality across a couple files - Introduce an AdvancedFieldValueTypes module, which contains an example advanced field, for a datetime implementation. Pass this as the "valueType" on an IRField to have it automatically convert to/from a datetime. This stores a string on the backend, and is slightly less efficent than using a property and storing an integer, but more convienant. - Introduce an IRPickleField, use this in place of IRField. It only takes one argument right now, "name". It will pickle data before sending to Redis, and automatically unpickle it upon retrieval. I highly recommend not using this unless you absolutely have to, you are better off designing native models than trying to stuff in objects. - Add compression via compressed fields (IRCompressedField in fields.compressed), using zlib or bz2 - Change python2 to use unicode everywhere, to match python3 behaviour - Don't try to decode every field with the default encoding. Default is still to decode/encoding using that encoding (for items not in BINARY_FIELDS). Now you can use multiple encodings, or no encodings. There is a new field type, fields.IRUnicodeField which allows specifying a non-default encoding. E.x. : FIELDS = [ IRUnicodeField('name_english', encoding='utf-8'), IRUnicodeField('name_jp', encoding='utf-16'), IRUnicodeField('uses_default_encoding') ] You may also use fields.IRRawField which will do no encoding or conversions to/from Redis. - Field Types can implement "toBytes" to allow them to be base64 encoded/decoded, in the event that normal decoding wouldn't work (like the IRUnicodeField type) - Implement IRJsonValue which can be passed to valueType of IRField to automatically convert to json before storing, and convert to a python dict upon retrieval. - Implement IRBase64Field as a field type which will base64-encode before sending and base64-decode after retrieving. This adds a slight processing overhead, but will save space and network traffic. - Implement IRFieldChain, which allows chaining multiple field types together. They will be applied left-to-right when going to redis, and right-to-left when coming from. For example, to compress and base64 encode a json dict, use: FIELDS = [ ... , IRFieldChain('myJsonData', [IRField(valueType=IRJsonValue), IRCompressedField, IRBase64Field]), ] - Implement IRFixedPointField, for safely using floats in filtering and as indexes. You define a fixed precision (decimalPlaces) and values will always be represented/rounded to that many decimal places. This allows values to be defined in a standard away independent of platform. - Ensure "_id" field is always an integer, not mix of either bytes or str - Add destroyModel function to deleter, so you can do MyModel.deleter.destroyModel() to destroy all keys related to the model. Very similar to MyModel.reset([]) but more efficient and direct. - Change MyModel.objects.delete() ( so a delete with no filters, i.e. delete all objects) to call destroyModel. This ensures if you have an invalid model or an incompatible change, you can delete the objects without fetching anything. - Use connection pooling to limit connections to a unqiue Redis server at 32 (default). I've found that in some cases of network disruption, python-Redis can leak connections FAST, and within seconds exhaust all private ports available on a system. - Support hashed indexes, by passing hashIndex=True to an IRField. This will create use an md5 hash in the key in lieu of the field value, which will save memory, network bandwidth, and increase speed where very large values are indexed. - Add "compat_convertHashedIndexes" on IndexedRedisSave, i.e. "MyModel.objects.compat_convertHashedIndexes()" which should be used to reindex a model when any field changes the value of the "hashIndex" property. - Probably a lot more stuff, but this has been sitting around for almost 8 months due to me not having enough time to write up complete documentation!! -3.1.1 - Apr 15 2016 - Fix some 4.0 docs that slipped in to 3.0 series -3.1.0 - Apr 15 2016 - Fix where on updating a model, some operations would occur outside of a transaction. - Fix "reload" method to actually work. It now returns a dict of fields changed -> tuple(old value, new value) - Allow model.saver.save to take a QueryableList (the return of all()) by changing isinstance to issubclass. 3.0.3 - Apr 11 2016 - Fix issue with binary fields, they were always seen as "changed" even when no update was made, which could have caused unnecessary updates and saves - When deleting single objects, do entire operation in a transaction in case a part fails (like if Redis server is shut down) 3.0.0 - Jan 12 2016 - Change return type of functions that used to be a list of instantiated model objects to a QueryableList ( https://github.com/kata198/QueryableList ) which allows easilly chaining complex client-side filtering (beyond just equals and not-equals as the DB-side exists). This is not a backwards-incompatible change, but is forwards-incompatible (i.e. your code may require IndexedRedis>=3.0.0 if you choose to use the client-side filtering) - Restore the repr-view of bytes in __repr__ instead of the "_BINARY DATA OF LENGTH N_" format. 2.9.0 - Dec 28 2015 - Add support for BINARY_FIELDS -- directly storing data as binary. This is a better option in most cases than BASE64_FIELDS, takes much less time, and is more space efficient - Implicitly make the FIELDS defined on models to be sets in __init__ 2.8.1 - (Oct 06 2015) - Fix py3 install 2.8.0 - (Oct 06 2015) - Add "connect" method to IndexedRedisModel, which allows using models with an alternate redis instance than that on the parent model. It returns a "class" that inherits the IndexedRedisModel with the REDIS_CONNECTION_PARAMS updated to reflect those as passed in. 2.7.2 - (Sep 24 2015) - Remove accidental addition of not-finished code 2.7.1 - (Sep 23 2015) - Updates to documentation and examples 2.7.0 - (Sep 23 2015) - Change very basic existing model validation to a one-time call, and validate on more things. - *EXCITING* - Implement BASE64_FIELDS on IndexedRedisModel. Any FIELDS that also show up in BASE64_FIELDS will be base64-encoded before storage and decoded upon retrieval. This makes it possible and very simple to use "bytes" or other binary data. You may need this, for example, to store files or other blobs. 2.6.0 - (Sep 22 2015) - Add copyToExternal which allows copying a model to a redis instance other than the one specified for that model - Add copyAllToExternal which allows copying the results of a filterset to a redis instance other than that specified for the given model - Fix inconsistant returns, pk should always be a string - Rewrote internal save function to make more sense and allow forcing multiple IDs - Add reindex method which will rerun the indexes on a list of models. Use this as MyModel.objects.reindex() if you add a field to INDEXED_FIELDS array which is already existing field to add it to indexes. 2.5.1 - (Sep 11 2015) - Add "exists" method for testing the existance of a primary key - Add MANIFEST.in file (missed in 2.5.0 -- this is only difference) - regen docs - Replace example.py with a copy of test.py... not sure why there were two 2.4.0 - (Jul 7 2015) - Add some more documentation - Cleanup connection handling - Remove undocumented _connection override on IndexedRedisModel 2.4.0 beta (unreleased to public) - (Jul 2 2015) - Add method, isIndexedRedisModel to see if a model extends IndexedRedisModel - Add method, hasUnsavedChanges which returns bool of if there are unsaved changes. Remember, you can see all (local) changes with getUpdatedFields - Implement __str__ and __repr__ Examples of __str__: (Pdb) str(z) '' (Pdb) z.artist = 'New Artist' (Pdb) str(z) '' - Examples of __repr__ - This will build a constructor. eval(repr(obj)) should build the same object. (Pdb) print repr(song) Song(_id="6", album='Super Tracks', description='Super Nintendo', copyright='Copyright 2014 (c) Cheese Industries', title='Nintendo 2', artist='Mega Men', track_number='2', duration='1:55') - Implement a .copy function for copying models. Takes a single argument, copyPrimaryKey. If True, any saves on the copy will change the original model. Keep in mind this may cause sync issues. If False (default) only the data is copied. - Implement __setstate__ and __getstate__ to make objects support being pickled and loaded from pickle strings efficiently. - Implement "reload" function on a model. This fetches any updates from Redis, if available, and returns a list of field names that were updated. 2.3.1 (Jun 27 2015) - Add some more docstring - make getNextID and peekNextID private methods. They should only be used internal. - Regenerate docs - Remove argument on getEncoding -- didn't do anything 2.3.0 (Jun 27 2015) - Change Model.objects.filter(...).delete to fetch minimal data (only indexed fields) instead of entire objects, so deleting is more efficent. - Add getOnlyFields, allOnlyFields, allOnlyIndexedFields, etc for getting partial objects - Increase efficency of getMultiple function - Add more docstrings - Distribute pydoc as /IndexedHtml.html - Allow deleter to delete by primary key only on (Model.deleter) 2.2.2 (Jun 25 2015) - Fix invalid variable 2.2.1 (Jun 25 2015) - Implement getPrimaryKeys (get primary keys at current filter level). Takes optional argument to sort by age - Implement first/last/random for getting oldest/newest/random record - Update documentation a bit 2.1.1 (Jun 21 2015): - Allow deleting directly from a filter object (SomeModel.objects.filter(...).delete) 2.1.0 (Jun 21 2015): - Much better handle unicode in Python 2 - allow changing encoding via a setEncoding function at the global IndexedRedis level 2.0.2 (May 5 2015): - fix typos - fix deleteMultiple 2.0.0 (May 1 2015): - Add support for __ne (not equals) filtering - Make filters default to be copies instead of operating on self, which allows them to be passed to functions but retain original value. Old behaviour can be retained doing .filterInline - Enhance example with more features - Add some docstrings - Fix example where __init__ did not pass args and kwargs to parent and thus broke delete - add asDict method for representation as a dictionary - Change example to use asDict to not print original data - Move module to a standard package setup