Archivos estáticos en Flask - robot.txt, mapa del sitio.xml (mod wsgi)

@vonPetrushev tiene razón, en producción querrá servir archivos estáticos a través de nginx o apache, pero para el desarrollo es bueno tener su entorno de desarrollo simple que su aplicación python sirva el contenido estático también para que no tenga que preocuparse por cambiar configuraciones y múltiples proyectos. Para hacer eso, querrá usar el SharedDataMiddleware.

from flask import Flask
app = Flask(__name__)
'''
Your app setup and code
'''
if app.config['DEBUG']:
    from werkzeug import SharedDataMiddleware
    import os
    app.wsgi_app = SharedDataMiddleware(app.wsgi_app, {
      '/': os.path.join(os.path.dirname(__file__), 'static')
    })

Este ejemplo asume que sus archivos estáticos están en la carpeta "static", ajuste a lo que se ajuste a su ambiente.

La respuesta más limpia a esta pregunta es la respuesta a esta (idéntica) pregunta :

from flask import Flask, request, send_from_directory
app = Flask(__name__, static_folder='static')    

@app.route('/robots.txt')
@app.route('/sitemap.xml')
def static_from_root():
    return send_from_directory(app.static_folder, request.path[1:])

Para resumir:

• como David señaló, con la configuración correcta es aceptable servir algunos archivos estáticos a través de prod
• buscando /robots.txt no debería resultar en una redirección a /static/robots.txt. (En Seans respuesta no es inmediatamente claro cómo se logra.)
• no es limpio agregar archivos estáticos a la raíz de la aplicación folder
• finalmente, la solución propuesta parece mucho más limpia que el enfoque de agregar middleware:

A pesar de que esta es una vieja pregunta respondida, estoy respondiendo esto porque este post aparece bastante alto en los resultados de Google. Si bien no está cubierto en la documentación, si lee los documentos de la API para el constructor de objetos de la aplicación Flask, está cubierto. Pasando el parámetro llamado static_folder de la siguiente manera:

from flask import Flask
app = Flask(__name__,
            static_folder="/path/to/static",
            template_folder="/path/to/templates")

...puede definir desde dónde se sirven los archivos estáticos. Del mismo modo, puede definir un template_folder, el nombre de usted static_url_path.

Servir archivos estáticos no tiene nada que ver con la aplicación que está destinada a entregar contenido dinámico. La forma correcta de servir archivos estáticos depende del servidor que esté utilizando. Después de todo, cuando tenga su aplicación en funcionamiento, deberá vincularla a un servidor web. Solo puedo hablar de apache httpd, por lo que la forma de servir archivos estáticos se define en el host virtual que está vinculando a su aplicación a través de mod-wsgi. Aquí está la guía que le mostrará cómo servir sitemaps, robot.txt o cualquier contenido estático: http://code.google.com/p/modwsgi/wiki/QuickConfigurationGuide#Mounting_At_Root_Of_Site

Otra forma de enviar archivos estáticos es usar una regla general como esta:

@app.route('/<path:path>')
def catch_all(path):
    if not app.debug:
        flask.abort(404)
    try:
        f = open(path)
    except IOError, e:
        flask.abort(404)
        return
    return f.read()

Uso esto para tratar de minimizar la configuración al desarrollar. Tengo la idea de http://flask.pocoo.org/snippets/57 /

Además, estoy desarrollando usando flask en mi máquina independiente, pero implementando con Apache en el servidor de producción. Uso:

file_suffix_to_mimetype = {
    '.css': 'text/css',
    '.jpg': 'image/jpeg',
    '.html': 'text/html',
    '.ico': 'image/x-icon',
    '.png': 'image/png',
    '.js': 'application/javascript'
}
def static_file(path):
    try:
        f = open(path)
    except IOError, e:
        flask.abort(404)
        return
    root, ext = os.path.splitext(path)
    if ext in file_suffix_to_mimetype:
        return flask.Response(f.read(), mimetype=file_suffix_to_mimetype[ext])
    return f.read()

[...]

if __name__ == '__main__':
    parser = optparse.OptionParser()
    parser.add_option('-d', '--debug', dest='debug', default=False,
                      help='turn on Flask debugging', action='store_true')

    options, args = parser.parse_args()

    if options.debug:
        app.debug = True
        # set up flask to serve static content
        app.add_url_rule('/<path:path>', 'static_file', static_file)
    app.run()

Esto podría haber sido añadido desde que se hizo esta pregunta, pero yo estaba mirando a través del frasco "helpers.py" y encontré petaca.send_from_directory:

send_from_directory(directory, filename, **options)
'''
  send_from_directory(directory, filename, **options)
  Send a file from a given directory with send_file.  This
  is a secure way to quickly expose static files from an upload folder
  or something similar.
'''

... que hace referencia al frasco.send_file:

send_file(filename_or_fp, mimetype=None, as_attachment=False, attachment_filename=None, add_etags=True, cache_timeout=43200, conditional=False)

... lo que parece mejor para un mayor control, aunque send_from_directory pasa las opciones * * directamente a través de send_file.

De la documentación aquí: http://flask.pocoo.org/docs/quickstart/#static-files

Las aplicaciones web dinámicas necesitan estática archivos también. Por lo general es donde los archivos CSS y JavaScript son viniendo de. Idealmente su servidor web está configurado para servirlos por usted, pero durante el desarrollo Matraz puede hacer eso también. Simplemente crea una carpeta llamada estática en su paquete o siguiente a su módulo y será disponible en / estático en el aplicación.

Para generar URLs a esa parte de la URL, utilice la URL 'estática' especial nombre:

Url_for ('static', filename = ' style.css')

El archivo tiene que ser almacenado en el sistema de archivos como estático / estilo.css.

Estoy teniendo el mismo dilema también. Hice una búsqueda y encontré mi respuesta (MHO):

También podría citar de la documentación

Las aplicaciones web dinámicas también necesitan archivos estáticos. Por lo general, de ahí vienen los archivos CSS y JavaScript. Idealmente su servidor web está configurado para servirlos por usted, pero durante el desarrollo Flask puede hacer eso también. Simplemente cree una carpeta llamada static en su paquete o al lado de su módulo y estará disponible at / estático en la aplicación.

En mi humilde opinión: Cuando su aplicación está lista para producción, el servicio de archivos estáticos debería estar (o idealmente está) configurado en el servidor web (nginx, apache); pero durante desarrollo, Flask lo hizo disponible para servir archivos estáticos. Esto es para ayudarle a desarrollar rápidamente-no hay necesidad de configurar servidores web y tal.

Espero que ayude.