def test_init_app(app):
'''Test that a constructor without app instance will not initialize the
connection.
After FlaskRedis.init_app(app) is called, the connection will be
initialized.'''
redis = FlaskRedis()
assert redis._redis_client is None
redis.init_app(app)
assert redis._redis_client is not None
assert hasattr(redis._redis_client, 'connection_pool')
def test_init_app(app):
"""Test that a constructor without app instance will not initialize the
connection.
After FlaskRedis.init_app(app) is called, the connection will be
initialized."""
redis = FlaskRedis()
assert redis._redis_client is None
redis.init_app(app)
assert redis._redis_client is not None
assert hasattr(redis._redis_client, 'connection_pool')
if hasattr(app, 'extensions'):
assert 'redis' in app.extensions
assert app.extensions['redis'] == redis
class Alert(object):
def __init__(self, user, app):
self.user = user
self.redis_store = FlaskRedis(app)
def get(self):
try:
alerts = self.redis_store.lrange(self.user.userhash(), 0, -1)
except Exception as e:
alerts = ['Alert: Could not retreive alert for user']
print("Problem retreiving alerts {error}").format(error=e)
return alerts
def set(self, channel, message):
try:
self.redis_store.lpush(channel, message)
except Exception as e:
print("Problem setting alerts {error}").format(error=e)
def test_custom_provider(app):
'''Test that FlaskRedis can be instructed to use a different Redis client,
like StrictRedis'''
class FakeProvider(object):
@classmethod
def from_url(cls, *args, **kwargs):
return cls()
redis = FlaskRedis.from_custom_provider(FakeProvider)
assert redis._redis_client is None
redis.init_app(app)
assert redis._redis_client is not None
assert isinstance(redis._redis_client, FakeProvider)
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
# -*- mode: Python; tab-width: 4; indent-tabs-mode: nil; -*-
# ex: set tabstop=4 :
# Please do not change the lines above. See PEP 8, PEP 263.
import os
from flask import Flask
from flask import request
from flask_redis import FlaskRedis
from phone_rule_engine import RuleOperations
app = Flask(__name__)
app.config["REDIS_URL"] = os.environ.get("REDIS_URL",
"redis://localhost:6379/0")
rules_op = RuleOperations(FlaskRedis(app))
@app.before_request
def check_if_can_call():
if not request.view_args:
return
phone_number = request.view_args.get("phone_number")
if not phone_number:
return
is_trial = request.args.get('is_trial')
org_id = request.args.get('org_id')
rule = rules_op.query_rule(phone_number, is_trial, org_id)
if rule:
app.logger.info("Allowing call to (%s, %s, %s) based on explicit rule",
phone_number, is_trial, org_id)
return
if rule is None:
from flask import Flask
from flask_redis import FlaskRedis
# Instantiate redis client
redis_client = FlaskRedis(decode_responses=True)
def create_app():
"""Flask application factory."""
# Create the application instance
app = Flask(__name__)
# Load extra config variables
app.config.from_object('config.Config')
# Associate redis
redis_client.init_app(app)
# Register blueprint(s)
from . import spellcheck
app.register_blueprint(spellcheck.bp)
# Return the application
return app
from random import random
from flask import Flask, render_template, request, jsonify
from flask_pymongo import PyMongo
from flask_redis import FlaskRedis
import uuid
import pymongo
import json
import time
from datetime import datetime
from flask_redis import FlaskRedis
app = Flask(__name__)
#app.config['MONGO_URI']="mongodb://10.122.138.24:27017/flask"
app.config['REDIS_URL'] = "redis://127.0.0.1:6379/0"
#mongo = PyMongo(app)
redis_store = FlaskRedis(app)
'''
def utc2local(utc_dtm):
local_tm = datetime.fromtimestamp( 0 )
utc_tm = datetime.utcfromtimestamp( 0 )
offset = local_tm - utc_tm
return str(utc_dtm + offset)
'''
@app.route("/")
def index():
return render_template("index.html")
@app.route("/liuyanbanpost", methods=['POST'])
from flask_redis import FlaskRedis redis_store = FlaskRedis()
from flask_cache import Cache
from flask_migrate import Migrate
from flask_session import Session
from flask_sqlalchemy import SQLAlchemy
from flask_redis import FlaskRedis
cache = FlaskRedis()
db = SQLAlchemy()
def init_ext(app):
Session(app=app)
# with app.app_context():
db.init_app(app)
cache.init_app(app=app)
migrate = Migrate(app=app, db=db) ## 用来绑定app和db到flask_migrate的
# 发送监控数据事件
SEND_MON_DATA = 'SEND_MON_DATA'
# 开启监控数据传输
IS_SEND_MON_DATA = 'IS_SEND_MON_DATA'
# 开启视频数据
IS_SEND_VIDEO_DATA = 'IS_SEND_VIDEO_DATA'
#发送视频数据
SEND_VIDEO_DATA = 'SEND_VIDEO_DATA'
app = Flask(__name__, template_folder='./')
app.config['SECRET_KEY'] = 'secret!'
app.config['REDIS_URL'] = "redis://localhost:6379/COM"
socketio = SocketIO(app)
redis_store = FlaskRedis(app)
def getAll():
all_datas = []
keys = redis_store.keys()
for key in keys:
value = redis_store.get(key)
all_datas.append({
'device': value.decode("utf-8"),
'sid': key.decode("utf-8")
})
return all_datas
from zopsedu.lib.sessions import CustomSessionInterface
from zopsedu.lib.db import DB
# pylint: disable=invalid-name
app = Flask("zopsedu")
app = configure_app(app)
session_opts = {
'session.cookie_expires': app.config.get('SESSION_COOKIE_EXPIRES', 30),
'session.timeout': app.config.get('SESSION_TIMEOUT', 30),
'cache_key_prefix': app.config.get('SESSION_CACHE_KEY_PREFIX', 'Sessions'),
'token_key_prefix': app.config.get('TOKEN_CACHE_KEY_PREFIX', 'Tokens'),
'token_header': app.config.get('TOKEN_HEADER', 'X-Auth-Token'),
}
redis_store = FlaskRedis(strict=False)
redis_store.init_app(app)
app.session_interface = CustomSessionInterface(
session_opts,
app.extensions['redis'],
)
# pylint: enable=invalid-name
# csrf protection
CSRFProtect(app)
# init db object
DB.init_app(app)
DB.app = app
job_store = SQLAlchemyJobStore(url=app.config.get('SQLALCHEMY_DATABASE_URI'),
from twistedApp import app
from flask import render_template, flash, redirect, url_for
from flask_redis import FlaskRedis
from app.forms import PumpForm
from flask_wtf import FlaskForm
from wtforms import SubmitField
import pickle
from .tools import ping, timeTools
app.config['REDIS_URL'] = "redis://:@localhost:6379/0"
redis_client = FlaskRedis(app)
#initialize database
initialPumpsState = {"lowAg": "off", "medAg": "off"}
redis_client.set("creekpi", pickle.dumps(initialPumpsState))
@app.route('/', methods=['GET', 'POST'])
@app.route('/index', methods=['GET', 'POST'])
def index():
return render_template('base.html')
@app.route('/pumps', methods=['GET', 'POST'])
def pumps():
form = PumpForm()
pickled = redis_client.get("creekpi")
unpickled = pickle.loads(pickled)
print(unpickled)
pickledTime = redis_client.get("creekpi-time")
unpickledTime = pickle.loads(pickledTime)
#!/usr/bin/python3
from flask import Flask, render_template, url_for, request
from flask_redis import FlaskRedis
import os
app = Flask(__name__)
app.config["REDIS_URL"] = "redis://:@cc-db:6379/0"
rc = FlaskRedis(app)
@app.route("/")
def index():
files = rc.lrange("0", 0, -1)
file_list = []
for f in files:
file_list.append(f.decode("utf-8"))
print(file_list)
return render_template("home.html", files=file_list)
@app.route("/photo_set/<int:photo_set_id>")
def photo_set(photo_set_id=None):
files = rc.lrange(photo_set_id, 0, -1)
file_list = []
for f in files:
file_list.append(f.decode("utf-8"))
print(file_list)
return render_template("photo_set.html",
photo_set_id=photo_set_id,
files=file_list)
def redis_store(app):
return FlaskRedis.from_custom_provider(FakeStrictRedis, app)
def connect_db():
""" connects to our redis database """
redis_store = FlaskRedis()
redis_store.init_app(app)
return redis_store
import os
from flask import Flask, request, jsonify, abort
from werkzeug.utils import secure_filename
import hashlib
from functools import wraps
import time
from flask_executor import Executor
from PIL import Image
import pytesseract
from flask_redis import FlaskRedis
app = Flask(__name__)
#redis用于存放用户的token和异步时临时存储用户的索引
redis_client = FlaskRedis(app, charset='utf-8', decode_responses=True)
#启动异步操作多线程
executor = Executor(app)
app.config['EXECUTOR_TYPE'] = 'thread'
app.config['EXECUTOR_MAX_WORKERS'] = 5
#存放图片位置
UPLOAD_FOLDER = 'images/'
ALLOWED_EXTENSIONS = set(['jpg', 'png'])
@app.route("/echo", methods=['GET'])
def echo():
"""
测试服务器运行正常
:return:
def __init__(self):
self.blacklist = FlaskRedis()
from hashlib import md5
import json
import urllib.request, urllib.parse, urllib.error
import re
import time
from referencesrv.parser.crf import CRFClassifierText, create_text_model, load_text_model
from referencesrv.resolver.solve import solve_reference
from referencesrv.resolver.hypotheses import Hypotheses
from referencesrv.resolver.sourcematchers import create_source_matcher, load_source_matcher
from referencesrv.resolver.common import NoSolution, Incomplete
bp = Blueprint('reference_service', __name__)
redis_db = FlaskRedis()
RE_NUMERIC_VALUE = re.compile(r'\d')
# @bp.before_app_first_request
def text_model():
"""
:return:
"""
# load only if in production mode
if current_app.config['REFERENCE_SERVICE_LIVE']:
current_app.extensions['text_crf'] = load_text_model()
current_app.extensions['source_matcher'] = load_source_matcher()
import conf
from .flaskAlchemyInit import app
LOGGER = logging.getLogger('auth.' + __name__)
LOGGER.addHandler(logging.StreamHandler())
LOGGER.setLevel(logging.INFO)
if conf.cacheName == 'redis':
REDIS_URL = ('redis://' + conf.cacheUser + ':' + conf.cachePdw + '@' +
conf.cacheHost + ':6379/' + conf.cacheDatabase)
app.config['DBA_URL'] = REDIS_URL
redis_store = FlaskRedis(app,
config_prefix='DBA',
strict=False,
encoding="utf-8",
socket_keepalive=True,
charset="utf-8",
decode_responses=True)
elif conf.cacheName == 'NOCACHE':
LOGGER.warning("Warning. Cache policy set to NOCACHE."
"This may degrade PDP performance.")
redis_store = None
else:
LOGGER.error("Currently, there is no support for cache policy " +
conf.dbName)
exit(-1)
import logging
from flask import Blueprint, Flask, render_template, redirect, request, url_for
from flask_sqlalchemy import SQLAlchemy
from flask_redis import FlaskRedis
from redis import StrictRedis
from sqlalchemy.sql.expression import func
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.INFO)
db = SQLAlchemy()
redis_store = FlaskRedis.from_custom_provider(StrictRedis)
page = Blueprint('page', __name__)
def create_app():
"""
Create a Flask application using the app factory pattern.
:return: Flask app
"""
app = Flask(__name__, instance_relative_config=True)
app.config.from_object('config.settings')
app.config.from_pyfile('settings.py', silent=True)
db.init_app(app)
redis_store.init_app(app)
# server/app/extensions.py
from gql import GQL
from flask_bcrypt import Bcrypt
from flask_jwt_extended import JWTManager
from flask_migrate import Migrate
from flask_redis import FlaskRedis
bcrypt = Bcrypt()
migrate = Migrate()
jwt = JWTManager()
redis_client = FlaskRedis()
graphql_client = GQL()
@jwt.expired_token_loader
def jwt_token_expired():
return {"message": "Signature expired. Please log in again."}, 401
@jwt.invalid_token_loader
def jwt_token_invalid(_):
return {"message": "Invalid token. Please log in again."}, 401
@jwt.revoked_token_loader
def jwt_token_revoked():
return {"message": "Invalid token. Please log in again."}, 401
@jwt.token_in_blacklist_loader
Base.metadata.create_all(engine)
jwt = JWTManager(app)
cors = CORS(app, resources={r"/api/*": {"origins": "*"}})
class DecodedRedis(StrictRedis):
@classmethod
def from_url(cls, url, db=None, **kwargs):
kwargs['decode_responses'] = True
kwargs['password'] = app.config["REDIS_PASSWORD"]
return StrictRedis.from_url(url, db, **kwargs)
rc = FlaskRedis.from_custom_provider(DecodedRedis, app)
rc_user = StrictRedis(host=app.config["REDIS_HOST"],
port=int(app.config["REDIS_PORT"]),
password=app.config["REDIS_PASSWORD"],
db=1,
decode_responses=True)
# encrypt & decrypt
key = local_settings["fernet_key"].encode()
fernet = Fernet(key)
authorizations = {
'Bearer Auth': {
'type': 'apiKey',
'in': 'header',
from baseframe import Bundle, Version, assets, baseframe
import coaster.app
from ._version import __version__
# Three apps
app = Flask(__name__, instance_relative_config=True)
funnelapp = Flask(__name__,
instance_relative_config=True,
subdomain_matching=True)
lastuserapp = Flask(__name__, instance_relative_config=True)
mail = Mail()
pages = FlatPages()
redis_store = FlaskRedis(decode_responses=True)
rq = RQ()
# --- Assets ------------------------------------------------------------------
version = Version(__version__)
assets['funnel.css'][version] = 'css/app.css'
assets['funnel.js'][version] = 'js/scripts.js'
assets['spectrum.js'][version] = 'js/libs/spectrum.js'
assets['spectrum.css'][version] = 'css/spectrum.css'
assets['screens.css'][version] = 'css/screens.css'
assets['schedules.js'][version] = 'js/schedules.js'
assets['schedule-print.css'][version] = 'css/schedule-print.css'
# --- Import rest of the app --------------------------------------------------
from flask import Flask
#, flash, redirect, render_template, request, url_for
from flask_bootstrap import Bootstrap
from flask_login import (LoginManager, current_user, login_required,
login_user, logout_user)
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from itsdangerous import URLSafeTimedSerializer
from flask_redis import FlaskRedis
from .config import BaseConfig
db = SQLAlchemy()
r = FlaskRedis()
migrate = Migrate()
def create_app():
app = Flask(__name__)
app.config.from_object(BaseConfig)
db.init_app(app)
r.init_app(app)
migrate.init_app(app, db)
bootstrap = Bootstrap(app)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_redis import FlaskRedis
from config import ProductionConfig, DevelopmentConfig
def create_app():
app = Flask(__name__)
app.config.from_object(DevelopmentConfig)
return app
app = create_app()
db = SQLAlchemy(app)
redis = FlaskRedis(app)
with app.app_context():
from flask_app import routes
from flask_app import models
db.create_all()
from flask import request, session
from flask_limiter import Limiter
from flask_socketio import SocketIO, disconnect
from flask_babel import Babel
from flask_redis import FlaskRedis
from config import config
from sqlalchemy import and_
from itsdangerous import URLSafeSerializer
#from raven.contrib.flask import Sentry
import random
import string
import hashlib
import time
import json
redis_store = FlaskRedis(charset="utf-8", decode_responses=True)
from titanembeds.discordrest import DiscordREST
from titanembeds.redisqueue import RedisQueue
discord_api = DiscordREST(config['bot-token'])
redisqueue = RedisQueue()
serializer = URLSafeSerializer(config["app-secret"])
def get_client_ipaddr():
if request.headers.getlist("X-Forwarded-For"):
ip = request.headers.getlist("X-Forwarded-For")[0]
else:
ip = request.remote_addr
import managers
from flask_redis import FlaskRedis
from flask import Flask
# Instantiate and config flask
flask_app = Flask(__name__)
flask_app.config.update(
CELERY_BROKER_URL=managers.celery_config.CELERY_BROKER_URL,
CELERY_RESULT_BACKEND=managers.celery_config.CELERY_RESULT_BACKEND,
REDIS_URL=managers.celery_config.REDIS_URL)
# Instantiate and config celery from flask
celery = managers.make_celery(flask_app)
celery.config_from_object(managers.celery_config)
# Instantiate py-redis
redis_store = FlaskRedis(flask_app)
# We need this for task discovery
from app import tasks
def __init__(self, user, app):
self.user = user
self.redis_store = FlaskRedis(app)
super(RegexConverter, self).__init__(url_map)
self.regex = args[0]
class Config(object):
SQLALCHEMY_DATABASE_URI = "mysql+mysqlconnector://root:[email protected]:3306/flask_movie"
REDIS_URL = "redis://127.0.0.1:6379/0"
SQLALCHEMY_TRACK_MODIFICATIONS = True
SECRET_KEY = "密钥字符串"
BASE_DIR = os.path.abspath(os.path.dirname(__file__))
UPLOAD_DIR = create_upload_dir(BASE_DIR)
DEBUG = True
db = SQLAlchemy()
redis = FlaskRedis()
def create_app():
app = Flask(__name__)
app.config.from_object(Config)
app.url_map.converters["re"] = RegexConverter
app.app_context().push()
CSRFProtect(app)
db.init_app(app)
redis.init_app(app)
from .admin import admin as admin_blueprint
from .home import home as home_blueprint
#coding: utf-8
from APITaxi_utils.redis_geo import GeoRedis
from flask_redis import FlaskRedis
redis_store = FlaskRedis.from_custom_provider(GeoRedis)
redis_store_haillog = FlaskRedis.from_custom_provider(GeoRedis,
config_prefix='REDIS_HAILLOG')
from flask_celery import Celery
celery = Celery()
from APITaxi_utils.cache_user_datastore import CacheUserDatastore
user_datastore = CacheUserDatastore()
app = Flask(__name__)
# 用于连接数据的数据库。
app.config[
"SQLALCHEMY_DATABASE_URI"] = "mysql+pymysql://root:Jiege..950417@localhost:3306/movie"
# app.config["SQLALCHEMY_DATABASE_URI"] = "mysql://*****:*****@127.0.0.1:3306/movie"
# 如果设置成 True (默认情况)，Flask-SQLAlchemy 将会追踪对象的修改并且发送信号。
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = True
app.config["REDIS_URL"] = "redis://127.0.0.1:6379/0"
app.config['SECRET_KEY'] = 'mtianyan_movie'
app.config["UP_DIR"] = os.path.join(os.path.abspath(os.path.dirname(__file__)),
"static/uploads/")
app.config["FC_DIR"] = os.path.join(os.path.abspath(os.path.dirname(__file__)),
"static/uploads/users/")
app.debug = True
db = SQLAlchemy(app)
rd = FlaskRedis(app)
# 不要在生成db之前导入注册蓝图。
from app.home import home as home_blueprint
from app.admin import admin as admin_blueprint
app.register_blueprint(home_blueprint)
app.register_blueprint(admin_blueprint, url_prefix="/admin")
@app.errorhandler(404)
def page_not_found(error):
"""
404
"""
return render_template("home/404.html"), 404
# -*- coding: utf-8 -*-
from flask_sqlalchemy import SQLAlchemy
from flask_limiter import Limiter
from flask_admin import Admin
from flask_login import LoginManager
from flask_script import Manager
from youjiao.yj_admin.views import YJHomeView
from flask_redis import FlaskRedis
from flask_jwt import JWT
from .flask_qiniu import FlaskQiniu
db = SQLAlchemy()
USER_TABLE_NAME = 'youjiao_user' # table name 'user' is used in postgresql
USER_TABLE_USER_ID = '{}.id'.format(USER_TABLE_NAME)
limiter = Limiter()
admin = Admin(index_view=YJHomeView(name=u'数据面板'),
name=u'幼教后台',
template_mode='bootstrap3')
redis_cli = FlaskRedis(strict=True)
flask_qiniu = FlaskQiniu()
manager = Manager()
jwt = JWT()
login_manager = LoginManager()
import logging
from flask import Blueprint, Flask, render_template, redirect, request, url_for
from flask_sqlalchemy import SQLAlchemy
from flask_redis import FlaskRedis
from redis import StrictRedis
from sqlalchemy.sql.expression import func
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.INFO)
db = SQLAlchemy()
redis_store = FlaskRedis.from_custom_provider(StrictRedis)
page = Blueprint('page', __name__)
def create_app():
"""
Create a Flask application using the app factory pattern.
:return: Flask app
"""
app = Flask(__name__, instance_relative_config=True)
app.config.from_object('config.settings')
app.config.from_pyfile('settings.py', silent=True)
db.init_app(app)
redis_store.init_app(app)
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_redis import FlaskRedis
import yaml
config_file = 'config/OAuth2.yml'
with open(config_file, 'r') as f:
config = yaml.load(f)
app = Flask(config.get('main_name'),
template_folder='../templates',
static_folder='../static')
app.config[
'SQLALCHEMY_DATABASE_URI'] = '{database}://{username}:{password}@{db_host}/{db_name}'.format(
**config.get('db_config'))
app.config['REDIS_URL'] = 'redis://:{password}@{host}:{port}/0'.format(
**config.get('redis_config'))
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
cache_db = FlaskRedis(app)
import os
import sys
import optparse
import redlock
registry = []
from flask_redis import FlaskRedis
redis_store = FlaskRedis()
# 35 times x 200 ms = 7 seconds trying to acquire, 200 millis each time
rlock = redlock.Redlock([
{
"host": "localhost",
"port": 6379,
"db": 0
},
],
retry_count=35)
from .application import app
from .db import db, upgrader
redis_store.init_app(app)
assert db is not None # ignore pyflakes
from flask import render_template
""" Database and storage related functions and classes """
import datetime
from enum import IntEnum
import functools
import sys
from flask import g
from flask_redis import FlaskRedis
from peewee import IntegerField, DateTimeField, BooleanField, Proxy, Model, Database
from peewee import CharField, ForeignKeyField, TextField, PrimaryKeyField
from werkzeug.local import LocalProxy
from .storage import file_url
from .config import config
rconn = FlaskRedis()
dbp = Proxy()
def get_db():
if "db" not in g:
if dbp.is_closed():
dbp.connect()
g.db = dbp
return g.db
db = LocalProxy(get_db)
def db_init_app(app):
dbconnect = app.config["THROAT_CONFIG"].database.as_dict()
from flask_mail import Mail from flask_redis import FlaskRedis from flask_lastuser import Lastuser from flask_lastuser.sqlalchemy import UserManager from baseframe import baseframe, assets, Version import coaster.app from ._version import __version__ # First, make an app and config it app = Flask(__name__, instance_relative_config=True, subdomain_matching=True) app.static_folder = 'static' mail = Mail() lastuser = Lastuser() redis_store = FlaskRedis() # Second, setup assets version = Version(__version__) # Third, after config, import the models and views from . import models, views # NOQA from .models import db # NOQA # Configure the app coaster.app.init_app(app) db.init_app(app) db.app = app migrate = Migrate(app, db) app.geoip = None
import os
from flask import Flask
from flask_pymongo import PyMongo
from flask_redis import FlaskRedis
from flask_sqlalchemy import SQLAlchemy
from config import Configuration
# config file has all the connections
app = Flask(__name__)
app.config.from_object(Configuration)
MIGRATION_DIR = os.path.join('models', 'migrations')
# DB connections
mongo = PyMongo(app) # mongo db
db = SQLAlchemy(app) # sql alchemy
redis_client = FlaskRedis(app) # redis cache
#login_manager = LoginManager()
#login_manager.init_app(app)
#app.config['FLASK_ADMIN_SWATCH'] = 'darkly'
