Django Cacheops

https://github.com/suor/django-cacheops
Admin
Django Cacheops provides a powerful toolkit for caching Django ORM queries and invalidating them...
Tokens:32,148
Snippets:446
Trust Score:9.4
License:BSD-3-Clause
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install django-cacheops

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/00-START-HERE.md

Install the package via pip.

```bash
pip install django-cacheops
```

--------------------------------

### Cache key format examples

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/types.md

Examples of generated cache keys for different ORM and function caching scenarios.

```text
# QuerySet: User.objects.filter(active=True).get(id=1)
default:q:a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5

# Function: @cached def get_stats()
default:c:f1e2d3c4b5a6z7y8x9w0v1u2t3s4r5

# ORM: @cached_as(User.objects.all()) def count_users()
default:as:e1d2c3b4a5z6y7x8w9v0u1t2s3r4q5

# Invalidation: User with status='active'
default:conj:auth_user:status=active
```

--------------------------------

### Manual Installation of Cacheops

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/installation-setup.md

Methods for manually invoking the installation process in settings, URLs, or application configurations.

```python
from cacheops import install_cacheops

# In settings.py or urls.py
install_cacheops()

# Or in app config
from django.apps import AppConfig

class MyAppConfig(AppConfig):
    def ready(self):
        from cacheops import install_cacheops
        install_cacheops()
```

--------------------------------

### Install transaction support

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/installation-setup.md

Initialize transaction support by calling install_cacheops() in settings or an AppConfig.

```python
# settings.py or in an AppConfig.ready()

from cacheops import install_cacheops

install_cacheops()
```

```python
from django.apps import AppConfig
from cacheops import install_cacheops

class MyAppConfig(AppConfig):
    name = 'myapp'
    
    def ready(self):
        install_cacheops()
```

--------------------------------

### Install Cacheops Function Signature

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/installation-setup.md

The main function signature for installing cacheops functionality.

```python
def install_cacheops() -> None
```

--------------------------------

### Use FileCache Implementation

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/simple-caching.md

Example of using FileCache for function result caching.

```python
from cacheops import FileCache

file_cache = FileCache('/var/cache/myapp', timeout=3600)

@file_cache.cached(timeout=1800)
def compute_report(date):
    return Report.objects.filter(date=date).values_list('id', flat=True)

report = compute_report('2024-01-01')
```

--------------------------------

### Use RedisCache Implementation

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/simple-caching.md

Example of using RedisCache for function result caching.

```python
from cacheops import cache

@cache.cached(timeout=300)
def get_user_by_email(email):
    return User.objects.get(email=email)

user = get_user_by_email('test@example.com')
```

--------------------------------

### Implement a CACHEOPS_PREFIX Callable

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/types.md

Example implementation of a prefix function using the PrefixQuery object to generate cache keys.

```python
def get_prefix(prefix_query):
    if prefix_query.func:
        return f'func:{prefix_query.func.__name__}:'
    elif prefix_query.table:
        return f'table:{prefix_query.table}:'
    return ''

CACHEOPS_PREFIX = get_prefix
```

--------------------------------

### Example of whitespace stripping

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/template-tags.md

Demonstrates how template content is stored in the cache after whitespace removal.

```django
{% cached 3600 "content" %}
    <div>
        <p>Content</p>
    </div>
{% endcached %}

<!-- Stored in cache as: <div>\n<p>Content</p>\n</div> -->
```

--------------------------------

### Implement a JSON Serializer

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/types.md

Example implementation of a custom serializer using the json module, configured via CACHEOPS_SERIALIZER.

```python
import json

class JsonSerializer:
    HIGHEST_PROTOCOL = 1
    
    def dumps(self, obj):
        return json.dumps(obj).encode('utf-8')
    
    def loads(self, data):
        return json.loads(data.decode('utf-8'))
    
    def dump(self, obj, file):
        json.dump(obj, file)
    
    def load(self, file):
        return json.load(file)

# In settings
CACHEOPS_SERIALIZER = 'myapp.serializers.JsonSerializer'
```

--------------------------------

### Define a Model Profile Configuration

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/types.md

Example of a dictionary structure used to configure caching behavior for a specific model.

```python
profile = {
    'ops': {'get', 'fetch', 'count'},
    'timeout': 3600,
    'local_get': False,
    'db_agnostic': True,
    'lock': True,
}
```

--------------------------------

### Implement caching in Django

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/00-START-HERE.md

Examples of automatic ORM caching, manual function result caching, and view caching.

```python
# Automatic caching via configuration
user = User.objects.get(id=1)  # Cached automatically
users = User.objects.all()      # Cached automatically

# Manual caching
@cache.cached(timeout=3600)
def expensive_calculation():
    return User.objects.count()

# Template caching
@cached_view(timeout=3600)
def my_view(request):
    return render(request, 'template.html')
```

--------------------------------

### Handle cache_read signal

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/signals.md

Example of connecting a receiver to the cache_read signal to monitor cache hits and misses.

```python
from django.dispatch import receiver
from cacheops.signals import cache_read

@receiver(cache_read)
def on_cache_read(sender, func, hit, **kwargs):
    if hit:
        print(f"Cache hit: {func or sender}")
    else:
        print(f"Cache miss: {func or sender}")

# Use in views
from cacheops import cache

@cache.cached(timeout=3600)
def expensive_function():
    return "result"

# Emits cache_read signal on call
expensive_function()
```

--------------------------------

### Import standard Django constants

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/types.md

Imports the default database alias and maximum get results constant from Django's query module.

```python
from django.db import DEFAULT_DB_ALIAS
from django.db.models.query import MAX_GET_RESULTS
```

--------------------------------

### Connect Custom Signal Handlers

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/signals.md

Register signal handlers within the ready method of an AppConfig to ensure they are connected when the application starts.

