Flask'ta statik dosyalar nasıl sunulur?

Yani bu utanç verici. Birlikte attığım bir uygulama var Flaskve şimdilik sadece CSS ve JS'ye bazı bağlantılar içeren tek bir statik HTML sayfası sunuyor. Ve belgelerde Flaskstatik dosyaların geri döndüğünü açıkladığı yeri bulamıyorum . Evet, kullanabilirim render_templateama verilerin geçici olmadığını biliyorum. Düşünürdüm send_fileya url_forda doğru olanıydım, ama bunları çalıştıramadım. Bu arada, dosyaları açıyorum, içerik okuyorum ve Responseuygun bir mimetype ile arma :

import os.path

from flask import Flask, Response


app = Flask(__name__)
app.config.from_object(__name__)


def root_dir():  # pragma: no cover
    return os.path.abspath(os.path.dirname(__file__))


def get_file(filename):  # pragma: no cover
    try:
        src = os.path.join(root_dir(), filename)
        # Figure out how flask returns static files
        # Tried:
        # - render_template
        # - send_file
        # This should not be so non-obvious
        return open(src).read()
    except IOError as exc:
        return str(exc)


@app.route('/', methods=['GET'])
def metrics():  # pragma: no cover
    content = get_file('jenkins_analytics.html')
    return Response(content, mimetype="text/html")


@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def get_resource(path):  # pragma: no cover
    mimetypes = {
        ".css": "text/css",
        ".html": "text/html",
        ".js": "application/javascript",
    }
    complete_path = os.path.join(root_dir(), path)
    ext = os.path.splitext(path)[1]
    mimetype = mimetypes.get(ext, "text/html")
    content = get_file(complete_path)
    return Response(content, mimetype=mimetype)


if __name__ == '__main__':  # pragma: no cover
    app.run(port=80)

Birisi bunun için bir kod örneği veya URL vermek istiyor? Bunun ölü basit olacağını biliyorum.

Tercih edilen yöntem, statik dosyaları sunmak için nginx veya başka bir web sunucusu kullanmaktır; Flask'tan daha verimli bir şekilde yapabilirler.

Bununla birlikte, send_from_directorybazı durumlarda oldukça uygun olabilecek bir dizinden dosya göndermek için kullanabilirsiniz :

from flask import Flask, request, send_from_directory

# set the project root directory as the static folder, you can set others.
app = Flask(__name__, static_url_path='')

@app.route('/js/<path:path>')
def send_js(path):
    return send_from_directory('js', path)

if __name__ == "__main__":
    app.run()

Do not kullanmak send_fileveya send_static_filebir kullanıcı tarafından sağlanan yolu ile.

send_static_file misal:

from flask import Flask, request
# set the project root directory as the static folder, you can set others.
app = Flask(__name__, static_url_path='')

@app.route('/')
def root():
    return app.send_static_file('index.html')

Statik dosyalarınızın konumunu taşımak istiyorsanız, en basit yöntem yapıcıdaki yolları bildirmektir. Aşağıdaki örnekte, şablonlarımı ve statik dosyalarımı adlı bir alt klasöre taşıdım web.

app = Flask(__name__,
            static_url_path='', 
            static_folder='web/static',
            template_folder='web/templates')

• static_url_path=''URL'den önceki tüm yolları kaldırır (yani varsayılan /static).
• static_folder='web/static'klasörde bulunan web/staticdosyaları statik dosyalar olarak sunmak için .
• template_folder='web/templates' benzer şekilde, bu şablonlar klasörünü değiştirir.

Bu yöntemi kullanarak, aşağıdaki URL bir CSS dosyası döndürür:

<link rel="stylesheet" type="text/css" href="/css/bootstrap.min.css">

Ve son olarak, flask_server.pyFlask örneğinin bulunduğu klasör yapısının bir eki:

Ayrıca, bu benim favorim, bir klasörü statik yol olarak ayarlayabilirsiniz, böylece içindeki dosyalar herkes için erişilebilir olur.

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

Bu setle standart HTML'yi kullanabilirsiniz:

<link rel="stylesheet" type="text/css" href="/static/style.css">

İhtiyacınız olanı orada bulacağınızdan eminim: http://flask.pocoo.org/docs/quickstart/#static-files

Temel olarak paketinizin kökünde bir "statik" klasöre ihtiyacınız vardır ve daha sonra http://example.com/static/foo.barurl_for('static', filename='foo.bar') ile dosyalarınızı kullanabilir veya doğrudan dosyalarınıza bağlayabilirsiniz .

