Metadata-Version: 1.1
Name: drf-cached-instances
Version: 0.3.2
Summary: Cached instances for Django REST Framework
Home-page: https://github.com/jwhitlock/drf-cached-instances
Author: John Whitlock
Author-email: john@factorialfive.com
License: MPL 2.0
Description: 
        ==========================================
        Cached Instances for Django REST Framework
        ==========================================
        
        
        Speed up `Django REST Framework`_ (DRF) reads by storing instance data in cache.
        
        This code was split from browsercompat_.  You may be interested in
        viewing the browsercompat source code for a full example implementation.
        
        * Code: https://github.com/jwhitlock/drf-cached-instances
        * Free software: `Mozilla Public License Version 2.0`_
        * Documentation: https://drf-cached-instances.readthedocs.org
        
        How it works
        ------------
        In a normal DRF view, a Django queryset is used to load an object or list of
        objects.  A serializer is used to convert the objects into the "native"
        representation, and then a renderer works on this native representation.  If
        the serializer includes data from related models, then multiple database
        queries may be required to generate a native representation.  Some database
        efficiency can be gained by using ``select_related``, but a minimum of one query
        is needed, which is unfortunate for an API with heavy read usage.
        
        This project replaces the Django queryset with a cache-aware proxy class,
        making it possible to serve a read request with zero database requests (to
        retrieve an instance) or one request (to get the primary keys for a list view).
        It is suitable for APIs with heavy read operations and lots of linking between
        related instances.
        
        When using the cache, Django objects are serialized to JSON.  Only the
        attributes needed for the DRF native representation are stored in the cache.
        This include the JSON representation of fields such as foreign keys, reverse
        relations, and dates and times.  These serialized objects are stored by primary
        key in the cache.  When an instance is found in the cache, no database reads
        are needed to render the DRF representation.  If the instance is not in the
        cache, it is serialized and stored, so that future reads will be faster.
        
        The API implementor writes methods to handle JSON serialization, loading from
        the database, and identifying invalid cache entries on changes.  There are a
        few integration points, including a mixin for views to load data from the cache.
        With only a few changes to existing code, your read views could be a lot faster.
        
        Project status
        --------------
        This code is used for the browsercompat_ project, which is in development
        as of September 2015.  The code may change in response to the needs of the
        browsercompat project.  It is expected to stabilize by early 2016.  And,
        like all open source projects, more documentation is needed.
        
        .. _`Django REST Framework`: http://www.django-rest-framework.org
        .. _`browsercompat`: https://github.com/mdn/browsercompat
        .. _`Mozilla Public License Version 2.0`: https://www.mozilla.org/MPL/2.0/
        
        
        
        
        History
        =======
        
        0.3.2 (2015-09-23)
        ------------------
        * Remove deprecation warning in Django 1.8
        * Expand tests to Django master and Django REST Framework 3.2
        * Fix invalid mock.patch tests that break under mock 1.3.0
        * Documentation updates and fixes
        
        0.3.1 (2015-06-16)
        ------------------
        * Move get_object_or_404 to mixin method, to allow easier extending.
        
        0.3.0 (2015-04-09)
        ------------------
        * Tested with Django 1.8
        * Tested with Django REST Framework 2.4, 3.0, and 3.1
        * CachedModel now supports .pk attribute as an alias, usually to the .id
          field. DRF 3 uses .pk to determine if a model is saved to database, and
          returns empty relation data for unsaved fields.
        * cache.delete_all_versions() will delete all cached instances of a model and
          PK. This is useful when changes are made outside of normal requests, such as
          during a data migration.
        
        0.2.0 (2014-12-11)
        ------------------
        * Add ``update_only`` option to ``cache.update_instance``, to support eventual
          consistency for cold caches.
        
        0.1.0 (2014-11-06)
        ------------------
        
        * First release on PyPI.
        
        
Keywords: drf-cached-instances
Platform: UNKNOWN
Classifier: Development Status :: 2 - Pre-Alpha
Classifier: Framework :: Django
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
Classifier: Natural Language :: English
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
