Python: package IndexedRedis

IndexedRedis (version 3.0.0) | index

`# Copyright (c) 2014, 2015 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
`` |  |

Classes
`` |  | __builtin__.object IndexedRedisHelper IndexedRedisDelete IndexedRedisQuery IndexedRedisSave IndexedRedisModel exceptions.Exception(exceptions.BaseException) InvalidModelException
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 __builtin__.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)` 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(__builtin__.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(__builtin__.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. 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. Entries here will be omitted from __repr__ view and replaced with "_BINARY FIELD OF LENGTH N_" where N is the length, in bytes, of the string. *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 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.setEncoding`
| 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) `toDict / asDict - Get a dictionary representation of this model. @param includeMeta - Include metadata in return. For now, this is only pk stored as "_id" @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` deleter = <IndexedRedis.IndexedRedisDelete 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)` 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 = <IndexedRedis.IndexedRedisQuery object> reload(self) `reload - Reload this object from the database. @raises KeyError - if this object has not been saved (no primary key) @return - True if any updates occured, False if data remained the same.` 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.` saver = <IndexedRedis.IndexedRedisSave object> toDict = asDict(self, includeMeta=False) Class methods defined here: connect(cls, redisConnectionParams) from __builtin__.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(cls, newValues) from __builtin__.type validateModel(model) from __builtin__.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 = {}
class IndexedRedisQuery(IndexedRedisHelper)
`` | `IndexedRedisQuery - The query object. This is the return of "Model.objects" and "Model.objects.filter"`
| Method resolution order: IndexedRedisQuery IndexedRedisHelper __builtin__.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 __builtin__.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 - The object 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` 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(exceptions.Exception)
`` | `InvalidModelException - Raised if a model fails validation (not valid)`
| Method resolution order: InvalidModelException exceptions.Exception exceptions.BaseException __builtin__.object Data descriptors defined here: __weakref__ `list of weak references to the object (if defined)` Methods inherited from exceptions.Exception: __init__(...) `x.__init__(...) initializes x; see help(type(x)) for signature` Data and other attributes inherited from exceptions.Exception: __new__ = <built-in method __new__ of type object> `T.__new__(S, ...) -> a new object with type S, a subtype of T` Methods inherited from exceptions.BaseException: __delattr__(...) `x.__delattr__('name') <==> del x.name` __getattribute__(...) `x.__getattribute__('name') <==> x.name` __getitem__(...) `x.__getitem__(y) <==> x[y]` __getslice__(...) `x.__getslice__(i, j) <==> x[i:j] Use of negative indices is not supported.` __reduce__(...) __repr__(...) `x.__repr__() <==> repr(x)` __setattr__(...) `x.__setattr__('name', value) <==> x.name = value` __setstate__(...) __str__(...) `x.__str__() <==> str(x)` __unicode__(...) Data descriptors inherited from exceptions.BaseException: __dict__ args message

Functions
`` |  | getIndexedRedisEncoding = getEncoding() `getEncoding - Get the encoding that IndexedRedis will use @note Aliased as "setIndexedRedisEncoding" so import * has a namespaced name.` isIndexedRedisModel(model) setIndexedRedisEncoding = setEncoding(encoding) `setEncoding - Sets the encoding used by IndexedRedis. @note Aliased as "setIndexedRedisEncoding" so import * has a namespaced name. @param encoding - An encoding (like utf-8)`

Data
`` |  | INDEXED_REDIS_PREFIX = '_ir_|' INDEXED_REDIS_VERSION = (3, 0, 0) INDEXED_REDIS_VERSION_STR = '3.0.0' __all__ = ('INDEXED_REDIS_PREFIX', 'INDEXED_REDIS_VERSION', 'INDEXED_REDIS_VERSION_STR', 'IndexedRedisDelete', 'IndexedRedisHelper', 'IndexedRedisModel', 'IndexedRedisQuery', 'IndexedRedisSave', 'isIndexedRedisModel', 'setIndexedRedisEncoding', 'getIndexedRedisEncoding', 'InvalidModelException') __version__ = '3.0.0'