Comment servir les fichiers statiques dans le Flacon

Donc, c'est embarrassant. J'ai une application que j'ai jeté dans Flask et pour l'instant, il est juste à servir une seule page HTML statique avec quelques liens vers des CSS et JS. Et je ne trouve pas où dans la documentation Flask décrit le retour des fichiers statiques. Oui, je pourrais l'utiliser render_template mais je sais que les données ne sont pas templatized. J'aurais pensé send_file ou url_for était la bonne chose, mais je ne pouvais pas obtenir ces au travail. En attendant, je vais ouvrir les fichiers, la lecture du contenu, et le gréement d'un Response appropriées type mime:

import os.path

from flask import Flask, Response


app = Flask(__name__)
app.config.from_object(__name__)


def root_dir():  # pragma: no cover
    return os.path.abspath(os.path.dirname(__file__))


def get_file(filename):  # pragma: no cover
    try:
        src = os.path.join(root_dir(), filename)
        # Figure out how flask returns static files
        # Tried:
        # - render_template
        # - send_file
        # This should not be so non-obvious
        return open(src).read()
    except IOError as exc:
        return str(exc)


@app.route('/', methods=['GET'])
def metrics():  # pragma: no cover
    content = get_file('jenkins_analytics.html')
    return Response(content, mimetype="text/html")


@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def get_resource(path):  # pragma: no cover
    mimetypes = {
        ".css": "text/css",
        ".html": "text/html",
        ".js": "application/javascript",
    }
    complete_path = os.path.join(root_dir(), path)
    ext = os.path.splitext(path)[1]
    mimetype = mimetypes.get(ext, "text/html")
    content = get_file(complete_path)
    return Response(content, mimetype=mimetype)


if __name__ == '__main__':  # pragma: no cover
    app.run(port=80)

Quelqu'un veut donner un exemple de code ou d'une url pour cela? Je sais que cela va être simple.

Pourquoi ne pas utiliser nginx ou d'autres serveurs web pour servir les fichiers statiques.
Veuillez garder à l'esprit que la façon dont vous avez réellement "servir" les fichiers seront probablement différentes entre la production (sur votre serveur web) et de développement (sur votre ordinateur local, ou une autre zone de test). Que certaines réponses ont souligné, vous n'aurez probablement PAS envie de servir vos fichiers statiques avec flacon, mais plutôt dans leur propre répertoire et alors votre serveur web (Apache, nginx, etc.) serveur les fichiers directement.
Double Possible de les fichiers Statiques dans le Flacon robot.txt, sitemap.xml (mod_wsgi)
"Pourquoi ne pas utiliser nginx ..." Parce que quand je suis en cours d'exécution dans le mode développeur sur mon ordinateur portable, il est agréable de vous devez exécuter une chose et une seule chose. Oui, ça rend les choses un peu différentes, mais c'est correct.
Même dans la production, c'est très très courant de voir cela, avec bien sûr un cache couche à l'avant (comme un Vernis ou Nginx ou un CDN).
Voir aussi: Fiole plan statique répertoire ne fonctionne pas?

InformationsquelleAutor hughdbrown | 2013-12-17

562

La méthode préférée consiste à utiliser nginx ou un autre serveur web de servir les fichiers statiques; ils vont être en mesure de le faire plus efficacement que ne le Flacon.

Toutefois, vous pouvez utiliser send_from_directory pour envoyer des fichiers à partir d'un répertoire, ce qui peut être très pratique dans certaines situations:
```
from flask import Flask, request, send_from_directory

# set the project root directory as the static folder, you can set others.
app = Flask(__name__, static_url_path='')

@app.route('/js/<path:path>')
def send_js(path):
    return send_from_directory('js', path)

if __name__ == "__main__":
    app.run()
```
Ne pas utilisation send_file ou send_static_file avec une fourni par l'utilisateur chemin.