```python
from django.apps import AppConfig
from django.dispatch import receiver

class MyAppConfig(AppConfig):
    name = 'myapp'
    
    def ready(self):
        from cacheops.signals import cache_read, cache_invalidated
        
        @receiver(cache_read)
        def on_cache_read(sender, func, hit, **kwargs):
            # Custom handling
            pass
        
        @receiver(cache_invalidated)
        def on_cache_invalidated(sender, obj_dict, **kwargs):
            # Custom handling
            pass
```

--------------------------------

### Example usage of cached tag with extra parameters

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/template-tags.md

Caching a post list fragment using multiple extra parameters for the cache key.

```django
{% cached 1800 "post_list" category.id "page" page_num %}
    {% for post in posts %}
        <article>{{ post.title }}</article>
    {% endfor %}
{% endcached %}
```

--------------------------------

### Example usage of cached tag

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/template-tags.md

Caching a user sidebar fragment with a specific timeout and user ID as an extra parameter.

```django
{% load cacheops %}

{% cached 3600 "user_sidebar" user.id %}
    <div class="sidebar">
        <h3>{{ user.name }}</h3>
        <p>Points: {{ user.total_points }}</p>
    </div>
{% endcached %}
```

--------------------------------

### Execute reap_conjs programmatically

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/cache-reaping.md

Examples of calling the reap_conjs function with various parameters for standard, dry-run, or aggressive cleanup.

```python
from cacheops.reaper import reap_conjs

# Scan and remove expired keys
reap_conjs()

# Dry run to see what would be removed
reap_conjs(dry_run=True)

# Aggressive reaping with smaller sets
reap_conjs(min_conj_set_size=500, chunk_size=2000)
```

--------------------------------

### Reap invalidation sets via management command

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/cache-reaping.md

Usage examples for the reapconjs management command to clean up invalidation sets from the CLI.

```bash
python manage.py reapconjs [--chunk-size N] [--min-size N] [--dry-run]
```

```bash
# Standard reaping
python manage.py reapconjs

# Dry run to see impact
python manage.py reapconjs --dry-run

# Aggressive reaping
python manage.py reapconjs --chunk-size 2000 --min-size 500
```

--------------------------------

### Check transaction dirty state

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/transaction-support.md

Example usage of checking if a specific database connection has pending write operations.

```python
from cacheops.transaction import transaction_states

is_dirty = transaction_states.is_dirty(['default'])
if is_dirty:
    print("Transaction has writes")
```

--------------------------------

### Configure cache operations

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/types.md

Demonstrates importing ALL_OPS and using it within the CACHEOPS configuration dictionary.

```python
from cacheops.conf import ALL_OPS

print(ALL_OPS)  # {'get', 'fetch', 'count', 'aggregate', 'exists'}

# Use in configuration
CACHEOPS = {
    'auth.user': {'ops': ALL_OPS, 'timeout': 3600},
    'myapp.post': {'ops': ALL_OPS - {'exists'}, 'timeout': 1800},
}
```

--------------------------------

### Configure development environment settings

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/installation-setup.md

Sets short timeouts for testing and enables degradation on failure to prevent errors if Redis is unavailable.

```python
# settings.py (development)

CACHEOPS = {
    '*.*': {'timeout': 300},  # Short timeout for faster testing
}

CACHEOPS_DEFAULTS = {
    'timeout': 300,
}

CACHEOPS_DEGRADE_ON_FAILURE = True  # Don't fail if Redis unavailable
```

--------------------------------

### Configure Django settings for cacheops

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/00-START-HERE.md

Add cacheops to INSTALLED_APPS, define the Redis connection, and initialize the cache.

```python
# settings.py
INSTALLED_APPS = ['cacheops']

CACHEOPS_REDIS = "redis://localhost:6379/1"

CACHEOPS = {
    '*.*': {'ops': 'all', 'timeout': 3600},
}

# In apps.py or settings.py
from cacheops import install_cacheops
install_cacheops()
```

--------------------------------

### Configure Redis key prefixes

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/types.md

Demonstrates how to define CACHEOPS_PREFIX to avoid key collisions across different environments.

```python
# Example with default (empty) prefix
CACHEOPS_PREFIX = lambda q: ''
# Key: q:a1b2c3d4...

# Example with environment prefix
def env_prefix(q):
    return os.environ.get('ENV', 'dev') + ':'

# Key in dev: dev:q:a1b2c3d4...
# Key in prod: prod:q:a1b2c3d4...
```

--------------------------------

### Example usage of invalidate_fragment

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/template-tags.md

Manually invalidating cached template fragments from Python code.

```python
from cacheops.templatetags.cacheops import invalidate_fragment

# Invalidate fragment from template
invalidate_fragment('user_sidebar', user.id)
invalidate_fragment('post_list', category.id, 'page', 1)
```

--------------------------------

### Configure django-cacheops

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/README.md

Define Redis connection and cache rules in settings.py, then initialize via install_cacheops().

```python
# settings.py
INSTALLED_APPS = ['cacheops']

CACHEOPS_REDIS = "redis://localhost:6379/1"

CACHEOPS = {
    'auth.user': {'ops': {'get', 'fetch'}, 'timeout': 900},
    'auth.*': {'ops': 'all', 'timeout': 3600},
    '*.*': {'timeout': 3600},
}

# In apps.py or settings.py
from cacheops import install_cacheops
install_cacheops()
```

--------------------------------

### Disabling Transaction Support

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/transaction-support.md

Provides the approach to prevent the installation of cacheops transaction signal handlers.

```python
from django.core.signals import setting_changed

# Disconnect handlers
from cacheops.transaction import (
    install_cacheops_transaction_support,
    AtomicMixIn,
    CursorWrapperMixin
)
from cacheops.utils import monkey_mix

# Don't call install_cacheops_transaction_support()
# or use CACHEOPS_ENABLED = False
```

--------------------------------

### Example usage of cached_as tag

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/template-tags.md

Caching a fragment that invalidates based on the provided active_posts queryset.

