django-ormcache 1.4__py3-none-any.whl

django_ormcache-1.4.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: django-ormcache
+Version: 1.4
+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: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.8, <3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django<6.0,>=4.2
+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"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 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.4.dist-info/RECORD

@@ -0,0 +1,12 @@
+django_ormcache-1.4.dist-info/licenses/LICENSE,sha256=RVUF4JTQmXwGoB2iQ_ywDydZlJ0ILqbUgdN7DxvayiA,1085
+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=uTFu2IUk16_R9hIZrXjuZQAEllrK-xOr1oVtkOh7cI4,5438
+ormcache/signals.py,sha256=4v7Awa3QIH9pGd-VbEk9jcjQvwBABq-29fmn9p6z1lg,147
+ormcache/utils.py,sha256=RSI___JrEEDEzwb-MjhqtDojYvsoX0qD-6gAObNbkBc,1792
+django_ormcache-1.4.dist-info/METADATA,sha256=cvBPGc2_neM4K27oiCMM6dJAxYbZJqM7_nswsSiyn4M,1763
+django_ormcache-1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+django_ormcache-1.4.dist-info/top_level.txt,sha256=aOHDwDLnkCYseV7Vm27Flc3fKlms_YQQnElZh0fSgR8,9
+django_ormcache-1.4.dist-info/RECORD,,

django_ormcache-1.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

django_ormcache-1.4.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Educreations, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

django_ormcache-1.4.dist-info/top_level.txt

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

ormcache/decorators.py

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,149 @@
+from __future__ import unicode_literals
+
+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

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

ormcache/utils.py

@@ -0,0 +1,54 @@
+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)))