Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://django-components.github.io/django-components/latest/concepts/advanced/component_caching/ below:

Component caching - Django-Components

Component caching allows you to store the rendered output of a component. Next time the component is rendered with the same input, the cached output is returned instead of re-rendering the component.

This is particularly useful for components that are expensive to render or do not change frequently.

Caching is disabled by default.

To enable caching for a component, set Component.Cache.enabled to True:

from django_components import Component

class MyComponent(Component):
    class Cache:
        enabled = True

You can specify a time-to-live (TTL) for the cache entry with Component.Cache.ttl, which determines how long the entry remains valid. The TTL is specified in seconds.

class MyComponent(Component):
    class Cache:
        enabled = True
        ttl = 60 * 60 * 24  # 1 day

• If ttl > 0, entries are cached for the specified number of seconds.
• If ttl = -1, entries are cached indefinitely.
• If ttl = 0, entries are not cached.
• If ttl = None, the default TTL is used.

Since component caching uses Django's cache framework, you can specify a custom cache name with Component.Cache.cache_name to use a different cache backend:

class MyComponent(Component):
    class Cache:
        enabled = True
        cache_name = "my_cache"

By default, the cache key is generated based on the component's input (args and kwargs). So the following two calls would generate separate entries in the cache:

MyComponent.render(name="Alice")
MyComponent.render(name="Bob")

However, you have full control over the cache key generation. As such, you can:

• Cache the component on all inputs (default)
• Cache the component on particular inputs
• Cache the component irrespective of the inputs

To achieve that, you can override the Component.Cache.hash() method to customize how arguments are hashed into the cache key.

class MyComponent(Component):
    class Cache:
        enabled = True

        def hash(self, *args, **kwargs):
            return f"{json.dumps(args)}:{json.dumps(kwargs)}"

For even more control, you can override other methods available on the ComponentCache class.

Warning

The default implementation of Cache.hash() simply serializes the input into a string. As such, it might not be suitable if you need to hash complex objects like Models.

By default, the cache key is generated based ONLY on the args and kwargs.

To cache the component based on the slots, set Component.Cache.include_slots to True:

class MyComponent(Component):
    class Cache:
        enabled = True
        include_slots = True

with include_slots = True, the cache key will be generated also based on the given slots.

As such, the following two calls would generate separate entries in the cache:

{% component "my_component" position="left" %}
    Hello, Alice
{% endcomponent %}

{% component "my_component" position="left" %}
    Hello, Bob
{% endcomponent %}

Same when using Component.render() with string slots:

MyComponent.render(
    kwargs={"position": "left"},
    slots={"content": "Hello, Alice"}
)
MyComponent.render(
    kwargs={"position": "left"},
    slots={"content": "Hello, Bob"}
)

Warning

Passing slots as functions to cached components with include_slots=True will raise an error.

MyComponent.render(
    kwargs={"position": "left"},
    slots={"content": lambda ctx: "Hello, Alice"}
)

Warning

Slot caching DOES NOT account for context variables within the {% fill %} tag.

For example, the following two cases will be treated as the same entry:

{% with my_var="foo" %}
    {% component "mycomponent" name="foo" %}
        {{ my_var }}
    {% endcomponent %}
{% endwith %}

{% with my_var="bar" %}
    {% component "mycomponent" name="bar" %}
        {{ my_var }}
    {% endcomponent %}
{% endwith %}

Currently it's impossible to capture used variables. This will be addressed in v2. Read more about it in django-components/#1164.

Here's a complete example of a component with caching enabled:

from django_components import Component

class MyComponent(Component):
    template = "Hello, {{ name }}"

    class Cache:
        enabled = True
        ttl = 300  # Cache for 5 minutes
        cache_name = "my_cache"

    def get_template_data(self, args, kwargs, slots, context):
        return {"name": kwargs["name"]}

In this example, the component's rendered output is cached for 5 minutes using the my_cache backend.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4