```django
{% load cacheops %}

{% cached_as active_posts 3600 "active_posts_sidebar" %}
    <div class="recent-posts">
        {% for post in active_posts %}
            <a href="{{ post.get_absolute_url }}">{{ post.title }}</a>
        {% endfor %}
    </div>
{% endcached_as %}
```

--------------------------------

### Handle cache_invalidated signal

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/signals.md

Example of connecting a receiver to the cache_invalidated signal to log invalidation events.

```python
from django.dispatch import receiver
from cacheops.signals import cache_invalidated

@receiver(cache_invalidated)
def on_cache_invalidated(sender, obj_dict, **kwargs):
    if sender is User:
        print(f"User cache invalidated: {obj_dict}")
    elif sender is None:
        print("Full cache flush")

# Triggered on save
user = User.objects.get(id=1)
user.email = 'new@example.com'
user.save()  # Emits cache_invalidated
```

--------------------------------

### install_cacheops()

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/installation-setup.md

The main function to initialize cacheops. It monkey-patches the Django QuerySet, sets up signal handlers for invalidation, and configures cache profiles.

```APIDOC
## install_cacheops()

### Description
Initializes the cacheops library. This function is typically called automatically by Django app initialization, but can be invoked manually.

### Signature
`def install_cacheops() -> None`

### Usage
```python
from cacheops import install_cacheops

# Manually trigger installation
install_cacheops()
```
```

--------------------------------

### Clear Cache Between Tests

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/installation-setup.md

Ensures a clean state by invalidating all cache entries during test setup and teardown.

```python
from django.test import TestCase
from cacheops import invalidate_all

class MyTestCase(TestCase):
    def setUp(self):
        invalidate_all()
    
    def tearDown(self):
        invalidate_all()
```

--------------------------------

### Configure Cacheops Defaults

Source: https://github.com/suor/django-cacheops/blob/master/README.rst

Setting global default cache configurations using CACHEOPS_DEFAULTS.

```python
CACHEOPS_DEFAULTS = {
    'timeout': 60*60
}
CACHEOPS = {
    'auth.user': {'ops': 'get', 'timeout': 60*15},
    'auth.*': {'ops': ('fetch', 'get')},
    'auth.permission': {'ops': 'all'},
    '*.*': {},
}
```

--------------------------------

### Use cached_as tag in Jinja2

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/template-tags.md

Syntax and example for caching template blocks tied to a specific queryset for invalidation.

```jinja2
{% cached_as queryset, timeout=3600, extra="fragment_name" %}
    ... content ...
{% endcached_as %}
```

```jinja2
{% cached_as active_users, timeout=3600, extra="online_count" %}
    <div class="stats">
        <p>Online users: {{ active_users.count() }}</p>
    </div>
{% endcached_as %}
```

--------------------------------

### Define Configuration Patterns

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/README.md

Specify caching rules using model-based pattern matching in the CACHEOPS dictionary.

```python
# Pattern matching: specific model
'auth.user': {...}

# Pattern matching: all models in app
'auth.*': {...}

# Pattern matching: all models
'*.*': {...}

# Explicitly disable
'myapp.temporary': None
```

--------------------------------

### Use cached tag in Jinja2

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/template-tags.md

Syntax and examples for caching template blocks with a timeout and optional extra identifiers.

```jinja2
{% cached timeout=3600, extra="fragment_name" %}
    ... content ...
{% endcached %}
```

```jinja2
{% cached timeout=3600, extra="user_profile" %}
    <div class="profile">
        <h1>{{ user.name }}</h1>
        <p>Email: {{ user.email }}</p>
    </div>
{% endcached %}
```

```jinja2
{% cached timeout=1800, extra=("posts", category.id, page) %}
    {% for post in posts %}
        <article>{{ post.title }}</article>
    {% endfor %}
{% endcached %}
```

--------------------------------

### Configure production environment settings

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/installation-setup.md

Defines specific cache operations and timeouts for models, along with production-grade Redis connection settings.

```python
# settings.py (production)

CACHEOPS_REDIS = {
    'host': 'redis.internal',
    'port': 6379,
    'db': 1,
    'socket_timeout': 5,
    'socket_connect_timeout': 5,
}

CACHEOPS = {
    'auth.user': {
        'ops': {'get', 'fetch'},
        'timeout': 3600,
        'lock': True,
    },
    'auth.permission': {
        'ops': 'all',
        'timeout': 7200,
        'local_get': True,
    },
    'myapp.post': {
        'ops': {'fetch', 'count'},
        'timeout': 1800,
        'lock': True,
    },
    '*.*': {
        'timeout': 3600,
    },
}

CACHEOPS_DEFAULTS = {
    'timeout': 3600,
}

CACHEOPS_DEGRADE_ON_FAILURE = True
```

--------------------------------

### Define multiple model caching rules

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/orm-caching.md

Demonstrates applying different caching configurations to multiple models and using a wildcard for global defaults.

```python
CACHEOPS = {
    'auth.user': {
        'ops': {'get', 'fetch'},
        'timeout': 3600,
        'local_get': True,
    },
    'auth.permission': {
        'ops': 'all',
        'timeout': 7200,
    },
    'myapp.post': {
        'ops': {'fetch', 'count'},
        'timeout': 1800,
        'lock': True,
    },
    '*.*': {
        'timeout': 3600,
    },
}
```

--------------------------------

### prepare_profiles()

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Computes and returns memoized model profiles for all configured models.

```APIDOC
## prepare_profiles()

### Description
Computes memoized model profiles. Returns a dictionary mapping 'app.model' strings to profile dictionaries, or None if disabled.

### Signature
`prepare_profiles() -> dict[str, dict | None]`

### Example
```python
from cacheops.conf import prepare_profiles
profiles = prepare_profiles()
```
```

--------------------------------

### Cache view responses with cached_view_as

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/orm-caching.md

Caches GET and HEAD requests for Django views based on queryset invalidation.

