Come si usano i template Django senza il resto di Django?

Voglio usare il motore di template Django nel mio codice (Python), ma non sto costruendo un sito web basato su Django. Come si usa senza avere un file settings.py (e altri) e dover impostare la variabile d'ambiente DJANGO_SETTINGS_MODULE?

Se eseguo il codice seguente:

>>> import django.template
>>> from django.template import Template, Context
>>> t = Template('My name is {{ my_name }}.')

Ottengo:

ImportError: Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.

La soluzione è semplice. In realtà è ben documentato , ma non troppo facile da trovare. (Ho dovuto scavare in giro - non è emerso quando ho provato alcune ricerche diverse su Google.)

Il codice seguente funziona:

>>> from django.template import Template, Context
>>> from django.conf import settings
>>> settings.configure()
>>> t = Template('My name is {{ my_name }}.')
>>> c = Context({'my_name': 'Daryl Spitzer'})
>>> t.render(c)
u'My name is Daryl Spitzer.'

Vedere la documentazione di Django (collegata sopra) per una descrizione di alcune delle impostazioni che potresti voler definire (come argomenti di parole chiave da configurare).

La sintassi di Jinja2 è praticamente la stessa di Django con pochissime differenze, e ottieni un motore di template molto più potente, che compila anche il tuo template in bytecode (FAST!).

Lo uso per creare modelli, incluso lo stesso Django, ed è molto buono. Puoi anche scrivere facilmente estensioni se manca qualche funzionalità che desideri.

Ecco alcune dimostrazioni della generazione del codice:

>>> import jinja2
>>> print jinja2.Environment().compile('{% for row in data %}{{ row.name | upper }}{% endfor %}', raw=True) 
from __future__ import division
from jinja2.runtime import LoopContext, Context, TemplateReference, Macro, Markup, TemplateRuntimeError, missing, concat, escape, markup_join, unicode_join
name = None

def root(context, environment=environment):
    l_data = context.resolve('data')
    t_1 = environment.filters['upper']
    if 0: yield None
    for l_row in l_data:
        if 0: yield None
        yield unicode(t_1(environment.getattr(l_row, 'name')))

blocks = {}
debug_info = '1=9'

Qualche motivo particolare per cui vuoi usare i template di Django? Sia Jinja che Genshi sono, a mio parere, superiori.

Se vuoi davvero, consulta la documentazione di Django susettings.py . Soprattutto la sezione "Utilizzo delle impostazioni senza impostazione DJANGO_SETTINGS_MODULE". Usa qualcosa del genere:

from django.conf import settings
settings.configure (FOO='bar') # Your settings go here

Consiglierei anche jinja2. C'è un bell'articolo su djangovs. jinja2che fornisce alcune informazioni dettagliate sul motivo per cui dovresti preferire il secondo.

Secondo la documentazione di Jinja, il supporto per Python 3 è ancora sperimentale . Quindi, se sei su Python 3 e le prestazioni non sono un problema, puoi utilizzare il motore di modelli integrato di django.

Django 1.8 ha introdotto il supporto per più motori di modelli che richiedono una modifica al modo in cui i modelli vengono inizializzati. Devi configurare esplicitamente settings.DEBUGquale viene utilizzato dal motore di modelli predefinito fornito da django. Ecco il codice per utilizzare i modelli senza utilizzare il resto di django.

from django.template import Template, Context
from django.template.engine import Engine

from django.conf import settings
settings.configure(DEBUG=False)

template_string = "Hello {{ name }}"
template = Template(template_string, engine=Engine())
context = Context({"name": "world"})
output = template.render(context) #"hello world"

In aggiunta a quanto scritto da altri, se vuoi usare Django Template su Django> 1.7, devi dare il tuo settings.configure (...) chiamare la variabile TEMPLATES e chiamare django.setup () in questo modo:

from django.conf import settings

settings.configure(TEMPLATES=[
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': ['.'], # if you want the templates from a file
        'APP_DIRS': False, # we have no apps
    },
])

import django
django.setup()

Quindi puoi caricare il tuo modello come normalmente, da una stringa:

from django import template   
t = template.Template('My name is {{ name }}.')   
c = template.Context({'name': 'Rob'})   
t.render(c)

E se hai scritto la variabile DIRS nel .configure, dal disco:

from django.template.loader import get_template
t = get_template('a.html')
t.render({'name': 5})

Errore Django: nessun backend DjangoTemplates è configurato

http://django.readthedocs.io/en/latest/releases/1.7.html#standalone-scripts

Direi anche Jinja . È decisamente più potente di Django Templating Engine ed è autonomo .

Se si trattava di un plug esterno a un'applicazione Django esistente, è possibile creare un comando personalizzato e utilizzare il motore di modelli all'interno dell'ambiente dei progetti. Come questo;

manage.py generatereports --format=html

Ma non credo valga la pena usare solo il Django Templating Engine invece di Jinja.

Grazie per l'aiuto gente. Ecco un'altra aggiunta. Il caso in cui è necessario utilizzare tag modello personalizzato.

Supponiamo che tu abbia questo importante tag del modello nel modulo read.py

from django import template

register = template.Library()

@register.filter(name='bracewrap')
def bracewrap(value):
    return "{" + value + "}"

Questo è il file modello html "temp.html":

{{var|bracewrap}}

Infine, ecco uno script Python che si collegherà a tutti insieme

import django
from django.conf import settings
from django.template import Template, Context
import os

#load your tags
from django.template.loader import get_template
django.template.base.add_to_builtins("read")

# You need to configure Django a bit
settings.configure(
    TEMPLATE_DIRS=(os.path.dirname(os.path.realpath(__file__)), ),
)

#or it could be in python
#t = Template('My name is {{ my_name }}.')
c = Context({'var': 'stackoverflow.com rox'})

template = get_template("temp.html")
# Prepare context ....
print template.render(c)

L'output sarebbe

{stackoverflow.com rox}

Trovato questo:

http://snippets.dzone.com/posts/show/3339

Non farlo. Uso invece StringTemplate : non c'è motivo di prendere in considerazione un altro motore di modelli una volta che ne sei a conoscenza.

Mi associo alle dichiarazioni di cui sopra. Jinja 2 è un ottimo superset di template Django per uso generale. Penso che stiano lavorando per rendere i template Django un po 'meno accoppiati a settings.py, ma Jinja dovrebbe fare bene per te.

Durante l'esecuzione della manage.pyshell:

>>> from django import template   
>>> t = template.Template('My name is {{ me }}.')   
>>> c = template.Context({'me': 'ShuJi'})   
>>> t.render(c)

Google AppEngineutilizza il motore di template Django, hai dato un'occhiata a come lo fanno? Potresti forse usarlo.