send_static_file exemple:
```
from flask import Flask, request
# set the project root directory as the static folder, you can set others.
app = Flask(__name__, static_url_path='')

@app.route('/')
def root():
    return app.send_static_file('index.html')
```
- à l'appui de Windows: return app.send_static_file(os.chemin d'accès.join('js', chemin d'accès).remplacer('\\','/'))
- un attaquant peut exploiter cette méthode pour parcourir le flacon fichiers source en parcourant genre de /js/ <astucieux encodage de "../yourflaskapp.py"> ?
- href="http://flask.pocoo.org/docs/api/#flask.send_from_directory" >send_from_directory est conçu pour résoudre ce problème de sécurité. Il existe d'erreur si le chemin mène à l'extérieur du répertoire particulier.
- "Ne pas utiliser send_file ou send_static_file avec une fourni par l'utilisateur chemin." pourquoi pas?
- Je suppose qu'il n'est pas assurez-vous de ne pas conduire hors du répertoire désigné, dans ce cas, ils ont accès à des fichiers, ils ne devraient pas avoir accès à
- Voir "directory traversal attaque."
- Cela fonctionne pour les petits projets bien! 😀
- Je vous suggère aussi d'utiliser return redirect(url_for('static', filename='index.html')) au lieu de send_static_file si c'est ce que vous allez pour. Les deux sont bons. J'utilise rediriger sur mon serveur de dev.
- Désolé, je ne suis pas un expert Python, mais quelqu'un peut-il expliquer, pourquoi il est <path:path> et pas <path>?
- il n'a rien à voir avec Python per se, c'est Fiole convention pour définir les paramètres d'URL (voir http://flask.pocoo.org/docs/0.12/api/#url-route-registrations). En un mot <path> est équivalent à <string:path>, et parce que vous voulez Flacon pour assurer un chemin, comme les paramètre que vous demandez pour <path:path>.
- Toutes les explications possibles pour expliquer pourquoi un send_static_file ne fonctionnent pas comme prévu lorsque send_from_directory échoue? Je ne peux pas comprendre comment déboguer le send_from_directory fonction et savoir pourquoi il me 404s. (Mon problème est ici, si vous êtes curieux)
InformationsquelleAutor atupal
80

Si vous voulez juste pour déplacer l'emplacement de vos fichiers statiques, alors la méthode la plus simple est de déclarer les chemins d'accès dans le constructeur. Dans l'exemple ci-dessous, j'ai déplacé mes modèles et des fichiers statiques dans un sous-dossier appelé web.
```
app = Flask(__name__,
            static_url_path='', 
            static_folder='web/static',
            template_folder='web/templates')
```
- static_url_path='' supprime tous les précédents chemin de l'URL (c'est à dire
  la valeur par défaut /static).
- static_folder='web/static' dira Flacon de servir les fichiers trouvés à
  web/static.
- template_folder='web/templates', de la même façon, ce qui change la
  le dossier de modèles.
À l'aide de cette méthode, l'URL suivante sera de retour un fichier CSS:
```
<link rel="stylesheet" type="text/css" href="/css/bootstrap.min.css">
```
Et enfin, voici un composant logiciel enfichable de la structure de dossier, où flask_server.py est le Flacon exemple:
- C'est ce qui a fonctionné pour moi aussi. Send_from_directory n'a tout simplement pas de travail malgré toutes les recommandations pour elle.
- C'est la seule qui a fonctionné pour moi! 🙂
InformationsquelleAutor Richard Dunn
76

Je suis sûr que vous trouverez ce dont vous avez besoin: http://flask.pocoo.org/docs/quickstart/#static-files

Fondamentalement, vous avez juste besoin d'un "statique" dossier à la racine de votre colis, et vous pouvez ensuite utiliser url_for('static', filename='foo.bar') ou directement de lien vers vos fichiers avec http://example.com/static/foo.bar.

