Pourquoi le serveur de développement Flask s'exécute-t-il deux fois?

J'utilise Flask pour développer un site Web et pendant le développement, j'exécute flask en utilisant le fichier suivant:

#!/usr/bin/env python
from datetime import datetime
from app import app
import config

if __name__ == '__main__':
    print '################### Restarting @', datetime.utcnow(), '###################'
    app.run(port=4004, debug=config.DEBUG, host='0.0.0.0')

Lorsque je démarre le serveur, ou lorsqu'il redémarre automatiquement parce que les fichiers ont été mis à jour, il affiche toujours deux fois la ligne d'impression:

################### Restarting @ 2014-08-26 10:51:49.167062 ###################
################### Restarting @ 2014-08-26 10:51:49.607096 ###################

Bien que ce ne soit pas vraiment un problème (le reste fonctionne comme prévu), je me demande simplement pourquoi il se comporte comme ça? Des idées?

Le rechargement Werkzeug génère un processus enfant afin qu'il puisse redémarrer ce processus chaque fois que votre code change. Werkzeug est la bibliothèque qui fournit à Flask le serveur de développement lorsque vous appelez app.run().

Voir le restart_with_reloader()code de fonction ; votre script est à nouveau exécuté avec subprocess.call().

Si vous définissez use_reloadersur, Falsevous verrez le comportement disparaître, mais vous perdrez également la fonctionnalité de rechargement:

app.run(port=4004, debug=config.DEBUG, host='0.0.0.0', use_reloader=False)

Vous pouvez également désactiver le rechargeur lorsque vous utilisez la flask runcommande:

FLASK_DEBUG=1 flask run --no-reload

Vous pouvez rechercher la WERKZEUG_RUN_MAINvariable d'environnement si vous souhaitez détecter lorsque vous êtes dans le processus enfant de rechargement:

import os
if os.environ.get('WERKZEUG_RUN_MAIN') == 'true':
    print '################### Restarting @ {} ###################'.format(
        datetime.utcnow())

Cependant, si vous avez besoin de configurer des globaux de module, vous devez à la place utiliser le @app.before_first_requestdécorateur sur une fonction et que cette fonction configure ces globaux. Il ne sera appelé qu'une seule fois après chaque rechargement lorsque la première demande arrivera:

@app.before_first_request
def before_first_request():
    print '########### Restarted, first request @ {} ############'.format(
        datetime.utcnow())

Tenez compte du fait que si vous l'exécutez sur un serveur WSGI à grande échelle qui utilise la fourche ou de nouveaux sous-processus pour gérer les demandes, ces before_first_requestgestionnaires peuvent être appelés pour chaque nouveau sous-processus.

Si vous utilisez la flask runcommande moderne , aucune des options à app.runn'est utilisée. Pour désactiver complètement le rechargeur, passez --no-reload:

FLASK_DEBUG=1 flask run --no-reload

De plus, __name__ == '__main__'cela ne sera jamais vrai car l'application n'est pas exécutée directement. Utilisez les mêmes idées de la réponse de Martijn , sauf sans le __main__blocage.

if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
    # do something only once, before the reloader

if os.environ.get('WERKZEUG_RUN_MAIN') == 'true':
    # do something each reload

J'ai eu le même problème et je l'ai résolu en réglant app.debugsur False. Le paramétrer Trueme faisait __name__ == "__main__"appeler deux fois.

À partir de Flask 0.11, il est recommandé d'exécuter votre application avec flask runplutôt que python application.py. L'utilisation de ce dernier pourrait entraîner l'exécution de votre code deux fois.

Comme indiqué ici :

... à partir du flacon 0.11, la méthode du flacon est recommandée. La raison en est qu'en raison du fonctionnement du mécanisme de rechargement, il y a des effets secondaires bizarres (comme exécuter certains codes deux fois ...)

L'une des raisons possibles pour lesquelles l'application Flask s'exécute deux fois est une configuration de WEB_CONCURRENCY paramètre sur Heroku. Pour définir en un, vous pouvez écrire dans la console heroku config:set WEB_CONCURRENCY=1

Une observation concernant les fils

Ceci est particulièrement ennuyeux lorsque votre application utilise des threads car ils seront déclenchés deux fois au démarrage. Pour autant que j'ai essayé les singletons, cela ne remédie pas non plus (ce qui est surprenant). Cependant, l'ajout d'un délai initial de quelques secondes avant le démarrage de votre thread peut résoudre le problème.

Si l'application redémarre plus rapidement qu'avant la fin de votre délai, le thread donné n'est généré qu'une seule fois, après le redémarrage.

J'ai eu le même problème. Je l'ai résolu en modifiant mon principal et en y insérant use_reloader = False. Si un organisme est ici à la recherche d'une solution de contournement à ce problème, le code ci-dessous vous permettra de démarrer, mais la fonctionnalité des modifications de code détectées automatiquement et le redémarrage de l'application ne fonctionneront pas. Vous devrez arrêter et redémarrer manuellement votre application après chaque modification du code.

if __name__ == '__main__':
    app.run(debug=True, use_reloader=False)