def loader_meta(app=None):
from .views import core
app.register_blueprint(core)
from flask_bootstrap import Bootstrap
bootstrap = Bootstrap()
bootstrap.init_app(app)
from flask_menu import Menu
menu = Menu()
menu.init_app(app)
from flask import render_template
app.errorhandler(404)(lambda e: (render_template('core/404.html'), 404))
app.errorhandler(500)(lambda e: (render_template('core/404.html'), 500))
def create_app(config_filename=None):
app = Flask(__name__, instance_relative_config=True)
# Load default config
app.config.from_object('{{cookiecutter.app_name}}.config.DefaultConfig')
# Load secret config stuff from instance folder
app.config.from_pyfile('config.py', silent=True)
# Permit passing in config filename for testing
if config_filename is not None:
app.config.from_pyfile(config_filename)
bootstrap = Bootstrap()
bootstrap.init_app(app)
from .views.public import public
app.register_blueprint(public)
@app.errorhandler(404)
def page_not_found(error):
return 'This route does not exist: {}'.format(request.url), 404
return app
def create_app(config_filename):
# for static files
app = Flask(__name__, instance_relative_config=True, instance_path='/code')
app.config.from_pyfile(os.path.join(app.instance_path, config_filename))
app.config['STATIC_URL_PATH'] = 'static'
#app.config['DEBUG'] = True
bootstrap = Bootstrap()
bootstrap.init_app(app)
#app.register_blueprint(app)
## prepare database
from web_tasker.models import db
db.init_app(app)
with app.app_context():
db.create_all()
# show startup flask variables
#from pprint import pprint
#items = app.config.viewitems()
#for i in items: pass
# print(i)
return app
def create_app():
app = flask.Flask(__name__)
config.init_app(app)
bootstrap = Bootstrap()
bootstrap.init_app(app)
moment.init_app(app)
mail.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
return app
def register_app(app):
" Configure application. "
from .views import urls
app.register_blueprint(urls)
from .ext import admin
admin.init_app(app)
from flask_bootstrap import Bootstrap
bootstrap = Bootstrap()
bootstrap.init_app(app)
from flask import render_template
app.errorhandler(404)(lambda e: (render_template('core/404.html'), 404))
def create_app(db):
app = Flask(__name__)
app.register_blueprint(index_blueprint, url_prefix='/')
app.register_blueprint(member_blueprint, url_prefix='/member/')
app.config['SECRET_KEY'] = '\xca\x0c\x86\x04\x98@\x02b\x1b7\x8c\x88]\x1b\xd7"+\xe6px@\xc3#\\'
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://*****:*****@localhost/myweb'
login = LoginManager()
bootstrap = Bootstrap()
admin = Admin(name="APP admin", template_mode='bootstrap3')
admin.add_view(myview.MyView(name='Hello'))
admin.init_app(app)
bootstrap.init_app(app)
login.init_app(app)
db.init_app(app)
return app
def register_app(app):
" Configure application. "
from .views import core
app.register_blueprint(core)
from .ext import admin
admin.init_app(app)
from flask_bootstrap import Bootstrap
bootstrap = Bootstrap()
bootstrap.init_app(app)
from flask import render_template
app.errorhandler(404)(lambda e: (render_template('core/404.html'), 404))
if not app.debug:
mailhandler = FlaskMailHandler(ERROR)
app.logger.addHandler(mailhandler)
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap = Bootstrap()
bootstrap.init_app(app)
from app.models import db
db.init_app(app)
from app.models import login_manager
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
from app.email import mail
mail.init_app(app)
if not app.debug and not app.testing:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
from app.blueprints.main import main as main_blueprint
app.register_blueprint(main_blueprint)
from app.blueprints.auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
# Add additional blueprints here...
# example:
# from .myblueprint import myblueprint as myblueprint_blueprint
# app.register_blueprint(myblueprint_blueprint, url_prefix='/myblueprint')
return app
from flask import Flask, render_template, request, redirect
# render_template is to add html files
from flask_bootstrap import Bootstrap
#import database
from flask_mysqldb import MySQL
import yaml
app = Flask(__name__)
Bootstrap(app) #enable bootastrap
#connection
db = yaml.safe_load(open('db.yaml'))
app.config['MYSQL_HOST'] = db['mysql_host']
app.config['MYSQL_USER'] = db['mysql_user']
app.config['MYSQL_PASSWORD'] = db['mysql_password']
app.config['MYSQL_DB'] = db['mysql_db']
app.config[
'MYSQL_CURSORCLASS'] = 'DictCursor' # This will laid us to pass in dictionary
# format in users.html file
mysql = MySQL(app)
#Display All Data from Database
@app.route('/')
def display():
cur = mysql.connection.cursor()
result = cur.execute("select * from entry")
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from flask_login import LoginManager
import logging
from logging.handlers import SMTPHandler
from logging.handlers import RotatingFileHandler
from flask_bootstrap import Bootstrap
import os
app = Flask(__name__) #Defines Python flask application
app.config.from_object(Config) #Configures database
db = SQLAlchemy(app) #Database from SQLAlchemy
migrate = Migrate(app, db) #Handles database migrations w/ Alembic
login = LoginManager(app) #Login with login manager
login.login_view = 'login' #Protects and mandates login
bootstrap = Bootstrap(app) #Applies bootstrap onto Flask app
if not app.debug:
if app.config['MAIL_SERVER']:
auth = None
if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']:
auth = (app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD'])
secure = None
if app.config['MAIL_USE_TLS']:
secure = ()
mail_handler = SMTPHandler(
mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']),
fromaddr='no-reply@' + app.config['MAIL_SERVER'],
toaddrs=app.config['ADMINS'],
subject='Blog Failure',
credentials=auth,
from models import db, User, Recipe, Ingredient, Step
from forms import LoginForm, SignupForm
''' Begin boilerplate code '''
def create_app():
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db'
app.config['SECRET_KEY'] = "MYSECRET"
app.config['JWT_EXPIRATION_DELTA'] = timedelta(days=7)
db.init_app(app)
return app
app = create_app()
Bootstrap(app)
app.app_context().push()
db.create_all(app=app)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'
''' End Boilerplate Code '''
@app.route("/", methods=['GET', 'POST'])
def index():
form = LoginForm()
if form.validate_on_submit():
return render_template('index.html', user=user)
@app.route('/create_db/')
def create_database():
token = request.cookies.get('token')
if User.query.get(cache.get_user_id(token)).roles: # 该用户的角色列表
for u in User.query.get(cache.get_user_id(token)).roles:
for p in u.privileges:
if p.name == 'create_db':
print('有权限！')
return 'OK'
# print('name:',i.name)
# db.create_all()
return '创建数据库中的所有模型表成功'
@app.route('/drop_db/')
def drop_database():
db.drop_all()
return '删除数据库中的所有模型表成功'
if __name__ == '__main__':
app.register_blueprint(user_v.blue, url_prefix='/user')
db.init_app(app)
CORS().init_app(app)
Bootstrap().init_app(app)
manage = Manager(app)
manage.run()
from app import error_route
mail_settings = {
"MAIL_SERVER": os.environ['MAIL_SERVER'],
"MAIL_PORT": os.environ['MAIL_PORT'],
"MAIL_USE_TLS": True,
"MAIL_USE_SSL": False,
"MAIL_USERNAME": os.environ['MAIL_ADDR'],
"MAIL_PASSWORD": os.environ['MAIL_PASSWD'],
"MAIL_DEFAULT_SENDER": os.environ['MAIL_ADDR']
}
template_dir = os.path.abspath('./app/template')
application = Flask(__name__, template_folder=template_dir)
application.config.update(mail_settings)
application.config['RESIZE_URL'] = 'http://il-a3.21-school.ru:5000/'
application.config['RESIZE_ROOT'] = '~/py_img'
application.secret_key = 'VERYVERYSECRETKEY'
application.config['SESSION_TYPE'] = 'redis'
Bootstrap(application)
moment = Moment(application)
route.init(application)
rest_api.init(application)
error_route.init(application)
if __name__ == '__main__':
application.run()
def create_app():
app = Flask(__name__)
Bootstrap(app)
return app
def create_app():
Bootstrap(app)
return app
def create_app_new(configfile=None):
app = Flask(__name__)
AppConfig(app, configfile) # Flask-Appconfig is not necessary, but
# highly recommend =)
# https://github.com/mbr/flask-appconfig
Bootstrap(app)
flask_sijax.Sijax(app)
# in a real app, these should be configured through Flask-Appconfig
app.config['SECRET_KEY'] = 'devkey'
app.config['RECAPTCHA_PUBLIC_KEY'] = \
'6Lfol9cSAAAAADAkodaYl9wvQCwBMr3qGR_PPHcw'
@app.route('/', methods=('GET', 'POST'))
def index():
form = ExampleForm()
form.validate_on_submit() # to get error messages to the browser
flash('critical message', 'critical')
flash('error message', 'error')
flash('warning message', 'warning')
flash('info message', 'info')
flash('debug message', 'debug')
flash('different message', 'different')
flash('uncategorized message')
return render_template('index.html', form=form)
@app.route('/congrats')
def congrats():
return render_template('congrats.html')
@app.route('/wrong')
def wrong():
return render_template('wrong.html')
@app.route('/quiz')
def quiz():
qid = random.sample(range(len(qa_set.keys())), 1)[0]
contents, question, answer, score = qa_set[qid]
correct_count = 0
if request.args.get('correct_count'):
correct_count = int(request.args.get('correct_count'))
ai_correct_count = 0
if request.args.get('ai_correct_count'):
ai_correct_count = int(request.args.get('ai_correct_count'))
correct_qids = []
if correct_count > 0:
if request.args.get('correct_qids'):
correct_qids = request.args.get('correct_qids').split(',')
print(correct_qids)
while (str(qid) in correct_qids):
qid = random.sample(range(len(qa_set.keys())), 1)[0]
# for key in request.args.keys():
# print(key + ' ' + request.args.get(key))
# print(int(request.args.get('ai_correct_count')))
# print
return render_template('quiz.html', contents=contents, qid=qid, question=question, correct_count=correct_count, ai_correct_count=ai_correct_count, correct_qids=','.join(correct_qids))
# @flask_sijax.route(app, '/result')
@app.route('/result', methods=['POST'])
def result():
# Every Sijax handler function (like this one) receives at least
# one parameter automatically, much like Python passes `self`
# to object methods.
# The `obj_response` parameter is the function's way of talking
# back to the browser
# def say_hi(obj_response):
# obj_response.alert('Hi there!')
correct_count = int(request.form['correct_count'])
ai_correct_count = int(request.form['ai_correct_count'])
correct_qids = request.form['correct_qids'].split(',')
#ai_correct_count = int(request.form['ai_correct_count'])
qid = request.form['qid']
answer = request.form['answer']
ai_answer = qa_set[int(qid)][3]
correct_answer = qa_set[int(qid)][2]
result_message = ''
animation = ''
ai_result = ''
human_result = ''
if ai_answer == correct_answer:
ai_result = 'correct'
ai_correct_count = ai_correct_count + 1
else:
ai_result = 'wrong'
if correct_answer == answer:
result_message = '정답이에요~';
animation = 'pulse slow';
human_result = 'correct'
correct_count = correct_count + 1
if correct_qids == ['']:
correct_qids = [qid]
else:
correct_qids.append(qid)
else:
result_message = '땡! 기계보다 못한..'
animation = 'hinge delay-2s'
human_result = 'wrong'
correct_qids = []
result = str(correct_answer==answer)
# if g.sijax.is_sijax_request:
# # Sijax request detected - let Sijax handle it
# g.sijax.register_callback('say_hi', say_hi)
# return g.sijax.process_request()
# Regular (non-Sijax request) - render the page template
return render_template('result.html',
result_message=result_message,
correct_answer=correct_answer,
animation=animation,
ai_result=ai_result,
human_result=human_result,
answer=answer,
correct_count=correct_count,
ai_correct_count=ai_correct_count,
result=(correct_answer==answer),
ai_answer=ai_answer,
correct_qids=','.join(correct_qids))
#return json.dumps({'result_message':result_message,'correct_answer':correct_answer,'animation':animation});
return app
from flask import Flask, render_template
from flask_bootstrap import Bootstrap
from flask_nav import Nav
from flask_nav.elements import Navbar, View, Subgroup, Link
from meusforms import LoginForm, FormDeRegistro
from dadostabela import *
SECRET_KEY = 'aula de BCD - string aleatória'
app = Flask(__name__)
app.secret_key = SECRET_KEY
boostrap = Bootstrap(app) # isso habilita o template bootstrap/base.html
nav = Nav()
nav.init_app(
app) # isso habilita a criação de menus de navegação do pacote Flask-Nav
@nav.navigation()
def meunavbar():
menu = Navbar('Minha aplicação')
menu.items = [View('Home', 'inicio'), View('Registro', 'cadastro')]
menu.items.append(
Subgroup('Menu de opções', View('Aluno', 'aluno'),
View('Professor', 'professor')))
menu.items.append(View('Login', 'autenticar'))
menu.items.append(Link('Ajuda', 'https://www.google.com'))
return menu
import os
from flask import Flask, request, jsonify, render_template
from flask_bootstrap import Bootstrap
from flask_sqlalchemy import SQLAlchemy
# TODO: Remove basedir once switched to postgres etc
basedir = os.path.abspath(os.path.dirname(__file__))
site = { 'title' : "N Tier Flask App" } # My additions for Title, simplify passing metadata
app = Flask(__name__)
bootstrap = Bootstrap(app) # Setting up bootstrap
# app.config.from_object(os.environ['APP_SETTINGS'])
app.config['SECRET_KEY'] = 'r3dh4t1!' # For now, externalize later
app.config['SQLALCHEMY_DATABASE_URI'] =\
'postgresql://*****:*****@appdb1:5432/flask_db'
# 'sqlite:///' + os.path.join(basedir, 'data.sqlite')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
# TODO: abstract into ext.py and avoid circular dependencies
class Resource(db.Model):
__tablename__ = 'resources'
def create_app(config_filename=None):
"""create app."""
app = FlaskAPI(__name__)
per_page = int(
os.getenv('BUKUSERVER_PER_PAGE', str(views.DEFAULT_PER_PAGE)))
per_page = per_page if per_page > 0 else views.DEFAULT_PER_PAGE
app.config['BUKUSERVER_PER_PAGE'] = per_page
url_render_mode = os.getenv('BUKUSERVER_URL_RENDER_MODE',
views.DEFAULT_URL_RENDER_MODE)
if url_render_mode not in ('full', 'netloc'):
url_render_mode = views.DEFAULT_URL_RENDER_MODE
app.config['BUKUSERVER_URL_RENDER_MODE'] = url_render_mode
app.config['SECRET_KEY'] = os.getenv(
'BUKUSERVER_SECRET_KEY') or os.urandom(24)
app.config['BUKUSERVER_DB_FILE'] = os.getenv('BUKUSERVER_DB_FILE')
bukudb = BukuDb(dbfile=app.config['BUKUSERVER_DB_FILE'])
app.app_context().push()
setattr(flask.g, 'bukudb', bukudb)
@app.shell_context_processor
def shell_context():
"""Shell context definition."""
return {'app': app, 'bukudb': bukudb}
app.jinja_env.filters['netloc'] = lambda x: urlparse(x).netloc # pylint: disable=no-member
Bootstrap(app)
admin = Admin(app,
name='Buku Server',
template_mode='bootstrap3',
index_view=views.CustomAdminIndexView(
template='bukuserver/home.html', url='/'))
# routing
# api
app.add_url_rule('/api/tags', 'get_tags', tag_list, methods=['GET'])
app.add_url_rule('/api/tags/<tag>',
'update_tag',
tag_detail,
methods=['GET', 'PUT'])
app.add_url_rule('/api/network_handle',
'networkk_handle',
network_handle_detail,
methods=['POST'])
app.add_url_rule('/api/bookmarks',
'bookmarks',
bookmarks,
methods=['GET', 'POST', 'DELETE'])
app.add_url_rule('/api/bookmarks/refresh',
'refresh_bookmarks',
refresh_bookmarks,
methods=['POST'])
app.add_url_rule('/api/bookmarks/<id>',
'bookmark_api',
bookmark_api,
methods=['GET', 'PUT', 'DELETE'])
app.add_url_rule('/api/bookmarks/<id>/refresh',
'refresh_bookmark',
refresh_bookmark,
methods=['POST'])
app.add_url_rule('/api/bookmarks/<id>/tiny',
'get_tiny_url',
get_tiny_url,
methods=['GET'])
app.add_url_rule('/api/bookmarks/<id>/long',
'get_long_url',
get_long_url,
methods=['GET'])
app.add_url_rule('/api/bookmarks/<starting_id>/<ending_id>',
'bookmark_range_operations',
bookmark_range_operations,
methods=['GET', 'PUT', 'DELETE'])
app.add_url_rule('/api/bookmarks/search',
'search_bookmarks',
search_bookmarks,
methods=['GET', 'DELETE'])
# non api
admin.add_view(
views.BookmarkModelView(bukudb,
'Bookmarks',
page_size=per_page,
url_render_mode=url_render_mode))
admin.add_view(views.TagModelView(bukudb, 'Tags', page_size=per_page))
admin.add_view(
views.StatisticView(bukudb, 'Statistic', endpoint='statistic'))
return app
# 扩展类实例化
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from flask_bootstrap import Bootstrap
from flask_wtf.csrf import CSRFProtect
db = SQLAlchemy() # 数据库实例化
login_manager = LoginManager() #扩展登录功能
bootstrap = Bootstrap() #扩展Bootstrap
csrf = CSRFProtect() #CSRF保护
# 用户加载函数
@login_manager.user_loader
def load_user(user_id):
from edatribe.models import Admin
user = Admin.query.get(int(user_id))
return user
# 页面保护 -> 登录视图
login_manager.login_view = 'auth.login'
from flask import render_template from flask_bootstrap import Bootstrap from wtforms.validators import Required from flask_login import login_required from flask_wtf import Form from wtforms import StringField, SubmitField, TextAreaField, PasswordField, BooleanField from flask_login import login_user, logout_user, UserMixin, LoginManager from flask_sqlalchemy import SQLAlchemy #dsjflksadjflksa import six #get_id import requests ''' test git ''' #配置文件 app = Flask(__name__) bootstrap = Bootstrap(app) #初始化Bootstrap app.config['SECRET_KEY'] = 'hard to guess string' #WTF SRCF保护 app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://*****:*****@localhost/new' app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True app.config['PER_PAGE_NUM'] = 5 URL_RIGTSTER = 'http://222.18.167.207:4000/auth/register' login_manager = LoginManager() login_manager.session_protection = 'strong' login_manager.login_view = 'login' db = SQLAlchemy(app) #Form文件
def init_ext(app):
bcrypt.init_app(app)
mail.init_app(app)
DebugToolbarExtension(app)
Bootstrap(app)
print("Preparing readers")
for pair in SERVER_SUPPORTED_PAIRS:
print(f"\t {pair}")
storage = StorageReader(pair)
readers.append(storage)
history_cache[pair] = HistoryCache(storage, 10.0, 5 * 3600)
history_cache[pair].get_data()
print("readers are ready")
trading_server = TradingServer(EXCHANGE_NAME, readers)
trading_server.run_server(int(TRADING_ENDPOINT.split(":")[-1]))
web_server = Flask(__name__, template_folder="web/templates", static_folder="web/static")
web_server.secret_key = b'fer234\n\xec]/'
Bootstrap(web_server)
@web_server.route("/profile/<username>")
def profile(username):
return render_template("profile.html", username=username)
@web_server.route("/history")
def history():
return render_template("history.html")
@web_server.route("/portfolio_values")
def portfolio_values():
return render_template("portfolio_values.html")
def create_app(config_name):
app = Flask(__name__)
Bootstrap(app)
global return_url
return_url = ''
class MainForm(FlaskForm):
fullname = StringField('Full Name: ', [validators.DataRequired(), ])
submit = SubmitField('Submit')
@app.route('/', methods=['GET', 'POST'])
def index():
global return_url
user = request.remote_user
if "redir" in request.args and return_url == "":
return_url = request.args.get("redir") or "/pun/sys/dashboard"
username = False
form = MainForm()
if form.is_submitted():
username = form.fullname.data
form.fullname.data = ''
return redirect(url_for('success', username=str(user), fullname=username))
return render_template('auth/SignUp.html', form=form, user=user)
@app.route('/success/<username>/<fullname>')
def success(username, fullname):
global return_url
print(username, fullname, return_url, file=sys.stdout)
# Deliver arguments to script.
tempString = 'ssh ohpc "sudo /opt/ohpc_user_create/user_create ' + username + " " + fullname + '"'
print(tempString, file=sys.stdout)
try:
# function to write out a flatdb with the name of the file being a timestamp and the content
# of the file beieng blazerID the user submitted from the flask form (fullname)
time_stamp = time.strftime("%m-%d-%Y_%H:%M:%S")
directory = "/var/www/ood/register/flask_user_reg/app/flat_db"
complete_file_name = os.path.join(directory, time_stamp + ".txt")
if not os.path.exists(directory):
os.makedirs(directory)
file = open(complete_file_name, "w")
file.write(fullname)
file.close()
return redirect(return_url, 302)
except:
flash("Registration Failed. Please try again.")
return redirect(url_for('index'))
@app.errorhandler(403)
def forbidden(error):
return render_template('errors/403.html', title='Forbidden'), 403
@app.errorhandler(404)
def page_not_found(error):
return render_template('errors/404.html', title='Page Not Found'), 404
@app.errorhandler(500)
def internal_server_error(error):
return render_template('errors/500.html', title='Server Error'), 500
return app
from flask_wtf.file import FileField, FileAllowed
from werkzeug import secure_filename
from wtforms import PasswordField, RadioField, TextField
from wtforms.validators import DataRequired
from tasks import process_user_csv, process_access_levels_csv
from access_levels import dump_access_levels_csv
app = Flask(__name__)
# TODO put them somewhere secure
app.config["UPLOAD_FOLDER"] = tempfile.gettempdir()
app.config["SECRET_KEY"] = os.environ.get('XIT_SECRET', 'secret-key')
bs = Bootstrap()
bs.init_app(app)
class CsvUploadForm(Form):
xplan_url = TextField(
'XPLAN URL',
validators=[DataRequired()])
xplan_username = TextField(
'Username',
validators=[DataRequired()])
xplan_password = PasswordField(
'Password',
validators=[DataRequired()])
csv_type = RadioField(
'CSV Type',
import click from flask import Flask from config import Config from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate from flask_login import LoginManager from flask_bootstrap import Bootstrap from flask.cli import with_appcontext from werkzeug.security import generate_password_hash flask_app = Flask(__name__) flask_app.config.from_object(Config) db = SQLAlchemy(flask_app) migrate = Migrate(flask_app, db) bootstrap = Bootstrap(flask_app) login = LoginManager(flask_app) login.login_view = 'admin_login' from app import routes, models, errors @click.command(name='create_admin') @with_appcontext def create_admin(): admin = models.User(email=flask_app.config['ADMIN_EMAIL'], password=flask_app.config['ADMIN_PASSWORD']) admin.password = generate_password_hash(admin.password, 'sha256', salt_length=12) db.session.add(admin) db.session.commit() flask_app.cli.add_command(create_admin)
import flask, json, urllib, gmpy2
from flask import render_template
import base64, base58, base91, base36, base62
#62->pip install pybase62
from flask_bootstrap import Bootstrap
from flask import request
server = flask.Flask(__name__)
bootstrap = Bootstrap()
bootstrap.init_app(server)
@server.route('/', methods=['get', 'post'])
def index():
return render_template('index.html')
@server.route('/to_base64', methods=['get', 'post'])
def to_base64():
return render_template('base-base64.html', result='')
@server.route('/base_all', methods=['get', 'post'])
def base_all():
cypher_text = ''
plain_text = ''
text = request.values.get('text')
num_of_base = request.values.get('num_of_base')
encode_or_decode = request.values.get('encode_or_decode')
from flask_sqlalchemy import SQLAlchemy
from flask_bootstrap import Bootstrap
from flask_login import LoginManager
from flask_mail import Mail
from flask_moment import Moment
from flask_whooshee import Whooshee
from flask_wtf import CSRFProtect
db=SQLAlchemy()
bootstrap=Bootstrap()
login_manager=LoginManager()
mail=Mail()
moment=Moment()
whooshee=Whooshee()
csrf = CSRFProtect()
@login_manager.user_loader
def load_user(user_id):
from tt.models import User
return User.query.get(int(user_id))
login_manager.login_view = 'auth.login'
from flask_bootstrap import Bootstrap
# docker
import sys
sys.path.append('/code')
from transfer_learning_spades import load_transfer_model
from VGG16_spades import predict
from spades_recommend import place_recommend, food_recommend
from route_plan import main as route_plan
from weather import weather
app = Flask(__name__) #建立 Flask 物件
# app.config['UPLOAD_FOLDER'] = upload_dir # user_test 上傳照片的存檔路徑
# app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024 # 16MB
bootstrap = Bootstrap(app) #建立 bootstrap 物件
@app.route('/')
def my_index():
return render_template('index.html')
@app.route('/sign_up')
def sign_up():
return render_template('sign_up.html')
@app.route('/action_number.php', methods=['GET'])
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + app.root_path + '/data.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
from luogu_spider import t, BenBen, LuoguUser, User, DeleteWant, LoginRecord, Notification, doing
from flask_bootstrap import Bootstrap
from flask_wtf import FlaskForm
from wtforms import SubmitField, StringField, DateTimeField, TextAreaField, PasswordField, BooleanField, RadioField
from wtforms.validators import DataRequired, Length, AnyOf, EqualTo
import click
from flask_migrate import Migrate
from werkzeug.security import generate_password_hash, check_password_hash
import uuid
import cgi
migrate = Migrate(app, db)
bootstrap = Bootstrap(app)
#thread = threading.Thread(target=doing)
t.setDaemon(True)
t.start()
login_manager = LoginManager()
login_manager.init_app(app)
#ckeditor = CKEditor(app)
limiter = Limiter(app, key_func=get_remote_address)
moment = Moment()
moment.init_app(app)
@login_manager.user_loader
def load_user(user_id):
user = User.query.get(int(user_id))
return user
def create_app(config_filename="config.development.Config",
app_name=None,
register_blueprints=True):
# App configuration
app = Flask(app_name or __name__)
app_settings = os.getenv("APP_SETTINGS", config_filename)
print(f" * Loading config: '{app_settings}'")
try:
cfg = import_string(app_settings)()
except ImportError:
print(" *** Cannot import config ***")
cfg = import_string("config.config.BaseConfig")
print(" *** Default config loaded, expect problems ***")
if hasattr(cfg, "post_load"):
print(" *** Doing some magic")
cfg.post_load()
app.config.from_object(cfg)
app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1)
Bootstrap(app)
app.jinja_env.add_extension("jinja2.ext.with_")
app.jinja_env.add_extension("jinja2.ext.do")
app.jinja_env.globals.update(is_admin=is_admin)
if HAS_SENTRY:
sentry_sdk.init(
app.config["SENTRY_DSN"],
integrations=[SentryFlaskIntegration(),
SentryCeleryIntegration()],
release=f"{VERSION} ({GIT_VERSION})",
)
print(" * Sentry Flask/Celery support activated")
print(" * Sentry DSN: %s" % app.config["SENTRY_DSN"])
if app.debug:
app.jinja_env.auto_reload = True
logging.basicConfig(level=logging.DEBUG)
# Logging
if not app.debug:
formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s "
"[in %(pathname)s:%(lineno)d]")
file_handler = RotatingFileHandler("%s/errors_app.log" % os.getcwd(),
"a", 1000000, 1)
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(formatter)
app.logger.addHandler(file_handler)
CORS(app, origins=["*"])
if app.debug:
logging.getLogger("flask_cors.extension").level = logging.DEBUG
mail = Mail(app) # noqa: F841
migrate = Migrate(app, db) # noqa: F841 lgtm [py/unused-local-variable]
babel = Babel(app) # noqa: F841
app.babel = babel
template = {
"swagger": "2.0",
"info": {
"title": "reel2bits API",
"description": "API instance",
"version": VERSION
},
"host": app.config["AP_DOMAIN"],
"basePath": "/",
"schemes": ["https"],
"securityDefinitions": {
"OAuth2": {
"type": "oauth2",
"flows": {
"authorizationCode": {
"authorizationUrl":
f"https://{app.config['AP_DOMAIN']}/oauth/authorize",
"tokenUrl":
f"https://{app.config['AP_DOMAIN']}/oauth/token",
"scopes": {
"read": "Grants read access",
"write": "Grants write access",
"admin": "Grants admin operations",
},
}
},
}
},
"consumes": ["application/json", "application/jrd+json"],
"produces": ["application/json", "application/jrd+json"],
}
db.init_app(app)
# ActivityPub backend
back = Reel2BitsBackend()
ap.use_backend(back)
# Oauth
config_oauth(app)
# Setup Flask-Security
security = Security(
app, user_datastore) # noqa: F841 lgtm [py/unused-local-variable]
@FlaskSecuritySignals.password_reset.connect_via(app)
@FlaskSecuritySignals.password_changed.connect_via(app)
def log_password_reset(sender, user):
if not user:
return
add_user_log(user.id, user.id, "user", "info",
"Your password has been changed !")
@FlaskSecuritySignals.reset_password_instructions_sent.connect_via(app)
def log_reset_password_instr(sender, user, token):
if not user:
return
add_user_log(user.id, user.id, "user", "info",
"Password reset instructions sent.")
@FlaskSecuritySignals.user_registered.connect_via(app)
def create_actor_for_registered_user(app, user, confirm_token):
if not user:
return
actor = create_actor(user)
actor.user = user
actor.user_id = user.id
db.session.add(actor)
db.session.commit()
@babel.localeselector
def get_locale():
# if a user is logged in, use the locale from the user settings
identity = getattr(g, "identity", None)
if identity is not None and identity.id:
return identity.user.locale
# otherwise try to guess the language from the user accept
# header the browser transmits. We support fr/en in this
# example. The best match wins.
return request.accept_languages.best_match(AVAILABLE_LOCALES)
@babel.timezoneselector
def get_timezone():
identity = getattr(g, "identity", None)
if identity is not None and identity.id:
return identity.user.timezone
@app.before_request
def before_request():
_config = Config.query.first()
if not _config:
flash(gettext("Config not found"), "error")
cfg = {
"REEL2BITS_VERSION_VER": VERSION,
"REEL2BITS_VERSION_GIT": GIT_VERSION,
"app_name": _config.app_name,
"app_description": _config.app_description,
}
if GIT_VERSION:
cfg["REEL2BITS_VERSION"] = "{0}-{1}".format(VERSION, GIT_VERSION)
else:
cfg["REEL2BITS_VERSION"] = VERSION
g.cfg = cfg
@app.errorhandler(InvalidUsage)
def handle_invalid_usage(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
# Tracks files upload set
sounds = UploadSet("sounds", AUDIO)
configure_uploads(app, sounds)
# Album artwork upload set
artworkalbums = UploadSet("artworkalbums",
Reel2bitsDefaults.artwork_extensions_allowed)
configure_uploads(app, artworkalbums)
# Track artwork upload set
artworksounds = UploadSet("artworksounds",
Reel2bitsDefaults.artwork_extensions_allowed)
configure_uploads(app, artworksounds)
# User avatars
avatars = UploadSet("avatars", Reel2bitsDefaults.avatar_extensions_allowed)
configure_uploads(app, avatars)
# Total max size upload for the whole app
patch_request_class(app, app.config["UPLOAD_TRACK_MAX_SIZE"])
app.flake_id = FlakeId()
if register_blueprints:
from controllers.main import bp_main
app.register_blueprint(bp_main)
from controllers.admin import bp_admin
app.register_blueprint(bp_admin)
# ActivityPub
from controllers.api.v1.well_known import bp_wellknown
app.register_blueprint(bp_wellknown)
from controllers.api.v1.nodeinfo import bp_nodeinfo
app.register_blueprint(bp_nodeinfo)
from controllers.api.v1.ap import bp_ap
# Feeds
from controllers.feeds import bp_feeds
app.register_blueprint(bp_feeds)
# API
app.register_blueprint(bp_ap)
from controllers.api.v1.auth import bp_api_v1_auth
app.register_blueprint(bp_api_v1_auth)
from controllers.api.v1.accounts import bp_api_v1_accounts
app.register_blueprint(bp_api_v1_accounts)
from controllers.api.v1.timelines import bp_api_v1_timelines
app.register_blueprint(bp_api_v1_timelines)
from controllers.api.v1.notifications import bp_api_v1_notifications
app.register_blueprint(bp_api_v1_notifications)
from controllers.api.tracks import bp_api_tracks
app.register_blueprint(bp_api_tracks)
from controllers.api.albums import bp_api_albums
app.register_blueprint(bp_api_albums)
from controllers.api.account import bp_api_account
app.register_blueprint(bp_api_account)
from controllers.api.reel2bits import bp_api_reel2bits
app.register_blueprint(bp_api_reel2bits)
# Pleroma API
from controllers.api.pleroma_admin import bp_api_pleroma_admin
app.register_blueprint(bp_api_pleroma_admin)
# OEmbed
from controllers.api.oembed import bp_api_oembed
app.register_blueprint(bp_api_oembed)
# Iframe
from controllers.api.embed import bp_api_embed
app.register_blueprint(bp_api_embed)
swagger = Swagger(
app,
template=template) # noqa: F841 lgtm [py/unused-local-variable]
# SPA catchalls for meta tags
from controllers.spa import bp_spa
app.register_blueprint(bp_spa)
@app.route("/uploads/<string:thing>/<path:stuff>", methods=["GET"])
@cross_origin(origins="*",
methods=["GET", "HEAD", "OPTIONS"],
expose_headers="content-length",
send_wildcard=True)
def get_uploads_stuff(thing, stuff):
if app.testing or app.debug:
directory = safe_join(app.config["UPLOADS_DEFAULT_DEST"], thing)
app.logger.debug(f"serving {stuff} from {directory}")
return send_from_directory(directory, stuff, as_attachment=True)
else:
app.logger.debug(f"X-Accel-Redirect serving {stuff}")
resp = Response("")
resp.headers[
"Content-Disposition"] = f"attachment; filename={stuff}"
resp.headers[
"X-Accel-Redirect"] = f"/_protected/media/{thing}/{stuff}"
resp.headers[
"Content-Type"] = "" # empty it so Nginx will guess it correctly
return resp
def render_tags(tags):
"""
Given a dict like {'tag': 'meta', 'hello': 'world'}
return a html ready tag like
<meta hello="world" />
"""
for tag in tags:
yield "<{tag} {attrs} />".format(
tag=tag.pop("tag"),
attrs=" ".join([
'{}="{}"'.format(a, html.escape(str(v)))
for a, v in sorted(tag.items()) if v
]),
)
@app.errorhandler(404)
def page_not_found(msg):
excluded = ["/api", "/.well-known", "/feeds", "/oauth/authorize"]
if any([request.path.startswith(m) for m in excluded]):
return jsonify({"error": "page not found"}), 404
html = get_spa_html(app.config["REEL2BITS_SPA_HTML"])
head, tail = html.split("</head>", 1)
request_tags = get_request_head_tags(request)
default_tags = get_default_head_tags(request.path)
unique_attributes = ["name", "property"]
final_tags = request_tags
skip = []
for t in final_tags:
for attr in unique_attributes:
if attr in t:
skip.append(t[attr])
for t in default_tags:
existing = False
for attr in unique_attributes:
if t.get(attr) in skip:
existing = True
break
if not existing:
final_tags.append(t)
head += "\n" + "\n".join(render_tags(final_tags)) + "\n</head>"
return head + tail
@app.errorhandler(403)
def err_forbidden(msg):
if request.path.startswith("/api/"):
return jsonify({"error": "access forbidden"}), 403
pcfg = {
"title": gettext("Whoops, something failed."),
"error": 403,
"message": gettext("Access forbidden"),
"e": msg,
}
return render_template("error_page.jinja2", pcfg=pcfg), 403
@app.errorhandler(410)
def err_gone(msg):
if request.path.startswith("/api/"):
return jsonify({"error": "gone"}), 410
pcfg = {
"title": gettext("Whoops, something failed."),
"error": 410,
"message": gettext("Gone"),
"e": msg
}
return render_template("error_page.jinja2", pcfg=pcfg), 410
if not app.debug:
@app.errorhandler(500)
def err_failed(msg):
if request.path.startswith("/api/"):
return jsonify({"error": "server error"}), 500
pcfg = {
"title": gettext("Whoops, something failed."),
"error": 500,
"message": gettext("Something is broken"),
"e": msg,
}
return render_template("error_page.jinja2", pcfg=pcfg), 500
@app.after_request
def set_x_powered_by(response):
response.headers["X-Powered-By"] = "reel2bits"
return response
# Register CLI commands
app.cli.add_command(commands.db_datas)
app.cli.add_command(commands.users)
app.cli.add_command(commands.roles)
app.cli.add_command(commands.tracks)
app.cli.add_command(commands.system)
return app
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.keys import Keys
from selenium.common.exceptions import TimeoutException, StaleElementReferenceException
def WaitforElement(browser, timeout, xpathElement):
try:
WebDriverWait(browser, timeout).until(EC.visibility_of_element_located((By.XPATH, xpathElement)))
except TimeoutException:
print("Timed out waiting for page to load")
browser.quit()
app = Flask(__name__)
Bootstrap(app) # use bootstrap
action_url = "https://play.google.com/store/apps/category/GAME_ACTION?hl=en"
browser = webdriver.Chrome()
browser.get(action_url)
#game categories objects of all game titles and category
all_game_categories = collections.OrderedDict()
title_categoryElements = browser.find_elements_by_xpath('//a[@class="title-link id-track-click"]') # get all the Title buttons
title_categories = [(x.text, x.get_attribute('href')) for x in title_categoryElements]
for title in title_categories:
browser.get(title[1])
def create_app(config_name):
"""Create Flask application
Create Flask application with configuration provided by config_name variable.
Furthermore, this function create database migrations and handle 403,404,500 errors.
Args:
config_name: configuration variable that configure executing mod.
Returns: Flask application.
"""
app = Flask(__name__, instance_relative_config=True)
app.config.from_object(app_config[config_name])
# app.config.from_pyfile('config.py')
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'mysql://root:@127.0.0.1/dep_db_test'
app.config['SECRET_KEY'] = ''
Bootstrap(app)
db.init_app(app)
login_manager.init_app(app)
login_manager.login_message = "You must be logged in to access this page."
login_manager.login_view = "auth.login"
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand, compare_type=True)
from app import models
# Each blueprint object has imported and registered. For the admin blueprint,
# url prefix /admin is added. This means that all the views for this blueprint will be accessed
# in the browser with the url prefix admin.
from app.admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
from .home import home as home_blueprint
app.register_blueprint(home_blueprint)
@app.errorhandler(403)
def forbidden(error):
logger.error('403 Error occurred')
return render_template('errors/403.html', title='Forbidden'), 403
@app.errorhandler(404)
def page_not_found(error):
logger.error('404 Error occurred')
return render_template('errors/404.html', title='Page Not Found'), 404
@app.errorhandler(500)
def internal_server_error(error):
logger.error('500 Error occurred')
return render_template('errors/500.html', title='Server Error'), 500
@app.route('/500')
def error():
abort(500)
return app
from flask import Flask from flask_bootstrap import Bootstrap import os webapp = Flask(__name__) # webapp.secret_key = 'some_secret' webapp.config['UPLOADED_PHOTOS_DEST'] = os.getcwd()+'/uploads' webapp.config['SECRET_KEY'] = 'hard to guess string' Bootstrap(webapp) from app import views from app import forms from app import thumbnails from app import dynamo
reload(sys)
sys.setdefaultencoding('utf-8')
# Application Configuration
template = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'templates')
asset = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'templates/asset')
web = Flask(__name__, template_folder=template, static_folder=asset)
web.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
web.config['SQLALCHEMY_DATABASE_URI'] = config.Config('database',
'mysql').value
# web.config['SQLALCHEMY_ECHO'] = True
web.secret_key = config.Config('cobra', 'secret_key').value
bootstrap = Bootstrap(web)
# set bootstrap css and jquery js to local
web.config['BOOTSTRAP_SERVE_LOCAL'] = True
# upload directory
upload_directory = os.path.join(
config.Config('upload', 'directory').value, 'uploads')
if os.path.isdir(upload_directory) is not True:
os.makedirs(upload_directory)
web.config['UPLOAD_FOLDER'] = upload_directory
web.config['MAX_CONTENT_LENGTH'] = int(
config.Config('upload', 'max_size').value) * 1024 * 1024
db = SQLAlchemy(web)
def create_app(version, run_path):
global app, token_blacklist, socketio
app = Flask(__name__)
app.config["version"] = version
app.config["run_path"] = run_path
config = Configuration()
if config.getWebInterface().lower() == "full":
app.config["WebInterface"] = False
else:
app.config["WebInterface"] = True
app.config["MONGO_DBNAME"] = config.getMongoDB()
app.config["SECRET_KEY"] = str(random.getrandbits(256))
app.config["JWT_SECRET_KEY"] = str(random.getrandbits(256))
app.config["JWT_ACCESS_TOKEN_EXPIRES"] = ACCESS_EXPIRES
app.config["JWT_REFRESH_TOKEN_EXPIRES"] = REFRESH_EXPIRES
app.config["JWT_BLACKLIST_ENABLED"] = True
app.config["JWT_BLACKLIST_TOKEN_CHECKS"] = ["access", "refresh"]
token_blacklist = config.getRedisTokenConnection()
app.config["RESTX_MASK_SWAGGER"] = False
socketio = SocketIO(app)
Breadcrumbs(app=app)
Bootstrap(app)
jwt = JWTManager(app)
@jwt.user_claims_loader
def add_claims_to_access_token(identity):
return {"user": identity}
@jwt.token_in_blacklist_loader
def check_if_token_is_revoked(decrypted_token):
jti = decrypted_token["jti"]
entry = token_blacklist.get(jti)
if entry == "true":
return True
return False
login_manager.init_app(app)
login_manager.login_message = "You must be logged in to access this page!!!"
login_manager.login_view = "auth.login"
@login_manager.user_loader
def load_user(id):
return User.get(id, auth_handler)
from .home import home as home_blueprint
app.register_blueprint(home_blueprint)
from .plugins import plugins as plugins_blueprint
app.register_blueprint(plugins_blueprint, url_prefix="/plugin")
if not app.config["WebInterface"]:
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix="/admin")
from .restapi import blueprint as api
app.register_blueprint(api)
from .restapidocs import docs as docs_blueprint
app.register_blueprint(docs_blueprint)
@app.context_processor
def version():
def get_version():
return app.config["version"]
return dict(get_version=get_version)
@app.context_processor
def db_schema():
def db_schema():
sc = SchemaChecker()
try:
return sc.validate_schema()
except DatabaseSchemaError as err:
return err
return dict(db_schema=db_schema)
@app.context_processor
def WebInterface():
def get_WebInterface():
return app.config["WebInterface"]
return dict(get_WebInterface=get_WebInterface)
@app.context_processor
def JSON2HTMLTable():
# Doublequote, because we have to |safe the content for the tags
def doublequote(data):
return urllib.parse.quote_plus(urllib.parse.quote_plus(data))
def JSON2HTMLTableFilter(data, stack=None):
_return = ""
if type(stack) == str:
stack = [stack]
if type(data) == list:
if len(data) == 1:
_return += JSON2HTMLTableFilter(data[0], stack)
else:
_return += '<ul class="via4">'
for item in data:
_return += "<li>%s</li>" % JSON2HTMLTableFilter(
item, stack)
_return += "</ul>"
elif type(data) == dict:
_return += '<table class="invisiTable">'
for key, val in sorted(data.items()):
_return += "<tr><td><b>%s</b></td><td>%s</td></tr>" % (
key,
JSON2HTMLTableFilter(val, stack + [key]),
)
_return += "</table>"
elif type(data) == str:
if stack:
_return += ("<a href='/link/" +
doublequote(".".join(stack)) + "/" +
doublequote(data) + "'>") # link opening
_return += "<i class='fas fa-link' aria-hidden='true'></i> </a>"
_return += ("<a target='_blank' href='%s'>%s</a>" %
(data, data) if isURL(data) else data)
_return += ""
return _return
return dict(JSON2HTMLTable=JSON2HTMLTableFilter)
@app.template_filter("htmlEncode")
def htmlEncode(string):
return urllib.parse.quote_plus(string).lower()
@app.template_filter("htmlDecode")
def htmlDecode(string):
return urllib.parse.unquote_plus(string)
@app.template_filter("sortIntLikeStr")
def sortIntLikeStr(datalist):
return sorted(datalist, key=lambda k: int(k))
@app.errorhandler(404)
def page_not_found(error):
return (
render_template("404.html", ),
404,
)
return app, socketio
# All imports :
from flask import Flask
from flask_script import Manager
import os.path
from flask_bootstrap import Bootstrap
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
app = Flask(__name__) # create an instance of the Flask class for our web app
app.debug = True # set debug to "True" to print out possible Python errors on the web page
Bootstrap(app) # load Bootstrap to use new templates
manager = Manager(app)
def mkpath(p):
return os.path.normpath(
os.path.join(
os.path.dirname(__file__),
p))
app.config['SQLALCHEMY_DATABASE_URI']=( #config the database which will be used in the app
'sqlite:///'+mkpath('../tuto.db'))
# app.config['SQLALCHEMY_TRACK_MODIFICATIONS']=True
db=SQLAlchemy(app) # get the database from the app and put it in db
app.config['SECRET_KEY']="f80e3c9d-4229-4e14-a302-7b624a52f6eb" # config the SECRET_KEY
login_manager = LoginManager(app) # To start using Flask-Login in our application we need to create
# an instance of LoginManager and initialize it with our application instance
webapp.config['MAIL_USE_SSL'] = True webapp.config['MAIL_USERNAME'] = '******' webapp.config['MAIL_PASSWORD'] = '******' webapp.config['DEFAULT_MAIL_SENDER'] = '*****@*****.**' db.init_app(webapp) login_manager = LoginManager() login_manager.init_app(webapp) bcrypt = Bcrypt() mail = Mail() mail.init_app(webapp) bootstrap = Bootstrap() bootstrap.init_app(webapp) import datetime from dateutil import parser from rq import Queue from rq.job import Job from worker import conn q = Queue(connection=conn) import tasks import collections @login_manager.user_loader
import json
from flask import Flask, render_template
from flask_bootstrap import Bootstrap
import pandas as pd
app = Flask(__name__)
bootstrap = Bootstrap()
bootstrap.init_app(app)
@app.route("/")
def index():
df = pd.read_csv('data.csv').drop('Open', axis=1)
chart_data = df.to_dict(orient='records')
chart_data = json.dumps(chart_data, indent=2)
data = {'chart_data': chart_data}
return render_template("index.html", data=data)
if __name__ == "__main__":
app.run(debug=True)
from flask import Flask
from flask_bootstrap import Bootstrap
from flask_sitemap import Sitemap
from flask_wtf.csrf import CSRFProtect
import os
bootstrap = Bootstrap()
sitemap = Sitemap()
csrf = CSRFProtect()
if os.getenv('SERVER_SOFTWARE', '').startswith('Google App Engine/'):
app = Flask(__name__, root_path='blog',
template_folder= 'templates/production',
instance_relative_config = True)
from flask import Flask
from flask_bootstrap import Bootstrap
from config import Config
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from flask_login import LoginManager
app = Flask(__name__)
app.config.from_object(Config)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
login = LoginManager(app)
login.login_view = 'login'
from app import routes, models
bootstrap = Bootstrap(
app) #Do this to use bootstrap instead of linking with style tag in HTML
