Comment utiliser les modèles Django sans le reste de Django?

Question

Je souhaite utiliser le moteur de modèles Django dans mon code (Python), mais je ne construis pas de site Web basé sur Django. Comment l'utiliser sans avoir un fichier settings.py (et autres) et sans avoir à définir la variable d'environnement DJANGO_SETTINGS_MODULE?

Si je lance le code suivant:

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

je reçois:

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

Answer 1

La solution est simple. Il s’agit en réalité de bien documenté , mais pas trop facile à trouver. (J'ai dû creuser. Cela n'a pas été possible lorsque j'ai essayé plusieurs recherches différentes sur Google.)

Le code suivant fonctionne:

>>> 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.'

Voir la documentation de Django (lien ci-dessus) pour une description de certains paramètres que vous pouvez définir (en tant qu'arguments de mot-clé à configurer).

Answer 2

Jinja2 La syntaxe est à peu près identique à celle de Django, avec très peu de différences, et vous obtenez un moteur de gabarit bien plus puissant, qui compile également votre modèle en bytecode (FAST!).

Je l’utilise pour la création de modèles, y compris dans Django même, et c’est très bien. Vous pouvez également écrire facilement des extensions si certaines fonctionnalités de votre choix sont manquantes.

Voici une démonstration de la génération de code:

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

Answer 3

Une raison particulière pour laquelle vous souhaitez utiliser les modèles de Django? Jinja et Genshi sont, à mon avis, supérieurs.

Si vous le souhaitez vraiment, consultez la documentation Django sur < code> settings.py . En particulier, la section "Utilisation des paramètres sans définir DJANGO_SETTINGS_MODULE ". Utilisez quelque chose comme ceci:

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

Answer 4

Je recommanderais également jinja2. Il y a un bel article sur django vs jinja2 qui donne des informations détaillées sur les raisons pour lesquelles vous devriez préférer le plus tard.

Answer 5

Selon la documentation de Jinja, le est toujours supporté. expérimental . Donc, si vous êtes sur Python 3 et que les performances ne sont pas un problème, vous pouvez utiliser le moteur de templates intégré de django.

Django 1.8 a introduit le support pour les moteurs de modèles multiples qui nécessite une modification de la manière dont les modèles sont initialisés. Vous devez configurer explicitement settings.DEBUG qui est utilisé par le moteur de template par défaut fourni par django. Voici le code pour utiliser des modèles sans utiliser le reste de 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"

Answer 6

Je dirais aussi Jinja . Il est certainement plus puissant que Django Templating Engine et autonome .

S'il s'agissait d'un plug-in externe à une application Django existante, vous pouvez créer une commande personnalisée et utilisez le moteur de modélisation dans votre environnement de projets. Comme ça;

manage.py generatereports --format=html

Mais je ne pense pas qu'il vaille la peine d'utiliser le moteur de création de modèles Django au lieu de Jinja.

Answer 7

Merci pour votre aide. Voici encore un ajout. Le cas où vous devez utiliser des balises de modèle personnalisées.

Disons que vous avez cette balise de modèle importante dans le module read.py

from django import template

register = template.Library()

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

Il s'agit du fichier de modèle html "temp.html":

{{var|bracewrap}}

Enfin, voici un script Python qui sera lié à tous ensemble

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)

La sortie serait

{stackoverflow.com rox}

Answer 8

trouvé ceci:

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

Answer 9

Ne pas. Utilisez plutôt StringTemplate - il n'y a aucune raison d'envisager un autre moteur de modèle une fois que vous en êtes informé.

Answer 10

Un ajout à ce que d'autres ont écrit, si vous souhaitez utiliser Django Template sur Django > 1.7, vous devez donner à votre settings.configure (...) appeler la variable TEMPLATES et appeler django.setup () comme ceci:

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

Ensuite, vous pouvez charger votre modèle normalement, à partir d'une chaîne:

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

Et si vous avez écrit la variable DIRS dans la .configure, à partir du disque:

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

Erreur Django: aucun backend DjangoTemplates n'est configuré.

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

Answer 11

Je fais écho aux déclarations ci-dessus. Jinja 2 est un très bon sur-ensemble de modèles Django à usage général. Je pense qu’ils travaillent à rendre les modèles Django un peu moins couplés à settings.py, mais Jinja devrait bien vous servir.

Answer 12

Lors de l'exécution du shell manage.py :

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

Answer 13

Google AppEngine utilise le moteur de templates Django, avez-vous examiné comment ils le font? Vous pourriez peut-être simplement l'utiliser.