Llamar a una función de python desde jinja2

Estoy usando jinja2, y quiero llamar a una función de python como ayudante, usando una sintaxis similar a la de una macro. Parece que jinja2 intenta evitar que haga una llamada a una función, e insiste en que me repita copiando la función en una plantilla como una macro.

¿Hay alguna forma directa de hacer esto? Y, ¿hay alguna manera de importar un conjunto completo de funciones de Python y tenerlas accesibles desde jinja2, sin pasar por un montón de rigamarole (como escribir una extensión)?

Para aquellos que usan Flask, pon esto en tu __init__.py:

def clever_function():
    return u'HELLO'

app.jinja_env.globals.update(clever_function=clever_function)

y en tu plantilla llámalo con {{ clever_function() }}

Nota: ¡Esto es específico de Flask!

Sé que esta publicación es bastante antigua, pero hay mejores métodos para hacerlo en las versiones más recientes de Flask usando procesadores de contexto.

Las variables se pueden crear fácilmente:

@app.context_processor
def example():
    return dict(myexample='This is an example')

Lo anterior se puede usar en una plantilla Jinja2 con Flask así:

{{ myexample }}

(Que salidas This is an example)

Además de las funciones completas:

@app.context_processor
def utility_processor():
    def format_price(amount, currency=u'€'):
        return u'{0:.2f}{1}'.format(amount, currency)
    return dict(format_price=format_price)

Lo anterior cuando se usa así:

{{ format_price(0.33) }}

(Que genera el precio de entrada con el símbolo de moneda)

Alternativamente, puede usar filtros jinja , horneados en Flask. Por ejemplo, usar decoradores:

@app.template_filter('reverse')
def reverse_filter(s):
    return s[::-1]

O, sin decoradores, y registrando manualmente la función:

def reverse_filter(s):
    return s[::-1]
app.jinja_env.filters['reverse'] = reverse_filter

Los filtros aplicados con los dos métodos anteriores se pueden usar así:

{% for x in mylist | reverse %}
{% endfor %}

Creo que jinja deliberadamente hace que sea difícil ejecutar python 'arbitrario' dentro de una plantilla. Intenta imponer la opinión de que menos lógica en las plantillas es algo bueno.

Puede manipular el espacio de nombres global dentro de una Environmentinstancia para agregar referencias a sus funciones. Debe hacerse antes de cargar cualquier plantilla. Por ejemplo:

from jinja2 import Environment, FileSystemLoader

def clever_function(a, b):
    return u''.join([b, a])

env = Environment(loader=FileSystemLoader('/path/to/templates'))
env.globals['clever_function'] = clever_function

from jinja2 import Template

def custom_function(a):
    return a.replace('o', 'ay')

template = Template('Hey, my name is {{ custom_function(first_name) }} {{ func2(last_name) }}')
template.globals['custom_function'] = custom_function

También puede asignar la función en los campos según la respuesta de Matroskin

fields = {'first_name': 'Jo', 'last_name': 'Ko', 'func2': custom_function}
print template.render(**fields)

Saldrá:

Hey, my name is Jay Kay

Funciona con Jinja2 versión 2.7.3

Y si desea un decorador para facilitar la definición de funciones al template.globalsconsultar la respuesta de Bruno Bronosky

Me gusta la respuesta de @ AJP . Lo usé textualmente hasta que terminé con muchas funciones. Luego me cambié a un decorador de funciones de Python .

from jinja2 import Template

template = '''
Hi, my name is {{ custom_function1(first_name) }}
My name is {{ custom_function2(first_name) }}
My name is {{ custom_function3(first_name) }}
'''
jinga_html_template = Template(template)

def template_function(func):
    jinga_html_template.globals[func.__name__] = func
    return func

@template_function
def custom_function1(a):
    return a.replace('o', 'ay')

@template_function
def custom_function2(a):
    return a.replace('o', 'ill')

@template_function
def custom_function3(a):
    return 'Slim Shady'

fields = {'first_name': 'Jo'}
print(jinga_html_template.render(**fields))

Lo bueno es que las funciones tienen un __name__!

Nunca vi una manera tan simple en los documentos oficiales o en el desbordamiento de la pila, pero me sorprendió cuando encontré esto:

# jinja2.__version__ == 2.8
from jinja2 import Template

def calcName(n, i):
    return ' '.join([n] * i)

template = Template("Hello {{ calcName('Gandalf', 2) }}")

template.render(calcName=calcName)
# or
template.render({'calcName': calcName})

Use una lambda para conectar la plantilla a su código principal

return render_template("clever_template", clever_function=lambda x: clever_function x)

Luego puede llamar sin problemas a la función en la plantilla

{{clever_function(value)}}

Para llamar a una función de Python desde Jinja2, puede usar filtros personalizados que funcionan de manera similar a los globales: http://jinja.pocoo.org/docs/dev/api/#writing-filters

Es bastante simple y útil. En un archivo myTemplate.txt, escribí:

{{ data|pythonFct }}

Y en un script de python:

import jinja2

def pythonFct(data):
    return "This is my data: {0}".format(data)

input="my custom filter works!"

loader = jinja2.FileSystemLoader(path or './')
env = jinja2.Environment(loader=loader)
env.filters['pythonFct'] = pythonFct
result = env.get_template("myTemplate.txt").render(data=input)
print(result)

¿Hay alguna manera de importar un conjunto completo de funciones de Python y tenerlas accesibles desde jinja2?

Sí, hay, además de las otras respuestas anteriores, esto funciona para mí.

Cree una clase y complétela con los métodos asociados, p. Ej.

class Test_jinja_object:

    def __init__(self):
        self.myvar = 'sample_var'

    def clever_function (self):
        return 'hello' 

Luego cree una instancia de su clase en su función de vista y pase el objeto resultante a su plantilla como parámetro para la función render_template

my_obj = Test_jinja_object()

Ahora en su plantilla, puede llamar a los métodos de clase en jinja así

{{ my_obj.clever_function () }}

Para importar todas las funciones integradas que puede usar:

app.jinja_env.globals.update(__builtins__)

Agregue .__dict__después __builtins__si esto no funciona.

Basado en la respuesta de John32323 .

Si lo está haciendo con Django, puede pasar la función con el contexto:

context = {
    'title':'My title',
    'str': str,
}
...
return render(request, 'index.html', context)

Ahora podrá usar la strfunción en la plantilla jinja2

Hay una decisión mucho más simple.

@app.route('/x')
def x():
    return render_template('test.html', foo=y)

def y(text):
    return text

Luego, en test.html :

{{ y('hi') }}