def create_app(config):
"""
:param config: a string specifying the configuration environment
:return: a Flask instance properly configured
"""
app.config["SQLALCHEMY_DATABASE_URI"] = keys.db_uri
app.config["DEBUG"] = True
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
app.secret_key = 'dogfood'
bootstrap = Bootstrap()
db.init_app(app)
my_bcrypt.init_app(app)
bootstrap.init_app(app)
moment.init_app(app)
login_manager.session_protection = 'strong'
login_manager.login_view = 'main.login'
login_manager.init_app(app)
from views import main
app.register_blueprint(main)
from api import api
app.register_blueprint(api)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
cake = Cake(app)
bootstrap = Bootstrap()
bootstrap.init_app(app)
from .bankworld import app as app_blueprint
app.register_blueprint(app_blueprint)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
cake = Cake(app)
bootstrap = Bootstrap()
bootstrap.init_app(app)
from .lastfm import app as app_blueprint
app.register_blueprint(app_blueprint)
from .mongo import mongo as mongo_blueprint
app.register_blueprint(mongo_blueprint, url_prefix='/mongo')
from .mongo.artists import artists as mongo_artists_blueprint
app.register_blueprint(mongo_artists_blueprint, url_prefix = '/mongo/artists')
from .mongo.auth import auth as mongo_auth_blueprint
app.register_blueprint(mongo_auth_blueprint, url_prefix='/mongo/auth')
from .mongo.users import users as mongo_users_blueprint
app.register_blueprint(mongo_users_blueprint, url_prefix='/mongo/users')
from .neo4j import neo4j as neo4j_blueprint
app.register_blueprint(neo4j_blueprint, url_prefix='/neo4j')
from .neo4j.artists import artists as neo4j_artists_blueprint
app.register_blueprint(neo4j_artists_blueprint, url_prefix = '/neo4j/artists')
from .neo4j.auth import auth as neo4j_auth_blueprint
app.register_blueprint(neo4j_auth_blueprint, url_prefix='/neo4j/auth')
from .neo4j.users import users as neo4j_users_blueprint
app.register_blueprint(neo4j_users_blueprint, url_prefix='/neo4j/users')
from .neomongo import neomongo as neomongo_blueprint
app.register_blueprint(neomongo_blueprint, url_prefix='/neomongo')
from .neomongo.artists import artists as neomongo_artists_blueprint
app.register_blueprint(neomongo_artists_blueprint, url_prefix = '/neomongo/artists')
from .neomongo.auth import auth as neomongo_auth_blueprint
app.register_blueprint(neomongo_auth_blueprint, url_prefix='/neomongo/auth')
from .neomongo.users import users as neomongo_users_blueprint
app.register_blueprint(neomongo_users_blueprint, url_prefix='/neomongo/users')
return app
def create_app():
app = Flask(__name__)
from . import config
app.config.from_object(config)
from .libs.serialization import CustomJSONEncoder
app.json_encoder = CustomJSONEncoder
bootstrap = Bootstrap()
bootstrap.init_app(app)
store.init_app(app)
store.app = app
store.session.expire_on_commit = False
admin = Admin(app)
from app.models.user import User # NOQA
from app.models.flower import Flower # NOQA
from app.models.song import Song # NOQA
from app.models.task import Task # NOQA
from app.models.message import Message # NOQA
from app.models.registration import Registration # NOQA
from app.models.statistics import Statistics # NOQA
admin.add_view(ModelView(User, store.session))
admin.add_view(ModelView(Flower, store.session))
admin.add_view(ModelView(Song, store.session))
admin.add_view(ModelView(Message, store.session))
admin.add_view(ModelView(Task, store.session))
admin.add_view(ModelView(Registration, store.session))
admin.add_view(ModelView(Statistics, store.session))
@event.listens_for(store.engine, "connect")
def change_text_factory(connection, connection_record):
connection.text_factory = str
from .api import api as api_blueprint
app.register_blueprint(api_blueprint, url_prefix="/api")
return app
def create_app(config_name):
"""
An "application factory" used to initialise the app object. Configs and
extensions are loaded here.
See Flask docs for additional information:
http://flask.pocoo.org/docs/0.10/patterns/appfactories/
Parameters
----------
config_name : str
The configuration to run. Currently should be one of "development"
or "default".
Returns
-------
app : flask.app.Flask
Flask application object.
"""
app = Flask(__name__, static_url_path="/static")
app.config.from_object(config[config_name])
bootstrap = Bootstrap()
compress = Compress()
bootstrap.init_app(app)
compress.init_app(app)
mongo.init_app(app)
from app.main import main as main_blueprint
app.register_blueprint(main_blueprint)
from app.dbapi import dbapi as dbapi_blueprint
app.register_blueprint(dbapi_blueprint, url_prefix="/api")
return app
# -*- encoding: utf-8 -*-
"""
Python Aplication Template
Licence: GPLv3
"""
from flask import Flask
from flask.ext.bootstrap import Bootstrap
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.pymongo import PyMongo
from flask.ext.login import LoginManager
app = Flask(__name__)
#Configuration of application, see configuration.py, choose one and uncomment.
#app.config.from_object('configuration.ProductionConfig')
app.config.from_object('app.configuration.DevelopmentConfig')
#app.config.from_object('configuration.TestingConfig')
bs = Bootstrap(app) #flask-bootstrap
db = SQLAlchemy(app) #flask-sqlalchemy
lm = LoginManager()
#lm.setup_app(app)
#lm.session_protection = 'strong'
lm.login_view = 'login'
lm.login_message = 'please login'
lm.init_app(app)
from app import views, models
from flask.ext.moment import Moment
from flask.ext.mail import Mail
from flask.ext.pagedown import PageDown
login_manager = LoginManager()
login_manager.session_protection = 'basic'
login_manager.login_view = 'auth.login'
login_manager.login_message = u'请先登录'
db = SQLAlchemy()
mail = Mail()
pagedown = PageDown()
moment = Moment()
if __name__ == '__main__':
bootstrap = Bootstrap()
app = Flask(__name__)
app.config['SECRET_KEY'] = 'hard to guess string'
app.config['SQLALCHEMY_DATABASE_URI'] =\
'mysql://*****:*****@172.16.34.7:3306/test'
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app.config['MAIL_SERVER'] = 'smtp.qiye.163.com'
app.config['MAIL_PORT'] = 25
app.config['MAIL_USE_TLS'] = False
app.config['MAIL_USERNAME'] = '******'
app.config['MAIL_PASSWORD'] = '******'
app.config['FLASKY_MAIL_SUBJECT_PREFIX'] = '[Flasky]'
app.config['FLASKY_MAIL_SENDER'] = 'Flasky Admin <*****@*****.**>'
app.config['FLASKY_ADMIN'] = '*****@*****.**'
#!/usr/bin/python
# -*- coding:utf-8 -*-
################################################################
# 服务器程序
################################################################
import json
import time
import sys
from flask import Flask, abort, render_template, redirect, send_from_directory, request, make_response
from flask.ext.bootstrap import Bootstrap
sys.path.append('..')
from tools.conf.website_conf import website_list, website_link
from tools.general_tools import get_top_n_website_scores
server = Flask(__name__)
bootstrap = Bootstrap(server)
def generate_result(scores):
result_list = []
for score in scores:
result = {}
result['website'] = score[0]
result['score'] = '%.3f' % (score[1] * 100)
result['link'] = website_link[score[0]][0]
result['type'] = website_link[score[0]][1]
result_list.append(result)
return result_list # sorted(result_list, key=lambda x: x['score'], reverse=True)
@server.route('/')
#!/usr/bin/env python
from flask import Flask, redirect, url_for
from flask.ext.bootstrap import Bootstrap
from datetime import datetime
from delorean import Delorean, parse
main = Flask(__name__)
main.config.from_pyfile('../misc/app.cfg')
# load flask-bootstrap middleware
Bootstrap(main)
main.config['BOOTSTRAP_USE_MINIFIED'] = True
main.config['BOOTSTRAP_USE_CDN'] = True
main.config['BOOTSTRAP_FONTAWESOME'] = True
import admin
admin.register_to(main)
from app.models.base import Session
from app.models.auction_item import AuctionItem
def format_currency(value):
return "${:,.2f}".format(value)
def format_date(date):
return date.strftime("%a %B %d, %I:%M %p")
from flask.ext.login import LoginManager from flask.ext.bootstrap import Bootstrap import os #create flask yoke = Flask(__name__) yoke.config['DEBUG'] = True yoke.config['SECRET_KEY'] = 'default' yoke.config['CSRF_ENABLED'] = True yoke.config['CSRF_SESSION_KEY'] = 'csrf_secret' #bootstrap init bootstrap = Bootstrap() bootstrap.init_app(yoke) #init database with yoke db = SQLAlchemy() db.init_app(yoke) db.app = yoke yoke.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(os.getcwd(), 'data.sqlite') yoke.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True yoke.config['SQLALCHEMY_RECORD_QUERIES'] = True #init login_manager with yoke login_manager = LoginManager() login_manager.session_protection = 'basic' login_manager.login_view = 'auth.login'
def create_app(test_config=None): # For automated tests
# Setup Flask and read config from ConfigClass defined above
app = Flask(__name__)
app.config.from_object(__name__ + '.ConfigClass')
# Load local_settings.py if file exists # For automated tests
try:
app.config.from_object('local_settings')
except:
pass
# Over-write app config # For automated tests
if test_config:
for key, value in test_config.items():
app.config[key] = value
# Setup Flask-Mail, Flask-Babel and Flask-SQLAlchemy
app.mail = Mail(app)
app.babel = babel = Babel(app)
app.db = db = SQLAlchemy(app)
@babel.localeselector
def get_locale():
translations = [str(translation)
for translation in babel.list_translations()]
return request.accept_languages.best_match(translations)
# Define User model. Make sure to add flask.ext.user UserMixin!!
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
active = db.Column(db.Boolean(), nullable=False, default=False)
email = db.Column(db.String(255), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, default='')
username = db.Column(db.String(50), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
reset_password_token = db.Column(
db.String(100), nullable=False, default='')
tweets = db.relationship('Tweet', backref='user', lazy='dynamic')
app.User = User
class Tweet(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(144), nullable=False, default='')
tweeted_at = db.Column(db.DateTime())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
# Create all database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User) # Select database adapter
# Init Flask-User and bind to app
user_manager = UserManager(db_adapter, app)
# Setup forms
class TweetForm(Form):
text = StringField('Message', validators=[Required()])
submit = SubmitField('Submit')
# The '/' page is accessible to anyone
@app.route('/')
def home_page():
if current_user.is_authenticated():
return profile_page()
return render_template("index.html")
# The '/profile' page requires a logged-in user
@app.route('/profile')
# Use of @login_required decorator
@login_required
def profile_page():
return render_template("profile.html")
@app.route('/tweet/new', methods=['GET', 'POST'])
@login_required
def new_tweet():
form = TweetForm()
if form.validate_on_submit():
tweet = Tweet()
form.populate_obj(tweet)
tweet.tweeted_at = datetime.now()
tweet.user = current_user
db.session.add(tweet)
db.session.commit()
flash("Your message is tweeted.")
return redirect(url_for("list_tweet"))
return render_template("new_tweet.html", form=form)
@app.route('/tweet/list')
@login_required
def list_tweet():
tweets = Tweet.query.order_by(Tweet.tweeted_at).limit(50)
print(tweets[0].user.username)
return render_template("list_tweet.html", tweets=tweets)
bootstrap = Bootstrap(app)
return app
import os
from flask import Flask
from flask.ext.bootstrap import Bootstrap
from flask_peewee.db import Database
app = Flask(__name__)
app.config.from_object(os.environ.get('BADBATCH_SETTINGS'))
Bootstrap(app)
db = Database(app)
# Register views
from views import RegisterView, IndexPageView, AlertsView, ContactView, CallView
IndexPageView.register(app, route_base="/")
RegisterView.register(app, route_base="/register")
AlertsView.register(app, route_base="/alerts")
ContactView.register(app, route_base="/contact")
CallView.register(app, route_base="/voice")
from wtforms import StringField, SubmitField
from wtforms.validators import Required
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.migrate import Migrate, MigrateCommand
from flask.ext.mail import Mail, Message
basedir = os.path.abspath(os.path.dirname(__file__))
app = Flask(__name__)
app.config['SECRET_KEY'] = 'hard to guess string'
app.config['SQLALCHEMY_DATABASE_URI'] =\
'sqlite:///' + os.path.join(basedir, 'data.sqlite')
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
manager = Manager(app)
bootstrap = Bootstrap(app)
moment = Moment(app)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
users = db.relationship('User', backref='role', lazy='dynamic')
def __repr__(self):
return '<Role %r>' % self.name
from flask import Flask, render_template, flash
from flask.ext.bootstrap import Bootstrap
from flask.ext.wtf import Form
from wtforms import StringField, SubmitField
from wtforms.validators import Required
kevin = Flask(__name__)
kevin.config[
'SECRET_KEY'] = '128JSD*idfedf8ued89f7JHEDFjtw1143589123849iU*(UDF*D*F()D*F)(D*fjsdjfkj238490sdjfkjJDJFi(*)(&^&^*%tYYGHGhjBBb*H*hffJghgdfhkjk3eio2u3oiuqwoieuoiqyopolavofuiekghogsjdb*&&&DFOD&*F*(D&F*(DIOFUIKFHJDJHCKJVHJKCVkchvuhyiudyf8s9df98789743124789238UIOuFKAHDFKJAHDKLASHjkdgasgdhhasdgkjashdU(*&(*&*(*^^ASd876a7s6d87&&$^%$^#<F2>3234$#@121432!$25434%79^)*X&D(97_(A*Sd09POJZXd'
Bootstrap(kevin)
class NameForm(Form):
email = StringField('Email Address', validators=[Required()])
password = StringField('Password', validators=[Required()])
submit = SubmitField('Submit')
@kevin.route('/')
def index():
return render_template('index.html')
@kevin.route('/signin', methods=['GET', 'POST'])
def signin():
email = None
password = None
form = NameForm()
if form.validate_on_submit():
email = form.email.data
password = form.password.data
from flask.ext.bootstrap import Bootstrap
from flask.ext.login import LoginManager
from flask.ext.mail import Mail
from flask.ext.migrate import Migrate
from flask.ext.moment import Moment
from flask.ext.uploads import UploadSet, IMAGES, configure_uploads
from flask_sqlalchemy import SQLAlchemy
# 各种扩展对象
db = SQLAlchemy()
migrate = Migrate(db=db)
bs = Bootstrap()
# 发邮件扩展
mail = Mail()
# 配置LoginManager的配置
lm = LoginManager()
lm.login_view = 'userbp.login'
lm.login_message = 'login required!'
lm.session_protection = 'strong'
# 上传扩展扩展对象，允许的格式为图片
photos = UploadSet('photos', IMAGES)
moment = Moment()
# 为各种扩展绑定app
# 使用的是事后绑定——因为app诞生的很晚，但各种扩展被依赖的很早
def init_extentions(app):
@app.route('/submitted')
def submitted():
return render_template('main_page.html')
@app.route('/signup')
def signup():
images = [0]
return render_template('main_page.html')
@app.route('/login')
def login():
images = [1]
return render_template('main_page.html')
@app.route('/profile')
def profile():
images = [2]
return render_template('main_page.html')
if __name__ == '__main__':
Bootstrap(app) # initialise bootstrap for app
app.debug = True
port = int(os.getenv('PORT', 8080))
host = os.getenv('IP', '0.0.0.0')
app.run(port=port, host=host)
def main():
app = Eve(settings=ApiSettings(), redis=Caching())
Bootstrap(app)
app.register_blueprint(eve_docs, url_prefix='/docs')
'SECRET_KEY'] = 'hard to guess string' # app.config作为字典存储框架、扩展和程序本身的配置变量,标准字典形式
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(
basedir, 'data.sqlite') # 指定数据库URI
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app.config['MAIL_SERVER'] = 'smtp.qq.com'
app.config['MAIL_PORT'] = 587 # 465
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = os.environ.get('MAIL_USERNAME')
app.config['MAIL_PASSWORD'] = os.environ.get('MAIL_PASSWORD')
app.config['FLASKY_MAIL_SUBJECT_PREFIX'] = '[Flasky]'
app.config['FLASKY_MAIL_SENDER'] = 'Flasky Admin <' + app.config[
'MAIL_USERNAME'] + '>'
app.config['FLASKY_ADMIN'] = os.environ.get('FLASKY_ADMIN')
manager = Manager(app) # 命令行解析功能
bootstrap = Bootstrap(app) # 集成Bootstrap框架
moment = Moment(app) # 渲染日期和时间
db = SQLAlchemy(app) # 创建数据库
mail = Mail(app) # 初始化Flask-Mail
migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)
class NameForm(Form):
name = StringField('What is your name?', validators=[Required()])
submit = SubmitField('Submit')
class Role(db.Model):
__tablename__ = 'roles'
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True #设置这一项是每次请求结束后都会自动提交数据库中的变动
#################################user 相关
app.config['SECRET_KEY'] = 'f**k money' # 必须 用于加密
login_manager = LoginManager()
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
##################################下面都是处理数据库的##############################################################################
##################################下面都是处理数据库的##############################################################################
db = SQLAlchemy(app) #实例化
bootstrap = Bootstrap(
app
) #https://www.jianshu.com/p/102afa96bc4b bootstrap的使用 {% extends "bootstrap/base.html" %}会自动引用，不需要copy过来这个模板
class Tupian(db.Model): #这里的类名和下面的tablename随便取
__tablename__ = 'tupian'
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
autoincrement=True)
name = db.Column(db.String(255),
nullable=False,
unique=True,
server_default='',
index=True)
label = db.Column(db.String(255), nullable=False, server_default='')
def make_app(env="dev"):
"""
This is still needlessly complicated.
Returns a Flask WSGI instance.
"""
debug = env == "dev"
url_root = dict(
dev="/",
build="/dist/",
test="/dist/",
prod="/"
)[env]
app_home = os.path.dirname(__file__)
cfg = dict(
dev=dict(
static_url_path="/static",
template_folder="./templates",
static_folder=opa(opj(app_home, "static"))
),
build=dict(
static_url_path="/",
template_folder="./templates",
static_folder=opa(opj(app_home, "static"))
),
test=dict(
static_url_path="/dist",
template_folder="../dist",
static_folder=opa(opj(app_home, "..", "dist"))
),
prod=dict(
static_url_path="/static",
template_folder="./templates",
static_folder=opa(opj(app_home, "static"))
)
)[env]
app = Flask(__name__, **cfg)
app.config.update(dict(
CSRF_ENABLED=debug,
SECRET_KEY=os.environ.get("FLASK_SECRET_KEY", "totally-insecure"),
DEBUG=debug,
ASSETS_DEBUG=debug,
BOOTSTRAP_JQUERY_VERSION=None
))
Bootstrap(app)
def font_stuff(url):
"""
Some font URL rewriting
"""
repl = "./lib/awesome/font/"
if env == "build":
repl = "./font/"
return url.replace("../font/", repl)
fix_font_css = CSSRewrite(replace=font_stuff)
assets = Environment(app)
bundles = YAMLLoader(os.path.join(app_home, 'assets.yaml')).load_bundles()
for to_fix in ["prod", "build"]:
bundles["css-%s" % to_fix].filters.insert(0, fix_font_css)
for name, bundle in bundles.iteritems():
assets.register(name, bundle)
@app.route(url_root)
def index():
kwargs = {
"gh_client_id": os.environ.get("GITHUB_CLIENT_ID",
"deadbeef")
}
return render_template("index.html", env=env, **kwargs)
@app.route("/login")
def login(code=None):
return render_template("login.html")
@app.route("/oauth")
def oauth():
oauth_args = dict(
code=request.args.get("code", ""),
state=request.args.get("state", ""),
client_id=os.environ["GITHUB_CLIENT_ID"],
client_secret=os.environ["GITHUB_CLIENT_SECRET"]
)
req = requests.post(
"https://github.com/login/oauth/access_token",
data=oauth_args
)
query = urlparse.parse_qs(req.content)
return query["access_token"][0]
return app
from flask import Flask
from flask.ext.login import LoginManager
from playhouse.flask_utils import FlaskDB
from flask.ext.bootstrap import Bootstrap
application = Flask(__name__)
application.config.from_object('config')
bootstrap = Bootstrap(application)
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
flask_db = FlaskDB(application)
database = flask_db.database
def register_blueprints(app):
# Prevents circular imports
from views import posts
from admin import admin
from auth import auth
from profile import profile
app.register_blueprint(posts)
app.register_blueprint(admin)
app.register_blueprint(auth)
app.register_blueprint(profile)
login_manager.init_app(app)
register_blueprints(application)
from flask import request, Flask, render_template, session, redirect, url_for, flash
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.options import define, options
from tornado.ioloop import IOLoop
from flask.ext.bootstrap import Bootstrap
# from flask.ext.moment import Moment
import datetime
from flask.ext.wtf import FlaskForm
from wtforms import StringField, SubmitField
from wtforms.validators import Required
import os
app = Flask(__name__)
app.config['SECRET_KEY'] = 'hard to guess string'
bootstrap = Bootstrap(app) # 用bootstrap初始化app
# moment = Moment(app) # 用Moment初始化app 获取本地时间
class NameForm(FlaskForm):
name = StringField("what is your name!", validators=[Required()])
submit = SubmitField("Submit")
@app.errorhandler(404)
def page_not_found():
return render_template("404.html"), 404
@app.errorhandler(500)
def internal_server_error(e):
'schema': {
'type': 'float'
}
}
}
self._validate_schema(schema, field, value, None)
if not -180.0 <= value['coordinates'][0] <= 180.0:
self._error(field, "Longitude must be in the range -180.0, 180.0")
if not -90.0 <= value['coordinates'][1] <= 90.0:
self._error(field, "Latitude must be in the range -90.0, 90.0")
settingsfile = path.join(path.abspath(path.dirname(__file__)), 'settings.py')
api = Eve(API_NAME, validator=KeySchemaValidator, settings=settingsfile)
Bootstrap(api)
Compress(api)
api.register_blueprint(eve_docs, url_prefix='/docs')
resource_url = lambda resource: '/' + api.config['URL_PREFIX'] + '/' + resource
def get_schema(resource):
"Get the schema for a given resource."
return api.config['DOMAIN'][resource]['schema']
def add_document(resource, document):
"Add a new document to the given resource."
with api.test_request_context(resource_url(resource)):
return post_internal(resource, payl=document, skip_validation=True)
### If not, will HTML comments work for non-displayed codes?
app = Flask(__name__) # create Flask WSGI application
app.config['SECRET_KEY'] = environ.get('SECRET_KEY')
# mail configuration settings
app.config['MAIL_SERVER'] = 'smtp.googlemail.com'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = environ.get('MAIL_USERNAME')
app.config['MAIL_PASSWORD'] = environ.get('MAIL_PASSWORD')
app.config['AROWF_MAIL_SUBJECT_PREFIX'] = '[AROWF]'
app.config['AROWF_MAIL_SENDER'] = 'AROWF Admin'
app.config['AROWF_ADMIN'] = environ.get('AROWF_ADMIN')
bootstrap = Bootstrap(app) # create Bootstrap instance
mail = Mail(app) # create Mail instances
def send_async_email(app, msg):
with app.app_context():
mail.send(msg)
def send_email(to, subject, template, **kwargs):
msg = Message(app.config['AROWF_MAIL_SUBJECT_PREFIX'] + ' ' + subject,
sender=app.config['AROWF_ADMIN'],
recipients=[to])
msg.body = render_template(template + '.txt', **kwargs)
msg.html = render_template(template + '.html', **kwargs)
thr = Thread(target=send_async_email, args=[app, msg])
from flask import Flask
from flask.ext.bootstrap import Bootstrap
from flask.ext.mail import Mail
from flask.ext.moment import Moment
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager
from flask_oauthlib.client import OAuth
from config import config, GITHUB_SETTINGS
bootstrap = Bootstrap()
mail = Mail()
moment = Moment()
db = SQLAlchemy()
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
oauth = OAuth()
github = oauth.remote_app('github', **GITHUB_SETTINGS)
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
oauth.init_app(app)
from app import app
from flask import render_template, request, session, redirect, url_for, flash
from flask.ext.bootstrap import Bootstrap
from flask.ext.moment import Moment
from datetime import datetime
from app.form import NameForm
Bootstrap(app) ## use bootstrap to fly :)
Moment(app) ## use moment.js to handle user time
@app.route('/', methods=["GET", "POST"])
def index():
return render_template('index.html',
current_time=datetime.utcnow(),
name=session.get("name"))
@app.route('/login', methods=["GET", "POST"])
def login():
form = NameForm()
if request.method == "POST" and form.validate_on_submit():
old_name = session.get("name")
if old_name is not None and old_name != form.name.data:
flash("your name is successfully changed")
session["name"] = form.name.data
return redirect(url_for("index"))
return render_template("signup.html", form=form)
@app.route('/user/<name>')
from flask import Flask from flask.ext.bootstrap import Bootstrap BOOTSTRAP = Bootstrap() APP = Flask(__name__) BOOTSTRAP.init_app(APP) import wintermute.views
# /usr/bin/python
#coding:utf-8
__author__ = 'eyu Fanne'
import os
from flask import Flask
from flask.ext.bootstrap import Bootstrap
from flask.ext.sqlalchemy import SQLAlchemy
from config import config
from flask.ext.pagedown import PageDown
from flask.ext.login import LoginManager
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
bootsrtap = Bootstrap()
db = SQLAlchemy()
pagedown = PageDown()
def creat_app(config_name):
app = Flask(__name__)
bootsrtap.init_app(app)
db.init_app(app)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
pagedown.init_app(app)
login_manager.init_app(app)
from blog import blog as blog_blueprint
from flask import Flask from flask.ext.bootstrap import Bootstrap from flask.ext.mail import Mail from flask.ext.moment import Moment from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.login import LoginManager from flask.ext.pagedown import PageDown from config import config bootstrap = Bootstrap() mail = Mail() moment = Moment() db = SQLAlchemy() pagedown = PageDown() login_manager = LoginManager() login_manager.session_protection = 'strong' login_manager.login_view = 'auth.login' app = Flask(__name__) app.config.from_object(config['development']) config['development'].init_app(app) bootstrap = Bootstrap() mail = Mail() moment = Moment() db = SQLAlchemy() login_manager = LoginManager() login_manager.session_protection = 'strong' login_manager.login_view = 'auth.login'
'name': 'data/database.db',
'engine': 'peewee.SqliteDatabase',
}
DEBUG = True
SECRET_KEY = 'ssshhhh'
CSRF_ENABLED = False
APP_DIR = 'app'
BOOTSTRAP_JQUERY_VERSION = None
SOURCES = []
DESTINATIONS = []
""" Load Basic config """
webackup = Flask('modules',
static_folder="static",
template_folder='templates')
webackup.config.from_object(__name__)
Bootstrap(webackup)
# instantiate the db wrapper
db = Database(webackup)
# instatiate the login
login_manager = LoginManager()
login_manager.setup_app(webackup)
# initiate scheduler
sched = Scheduler()
sched.add_jobstore(ShelveJobStore('data/scheduler.db'), 'default')
sched.start()
""" Registering the blueprint controller """
dirs = os.listdir(APP_DIR)
for module in dirs:
