def db_init(app):
app.logger.info('Initializing PsqlGraph driver')
app.db = PsqlGraphDriver(
host=app.config['PSQLGRAPH']['host'],
user=app.config['PSQLGRAPH']['user'],
password=app.config['PSQLGRAPH']['password'],
database=app.config['PSQLGRAPH']['database'],
set_flush_timestamps=True,
)
app.userdb = SQLAlchemyDriver(app.config['PSQL_USER_DB_CONNECTION'])
flask_scoped_session(app.userdb.Session, app)
app.oauth2 = OAuth2Client(**app.config['OAUTH2'])
app.logger.info('Initializing Signpost driver')
app.signpost = SignpostClient(
app.config['SIGNPOST']['host'],
version=app.config['SIGNPOST']['version'],
auth=app.config['SIGNPOST']['auth'])
try:
app.logger.info('Initializing Auth driver')
app.auth = AuthDriver(app.config["AUTH_ADMIN_CREDS"], app.config["INTERNAL_AUTH"])
except Exception:
app.logger.exception("Couldn't initialize auth, continuing anyway")
def create_app():
app = Flask(__name__)
app.config.from_pyfile('settings.py')
engine = create_engine(app.config['SQLALCHEMY_DB_URI'], echo=app.config['SQLALCHEMY_ECHO'])
flask_scoped_session(sessionmaker(bind=engine), app)
JWTManager(app)
api = Api(
app,
description='OLOLO',
authorizations={
'JWT Access': {
'type': 'apiKey',
'in': 'header',
'name': 'Authorization'
},
'JWT Refresh': {
'type': 'apiKey',
'in': 'header',
'name': 'Authorization'
},
},
)
api.add_namespace(auth_namespace)
api.add_namespace(towns_namespace)
api.add_namespace(district_namespace)
return app
def __create_session(app):
flask_scoped_session(
sessionmaker(autocommit=False,
autoflush=True,
expire_on_commit=False,
bind=create_engine(
app.config['SQLALCHEMY_DATABASE_URI'],
encoding='utf-8')), app)
def create_app(db_uri: str = "sqlite://"):
"""
Create a Flask application instance.
Initializes the database, app routes, and extensions.
:param db_uri: Database uri
"""
app = Flask('featuresreq')
# Intialize the datbase
engine = create_engine(db_uri)
session_factory.configure(bind=engine)
session = flask_scoped_session(session_factory, app)
app.session = session
# Register blueprints
app.register_blueprint(bp)
# Bootstrap the database models and Clients
@app.before_first_request
def bootstrap_client_models():
Base.metadata.create_all(engine)
for c in ("a", "b", "c"):
name = "Client {}".format(c.upper())
client = session.query(Client).filter(
func.lower(Client.name) == name.lower()).first()
if client is None:
client = Client(name=name)
session.add(client)
session.commit()
return app
def configure_flask_sqlalchemy_session(app: flask.Flask):
db_config = app.config['DB_CONFIG']
session_factory = session_factory_from_config(db_config)
flask_sa_session = flask_sqlalchemy_session.flask_scoped_session(
session_factory, app)
return flask_sa_session
def app_sessions(app):
app.url_map.strict_slashes = False
app.db = SQLAlchemyDriver(app.config["DB"])
migrate(app.db)
session = flask_scoped_session(app.db.Session, app) # noqa
app.storage_manager = StorageManager(
app.config["STORAGE_CREDENTIALS"], logger=app.logger
)
enabled_idp_ids = app.config["ENABLED_IDENTITY_PROVIDERS"]["providers"].keys()
# Add OIDC client for Google if configured.
configured_google = (
"OPENID_CONNECT" in app.config and "google" in app.config["OPENID_CONNECT"]
)
if configured_google:
app.google_client = GoogleClient(
app.config["OPENID_CONNECT"]["google"],
HTTP_PROXY=app.config.get("HTTP_PROXY"),
logger=app.logger,
)
# Add OIDC client for multi-tenant fence if configured.
configured_fence = (
"OPENID_CONNECT" in app.config
and "fence" in app.config["OPENID_CONNECT"]
and "fence" in enabled_idp_ids
)
if configured_fence:
app.fence_client = OAuthClient(**app.config["OPENID_CONNECT"]["fence"])
app.session_interface = UserSessionInterface()
if app.config.get("ARBORIST"):
app.arborist = ArboristClient(arborist_base_url=app.config["ARBORIST"])
def initialize_database(autoinitialize=True):
db_url = Configuration.database_url()
if autoinitialize:
SessionManager.initialize(db_url)
session_factory = SessionManager.sessionmaker(db_url)
_db = flask_scoped_session(session_factory, app)
app._db = _db
Configuration.load(_db)
testing = 'TESTING' in os.environ
log_level = LogConfiguration.initialize(_db, testing=testing)
if app.debug is None:
debug = log_level == 'DEBUG'
app.debug = debug
else:
debug = app.debug
app.config['DEBUG'] = debug
_db.commit()
app.log = logging.getLogger("Metadata web app")
app.log.info("Application debug mode: %r", app.debug)
for logger in logging.getLogger().handlers:
app.log.info("Logs are going to %r", logger)
# Register an error handler that logs exceptions through the
# normal logging process and tries to turn them into Problem
# Detail Documents.
h = ErrorHandler(app, app.config['DEBUG'])
@app.errorhandler(Exception)
def exception_handler(exception):
return h.handle(exception)
def init_db(app):
from app.db import Base
Base.metadata.create_all(bind=engine)
db_session = flask_scoped_session(session_factory, app)
Base.query = db_session.query_property()
return db_session
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 initialize_database(autoinitialize=True):
db_url = Configuration.database_url()
if autoinitialize:
SessionManager.initialize(db_url)
session_factory = SessionManager.sessionmaker(db_url)
_db = flask_scoped_session(session_factory, app)
app._db = _db
Configuration.load(_db)
testing = 'TESTING' in os.environ
log_level = LogConfiguration.initialize(_db, testing=testing)
if app.debug is None:
debug = log_level == 'DEBUG'
app.debug = debug
else:
debug = app.debug
app.config['DEBUG'] = debug
_db.commit()
app.log = logging.getLogger("Metadata web app")
app.log.info("Application debug mode: %r", app.debug)
for logger in logging.getLogger().handlers:
app.log.info("Logs are going to %r", logger)
# Register an error handler that logs exceptions through the
# normal logging process and tries to turn them into Problem
# Detail Documents.
h = ErrorHandler(app, app.config['DEBUG'])
@app.errorhandler(Exception)
def exception_handler(exception):
return h.handle(exception)
def setup_scoped_sessions(app: Flask, db_url: URL) -> Engine:
engine = SQLAlchemyEngineManager.init_engine_for_postgres_instance(
database_key=SQLAlchemyDatabaseKey.for_schema(SchemaType.CASE_TRIAGE),
db_url=db_url,
)
session_factory = sessionmaker(bind=engine)
app.scoped_session = flask_scoped_session(session_factory, app)
return engine
def create_app(config):
app = Flask(__name__, template_folder='app/templates')
app.config.from_object(config)
engine = create_engine(Config.SQLALCHEMY_DATABASE_URI)
session_factory = sessionmaker(bind=engine)
session = flask_scoped_session(session_factory, app)
register_extensions(app)
CORS(app)
return app
def __init__(self, engine, flask_app=None, timedelta_mins_from_utc=0):
self.engine = engine
self.timedelta_mins_from_utc = timedelta_mins_from_utc
self.sessionmaker = sessionmaker(bind=self.engine)
self.app = flask_app
if flask_app:
self.session = flask_scoped_session(self.sessionmaker, flask_app)
else:
self.session = scoped_session(self.sessionmaker)
def setup_db():
global BASE
engine = create_engine(f'sqlite:///{DBFILE}')
BASE.metadata.bind = engine
# Before doing this, clean up prev DB for testing purposes.
# Submit to autograder WITHOUT this line.
#BASE.metadata.drop_all(engine)
# Create DB again.
BASE.metadata.create_all(engine)
DBSessionMaker = sessionmaker(bind=engine)
return flask_scoped_session(DBSessionMaker, app)
def client(app, engine, tables):
"""
Get a test client for your Flask app
:param app: Test FlaskApp
:param engine: sqlalchemy engine
:param tables: creating all tables ## DON'T REMOVE FROM HERE
:return: test client
"""
session_factory = sessionmaker(bind=engine)
app.db_session = flask_scoped_session(session_factory, app)
with app.app_context():
yield app.test_client()
def create_app():
""" Create an app instance """
app = Flask(__name__)
app.config.from_object('config')
app.json_encoder = JSONEncoder
app.db_session = flask_scoped_session(session_factory, app)
CORS(app)
app.register_error_handler(Exception, handle_error)
_ = list(map(app.register_blueprint, BLUEPRINTS))
return app
def sync_transactions():
''' sync transactions from prev db '''
click.echo('Init the db')
from .base import OLD_DB_URL
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session, sessionmaker
__old_engine__ = create_engine(OLD_DB_URL)
old_db_session = scoped_session(
sessionmaker(autocommit=False, autoflush=False, bind=__old_engine__))
old_db = flask_scoped_session(old_db_session, APP)
result = old_db.execute("select * from transactions")
results = {}
for row in result:
results[row['id']] = row
_transaction = DB.query(Transaction).get(row['id'])
if _transaction is None:
# if row['transfer']:
# print('transfer. skipping for now')
# continue
print("adding {}".format(row['id'], row))
new_transaction = Transaction(record_id=row['id'],
time=row['time'],
account_id=row['account_id'],
user_id=1,
summ=row['sum'],
income_id=row['income_id'],
comments=row['comment'])
print(new_transaction)
DB.add(new_transaction)
continue
if _transaction.summ == row['sum'] and _transaction.account_id == row[
'account_id'] and _transaction.transfer == row[
'transfer'] and _transaction.income_id == row[
'income_id'] and _transaction.comments == row[
'comment']:
continue
#print("{:3d} {:7.2f} {:3d} {:3d} {:3d} {:30s}".format(
# row['id'], row['sum'], row['account_id'], row['transfer'], row['income_id'], row['comment']
# ))
print(row)
print(_transaction)
# \n {:7s} {:3s} {:3s}
# _transaction.summ, _transaction.account_id, _transaction.transfer
DB.commit()
for _transaction in DB.query(Transaction).all():
if _transaction.record_id in results:
continue
print(_transaction)
old_db.close()
def app_sessions(app):
app.url_map.strict_slashes = False
app.db = SQLAlchemyDriver(config["DB"])
# app.db = SQLAlchemyDriver('postgresql://*****:*****@postgres:5432/amanuensis_db')
logger.warning("LUCA - DB connected")
# TODO: we will make a more robust migration system external from the application
# initialization soon
if config["ENABLE_DB_MIGRATION"]:
logger.info("Running database migration...")
migrate(app.db)
logger.info("Done running database migration.")
else:
logger.info("NOT running database migration.")
session = flask_scoped_session(app.db.Session, app) # noqa
def app_sessions(app):
app.url_map.strict_slashes = False
app.db = SQLAlchemyDriver(config["DB"])
# TODO: we will make a more robust migration system external from the application
# initialization soon
if config["ENABLE_DB_MIGRATION"]:
logger.info("Running database migration...")
migrate(app.db)
logger.info("Done running database migration.")
else:
logger.info("NOT running database migration.")
session = flask_scoped_session(app.db.Session, app) # noqa
app.session_interface = UserSessionInterface()
def initialize_database(autoinitialize=True):
testing = 'TESTING' in os.environ
db_url = Configuration.database_url()
if autoinitialize:
SessionManager.initialize(db_url)
session_factory = SessionManager.sessionmaker(db_url)
_db = flask_scoped_session(session_factory, app)
app._db = _db
log_level = LogConfiguration.initialize(_db, testing=testing)
debug = log_level == 'DEBUG'
app.config['DEBUG'] = debug
app.debug = debug
_db.commit()
logging.getLogger().info("Application debug mode==%r" % app.debug)
def get_db_session():
if has_app_context():
# This branch is used when we're working in the scope of Flask app
global flask_db_session
if not flask_db_session:
from application import application
flask_db_session = flask_scoped_session(get_session_factory(),
application)
return flask_db_session
else:
# We use a different session if we're outside of Flask app,
# for example running our code in a separate Thread
global non_flask_db_session
if not non_flask_db_session:
non_flask_db_session = scoped_session(
get_session_factory(DB_PREFIX))()
return non_flask_db_session
def init(app, engine, session_factory):
"""Adds app.engine, and app.session_factory. Creates them if not passed in.
:param app: flask app.
:param engine: sqlalchemy engine.
:param session_factory: session factory.
"""
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
# http://flask-sqlalchemy-session.readthedocs.io/en/v1.1/
from flask_sqlalchemy_session import flask_scoped_session
app.engine = (create_engine(app.config["SQLALCHEMY_DATABASE_URI"])
if engine is None else engine)
app.session_factory = (sessionmaker(
bind=app.engine) if session_factory is None else session_factory)
app.scoped_session = flask_scoped_session(app.session_factory, app)
def create_app(Config):
"""
Create Flask application using app factory pattern.
:return: Flask app, SocketIO sockio
"""
app = Flask(__name__, instance_relative_config=False)
app.config.from_object(Config)
CORS(app, resources={r"/api/*": {"origins": "*"}})
# initialize plugins
from bfx_data_server.database import session_factory, User, Favourite
dbSession = flask_scoped_session(session_factory, app)
login_manager.init_app(app)
sesh.init_app(app)
sockio.init_app(app, manage_session=False)
with app.app_context():
from bfx_data_server.server.blueprints import home, auth, main, errors, data, api
app.register_blueprint(home.home_bp)
app.register_blueprint(auth.auth_bp, url_prefix='/auth')
app.register_blueprint(main.main_bp)
app.register_blueprint(errors.err, url_prefix='/error')
app.register_blueprint(data.data_bp)
app.register_blueprint(api.api_v1, url_perfix='/api_v1')
@login_manager.user_loader
def load_user(user_id):
if user_id is not None:
return dbSession.query(User).get(int(user_id))
return None
@app.shell_context_processor
def make_shell_context():
return {'db': dbSession, 'User': User, 'Favourite': Favourite}
@app.teardown_appcontext
def shutdown_session(exception=None):
dbSession.remove()
return app, sockio
def create_app(dbsession: Session = None) -> Flask:
"""Create new Flask app
:param dbsession: optional sqlalchemy Session, if `None`, a new one will be created.
:return: Flask instance.
"""
app = Flask(__name__)
app.config.update()
if not dbsession:
# no session given, will setup an engine using DATABASE_URL env var, and create a session_factory from it
database.setup()
session_factory = sqlalchemy.orm.sessionmaker(bind=database.engine)
database.session = flask_scoped_session(session_factory, app)
else:
# session given, this is for tests - session is setup in tests/conftest.py.
database.setup(dbsession.bind.engine)
database.session = dbsession
# loads the routes
init_app(app, database.session)
return app
def app_sessions(app):
app.url_map.strict_slashes = False
app.db = SQLAlchemyDriver(app.config['DB'])
migrate(app.db)
session = flask_scoped_session(app.db.Session, app) # noqa
app.jinja_env.globals['csrf_token'] = generate_csrf_token
app.storage_manager = StorageManager(
app.config['STORAGE_CREDENTIALS'],
logger=app.logger
)
enabled_idp_ids = (
fence.settings
.ENABLED_IDENTITY_PROVIDERS['providers']
.keys()
)
# Add OIDC client for Google if configured.
configured_google = (
'OPENID_CONNECT' in app.config
and 'google' in app.config['OPENID_CONNECT']
and 'google' in enabled_idp_ids
)
if configured_google:
app.google_client = GoogleClient(
app.config['OPENID_CONNECT']['google'],
HTTP_PROXY=app.config.get('HTTP_PROXY'),
logger=app.logger
)
# Add OIDC client for multi-tenant fence if configured.
configured_fence = (
'OPENID_CONNECT' in app.config
and 'fence' in app.config['OPENID_CONNECT']
and 'fence' in enabled_idp_ids
)
if configured_fence:
app.fence_client = OAuthClient(**app.config['OPENID_CONNECT']['fence'])
app.session_interface = UserSessionInterface()
def test_constructor(sqlite_engine, flask_app):
"""Test init_app is called when an app is passed in the constructor"""
with mock.patch.object(flask_scoped_session, "init_app"):
ses = flask_scoped_session(sessionmaker(bind=sqlite_engine), flask_app)
ses.init_app.assert_called_once_with(flask_app)
def unitialized_session(sqlite_engine):
"""Return a request_scoped_session that has not been used for a flask app"""
ses = flask_scoped_session(sessionmaker(bind=sqlite_engine))
_remove = ses.remove
ses.remove = mock.Mock(side_effect=_remove)
return ses
ride_table_id = RideUsersTable(user_table_name=ride_request.created_by,
ride_table_id=ride_id).write_to_db()
return Response(j.dumps({"ride_id": ride_id}),
status=201,
mimetype='application/json')
elif (action == "join_ride"):
RideUsersTable(user_table_name=body["username"],
ride_table_id=body["ride_id"]).write_to_db()
return Response(None, status=200, mimetype='application/json')
elif (action == "delete_ride"):
RideTable.read_from_db(body['ride_id']).delete_from_db()
return Response(None, status=200, mimetype='application/json')
e = sql.create_engine("sqlite:///{}".format(
os.path.join(os.path.dirname(os.path.abspath(__file__)), "riders.db")))
sf = orm.sessionmaker(bind=e)
session = fss.flask_scoped_session(sf, app)
Base.metadata.create_all(e, checkfirst=True)
if __name__ == "__main__":
'''e = sql.create_engine("sqlite:///{}".format(
os.path.join(os.path.dirname(os.path.abspath(__file__)), "riders.db")))
Base.metadata.create_all(e, checkfirst=True)
sf = orm.sessionmaker(bind=e)
session = fss.flask_scoped_session(sf, app)'''
app.run(host='0.0.0.0', port=8080, debug=True)
def init(cls, app: Flask) -> None:
cls.session = flask_scoped_session(session_factory, app)
return JSONEncoder.default(self, o)
app = Flask(__name__)
app.json_encoder = JsonEncoder
@app.route("/")
def index():
return "Hello! v2"
@app.route("/environ")
def environ():
return ppr(os.environ)
DB_URL = os.environ["DB_URL"]#, "postgres://docker@db:5432/docker")
engine = create_engine(DB_URL)
session = flask_scoped_session(sessionmaker(engine), app)
@app.route("/sql/<query>")
def sql(query):
response = {"query": query}
try:
query_result = session.execute(query)
session.commit()
response["message"] = "Executed successfully."
if query_result.rowcount is not None:
response["rows_affected"] = query_result.rowcount
if query_result.returns_rows:
response["returned_rows"] = query_result.fetchall()
except Exception as ex:
response["error"] = str(ex)
response["traceback"] = format_exc()
}
)
# mail setup
app.config['MAIL_USE_SSL'] = False
app.config['MAIL_SERVER'] = 'smtp.googlemail.com'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = '******'
app.config['MAIL_PASSWORD'] = '******'
mail = Mail(app)
app.secret_key = 'bdfa8a83f16eb4f95dc2473fe4a50820b14e74cc70cef6ae'
# print(os.random(24))
sess = flask_scoped_session(session_factory, app)
########## CAS AUTHENTICATION ###########
cas = CAS(app)
app.config['CAS_SERVER'] = "https://fed.princeton.edu/cas/login"
app.config['CAS_AFTER_LOGIN'] = '******'
app.config['CAS_AFTER_LOGOUT'] = 'http://princeton-qroom.herokuapp.com/caslogout'
# app.config['CAS_AFTER_LOGOUT'] = 'http://*****:*****@app.route('/')
def index():
if isLoggedIn():
return redirect(url_for('booking'))
session['admin'] = True
def test_constructor(sqlite_engine, flask_app):
"""Test init_app is called when an app is passed in the constructor"""
with mock.patch.object(flask_scoped_session, "init_app"):
ses = flask_scoped_session(sessionmaker(bind=sqlite_engine), flask_app)
ses.init_app.assert_called_once_with(flask_app)
Base.prepare(engine, reflect=True)
# TODO make base classes use the correct engine
# Currently, this uses sqlite o.O: `num_authors = Author.query.count()`
Author = Base.classes.authors
Document = Base.classes.documents
Label = Base.classes.labels
toolbar = DebugToolbarExtension(app)
# Enable SQLAlchemy in Debug Toolbar without flask-sqlalchemy :)
from flask.ext.sqlalchemy import _EngineDebuggingSignalEvents
_EngineDebuggingSignalEvents(engine, app.import_name).register()
session_factory = sessionmaker(bind=engine)
session = flask_scoped_session(session_factory, app)
# From http://flask.pocoo.org/snippets/33/
@app.template_filter()
def friendly_time(dt, past_="ago",
future_="from now",
default="just now"):
"""
Returns string representing "time since"
or "time until" e.g.
3 days ago, 5 hours from now etc.
"""
now = datetime.now()
if now > dt:
diff = now - dt
# set up Flask
app = Flask(__name__, static_url_path='')
app.secret_key = conf.get("server", "secret")
app.config['UPLOAD_FOLDER'] = "/tmp"
start_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
# set up database connection
db_url = conf.get("database", "url")
engine = create_engine(db_url, pool_recycle=3600)
# flask-mysqlalchemy integration
Base.metadata.bind = engine
DBSession = sessionmaker(bind=engine)
session = flask_scoped_session(DBSession, app) # type: Session
# set up Jinja rendering environment for Latex
# http://flask.pocoo.org/snippets/55/
texenv = app.create_jinja_environment()
# texenv.block_start_string = '((*'
# texenv.block_end_string = '*))'
texenv.variable_start_string = '((('
texenv.variable_end_string = ')))'
# texenv.comment_start_string = '((='
# texenv.comment_end_string = '=))'
# format float as EUR value
@app.template_filter()
def create_app(verbosity=None):
"""Creates a Flask application object that registers all the blueprints on
which the actual routes are defined.
Parameters
----------
verbosity: int, optional
logging verbosity to override the
:attr:`logging_verbosity <tmserver.config.ServerConfig.logging_verbosity>`
setting in the configuration file (default: ``None``)
Returns
-------
flask.Flask
Flask application
"""
log_formatter = logging.Formatter(
fmt='%(process)5d/%(threadName)-12s| %(levelname)-8s| %(message)s [[%(name)s @ %(pathname)s:%(lineno)d]]',
datefmt='%Y-%m-%d %H:%M:%S'
)
log_handler = logging.StreamHandler(stream=sys.stdout)
log_handler.setFormatter(log_formatter)
if verbosity is None:
verbosity = cfg.logging_verbosity
log_level = map_logging_verbosity(verbosity)
app = Flask('wsgi')
app.config['PROPAGATE_EXCEPTIONS'] = True
app.logger.handlers = [] # remove standard handlers
app.logger.setLevel(log_level)
app.logger.addHandler(log_handler)
tmserver_logger = logging.getLogger('tmserver')
tmserver_logger.setLevel(log_level)
tmserver_logger.addHandler(log_handler)
tmlib_logger = logging.getLogger('tmlib')
tmlib_logger.setLevel(log_level)
tmlib_logger.addHandler(log_handler)
flask_jwt_logger = logging.getLogger('flask_jwt')
flask_jwt_logger.setLevel(log_level)
flask_jwt_logger.addHandler(log_handler)
gevent_logger = logging.getLogger('gevent')
gevent_logger.addHandler(log_handler)
gc3pie_logger = logging.getLogger('gc3.gc3libs')
gc3pie_logger.addHandler(log_handler)
sqlalchemy_logger = logging.getLogger('sqlalchemy.engine')
sqlalchemy_logger.addHandler(log_handler)
wsgi_logger = logging.getLogger('wsgi')
wsgi_logger.addHandler(log_handler)
if verbosity > 4:
gevent_logger.setLevel(logging.DEBUG)
gc3pie_logger.setLevel(logging.DEBUG)
sqlalchemy_logger.setLevel(logging.DEBUG)
wsgi_logger.setLevel(logging.DEBUG)
elif verbosity > 3:
gevent_logger.setLevel(logging.INFO)
gc3pie_logger.setLevel(logging.INFO)
sqlalchemy_logger.setLevel(logging.INFO)
wsgi_logger.setLevel(logging.INFO)
else:
gevent_logger.setLevel(logging.ERROR)
gc3pie_logger.setLevel(logging.ERROR)
sqlalchemy_logger.setLevel(logging.ERROR)
wsgi_logger.setLevel(logging.ERROR)
app.json_encoder = TmJSONEncoder
if cfg.secret_key == 'default_secret_key':
app.logger.warn('The application will run with the default secret key!')
elif not cfg.secret_key:
app.logger.critical('Specify a secret key for this application!')
sys.exit(1)
app.config['SECRET_KEY'] = cfg.secret_key
app.config['JWT_EXPIRATION_DELTA'] = cfg.jwt_expiration_delta
## Error handling
# Register custom error classes
register_http_error_classes(app)
# Register SQLAlchemy error classes
@app.errorhandler(NoResultFound)
def _handle_no_result_found(error):
response = jsonify(error={
'message': error.message,
'status_code': 400,
'type': error.__class__.__name__
})
logger.error('no result found: ' + error.message)
response.status_code = 400
return response
@app.errorhandler(MultipleResultsFound)
def _multiple_results_found(error):
response = jsonify(error={
'message': error.message,
'status_code': 409,
'type': error.__class__.__name__
})
logger.error('multiple results found: ' + error.message)
response.status_code = 409
return response
@app.errorhandler(IntegrityError)
def _handle_integrity_error(error):
response = jsonify(error={
'error': True,
'message': error.message,
'status_code': 500,
'type': error.__class__.__name__
})
logger.error('database integrity error: ' + error.message)
response.status_code = 500
return response
## Initialize Plugins
jwt.init_app(app)
# Create a session scope for interacting with the main database
engine = create_db_engine(cfg.db_master_uri)
create_db_tables(engine)
session_factory = create_db_session_factory()
session_factory.configure(bind=engine)
session = flask_scoped_session(session_factory, app)
from tmserver.extensions import gc3pie
gc3pie.init_app(app)
## Import and register blueprints
from tmserver.api import api
app.register_blueprint(api, url_prefix='/api')
from tmserver.jtui import jtui
app.register_blueprint(jtui, url_prefix='/jtui')
# For uWSGI fork()
engine.dispose()
return app
from .oauth import GOOGLE, REDIRECT_URI, get_user_info
from .database import User, \
Account, \
DBJsonEncoder, Income, Interval
from .currencies import UserCurrencies, Currency
from .currencies import usercurrency_delete, usercurrency_put, currency_get # pylint: disable=W0611
from .base import DB_URL, DB_SESSION
from .utils import strip_numbers
from .transactions import Transaction, transaction_get, transaction_put, transaction_post, transaction_delete # pylint: disable=W0611
# from .payforward import Payforward
__version__ = "1.0.1"
APP = Flask(__name__) # create the application instance :)
APP.config.from_object(__name__) # load config from this file , flaskr.py
DB = flask_scoped_session(DB_SESSION, APP)
SECRET = 'icDauKnydnomWovijOakgewvIgyivfahudWocnelkikAndeezCogneftyeljogdy'
# Load default config and override config from an environment variable
APP.config.update(
dict(SECRET_KEY=SECRET,
PREFERRED_URL_SCHEME='http',
SESSION_TYPE='sqlalchemy',
SQLALCHEMY_DATABASE_URI=DB_URL,
SQLALCHEMY_TRACK_MODIFICATIONS=False,
DEBUG=True))
APP.config.from_envvar('E4_SETTINGS', silent=True)
@APP.teardown_appcontext
def unitialized_session(sqlite_engine):
"""Return a request_scoped_session that has not been used for a flask app"""
ses = flask_scoped_session(sessionmaker(bind=sqlite_engine))
_remove = ses.remove
ses.remove = mock.Mock(side_effect=_remove)
return ses
