Statische Dateien in Flask - robot.txt, sitemap.xml (mod_wsgi)

Question

Gibt es eine clevere Lösung zum Speichern von statischen Dateien in Flask Anwendung Root-Verzeichnis. robots.txt und sitemap.xml erwarten in / zu finden sind, so meine Idee war Routen für sie zu schaffen:

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

Es muss etwas bequemer:)

Answer 1

Der beste Weg ist, auf static_url_path , um Root-URL

from flask import Flask

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

Answer 2

@vonPetrushev ist richtig, in der Produktion Sie statische Dateien über nginx oder Apache dienen will, aber für die Entwicklung ist es schön, Ihre Dev-Umgebung einfach zu haben, Ihren Python App als auch die statischen Inhalte dienen zu müssen, so tun Sie nicht müssen Sorge über das Ändern von Konfigurationen und mehrere Projekte. Um das zu tun, werden Sie die SharedDataMiddleware verwenden möchten.

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')
    })

In diesem Beispiel wird davon ausgegangen, Ihre statischen Dateien im Ordner „statisch“ sind, passen Sie auf, was auch immer Ihre Umgebung passt.

Answer 3

Die sauberste Antwort auf diese Frage ist das Antwort auf diesen (identischen) 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:])

Um es zusammenzufassen:

• als David wies darauf hin, mit der richtigen config es ok ein paar statische Dateien durch prod
• für /robots.txt sucht, sollte in einer Umleitung zu /static/robots.txt führen. (In Seans beantwortet es nicht sofort klar, wie das erreicht wird.)
• es nicht sauber ist statische Dateien in die App Stammordner hinzufügen
• schließlich die vorgeschlagene Lösung viel sauberer als die Zugabe von Middleware-Ansatz aussieht:

Answer 4

Auch wenn dies eine alte beantwortete Frage ist, bin ich zu beantworten, weil dieser Beitrag aufgeht ziemlich hoch in den Google Suchergebnissen. Während es in der Dokumentation nicht abgedeckt ist, lesen Sie, wenn Sie die API-Dokumentation für die Flask Anwendung Objektkonstruktor es bedeckt. Durch die Übergabe der benannten Parameter static_folder etwa so:

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

... können Sie festlegen, wo statische Dateien aus bedient werden. Ebenso können Sie eine template_folder definieren, den Namen Sie static_url_path.

Answer 5

Serving statische Dateien hat nichts mit der Anwendung zu tun, das gemeint ist, dynamische Inhalte zu liefern. Die richtige Art und Weise statische Dateien dienen ist abhängig davon, welcher Server Sie verwenden. Nach allem, wenn Sie Ihre Anwendung und laufen zu bekommen, müssen Sie es auf einen Web-Server binden. Ich kann nur für Apache sprechen, so dass die Art und Weise statische Dateien dienen in dem virtuellen Host definiert ist, dass Sie durch mod-wsgi für Ihre Anwendung sind verbindlich. Hier ist die Anleitung, die zeigen Sie, wie Sitemaps dienen, robots.txt oder statischen Inhalt: http://code.google.com/p/modwsgi/wiki/QuickConfigurationGuide#Mounting_At_Root_Of_Site

Answer 6

Eine andere Möglichkeit, statische Dateien zu senden ist eine Catch-All-Regel wie folgt zu verwenden:

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

ich diese verwenden, um zu versuchen, die Abstimmung zu minimieren, wenn die Entwicklung. Ich habe die Idee von http://flask.pocoo.org/snippets/57/

Außerdem entwickle ich auf meiner Standalone-Maschine mit Kolben aber dem Einsatz mit Apache in Produktionsserver. Ich benutze:

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

Dies könnte hinzugefügt wurden, da diese Frage gestellt wurde, aber ich war auf der Suche durch den Kolben „helpers.py“ und ich fand 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.
'''

... die Referenzen flask.send_file:

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

..., die für mehr Kontrolle besser scheint, obwohl send_from_directory Pässe ** Optionen durch direkt an send_file.

Answer 8

Aus der Dokumentation hier: http://flask.pocoo.org/docs/ quickstart / # static-Dateien

  

Dynamische Web-Anwendungen müssen statisch   Dateien als auch. Das ist in der Regel, wo   die CSS und JavaScript-Dateien sind   kommen von. Im Idealfall Ihren Webserver   so konfiguriert ist, sie für Sie zu dienen,   aber während der Entwicklung Flask tun können   das auch. Erstellen Sie einfach einen Ordner   genannt statisch in Ihrem Paket oder nächsten   Ihr Modul und es wird   bei / statisch auf die zur Verfügung stehende   Anwendung.

     

Um URLs zu diesem Teil der Erzeugung   URL, verwenden Sie die spezielle 'static' URL   Name:

     

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

     

hat die Datei auf dem gespeichert werden   Dateisystem als statisch / style.css.

Answer 9

Ich habe das gleiche Dilemma wie gut. Habe einige Suche und fand meine Antwort (MHO):

Es könnte aber auch zitiere aus der Dokumentation

  

Dynamische Web-Anwendungen benötigen statische Dateien als auch. Das ist in der Regel, wo die CSS und JavaScript-Dateien kommen aus. Im Idealfall wird Ihr Webserver konfiguriert sie für Sie zu dienen, aber während der Entwicklung kann Flask tut das auch . Erstellen Sie einfach einen Ordner statisch in Ihrem Paket oder neben dem Modul genannt, und es wird an / statisch auf der Anwendung zur Verfügung.

IMHO: Wenn Ihre Anwendung liegt für Produktion , statische Datei Portion sein sollte (oder idealerweise) konfiguriert auf dem Webserver (nginx, Apache); aber während Entwicklung , Flask zugänglich gemacht statische Dateien zu dienen. Dies soll Ihnen helfen schnell zu entwickeln - keine Notwendigkeit zur Einrichtung webservers und so.

Hope es hilft.