django-ormcache 1.2.2__py2.py3-none-any.whl → 1.3__py2.py3-none-any.whl

django_ormcache-1.3.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.1
+Name: django-ormcache
+Version: 1.3
+Summary: ORM cache for Django
+Home-page: https://github.com/educreations/django-ormcache
+Author: Corey Farwell
+Author-email: coreyf@rwell.org
+Maintainer: Educreations Engineering
+Maintainer-email: engineering@educreations.com
+License: MIT
+Project-URL: Homepage, https://github.com/educreations/django-ormcache
+Project-URL: Issues, https://github.com/educreations/django-ormcache/issues
+Project-URL: Changelog, https://github.com/educreations/django-ormcache/blob/master/CHANGES.md
+Keywords: cache django
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.7, <4
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django <5.0,>=2.0
+Requires-Dist: six
+Provides-Extra: test
+Requires-Dist: tox ; extra == 'test'
+Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: pytest-django ; extra == 'test'
+Requires-Dist: flake8 ; extra == 'test'
+
+# Django ORMCache
+
+A cache manager mixin that provides some caching of objects for the ORM.
+
+
+# Installation / Setup / Usage
+
+TODO
+
+
+# Testing
+
+Run the tests with:
+
+```
+pip install -e .[tests]
+tox
+```
+
+# License
+
+Copyright © 2024, Educreations, Inc under the [MIT](LICENSE).

django_ormcache-1.3.dist-info/RECORD

@@ -0,0 +1,5 @@
+django_ormcache-1.3.dist-info/LICENSE,sha256=RVUF4JTQmXwGoB2iQ_ywDydZlJ0ILqbUgdN7DxvayiA,1085
+django_ormcache-1.3.dist-info/METADATA,sha256=uiHFtyu46ZCR89bC0GNJEqGv5l9-l8KEeR9kY87z5_Y,1471
+django_ormcache-1.3.dist-info/WHEEL,sha256=0XQbNV6JE5ziJsWjIU8TRRv0N6SohNonLWgP86g5fiI,109
+django_ormcache-1.3.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+django_ormcache-1.3.dist-info/RECORD,,

