Wywołaj funkcję Pythona z jinja2

Używam jinja2 i chcę wywołać funkcję Pythona jako pomocnika, używając podobnej składni, jak gdybym wywoływał makro. jinja2 wydaje się mieć zamiar uniemożliwić mi wywołanie funkcji i nalega, abym się powtarzał, kopiując funkcję do szablonu jako makro.

Czy jest na to prosty sposób? I czy istnieje sposób na zaimportowanie całego zestawu funkcji Pythona i udostępnienie ich z jinja2 bez przechodzenia przez całą masę rygorolek (takich jak pisanie rozszerzenia)?

Dla tych, którzy używają Flaska, umieść to w swoim __init__.py :

def clever_function():
    return u'HELLO'

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

iw swoim szablonie nazwij to za pomocą {{ clever_function() }}

Uwaga: to jest specyficzne dla Flask!

Wiem, że ten post jest dość stary, ale w nowszych wersjach Flaska są lepsze metody na zrobienie tego przy użyciu procesorów kontekstu.

Zmienne można łatwo tworzyć:

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

Powyższe może być użyte w szablonie Jinja2 z Flask w następujący sposób:

{{ myexample }}

(Które wyjścia This is an example )

Oprócz pełnoprawnych funkcji:

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

Powyższe użyte w ten sposób:

{{ format_price(0.33) }}

(Który podaje cenę wejściową z symbolem waluty)

Alternatywnie możesz użyć filtrów jinja wypieczonych w Flasku. Np. Przy użyciu dekoratorów:

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

Lub bez dekoratorów i ręcznie rejestrując funkcję:

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

Filtry zastosowane dwiema powyższymi metodami mogą być używane w następujący sposób:

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

Myślę, że jinja celowo utrudnia uruchomienie „dowolnego” Pythona w szablonie. Próbuje narzucić opinię, że mniej logiki w szablonach to dobra rzecz.

Możesz manipulować globalną przestrzenią nazw w Environmentinstancji, aby dodawać odwołania do funkcji. Należy to zrobić przed załadowaniem jakichkolwiek szablonów. Na przykład:

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

Możesz również podać funkcję w polach zgodnie z odpowiedzią Matroskina

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

Wyświetli:

Hey, my name is Jay Kay

Działa z Jinja2 w wersji 2.7.3

A jeśli chcesz, aby dekorator ułatwił definiowanie funkcji, template.globalszapoznaj się z odpowiedzią Bruno Bronosky'ego

Podoba mi się odpowiedź @ AJP . Używałem go dosłownie, aż skończyło się na wielu funkcjach. Następnie przełączyłem się na dekorator funkcji Pythona .

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

Dobre funkcje mają __name__!

Nigdy nie widziałem tak prostego sposobu w oficjalnych dokumentach ani przy przepełnieniu stosu, ale byłem zdumiony, gdy znalazłem to:

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

Użyj lambdy, aby połączyć szablon z głównym kodem

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

Następnie możesz bezproblemowo wywołać funkcję w szablonie

{{clever_function(value)}}

Aby wywołać funkcję Pythona z Jinja2, możesz użyć niestandardowych filtrów, które działają podobnie jak globalne: http://jinja.pocoo.org/docs/dev/api/#writing-filters

To całkiem proste i przydatne. W pliku myTemplate.txt napisałem:

{{ data|pythonFct }}

A w skrypcie Pythona:

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)

czy istnieje sposób na zaimportowanie całego zestawu funkcji Pythona i udostępnienie ich w jinja2?

Tak, oprócz innych odpowiedzi powyżej, to działa dla mnie.

Utwórz klasę i wypełnij ją powiązanymi metodami, np

class Test_jinja_object:

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

    def clever_function (self):
        return 'hello' 

Następnie utwórz instancję swojej klasy w funkcji widoku i przekaż wynikowy obiekt do szablonu jako parametr funkcji render_template

my_obj = Test_jinja_object()

Teraz w swoim szablonie możesz wywoływać metody klas w jinja w ten sposób

{{ my_obj.clever_function () }}

Aby zaimportować wszystkie wbudowane funkcje, których możesz użyć:

app.jinja_env.globals.update(__builtins__)

Dodaj .__dict__po__builtins__ jeśli to nie zadziała.

Na podstawie odpowiedzi John32323 .

Jeśli robisz to z Django, możesz po prostu przekazać funkcję z kontekstem:

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

Teraz będziesz mógł korzystać z strfunkcji w szablonie jinja2

Jest o wiele prostsza decyzja.

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

def y(text):
    return text

Następnie w pliku test.html :

{{ y('hi') }}