def create_application(default_env='DEVELOPMENT'):
"""
Util method to create a fully configured `Flask app` for
production/development/testing envs. We set all config'd objects
as globals so they can be imported at the module level.
"""
from flask import Flask
from flask_environments import Environments
from flask.ext.mongoengine import MongoEngine
from raven.contrib.flask import Sentry
global application
global env
global db
# Instatiate the app and the environment
application = Flask(__name__)
env = Environments(application, default_env=default_env)
env.from_object('uber.config')
# Instantiate the mongo connection
db = MongoEngine(application)
# Configure Sentry/error logging
sentry = Sentry(
application,
dsn='https://*****:*****@app.getsentry.com/4404'
)
# Import and route all views
from uber.views import index
return application
def create_app(app_config=None):
app = Flask(__name__)
# 读取配置文件
if app_config is None:
env = Environments(app, var_name='env', default_env='None')
env.from_object('app.config')
else:
app.config.from_object(configs[app_config])
# 蓝图注册
register_blueprints(app)
# 扩展注册
register_extensions(app)
# 自定义日期格式，待修改
datetime_format = app.config.get('APIZEN_DATETIME_FMT',
'%Y/%m/%d %H:%M:%S')
CustomJSONEncoder.datetime_format = datetime_format
app.json_encoder = CustomJSONEncoder
@app.route('/', methods=['GET'])
def index():
return '<h1>请直接调用接口</h1>'
return app
def create_app(environment="DEVELOPMENT"):
"""worldofsfx application factory.
This function defines a re-usable pattern for instantiating and creating
application objects.
:param str environment: Specify the name of the configuration object used
to build this application object
Usage::
from worldofsfx import create_app
from unittest import TestCase
class MyTest(TestCase):
def setUp(self):
self.app = create_app(environment="TESTING")
:returns: flask application
:rtype: :obj:`flask.Flask`
"""
if not environment:
env_name = "DEVELOPMENT"
else:
env_name = environment.upper()
app = Flask(__name__)
env = Environments(app, default_env=env_name)
env.from_object("worldofsfx.config")
wos_privates = os.getenv("WOS_PRIVATES")
if wos_privates:
env.from_object(wos_privates)
app.template_folder = app.config.get("TEMPLATE_FOLDER", "templates")
app.register_blueprint(wos)
app.register_blueprint(events)
app.register_blueprint(buzz)
app.register_blueprint(beatport)
db.init_app(app)
return app
class FlaskEnvironmentsTestCase(unittest.TestCase):
DEFAULT_ENV = None
VAR_NAME = None
DATABASE_VALUE = 'development_db'
def setUp(self):
self.app = Flask(__name__)
self.environments = Environments(self.app,
var_name=self.VAR_NAME,
default_env=self.DEFAULT_ENV)
def test_from_object(self):
self.environments.from_object('tests.config')
self.assertEqual(self.app.config['DATABASE'], self.DATABASE_VALUE)
def test_from_yaml(self):
path = os.path.join(os.getcwd(), 'tests', 'config.yml')
self.environments.from_yaml(path)
self.assertEqual(self.app.config['DATABASE'], self.DATABASE_VALUE)
def create_app():
"""
This method create the Flask application.
:return: Flask App Object
"""
global app
global login
app = Flask(__name__, instance_relative_config=True)
flask_env = os.getenv('FLASK_ENV', 'None')
if flask_env == 'development':
config_object = 'config.DevConfig'
elif flask_env == 'testing':
config_object = 'config.TestConfig'
elif flask_env == 'production':
config_object = 'config.ProdConfig'
else:
raise RuntimeError(
"%s is not recognized as valid app environment. You have to setup the environment!"
% flask_env)
# Load config
env = Environments(app)
env.from_object(config_object)
# Configuring redis
create_redis(app)
register_extensions(app)
register_blueprints(app)
register_handlers(app)
# loading login manager
import gooutsafe.auth.login_manager as lm
login = lm.init_login_manager(app)
if flask_env == 'testing' or flask_env == 'development':
register_test_blueprints(app)
return app
def create_app_api():
app = Flask(SERVICE_NAME)
config_env = Environments(app, default_env="DEVELOPMENT")
config_env.from_object('config')
config_redis_ipport = app.config["CONFIG_REDIS_IPPORT"]
config_redis_password = app.config["CONFIG_REDIS_PWD"]
app.config[
'REDIS_URL'] = "redis://:" + config_redis_password + "@" + config_redis_ipport + "/7"
redisService.init_app(app)
api_plus = Api(app,
version="v1.0.0",
title=SERVICE_NAME,
prefix=APP_URL_PREFIX)
# 首先打开（或创建）一个scheduler.lock文件，并加上非阻塞互斥锁。成功后创建scheduler并启动。
f = open("scheduler.lock", "wb")
try:
fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
scheduler = APScheduler()
scheduler.init_app(app)
scheduler.start()
except:
# 如果加文件锁失败，说明scheduler已经创建，就略过创建scheduler的部分。
pass
# 最后注册一个退出事件，如果这个flask项目退出，则解锁并关闭scheduler.lock文件的锁。
def unlock():
fcntl.flock(f, fcntl.LOCK_UN)
f.close()
atexit.register(unlock)
BASIC_URL_PREFIX = "/basic" # stellar基础接口(用户、区块浏览器等相关)
api_plus.add_namespace(basic_ns, BASIC_URL_PREFIX)
return app, api_plus
def create_index(self, name):
try:
self.get_session().execute(
"CREATE INDEX %s_key on stats (%s);" % (name, name)
)
except cassandra.InvalidRequest as e:
print " %s" % e.message
def destroy_all_the_things(self):
# do we REALLY want this method here? or just in the tests?
self.get_session().execute("DROP KEYSPACE %s" % self.keyspace())
def destroy_the_tables(self):
self.get_session().execute("DROP TABLE stats")
def migrate(self):
print "initializing cluster %s in %s" % (self.config['NODES'],
self.config['KEYSPACE'])
self.create_keyspace()
self.create_tables()
self.create_indicies()
print "done."
if __name__ == '__main__':
app = Flask(__name__)
env = Environments(app)
env.from_object('whatsup.config')
migrator = Migrator(app.config)
migrator.migrate()
def create_app():
"""
This method create the Flask application.
:return: Flask App Object
"""
global db
global app
global api_app
global celery
# first initialize the logger
init_logger()
api_app = connexion.FlaskApp(
__name__,
server='flask'
)
# getting the flask app
app = api_app.app
flask_env = os.getenv('FLASK_ENV', 'None')
if flask_env == 'development':
config_object = 'config.DevConfig'
elif flask_env == 'testing':
config_object = 'config.TestConfig'
elif flask_env == 'production':
config_object = 'config.ProdConfig'
else:
raise RuntimeError(
"%s is not recognized as valid app environment. You have to setup the environment!" % flask_env)
# Load config
env = Environments(app)
env.from_object(config_object)
# creating celery
celery = make_celery(app)
# loading communications
import gooutsafe.comm as comm
#if flask_env != 'testing':
comm.init_rabbit_mq()
"""else:
comm.disabled = True"""
if flask_env != 'production':
# disable communication for testing purposes
comm.disabled = True
else:
comm.init_rabbit_mq()
db = MongoEngine(
app=app
)
# requiring the list of models
import gooutsafe.models
# registering to api app all specifications
register_specifications(api_app)
return app
from app.css_assets import non_admin_css_files, admin_css_files, gallery_css_files
from app.js_assets import non_admin_js_files, admin_js_files, gallery_js_files
# Create app
GisApp = Flask(__name__)
Bootstrap(GisApp)
# for using jQuery 2 from cdn instead of jQuery 1
# (https://github.com/mbr/flask-bootstrap/blob/master/docs/faq.rst#how-can-i-use-jquery2-instead-of-jquery1)
GisApp.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'//cdnjs.cloudflare.com/ajax/libs/jquery/2.2.1/')
# GisApp.config.from_object('config')
db = SQLAlchemy(GisApp)
env = Environments(GisApp)
env.from_object('config')
# Assets
assets = Environment(GisApp)
js = Bundle(*non_admin_js_files, filters='jsmin', output='gen/packed.js')
admin_js = Bundle(*admin_js_files,
filters='jsmin',
output='gen/admin_packed.js')
gallery_js = Bundle(*gallery_js_files,
filters='jsmin',
output='gen/gallery_packed.js')
assets.register('application_js', js)
assets.register('admin_application_js', admin_js)
assets.register('gallery_application_js', gallery_js)
from celery import Celery
from flask import Flask
from flask_environments import Environments
from flask_mongoengine import MongoEngine
from celery.signals import before_task_publish, task_prerun, task_success, task_failure
import mongoengine
from datetime import datetime
import pytz
from config import celery_config
from db.mongo_models import task_monitor
app = Flask(__name__)
env = Environments(app)
env.from_object('config.flask_config')
basedir = os.path.abspath(
os.path.join(os.path.dirname(__file__),
os.path.pardir)) # os.path.abspath(os.path.dirname(__file__))
file_handler = RotatingFileHandler(basedir + "/logs/logger_flask.log",
encoding='utf-8')
formatter = logging.Formatter("%(asctime)s\t%(levelname)s\t%(message)s")
file_handler.setFormatter(formatter)
# 初始化mongodb
monogo_conn = MongoEngine()
monogo_conn.init_app(app)
flask_celery = Celery(app.name, broker=celery_config.CELERY_BROKER_URL)
flask_celery.config_from_object('config.celery_config')
# print(os.path.dirname(__file__))
# print(os.path.dirname(os.path.abspath(__file__)))
# sys.path.append(os.path.dirname(__file__))
# sys.path.append(os.path.dirname(os.path.abspath(__file__)))
# print(sys.path)
from app import init_beas_when_app_start
from app.soda_log import init_log
from app.visualization.soda_visualization_api import base_ns
from app.common.soda_common import SDCommonJsonRet, SDResource, SDCodeMsg, SDRequestParser
from app import sodaVisualizationService
SERVICE_NAME = "soda_potentialpie_pyservice"
APP_URL_PREFIX = "/v1/api/soda"
app = Flask(SERVICE_NAME)
config_env = Environments(app,default_env="DEVELOPMENT")
config_env.from_object('config')
# 日志
init_log()
#加载配置 生产对应环境（生产／开发）的bean
init_beas_when_app_start(app)
api_plus = Api(app,version="v1.0.0",title=SERVICE_NAME,prefix=APP_URL_PREFIX)
#基础接口
BASE_URL_PREFIX = "/base"
api_plus.add_namespace(base_ns,BASE_URL_PREFIX)
from flask import Flask
from flask.ext.assets import Environment, Bundle
from flask_environments import Environments
from flask.ext.sqlalchemy import SQLAlchemy
from flask_bootstrap import Bootstrap
import os
# Create app
GisApp = Flask(__name__)
Bootstrap(GisApp)
# GisApp.config.from_object('config')
db = SQLAlchemy(GisApp)
env = Environments(GisApp)
env.from_object('config')
# Assets
assets = Environment(GisApp)
js = Bundle('javascripts/leaflet-src.js', 'javascripts/main.js', 'javascripts/leaflet.markercluster-src.js','javascripts/leaflet.draw-src.js', 'javascripts/handlebars-v3.0.3.js', 'javascripts/Control.Geocoder.js', 'javascripts/underscore-min.js',
filters='jsmin', output='gen/packed.js')
admin_js = Bundle('javascripts/leaflet-src.js', 'javascripts/jquery-2.1.3.min.js', 'javascripts/admin_main.js', 'javascripts/leaflet.draw-src.js',
filters='jsmin', output='gen/admin_packed.js')
assets.register('application_js', js)
assets.register('admin_application_js', admin_js)
less = Bundle('stylesheets/leaflet.css', 'stylesheets/main.less.css', 'stylesheets/MarkerCluster.css', 'stylesheets/MarkerCluster.Default.css','stylesheets/leaflet.draw.css', 'stylesheets/Control.Geocoder.css',
filters='less,cssmin', output='gen/packed.css')
admin_less = Bundle('stylesheets/leaflet.css', 'stylesheets/admin_main.less.css','stylesheets/leaflet.draw.css',
filters='less,cssmin', output='gen/admin_packed.css')
import config
from models import db
from Mailer import MailerController
### Set up the Flask application
application = Flask(__name__)
env = Environments(application)
# Load the appropriate configuration depending on
# the current environment. Development is for local
# testing, and production is for AWS.
if os.environ.get('FLASK_ENV') == 'Development':
env.from_object(config.Development)
# If we're in development mode, we need to load SQLite
# and enable foreign keys on it (to support relations
# in our models).
from sqlalchemy import event
from sqlalchemy.engine import Engine
from sqlite3 import Connection as SQLite3Connection
@event.listens_for(Engine, "connect")
def _set_sqlite_pragma(dbapi_connection, connection_record):
if isinstance(dbapi_connection, SQLite3Connection):
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON;")
cursor.close()
elif os.environ.get('FLASK_ENV') == 'Production':
def create_app():
"""
This method create the Flask application.
:return: Flask App Object
"""
global db
global app
global migrate
global login
global celery
app = Flask(__name__, instance_relative_config=True)
flask_env = os.getenv('FLASK_ENV', 'None')
if flask_env == 'development':
config_object = 'config.DevConfig'
elif flask_env == 'testing':
config_object = 'config.TestConfig'
elif flask_env == 'production':
config_object = 'config.ProdConfig'
else:
raise RuntimeError(
"%s is not recognized as valid app environment. You have to setup the environment!" % flask_env)
# Load config
env = Environments(app)
env.from_object(config_object)
# registering db
db = SQLAlchemy(
app=app
)
# creating celery
celery = make_celery(app)
# requiring the list of models
register_extensions(app)
register_blueprints(app)
register_handlers(app)
# loading login manager
import gooutsafe.auth as auth
login = auth.init_login_manager(app)
# creating migrate
migrate = Migrate(
app=app,
db=db
)
# checking the environment
if flask_env == 'testing':
# we need to populate the db
db.create_all()
if flask_env == 'testing' or flask_env == 'development':
register_test_blueprints(app)
return app
def create_app():
"""
This method create the Flask application.
:return: Flask App Object
"""
global db
global app
global migrate
global api_app
# first initialize the logger
init_logger()
api_app = connexion.FlaskApp(
__name__,
server='flask',
specification_dir='openapi/',
)
# getting the flask app
app = api_app.app
flask_env = os.getenv('FLASK_ENV', 'None')
if flask_env == 'development':
config_object = 'config.DevConfig'
elif flask_env == 'testing':
config_object = 'config.TestConfig'
elif flask_env == 'production':
config_object = 'config.ProdConfig'
else:
raise RuntimeError(
"%s is not recognized as valid app environment. You have to setup the environment!" % flask_env)
# Load config
env = Environments(app)
env.from_object(config_object)
# creating redis instance
create_redis(app)
# loading communications
import gooutsafe.comm as comm
if flask_env != 'production':
# disable communication for testing purposes
comm.disabled = True
else:
comm.init_rabbit_mq(app)
# registering db
db = SQLAlchemy(
app=app
)
# requiring the list of models
import gooutsafe.models
# creating migrate
migrate = Migrate(
app=app,
db=db
)
# checking the environment
if flask_env == 'testing':
# we need to populate the db
db.create_all()
# registering to api app all specifications
register_specifications(api_app)
return app
def create_app(broker_start=False, log_level=logging.ERROR):
"""
This method create the Flask application.
:return: Flask App Object
"""
global db
global app
global migrate
global login
api_app = connexion.App(__name__,
server='flask',
specification_dir='openapi/')
# getting the flask app
app = api_app.app
flask_env = os.getenv('FLASK_ENV', 'None')
if flask_env == 'development':
config_object = 'config.DevConfig'
elif flask_env == 'testing':
config_object = 'config.TestConfig'
elif flask_env == 'production':
config_object = 'config.ProdConfig'
else:
raise RuntimeError(
"%s is not recognized as valid app environment. You have to setup the environment!"
% flask_env)
# Load config
env = Environments(app)
env.from_object(config_object)
# configuring logging
logging.basicConfig(level=log_level)
# loading communications
import gooutsafe.comm as comm
if broker_start:
if flask_env != 'testing':
comm.init_rabbit_mq(app)
else:
comm.disabled = True
# registering db
db = SQLAlchemy(app=app)
# importing models
try:
import gooutsafe.models.reservation
except ImportError:
raise RuntimeError('Cannot import the models!')
# creating migrate
migrate = Migrate(app=app, db=db)
# checking the environment
if flask_env == 'testing':
# we need to populate the db
db.create_all()
# registering to api app all specifications
register_specifications(api_app)
return app
from flask import Flask
from flask_environments import Environments
from weibo import Client
app = Flask(__name__)
env = Environments(app)
env.from_object('config-devel')
print app.config
weiboClient = Client(app.config['WEIBO_API_KEY'],
app.config['WEIBO_API_SECRET'],
app.config['WEIBO_API_REDIRECT_URI'])
dataset_gen_src = ''
for line in sys.stdin:
dataset_gen_src += line
if len(dataset_gen_src) == 0:
print >> sys.stderr, "Empty dataset generator!"
sys.exit(1)
user_id = int(sys.argv[1])
campaign_id = int(sys.argv[2])
### Set up our flask environment so we can access the DB
application = Flask(__name__)
env = Environments(application)
if os.environ.get('FLASK_ENV') == 'Development':
env.from_object(config.Development)
elif os.environ.get('FLASK_ENV') == 'Production':
env.from_object(config.Production)
else:
env.from_object(config.Production)
### Setup DB
db.app = application
db.init_app(application)
db.create_all()
### Read in our harness code
with application.open_resource('static/js/dataset-generator-harness.js') as harness_file:
harness_src = harness_file.read()
from flask import Flask
from frontend.app import frontend_bp
from backend.persistencia import Persistencia
from flask_environments import Environments
from b_logic.business import Billetera
billetera = Billetera()
persistencia = Persistencia('190.188.234.6', 'admin', 'admin2k14')
app = Flask(__name__)
env = Environments(app)
env.from_object('billetera')
app.register_blueprint(frontend_bp, url_prefix="/frontend")
#app.register_blueprint(backoffice_bp, url_prefix="/backoffice")
app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
if __name__ == '__main__':
app.config['TRAP_BAD_REQUEST_ERRORS'] = True
app.run(debug=True)