```python
from cacheops import cached_view_as
from django.views.decorators.http import condition

@cached_view_as(Post.objects.all(), timeout=3600)
def post_list(request):
    posts = Post.objects.all()
    return render(request, 'posts.html', {'posts': posts})
```

--------------------------------

### Verify Redis Connection and Settings

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/installation-setup.md

Use the Django shell to confirm that Redis is reachable and that cacheops settings are correctly loaded.

```python
# shell
python manage.py shell

from cacheops import cache, invalidate_all
from cacheops.conf import settings as cacheops_settings

# Test Redis connection
print(cache.conn.ping())  # Should return True

# Check settings
print(cacheops_settings.CACHEOPS_ENABLED)
print(cacheops_settings.CACHEOPS_REDIS)
```

--------------------------------

### Implement a custom Redis client

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/installation-setup.md

Allows overriding the default Redis client by providing a custom class path in the settings.

```python
# myapp/redis.py

from redis import Redis
from redis.sentinel import Sentinel

class CustomRedisClient(Redis):
    def __init__(self):
        # Custom initialization
        super().__init__(host='localhost', port=6379, db=1)

# settings.py

CACHEOPS_CLIENT_CLASS = 'myapp.redis.CustomRedisClient'
```

--------------------------------

### Register custom template tags

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/template-tags.md

Initialize the CacheopsLibrary instance and use it to register custom template tags.

```python
register = CacheopsLibrary()
```

```python
from cacheops.templatetags.cacheops import register

@register.simple_tag
def my_tag(arg):
    return f"Result: {arg}"
```

--------------------------------

### Invalidate cache via management command

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/cache-reaping.md

Usage examples for the invalidate management command to clear cache for specific models or all models.

```bash
python manage.py invalidate [model_path...]
```

```bash
# Invalidate specific model
python manage.py invalidate auth.User

# Invalidate all models in app
python manage.py invalidate auth

# Invalidate everything
python manage.py invalidate
```

--------------------------------

### cached_view_as(*samples, **kwargs)

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/orm-caching.md

Caches Django view responses using queryset invalidation rules. Only caches GET and HEAD requests.

```APIDOC
## cached_view_as

### Description
Caches view responses using queryset invalidation rules. Wraps `cached_as` for Django views.

### Signature
`def cached_view_as(*samples, **kwargs) -> Callable`

### Parameters
- **samples** (QuerySet, Model class, or Model instance) - Required - Sample queryset(s) to cache like
- **timeout** (int) - Optional - Cache duration in seconds
- **extra** (Any or Callable) - Optional - Extra data for cache key
- **lock** (bool) - Optional - Use dog-pile lock
- **keep_fresh** (bool) - Optional - Prevent caching during invalidation

### Returns
- **Decorator** (Callable) - A decorator function to wrap the Django view.
```

--------------------------------

### Test Redis Connection

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/README.md

Use the redis_client to ping the server and verify connectivity.

```python
from cacheops.redis import redis_client

try:
    redis_client.ping()
except Exception as e:
    print(f"Redis error: {e}")
    # Set CACHEOPS_DEGRADE_ON_FAILURE = True to continue without cache
```

--------------------------------

### Enable Process-Local Caching

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/00-START-HERE.md

Set local_get to True to cache results in process memory for faster access.

```python
CACHEOPS = {
    'auth.user': {
        'ops': 'all',
        'timeout': 3600,
        'local_get': True,  # Cache in process memory
    }
}
```

--------------------------------

### Define project version constants

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/types.md

Defines the current version of the package as both a string and a tuple.

```python
__version__ = '7.2'
VERSION = (7, 2)
```

--------------------------------

### Define CacheopsLibrary class

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/template-tags.md

Extends Django's Library class to support decorator-based tag registration.

```python
class CacheopsLibrary(Library):
    def decorator_tag(self, func=None, takes_context=False) -> Callable
```

--------------------------------

### Configure CACHEOPS_SERIALIZER

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Set the serialization backend using a string import path or object.

```python
CACHEOPS_SERIALIZER = 'pickle'  # Default
CACHEOPS_SERIALIZER = 'myapp.serializers.JsonSerializer'
```

--------------------------------

### Add cacheops to INSTALLED_APPS

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/installation-setup.md

Include 'cacheops' in the INSTALLED_APPS list within settings.py.

```python
# settings.py

INSTALLED_APPS = [
    'django.contrib.contenttypes',
    'django.contrib.auth',
    # ...
    'cacheops',
]
```

--------------------------------

### Perform Manual Cache Operations

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/simple-caching.md

Demonstrates manual interaction with cache keys using the cached decorator.

```python
from cacheops import cache

key = cache.cached(timeout=3600)(my_function).key('arg1', 'arg2')
key.set(result_value)
result = key.get()
key.delete()
```

--------------------------------

### Configure Redis connection

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/installation-setup.md

Define the Redis connection settings using a dictionary or a connection URL.

```python
# settings.py

CACHEOPS_REDIS = {
    'host': 'localhost',
    'port': 6379,
    'db': 1,
}
```

```python
CACHEOPS_REDIS = "redis://localhost:6379/1"
```

--------------------------------

### Set Custom Redis Client

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Specify a custom Redis client class via its import path. The class must be compatible with or subclass redis.Redis.

```python
CACHEOPS_CLIENT_CLASS = 'myapp.redis.CustomRedisClient'
```

--------------------------------

### Configure CACHEOPS_PREFIX

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Define a function or import path to compute the cache key prefix.

```python
def my_prefix(prefix_query):
    if prefix_query.func:
        return 'func:'
    return ''

CACHEOPS_PREFIX = my_prefix
```

```python
CACHEOPS_PREFIX = 'myapp.cache.get_prefix'
```

--------------------------------

### Configure Multi-Database Support

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/README.md

Set db_agnostic to False to ensure cache entries are specific to the database being queried.

```python
# Different caches per database
CACHEOPS = {
    'myapp.model': {
        'ops': 'all',
        'timeout': 3600,
        'db_agnostic': False,  # Cache per database
    }
}
```

