file statici nel pallone - robot.txt, sitemap.xml (mod_wsgi)

Question

C'è qualche soluzione intelligente per memorizzare i file statici nella directory principale dell'applicazione di Flask. robots.txt e sitemap.xml dovrebbero essere trovata in /, quindi la mia idea era quella di creare dei percorsi per loro:

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

Ci deve essere qualcosa di più comodo:)

Answer 1

Il modo migliore è quello di impostare static_url_path per radice url

from flask import Flask

app = Flask(__name__, static_folder='static', static_url_path='')

Answer 2

@vonPetrushev è giusto, nella produzione si vorrà servire i file statici tramite nginx o Apache, ma per lo sviluppo è bello avere il vostro ambiente dev semplice avere il pitone app servendo il contenuto statico pure in modo non lo fai devono preoccuparsi di cambiare le configurazioni e progetti multipli. Per fare questo, ti consigliamo di utilizzare la 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')
    })

Questo esempio assume i file statici sono nella "statica" della cartella, registrare a che cosa si adatta al proprio ambiente.

Answer 3

La risposta più pulita a questa domanda è il risposta a questa (identici) question :

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:])

Per riassumere:

• come David ha sottolineato, con la configurazione giusta è ok per servire un paio di file statici tramite prod
• alla ricerca di /robots.txt non deve tradursi in un reindirizzamento al /static/robots.txt. (In Seans Risposta Non è immediatamente chiaro come sia raggiunto.)
• non è pulito per aggiungere i file statici nella cartella app root
• , infine, la soluzione proposta sembra molto più pulita rispetto all'approccio middleware aggiungendo:

Answer 4

Anche se questa è una vecchia domanda ha risposto, sto rispondendo perché questo post arriva piuttosto alto nei risultati di Google. Anche se non è coperto nella documentazione, se si legge la documentazione API per l'applicazione Flask costruttore dell'oggetto è coperto. Passando il parametro static_folder denominato in questo modo:

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

... si può definire dove file statici sono serviti da. Allo stesso modo, è possibile definire un template_folder, il nome di voi static_url_path.

Answer 5

Serve file statici non ha nulla a che fare con l'applicazione che ha lo scopo di fornire contenuti dinamici. Il modo corretto di servire file statici dipende da quale server si sta utilizzando. Dopo tutto, quando si ottiene la vostra applicazione installato e funzionante, è necessario associarlo a un server web. Posso solo parlare per apache httpd, quindi il modo di servire i file statici è definito nel host virtuale che si sono vincolanti per l'applicazione attraverso il mod-WSGI. Ecco la guida che vi mostrerà come servire sitemap, robots.txt o qualsiasi contenuto statico: http://code.google.com/p/modwsgi/wiki/QuickConfigurationGuide#Mounting_At_Root_Of_Site

Answer 6

Un altro modo per inviare file statici è quella di utilizzare un catch-all regola in questo modo:

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

Io uso questo per cercare di ridurre al minimo il set-up durante lo sviluppo. Ho avuto l'idea da http://flask.pocoo.org/snippets/57/

Inoltre, sto sviluppando con pallone sulla mia macchina stand-alone, ma la distribuzione con Apache nel server di produzione. Io 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()

Answer 7

Questo potrebbe essere stato aggiunto in quanto questa domanda è stato chiesto, ma mi è stato guardando attraverso "helpers.py" del pallone e ho trovato 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.
'''

... che i riferimenti flask.send_file:

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

... che sembra migliore per un maggiore controllo, anche se passa send_from_directory ** opzioni direttamente fino alla send_file.

Answer 8

Dalla documentazione qui: http://flask.pocoo.org/docs/ quickstart / # static-files

  

applicazioni Web dinamiche bisogno statica   file come bene. Questo è di solito dove   i file CSS e JavaScript sono   proveniente da. Idealmente il vostro web server   è configurato per servire loro per voi,   ma durante lo sviluppo Flask può fare   che pure. Basta creare una cartella   chiamato statica nel pacchetto o successivo   per il modulo e sarà   disponibile presso statica / sul   applicazione.

     

Per generare URL a quella parte del   URL, utilizzare lo speciale URL 'statica'   Nome:

     

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

     

Il file deve essere memorizzato sul   filesystem come statica / style.css.

Answer 9

Sto avendo lo stesso dilemma pure. Abbiamo fatto un po di ricerca e ho trovato la mia risposta (MHO):

Potrebbe pure citare dalla documentazione

  

applicazioni web dinamiche hanno bisogno di file statici come bene. Che di solito è dove il file CSS e JavaScript sono provenienti da. Idealmente il server Web è configurato per servire loro per voi, ma durante lo sviluppo Flask può fare anche questo . Basta creare una cartella chiamata statica nel pacchetto o accanto al modulo e sarà disponibile presso statica / sull'applicazione.

IMHO: Quando l'applicazione è in su per di produzione , che serve file statici dovrebbe essere (o è idealmente) configurato sul server web (Nginx, Apache); ma durante sviluppo , Flask reso disponibile a servire i file statici. Questo è quello di aiutare a sviluppare rapidamente - non c'è bisogno di server web di configurazione e così via.

La speranza aiuta.