def before_request():
"""
Setup before request
"""
if not getattr(g, 'redis', None):
redis_store = FlaskRedis(app)
try:
redis_store.client_list()
except ConnectionError:
redis_store = None
g.redis = redis_store
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(config=None):
app = flask.Flask(
'threatresponse',
static_folder='../static',
template_folder='../templates',
)
app.config.from_object('config') # Load from config.py
app.config.from_object(settings)
FlaskRedis(app, 'REDIS')
return app
"""Initializer for Resume Parsing App"""
__author__ = 'erikfarmer'
from flask.ext.redis import FlaskRedis
from resume_parsing_service.common.utils.models_utils import init_talent_app
from resume_parsing_service.common.routes import ResumeApi, GTApis
from resume_parsing_service.common.talent_config_manager import load_gettalent_config, TalentConfigKeys
from resume_parsing_service.common.utils.talent_ec2 import get_ec2_instance_id
from resume_parsing_service.common.talent_flask import TalentFlask
from resume_parsing_service.common.models.db import db
app, logger = init_talent_app(__name__)
try:
redis_store = FlaskRedis(app)
from views import api, contact_api
app.register_blueprint(api.PARSE_MOD, url_prefix=ResumeApi.URL_PREFIX)
app.register_blueprint(contact_api.CONTACT_MOD, url_prefix='/v1')
logger.info("Starting resume_parsing_service in %s environment",
app.config[TalentConfigKeys.ENV_KEY])
except Exception as error:
logger.exception(
"Couldn't start resume_service in %s environment because: %s" %
(app.config[TalentConfigKeys.ENV_KEY], error.message))
# _*_ coding:utf-8 _*_ from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.redis import FlaskRedis from flask.ext.bootstrap import Bootstrap from flask.ext.login import LoginManager __all__ = ['db', 'redis'] db = SQLAlchemy() redis = FlaskRedis() bootstrap = Bootstrap() loging_manager = LoginManager() loging_manager.session_protection = 'strong' loging_manager.login_view = 'admin.login' loging_manager.login_message = u'请登入帐号再进行下一步操作！'
#coding:utf-8 from flask import Flask,render_template import pymysql from flask import Flask from flask_sqlalchemy import SQLAlchemy import os from flask.ext.redis import FlaskRedis app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:[email protected]:3306/movie' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True app.config['SECRET_KEY']="57a9c928-06cf-4550-8d4c-0d7adf8a8250" # app.config['REDIS_URL'] = "redis://localhost:6379/0" app.config['REDIS_URL'] = "redis://192.168.3.23:6379/0" app.config['UP_DIR'] = os.path.join(os.path.abspath(os.path.dirname(__file__)),"static/uploads/") app.config['FACE_DIR'] = os.path.join(os.path.abspath(os.path.dirname(__file__)),"static/uploads/users/") app.debug = True db = SQLAlchemy(app) rd = FlaskRedis(app) 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): return render_template('home/404.html'),404
import uuid
import json
from flask.ext.redis import FlaskRedis
db = FlaskRedis()
class BadFieldException(BaseException):
pass
class NotFoundException(BaseException):
pass
class TTLDBaseModel(object):
__key_pattern__ = 'nothing'
__fields__ = []
__blacklist__ = ['_meta']
_doc = {}
def __init__(self, *args, **kwargs):
pass
def _hasfield(self, key):
return key in self.__fields__ and key not in self.__blacklist__
def __setitem__(self, key, val):
if self._hasfield(key):
__author__ = 'ufarooqi'
from flask.ext.redis import FlaskRedis
from redis_collections import Dict
from .constants import REDIS2
redis_store = FlaskRedis()
redis_store2 = FlaskRedis(config_prefix=REDIS2)
def redis_dict(redis_instance, redis_list_key=None):
if redis_list_key and redis_instance.exists(redis_list_key):
return Dict(redis=redis_instance,
key=redis_instance.get(redis_list_key))
else:
redis_list_instance = Dict(redis=redis_instance)
if redis_list_key:
redis_instance.set(redis_list_key, redis_list_instance.key)
return redis_list_instance
from flask import Flask
from flask.ext.redis import FlaskRedis
import os
__version__ = '0.9.0'
redis_store = FlaskRedis()
template_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'templates')
def create_app(name=__name__,
config={},
static_folder='transporter/static',
template_folder=template_dir):
"""NOTE: `db_uri` is only a temporary solution. It shall be replaced by
something more robust."""
app = Flask(name,
static_folder=static_folder,
template_folder=template_folder)
app.secret_key = 'secret'
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DB_URI')
app.config['REDIS_URL'] = os.environ.get('REDIS_URL')
app.config['DEBUG'] = True
app.config.update(config)
redis_store.init_app(app)
from transporter.models import db
db.init_app(app)
from flask import Flask, g
from flask.ext.redis import FlaskRedis
from flask.ext.login import LoginManager
from flask.sessions import SecureCookieSessionInterface
from ldappool import ConnectionManager
from cosign import CoSign
from ldaptools import LDAPTools
app = Flask(__name__)
app.config.from_object('config')
flask_redis = FlaskRedis(app, 'REDIS')
ldap = LDAPTools(
ConnectionManager(app.config["LDAP_SERVER"])
)
cosign = CoSign(app)
lm = LoginManager(app)
lm.login_view = "login"
class CustomSessionInterface(SecureCookieSessionInterface):
"""Prevent creating session from API requests."""
def save_session(self, *args, **kwargs):
return
app.session_interface = CustomSessionInterface()
@lm.request_loader
from flask import Flask
from flask.ext.redis import FlaskRedis
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__, static_folder='static/public')
app.config.from_pyfile('../config/config.cfg')
db = SQLAlchemy(app)
redis = FlaskRedis(app)
import website.routes.index
import website.routes.matches
import website.routes.clubs
import website.routes.teams
import website.routes.error_handlers
import website.routes.webhook
import website.custom_filters
import website.models.country
import website.models.club
import website.models.position
import website.models.player
configuration = {'debug': False}
configuration_file = pkg_resources.resource_filename(
pkg_resources.Requirement.parse('commandment'), 'config/config.json')
if os.path.exists(configuration_file):
with open(configuration_file, 'r') as configuration_fh:
loaded_configuration = json.load(configuration_fh)
configuration.update(loaded_configuration)
for key in ('host', 'port', 'pass', 'database'):
keyu = key.upper()
if os.environ.get('REDIS_%s' % keyu):
configuration['redis'][key] = os.environ.get('REDIS_%s' % keyu)
app = create_app(configuration['debug'], FlaskRedis(), configuration)
if 'database' not in configuration:
configuration['database'] = {
'uri': app.config['DATABASE_URI'],
'echo': app.config['DATABASE_ECHO']
}
if os.environ.get('COMMANDMENT_PORT'):
configuration['port'] = int(os.environ.get('COMMANDMENT_PORT'))
if 'port' not in configuration:
configuration['port'] = app.config.get('PORT')
app.logger.info(configuration)