--------------------------------

### Implement Cache Warming

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/README.md

Use @cached_as to define a cacheable function and trigger it during application startup to populate the cache.

```python
@cached_as(User.objects.all())
def get_active_user_count():
    return User.objects.filter(is_active=True).count()

# Warm cache on startup
from django.apps import AppConfig

class MyAppConfig(AppConfig):
    def ready(self):
        get_active_user_count()  # Populates cache
```

--------------------------------

### Configure Jinja2 in Django settings

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/template-tags.md

Add the CacheopsExtension to the Jinja2 extensions list in the TEMPLATES setting.

```python
TEMPLATES = [
    {
        'BACKEND': 'jinja2.Jinja2',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'extensions': [
                'cacheops.jinja2.CacheopsExtension',
            ],
        },
    },
]
```

--------------------------------

### Configure Cacheops Signals

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/installation-setup.md

Ensure cacheops is registered in INSTALLED_APPS and initialized within the AppConfig ready method to enable signals.

```python
# Ensure app is in INSTALLED_APPS
INSTALLED_APPS = [
    # ...
    'cacheops',
]

# Call install_cacheops in app config
from django.apps import AppConfig
from cacheops import install_cacheops

class MyAppConfig(AppConfig):
    def ready(self):
        install_cacheops()
```

--------------------------------

### Configure cacheops settings

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/INDEX.md

Define Redis connection, global caching rules, and operational flags in settings.

```python
CACHEOPS_REDIS = "redis://localhost:6379/1"
CACHEOPS = {'*.*': {'ops': 'all', 'timeout': 3600}}
CACHEOPS_ENABLED = True
CACHEOPS_DEGRADE_ON_FAILURE = False
```

--------------------------------

### Define default configuration settings

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/types.md

Lists the default configuration class used by cacheops for various operational settings.

```python
class Defaults:
    CACHEOPS_ENABLED = True
    CACHEOPS_REDIS = {}
    CACHEOPS_DEFAULTS = {}
    CACHEOPS = {}
    CACHEOPS_PREFIX = lambda query: ''
    CACHEOPS_INSIDEOUT = False
    CACHEOPS_CLIENT_CLASS = None
    CACHEOPS_DEGRADE_ON_FAILURE = False
    CACHEOPS_SENTINEL = {}
    CACHEOPS_SKIP_FIELDS = ("FileField", "TextField", "BinaryField", "JSONField", "ArrayField")
    CACHEOPS_LONG_DISJUNCTION = 8
    CACHEOPS_SERIALIZER = 'pickle'
    FILE_CACHE_DIR = '/tmp/cacheops_file_cache'
    FILE_CACHE_TIMEOUT = 60*60*24*30
```

--------------------------------

### AtomicMixIn transaction tracking

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/transaction-support.md

Extends Django's atomic context manager to track transaction boundaries and manage the lifecycle of queued invalidations.

```python
class AtomicMixIn:
    def __enter__(self) -> None
    def __exit__(self, exc_type, exc_value, traceback) -> None
```

```python
from django.db import transaction

with transaction.atomic():
    user = User.objects.get(id=1)
    user.email = 'new@example.com'
    user.save()
    # Invalidation queued, not executed yet

# Transaction commits, invalidation executed
```

--------------------------------

### Configure Cache with Lock for Dog-Pile Prevention

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/README.md

Enable locking in the CACHEOPS configuration to prevent cache stampede on expensive model queries.

```python
CACHEOPS = {
    'myapp.expensive_model': {
        'ops': 'all',
        'timeout': 3600,
        'lock': True,  # Prevents cache stampede
    }
}
```

--------------------------------

### Monitor cache hit rate with signals

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/README.md

Use the cache_read signal to track hits and misses globally. Requires importing the signal from cacheops.signals.

```python
from django.dispatch import receiver
from cacheops.signals import cache_read

hits = misses = 0

@receiver(cache_read)
def track(sender, func, hit, **kwargs):
    global hits, misses
    if hit:
        hits += 1
    else:
        misses += 1

print(f"Hit rate: {hits / (hits + misses) * 100:.1f}%")
```

--------------------------------

### Monitor Cache Performance with Signals

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/README.md

Connect to the cache_read signal to log cache hits and misses.

```python
from django.dispatch import receiver
from cacheops.signals import cache_read

@receiver(cache_read)
def log_cache_events(sender, func, hit, **kwargs):
    status = 'HIT' if hit else 'MISS'
    print(f"Cache {status}: {sender or func}")
```

--------------------------------

### Enable Local Process Memory Cache

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/README.md

Set local_get to True to cache .get() calls directly in the process memory.

```python
CACHEOPS = {
    'auth.user': {
        'ops': 'all',
        'timeout': 3600,
        'local_get': True,  # Cache .get() in process memory
    }
}
```

--------------------------------

### BaseCache Methods

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/simple-caching.md

Core methods for cache operations and function/view decoration.

```APIDOC
## BaseCache.cached(timeout=None, extra=None)

### Description
Decorator to cache function results based on a timeout.

### Parameters
- **timeout** (int) - Optional - Cache duration in seconds.
- **extra** (Any) - Optional - Additional data for cache key generation.

## BaseCache.cached_view(timeout=None, extra=None)

### Description
Decorator for Django views, restricted to GET/HEAD requests.

### Parameters
- **timeout** (int) - Optional - Cache duration in seconds.
- **extra** (Any) - Optional - Additional data for cache key generation.

## BaseCache.get(cache_key)

### Description
Retrieves a value from the cache by key. Raises `CacheMiss` if not found.

## BaseCache.set(cache_key, data, timeout=None)

### Description
Stores data in the cache with an optional timeout override.

## BaseCache.delete(cache_key)

### Description
Removes a specific key from the cache.
```

--------------------------------

### Configure Redis Sentinel

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Set up high availability using Redis Sentinel. This configuration is mutually exclusive with CACHEOPS_REDIS.

