flacon plan modèle de dossier

En plus de linqq de bonnes suggestions ci-dessus, vous pouvez également remplacer la fonctionnalité par défaut si nécessaire. Il y a deux façons:

On peut remplacer create_global_jinja_loader dans un sous-classé Flacon d'application (qui renvoie un DispatchingJinjaLoader définis dans flask/templating.py). Ce n'est pas recommandé, mais pourrait fonctionner. La raison que c'est déconseillé, c'est que le DispatchingJinjaLoader a suffisamment de flexibilité pour soutenir l'injection de la coutume des chargeurs. Et si vous vissez votre propre chargeur en place, il va pouvoir se pencher sur par défaut, sane fonctionnalité.

Donc, ce qui est recommandé, c'est que l'on "remplacer la jinja_loader fonction" à la place. C'est là que le manque de documentation est en. Correctifs Flacon de chargement de la stratégie nécessite quelques connaissances qui ne semble pas être documentées, ainsi qu'une bonne compréhension de Jinja2.

Il y a deux composants dont vous avez besoin pour comprendre:

• De la Jinja2 environnement
• De la Jinja2 modèle de chargeur

Elles sont créées par Flacon, avec des paramètres par défaut, automatiquement. (Vous pouvez spécifier votre propre Jinja2 options, par la manière, par des raisons impérieuses app.jinja_options -- mais gardez à l'esprit que vous perdrez à deux extensions qui Fiole inclut par défaut -- autoescape et with -- sauf si vous spécifiez vous-même. Jetez un oeil à flask/app.py pour voir comment ils font référence à ceux-ci.)

L'environnement contient tous ceux contexte processeurs (par exemple, de sorte que vous pouvez faire var|tojson dans un modèle), des fonctions d'assistance (url_for, etc) et des variables (g, session, app). Il contient également une référence à un modèle de chargeur, dans ce cas susmentionnés et de l'auto-instancié DispatchingJinjaLoader. Ainsi, lorsque vous appelez render_template dans votre application, il trouve ou crée de la Jinja2 de l'environnement, met en place toutes ces bonnes choses, et des appels get_template sur elle, qui à son tour appelle get_source à l'intérieur de la DispatchingJinjaLoader, qui tente quelques stratégies décrites plus tard.

Si tout se passe selon le plan, que la chaîne se résoudre à trouver un fichier et retourne son contenu (et certains d'autres données). Aussi, notez que c'est le même chemin d'exécution qui {% extend 'foo.htm' %} prend.

DispatchingJinjaLoader fait deux choses: d'Abord, il vérifie si l'application globale de chargeur, qui est app.jinja_loader pouvez localiser le fichier. À défaut, il vérifie tous des modèles d'application (par ordre d'inscription, autant que je sache) pour blueprint.jinja_loader dans une tentative pour localiser le fichier. Suivi de la chaîne à la fin, ici est la définition de jinja_loader (en flask/helpers.py, _PackageBoundObject la classe de base, à la fois de la Fiole d'application et les Plans):

def jinja_loader(self):
    """The Jinja loader for this package bound object.

    .. versionadded:: 0.5
    """
    if self.template_folder is not None:
        return FileSystemLoader(os.path.join(self.root_path,
                                             self.template_folder))

Ah! Alors maintenant que nous voyons. Évidemment, les espaces de noms de conflit au cours de la même noms de répertoire. Depuis le mondial chargeur est appelé en premier, il va toujours gagner. (FileSystemLoader est l'un de plusieurs la norme Jinja2 chargeurs.) Cependant, ce que cela signifie, c'est qu'il n'y a pas vraiment de moyen simple de réorganiser le Plan directeur et l'ensemble de l'application du modèle de chargeur.

Donc, nous avons besoin de modifier le comportement de DispatchingJinjaLoader. Pendant un moment, je pensais qu'il n'était pas bon non découragés et efficace façon d'aller à ce sujet. Cependant, apparemment, si vous remplacez app.jinja_options['loader'] lui-même, nous pouvons obtenir le comportement que nous voulons. Donc, si nous sous -DispatchingJinjaLoader, et de modifier une petite fonction (je suppose qu'il pourrait être préférable de le ré-écrire entièrement, mais cela fonctionne pour l'instant), nous avons le comportement que nous voulons. Au total, une stratégie raisonnable serait la suivante (non testé, mais devrait fonctionner avec moderne Flacon applications):

from flask.templating import DispatchingJinjaLoader
from flask.globals import _request_ctx_stack

class ModifiedLoader(DispatchingJinjaLoader):
    def _iter_loaders(self, template):
        bp = _request_ctx_stack.top.request.blueprint
        if bp is not None and bp in self.app.blueprints:
            loader = self.app.blueprints[bp].jinja_loader
            if loader is not None:
                yield loader, template

        loader = self.app.jinja_loader
        if loader is not None:
            yield loader, template

Cela modifie la stratégie de l'original chargeur de deux façons: Tentative de chargement du modèle (et SEULEMENT en cours d'exécution plan, pas tous les modèles) en premier, et si cela échoue, alors seulement la charge de l'application. Si vous aimez les tout-plan du comportement, vous pouvez faire quelques copier-pâtes de flask/templating.py.

De lier tout cela ensemble, vous devez définir jinja_options sur le Flacon de l'objet:

app = Flask(__name__)
# jinja_options is an ImmutableDict, so we have to do this song and dance
app.jinja_options = Flask.jinja_options.copy() 
app.jinja_options['loader'] = ModifiedLoader(app)

La première fois un modèle de l'environnement est nécessaire (et donc instancié), c'est la première fois render_template est appelée, votre chargeur doit être utilisé.

Je suis en utilisant quelque chose comme ça sur fypress et fybb parce que j'ai un système de thème.

# utils.templates
from jinja2 import Environment, PackageLoader
from flask.templating import _default_template_ctx_processor
from flask import current_app, url_for, get_flashed_messages


admin_env = Environment(
    loader=PackageLoader('fypress', '/templates/admin/'),
    extensions=['jinja2.ext.autoescape', 'jinja2.ext.with_'],
    autoescape=True
)

def render_template(template, **kwargs):
    kwargs.update(_default_template_ctx_processor())
    kwargs.update({
        'url_for': url_for,
        'get_flashed_messages': get_flashed_messages # etc...

    })
    kwargs.update(dict(debug=current_app.config.get('DEBUG'), flask_config=current_app.config))

    template = admin_env.get_template(template)
    return template.render(**kwargs)

Et puis

# routes.admin.
from flask import Blueprint
from utils.templates import render_template

admin_bp = Blueprint('admin', __name__,  url_prefix='/admin')

@admin_bp.route('/')
def root():
    return render_template('index.html', title='Admin')