{django_ormcache-1.2.2.dist-info → django_ormcache-1.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: setuptools (70.2.0)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

django_ormcache-1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+

django_ormcache-1.2.2.dist-info/METADATA

@@ -1,57 +0,0 @@
-Metadata-Version: 2.1
-Name: django-ormcache
-Version: 1.2.2
-Summary: ORM cache for Django
-Home-page: https://github.com/educreations/django-ormcache
-Author: Corey Farwell
-Author-email: coreyf@rwell.org
-Maintainer: Educreations Engineering
-Maintainer-email: engineering@educreations.com
-License: MIT
-Keywords: cache django
-Platform: UNKNOWN
-Classifier: Framework :: Django
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Software Development
-Requires-Dist: Django (<4.2,>=1.9)
-
-Django ORMCache
-===============
-
-.. image:: https://travis-ci.org/educreations/django-ormcache.svg?branch=master
-   :target: https://travis-ci.org/educreations/django-ormcache
-
-.. image:: https://coveralls.io/repos/github/educreations/django-ormcache/badge.svg?branch=master
-   :target: https://coveralls.io/github/educreations/django-ormcache?branch=master
-
-A cache manager mixin that provides some caching of objects for the ORM.
-
-
-Installation / Setup / Usage
-----------------------------
-
-TODO
-
-
-Testing
--------
-
-Run the tests with:
-
-.. code:: bash
-
-    pip install -r requirements.txt
-    python runtests.py
-
-
-License
--------
-
-Copyright © 2017, Educreations, Inc under the `MIT <LICENSE>`_.
-
-

django_ormcache-1.2.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-ormcache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ormcache/decorators.py,sha256=2ZMqQTIJlK0uLCf4Egk5rZhp4WrBzeGyaIScWpT3yp4,1822
-ormcache/managers.py,sha256=s1r9FxqN6pyxxM22aUqdI9IK22a37tTPbtB-gLBlNrQ,2034
-ormcache/models.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ormcache/queryset.py,sha256=oFAfJtRjk8In0FrGtjrOfrlWYOuh_cSEHLxlo3RbcfA,5398
-ormcache/signals.py,sha256=4v7Awa3QIH9pGd-VbEk9jcjQvwBABq-29fmn9p6z1lg,147
-ormcache/utils.py,sha256=RSI___JrEEDEzwb-MjhqtDojYvsoX0qD-6gAObNbkBc,1792
-django_ormcache-1.2.2.dist-info/LICENSE,sha256=RVUF4JTQmXwGoB2iQ_ywDydZlJ0ILqbUgdN7DxvayiA,1085
-django_ormcache-1.2.2.dist-info/METADATA,sha256=40fZpcqPBD2dL33rL7rhSwUXhaLyg9ZG5XOB78IucCA,1431
-django_ormcache-1.2.2.dist-info/WHEEL,sha256=z9j0xAa_JmUKMpmz72K0ZGALSM_n-wQVmGbleXx2VHg,110
-django_ormcache-1.2.2.dist-info/top_level.txt,sha256=aOHDwDLnkCYseV7Vm27Flc3fKlms_YQQnElZh0fSgR8,9
-django_ormcache-1.2.2.dist-info/RECORD,,

django_ormcache-1.2.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-ormcache

ormcache/decorators.py

@@ -1,57 +0,0 @@
-from hashlib import sha1
-import logging
-
-from django.core.cache import cache
-from django.utils.decorators import wraps
-
-log = logging.getLogger(__name__)
-
-
-def cache_result(ttl=60 * 5, key=None):
-    """
-    Cache the result of a function call using Django's caching mechanism.
-
-    If the decorated function returns None, cache_result raises a
-    RuntimeException (as the cache returns None to indicate a miss).
-
-    Note: If a key is not passed, the decorator will hash the function
-    signature. The ordering of function parameters is important. e.g.:
-    * myFunction(x=1, y=2)
-    * myFunction(y=2, x=1)
-    * myFunction(1, 2)
-    will each be cached separately.
-
-    Note: Does not automatically handle invalidation
-
-    Usage:
-    --------------------------------------------------------------------------
-    @cache_result
-    def my_expensive_method(param1, param2, param3):
-        ....
-        return expensive_result
-    --------------------------------------------------------------------------
-    """
-
-    def decorator(func):
-        @wraps(func)
-        def inner(*args, **kwargs):
-            key_ = key
-            if key_ is None:
-                func_signature = (
-                    str(func.__module__) + str(func.__name__) + str(args) + str(kwargs)
-                ).encode("utf8")
-                key_ = sha1(func_signature).hexdigest()
-            result = cache.get(key_)
-            if result is None:
-                result = func(*args, **kwargs)
-                if result is None:
-                    log.error(
-                        "Function decorated by @cache_result returned " "None",
-                        extra={"function": func.__name__},
-                    )
-                cache.set(key_, result, ttl)
-            return result
-
-        return inner
-
-    return decorator

ormcache/managers.py

@@ -1,59 +0,0 @@
-from django.db.models.signals import class_prepared, post_delete, post_save
-from django.utils.functional import cached_property
-
-from ormcache.queryset import CachedQuerySet
-
-
-class CachedManagerMixin(object):
-    @cached_property
-    def __cache_enabled(self):
-        return getattr(self.model, "cache_enabled", False)
-
-    def __require_cache(func):
-        def wrapper(self, *args, **kwargs):
-            if not self.__cache_enabled:
-                error = "Caching is not enabled on {}".format(str(type(self)))
-                raise RuntimeError(error)
-            return func(self, *args, **kwargs)
-
-        return wrapper
-
-    @__require_cache
-    def from_ids(self, ids, lookup="pk__in", **kwargs):
-        queryset = self.get_queryset()
-        return queryset.from_ids(ids, lookup=lookup, **kwargs)
-
-    @__require_cache
-    def invalidate(self, *args, **kwargs):
-        return self.get_queryset().invalidate(*args, **kwargs)
-
-    @__require_cache
-    def cache_key(self, *args, **kwargs):
-        return self.get_queryset().cache_key(*args, **kwargs)
-
-    # Django overrides
-
-    def contribute_to_class(self, model, name):
-        """Override Django builtin"""
-        super(CachedManagerMixin, self).contribute_to_class(model, name)
-        class_prepared.connect(self.__class_prepared_cache, sender=model)
-
-    def get_queryset(self):
-        """Override Django builtin"""
-        if self.__cache_enabled:
-            return CachedQuerySet(self.model)
-        else:
-            return super(CachedManagerMixin, self).get_queryset()
-
-    # Signals
-
-    def __class_prepared_cache(self, sender, **kwargs):
-        if self.__cache_enabled:
-            post_save.connect(self.__post_save_cache, sender=self.model, weak=False)
-            post_delete.connect(self.__post_delete_cache, sender=self.model, weak=False)
-
-    def __post_save_cache(self, instance, created, **kwargs):
-        self.invalidate(instance.pk, recache=True)
-
-    def __post_delete_cache(self, instance, **kwargs):
-        self.invalidate(instance.pk)

ormcache/queryset.py

@@ -1,148 +0,0 @@
-try:
-    from collections.abc import Iterable
-except ImportError:
-    from collections import Iterable
-
-import logging
-
-import django
-from django.core.cache import cache
-from django.db.models.query import QuerySet
-
-if django.VERSION >= (1, 8):
-    from django.db.models.expressions import Col
-    from django.db.models.lookups import Exact
-elif django.VERSION >= (1, 7):
-    from django.db.models.lookups import Exact
-    from django.db.models.sql.datastructures import Col
-
-from ormcache.signals import cache_hit, cache_missed, cache_invalidated  # noqa
-
-log = logging.getLogger(__name__)
-
-
-class CachedQuerySet(QuerySet):
-
-    __MAXIMUM_CACHE_KEY_LENGTH = 250
-    __CACHE_FOREVER = 2592000  # http://ur1.ca/egyvu
-
-    def get(self, *args, **kwargs):
-        """
-        Adds a layer of caching around the Manager's built in 'get()' method.
-        Will only cache if 'pk' or 'id' is used in kwargs. Results from the
-        'get()' method will be cached indefinitely (30 days) until invalidated.
-        """
-
-        orig_kwargs = kwargs.copy()
-
-        # If this queryset is filtered by a single column and no arguments
-        # were passed to get(), treat the queryset filter as an argument to
-        # get(). This lets Model.objects.filter(pk=42).get() work like
-        # Model.objects.get(pk=42).
-        can_ignore_filter = False
-        if django.VERSION >= (1, 7) and not kwargs:
-            if len(self.query.where) == 1 and not self.query.where.negated:
-                (child,) = self.query.where.children
-                if isinstance(child, Exact) and isinstance(child.lhs, Col):
-                    can_ignore_filter = True
-                    kwargs[child.lhs.target.attname] = child.rhs
-            elif (
-                len(args) == 1
-                and len(args[0].children) == 1
-                and len(args[0].children[0]) == 2
-                and args[0].children[0][0] == "id"
-            ):
-                can_ignore_filter = True
-                kwargs[args[0].children[0][0]] = args[0].children[0][1]
-
-        # Don't access cache if using a filtered queryset
-        if self.query.where and not can_ignore_filter:
-            return super(CachedQuerySet, self).get(*args, **orig_kwargs)
-
-        # Don't access cache if using a deferred queryset
-        if (
-            len(self.query.deferred_loading[0]) > 0
-            or not self.query.deferred_loading[1]
-        ):
-            return super(CachedQuerySet, self).get(*args, **orig_kwargs)
-
-        # Get the cache key from the model name and pk
-        if "pk" in kwargs:
-            pk = kwargs["pk"]
-        elif "pk__exact" in kwargs:
-            pk = kwargs["pk__exact"]
-        elif "id" in kwargs:
-            pk = kwargs["id"]
-        elif "id__exact" in kwargs:
-            pk = kwargs["id__exact"]
-        else:
-            return super(CachedQuerySet, self).get(*args, **orig_kwargs)
-
-        key = self.cache_key(pk)
-
-        # Retrieve (or set) the item in the cache
-        item = cache.get(key)
-        if item is None:
-            cache_missed.send(sender=self.model)
-            item = super(CachedQuerySet, self).get(*args, **orig_kwargs)
-            cache.set(key, item, self.__CACHE_FOREVER)
-        else:
-            cache_hit.send(sender=self.model)
-
-        return item
-
-    def from_ids(self, ids, lookup="pk__in"):
-        assert isinstance(ids, Iterable)
-
-        cache_keys = [self.cache_key(id_) for id_ in ids]
-
-        instances = cache.get_many(cache_keys).values()
-        cached_dict = {i.id: i for i in instances if i}
-        uncached_ids = set(ids) - set(cached_dict.keys())
-
-        # If there are uncached instances, retrieve and cache them
-        if len(uncached_ids) > 0:
-            uncached = self.filter(**{lookup: uncached_ids})
-
-            # Add the uncached instances to the existing instances
-            cached_dict.update((i.id, i) for i in uncached)
-
-            # Cache the uncached instances
-            to_cache = {self.cache_key(i.pk): i for i in uncached}
-            cache.set_many(to_cache, self.__CACHE_FOREVER)
-
-        return [cached_dict[id_] for id_ in ids if id_ in cached_dict]
-
-    def cache_key(self, pk):
-        """Generate the cache key for an individual model"""
-        key = "{}-pk:{}".format(self.model.__name__, pk)
-
-        # We shouldn't have keys that are crazy long. This might mean
-        # we get duplicates though
-        key = key[: self.__MAXIMUM_CACHE_KEY_LENGTH]
-
-        return key
-
-    def invalidate(self, pk, recache=False):
-        """Invalidate a single item in the cache"""
-        key = self.cache_key(pk)
-        cache_invalidated.send(sender=self.model)
-        if recache is True:
-            try:
-                entry = super(CachedQuerySet, self).get(pk=pk)
-            except self.model.DoesNotExist:
-                log.info(
-                    "Unable to recache model during invalidate",
-                    exc_info=True,
-                    extra={"data": {"model": self.model, "pk": pk}},
-                )
-            except self.model.MultipleObjectsReturned:
-                log.error(
-                    "Error retrieving single entry from database",
-                    exc_info=True,
-                    extra={"data": {"model": self.model, "pk": pk}},
-                )
-            else:
-                cache.set(key, entry, self.__CACHE_FOREVER)
-        else:
-            cache.delete(key)

ormcache/signals.py

@@ -1,6 +0,0 @@
-import django.dispatch
-
-
-cache_hit = django.dispatch.Signal()
-cache_missed = django.dispatch.Signal()
-cache_invalidated = django.dispatch.Signal()

ormcache/utils.py

@@ -1,54 +0,0 @@
-try:
-    from django.db.models.fields.related import SingleRelatedObjectDescriptor
-except ImportError:
-    from django.db.models.fields.related_descriptors import (
-        ReverseOneToOneDescriptor as SingleRelatedObjectDescriptor,
-    )
-
-
-def _distinct(l):
-    """Given an iterable will return a list of all distinct values."""
-    return list(set(l))
-
-
-def attach_foreignkey(objects, field):
-    """
-    Similar to the disqus's attach_foreignkey, but pulls items from the cache
-    if caching is enabled on the model
-    """
-    is_foreignkey = isinstance(field, SingleRelatedObjectDescriptor)
-
-    if not is_foreignkey:
-        field = field.field
-        accessor = "_%s_cache" % field.name
-        model = field.remote_field.model
-        lookup = "%s__in" % "pk"
-        column = field.column
-        key = "pk"
-    else:
-        accessor = field.cache_name
-        field = field.related.field
-        model = field.model
-        lookup = "%s__in" % field.name
-        column = "pk"
-        key = field.column
-
-    # Ensure values are unique, do not contain already present values, and
-    # are not missing values specified in select_related
-    values = _distinct(
-        getattr(o, column) for o in objects if getattr(o, accessor, False) is False
-    )
-    if not values:
-        return
-
-    # Pull instances from cache if caching is enabled. This conditional logic
-    # can be removed when the UserManager inherits BaseManager
-    if getattr(model, "cache_enabled", False) is True:
-        instances = model.objects.from_ids(values, lookup=lookup)
-    else:
-        instances = model.objects.filter(**{lookup: values})
-
-    instances_dict = {getattr(i, key): i for i in instances}
-
-    for obj in objects:
-        setattr(obj, accessor, instances_dict.get(getattr(obj, column)))