```python
CACHEOPS_SENTINEL = {
    'locations': [('sentinel1', 26379), ('sentinel2', 26379)],
    'service_name': 'mymaster',
    'socket_timeout': 0.1,
    'db': 0,
}
```

--------------------------------

### Share Redis instance with key prefixes

Source: https://github.com/suor/django-cacheops/blob/master/README.rst

Define a prefix for cache keys to share a single Redis instance across different applications or contexts.

```python
CACHEOPS_PREFIX = lambda query: ...
# or
CACHEOPS_PREFIX = 'some.module.cacheops_prefix'
```

```python
# get_request() returns current request saved to threadlocal by some middleware
cacheops_prefix = lambda _: get_request().get_host()
```

```python
def cacheops_prefix(query):
    query.dbs    # A list of databases queried
    query.tables # A list of tables query is invalidated on

    if set(query.tables) <= HELPER_TABLES:
        return 'helper:'
    if query.tables == ['blog_post']:
        return 'blog:'
```

--------------------------------

### Configure graceful degradation on Redis failure

Source: https://github.com/suor/django-cacheops/blob/master/README.rst

Enable this setting to allow the application to continue functioning if the Redis cache becomes unavailable.

```python
CACHEOPS_DEGRADE_ON_FAILURE = True
```

--------------------------------

### Configure Redis Connection

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Define the Redis connection using either a dictionary for granular control or a URL string. These settings are mutually exclusive with CACHEOPS_SENTINEL.

```python
CACHEOPS_REDIS = {
    'host': 'localhost',
    'port': 6379,
    'db': 1,
    'socket_timeout': 3,
    'password': 'secret',
}
```

```python
CACHEOPS_REDIS = "redis://localhost:6379/1"
CACHEOPS_REDIS = "redis://:password@localhost:6379/1"
CACHEOPS_REDIS = "unix:///tmp/redis.sock?db=1"
```

--------------------------------

### Create custom template tags with CacheopsLibrary

Source: https://github.com/suor/django-cacheops/blob/master/README.rst

Define custom template tags that act as decorators for template fragments. This is an experimental feature.

```python
from cacheops import cached_as, CacheopsLibrary

register = CacheopsLibrary()

@register.decorator_tag(takes_context=True)
def cache_menu(context, menu_name):
    from django.utils import translation
    from myapp.models import Flag, MenuItem

    request = context.get('request')
    if request and request.user.is_staff():
        # Use noop decorator to bypass caching for staff
        return lambda func: func

    return cached_as(
        # Invalidate cache if any menu item or a flag for menu changes
        MenuItem,
        Flag.objects.filter(name='menu'),
        # Vary for menu name and language, also stamp it as "menu" to be safe
        extra=("menu", menu_name, translation.get_language()),
        timeout=24 * 60 * 60
    )
```

--------------------------------

### Configure FILE_CACHE_TIMEOUT

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Set the default timeout in seconds for the file cache.

```python
FILE_CACHE_TIMEOUT = 86400 * 7  # 7 days
```

--------------------------------

### install_cacheops_transaction_support

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/transaction-support.md

Enables automatic transaction support for the Django ORM by monkey-patching transaction context managers and cursor wrappers.

```APIDOC
## install_cacheops_transaction_support

### Description
Enables automatic transaction support for Django ORM. This is called automatically by `install_cacheops()` and monkey-patches `django.db.transaction.Atomic` and `django.db.backends.utils.CursorWrapper`.

### Signature
`install_cacheops_transaction_support() -> None`

### Example
```python
from cacheops.transaction import install_cacheops_transaction_support

install_cacheops_transaction_support()
```
```

--------------------------------

### CacheKey Methods

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/simple-caching.md

Methods for managing individual cache keys, including retrieval, storage, and deletion.

```APIDOC
## CacheKey.make(value, cache=None, timeout=None)

### Description
Creates a new cache key with associated metadata.

### Parameters
- **value** (str) - Required - The value to associate with the key.
- **cache** (BaseCache) - Optional - The cache backend instance.
- **timeout** (int) - Optional - Cache duration in seconds.

## CacheKey.get()

### Description
Retrieves the value from the cache. Raises `CacheMiss` if the key is not found or expired.

## CacheKey.set(value)

### Description
Stores a value in the cache with the configured timeout.

### Parameters
- **value** (Any) - Required - The data to store.

## CacheKey.delete()

### Description
Removes the key from the cache.
```

--------------------------------

### MD5 hashing utility

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/utilities.md

A wrapper for hashlib.md5 that sets usedforsecurity=False on Python 3.9+ for FIPS compliance.

```python
class md5:
    def __init__(self, s=None)
    def update(self, s: str) -> None
    def hexdigest(self) -> str
```

```python
from cacheops.utils import md5

m = md5('initial')
m.update('more')
m.update('data')
hash_val = m.hexdigest()
```

--------------------------------

### Accessing Runtime Settings

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Retrieve current cacheops configuration values using the settings object. Settings are lazy-loaded and cached.

```python
from cacheops.conf import settings

enabled = settings.CACHEOPS_ENABLED
redis_config = settings.CACHEOPS_REDIS
```

--------------------------------

### Define RedisCache Class

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/simple-caching.md

Redis-backed cache implementation using pickle serialization.

```python
class RedisCache(BaseCache):
    def __init__(self, conn: redis.Redis)
```

--------------------------------

### Configure Cache with Lock for Stampede Prevention

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/00-START-HERE.md

Enable the lock option in the CACHEOPS configuration to prevent cache stampede for high-traffic models.

```python
CACHEOPS = {
    'myapp.popular': {
        'ops': 'all',
        'timeout': 3600,
        'lock': True,  # Prevents cache stampede
    }
}
```

--------------------------------

### Optimize QuerySet performance with inplace mutation

Source: https://github.com/suor/django-cacheops/blob/master/README.rst

Use .inplace() to prevent unnecessary cloning of QuerySet objects. This is a micro-optimization intended only for performance-critical code paths.

