Pliki statyczne w Flask-robot.txt, sitemap.xml (mod wsgi)

@vonPetrushev ma rację, w produkcji będziesz chciał obsługiwać pliki statyczne przez nginx lub apache, ale dla rozwoju dobrze jest mieć środowisko programistyczne proste mając swoją aplikację Pythona obsługującą statyczną zawartość, więc nie musisz się martwić o zmianę konfiguracji i wielu projektów. Aby to zrobić, będziesz chciał użyć 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')
    })

Ten przykład zakłada, że Twoje pliki statyczne znajdują się w folderze "static", dostosuj je do tego, co pasuje do twojego środowisko.

Najczystszą odpowiedzią na to pytanie jest Odpowiedź na to (identyczne) pytanie :

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

Podsumowując:

• Jak zauważył David, przy prawidłowej konfiguracji jest ok, aby serwować kilka plików statycznych przez prod
• Szukam / robotów.txt nie powinno powodować przekierowania do /static / robots.txt. (W odpowiedzi Seans nie jest od razu jasne, jak to osiągnąć.)
• dodawanie plików statycznych do katalogu głównego aplikacji nie jest czyste folder
Ostatecznie proponowane rozwiązanie wygląda znacznie czystiej niż podejście dodawania middleware:]}

Mimo, że jest to stare pytanie, odpowiadam na to, ponieważ ten post pojawia się dość wysoko w wynikach Google. Chociaż nie jest to opisane w dokumentacji, to jeśli przeczytasz dokumenty API dla konstruktora obiektu Flask Application, to jest ono objęte. Przez podanie nazwanego parametru static_folder w ten sposób:

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

...możesz określić, skąd są serwowane pliki statyczne. Podobnie można zdefiniować template_folder, nazwę użytkownika static_url_path.

Serwowanie plików statycznych nie ma nic wspólnego z aplikacją, która ma dostarczać treści dynamiczne. Poprawny sposób serwowania plików statycznych zależy od używanego serwera. W końcu po uruchomieniu aplikacji będziesz musiał powiązać ją z serwerem WWW. Mogę mówić tylko za Apache httpd, więc sposób serwowania plików statycznych jest zdefiniowany w wirtualnym Hostie, który wiążesz z aplikacją za pośrednictwem Mod-wsgi. Oto przewodnik, który pokaże Ci, jak obsługiwać mapy witryn, roboty.txt lub dowolna zawartość statyczna: http://code.google.com/p/modwsgi/wiki/QuickConfigurationGuide#Mounting_At_Root_Of_Site

Innym sposobem wysyłania plików statycznych jest użycie reguły catch-all takiej jak Ta:

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

Używam tego, aby zminimalizować konfigurację podczas tworzenia. Mam pomysł z http://flask.pocoo.org/snippets/57/

Dalej, rozwijam się przy użyciu flask na mojej samodzielnej maszynie, ale wdrażam z Apache na serwerze produkcyjnym. Używam:

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

To mogło być dodane od kiedy zadano to pytanie, ale przeglądałem "helpers.py" i znalazłem piersiówkę.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.
'''

... które odwołują się do kolby.send_file:

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

... co wydaje się lepsze dla większej kontroli, chociaż send_from_directory przekazuje **opcje bezpośrednio do send_file.

Z dokumentacji tutaj: http://flask.pocoo.org/docs/quickstart/#static-files

Dynamiczne aplikacje internetowe potrzebują statycznych pliki też. Zwykle tam pliki CSS i JavaScript to pochodzę z. Idealnie Twój serwer WWW jest skonfigurowany, aby służyć im dla Ciebie, ale podczas rozwoju kolba może zrobić to też. Wystarczy utworzyć folder nazwane static w pakiecie lub next do twojego modułu i będzie dostępne w / static na podanie.

Aby wygenerować adresy URL do tej części URL, użyj specjalnego 'statycznego' adresu URL Nazwa:

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

Plik musi być zapisany na system plików jako static / style.css.

Ja też mam ten sam dylemat. Poszukałem i znalazłem odpowiedź (MHO):

Równie dobrze można cytować z Dokumentacji

Dynamiczne aplikacje internetowe również potrzebują plików statycznych. To Zwykle miejsce, z którego pochodzą pliki CSS i JavaScript. najlepiej, aby twój serwer WWW był skonfigurowany tak, aby obsługiwał je dla ciebie, ale podczas tworzenia Flask może to zrobić również . Wystarczy utworzyć folder o nazwie static w pakiecie lub obok modułu i będzie on dostępny at / static w aplikacji.

IMHO: gdy Twoja aplikacja jest gotowa do produkcji, statyczne serwowanie plików powinno być (lub najlepiej) skonfigurowane na serwerze WWW (nginx, apache); ale podczas rozwoju, Flask udostępnił ją do serwowania plików statycznych. Ma to pomóc w szybkim rozwoju-nie ma potrzeby konfigurowania webserverów itp.

Mam nadzieję, że to pomoże.