def create_app(debug=True): """Create an application.""" app = Flask(__name__) logging.basicConfig( filename="var/log/newsletter_dispatcher.log", level=logging.INFO, format="[%(asctime)s] %(levelname)s - %(message)s", ) try: app.config.from_object("config.Config") except ImportStringError: logger.error( "No config.py file found. Starting with standard configuration.") if app.config.get("SENTRY_DSN", ""): sentry_sdk.init( dsn=app.config.get("SENTRY_DSN", ""), integrations=[FlaskIntegration()], # debug=True, ) app.config["TESTING"] = testing_enabled() if app.config.get("REDIS_PORT", ""): app.redis = redis.Redis(port=app.config["REDIS_PORT"]) else: app.redis = redis.Redis() app.task_queue = Queue(connection=app.redis, default_timeout=10000) app.mail = Mail(app) Api(routes_bp) app.register_blueprint(routes_bp) return app
def create_app(redis_conn=None): settings_class = os.getenv('APP_SETTINGS', 'config.Config') app = Flask(__name__) app.config.from_object(settings_class) CORS(app, origins=app.config['CORS_ORIGINS'], supports_credentials=True) # Redis if redis_conn is None: import redis app.redis = redis.from_url(app.config["REDIS_URL"], decode_responses=True) else: app.redis = redis_conn redis_map.init_app(app, app.redis) # Api from api import routes routes.init_app(app) basic_auth.init_app(app) app.logger.setLevel(logging.DEBUG) # app.url_map.strict_slashes = False # Rate Limiter rate_limiter.init_app(app) # Webhook webhook.init_app(app, app.config['WEBHOOK_URL']) # Environment specific if settings_class == 'config.Config': from apscheduler.schedulers.gevent import GeventScheduler as Scheduler bg_jobs.init_app(app, Scheduler) elif settings_class == 'config.Develop': from api import localtest app.register_blueprint(localtest.bp) if is_main_workzeug_process(): from apscheduler.schedulers.background import BackgroundScheduler as Scheduler bg_jobs.init_app(app, Scheduler) elif settings_class == 'config.Testing': pass else: raise Exception(f'Unknown settings_class: {settings_class}') app.logger.info(f'Loaded {settings_class} configuration') return app
def create_app(config_class): app = Flask(__name__) app.config.from_object(config_class) # Initialize MongoEngine try: register_connection(alias="default", name=app.config["DB_NAME"], username=app.config["DB_USER"], password=app.config["DB_PASSWORD"], host=app.config["DB_URL"], port=app.config["DB_PORT"]) except: print("Database could not be configured.") return None nav.init_app(app) login_manager.init_app(app) bootstrap.init_app(app) app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue(app.config['REDIS_QUEUE_NAME'], connection=app.redis) from app.jobs import bp as jobs_bp app.register_blueprint(jobs_bp, url_prefix='') from app.web import bp as web_bp app.register_blueprint(web_bp, url_prefix='') from app.user import bp as user_bp app.register_blueprint(user_bp, url_prefix='') return app
def create_app(config): app = Flask(__name__) app.config.from_object(config) app.url_map.converters['html'] = HTMLConverter #session初始化,将session存储到redis中 Session(app) #创建redis存储对象 redis_store = StrictRedis(host=config.REDIS_HOST, port=config.REDIS_PORT) app.redis = redis_store # 日志处理 import logging from logging.handlers import RotatingFileHandler logging.basicConfig(level=logging.DEBUG) file_log_handler = RotatingFileHandler(os.path.join( BASE_DIR, "logs/ihome.log"), maxBytes=1024 * 1024 * 100, backupCount=10) formatter = logging.Formatter( '%(levelname)s %(filename)s:%(lineno)d %(message)s') file_log_handler.setFormatter(formatter) logging.getLogger().addHandler(file_log_handler) return app
def create_app(config_name='default'): app = Flask(__name__) app.config.from_object(config[config_name]) db.init_app(app) ma.init_app(app) migrate.init_app(app, db) login.init_app(app) moment.init_app(app) babel.init_app(app) api.init_app(app) app.elasticsearch = Elasticsearch([app.config['ELASTICSEARCH_URL']]) \ if app.config['ELASTICSEARCH_URL'] else None app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('feedback-tasks', connection=app.redis) if not app.debug and not app.testing: if app.config['MAIL_SERVER']: auth = None if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']: auth = (app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD']) secure = None if app.config['MAIL_USE_TLS']: secure = () mail_handler = SMTPHandler( mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']), fromaddr='no-reply@' + app.config['MAIL_SERVER'], toaddrs=app.config['ADMINS'], subject='FeedBack App Failure', credentials=auth, secure=secure) mail_handler.setLevel(logging.ERROR) app.logger.addHandler(mail_handler) if app.config['LOG_TO_STDOUT']: stream_handler = logging.StreamHandler() stream_handler.setLevel(logging.INFO) app.logger.addHandler(stream_handler) else: if not os.path.exists('logs'): os.mkdir('logs') file_handler = RotatingFileHandler('logs/feedback.log', maxBytes=10240, backupCount=10) file_handler.setFormatter( logging.Formatter('%(asctime)s %(levelname)s: %(message)s ' '[in %(pathname)s:%(lineno)d]')) file_handler.setLevel(logging.INFO) app.logger.addHandler(file_handler) app.logger.setLevel(logging.INFO) app.logger.info('Feedback is up!') # Start Modules! from . import modules modules.init_app(app) return app
def create_app(config): global app app = Flask( __name__, template_folder='../templates', static_folder='../static', ) app.wsgi_app = ProxyFix(app.wsgi_app) app.config.update(config) app.url_rule_class = GeneratorRule app.redis = redis.Redis.from_url(config['REDISCLOUD_URL']) app.eventee = { 'token': config['EVENTEE_TOKEN'], 'email': config['EVENTEE_EMAIL'], } import views import login import login_oauth import talks import program import entrant import vote import filters import service import workshops import invoices from admin import admin app.register_blueprint(admin, url_prefix='/admin') return app
def create_app(config_file=None, settings_override=None): # Create and configure the app app = Flask(__name__, instance_relative_config=True) # Load the default config file app.config.from_pyfile(os.path.join(APP_ROOT, "config", "default.py")) if config_file: # Use the manually specified config file app.config.from_pyfile(config_file) else: # Use the default already loaded into the environment variable app.config.from_envvar(VAR_CONFIG_PATH) if settings_override: # Override config variables with the dictionary parm app.config.update(settings_override) # Ensure the instance folder exists try: os.makedirs(app.instance_path) except OSError: pass app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = Queue(os.getenv("RQ_NAME"), connection=app.redis) from . import index app.register_blueprint(index.bp) return app
def create_app(config): global app app = Flask( __name__, template_folder='../templates', static_folder='../static', ) app.wsgi_app = ProxyFix(app.wsgi_app) app.config.update(config) app.url_rule_class = GeneratorRule app.redis = redis.Redis.from_url(config['REDISCLOUD_URL']) app.eventee = { 'token': config['EVENTEE_TOKEN'], 'email': config['EVENTEE_EMAIL'], } import views import login import login_oauth import talks import program import entrant import vote import filters import service import workshops import invoices return app
def create_app(): app = Flask(__name__, template_folder='./templates', static_folder='./static') app.config.from_object(Config) app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue(connection=app.redis) migrate = Migrate(app, db) db.init_app(app) login_helper.init_app(app) with app.app_context(): from .main.routes import bp as main_bp from .users.routes import bp as users_bp from .recipes.routes import bp as recipes_bp from .pantry.routes import bp as pantry_bp login_helper.login_view = 'users.login' db.create_all() app.register_blueprint(main_bp, url_prefix='/') app.register_blueprint(users_bp, url_prefix='/users') app.register_blueprint(recipes_bp, url_prefix='/recipes') app.register_blueprint(pantry_bp, url_prefix='/pantry') return app
def create_app(): app = Flask(__name__) #print(os.path.dirname(__file__)) app.config.from_object("web.defaultconfig") if "KFCHESS_CONFIG" in os.environ: app.config.from_envvar("KFCHESS_CONFIG") print("Using config at {}".format(os.environ["KFCHESS_CONFIG"])) else: print("KFCHESS_CONFIG envvar is not present, using default config") app.redis = redis.StrictRedis(host=app.config["REDIS_HOSTNAME"], port=app.config["REDIS_PORT"]) socketio.init_app(app) login_manager.init_app(app) mysql.init_app(app) bcrypt.init_app(app) # this weird local import on create seems to be necessitated by flask-socketio's lack of support of blueprints from web.main import main, user app.register_blueprint(main, url_prefix='/') from web.game import game_bp, init_game app.register_blueprint(game_bp, url_prefix='/game') app.register_blueprint(game_bp, url_prefix='/games') init_game(app, socketio) return app
def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(config_class) app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('src-tasks', connection=app.redis, job_timeout="40m") # app.elasticsearch = Elasticsearch([app.config['ELASTICSEARCH_URL']]) \ # if app.config['ELASTICSEARCH_URL'] else None if not app.debug and not app.testing: # ... if app.config['LOG_TO_STDOUT']: stream_handler = logging.StreamHandler() stream_handler.setLevel(logging.INFO) app.logger.addHandler(stream_handler) else: if not os.path.exists('logs'): os.mkdir('logs') file_handler = RotatingFileHandler('logs/kumbayuni.log', maxBytes=10240, backupCount=10) file_handler.setFormatter(logging.Formatter( '%(asctime)s %(levelname)s: %(message)s ' '[in %(pathname)s:%(lineno)d]')) file_handler.setLevel(logging.INFO) app.logger.addHandler(file_handler) app.logger.setLevel(logging.INFO) app.logger.info('Kumbayuni startup') return app
def create_app(): app = Flask(__name__, static_url_path='') app.config.from_object(__name__) Swagger(app) app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('tasks', connection=app.redis) @app.route('/') def index(): return render_template('index.html', workspaces=base_obj._get_workspaces(), headings=headings) @app.route('/framework') def framework(): r = requests.get('http://*****:*****@app.route('/search') def search(): return render_template('search.html') from core.web.api import resources app.register_blueprint(resources) return app
def create_app(config_name=Config): app = Flask(__name__.split('.')[0]) app.config.from_object(config_name) # Register before requests mixins prior to those that are inside extensions register_extensions(app) app.redis = redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('freedomap-tasks', connection=app.redis) app.task_queue.empty() app.scheduler = rq_scheduler.Scheduler( queue=app.task_queue, connection=app.task_queue.connection) setup_tasks(app.scheduler) register_url_rules(app) register_blueprints(app) register_errorhandlers(app) app.shell_context_processor( lambda: { 'db': db, 'Protest': map_blueprint.models.Protest, 'ProtestSubmission': map_blueprint.models.ProtestSubmission }) return app
def create_app(config_name=Config): load_dotenv() app = Flask(__name__.split('.')[0]) app.config.from_object(config_name) app.redis = redis.from_url(app.config['REDIS_URL']) app.config['SITEMAP_VIEW_DECORATORS'] = [load_page] # Don't cache js bundles if in development if app.config['ENV'] == 'development': app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0 # Register before requests mixins prior to those that are inside extensions register_extensions(app) register_url_rules(app) register_blueprints(app) register_errorhandlers(app) app.shell_context_processor( lambda: { 'db': db, 'User': main.models.User, 'CourseColor': calendar.models.CourseColor, 'CourseFilter': calendar.models.CourseFilter, 'CourseIdentifier': calendar.models.CourseIdentifier }) app.context_processor(inject_date) return app
def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(config_class) app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('beetroot_project-tasks', connection=app.redis) CORS(app, supports_credentials=True) db.init_app(app) migrate.init_app(app, db) mail.init_app(app) @jwt.unauthorized_loader def my_unauthorized_callback(error_msg): return jsonify({'msg': 'User Unauthorized'}), 401 jwt.init_app(app) from app.main import main as main_bp app.register_blueprint(main_bp) from app.telebot import bp as telebot_bp app.register_blueprint(telebot_bp, url_prefix='/RDOALlvctMgPAwCCKDmMsb') if not app.debug and not app.testing: if app.config['MAIL_SERVER']: auth = None if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']: auth = (app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD']) secure = None if app.config['MAIL_USE_TLS']: secure = () mail_handler = SMTPHandler( mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']), fromaddr='no-reply@' + app.config['MAIL_SERVER'], toaddrs=app.config['MAIL_USERNAME'], subject='Beetroot project Failure', credentials=auth, secure=secure) mail_handler.setLevel(logging.ERROR) app.logger.addHandler(mail_handler) if app.config['LOG_TO_STDOUT']: stream_handler = logging.StreamHandler() stream_handler.setLevel(logging.INFO) app.logger.addHandler(stream_handler) else: if not os.path.exists('logs'): os.mkdir('logs') file_handler = RotatingFileHandler('logs/beetroot-project.log', maxBytes=10240, backupCount=10) file_handler.setFormatter(logging.Formatter( '%(asctime)s %(levelname)s: %(message)s ' '[in %(pathname)s:%(lineno)d]')) file_handler.setLevel(logging.INFO) app.logger.addHandler(file_handler) app.logger.setLevel(logging.INFO) app.logger.info('Beetroot besvova490 startup') return app
def create_app(config_name='development'): app = Flask(__name__) setup = config_dic.get(config_name) if setup: app.config.from_object(setup) engine = create_engine(app.config['SQLALCHEMY_DATABASE_URI'], convert_unicode=True) session_factory = sessionmaker(bind=engine, autocommit=False, autoflush=False) db_session = flask_scoped_session(session_factory) db_session.init_app(app) Base = declarative_base() Base.query = db_session.query_property() def do_setup(): Base.metadata.create_all(bind=engine) do_setup() create_task_api(app) app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('drweb-tasks', connection=app.redis) return {'app': app, 'db_session': db_session, 'Base': Base}
def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(config_class) app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('kura-tasks', connection=app.redis) app.elasticsearch = Elasticsearch([app.config['ELASTICSEARCH_URL']]) \ if app.config['ELASTICSEARCH_URL'] else None db.init_app(app) bcrypt.init_app(app) login_manager.init_app(app) mail.init_app(app) moment.init_app(app) migrate = Migrate(app, db) from src.main.routes import main from src.users.routes import users from src.tweets.routes import tweets from src.errors.handlers import errors app.register_blueprint(main) app.register_blueprint(users) app.register_blueprint(tweets) app.register_blueprint(errors) return app
def create_app(config=Config): app = Flask(__name__) app.config.from_object(config) db.init_app(app) migrate.init_app(app, db) login.init_app(app) mail.init_app(app) bootstrap.init_app(app) moment.init_app(app) babel.init_app(app) from app.errors import bp as errors_bp app.register_blueprint(errors_bp) from app.auth import bp as auth_bp app.register_blueprint(auth_bp, url_prefix='/auth') from app.main import bp as main_bp app.register_blueprint(main_bp) from app.api import bp as api_bp app.register_blueprint(api_bp, url_prefix='/api') app.elasticsearch = Elasticsearch([ app.config['ELASTICSEARCH_URL'] ]) if app.config['ELASTICSEARCH_URL'] else None app.redis = Redis.from_url( app.config['REDIS_URL']) if app.config['REDIS_URL'] else None app.task_queue = rq.Queue( 'blog-tasks', connection=app.redis) if app.config['REDIS_URL'] else None return app
def create_app(config): global app app = Flask( __name__, template_folder='../templates', static_folder='../static', ) app.wsgi_app = ProxyFix(app.wsgi_app) app.config.update(config) app.url_rule_class = GeneratorRule app.redis = redis.Redis.from_url(config['REDISCLOUD_URL']) app.eventee = { 'token': config['EVENTEE_TOKEN'], 'email': config['EVENTEE_EMAIL'], } from . import views from . import login from . import login_oauth from . import talks from . import program from . import entrant from . import vote from . import filters from . import service from . import workshops from . import invoices from .admin import admin app.register_blueprint(admin, url_prefix='/admin') return app
def create_app(config_name='development'): app = Flask(__name__) app.config.from_object(config[config_name]) db.init_app(app) migrate.init_app(app, db) bcrypt.init_app(app) login_manager.init_app(app) if config_name != 'testing': app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('webgame-tasks', connection=app.redis) app.task_queue.empty() app.task_queue.enqueue('app.tasks.gift_users.gift_users', job_timeout=-1) from app.routes import base, shop, auth, google_auth, attack, profile, home from app.api import api_blueprint from app.models import user, army app.register_blueprint(home.home, url_prefix="") app.register_blueprint(base.base, url_prefix="/base") app.register_blueprint(shop.shop, url_prefix="/shop") app.register_blueprint(auth.auth, url_prefix="/auth") app.register_blueprint(attack.attack, url_prefix="/attack") app.register_blueprint(profile.profile, url_prefix="/profile") app.register_blueprint(google_auth.google_auth, url_prefix="/google") app.register_blueprint(api_blueprint, url_prefix='/api') return app
def create_app(): app = Flask(__name__, static_folder='static', static_url_path='') app.config.from_object(config) cache.init_app(app, config={'CACHE_TYPE': 'simple'}) db.init_app(app) migrate.init_app(app, db) ma.init_app(app) cors.init_app(app) jwt.init_app(app) with app.app_context(): from . import routes, models, commands db.create_all() app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue(app.config['QUEUE'], connection=app.redis, default_timeout=-1) app.register_blueprint(api_bp, url_prefix='/api') os.makedirs(app.config['ISIRANK_FILES'], exist_ok=True) os.makedirs(app.config['IMAGE_FILES'], exist_ok=True) @app.route('/') def healthcheck(): return "Application is running" return app
def create_app(): app = Flask(__name__) app.config.from_object(Config) db.init_app(app) migrate.init_app(app, db) login.init_app(app) bootstrap.init_app(app) mail.init_app(app) from app.errors import bp as errors_bp app.register_blueprint(errors_bp) from app.auth import bp as auth_bp app.register_blueprint(auth_bp, url_prefix='/') from app.admin import bp as admin_bp app.register_blueprint(admin_bp, url_prefix='/admin') from app.teacher import bp as teacher_bp app.register_blueprint(teacher_bp, url_prefix='/teacher') from app.student import bp as student_bp app.register_blueprint(student_bp, url_prefix='/student') app.redis = Redis.from_url(app.config['REDIS_URL']) app.solution_queue = rq.Queue('pointer-solutions', connection=app.redis) app.email_queue = rq.Queue('pointer-emails', connection=app.redis) return app
def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(config_class) db.init_app(app) migrate.init_app(app, db) login.init_app(app) mail.init_app(app) bootstrap.init_app(app) moment.init_app(app) babel.init_app(app) app.elasticsearch = (Elasticsearch([app.config["ELASTICSEARCH_URL"]]) if app.config["ELASTICSEARCH_URL"] else None) app.redis = Redis.from_url(app.config["REDIS_URL"]) app.task_queue = rq.Queue("blog-tasks", connection=app.redis) from app.errors import bp as errors_bp # noqa: E402 from app.auth import bp as auth_bp # noqa: E402 from app.main import bp as main_bp # noqa: E402 from app.api import bp as api_bp # noqa: E402 app.register_blueprint(errors_bp) app.register_blueprint(auth_bp, url_prefix="/auth") app.register_blueprint(main_bp) app.register_blueprint(api_bp, url_prefix="/api") if not app.debug and not app.testing: if app.config["MAIL_SERVER"]: auth = None if app.config["MAIL_USERNAME"] or app.config["MAIL_PASSWORD"]: auth = ( app.config["MAIL_USERNAME"], app.config["MAIL_PASSWORD"], ) secure = None if app.config["MAIL_USE_TLS"]: secure = () mail_handler = SMTPHandler( mailhost=(app.config["MAIL_SERVER"], app.config["MAIL_PORT"]), fromaddr="no-reply@" + app.config["MAIL_SERVER"], toaddrs=app.config["ADMINS"], subject="Blog Failure", credentials=auth, secure=secure, ) mail_handler.setLevel(logging.ERROR) app.logger.addHandler(mail_handler) if not os.path.exists("logs"): os.mkdir("logs") file_handler = RotatingFileHandler("logs/blog.log", maxBytes=10240, backupCount=10) file_handler.setFormatter( logging.Formatter("%(asctime)s %(levelname)s: %(message)s " "[in %(pathname)s:%(lineno)d]")) file_handler.setLevel(logging.INFO) app.logger.addHandler(file_handler) app.logger.setLevel(logging.INFO) app.logger.info("Blog startup") return app
def create_app(): duchess = Flask(__name__, static_url_path='/static', static_folder='assets') env = os.getenv('DUCHESS_ENV', 'Development') try: duchess.config.from_object('config.%s' % env) except ImportError: # Assuming Heroku duchess.config.update( APP_DIR=os.path.abspath(os.path.dirname(__file__)), PROJECT_ROOT=os.path.abspath( os.path.join(os.path.dirname(__file__), os.pardir) ), SECRET_KEY=os.urandom(24), DEBUG=bool(os.getenv('DEBUG')), REDIS_URL=os.getenv('REDISCLOUD_URL'), ) duchess.redis = Redis(duchess) if duchess.debug: from flask.ext.debugtoolbar import DebugToolbarExtension DebugToolbarExtension(duchess) autocompiler.watch_assets('duchess/assets') init_views(duchess) duchess.register_blueprint(api_router) return duchess
def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(config_class) app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('pi_task', connection=app.redis) cors.init_app(app) db.init_app(app) migrate.init_app(app, db) mail.init_app(app) from app.api.usuario import bp as usuario_bp app.register_blueprint(usuario_bp, url_prefix='/usuario') from app.api.login import bp as login_bp app.register_blueprint(login_bp, url_prefix='/login') from app.api.salas import bp as salas_bp app.register_blueprint(salas_bp, url_prefix='/salas') from app.api.tag import bp as tag_bp app.register_blueprint(tag_bp, url_prefix='/tag') from app.api.email import bp as email_bp app.register_blueprint(email_bp, url_prefix='/email') from app.api.agendamento import bp as agendamento_bp app.register_blueprint(agendamento_bp, url_prefix='/agendamento') return app
def init_app(config_name): """项目的初始化功能""" app = Flask(__name__) # 终端脚本工具 app.manager = Manager(app) # 启用数据迁移工具 Migrate(app, db) # 添加数据迁移的命令到终端脚本工具中 app.manager.add_command('db', MigrateCommand) # 设置配置类 Config = config.get(config_name) # 加载配置类 Config = config.get(config_name) # redis的链接初始化 app.redis = get_redis_connection(Config.REDIS.get("default")) # 开启session功能 Session(app) # 配置数据库连接 db.init_app(app) # 启动日志 setup_log(Config) return app
def create_app(debug=False, simulate=False): """Create an application context with blueprints.""" app = Flask(__name__, static_folder='./resources') app.config['SECRET_KEY'] = 'iqR2cYJp93PuuO8VbK1Z' app.config['MONGO_DBNAME'] = 'cloud_cafe' app.config['BREWS_COLLECTION'] = 'brews' app.config['HISTORY_COLLECTION'] = 'history' app.config['INVENTORY_COLLECTION'] = 'inventory' app.config['PROFILE_COLLECTION'] = 'profiles' app.config['USERS_COLLECTION'] = 'accounts' app.config['SIMULATE_ROAST'] = simulate app.config['MONGO_URI'] = os.environ.get('MONGO_URI') app.config['REDIS_HOST'] = os.environ.get('REDIS_HOST') app.redis = Redis(host='redis') login_manager.init_app(app) mongo.init_app(app) sio.init_app(app) from .core import core as core_blueprint app.register_blueprint(core_blueprint) if simulate: ht.set_simulate(True) return app
def app(): app = Flask(__name__) server = fakeredis.FakeServer() server.connected = True app.redis = fakeredis.FakeStrictRedis(server=server) app.app_context().push() yield app
def create_app(): app = Flask(__name__) app.config.from_object(os.environ['APP_SETTINGS']) # Necessary to support signalling app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True # allows visiting of say, /admin, not requiring the trailing # slash, which is the default. I.e., by default, /admin/ is # required which is annoying app.url_map.strict_slashes = False app.redis = Redis.from_url(app.config['REDIS_URL']) app.extract_queue = rq.Queue('extract', connection=app.redis) app.compare_queue = rq.Queue('compare', connection=app.redis) socketio.init_app(app, cors_allowed_origins="*", message_queue=app.config['REDIS_URL']) models.init_app(app) # inits db admin.init_app(app) cors.init_app(app) # TODO: Required on blueprints as well? routes.init_app(app) services.init_app(app) @app.shell_context_processor def ctx(): return {"app": app, "db": models.db} return app
def create_app(config_class=Config): app = Flask(__name__, template_folder='templates') # app.config.from_object(config_class) # commands # cli.register(microblog) # Initialize extensions initialize_extensions(app) # Register blueprints register_blueprints(app) app.elasticsearch = El([app.config['ELASTICSEARCH_URL'] ]) if app.config['ELASTICSEARCH_URL'] else None # logging if app.config.get('LOG_TO_STDOUT'): # from microblog.extensions import stream_handler app.logger.addHandler(stream_handler) else: # from microblog.extensions import file_handler app.logger.addHandler(file_handler) app.logger.setLevel(logging.INFO) app.logger.info("Microblog startup.") # Redis queue initialization app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('microblog-tasks', connection=app.redis) return app
def create_app(config): global app app = Flask( __name__, template_folder='../templates', static_folder='../static' ) app.wsgi_app = ProxyFix(app.wsgi_app) app.config.update(config) app.url_rule_class = GeneratorRule app.redis = redis.Redis.from_url(config['REDISCLOUD_URL']) import views import login import login_oauth import talks import program import entrant import vote import filters import presenters_go import service return app
def create_app(testing=False): if not testing: if not os.path.exists('logs'): os.makedirs('logs') fileConfig(os.path.abspath(os.path.dirname(__file__)) + '/logging.cfg') app = Flask(__name__) app.config.from_object(Config) Bootstrap(app) Session(app) FontAwesome(app) app.config["TESTING"] = testing app.register_blueprint(BP_HOMEPAGE) app.register_blueprint(BP_EXPLORER, url_prefix='/explorer') app.register_blueprint(BP_TABOO, url_prefix='/taboo') app.register_blueprint(BP_TASKS, url_prefix='/tasks') app.register_blueprint(BP_CODENAMES, url_prefix="/codenames") app.register_blueprint(BP_QUESTIONS, url_prefix="/questions") logger = create_logger(app) if testing: logger.setLevel(logging.DEBUG) DB.init_app(app) with app.app_context(): create_all_db() app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('quasimodo-tasks', connection=app.redis, default_timeout=50000) @app.before_request # pylint: disable=unused-variable def log_the_request(): if not app.config["TESTING"]: logger.info("\t".join([get_ip(), request.url, str(request.data)])) return app
def create_app(configfile=None): app = Flask(__name__) app.config.from_object("app.config.Config") sentry_sdk.init(app.config["SENTRY_URL"], integrations=[FlaskIntegration()], traces_sample_rate=app.config["SENTRY_RATE"]) app.redis = redis.from_url(app.config['REDISTOGO_URL']) app.task_queue = rq.Queue( app.config['REDIS_QUEUES'], connection=app.redis, default_timeout=3600) # app.task_queue.failed_job_registry.requeue() app.scheduler = Scheduler(connection=app.redis, queue=app.task_queue) Bootstrap(app) from app.frontend import public_bp app.register_blueprint(public_bp) # app.config.from_object(rqmonitor.defaults) # app.config['RQ_MONITOR_REDIS_URL'] = app.config['REDISTOGO_URL'] # app.register_blueprint(rqmonitor.monitor_blueprint, url_prefix="/rq") # app.config.from_object(rq_dashboard.default_settings) # app.config['RQ_DASHBOARD_REDIS_URL'] = app.config['REDISTOGO_URL'] # app.register_blueprint(rq_dashboard.blueprint, url_prefix="/rqd") # app.config.from_object(rq_scheduler_dashboard.default_settings) # app.register_blueprint( # rq_scheduler_dashboard.blueprint, url_prefix="/rqsd") return app
def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(config_class) app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('microblog-tasks', connection=app.redis) db.init_app(app) migrate.init_app(app, db) login.init_app(app) mail.init_app(app) bootstrap.init_app(app) moment.init_app(app) app.elasticsearch = Elasticsearch([app.config['ELASTICSEARCH_URL']]) \ if app.config['ELASTICSEARCH_URL'] else None from app.api import bp as api_bp app.register_blueprint(api_bp, url_prefix='/api') from app.errors import bp as errors_bp app.register_blueprint(errors_bp) from app.auth import bp as auth_bp app.register_blueprint(auth_bp, url_prefix='/auth') from app.main import bp as main_bp app.register_blueprint(main_bp) if not app.debug and not app.testing: if app.config['MAIL_SERVER']: auth = None if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']: auth = (app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD']) secure = None if app.config['MAIL_USE_TLS']: secure = () mail_handler = SMTPHandler( mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']), fromaddr='no-reply@' + app.config['MAIL_SERVER'], toaddrs=app.config['ADMINS'], subject='Microblog Failure', credentials=auth, secure=secure) mail_handler.setLevel(logging.ERROR) app.logger.addHandler(mail_handler) if not os.path.exists('logs'): os.mkdir('logs') file_handler = RotatingFileHandler('logs/microblog.log', maxBytes=10240, backupCount=10) file_handler.setFormatter( logging.Formatter('%(asctime)s %(levelname)s: %(message)s ' '[in %(pathname)s:%(lineno)d]')) file_handler.setLevel(logging.INFO) app.logger.addHandler(file_handler) app.logger.setLevel(logging.INFO) app.logger.info('Microblog startup') return app
def create_app(app_name='web_app'): app = Flask(app_name) CORS(app) app.config['DEBUG'] = True app.register_blueprint(api) app.redis = redis.StrictRedis(host='localhost', port=6379, db=0) return app
def create_app(log_level="INFO", config="config.yml"): app = Flask(__name__) app.secret_key = 'test' app.config.from_object(__name__) config_vars = yaml.load(open(root + '/config.yml')) # inject all the yaml configs app.config.update(config_vars) db.init_app(app) Migrate(app, db) # Setup redis redis_config = app.config.get('redis_conn', dict(type='live')) typ = redis_config.pop('type') if typ == "mock_redis": from mockredis import mock_redis_client app.redis = mock_redis_client() else: app.redis = Redis(**redis_config) del app.logger.handlers[0] app.logger.setLevel(logging.NOTSET) log_format = logging.Formatter('%(asctime)s [%(name)s] [%(levelname)s]: %(message)s') log_level = getattr(logging, str(log_level), app.config.get('log_level', "INFO")) logger = logging.getLogger() logger.setLevel(log_level) handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(log_format) logger.addHandler(handler) # Dynamically add all the filters in the filters.py file for name, func in inspect.getmembers(filters, inspect.isfunction): app.jinja_env.filters[name] = func app.rpc_connection = Proxy( "http://{0}:{1}@{2}:{3}/" .format(app.config['coinserv']['username'], app.config['coinserv']['password'], app.config['coinserv']['address'], app.config['coinserv']['port']) ) from . import views app.register_blueprint(views.main) return app
def create_app(): """Return an instance of the main Flask application.""" app = Flask(package_name) # TODO: do some config app.redis = StrictRedis() from .error import register_error_handler, html_handler register_error_handler(app, html_handler) from .session import LazyRedisSessionInterface app.session_interface = LazyRedisSessionInterface() from .views import views app.register_blueprint(views) return app
def create_app(config): global app application = Flask(__name__) application.secret_key = "jednadvehonzajde" application.config.update(config) application.redis = redis.Redis() app = application import views import login import login_oauth import talks import filters return app
def create_app(setting, debug=False): app = Flask(__name__) app.config.from_object(setting) app.debug = debug app.redis = redis.StrictRedis(host=setting.REDIS_HOST, port=setting.REDIS_PORT, db=0) Cache.redis = app.redis # users routes user_view = UserHandler.as_view('user_api') app.add_url_rule( '/user/', view_func=user_view, methods=['POST'] ) app.add_url_rule( '/user/<string:name>', view_func=user_view, methods=['GET', 'PUT', 'DELETE'] ) # urls routes url_view = UrlHandler.as_view('url_api') app.add_url_rule( '/user/<string:name>/url', view_func=url_view, methods=['POST'] ) app.add_url_rule( '/user/<string:name>/url/<string:shortened>', view_func=url_view, methods=['GET', 'PUT', 'DELETE'] ) # redirect routes url_view = RedirectHandler.as_view('redirect_api') app.add_url_rule( '/<string:shortened>', view_func=url_view, methods=['GET'] ) db.init_app(app) return app
def create_app(): app = Flask(__name__) app.config.from_pyfile('settings.cfg') app.config.from_pyfile('local_settings.cfg', silent=True) app.redis = StrictRedis(db=app.config['REDIS_DB']) assets = Environment(app) assets.config['stylus_plugins'] = ['nib'] assets.config['stylus_extra_args'] = ['--inline', '--include', 'static'] assets.register( 'css', '../styles/normalize.styl', '../styles/screen.styl', filters='stylus,cssmin', output='gen/screen.css') assets.register( 'pinmeal', 'vendor/jquery-1.8.2.js', 'vendor/underscore.js', 'vendor/backbone.js', 'vendor/handlebars.runtime-1.0.rc.1.js', Bundle( '../scripts/spot*.handlebars', depends='dummy', # to work around a webassets caching bug filters='handlebars', output='gen/pinmeal-handlebars.js'), Bundle( '../scripts/pinmeal.coffee', filters='coffeescript', output='gen/pinmeal-coffee.js'), filters='uglifyjs', output='gen/pinmeal.js') from main import main app.register_blueprint(main) #from pinmeal import pinmeal #app.register_blueprint(pinmeal, url_prefix='/pinmeal') return app
import os import redis from flask import Flask from flask import request, redirect, render_template, url_for from flask import Response app = Flask(__name__) app.redis = redis.StrictRedis(host='db', port=6379, db=0) # Be super aggressive about saving for the development environment. # This says save every second if there is at least 1 change. If you use # redis in production you'll want to read up on the redis persistence # model. app.redis.config_set('save', '1 1') @app.route('/', methods=['GET', 'POST']) def main_page(): if request.method == 'POST': app.redis.lpush('entries', request.form['entry']) return redirect(url_for('main_page')) else: entries = app.redis.lrange('entries', 0, -1) return render_template('main.html', entries=entries) @app.route('/clear', methods=['POST']) def clear_entries(): app.redis.ltrim('entries', 1, 0) return redirect(url_for('main_page')) if __name__ == "__main__":
def create_app(testing=False, live=False): from bhs_api.models import User, Role from bhs_api.forms import LoginForm app = Flask(__name__) app.testing = testing # load the config file conf = get_conf() app.conf = conf # Our config - need to move everything here app.config['VIDEO_BUCKET_URL'] = "https://storage.googleapis.com/bhs-movies" app.config['IMAGE_BUCKET_URL'] = "https://storage.googleapis.com/bhs-flat-pics" # Set app config app.config['DEBUG'] = True app.config['FRONTEND_SERVER'] = conf.frontend_server app.config['DEFAULT_NEXT'] = '/mjs' # Security Config app.config['SECRET_KEY'] = conf.secret_key app.config['WTF_CSRF_ENABLED'] = False app.config['SECURITY_PASSWORDLESS'] = True app.config['SECURITY_EMAIL_SENDER'] = 'BH Databases<*****@*****.**>' app.config['SECURITY_USER_IDENTITY_ATTRIBUTES'] = 'email' app.config['SECURITY_EMAIL_SUBJECT_PASSWORDLESS'] = 'Login link for Your Jewish Story' app.config['SECURITY_POST_LOGIN_VIEW'] = '/mjs' app.config['SECURITY_USER_IDENTITY_ATTRIBUTES'] = ('email', 'username', 'hash') # Mail Config app.config['MAIL_SERVER'] = conf.mail_server app.config['MAIL_PORT'] = conf.mail_port # Mail optional username and password try: app.config['MAIL_USERNAME'] = conf.mail_username app.config['MAIL_PASSWORD'] = conf.mail_password except AttributeError: pass # DB Config app.config['MONGODB_DB'] = conf.user_db_name app.config['MONGODB_HOST'] = conf.user_db_host app.config['MONGODB_PORT'] = conf.user_db_port # Redis app.config['REDIS_HOST'] = conf.redis_host app.config['REDIS_PORT'] = conf.redis_port app.config['REDIS_PASSWORD'] = getattr(conf, 'redis_password', None) # CACHING app.config['CACHING_TTL'] = conf.caching_ttl app.mail = Mail(app) app.db = MongoEngine(app) app.user_datastore = MongoEngineUserDatastore(app.db, User, Role) app.security = Security(app, app.user_datastore, passwordless_login_form=LoginForm) # Create database connection object app.client_data_db = pymongo.MongoClient(conf.data_db_host, conf.data_db_port, read_preference=pymongo.ReadPreference.SECONDARY_PREFERRED) app.data_db = app.client_data_db[conf.data_db_name] # Create the elasticsearch connection app.es = elasticsearch.Elasticsearch(conf.elasticsearch_host) app.es_data_db_index_name = getattr(conf, "elasticsearch_data_index", app.data_db.name) # Add the user's endpoints from bhs_api.user import user_endpoints app.register_blueprint(user_endpoints) # Add the v1 endpoint from bhs_api.v1_endpoints import v1_endpoints app.register_blueprint(v1_endpoints, url_prefix='/v1') # Initialize autodoc - https://github.com/acoomans/flask-autodoc #allow CORS cors = CORS(app, origins=['*'], headers=['content-type', 'accept', 'authentication-token', 'Authorization']) # logging if live: app.config['PROPAGATE_EXCEPTIONS'] = True try: fh = logging.FileHandler(conf.log_file) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') fh.setFormatter(formatter) app.logger.addHandler(fh) except AttributeError: pass # redis try: app.redis = redis.StrictRedis(host=conf.redis_host, port=conf.redis_port, password = app.config['REDIS_PASSWORD'], db=0) except AttributeError: app.redis = None return app, conf
# -*- coding: utf-8 -*- from flask import Flask, current_app, render_template import redis import time import json REDIS_HOST = '127.0.0.1' REDIS_PORT = 6379 app = Flask(__name__) app.debug = True app.redis = None app.ds = { 'name': 'ds-articles-ok' } @app.before_first_request def first(): current_app.redis = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT) @app.route('/', methods=['GET']) def welcome(): now = int(time.time()) items = current_app.redis.zrange(current_app.ds['name'], 0, now) return render_template('index.html', keys=[json.loads(item) for item in items]) if __name__ == '__main__':
from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.login import LoginManager from flask.ext.principal import Principal from redis import Redis app = Flask(__name__) app.config.from_object('config') db = SQLAlchemy(app) login_manager = LoginManager() login_manager.init_app(app) principals = Principal(app) # init redis and set as a app internal variable app.redis = Redis(host=app.config.get('REDIS_HOST', None), port=app.config.get('REDIS_PORT', None), password=app.config.get('REDIS_PASS', None)) from saulify import views, models
def create_app(mode, configs=None, log_level=None, **kwargs): # Allow configuration information to be specified with enviroment vars env_configs = {} for key in os.environ: if key.startswith('SIMPLECOIN_CONFIG'): env_configs[key] = os.environ[key] env_configs = [env_configs[value] for value in sorted(env_configs)] configs = ['defaults.toml'] + (env_configs or []) + (configs or []) if len(configs) == 1: print("Unable to start with only the default config values! {}" .format(configs)) exit(2) config_vars = {} for config in configs: if isinstance(config, basestring): if os.path.isabs(config): config_path = config else: config_path = os.path.join(root, config) config = open(config_path) updates = toml.loads(config.read()) toml.toml_merge_dict(config_vars, updates) # Initialize our flask application # ======================================================================= app = Flask(__name__, static_folder='../static', static_url_path='/static') app.jinja_loader = FileSystemLoader(os.path.join(root, 'templates')) # Objectizes all configurations # ======================================================================= ConfigChecker(config_vars, app) # Setup logging # ======================================================================= del app.logger.handlers[0] app.logger.setLevel(logging.NOTSET) log_format = logging.Formatter('%(asctime)s [%(name)s] [%(levelname)s]: %(message)s') log_level = getattr(logging, str(log_level), app.config['log_level']) logger = logging.getLogger() logger.setLevel(log_level) handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(log_format) logger.addHandler(handler) # Handle optionally adding log file writers for each different run mode # ======================================================================= if mode == "manage" and app.config['manage_log_file']: hdlr = logging.FileHandler(app.config['manage_log_file']) hdlr.setFormatter(log_format) logger.addHandler(hdlr) if mode == "scheduler" and app.config['scheduler_log_file']: hdlr = logging.FileHandler(app.config['scheduler_log_file']) hdlr.setFormatter(log_format) logger.addHandler(hdlr) if mode == "webserver" and app.config['webserver_log_file']: hdlr = logging.FileHandler(app.config['webserver_log_file']) hdlr.setFormatter(log_format) logger.addHandler(hdlr) logging.getLogger("gunicorn.access").setLevel(logging.WARN) logging.getLogger("requests.packages.urllib3.connectionpool").setLevel(logging.INFO) # Add the debug toolbar if we're in debug mode # ======================================================================= if app.config['DEBUG'] and mode == "webserver": # Log all stdout and stderr when in debug mode for convenience class LoggerWriter: def __init__(self, logger, level): self.logger = logger self.level = level def write(self, message): if message != '\n': self.logger.log(self.level, message) sys.stdout = LoggerWriter(app.logger, logging.DEBUG) sys.stderr = LoggerWriter(app.logger, logging.DEBUG) # Register the powerpool datastore + Cache # ======================================================================= db.init_app(app) babel.init_app(app) app.config['BABEL_DEFAULT_LOCALE'] = app.config.get('default_locale') def configure_redis(config): typ = config.pop('type') if typ == "mock_redis": from mockredis import mock_redis_client return mock_redis_client() return Redis(**config) cache_config = app.config.get('main_cache', dict(type='live')) cache_redis = configure_redis(cache_config) ds_config = app.config.get('redis_conn', dict(type='live')) ds_redis = configure_redis(ds_config) # Take advantage of the fact that werkzeug lets the host kwargs be a Redis # compatible object cache.init_app(app, config=dict(CACHE_TYPE='redis', CACHE_REDIS_HOST=cache_redis)) app.redis = ds_redis sentry = False if app.config.get('sentry'): try: from raven.contrib.flask import Sentry sentry = Sentry() except Exception: app.logger.error("Unable to initialize sentry!") # Helpful global vars # ======================================================================= app.SATOSHI = Decimal('0.00000001') app.MAX_DECIMALS = 28 # Configure app for running manage.py functions # ======================================================================= if mode == "manage" or mode == "webserver": # Dynamically add all the filters in the filters.py file for name, func in inspect.getmembers(filters, inspect.isfunction): app.jinja_env.filters[name] = func if mode == "manage": # Initialize the migration settings Migrate(app, db) # Disable for management mode if sentry: sentry = False # Configure app for serving web content # ======================================================================= elif mode == "webserver": # try and fetch the git version information try: output = subprocess.check_output("git show -s --format='%ci %h'", shell=True).strip().rsplit(" ", 1) app.config['hash'] = output[1] app.config['revdate'] = output[0] # celery won't work with this, so set some default except Exception: app.config['hash'] = '' app.config['revdate'] = '' app.logger.info("Starting up SimpleCoin!\n{}".format("=" * 100)) # Configure app for running scheduler.py functions + instantiate scheduler # ======================================================================= elif mode == "scheduler": if sentry and 'SENTRY_NAME' in app.config: app.config['SENTRY_NAME'] = app.config['SENTRY_NAME'] + "_scheduler" app.logger.info("=" * 80) app.logger.info("SimpleCoin cron scheduler starting up...") setproctitle.setproctitle("simplecoin_scheduler") sched = Scheduler(standalone=True) # monkey patch the scheduler to wrap each job call in its own flask # context. Kind of sloppy way to pass in the app context... Scheduler.app = app Scheduler._old_run_job = Scheduler._run_job def _run_job(self, *args, **kwargs): with self.app.app_context(): Scheduler._old_run_job(self, *args, **kwargs) Scheduler._run_job = _run_job stage_tasks = set(["cache_profitability", "leaderboard", "server_status", "update_network", "cache_user_donation", "update_online_workers"]) for task_config in app.config['tasks']: if not task_config.get('enabled', False): continue if app.config['stage'] and task_config['name'] not in stage_tasks: app.logger.debug( "Skipping scheduling {} because in stage mode!" .format(task_config['name'])) continue stripped_config = task_config.copy() del stripped_config['enabled'] task = getattr(sch, task_config['name']) sched.add_cron_job(task, **stripped_config) app.scheduler = sched if sentry: sentry.init_app(app, logging=True, level=logging.ERROR) # Route registration # ======================================================================= from . import views, models, api, rpc_views app.register_blueprint(views.main) app.register_blueprint(rpc_views.rpc_views) app.register_blueprint(api.api, url_prefix='/api') return app
def create_instance(): """ Construct a new Flask instance and return it. """ import os app = Flask(__name__) app.config.from_object('notifico.default_config') if app.config.get('NOTIFICO_ROUTE_STATIC'): # We should handle routing for static assets ourself (handy for # small and quick deployments). import os.path from werkzeug import SharedDataMiddleware app.wsgi_app = SharedDataMiddleware(app.wsgi_app, { '/': os.path.join(os.path.dirname(__file__), 'static') }) if not app.debug: # If sentry (http://getsentry.com) is configured for # error collection we should use it. if app.config.get('SENTRY_DSN'): sentry.dsn = app.config.get('SENTRY_DSN') sentry.init_app(app) # Setup our redis connection (which is already thread safe) app.redis = Redis( host=app.config['REDIS_HOST'], port=app.config['REDIS_PORT'], db=app.config['REDIS_DB'] ) # Attach Flask-Cache to our application instance. We override # the backend configuration settings because we only want one # Redis instance. cache.init_app(app, config={ 'CACHE_TYPE': 'redis', 'CACHE_REDIS_HOST': app.redis, 'CACHE_OPTIONS': { 'key_prefix': 'cache_' } }) # Attach Flask-Mail to our application instance. mail.init_app(app) # Attach Flask-SQLAlchemy to our application instance. db.init_app(app) # Update celery's configuration with our application config. celery.config_from_object(app.config) # Import and register all of our blueprints. from notifico.views.account import account from notifico.views.public import public from notifico.views.projects import projects from notifico.views.pimport import pimport from notifico.views.admin import admin app.register_blueprint(account, url_prefix='/u') app.register_blueprint(projects) app.register_blueprint(public) app.register_blueprint(pimport, url_prefix='/i') app.register_blueprint(admin, url_prefix='/_') # Register our custom error handlers. from notifico.views import errors app.error_handler_spec[None][500] = errors.error_500 # cia.vc XML-RPC kludge. from notifico.services.hooks.cia import handler handler.connect(app, '/RPC2') # Setup some custom Jinja2 filters. app.jinja_env.filters['pretty_date'] = pretty.pretty_date app.jinja_env.filters['plural'] = pretty.plural app.jinja_env.filters['fix_link'] = pretty.fix_link return app
# -*- coding: utf-8 -*- import os import redis from flask import Flask from flask import Response from flask import json app = Flask(__name__) app.redis = redis.StrictRedis(host=os.getenv('WERCKER_REDIS_HOST', 'localhost'), port= 6379, db=0) @app.route("/clouds.json") def clouds(): data = app.redis.lrange("clouds", 0, -1) resp = Response(json.dumps(data), status=200, mimetype='application/json') return resp if __name__ == "__main__": port = int(os.getenv('PORT', 5000)) app.run(host='0.0.0.0', port=port)
def create_app(mode, configs=None, log_level=None, **kwargs): # Allow configuration information to be specified with enviroment vars env_configs = {} for key in os.environ: if key.startswith('SIMPLECOIN_CONFIG'): env_configs[key] = os.environ[key] env_configs = [env_configs[value] for value in sorted(env_configs)] configs = ['defaults.toml'] + (env_configs or []) + (configs or []) if len(configs) == 1: print("Unable to start with only the default config values! {}" .format(configs)) exit(2) config_vars = {} for config in configs: if isinstance(config, basestring): if os.path.isabs(config): config_path = config else: config_path = os.path.join(root, config) config = open(config_path) updates = toml.loads(config.read()) toml.toml_merge_dict(config_vars, updates) # Initialize our flask application # ======================================================================= app = Flask(__name__, static_folder='../static', static_url_path='/static') app.jinja_loader = FileSystemLoader(os.path.join(root, 'templates')) # Objectizes all configurations # ======================================================================= ConfigChecker(config_vars, app) # Setup logging # ======================================================================= del app.logger.handlers[0] app.logger.setLevel(logging.NOTSET) log_format = logging.Formatter('%(asctime)s [%(name)s] [%(levelname)s]: %(message)s') log_level = getattr(logging, str(log_level), app.config['log_level']) logger = logging.getLogger() logger.setLevel(log_level) handler = logging.StreamHandler(stream=sys.stdout) handler.setFormatter(log_format) logger.addHandler(handler) # Handle optionally adding log file writers for each different run mode # ======================================================================= if mode == "manage" and app.config['manage_log_file']: hdlr = logging.FileHandler(app.config['manage_log_file']) hdlr.setFormatter(log_format) logger.addHandler(hdlr) if mode == "scheduler" and app.config['scheduler_log_file']: hdlr = logging.FileHandler(app.config['scheduler_log_file']) hdlr.setFormatter(log_format) logger.addHandler(hdlr) if mode == "webserver" and app.config['webserver_log_file']: hdlr = logging.FileHandler(app.config['webserver_log_file']) hdlr.setFormatter(log_format) logger.addHandler(hdlr) logging.getLogger("gunicorn.access").setLevel(logging.WARN) logging.getLogger("requests.packages.urllib3.connectionpool").setLevel(logging.INFO) # Add the debug toolbar if we're in debug mode # ======================================================================= if app.config['DEBUG'] and mode == "webserver": # Log all stdout and stderr when in debug mode for convenience class LoggerWriter: def __init__(self, logger, level): self.logger = logger self.level = level def write(self, message): if message != '\n': self.logger.log(self.level, message) sys.stdout = LoggerWriter(app.logger, logging.DEBUG) sys.stderr = LoggerWriter(app.logger, logging.DEBUG) # Register the powerpool datastore + Cache # ======================================================================= db.init_app(app) def configure_redis(config): typ = config.pop('type') if typ == "mock_redis": from mockredis import mock_redis_client return mock_redis_client() return Redis(**config) cache_config = app.config.get('main_cache', dict(type='live')) cache_redis = configure_redis(cache_config) ds_config = app.config.get('redis_conn', dict(type='live')) ds_redis = configure_redis(ds_config) # Take advantage of the fact that werkzeug lets the host kwargs be a Redis # compatible object cache.init_app(app, config=dict(CACHE_TYPE='redis', CACHE_REDIS_HOST=cache_redis)) app.redis = ds_redis sentry = False if app.config.get('sentry'): try: from raven.contrib.flask import Sentry sentry = Sentry() except Exception: app.logger.error("Unable to initialize sentry!") # Helpful global vars # ======================================================================= app.SATOSHI = Decimal('0.00000001') app.MAX_DECIMALS = 28 # Configure app for running manage.py functions # ======================================================================= if mode == "manage" or mode == "webserver": # Dynamically add all the filters in the filters.py file for name, func in inspect.getmembers(filters, inspect.isfunction): app.jinja_env.filters[name] = func if mode == "manage": # Initialize the migration settings Migrate(app, db) # Disable for management mode if sentry: sentry = False # Configure app for serving web content # ======================================================================= elif mode == "webserver": # try and fetch the git version information try: output = subprocess.check_output("git show -s --format='%ci %h'", shell=True).strip().rsplit(" ", 1) app.config['hash'] = output[1] app.config['revdate'] = output[0] # celery won't work with this, so set some default except Exception: app.config['hash'] = '' app.config['revdate'] = '' app.logger.info("Starting up SimpleCoin!\n{}".format("=" * 100)) # Configure app for running scheduler.py functions + instantiate scheduler # ======================================================================= elif mode == "scheduler": if sentry and 'SENTRY_NAME' in app.config: app.config['SENTRY_NAME'] = app.config['SENTRY_NAME'] + "_scheduler" app.logger.info("=" * 80) app.logger.info("SimpleCoin cron scheduler starting up...") setproctitle.setproctitle("simplecoin_scheduler") # Make app accessible from out monkey patched code. Messy.... ThreadPool.app = app sched = Scheduler(standalone=True) # monkey patch the thread pool for flask contexts ThreadPool._old_run_jobs = ThreadPool._run_jobs def _run_jobs(self, core): self.app.logger.debug("Starting patched threadpool worker!") with self.app.app_context(): ThreadPool._old_run_jobs(self, core) ThreadPool._run_jobs = _run_jobs # All these tasks actually change the database, and shouldn't # be run by the staging server if not app.config.get('stage', False): sched.add_cron_job(sch.compress_slices, minute='0,15,30,45', second=35) # every minute at 55 seconds after the minute sched.add_cron_job(sch.generate_credits, second=55) sched.add_cron_job(sch.create_trade_req, args=("sell",), minute=1, hour="0,6,12,18") sched.add_cron_job(sch.create_trade_req, args=("buy",), minute=1, hour="0,6,12,18") # every minute at 55 seconds after the minute sched.add_cron_job(sch.collect_minutes, second=35) sched.add_cron_job(sch.collect_ppagent_data, second=40) # every five minutes 20 seconds after the minute sched.add_cron_job(sch.compress_minute, minute='0,5,10,15,20,25,30,35,40,45,50,55', second=20) # every hour 2.5 minutes after the hour sched.add_cron_job(sch.compress_five_minute, minute=2, second=30) # every minute 2 seconds after the minute sched.add_cron_job(sch.update_block_state, second=2) # every day sched.add_cron_job(sch.update_block_state, hour=0, second=0, minute=3) else: app.logger.info("Stage mode has been set in the configuration, not " "running scheduled database altering cron tasks") sched.add_cron_job(sch.update_online_workers, minute='0,5,10,15,20,25,30,35,40,45,50,55', second=30) sched.add_cron_job(sch.cache_user_donation, minute='0,15,30,45', second=15) sched.add_cron_job(sch.server_status, second=15) # every 15 minutes 2 seconds after the minute sched.add_cron_job(sch.leaderboard, minute='0,5,10,15,20,25,30,35,40,45,50,55', second=30) app.scheduler = sched if sentry: sentry.init_app(app, logging=True, level=logging.ERROR) # Route registration # ======================================================================= from . import views, models, api, rpc_views app.register_blueprint(views.main) app.register_blueprint(rpc_views.rpc_views) app.register_blueprint(api.api, url_prefix='/api') return app
# 创建基于 Flask 的应用程序 app = Flask('tongbupan') from werkzeug.contrib.fixers import ProxyFix app.wsgi_app = ProxyFix(app.wsgi_app) app.config.from_object(config) app.debug = app.config.get('DEBUG', False) app.secret_key = app.config['SECRET_KEY'] app.selnk_key = app.config["SELNK_KEY"] assets = Assets(app) from redis import Redis app.redis = Redis(app.config['REDIS_HOST'], app.config['REDIS_PORT'], app.config['REDIS_DB'], app.config['REDIS_PASSWORD']) app.session_interface = RedisSessionInterface(app.redis) from lib.cache import init_cache init_cache(app) from flask.ext.pymongo import PyMongo app.mongo = PyMongo(app, config_prefix='MONGO') from lib.tokenstore import RedisTokenStore RedisTokenStore.setup_store(app) # 初始化进程全局的数据模型对象 models.setup(app)
from werkzeug import secure_filename import flask import utils import json from hanzi import Hanzi from flask import current_app import redis import HanziMatcher import sys ALLOWED_EXTENSIONS = set(['txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif']) app = Flask(__name__) app.config.from_pyfile('config.py') print app.config app.redis = redis.StrictRedis(host=app.config['REDIS_HOST'],port=app.config['REDIS_PORT'], db=0) #print app.hanzi_list #app.config['LABELED_DATASET_PATH'] = LABELED_DATASET_PATH #= set(map(lambda x:x.decode('utf-8'), os.listdir(app.config['LABELED_DATASET_PATH']) )) #app.hanzi_list = utils.read_handwriting(os.path.join("./","handwriting.txt")) #if not app.debug: #app.debug = True import logging from logging import FileHandler file_handler = FileHandler(app.config['LOG_FILE_PATH'],encoding='utf-8') #file_handler.setLevel(logging.ERROR)
Redis will set up a connection pooler automatically, but the nano tier of Redis To Go only supports 10 concurrent connections. """ pool = redis.ConnectionPool(host=app.config['REDIS_HOST'], port=app.config['REDIS_PORT'], password=app.config['REDIS_PASSWORD'], db=db, max_connections=max_connections) return redis.Redis(connection_pool=pool) ### ### Global Redis connection. ### app.redis = redis_init() ### ### Hooks. ### @app.before_request def force_ssl(): """Throw an error if the request is not secure.""" criteria = [ app.debug, request.is_secure, request.headers.get('X-Forwarded-Proto', "http") == "https", ]
from __future__ import print_function import os import sys import redis from flask import Flask from flask import jsonify app = Flask(__name__) app.redis = redis.StrictRedis(host=os.getenv('REDIS_HOST', 'localhost'), socket_timeout=5) @app.route('/set', methods=['POST']) def set_value(): try: app.redis.incr('total') except redis.ConnectionError as e: return jsonify({"status": "redis connection error"}) else: return jsonify({"status": "ok"}) @app.route('/get') def get_value(): try: data = app.redis.get('total') except redis.ConnectionError as e: return jsonify({"status": "redis connection error"}) else: return jsonify({"status": "ok", "data": int(data)})
from wtforms import widgets import redis import os app = Flask(__name__) app.config['SECRET_KEY'] = '123456790' app.config['MONGODB_SETTINGS'] = {'DB': 'taobao', "HOST": 'localhost', "PORT": 27017} app.__rootdir__ = os.getcwd() # Create models db = MongoEngine() db.init_app(app) #db.connection.admin.authenticate("root", "chenfuzhi") app.conn = db.connection app.redis = redis.Redis("localhost", 6379) __all__ = ["app", "modes", "api", "views", "cqlui", "blacklist"] from webadmin import *
def create_instance(): """ Construct a new Flask instance and return it. """ import os app = Flask(__name__) app.config.from_object('notifico.default_config') if app.config.get('HANDLE_STATIC'): # We should handle routing for static assets ourself (handy for # small and quick deployments). import os.path from werkzeug import SharedDataMiddleware app.wsgi_app = SharedDataMiddleware(app.wsgi_app, { '/': os.path.join(os.path.dirname(__file__), 'static') }) if not app.debug: # If sentry (http://getsentry.com) is configured for # error collection we should use it. if app.config.get('SENTRY_DSN'): sentry.dsn = app.config.get('SENTRY_DSN') sentry.init_app(app) # Setup our redis connection (which is already thread safe) app.redis = Redis( host=app.config['REDIS_HOST'], port=app.config['REDIS_PORT'], db=app.config['REDIS_DB'] ) cache.init_app(app, config={ 'CACHE_TYPE': 'redis', 'CACHE_REDIS_HOST': app.redis, 'CACHE_OPTIONS': { 'key_prefix': 'cache_' } }) db.init_app(app) with app.app_context(): # Let SQLAlchemy create any missing tables. db.create_all() # Import and register all of our blueprints. from notifico.views.account import account from notifico.views.public import public from notifico.views.projects import projects from notifico.views.pimport import pimport from notifico.views.admin import admin app.register_blueprint(account, url_prefix='/u') app.register_blueprint(projects) app.register_blueprint(public) app.register_blueprint(pimport, url_prefix='/i') app.register_blueprint(admin, url_prefix='/_') # cia.vc XML-RPC kludge. from notifico.services.hooks.cia import handler handler.connect(app, '/RPC2') # Setup some custom Jinja2 filters. app.jinja_env.filters['pretty_date'] = pretty.pretty_date app.jinja_env.filters['plural'] = pretty.plural app.jinja_env.filters['fix_link'] = pretty.fix_link return app
from scrapy.utils.project import get_project_settings from social_scraper.spiders.twitter import TwitterSpider from social_scraper.spiders.fb import FacebookSpider from social_scraper.settings import (API_HOST, API_PORT, API_DEBUG_MODE, CELERY_BROKER_URL, CELERY_IMPORTS, CELERY_RESULT_BACKEND, CELERYD_MAX_TASKS_PER_CHILD, REDIS_HOST, REDIS_PORT) # flask app configuration flask_app = Flask('profile_api') api = restful.Api(flask_app) # database setup flask_app.redis = redis.StrictRedis(REDIS_HOST, port=REDIS_PORT, db=0) # api output json encoding output_json.func_globals['settings'] = {'ensure_ascii': False, 'encoding': 'utf8'} # bind celery to flask app flask_app.config.update(CELERY_BROKER_URL=CELERY_BROKER_URL, CELERY_RESULT_BACKEND=CELERY_RESULT_BACKEND, CELERYD_MAX_TASKS_PER_CHILD=CELERYD_MAX_TASKS_PER_CHILD, CELERY_IMPORTS=CELERY_IMPORTS, ) celery = Celery(flask_app.import_name, broker=flask_app.config['CELERY_BROKER_URL']) celery.conf.update(flask_app.config) # Tasks @celery.task(name='tasks.crawl')
import os import redis from flask import Flask from flask import request, redirect, render_template, url_for from flask import Response app = Flask(__name__) app.redis = redis.StrictRedis(host='127.0.0.1', port=6379, db=0) # Be super aggressive about saving for the development environment. # This says save every second if there is at least 1 change. If you use # redis in production you'll want to read up on the redis persistence # model. app.redis.config_set('save', '1 1') @app.route('/', methods=['GET', 'POST']) def main_page(): if request.method == 'POST': app.redis.lpush('entries', request.form['entry']) return redirect(url_for('main_page')) else: entries = app.redis.lrange('entries', 0, -1) return render_template('main.html', entries=entries) @app.route('/clear', methods=['POST']) def clear_entries(): app.redis.ltrim('entries', 1, 0) return redirect(url_for('main_page')) if __name__ == "__main__":
from flask import Flask #from flask import Response #from flask import json import redis app = Flask(__name__) app.redis = redis.Redis(host='localhost',port=6379,db=0) from app import views
# -*- coding: utf-8 -*- import redis from flask import Flask, g, render_template, current_app from account.helpers import get_current_user from account.views import bp_account from trade.views import bp_trade from fund.views import bp_fund from api.views import bp_api import database app = Flask(__name__) app.config.from_object('settings') app.redis = redis.Redis( host=app.config['REDIS_HOST'], port=app.config['REDIS_PORT'], db=app.config['REDIS_NUM']) app.db = database.Connection( host=app.config['MYSQL_HOST'], database=app.config['MYSQL_DATABASE'], user=app.config['MYSQL_USER'], password=app.config['MYSQL_PASSWORD']) app.register_blueprint(bp_account, url_prefix="/account") app.register_blueprint(bp_trade, url_prefix="/trade") app.register_blueprint(bp_fund, url_prefix="/fund") app.register_blueprint(bp_api, url_prefix="/api") @app.before_request def before_request(): g.user = get_current_user()
from room.views import room from room.events import socketio REDIS_HOST = os.getenv('REDIS_HOST', 'localhost') REDIS_PORT = os.getenv('REDIS_PORT', 6379) REDIS_PASS = os.getenv('REDIS_PASS', None) REDIS_MASTER = os.getenv('REDIS_MASTER', None) DEBUG = os.getenv('DEBUG', True) PORT = int(os.getenv('PORT', '8000')) app = Flask(__name__) app.config['SECRET_KEY'] = '4403dac8-370a-4877-8d24-bab0511dc976' app.config['SESSION_TYPE'] = 'redis' app.register_blueprint(home) app.register_blueprint(room) if REDIS_HOST == 'localhost': app.redis = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0) else: sentinel = Sentinel([(REDIS_HOST, REDIS_PORT)], socket_timeout=0.1, password=REDIS_PASS) app.redis = sentinel.master_for(REDIS_MASTER, socket_timeout=0.1) app.debug = DEBUG socketio.init_app(app) if __name__ == '__main__': socketio.run(app, port=PORT, host='0.0.0.0')
formatter = logging.Formatter('%(asctime)s - %(process)d - %(name)s - %(module)s:%(lineno)d - %(levelname)s - %(message)s') file_handler.setFormatter(formatter) stream_handler.setFormatter(formatter) app.logger.addHandler(file_handler) #app.logger.addHandler(stream_handler) app.logger.setLevel(logging.DEBUG) app.logger.info('Application Process Started') from cchecker_web import cchecker_web app.register_blueprint(cchecker_web, url_prefix='') import redis redis_pool = redis.ConnectionPool(host=app.config.get('REDIS_HOST'), port=app.config.get('REDIS_PORT'), db=app.config.get('REDIS_DB')) app.redis = redis.Redis(connection_pool=redis_pool) redis_connection = app.redis # rq from rq import Queue app.queue = Queue('default', connection=app.redis) @app.context_processor def url_process(): def url_root(): return url_for('.show_root') return {'url_root': url_root} from cchecker_web.utils import setup_uploads setup_uploads(app)