```python
items = Item.objects.inplace().filter(category=12).order_by('-date')[:20]
```

--------------------------------

### Configure Per-Model Caching

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Define caching behavior for specific models or patterns. Use None to explicitly disable caching for a model.

```python
CACHEOPS = {
    'app.model': {
        'ops': {'get', 'fetch', 'count'},
        'timeout': 3600,
        'local_get': False,
        'db_agnostic': True,
        'lock': False,
    }
}
```

```python
class User(models.Model):
    username = models.CharField(max_length=100)
    email = models.EmailField()

CACHEOPS = {
    'auth.user': {
        'ops': 'all',
        'timeout': 3600,
        'cache_on_save': 'pk',  # or True for primary key
    }
}
```

```python
CACHEOPS = {
    'auth.user': {
        'ops': {'get', 'fetch'},
        'timeout': 900,
    },
    'auth.permission': {
        'ops': 'all',
        'timeout': 3600,
    },
    'myapp.post': {
        'ops': {'fetch', 'count'},
        'timeout': 1800,
        'lock': True,
    },
    'myapp.draft': None,  # Explicitly disable
    '*.*': {
        'timeout': 3600,
    },
}
```

--------------------------------

### Configure per-model caching settings

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/orm-caching.md

Defines the structure for the CACHEOPS dictionary to control caching behavior for specific models.

```python
CACHEOPS = {
    'app.model': {
        'ops': {'get', 'fetch', 'count'},  # or 'all' for all ops
        'timeout': 3600,                   # Cache timeout in seconds
        'local_get': False,                # Cache .get() in process memory
        'db_agnostic': True,               # Same cache for all databases
        'lock': False,                     # Use dog-pile prevention lock
    }
}
```

--------------------------------

### Configure FILE_CACHE_DIR

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Set the directory path for file-based caching.

```python
FILE_CACHE_DIR = '/var/cache/myapp'
```

--------------------------------

### Convert objects to cache keys with obj_key

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/utilities.md

Converts model instances, HTTP requests, functions, or other objects into a string or list representation suitable for caching.

```python
def obj_key(obj) -> str | list
```

```python
from cacheops.utils import obj_key

user = User.objects.get(id=1)
key = obj_key(user)
# Returns: 'auth.user.1'

def my_func():
    pass
key = obj_key(my_func)
# Returns: ['module.name', 'my_func', 123]
```

--------------------------------

### Implement Custom Serializer

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Custom serializers must implement the specified dumps, loads, load, and dump methods.

```python
class CustomSerializer:
    def dumps(self, obj) -> bytes
    def loads(self, data: bytes) -> obj
    def load(self, file)
    def dump(self, obj, file)
```

--------------------------------

### Configure Cacheops Serializer

Source: https://github.com/suor/django-cacheops/blob/master/README.rst

Specify a custom serializer for cache data. Use 'dill' for complex objects or a custom class to fix pickle protocols across Python versions.

```python
CACHEOPS_SERIALIZER = 'dill'
```

```python
import pickle

class CACHEOPS_SERIALIZER:
    dumps = lambda data: pickle.dumps(data, 3)
    loads = pickle.loads
```

--------------------------------

### Configure QuerySet caching

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/INDEX.md

Control caching behavior directly on QuerySets using these methods.

```python
qs.cache(ops='fetch', timeout=3600)
qs.nocache()
qs.cache().invalidate()
```

--------------------------------

### File-based Caching

Source: https://github.com/suor/django-cacheops/blob/master/README.rst

Using file-based cache for time-invalidated results and primitives.

```python
from cacheops import file_cache

@file_cache.cached(timeout=number_of_seconds)
def top_articles(category):
    return ... # Some costly queries

@file_cache.cached_view(timeout=number_of_seconds)
def top_articles(request, category):
    # Some costly queries
    return HttpResponse(...)

# later, on appropriate event
top_articles.invalidate(some_category)
# or
top_articles.key(some_category).set(some_value)

# primitives
file_cache.set(cache_key, data, timeout=None)
file_cache.get(cache_key)
file_cache.delete(cache_key)
```

--------------------------------

### Enable transaction support with install_cacheops_transaction_support

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/transaction-support.md

Monkey-patches Django's transaction and cursor utilities to enable cache invalidation tracking. This is typically invoked automatically by install_cacheops().

```python
@once
def install_cacheops_transaction_support() -> None
```

```python
from cacheops import install_cacheops
from cacheops.transaction import install_cacheops_transaction_support

# Called by install_cacheops automatically
install_cacheops_transaction_support()
```

--------------------------------

### Iterate Conjunctive Key Chunks

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/cache-reaping.md

Uses SSCAN to iterate over conjunctive set members in batches without blocking Redis.

```python
def _iter_keys_chunk(chunk_size: int, key: bytes) -> Iterator[list[bytes]]
```

--------------------------------

### Configure QuerySet Caching

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/orm-caching.md

Use the cache method to enable caching for specific operations and set custom timeouts or locks.

```python
def cache(self, ops=None, timeout=None, lock=None) -> QuerySet
```

```python
# Cache fetch operations for 2 hours
users = User.objects.filter(active=True).cache(ops='fetch', timeout=7200)
user_list = list(users)  # Cached

# Cache specific operations
posts = Post.objects.all().cache(ops={'fetch', 'count'}, timeout=3600)
count = posts.count()  # Cached
```

--------------------------------

### Configure database agnostic cache profiles

Source: https://github.com/suor/django-cacheops/blob/master/README.rst

Set db_agnostic to False in the CACHEOPS configuration to differentiate cache results based on the database queried.

```python
CACHEOPS = {
    'some.model': {'ops': 'get', 'db_agnostic': False, 'timeout': ...}
}
```

--------------------------------

### Configure Cacheops Settings

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/00-START-HERE.md

Define caching behavior for specific models, entire applications, or global defaults within the CACHEOPS dictionary.

