python - the - Archivos estáticos en Flask-robot.txt, sitemap.xml(mod_wsgi)

sitemap xml seo

Question

¿Hay alguna solución inteligente para almacenar archivos estáticos en el directorio raíz de la aplicación de Flask? Se espera que robots.txt y sitemap.xml se encuentren en /, así que mi idea era crear rutas para ellos:

@app.route(''/sitemap.xml'', methods=[''GET''])
def sitemap():
response = make_response(open(''sitemap.xml'').read())
response.headers["Content-type"] = "text/plain"
return response

Debe haber algo más conveniente :)

Answer 1

@vonPetrushev tiene razón, en producción querrás enviar archivos estáticos a través de nginx o apache, pero para el desarrollo es bueno tener tu entorno de desarrollo simple teniendo tu aplicación de python sirviendo también el contenido estático para que no tengas que preocuparte sobre el cambio de configuraciones y proyectos múltiples. Para hacer eso, querrá usar 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 "estática", ajústelos a su entorno.

Answer 2

Aunque esta es una vieja pregunta respondida, estoy respondiendo esto porque esta publicación aparece bastante alta en los resultados de Google. Si bien no está cubierto en la documentación, si lee los documentos API para el constructor de objetos de la Aplicación Flask está cubierto. Pasando el parámetro llamado static_folder como static_folder :

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 una template_folder , el nombre de usted static_url_path .

Answer 3

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

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

Para generar URL a esa parte de la URL, use el nombre de URL estático especial:

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

El archivo debe almacenarse en el sistema de archivos como static / style.css.

Answer 4

Esto podría haberse agregado desde que se hizo esta pregunta, pero estaba mirando a través de "helpers.py" del matraz y encontré el archivo flask.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 a flask.send_file:

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

... que parece mejor para tener más control, aunque send_from_directory pasa ** las opciones directamente a send_file.

Answer 5

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

Podría citar de la documentación

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

En mi humilde opinión: cuando su aplicación esté lista para producción , la entrega de archivos estáticos debe (o idealmente) estar configurada en el servidor web (nginx, apache); pero durante el desarrollo , Flask lo hizo disponible para servir archivos estáticos. Esto es para ayudarlo a desarrollarse rápidamente, no es necesario configurar servidores web ni nada más.

Espero eso ayude.

Answer 6

La mejor manera es establecer static_url_path en la url raíz

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

Answer 7

La publicación de archivos estáticos no tiene nada que ver con la aplicación destinada a ofrecer contenido dinámico. La forma correcta de servir archivos estáticos depende del servidor que está utilizando. Después de todo, cuando inicies y ejecutes tu aplicación, deberás vincularla a un servidor web. Solo puedo hablar sobre 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 publicar mapas de sitio, robots.txt o cualquier contenido estático: http://code.google.com/p/modwsgi/wiki/QuickConfigurationGuide#Mounting_At_Root_Of_Site

Answer 8

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

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 está bien servir algunos archivos estáticos a través de prod
• buscar /robots.txt no debería redirigir a /static/robots.txt. (En la respuesta de Seans, no está claro de inmediato cómo se logró eso).
• no está limpio agregar archivos estáticos a la carpeta raíz de la aplicación
• finalmente, la solución propuesta parece mucho más limpia que el enfoque de agregar middleware:

Answer 9

Otra forma de enviar archivos estáticos es usar una regla catch-all 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()

Lo uso para tratar de minimizar la configuración cuando se desarrolla. Obtuve la idea de http://flask.pocoo.org/snippets/57/

Además, estoy desarrollando el uso de un matraz en mi máquina independiente, pero implementando con Apache en el servidor de producción. Yo suelo:

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()