Statické soubory v baňce - robot.txt, sitemap.xml (mod_wsgi)

hlasů
84

Je nějaká chytrá řešení pro ukládání statických souborů v baňce v kořenovém adresáři aplikace. robots.txt a sitemap.xml se očekává, že se nacházejí v /, takže můj myšlenkou bylo vytvořit trasy pro ně:

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

Tam musí být něco mnohem pohodlnější :)

Položena 21/11/2010 v 20:26
zdroj uživatelem
V jiných jazycích...                            


9 odpovědí

hlasů
15

Podávat statické soubory, nemá nic společného s aplikací, která je určena k doručování dynamický obsah. Správný způsob servírování statických souborů je závislá na jaký server používáte. Koneckonců, když se dostanete vaše aplikace rozběhne, bude jej muset vázat na webový server. Mohu mluvit jen za Httpd, takže způsob servírování statické soubory je definována v virtuální hostitele, které jsou závazné pro vaši aplikaci pomocí mod-WSGI. Zde je průvodce, který vám ukáže, jak sloužit Sitemaps, robots.txt nebo statický obsah: http://code.google.com/p/modwsgi/wiki/QuickConfigurationGuide#Mounting_At_Root_Of_Site

Odpovězeno 22/11/2010 v 01:54
zdroj uživatelem

hlasů
65

@vonPetrushev má pravdu, ve výrobě budete chtít sloužit statické soubory pomocí Nginx nebo Apache, ale pro vývoj je fajn mít svůj dev prostředí jednoduché s vaší python app servírují statický obsah stejně, takže nemusíte mít strach, o měnících se konfigurací a více projektů. K tomu, že budete chtít používat 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')
    })

Tento příklad předpokládá, že vaše statické soubory jsou ve složce „statické“, přizpůsobit se, co vyhovuje vašemu prostředí.

Odpovězeno 10/02/2011 v 09:36
zdroj uživatelem

hlasů
3

Z dokumentace zde: http://flask.pocoo.org/docs/quickstart/#static-files

Dynamické webové aplikace potřebují statické soubory. To je obvykle, kde CSS a soubory JavaScriptu pochází. V ideálním případě váš webový server je nakonfigurován tak, aby jim sloužil pro vás, ale v průběhu vývoje Baňky můžete udělat, že stejně. Stačí vytvořit složku s názvem statické ve svém obalu nebo vedle modulu a bude k dispozici na adrese / static k aplikaci.

Chcete-li generovat adresy URL na tu část adresy URL, použijte speciální ‚statické‘ název URL:

url_for ( 'statická', jméno souboru = 'style.css')

Soubor musí být uložen v souborovém systému jako statické / style.css.

Odpovězeno 24/03/2011 v 17:35
zdroj uživatelem

hlasů
5

To by mohl být přidán, protože tato otázka byla položena, ale já jsem se díval skrz baňka je „helpers.py“ a našel jsem 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.
'''

... což odkazy flask.send_file:

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

... což se zdá být lepší pro větší kontrolu, když send_from_directory projde ** možnosti přímo s send_file.

Odpovězeno 23/07/2011 v 03:00
zdroj uživatelem

hlasů
0

Mám stejné dilema stejně. Udělal nějaké vyhledávání a našel svou odpověď (MH +):

Klidně citovat z dokumentace

Dynamické webové aplikace potřebují statické soubory. To je obvykle, kde CSS a soubory JavaScriptu pochází. V ideálním případě váš webový server je nakonfigurován tak, aby jim sloužil pro vás, ale v průběhu vývoje Baňka může dělat, že stejně . Stačí vytvořit složku s názvem statické ve svém obalu nebo vedle modulu a bude k dispozici na adrese / static k aplikaci.

IMHO: Je-li vaše žádost se k výrobě , static file porce by měla být (nebo v ideálním případě) nakonfigurován na webový server (Nginx, Apache); ale v průběhu vývoje , baňky zpřístupnila ji sloužit statické soubory. To je pomoci vám rychle vyvíjet - není třeba nastavení webových serverů a podobně.

Doufám, že to pomůže.

Odpovězeno 18/09/2011 v 07:59
zdroj uživatelem

hlasů
13

Dalším způsobem, jak posílat statické soubory je použití catch-all pravidlo takto:

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

Používám to, aby se pokusili minimalizovat set-up při vývoji. Dostal jsem nápad z http://flask.pocoo.org/snippets/57/

Dále jsem vyvíjet pomocí baňku na svém samostatném počítači, ale rozmístění Apache v produkčním serveru. Používám:

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()
Odpovězeno 26/10/2012 v 01:53
zdroj uživatelem

hlasů
21

I přesto, že se jedná o starý zodpovězená otázka, já to odpověděl, protože tento příspěvek přijde dost vysoko ve výsledcích Google. I když to není v naší dokumentaci, pokud budete číst docs API pro objekt konstruktoru baňka Application to vztahuje. Předáním pojmenovaný parametr static_folderjako tak:

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

... si můžete definovat, kde se podávají statické soubory z. Podobně můžete definovat template_folder, jméno vás static_url_path.

Odpovězeno 17/01/2013 v 23:50
zdroj uživatelem

hlasů
54

Nejčistší Odpověď na tuto otázku je odpověď na tuto (identickou) otázku :

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

Shrnout:

  • David poukázal na to, s pravou config je to v pořádku, aby sloužil několik statických souborů prostřednictvím prod
  • hledá /robots.txt by neměla vést k přesměrování na /static/robots.txt. (V Seans odpovědět, že to není hned jasné, jak to je dosaženo.)
  • to není čistá přidat statické soubory do kořenové složky app
  • Konečně, navrhované řešení vypadá mnohem čistší než přidávání middleware přístupu:
Odpovězeno 31/01/2013 v 13:18
zdroj uživatelem

hlasů
63

Nejlepší způsob, jak je nastavit static_url_path do kořenové url

from flask import Flask

app = Flask(__name__, static_folder='static', static_url_path='')
Odpovězeno 12/06/2013 v 20:22
zdroj uživatelem

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more