Render API

When a component is being rendered, whether with Component.render() or {% component %}, a component instance is populated with the current inputs and context. This allows you to access things like component inputs - methods and attributes on the component instance which would otherwise not be available.

We refer to these render-only methods and attributes as the "Render API".

Render API is available inside these Component methods:

Example:

class Table(Component):
    def get_context_data(self, *args, **attrs):
        # Access component's ID
        assert self.id == "djc1A2b3c"

        # Access component's inputs, slots and context
        assert self.input.args == (123, "str")
        assert self.input.kwargs == {"variable": "test", "another": 1}
        footer_slot = self.input.slots["footer"]
        some_var = self.input.context["some_var"]

        # Access the request object and Django's context processors, if available
        assert self.request.GET == {"query": "something"}
        assert self.context_processors_data['user'].username == "admin"

        return {
            "variable": variable,
        }

rendered = Table.render(
    kwargs={"variable": "test", "another": 1},
    args=(123, "str"),
    slots={"footer": "MY_SLOT"},
)

Accessing Render API¤

If you try to access the Render API outside of a render call, you will get a RuntimeError.

Component ID¤

Component ID (or render ID) is a unique identifier for the current render call.

That means that if you call Component.render() multiple times, the ID will be different for each call.

It is available as self.id.

Component inputs¤

All the component inputs are captured and available as self.input.

self.input (ComponentInput) has the mostly the same fields as the input to Component.render(). This includes:

args - List of positional arguments
kwargs - Dictionary of keyword arguments
slots - Dictionary of slots. Values are normalized to Slot instances
context - Context object that should be used to render the component
And other kwargs passed to Component.render() like type and render_dependencies

Thus, use can use self.input.args and self.input.kwargs to access the positional and keyword arguments passed to Component.render().

    def get_context_data(self, *args, **kwargs):
        # Access component's inputs, slots and context
        assert self.input.args == [123, "str"]
        assert self.input.kwargs == {"variable": "test", "another": 1}
        footer_slot = self.input.slots["footer"]
        some_var = self.input.context["some_var"]

        return {}

rendered = TestComponent.render(
    kwargs={"variable": "test", "another": 1},
    args=(123, "str"),
    slots={"footer": "MY_SLOT"},
)

Request object and context processors¤

If the component was either:

Given a request kwarg
Rendered with RenderContext
Nested in another component for which any of these conditions is true

Then the request object will be available in self.request.

If the request object is available, you will also be able to access the context processors data in self.context_processors_data.

This is a dictionary with the context processors data.

If the request object is not available, then self.context_processors_data will be an empty dictionary.

from django.http import HttpRequest

class Table(Component):
    def get_context_data(self, *args, **attrs):
        # Access the request object and Django's context processors
        assert self.request.GET == {"query": "something"}
        assert self.context_processors_data['user'].username == "admin"

        return {}

rendered = Table.render(
    request=HttpRequest(),
)

Warning

The self.context_processors_data object is generated dynamically, so changes to it are not persisted.