```python
CACHEOPS = {
    'app.model': {...},       # Specific model
    'app.*': {...},           # All models in app
    '*.*': {...},             # All models
    'app.model': None,        # Explicitly disable
}
```

--------------------------------

### CursorWrapperMixin query tracking

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/transaction-support.md

Extends Django's cursor wrapper to detect write operations and mark the transaction as dirty.

```python
class CursorWrapperMixin:
    def callproc(self, procname, params=None) -> Any
    def execute(self, sql, params=None) -> Any
    def executemany(self, sql, param_list) -> Any
```

```python
from django.db import transaction

with transaction.atomic():
    User.objects.all().update(last_login=timezone.now())
    # Transaction marked dirty on execute
```

--------------------------------

### Implement Cache Read Stats

Source: https://github.com/suor/django-cacheops/blob/master/README.rst

Connect to the cache_read signal to track cache hits and misses using external monitoring tools like statsd.

```python
from cacheops.signals import cache_read
from statsd.defaults.django import statsd

def stats_collector(sender, func, hit, **kwargs):
    event = 'hit' if hit else 'miss'
    statsd.incr('cacheops.%s' % event)

cache_read.connect(stats_collector)
```

--------------------------------

### Test Basic Function Caching

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/installation-setup.md

Demonstrates the use of the @cache.cached decorator to cache function results based on arguments.

```python
from cacheops import cache

@cache.cached(timeout=3600)
def test_function(x):
    print(f"Computing for {x}")
    return x * 2

# First call: prints and computes
result1 = test_function(5)  # Computing for 5

# Second call: uses cache
result2 = test_function(5)  # No print, uses cached value

# Different argument: computes again
result3 = test_function(10)  # Computing for 10
```

--------------------------------

### Monitor Cache Health

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/cache-reaping.md

Commands for checking Redis memory usage and conjunctive set sizes.

```bash
# Check conj set sizes before reaping
redis-cli --eval reapconjs.lua , <prefix>

# Check overall Redis memory
redis-cli INFO memory

# Monitor reaping progress
redis-cli --csv KEYS '<prefix>conj:*' | wc -l
```

--------------------------------

### Handle cache signals

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/INDEX.md

Connect to cache read and invalidation events using Django signals.

```python
from cacheops.signals import cache_read, cache_invalidated

@receiver(cache_read)
def on_cache_read(sender, func, hit, **kwargs): ...

@receiver(cache_invalidated)
def on_invalidate(sender, obj_dict, **kwargs): ...
```

--------------------------------

### Generate cache key with get_cache_key

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/utilities.md

Creates an MD5 hex digest from multiple factors. Factors are converted to strings using obj_key for model instances and functions.

```python
def get_cache_key(*factors) -> str
```

```python
from cacheops.utils import get_cache_key

key = get_cache_key('user', 123, 'profile')
# key = 'a1b2c3d4e5f6...' (40-char MD5 hex)

user = User.objects.get(id=1)
key = get_cache_key('fetch', user, ['active', 'verified'])
```

--------------------------------

### Computing Memoized Model Profiles

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Generate a dictionary mapping model identifiers to their respective caching profiles.

```python
from cacheops.conf import prepare_profiles

profiles = prepare_profiles()
profile = profiles['myapp.model']
```

--------------------------------

### md5 Class

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/utilities.md

A wrapper class around Python's hashlib.md5, configured for non-security use cases.

```APIDOC
## md5

### Description
Wrapper around Python's hashlib.md5, automatically setting usedforsecurity=False on Python 3.9+.

### Constructor
`md5(s=None)`
- **s** (str) - Optional - Initial string to hash.

### Methods
- **update(s: str) -> None**: Adds a string to the hash.
- **hexdigest() -> str**: Returns the 32-character hex digest of the hash.

### Example
```python
from cacheops.utils import md5

m = md5('initial')
m.update('more')
m.update('data')
hash_val = m.hexdigest()
```
```

--------------------------------

### Configure CACHEOPS_LONG_DISJUNCTION

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Set the threshold for __in lookups to trigger invalidation optimization.

```python
CACHEOPS_LONG_DISJUNCTION = 10
```

--------------------------------

### Parameterize cache keys

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/template-tags.md

Include unique identifiers in the cache tag to ensure content varies correctly based on user or page context.

```django
{# Wrong: content varies by user but not included #}
{% cached 3600 "sidebar" %}

{# Correct: user varies cache #}
{% cached 3600 "sidebar" user.id %}

{# Correct: page-specific content #}
{% cached 1800 "list" object_list.model._meta.model_name page %}
```

--------------------------------

### Perform Cache Cleanup

Source: https://github.com/suor/django-cacheops/blob/master/README.rst

Clean up stale conjunction keys using the management command or programmatically via Celery tasks.

```bash
./manage.py reapconjs --chunk-size=100 --min-conj-set-size=10000  # with custom values
./manage.py reapconjs                                             # with default values (chunks=1000, min size=1000)
```

```python
from cacheops import reap_conjs

@app.task
def reap_conjs_task():
    reap_conjs(
        chunk_size=2000,
        min_conj_set_size=100,
    )
```

--------------------------------

### Maintain Cache Health via CLI

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/00-START-HERE.md

Execute management commands to reap expired keys or invalidate cache entries for specific models or the entire system.

```bash
# Weekly cleanup of expired keys
python manage.py reapconjs

# Clear specific model
python manage.py invalidate auth.User

# Clear everything
python manage.py invalidate
```

--------------------------------

### Toggle Caching Runtime

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/configuration.md

Enable or disable all caching operations globally at runtime.

```python
CACHEOPS_ENABLED = False  # Disable all caching
```

--------------------------------

### Enable In-place QuerySet Modification

Source: https://github.com/suor/django-cacheops/blob/master/_autodocs/orm-caching.md

A convenience method that sets cloning to 0, allowing in-place modifications of the queryset.

```python
def inplace(self) -> QuerySet
```
Tokens:
Raw