def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
app.dbRedis = FlaskRedis.from_custom_provider(StrictRedis, app)
app.weather = Weather(app.config['OWM_API'], app.config['KEY_BASE'], app.dbRedis)
# register our blueprints
app.register_blueprint(main)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
app.dbRedis = FlaskRedis.from_custom_provider(StrictRedis, app)
app.dbStore = sqlite3.connect(app.config['STORE_DB'])
app.dbStore.row_factory = sqlite3.Row
app.iwn = IndieWebNews(app.config['KEY_BASE'])
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(api)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
app.dbRedis = FlaskRedis.from_custom_provider(StrictRedis, app)
app.weather = Weather(app.config['OWM_API'], app.config['KEY_BASE'], app.dbRedis)
# register our blueprints
app.register_blueprint(main)
return app
def app():
mock_redis = FlaskRedis.from_custom_provider(FakeStrictRedis)
flask_app = capp.create_app(True, mock_redis)
database.config_engine('sqlite://', echo=True)
database.init_db()
connection = database.engine.connect()
yield flask_app
connection.close()
database.Base.metadata.drop_all(bind=database.engine)
def get_redis():
"""Opens a new database connection if there is none yet."""
if not hasattr(g, 'redis'):
if app.testing:
rs = FlaskRedis.from_custom_provider(app.config['REDIS_PROVIDER'])
else:
rs = FlaskRedis()
rs.init_app(app)
g.redis = rs
return g.redis
def get_redis():
"""Opens a new database connection if there is none yet."""
if not hasattr(g, 'redis'):
if app.testing:
rs = FlaskRedis.from_custom_provider(app.config['REDIS_PROVIDER'])
else:
rs = FlaskRedis()
rs.init_app(app)
g.redis = rs
return g.redis
def create_app(testing=False):
app = Flask(__name__)
if testing:
app.config['TESTING'] = True
# Redis config
redis_url = environ.get('REDIS_URL')
if redis_url:
app.config.setdefault('REDIS_URL', redis_url)
# Mock redis
if app.testing:
redis = FlaskRedis.from_custom_provider(MockRedisWrapper)
else:
redis = FlaskRedis.from_custom_provider(OptionalRedis)
opbeat.init_app(app)
redis.init_app(app)
app.register_blueprint(views)
views.redis = redis
return app, redis
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
if os.environ.get('KAKU_SETTINGS', None) is not None:
app.config.from_envvar('KAKU_SETTINGS')
if not app.debug:
handler = logging.handlers.RotatingFileHandler(app.config['LOG_FILE'], maxBytes=100000000, backupCount=9)
formatter = logging.Formatter('%(asctime)s %(levelname)s %(pathname)s:%(lineno)d -- %(message)s')
handler.setFormatter(formatter)
handler.setLevel(logging.DEBUG)
app.logger.addHandler(handler)
app.logger.setLevel(logging.DEBUG)
wzlog = logging.getLogger('werkzeug')
wzlog.setLevel(logging.DEBUG)
wzlog.addHandler(handler)
if app.config['SITE_TEMPLATES'] is not None:
app.jinja_loader = jinja2.FileSystemLoader(app.config['SITE_TEMPLATES'])
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
app.dbRedis = FlaskRedis.from_custom_provider(StrictRedis, app)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(auth)
app.logger.info('Flask app [%s] created' % __name__)
return app
# coding=utf-8
from flask import Flask
from flask.ext.redis import FlaskRedis
from redis import StrictRedis
from wechat_sdk import WechatConf
app = Flask(__name__)
app.config.from_envvar('MY_WECHAT_APP_SETTINGS')
redis_store = FlaskRedis.from_custom_provider(StrictRedis, app)
wechat_conf = WechatConf(
token=app.config['WX_TOKEN'],
appid=app.config['WX_APP_ID'],
appsecret=app.config['WX_APP_SECRET'],
encrypt_mode=app.config['WX_ENCRYPT_MODE'],
encoding_aes_key=app.config['WX_ENCODING_AES_KEY']
)
#coding: utf-8
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.pool import QueuePool as BaseQueuePool
db = SQLAlchemy(session_options={"autoflush":False})
from .utils.redis_geo import GeoRedis
from flask.ext.redis import FlaskRedis
redis_store = FlaskRedis.from_custom_provider(GeoRedis)
from flask.ext.celery import Celery
celery = Celery()
from dogpile.cache import make_region
regions = {
'taxis': make_region('taxis'),
'hails': make_region('hails'),
'zupc': make_region('zupc').configure('dogpile.cache.memory'),
'users': make_region('users')
}
from flask.ext.uploads import (UploadSet, configure_uploads,
DOCUMENTS, DATA, ARCHIVES, IMAGES)
documents = UploadSet('documents', DOCUMENTS + DATA + ARCHIVES)
images = UploadSet('images', IMAGES)
from .index_zupc import IndexZUPC
index_zupc = IndexZUPC()
from .utils.cache_user_datastore import CacheUserDatastore
from .models import security
'''
Created on Mar 28, 2016
@author: wuw7
'''
#!/usr/bin/env python
import datetime
import flask
from flask.ext.redis import FlaskRedis
import redis
app = flask.Flask(__name__)
app.secret_key = 'asdf'
app.config.from_object('config')
red = FlaskRedis.from_custom_provider(redis.StrictRedis, app)
#red = redis.StrictRedis()
def event_stream():
pubsub = red.pubsub()
pubsub.subscribe('chat')
# TODO: handle client disconnection.
for message in pubsub.listen():
print message
yield 'data: %s\n\n' % message['data']
@app.route('/login', methods=['GET', 'POST'])
def login():
if flask.request.method == 'POST':
flask.session['user'] = flask.request.form['user']
# coding: utf-8
from redis import StrictRedis
from flask.ext.redis import FlaskRedis
from flask.ext.sqlalchemy import SQLAlchemy
class DecodedRedis(StrictRedis):
@classmethod
def from_url(cls, url, db=None, **kwargs):
kwargs['decode_responses'] = True
return StrictRedis.from_url(url, db, **kwargs)
rds = FlaskRedis.from_custom_provider(DecodedRedis)
db = SQLAlchemy()
app = Flask(__name__)
app.config.from_object(ProductionConfig)
mako = MakoTemplates(app)
db = SQLAlchemy(app)
bcrypt = Bcrypt(app)
# redis编码设置
class DecodedRedis(StrictRedis):
@classmethod
def from_url(cls, url, db=None, **kwargs):
kwargs['decode_responses'] = True
return StrictRedis.from_url(url, db, **kwargs)
redis_store = FlaskRedis.from_custom_provider(DecodedRedis, app)
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key = True, autoincrement = True)
username = db.Column(db.String(128), unique = True)
password_hashed = db.Column(db.String(256))
def __init__(self, username, password):
self.username = username
self.password_hashed = bcrypt.generate_password_hash(password)
def __repr__(self):
return "<User %r>" % (self.username)
utils.setup_logging()
app.config.update(utils.handle_env())
def get_docker_client():
try:
# We will attempt to get the cluster info from environment variables
kwargs = kwargs_from_env()
logging.debug("getting kwargs")
kwargs['tls'].assert_hostname = False
client = Client(**kwargs)
logging.debug(client.version())
return client
except Exception:
# If for some reason we can not connect, kill the server.
traceback.print_exc()
traceback.print_stack()
logging.critical("Unable to connect to cluster. Exiting")
exit(errno.ECONNABORTED)
app = Flask(__name__)
config()
api = Api(app)
# Pointing to our docker machine right now.
docker_client = get_docker_client()
# Using Cloudant to store our game-server data
# cloudant_client = cloudant_connect()
redis_client = FlaskRedis.from_custom_provider(DecodedRedis, app)
logging.debug("Initialized objects...")
app = Flask(__name__)
app.config.from_object(ProductionConfig)
mako = MakoTemplates(app)
db = SQLAlchemy(app)
bcrypt = Bcrypt(app)
# redis编码设置
class DecodedRedis(StrictRedis):
@classmethod
def from_url(cls, url, db=None, **kwargs):
kwargs['decode_responses'] = True
return StrictRedis.from_url(url, db, **kwargs)
redis_store = FlaskRedis.from_custom_provider(DecodedRedis, app)
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True)
password_hashed = db.Column(db.String(256))
def __init__(self, username, password):
self.username = username
self.password_hashed = bcrypt.generate_password_hash(password)
def __repr__(self):
return "<User %r>" % (self.username)
