Appeler une fonction python depuis jinja2

J'utilise jinja2, et je veux appeler une fonction python comme aide, en utilisant une syntaxe similaire comme si j'appelais une macro. jinja2 semble vouloir m'empêcher de faire un appel de fonction, et insiste pour que je me répète en copiant la fonction dans un modèle sous forme de macro.

Existe-t-il un moyen simple de le faire? Et, y a-t-il un moyen d'importer tout un ensemble de fonctions python et de les rendre accessibles à partir de jinja2, sans passer par beaucoup de rigamarole (comme l'écriture d'une extension)?

Pour ceux qui utilisent Flask, mettez ceci dans votre __init__.py:

def clever_function():
    return u'HELLO'

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

et dans votre modèle, appelez-le avec {{ clever_function() }}

Remarque: ceci est spécifique à Flask!

Je sais que cet article est assez ancien, mais il existe de meilleures méthodes pour le faire dans les nouvelles versions de Flask utilisant des processeurs de contexte.

Les variables peuvent être facilement créées:

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

Ce qui précède peut être utilisé dans un modèle Jinja2 avec Flask comme ceci:

{{ myexample }}

(Quelles sorties This is an example)

Ainsi que des fonctions à part entière:

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

Ce qui précède lorsqu'il est utilisé comme ceci:

{{ format_price(0.33) }}

(Qui sort le prix d'entrée avec le symbole monétaire)

Vous pouvez également utiliser des filtres jinja , cuits dans Flask. Par exemple en utilisant des décorateurs:

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

Ou, sans décorateurs, et en enregistrant manuellement la fonction:

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

Les filtres appliqués avec les deux méthodes ci-dessus peuvent être utilisés comme ceci:

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

Je pense que jinja rend délibérément difficile l'exécution de python «arbitraire» dans un modèle. Il essaie de renforcer l'opinion selon laquelle moins de logique dans les modèles est une bonne chose.

Vous pouvez manipuler l'espace de noms global dans une Environmentinstance pour ajouter des références à vos fonctions. Cela doit être fait avant de charger des modèles. Par exemple:

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

Vous pouvez également donner la fonction dans les champs selon la réponse de Matroskin

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

Sortira:

Hey, my name is Jay Kay

Fonctionne avec Jinja2 version 2.7.3

Et si vous voulez qu'un décorateur facilite la définition des fonctions, template.globalsconsultez la réponse de Bruno Bronosky

J'aime la réponse de @ AJP . Je l'ai utilisé textuellement jusqu'à ce que je me retrouve avec beaucoup de fonctions. Ensuite, je suis passé à un décorateur de fonctions 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))

Les bonnes fonctions ont un __name__!

Jamais vu un moyen aussi simple dans les documents officiels ou au débordement de pile, mais j'ai été étonné quand j'ai trouvé ceci:

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

Utilisez un lambda pour connecter le modèle à votre code principal

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

Ensuite, vous pouvez appeler la fonction de manière transparente dans le modèle

{{clever_function(value)}}

Pour appeler une fonction python depuis Jinja2, vous pouvez utiliser des filtres personnalisés qui fonctionnent de la même manière que les globals: http://jinja.pocoo.org/docs/dev/api/#writing-filters

C'est assez simple et utile. Dans un fichier myTemplate.txt, j'ai écrit:

{{ data|pythonFct }}

Et dans un script 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)

existe-t-il un moyen d'importer tout un ensemble de fonctions python et de les rendre accessibles à partir de jinja2?

Oui, en plus des autres réponses ci-dessus, cela fonctionne pour moi.

Créez une classe et remplissez-la avec les méthodes associées, par exemple

class Test_jinja_object:

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

    def clever_function (self):
        return 'hello' 

Ensuite, créez une instance de votre classe dans votre fonction de vue et transmettez l'objet résultant à votre modèle en tant que paramètre de la fonction render_template

my_obj = Test_jinja_object()

Maintenant, dans votre modèle, vous pouvez appeler les méthodes de classe dans jinja comme ceci

{{ my_obj.clever_function () }}

Pour importer toutes les fonctions intégrées, vous pouvez utiliser:

app.jinja_env.globals.update(__builtins__)

Ajoutez .__dict__après __builtins__si cela ne fonctionne pas.

Basé sur la réponse de John32323 .

Si vous le faites avec Django, vous pouvez simplement passer la fonction avec le contexte:

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

Vous pourrez maintenant utiliser la strfonction dans le modèle jinja2

Il y a une décision beaucoup plus simple.

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

def y(text):
    return text

Ensuite, dans test.html :

{{ y('hi') }}