How to dynamically call a Django templatetag from a variable

Question

I'm trying to allow for dynamic template tags. Specifically, I have a menu setup that I'm defining in code vs templates. And I would like to render the menu label as {{ request.user }}. So how can I define that as a string in Python, and allow the template to parse and render the string as intended. And not just variables too, templatetags as well ({% provider_login_url 'google' next=next %}).

What am I missing?

Update with code:

I'm specifically designing my menus with django-navutils, but that's less important (basically the package just stores the defined data and then uses templates to render it).

from navutils import menu

top_horizontal_nav = menu.Menu('top_nav')
left_vertical_nav = menu.Menu('left_nav')

menu.register(top_horizontal_nav)
menu.register(left_vertical_nav)

sign_in = menu.AnonymousNode(
    id='sign_in',
    label='Sign In',
    url='{% provider_login_url "google" next=next %}',
    template='nav_menu/signin_node.html',
)
user = menu.AuthenticatedNode(
    id='user_menu',
    label='{{ request.user }}',
    url='#',
    template='nav_menu/username_node.html'
)
top_horizontal_nav.register(sign_in)
top_horizontal_nav.register(user)

What I would like to do, is now render these string values ('{{ request.user }}') in my templates

{% load navutils_tags %}

<li
    class="{% block node_class %}nav-item menu-item{% if node.css_class %} {{ node.css_class }}{% endif %}{% if is_current %} {{ menu_config.CURRENT_MENU_ITEM_CLASS }}{% endif %}{% if has_current %} {{ menu_config.CURRENT_MENU_ITEM_PARENT_CLASS }}{% endif %}{% if viewable_children %} has-children has-dropdown{% endif %}{% endblock %}"
    {% for attr, value in node.attrs.items %} {{ attr }}="{{ value }}"{% endfor %}>
    <a href="{{ node.get_url }}" class="nav-link"{% for attr, value in node.link_attrs.items %} {{ attr }}="{{ value }}"{% endfor %}>{% block node_label %}{{ node.label }}{% endblock %}</a>
    {% if viewable_children %}
        <ul class="{% block submenu_class %}sub-menu dropdown{% endblock %}">
            {% for children_node in viewable_children %}
                {% render_node node=children_node current_depth=current_depth|add:'1' %}
            {% endfor %}
        </ul>
    {% endif %}
</li>

So, for the above, where I'm rendering {{ node.label }}, how can I get the value stored in node.label to actually be parsed as a request.user? This similarly applies for the URL of value {% provider_login_url "google" next=next %}.

Answer 1

If I understand you well, you want to write template code that renders to template code and then be processed again. Something like ... meta-templates?

I can see you already figured out the first part, but now you need the resulting code to be parsed again in order to set the respective value for {{ request.user }}.

I achieve that by using middleware, but since parsing a template is an expensive operation I implemented some a mechanism to apply the "re-parsing" process just to urls/views of my selection.

The model.

class ReparsingTarget(models.Model):
    url_name = models.CharField(max_length=255)

Simple enough, just a model for storing those URL names I want to be affected by the middleware.

The middleware.

class ReparsingMiddleware:

    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # We are no interested in whatever happens before
        # self.get_response is called.
        response = self.get_response(request)

        # Now we will re-parse response just if the requested url
        # is marked as target for re-parse.


        if self._marked(request) and isinstance(response, TemplateResponse):

            # Decode the template response code ...
            content = response.content.decode('utf-8')
            # Create a Template object ...
            template = Template(content)
            # Provide request to de context ...
            context_data = response.context_data
            context_data.update({'request': request})
            # ... and renders the template back the the response.
            response.content = template.render(Context(response.context_data))

        return response

    def _marked(self, request):
        url_name = resolve(request.path_info).url_name
        return ReparsingTarget.objects.filter(url_name=url_name).exists()

It is a really simple implementation, the tricky part for me was to figure out how to put the idea into Django code.

In practice.

Some model.

class Foo(models.Model):
    label = models.CharField(max_length=255)

The template:

{% for foo in foos %}
    {% comment %} Remember  foo.label == '{{ request.user }}' {% endcomment %}
    <p> Username: {{ foo.label }} </p>
{% endfor %}

The stored Foo instance:

And the result:

Answer 2

You can create a custom template tag and render those. Like this

from django import template

register = template.Library()

@register.simple_tag(takes_context=True)
def render_nested(context, template_text):
    # create template from text
    tpl = template.Template(template_text)
    return tpl.render(context)

Then in template

...
    <a href="{{ node.get_url }}" class="nav-link"
    {% for attr, value in node.link_attrs.items %} {{ attr }}="{{ value }}"{% endfor %}>
        {% block node_label %}{% render_nested node.label %}{% endblock %}
    </a>
...

Haven't tested but I think it will work.
More on template: https://docs.djangoproject.com/en/dev/ref/templates/api/#rendering-a-context
More on custom tags: https://docs.djangoproject.com/en/dev/howto/custom-template-tags/#writing-custom-template-tags