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 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 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)