MODIFIER: Comme suggéré dans les commentaires que vous pourriez utiliser directement les '/static/foo.bar' chemin d'accès d'URL MAIS url_for() frais généraux (performance sage) est assez faible, et l'utiliser signifie que vous serez en mesure de facilement personnaliser le comportement de la suite (changer le dossier, modifiez le chemin d'accès d'URL, déplacez vos fichiers statiques pour S3, etc).
- Pourquoi ne pas '/static/foo.bar' directement?
- est la droite - si vous souhaitez mettre un lien vers un fichier qui est déjà enregistré dans votre répertoire statique, vous pouvez accéder directement à elle sans aucune route code.
- modifié pour inclure vos suggestions.
InformationsquelleAutor b4stien
75

Vous pouvez aussi, et c'est mon préféré, définir un dossier comme statique chemin de sorte que les fichiers à l'intérieur sont accessibles pour tout le monde.
```
app = Flask(__name__, static_url_path='/static')
```
Avec qui vous pouvez utiliser le standard HTML:
```
<link rel="stylesheet" type="text/css" href="/static/style.css">
```
- Fonctionne bien si il y a un fichier project/static/style.css disponibles.
- la ligne "app = Flacon(....)" besoins "static_folder" être un paramètre trop
- J'ai été aux prises avec ce problème pendant des heures! Je ne manquait qu'un seul argument!
InformationsquelleAutor sharpshadow
37

Ce que j'utilise (et ça a été génial de travailler) est un des "modèles" de répertoire et un "statique" du répertoire. Je place tous mes .les fichiers html/Flacon de modèles à l'intérieur du répertoire de modèles et statique contient CSS/JS. render_template fonctionne très bien pour les fichiers html à ma connaissance, quelle que soit la mesure à laquelle vous avez utilisé Flacon de syntaxe spécifique. Ci-dessous est un exemple d'appel dans mon views.py fichier.
```
@app.route('/projects')
def projects():
    return render_template("projects.html", title = 'Projects')
```
Juste assurez-vous d'utiliser url_for() si vous ne voulez référence statique fichier dans le répertoire statique. Vous aurez probablement finir par faire cela de toute façon dans votre CSS/JS des liens vers des fichiers au format html. Par exemple...
```
<script src="{{ url_for('static', filename='styles/dist/js/bootstrap.js') }}"></script>
```
Voici un lien vers le "canonique" informel Flacon tutoriel - beaucoup de bons conseils ici pour vous aider à frapper le sol en cours d'exécution.

http://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world

InformationsquelleAutor Kyle Sum
37

Vous pouvez utiliser cette fonction :

send_static_file(filename)

Fonction utilisée en interne pour envoyer statique
les fichiers de la statique dossier pour le navigateur.
```
app = Flask(__name__)
@app.route('/<path:path>')
def static_file(path):
    return app.send_static_file(path)
```
- C'est la seule qui a fonctionné pour moi sans un grand mal de tête.
- De même. Où je me rends compte Flash s'appuie fortement sur l'idée que nous allons utiliser leur système de template, ce n'est pas quelques RIA où le HTML est produit ailleurs.
- AVERTISSEMENT: Ceci est un énorme problème de sécurité pour appeler send_static_file avec la saisie de l'utilisateur. Ne pas utiliser cette solution dans quelque chose d'important.
InformationsquelleAutor BlackMamba
35

Un simple exemple de travail sur la base des autres réponses est la suivante:
```
from flask import Flask, request
app = Flask(__name__, static_url_path='')

@app.route('/index/')
def root():
    return app.send_static_file('index.html')

if __name__ == '__main__':
  app.run(debug=True)
```
Avec le HTML appelé index.html:
```
<!DOCTYPE html>
<html>
<head>
    <title>Hello World!</title>
</head>
<body>
    <div>
         <p>
            This is a test.
         </p>
    </div>
</body>
</html>
```
IMPORTANT: Et index.html dans un dossier appelé statique, sens <projectpath> a la .py fichier, et <projectpath>\static a la html fichier.

Si vous souhaitez que le serveur soit visible sur le réseau, utilisez app.run(debug=True, host='0.0.0.0')