DÜZENLEME : Yorumlarda önerildiği gibi, doğrudan '/static/foo.bar'URL yolunu kullanabilirsiniz AMA url_for() ek yükü (performans açısından) oldukça düşüktür ve bunu kullanmak, daha sonra davranışı kolayca özelleştirebileceğiniz (klasörü değiştirme, URL yolunu değiştirme, statik dosyalarınızı S3'e vb. taşıyın).

Bu işlevi kullanabilirsiniz:

send_static_file(filename)
Statik dosyaları statik klasörden tarayıcıya göndermek için dahili olarak kullanılan işlev.

app = Flask(__name__)
@app.route('/<path:path>')
def static_file(path):
    return app.send_static_file(path)

Ne kullanıyorum (ve harika çalışıyor) bir "şablonlar" dizini ve bir "statik" dizin. Tüm .html dosyalarımı / Flask şablonlarını şablonlar dizinine yerleştiriyorum ve statik CSS / JS içeriyor. render_template, Flask'in şablon sözdizimini ne ölçüde kullandığınıza bakılmaksızın, genel html dosyaları için bilgime göre iyi çalışır. Aşağıda benim views.py dosyamda örnek bir çağrı var.

@app.route('/projects')
def projects():
    return render_template("projects.html", title = 'Projects')

Ayrı statik dizindeki bazı statik dosyalara başvurmak istediğinizde url_for () kullandığınızdan emin olun. Muhtemelen bunu html'deki CSS / JS dosya bağlantılarınızda yine de yapacaksınız. Örneğin...

<script src="{{ url_for('static', filename='styles/dist/js/bootstrap.js') }}"></script>

İşte "kanonik" gayri resmi Flask öğretici bir bağlantı - burada yere isabet yardımcı olmak için harika ipuçları bir sürü.

http://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world

Diğer cevaplara dayanan en basit çalışma örneği şudur:

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

@app.route('/index/')
def root():
    return app.send_static_file('index.html')

if __name__ == '__main__':
  app.run(debug=True)

İndex.html adlı HTML ile :

<!DOCTYPE html>
<html>
<head>
    <title>Hello World!</title>
</head>
<body>
    <div>
         <p>
            This is a test.
         </p>
    </div>
</body>
</html>

ÖNEMLİ: Ve index.html bir klasör denilen olduğu statik , anlam <projectpath>vardır .pydosyası ve <projectpath>\staticsahip htmldosyayı.

Sunucunun ağda görünür olmasını istiyorsanız, app.run(debug=True, host='0.0.0.0')

EDIT: İstenirse klasördeki tüm dosyaları göstermek için bunu kullanın

@app.route('/<path:path>')
def static_file(path):
    return app.send_static_file(path)

Bu aslında BlackMambacevaptır, bu yüzden onlara bir oy verin.

Sonraki klasörler ağacını oluşturan açısal + demirbaş akışı için:

backend/
|
|------ui/
|      |------------------build/          <--'static' folder, constructed by Grunt
|      |--<proj           |----vendors/   <-- angular.js and others here
|      |--     folders>   |----src/       <-- your js
|                         |----index.html <-- your SPA entrypoint 
|------<proj
|------     folders>
|
|------view.py  <-- Flask app here

Aşağıdaki çözümü kullanıyorum:

...
root = os.path.join(os.path.dirname(os.path.abspath(__file__)), "ui", "build")

@app.route('/<path:path>', methods=['GET'])
def static_proxy(path):
    return send_from_directory(root, path)


@app.route('/', methods=['GET'])
def redirect_to_index():
    return send_from_directory(root, 'index.html')
...

'Statik' klasörü özel olarak yeniden tanımlamaya yardımcı olur.

Bu yüzden işlerim var (@ user1671599 cevabına dayanarak) ve sizlerle paylaşmak istedim.

(Umarım Python'daki ilk uygulamam olduğu için doğru yapıyorum)

Bunu ben yaptım -

Proje yapısı:

server.py:

from server.AppStarter import AppStarter
import os

static_folder_root = os.path.join(os.path.dirname(os.path.abspath(__file__)), "client")

app = AppStarter()
app.register_routes_to_resources(static_folder_root)
app.run(__name__)

AppStarter.py:

from flask import Flask, send_from_directory
from flask_restful import Api, Resource
from server.ApiResources.TodoList import TodoList
from server.ApiResources.Todo import Todo


class AppStarter(Resource):
    def __init__(self):
        self._static_files_root_folder_path = ''  # Default is current folder
        self._app = Flask(__name__)  # , static_folder='client', static_url_path='')
        self._api = Api(self._app)

    def _register_static_server(self, static_files_root_folder_path):
        self._static_files_root_folder_path = static_files_root_folder_path
        self._app.add_url_rule('/<path:file_relative_path_to_root>', 'serve_page', self._serve_page, methods=['GET'])
        self._app.add_url_rule('/', 'index', self._goto_index, methods=['GET'])

    def register_routes_to_resources(self, static_files_root_folder_path):

        self._register_static_server(static_files_root_folder_path)
        self._api.add_resource(TodoList, '/todos')
        self._api.add_resource(Todo, '/todos/<todo_id>')

    def _goto_index(self):
        return self._serve_page("index.html")

    def _serve_page(self, file_relative_path_to_root):
        return send_from_directory(self._static_files_root_folder_path, file_relative_path_to_root)

    def run(self, module_name):
        if module_name == '__main__':
            self._app.run(debug=True)

Bunu yapmanın basit yollarından biri. Şerefe!

demo.py

from flask import Flask, render_template
app = Flask(__name__)

@app.route("/")
def index():
   return render_template("index.html")

if __name__ == '__main__':
   app.run(debug = True)

Şimdi şablon adı verilen klasör adı oluşturun . İndex.html dosyanızı şablonlar klasörüne ekleyin

index.html

<!DOCTYPE html>
<html>
<head>
    <title>Python Web Application</title>
</head>
<body>
    <div>
         <p>
            Welcomes You!!
         </p>
    </div>
</body>
</html>

Proje Yapısı

-demo.py
-templates/index.html

Bu örneği paylaşmayı düşündüm.

from flask import Flask
app = Flask(__name__)

@app.route('/loading/')
def hello_world():
    data = open('sample.html').read()    
    return data

if __name__ == '__main__':
    app.run(host='0.0.0.0')

Bu daha iyi ve basit çalışır.

Kullan redirectveurl_for

from flask import redirect, url_for

@app.route('/', methods=['GET'])
def metrics():
    return redirect(url_for('static', filename='jenkins_analytics.html'))

Bu sunucular html'nizde başvurulan tüm dosyaları (css & js ...).

En basit yol, ana proje klasörü içinde statik bir klasör oluşturmaktır. .Css dosyalarını içeren statik klasör.

ana klasör

/Main Folder
/Main Folder/templates/foo.html
/Main Folder/static/foo.css
/Main Folder/application.py(flask script)

Statik ve şablonlar klasörleri ve balon komut dosyası içeren ana klasörün görüntüsü

şişe

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/")
def login():
    return render_template("login.html")

html (düzen)

<!DOCTYPE html>
<html>
    <head>
        <title>Project(1)</title>
        <link rel="stylesheet" href="/static/styles.css">
     </head>
    <body>
        <header>
            <div class="container">
                <nav>
                    <a class="title" href="">Kamook</a>
                    <a class="text" href="">Sign Up</a>
                    <a class="text" href="">Log In</a>
                </nav>
            </div>
        </header>  
        {% block body %}
        {% endblock %}
    </body>
</html>

html

{% extends "layout.html" %}

{% block body %}
    <div class="col">
        <input type="text" name="username" placeholder="Username" required>
        <input type="password" name="password" placeholder="Password" required>
        <input type="submit" value="Login">
    </div>
{% endblock %}

app = Flask(__name__, static_folder="your path to static")

Kök dizininizde şablonlar varsa, bunu içeren dosya da aynı konumda ise app = Flask ( name ) yerleştirilirse, bu dosya başka bir konumdaysa, etkinleştirilecek şablon konumunu belirtmeniz gerekir Konumu işaret edecek bir şişe

Tüm cevaplar iyi ama benim için iyi çalışan şey sadece send_fileFlask'ın basit işlevini kullanmak . Ana bilgisayar: port / ApiName dosyanın çıktısını tarayıcıda gösterdiğinde yanıt olarak bir html dosyası göndermeniz gerektiğinde bu iyi çalışır

@app.route('/ApiName')
def ApiFunc():
    try:
        return send_file('some-other-directory-than-root/your-file.extension')
    except Exception as e:
        logging.info(e.args[0])```

   Varsayılan olarak, balon tüm şablon dosyalarınızı (herhangi bir düz metin dosyası, ancak genellikle .htmlveya jinja2 gibi bir şablon şablonu dili) içermek için bir "şablonlar" klasörü ve tüm statik dosyalarınızı (yani .js .cssve resimleriniz).
   Gözlerinde farklı routesu kullanabilirsiniz render_template()(ben yerleştirilir varsayılan olarak, yukarıda dediğimiz gibi bir şablon dosyasını işlemek için templatesisteğiniz için yanıt olarak klasöre). Ve şablon dosyasında (genellikle .html benzeri bir dosyadır), bazı .jsve / veya `` .css '' dosyalarını kullanabilirsiniz, bu yüzden sorunuzun bu statik dosyaları geçerli şablon dosyasına nasıl bağladığınızı tahmin ediyorum.

Sadece bir dosya açmaya çalışıyorsanız, kullanabilirsiniz app.open_resource(). Yani bir dosyayı okumak şöyle bir şey olurdu

with app.open_resource('/static/path/yourfile'):
      #code to read the file and do something