Bouteille fichiers statiques

Pour servir des fichiers statiques en utilisant bottle, vous devrez utiliser la fonction static_file fournie et ajouter quelques routes supplémentaires. Les itinéraires suivants dirigent les demandes de fichiers statiques et garantissent que seuls les fichiers avec l'extension de fichier correcte sont accessibles.

from bottle import get, static_file

# Static Routes
@get("/static/css/<filepath:re:.*\.css>")
def css(filepath):
    return static_file(filepath, root="static/css")

@get("/static/font/<filepath:re:.*\.(eot|otf|svg|ttf|woff|woff2?)>")
def font(filepath):
    return static_file(filepath, root="static/font")

@get("/static/img/<filepath:re:.*\.(jpg|png|gif|ico|svg)>")
def img(filepath):
    return static_file(filepath, root="static/img")

@get("/static/js/<filepath:re:.*\.js>")
def js(filepath):
    return static_file(filepath, root="static/js")

Maintenant, dans votre html, vous pouvez référencer un fichier comme ceci:

<link type="text/css" href="/static/css/main.css" rel="stylesheet">

Disposition du répertoire:

`--static
|  `--css
|  `--fonts
|  `--img
|  `--js

Juste fournir une réponse ici parce qu'un certain nombre de mes étudiants ont utilisé ce code dans une tâche et j'ai un peu d'inquiétude au sujet de la solution.

La manière standard de servir les fichiers statiques dans Bottle se trouve dans la documentation :

from bottle import static_file
@route('/static/<filepath:path>')
def server_static(filepath):
    return static_file(filepath, root='/path/to/your/static/files')

De cette façon, tous les fichiers sous votre dossier statique sont servis à partir d'une URL commençant par /static. Dans votre HTML, vous devez référencer le chemin D'URL complet de la ressource, par exemple:

<link rel='stylesheet' type='text/css' href='/static/css/style.css'>

La réponse de Sanketh fait en sorte que toute référence à une image, fichier css etc n'importe où dans L'espace URL est servi à partir d'un dossier donné dans le dossier statique. Alors / foo / bar / baz / image.jpg et /image.jpg serait à la fois servi de statique / images / Image.jpg. Cela signifie que vous n'avez pas besoin de vous soucier d'obtenir le bon chemin dans votre code HTML et vous pouvez toujours utiliser des noms de fichiers relatifs (ie. juste src="image.jpg").

Le problème avec cette approche vient lorsque vous essayez de déployer votre application. Dans un environnement de production vous voulez que les ressources statiques soient servies par un serveur web comme nginx, pas par votre application Bottle. Pour activer cela, ils doivent tous être servis à partir d'une seule partie de l'espace URL, par exemple. /statique. Si votre code est jonché de noms de fichiers relatifs, il ne se traduira pas facilement vers ce modèle.

Donc, je vous conseille d'utiliser la solution à trois lignes du tutoriel de la bouteille plutôt que la solution plus complexe répertoriée sur cette page. C'est un code plus simple (donc moins susceptible d'être bogué) et il vous permet de passer de manière transparente à un environnement de production sans modifications de code.

Plutôt que d'utiliser la correspondance d'expression régulière pour servir les fichiers comme dans la réponse de Sanketh, je préférerais ne pas modifier mes modèles et fournir explicitement un chemin vers les fichiers statiques, comme dans:

<script src="{{ get_url('static', filename='js/bootstrap.min.js') }}"></script>

, Vous pouvez le faire simplement en remplaçant les <filename> dans l'itinéraire statique décorateur: l'une de type :path comme:

@app.route('/static/<filename:path>', name='static')
def serve_static(filename):
    return static_file(filename, root=config.STATIC_PATH)

Le :path correspond à un chemin de fichier entier d'une manière non gourmande afin que vous n'ayez pas à vous soucier de changer de modèle lors du passage à la production-gardez tout dans la même structure de dossier relative.

J'ai utilisé le modèle de Sanketh dans le passé, mais au fil du temps condensé à une fonction agnostique d'extension. Il vous suffit d'ajouter des mappages de dossier d'extension dans le dictionnaire ext_map. Il est par défaut static / folder si une extension n'est pas mappée explicitement.

import os.path    

# Static Routes
@get('/<filename>')
def serve_static_file(filename):
    ext = os.path.splitext(filename)[1][1:]
    ext_map = {'image':['png','gif','jpg','ico'],'js':['js']}
    sub_folder = next((k for k, v in ext_map.items() if ext in v),'')
    return static_file(filename, root='static/'+sub_folder)