EDIT: Pour afficher tous les fichiers dans le dossier si nécessaire, utilisez ce
```
@app.route('/<path:path>')
def static_file(path):
    return app.send_static_file(path)
```
Qui est essentiellement BlackMamba's réponse, afin de leur donner un upvote.
- Merci pour l'observation importante!
InformationsquelleAutor EpicPandaForce

Angulaire+passe-partout de débit, ce qui crée à côté de l'arbre de dossiers:

backend/
|
|------ui/
|      |------------------build/          <--'static' folder, constructed by Grunt
|      |--<proj           |----vendors/   <-- angular.js and others here
|      |--     folders>   |----src/       <-- your js
|                         |----index.html <-- your SPA entrypoint 
|------<proj
|------     folders>
|
|------view.py  <-- Flask app here

Je utiliser la solution suivante:

...
root = os.path.join(os.path.dirname(os.path.abspath(__file__)), "ui", "build")

@app.route('/<path:path>', methods=['GET'])
def static_proxy(path):
    return send_from_directory(root, path)


@app.route('/', methods=['GET'])
def redirect_to_index():
    return send_from_directory(root, 'index.html')
...

Il contribue à redéfinir "statique" dossier personnalisé.

basé sur vos réponses j'ai fait ceci: stackoverflow.com/a/29521067/303114 notez que j'ai utilisé 'add_url_rule' intead "route" qui est essentiellement le même

InformationsquelleAutor user1671599

Donc j'ai eu des choses de travail (basé sur @user1671599 réponse) et je voulais partager avec vous les gars.

(J'espère que je suis en train de faire puisque c'est ma première application en Python)

Je l'ai fait -

Structure de projet:

Comment servir les fichiers statiques dans le Flacon

server.py:

from server.AppStarter import AppStarter
import os

static_folder_root = os.path.join(os.path.dirname(os.path.abspath(__file__)), "client")

app = AppStarter()
app.register_routes_to_resources(static_folder_root)
app.run(__name__)

AppStarter.py:

from flask import Flask, send_from_directory
from flask_restful import Api, Resource
from server.ApiResources.TodoList import TodoList
from server.ApiResources.Todo import Todo


class AppStarter(Resource):
    def __init__(self):
        self._static_files_root_folder_path = ''  # Default is current folder
        self._app = Flask(__name__)  # , static_folder='client', static_url_path='')
        self._api = Api(self._app)

    def _register_static_server(self, static_files_root_folder_path):
        self._static_files_root_folder_path = static_files_root_folder_path
        self._app.add_url_rule('/<path:file_relative_path_to_root>', 'serve_page', self._serve_page, methods=['GET'])
        self._app.add_url_rule('/', 'index', self._goto_index, methods=['GET'])

    def register_routes_to_resources(self, static_files_root_folder_path):

        self._register_static_server(static_files_root_folder_path)
        self._api.add_resource(TodoList, '/todos')
        self._api.add_resource(Todo, '/todos/<todo_id>')

    def _goto_index(self):
        return self._serve_page("index.html")

    def _serve_page(self, file_relative_path_to_root):
        return send_from_directory(self._static_files_root_folder_path, file_relative_path_to_root)

    def run(self, module_name):
        if module_name == '__main__':
            self._app.run(debug=True)

pour mieux comprendre, vous pouvez lire cette réponse: stackoverflow.com/a/23501776/303114 (qui vous renvoie à la source sur github)

InformationsquelleAutor danfromisrael

3

Pensé à partager.... cet exemple.
```
from flask import Flask
app = Flask(__name__)

@app.route('/loading/')
def hello_world():
    data = open('sample.html').read()    
    return data

if __name__ == '__main__':
    app.run(host='0.0.0.0')
```
Cela fonctionne mieux et plus simple.
- Pouvez-vous préciser comment sera-ce de travailler mieux?
- lmao toute autre méthode m'a donné un peu ennuyeux fichier non trouvé des erreurs. nice1 jeevan
InformationsquelleAutor Jeevan Chaitanya
3

L'un de la manière la plus simple de le faire. Cheers!

