¿Por qué ejecutar el servidor de desarrollo Flask se ejecuta solo dos veces?

Estoy usando Flask para desarrollar un sitio web y mientras estoy en desarrollo ejecuto flask usando el siguiente archivo:

#!/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')

Cuando inicio el servidor, o cuando se reinicia automáticamente porque los archivos se han actualizado, siempre muestra la línea de impresión dos veces:

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

Aunque realmente no es un problema (el resto funciona como se esperaba), simplemente me pregunto por qué se comporta así. ¿Algunas ideas?

El cargador de Werkzeug genera un proceso hijo para que pueda reiniciar ese proceso cada vez que cambia su código. Werkzeug es la biblioteca que proporciona a Flask el servidor de desarrollo cuando llamas app.run().

Ver el restart_with_reloader()código de función ; su script se ejecuta de nuevo con subprocess.call().

Si se establece use_reloaderque Falsepodrás ver el comportamiento desaparece, pero luego también se pierde la funcionalidad de recarga:

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

También puede deshabilitar el cargador cuando usa el flask runcomando:

FLASK_DEBUG=1 flask run --no-reload

Puede buscar la WERKZEUG_RUN_MAINvariable de entorno si desea detectar cuándo está en el proceso secundario de recarga:

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

Sin embargo, si necesita configurar módulos globales, entonces debería usar el @app.before_first_requestdecorador en una función y hacer que esa función configure dichos globales. Se llamará solo una vez después de cada recarga cuando llegue la primera solicitud:

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

Tenga en cuenta que si ejecuta esto en un servidor WSGI a gran escala que usa bifurcaciones o nuevos subprocesos para manejar solicitudes, esos before_first_requestcontroladores pueden ser invocados para cada nuevo subproceso.

Si está utilizando el flask runcomando moderno , no app.runse utiliza ninguna de las opciones para . Para deshabilitar el cargador por completo, pase --no-reload:

FLASK_DEBUG=1 flask run --no-reload

Además, __name__ == '__main__'nunca será cierto porque la aplicación no se ejecuta directamente. Use las mismas ideas de la respuesta de Martijn , excepto sin el __main__bloque.

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

Tuve el mismo problema y lo resolví estableciendo app.debugen False. Establecerlo en Trueestaba causando que me __name__ == "__main__"llamaran dos veces.

Desde Flask 0.11, se recomienda ejecutar su aplicación con en flask runlugar de python application.py. El uso de este último podría resultar en ejecutar su código dos veces.

Como se indica aquí :

... a partir del frasco 0.11 se recomienda el método del frasco. La razón de esto es que debido a cómo funciona el mecanismo de recarga, hay algunos efectos secundarios extraños (como ejecutar cierto código dos veces ...)

Una de las posibles razones por las que la aplicación Flask se ejecuta sola dos veces es una configuración de WEB_CONCURRENCYconfiguración en Heroku. Para configurarlo en uno, puede escribir en la consola heroku config:set WEB_CONCURRENCY=1

Una observación sobre los hilos

Esto es particularmente molesto cuando su aplicación usa subprocesos, ya que se activarán dos veces al inicio. Por lo que probé, los singleton tampoco remedian esto (lo cual es sorprendente). Sin embargo, agregar un retraso inicial de unos segundos antes de que se inicie el hilo puede resolver el problema.

Si la aplicación se reinicia más rápido que antes de que finalice el período de demora, el hilo dado solo se genera una vez, después del reinicio.

Tuve el mismo problema. Lo resolví modificando mi main e insertando use_reloader = False en él. Si alguien está aquí buscando una solución para este problema, el siguiente código lo ayudará a comenzar, sin embargo, la funcionalidad de los cambios en el código que se detectan automáticamente y reinicia la aplicación no funcionará. Tendrá que detener y reiniciar manualmente su aplicación después de cada edición en el código.

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