Chamar uma função python do jinja2

Estou usando jinja2 e quero chamar uma função python como auxiliar, usando uma sintaxe semelhante como se estivesse chamando uma macro. O jinja2 parece ter a intenção de impedir que eu faça uma chamada de função e insiste em que eu repita copiando a função em um modelo como uma macro.

Existe alguma maneira simples de fazer isso? E, existe alguma maneira de importar todo um conjunto de funções python e torná-las acessíveis a partir do jinja2, sem passar por um monte de rigamarole (como escrever uma extensão)?

Para aqueles que usam o Flask, coloque isso em __init__.py:

def clever_function():
    return u'HELLO'

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

e no seu modelo chame-o com {{ clever_function() }}

Nota: Isso é específico para o frasco!

Eu sei que este post é bastante antigo, mas existem métodos melhores para fazer isso nas versões mais recentes do Flask usando processadores de contexto.

Variáveis ​​podem ser facilmente criadas:

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

O acima pode ser usado em um modelo Jinja2 com o Flask da seguinte forma:

{{ myexample }}

(Quais saídas This is an example)

Bem como funções de pleno direito:

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

A descrição acima, quando usada da seguinte maneira:

{{ format_price(0.33) }}

(Que gera o preço de entrada com o símbolo da moeda)

Como alternativa, você pode usar filtros jinja , inseridos no Flask. Por exemplo, usando decoradores:

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

Ou, sem decoradores, e registrando manualmente a função:

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

Os filtros aplicados com os dois métodos acima podem ser usados ​​assim:

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

Eu acho que o jinja deliberadamente dificulta a execução de python 'arbitrário' dentro de um modelo. Ele tenta reforçar a opinião de que menos lógica nos modelos é uma coisa boa.

Você pode manipular o espaço para nome global em uma Environmentinstância para adicionar referências às suas funções. Isso deve ser feito antes de você carregar qualquer modelo. Por exemplo:

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

Você também pode fornecer a função nos campos conforme a resposta de Matroskin

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

Saída:

Hey, my name is Jay Kay

Funciona com o Jinja2 versão 2.7.3

E se você quer um decorador para facilitar a definição de funções, template.globalsconfira a resposta de Bruno Bronosky

Eu gosto da resposta da @ AJP . Eu o usei literalmente até terminar com muitas funções. Então mudei para um decorador de funções 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))

Coisa boa funções têm um __name__!

Nunca vi uma maneira tão simples em documentos oficiais ou no estouro de pilha, mas fiquei surpreso ao encontrar isso:

# 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 um lambda para conectar o modelo ao seu código principal

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

Em seguida, você pode chamar perfeitamente a função no modelo

{{clever_function(value)}}

Para chamar uma função python do Jinja2, você pode usar filtros personalizados que funcionam da mesma forma que os globais: http://jinja.pocoo.org/docs/dev/api/#writing-filters

É bastante simples e útil. Em um arquivo myTemplate.txt, escrevi:

{{ data|pythonFct }}

E em um 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 alguma maneira de importar todo um conjunto de funções python e tê-las acessíveis a partir do jinja2?

Sim, existe. Além das outras respostas acima, isso funciona para mim.

Crie uma classe e preencha-a com os métodos associados, por exemplo

class Test_jinja_object:

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

    def clever_function (self):
        return 'hello' 

Em seguida, crie uma instância da sua classe na sua função view e passe o objeto resultante para o seu template como um parâmetro para a função render_template

my_obj = Test_jinja_object()

Agora, no seu modelo, você pode chamar os métodos de classe no jinja dessa maneira

{{ my_obj.clever_function () }}

Para importar todas as funções internas, você pode usar:

app.jinja_env.globals.update(__builtins__)

Adicione .__dict__depois __builtins__se isso não funcionar.

Com base na resposta de John32323 .

Se você estiver fazendo isso com o Django, basta passar a função com o contexto:

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

Agora você poderá usar a strfunção no modelo jinja2

Há uma decisão muito mais simples.

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

def y(text):
    return text

Então, em test.html :

{{ y('hi') }}