Llamar a una función de pitón desde jinja2

Question

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

¿Hay alguna manera 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)?

Answer 1

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

Puede manipular el espacio de nombres global dentro de una instancia Environment 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 

Answer 2

Para aquellos que utilizan el frasco, puso esto en su __init__.py:

def clever_function(): 
    return u'HELLO' 

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

y en su plantilla llaman con {{ clever_function() }}

Answer 3

Nota: Esto es específico frasco!

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

Las variables pueden ser fácilmente creados:

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

Lo anterior puede ser utilizado en una plantilla Jinja2 con el frasco así:

{{ myexample }} 

(que emite 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 de esta manera:

{{ format_price(0.33) }} 

(que emite el precio de entrada con el símbolo de moneda)

Como alternativa, puede utilizar jinja filters, al horno en el frasco. P.ej.utilizando decoradores:

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

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

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

filtros aplicados con los dos métodos anteriores se pueden utilizar como esto:

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

Answer 4

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

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

A continuación, puede llamar a la función a la perfección en la plantilla

{{clever_function(value)}} 

Answer 5

from jinja2 import Template 

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

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

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

seria:

Hey, my name is Jay 

funciona con la versión 2.7.3 Jinja2

Answer 6

Para llamar a una función de Python 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 myTemplate.txt archivo, escribí:

{{ data|pythonFct }} 

Y en un script en 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) 

Answer 7

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

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

Ahora usted será capaz de utilizar la función str en la plantilla Jinja2

Answer 8

nunca vio de manera sencilla en documentos oficiales o al desbordamiento de pila, pero me quedé sorprendido cuando se encuentra presente:

# 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}) 

Answer 9

¿hay alguna manera de importar todo un conjunto de funciones de Python y les tienen acceso desde Jinja2?

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

Crear una clase y rellenarla con los métodos asociados, por ejemplo,

class Test_jinja_object: 

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

    def clever_function (self): 
     return 'hello' 

A continuación, crear una instancia de la clase en su función de vista y pasar el objeto resultante a la plantilla como un parámetro para la función de render_template

my_obj = Test_jinja_object() 

en su plantilla, puede llamar a los métodos de la clase en Jinja al igual que

{{ my_obj.clever_function() }} 

Answer 10

Me gusta @AJP's answer. Lo usé textualmente hasta que terminé con muchas funciones. Luego cambié a Python function decorator.

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)) 

¡Las funciones buenas tienen un __name__!

Answer 11

Para importar todas las funciones incorporadas que puede utilizar:

app.jinja_env.globals.update(__builtins__) 

Añadir .__dict__ después __builtins__ si esto no funciona.

Basado en John32323's answer.