demo.py
```
from flask import Flask, render_template
app = Flask(__name__)

@app.route("/")
def index():
   return render_template("index.html")

if __name__ == '__main__':
   app.run(debug = True)
```
Maintenant créer un dossier du nom appelé modèles.
Ajouter votre index.html fichier à l'intérieur de modèles dossier

index.html
```
<!DOCTYPE html>
<html>
<head>
    <title>Python Web Application</title>
</head>
<body>
    <div>
         <p>
            Welcomes You!!
         </p>
    </div>
</body>
</html>
```
Structure De Projet
```
-demo.py
-templates/index.html
```
- vous n'avez pas lu la question. J'ai expressément dit que j'étais conscient de la render_template solution, mais ne voulait pas le faire parce que le fichier est statique sans remplacements: "Oui, je pourrais l'utiliser render_template mais je sais que les données ne sont pas templatized."
InformationsquelleAutor Maheshvirus

from flask import redirect, url_for
...
@app.route('/', methods=['GET'])
def metrics():
    return redirect(url_for('static', filename='jenkins_analytics.html'))

Cette serveurs tous les fichiers (css & js...) référencées dans votre fichier html.

InformationsquelleAutor forzagreen

1

Toutes les réponses sont bonnes, mais ce qui a bien fonctionné pour moi, c'est juste à l'aide de la fonction simple send_file de Flacon. Cela fonctionne bien lorsque vous avez juste besoin d'envoyer un fichier html comme réponse quand host:port/ApiName montrera la sortie du fichier dans le navigateur
```
@app.route('/ApiName')
def ApiFunc():
    try:
        return send_file('some-other-directory-than-root/your-file.extension')
    except Exception as e:
        logging.info(e.args[0])```
```
InformationsquelleAutor Binoy S Kumar
0

Par défaut, flacon utiliser un dossier "modèles" pour contenir tous vos fichiers de modèle(n'importe quel fichier de texte brut, mais généralement .html ou une sorte de modèle de la langue tels que jinja2 ) & "statique" dossier contenant tous vos fichiers statiques(c'est à dire .js .css et de vos images).

Dans votre routes, u peut utiliser render_template() de rendre un fichier de modèle (comme je l'ai dit ci-dessus, par défaut il est placé dans le templates dossier) que la réponse à votre demande. Et dans le fichier de modèle (c'est généralement une .html fichier), u peut utiliser certains .js et/ou".css les fichiers, donc je suppose que votre question est de savoir comment u le lien entre ces fichiers statiques pour le modèle de fichier.

InformationsquelleAutor Harvey
0

Si vous essayez juste d'ouvrir un fichier, vous pouvez utiliser app.open_resource(). Donc, la lecture d'un fichier devrait ressembler à quelque chose comme
```
with app.open_resource('/static/path/yourfile'):
      #code to read the file and do something
```
InformationsquelleAutor Chaitanya Shivade

La façon la plus simple est de créer un statique dossier dans le dossier de projet principal. Statique dossier contenant .les fichiers css.

dossier principal

/Main Folder
/Main Folder/templates/foo.html
/Main Folder/static/foo.css
/Main Folder/application.py(flask script)

Image de dossier principal contenant statique et dossiers de modèles et flacon de script

flacon

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/")
def login():
    return render_template("login.html")

html (mise en page)

<!DOCTYPE html>
<html>
    <head>
        <title>Project(1)</title>
        <link rel="stylesheet" href="/static/styles.css">
     </head>
    <body>
        <header>
            <div class="container">
                <nav>
                    <a class="title" href="">Kamook</a>
                    <a class="text" href="">Sign Up</a>
                    <a class="text" href="">Log In</a>
                </nav>
            </div>
        </header>  
        {% block body %}
        {% endblock %}
    </body>
</html>

html

{% extends "layout.html" %}

{% block body %}
    <div class="col">
        <input type="text" name="username" placeholder="Username" required>
        <input type="password" name="password" placeholder="Password" required>
        <input type="submit" value="Login">
    </div>
{% endblock %}

InformationsquelleAutor ESbros

Vous devez vous connecter pour publier un commentaire.