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