Deci, acest lucru este jenant. Am'am o aplicație pe care am aruncat împreună în Balon
și pentru moment este doar servind o singură pagină HTML statice, cu unele link-uri de la CSS și JS. Și nu pot't găsi în cazul în care în documentația Balon
descrie revenirea fișiere statice. Da, am putea folosi render_template "" dar eu știu de date nu este templatized. Am'd au crezut send_file " sau " url_for
a fost corect, dar nu am putut obține aceste la muncă. Între timp, sunt deschiderea de fișiere, citirea conținutului, si tachelaj un "Răspuns" adecvat tip mime:
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)
Cineva a vrut să dea un exemplu de cod sau url-ul pentru acest lucru? Știu că asta o să fie mort simplu.
Metoda preferată este de a utiliza nginx sau un alt server web pentru a servi fișiere statice; ele'll fi capabil să-l facă mai eficient decât Vasul.
Cu toate acestea, puteți utiliza send_from_directory
pentru a trimite fișiere dintr-un director, care poate fi destul de convenabil, în unele situații:
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()
Nu nu utilizarea `send_file " sau " send_static_file cu un utilizator furnizate de cale.
send_static_file
exemplu:
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')
Dacă doriți doar pentru a muta locația de fișiere statice, atunci cea mai simplă metodă este de a declara căile de constructor. În exemplul de mai jos, mi-am schimbat template-uri și fișiere statice într-un sub-folder numit web
.
app = Flask(__name__,
static_url_path='',
static_folder='web/static',
template_folder='web/templates')
static_url_path=''
elimină orice precedent calea de la URL-ul (de exemplu,
implicit /static
).static_folder='web/static'
va spune Balon servi fișiere găsite la
web/static`.template_folder='web/template-uri'
, în mod similar, aceasta schimbă
șabloane.Folosind această metodă, următoarele URL-ul va reveni un fișier CSS:
<link rel="stylesheet" type="text/css" href="/css/bootstrap.min.css">
Și, în sfârșit, aici's-o clipă de structura de foldere, unde flask_server.py` este Balon de exemplu:
Am'm sigur că'll găsi ceea ce aveți nevoie aici: http://flask.pocoo.org/docs/quickstart/#static-files
Practic ai nevoie doar de un "static" folder de la rădăcina pachet, și apoi puteți folosi url_for('static', filename='foo.bar') sau direct link-ul de la fișierele cu http://example.com/static/foo.bar.
EDIT: Cum a sugerat în comentariile pe care le-ar putea folosi direct '/static/foo.bar'
cale URL DAR url_for()
deasupra capului (de performanță) este destul de scăzut, și folosind-o înseamnă că te'll fi capabil de a personaliza cu ușurință comportamentul ulterior (schimba dosar, schimba calea URL-ului, mutați fișierele statice la S3, etc).
Puteți, de asemenea, și acest lucru este meu preferat, setați un folder ca static calea, astfel încât fișierele în interiorul sunt accesibile pentru toată lumea.
app = Flask(__name__, static_url_path='/static')
Cu acest set puteți utiliza standard de HTML:
<link rel="stylesheet" type="text/css" href="/static/style.css">
Puteți utiliza această funcție :
send_static_file(filename)
Funcția de folosit intern pentru a trimite static fișierele din folder static pentru browser-ul.
app = Flask(__name__)
@app.route('/<path:path>')
def static_file(path):
return app.send_static_file(path)
Ceea ce am folosi (si's a fost mare lucru) este o "modele" director și un "static" director. Am locul meu .fișierele html/Balon template-uri în interiorul directorul template-uri, și statice conține CSS/JS. render_template funcționează bine pentru generic html fișiere pentru a cunoștințele mele, indiferent de nivelul la care te-ai folosit Vasul's templating sintaxă. Mai jos este o mostră de apel în views.py fișierul.
@app.route('/projects')
def projects():
return render_template("projects.html", title = 'Projects')
Doar asigurați-vă că utilizați url_for() atunci când doriți să referință un fișier static în statică separată director. Te'll probabil fac asta oricum in CSS/JS fișiere link-uri in html. De exemplu...
<script src="{{ url_for('static', filename='styles/dist/js/bootstrap.js') }}"></script>
Aici's un link la "canonic" informale Balon tutorial - o mulțime de sfaturi aici pentru a vă ajuta să lovi la sol de rulare.
http://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world
Un simplu exemplu de lucru bazat pe alte răspunsuri este următoarea:
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)
Cu HTML numit index.html:
<!DOCTYPE html>
<html>
<head>
<title>Hello World!</title>
</head>
<body>
<div>
<p>
This is a test.
</p>
</div>
</body>
</html>
IMPORTANT: Și index.html este într-un folder numit static, sensul <projectpath>
are .py
fișier, și <projectpath>\static
a html
de fișier.
Dacă doriți ca serverul să fie vizibile în rețea, utilizarea app.rula(debug=True, gazdă='0.0.0.0')`
EDIT: Pentru a arăta toate fișierele din folder dacă este solicitat, folositi acest
@app.route('/<path:path>')
def static_file(path):
return app.send_static_file(path)
Care este, în esență, BlackMamba
's a răspunde, astfel încât să le dea un vot pentru.
Pentru unghiulară+șabloane de flux care creează următoarele foldere copac:
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
Eu folosesc următoarea soluție:
...
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')
...
El ajută pentru a redefini 'static' folder personalizat.
Așa că am luat lucrurile de lucru (bazat pe @user1671599 răspuns) și a vrut să-l împărtășesc cu voi.
(Sper'm fac bine, deoarece's primul meu app în Python)
Am făcut acest lucru -
Structura proiectului:
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)
Ideea de a împărți.... acest exemplu.
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')
Aceasta funcționează mai bine și simplu.
Una dintre cele modalitate simplă de a face. Noroc!
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)
Acum crea folder cu numele șabloane. Adăugați index.html fișier în interiorul șabloane dosar
index.html
<!DOCTYPE html>
<html>
<head>
<title>Python Web Application</title>
</head>
<body>
<div>
<p>
Welcomes You!!
</p>
</div>
</body>
</html>
Structura Proiectului
-demo.py
-templates/index.html
from flask import redirect, url_for
...
@app.route('/', methods=['GET'])
def metrics():
return redirect(url_for('static', filename='jenkins_analytics.html'))
Această servere toate fișierele (css & js...) face referire în fișierul html.
Toate raspunsurile sunt bune, dar ceea ce a lucrat bine pentru mine este doar folosind simplu funcția `send_file
din Balon. Aceasta funcționează bine atunci când aveți nevoie doar pentru a trimite un fișier html ca răspuns atunci când host:port/ApiName va arăta de ieșire a fișierului în browser-ul
`din balon import Balon, send_file
@app.traseu('/ApiName') def ApiFunc(): încercați: reveni send_file('unele-altele-director-de-rădăcină/ta-fișier.extensia') cu excepția Excepție ca e: logare.informații(de exemplu.args[0])``
Dacă sunt doar încercarea de a deschide un fișier, puteți utiliza app.open_resource()`. Deci citirea unui fișier ar arata ceva de genul
with app.open_resource('/static/path/yourfile'):
#code to read the file and do something
Cel mai simplu mod este de a crea un folder static în principal dosar de proiect. Static folder care conține .fișierele css.
folderul principal
/Main Folder
/Main Folder/templates/foo.html
/Main Folder/static/foo.css
/Main Folder/application.py(flask script)
Imagine din folderul principal conținut static și template-uri, foldere și balon script
balon
from flask import Flask, render_template
app = Flask(__name__)
@app.route("/")
def login():
return render_template("login.html")
html (layout)
<!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 %}
în mod implicit, balon folosi un "modele" dosarul conține toate fișierele șablon(orice text simplu fișier, dar, de obicei .html sau un fel de șablon de limbă, cum ar fi jinja2 ) & a "static" dosarul conține toate fișierele statice(de exemplu
.js`.css și imagini). <br/> În "rute", u pot folosi render_template()
pentru a face un șablon de fișier (cum am spus mai sus, în mod implicit acesta este plasat în folderul "șabloane") ca răspuns la solicitarea dvs.. Și în fișier șablon (it's de obicei .html-fișiere), u poate fi utilizat `.js "și/sau".css' fișiere, deci cred că întrebarea ta este cum u link-ul de aceste fișiere statice de curent fișier șablon.