from flask import Flask
from flask.ext.appbuilder import SQLA, AppBuilder
from app.index import MyIndexView
"""
Logging configuration
"""
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
app.debug = True
db = SQLA(app)
appbuilder = AppBuilder(app, db.session, indexview=MyIndexView)
"""
from sqlalchemy.engine import Engine
from sqlalchemy import event
#Only include this for SQLLite constraints
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
# Will force sqllite contraint foreign keys
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
"""
from app import views
import logging
from flask import Flask
from flask.ext.appbuilder import AppBuilder, SQLA
from sqlalchemy.engine import Engine
from sqlalchemy import event
from indexview import FABView
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
appbuilder = AppBuilder(app, db.session, base_template='mybase.html', indexview=FABView)
"""
Only include this for SQLLite constraints
"""
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
from app import views, data
db.create_all()
data.fill_gender()
data.fill_data()
import logging
from flask import Flask
from flask.ext.appbuilder import SQLA, AppBuilder
from flask.ext.appbuilder.menu import Menu
from .sec import MySecurityManager
from .indexview import MyIndexView
from sqlalchemy.engine import Engine
from sqlalchemy import event
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
appbuilder = AppBuilder(app,
db.session,
indexview=MyIndexView,
menu=Menu(reverse=False),
security_manager_class=MySecurityManager)
"""
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
"""
from app import views
import logging
from flask import Flask, session
from flask.ext.appbuilder import SQLA, AppBuilder
from app.index import MyIndexView
"""
Logging configuration
"""
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
appbuilder = AppBuilder(app,
db.session,
base_template="graph_base.html",
indexview=MyIndexView)
# if 'access_token' in session:
# session.pop('access_token', None)
# if 'starling_access_token' in session:
# session.pop('starling_access_token', None)
"""
from sqlalchemy.engine import Engine
from sqlalchemy import event
#Only include this for SQLLite constraints
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
# Will force sqllite contraint foreign keys
import logging
from flask import Flask
from flask.ext.appbuilder import SQLA, AppBuilder, IndexView
"""
Logging configuration
"""
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
class MyIndexView(IndexView):
index_template = 'index.html'
appbuilder = AppBuilder(app,
db.session,
base_template='panoramix/base.html',
indexview=MyIndexView)
from app import views
import os
import logging
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.appbuilder import AppBuilder
from sqlalchemy.engine import Engine
from sqlalchemy import event
app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
appbuilder = AppBuilder(app, db)
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
"""
Only include this for SQLLite constraints
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
"""
from app import views
import logging
from flask import Flask
from flask.ext.appbuilder import SQLA, AppBuilder
"""
Logging configuration
"""
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
appbuilder = AppBuilder(app,
db.session,
base_template='base.html',
static_url_path='',
static_folder='static')
#lp = LP('/var/run/lp.pid')
#lp.verbose = True
#Timer(5, lp.run, ()).start()
"""
from sqlalchemy.engine import Engine
from sqlalchemy import event
#Only include this for SQLLite constraints
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
# Will force sqllite contraint foreign keys
cursor = dbapi_connection.cursor()
import logging
from flask import Flask
from flask.ext.appbuilder import SQLA, AppBuilder
#from sqlalchemy.engine import Engine
#from sqlalchemy import event
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
db = SQLA()
appbuilder = AppBuilder()
from app import views
def create_app(config):
app = Flask(__name__)
app.config.from_object(config)
db.init_app(app)
with app.app_context():
appbuilder.init_app(app, db.session)
db.create_all(app=app)
views.fill_gender()
return app
from flask_migrate import Migrate
"""
Logging configuration
"""
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
app.jinja_env.globals['momentjs'] = momentjs
db = SQLA(app)
migrate = Migrate(app, db)
appbuilder = AppBuilder(app,
db.session,
indexview=MyIndexView,
base_template='mybase.html')
#migration_dir = str(app.static_folder) + '/alembic'
#migrate = Migrate(app, db)
'''
with app.app_context():
# Only run DB downgrade for local dev environment
# otherwise all data is lost
# print 'Downgrading back to base revision'
# downgrade(directory=migration_dir, revision='base')
print('Upgrading up to head revision')
if os.path.exists(os.getcwd() + '/app/static/alembic'):
print('alembic migration folder found')
else:
import logging
from flask import Flask
from flask.ext.appbuilder import SQLA, AppBuilder
from app.index import LandingView
"""
Logging configuration
"""
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
appbuilder = AppBuilder(app, db.session, indexview=LandingView)
from app import views
from flask import Flask
from flask.ext.appbuilder import SQLA, AppBuilder
from flask.ext.appbuilder.menu import Menu
from .index import MyIndexView
"""
Logging configuration
"""
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
appbuilder = AppBuilder(app, db.session, indexview=MyIndexView, menu=Menu(reverse=False))
"""
from sqlalchemy.engine import Engine
from sqlalchemy import event
#Only include this for SQLLite constraints
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
# Will force sqllite contraint foreign keys
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
"""
from flask.ext.appbuilder import AppBuilder
from flask_mongoengine import MongoEngine
from app.index import MyIndexView
"""
Logging configuration
"""
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
db = MongoEngine(app)
appbuilder = AppBuilder(app,
security_manager_class=SecurityManager,
indexview=MyIndexView)
"""
from sqlalchemy.engine import Engine
from sqlalchemy import event
#Only include this for SQLLite constraints
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
# Will force sqllite contraint foreign keys
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
"""
from app import views
from flask.ext.appbuilder import SQLA, AppBuilder
from app.sec_views import MyIndexView
from app.sec import MySecurityManager
"""
Logging configuration
"""
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
appbuilder = AppBuilder(app,
db.session,
security_manager_class=MySecurityManager,
indexview=MyIndexView,
base_template="mybase.html")
"""
from sqlalchemy.engine import Engine
from sqlalchemy import event
#Only include this for SQLLite constraints
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
# Will force sqllite contraint foreign keys
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
"""
import logging
from flask import Flask
from flask.ext.appbuilder import SQLA, AppBuilder
from flask.ext.appbuilder.menu import Menu
#from sqlalchemy.engine import Engine
#from sqlalchemy import event
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
appbuilder = AppBuilder(app, db.session, menu=Menu(reverse=False))
"""
Only include this for SQLLite constraints
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
"""
from app import views
def setUp(self):
from flask import Flask
from flask.ext.appbuilder import AppBuilder
from flask.ext.appbuilder.models.datamodel import SQLAModel
from flask.ext.appbuilder.views import ModelView
self.app = Flask(__name__)
self.basedir = os.path.abspath(os.path.dirname(__file__))
self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///'
self.app.config['CSRF_ENABLED'] = False
self.app.config['SECRET_KEY'] = 'thisismyscretkey'
self.app.config['WTF_CSRF_ENABLED'] = False
self.db = SQLA(self.app)
self.appbuilder = AppBuilder(self.app, self.db.session)
class Model2View(ModelView):
datamodel = SQLAModel(Model2)
list_columns = [
'field_integer', 'field_float', 'field_string', 'field_method'
]
class Model1View(ModelView):
datamodel = SQLAModel(Model1)
related_views = [Model2View]
list_columns = ['field_string', 'field_file']
class Model1Filtered1View(ModelView):
datamodel = SQLAModel(Model1)
base_filters = [['field_string', FilterStartsWith, 'a']]
class Model1MasterView(MasterDetailView):
datamodel = SQLAModel(Model1)
related_views = [Model2View]
class Model1Filtered2View(ModelView):
datamodel = SQLAModel(Model1)
base_filters = [['field_integer', FilterEqual, 0]]
class Model2ChartView(ChartView):
datamodel = SQLAModel(Model2)
chart_title = 'Test Model1 Chart'
group_by_columns = ['field_string']
class Model2GroupByChartView(GroupByChartView):
datamodel = SQLAModel(Model2)
chart_title = 'Test Model1 Chart'
definitions = [{
'group':
'field_string',
'series': [(aggregate_sum, 'field_integer', aggregate_avg,
'field_integer', aggregate_count, 'field_integer')]
}]
class Model2DirectByChartView(DirectByChartView):
datamodel = SQLAModel(Model2)
chart_title = 'Test Model1 Chart'
definitions = [{
'group': 'field_string',
'series': ['field_integer', 'field_float']
}]
class Model2TimeChartView(TimeChartView):
datamodel = SQLAModel(Model2)
chart_title = 'Test Model1 Chart'
group_by_columns = ['field_date']
class Model2DirectChartView(DirectChartView):
datamodel = SQLAModel(Model2)
chart_title = 'Test Model1 Chart'
direct_columns = {'stat1': ('group', 'field_integer')}
class Model1MasterView(MasterDetailView):
datamodel = SQLAModel(Model1)
related_views = [Model2View]
class Model1MasterChartView(MasterDetailView):
datamodel = SQLAModel(Model1)
related_views = [Model2DirectByChartView]
self.appbuilder.add_view(Model1View, "Model1", category='Model1')
self.appbuilder.add_view(Model1MasterView,
"Model1Master",
category='Model1')
self.appbuilder.add_view(Model1MasterChartView,
"Model1MasterChart",
category='Model1')
self.appbuilder.add_view(Model1Filtered1View,
"Model1Filtered1",
category='Model1')
self.appbuilder.add_view(Model1Filtered2View,
"Model1Filtered2",
category='Model1')
self.appbuilder.add_view(Model2View, "Model2")
self.appbuilder.add_view(Model2View,
"Model2 Add",
href='/model2view/add')
self.appbuilder.add_view(Model2ChartView, "Model2 Chart")
self.appbuilder.add_view(Model2GroupByChartView,
"Model2 Group By Chart")
self.appbuilder.add_view(Model2DirectByChartView,
"Model2 Direct By Chart")
self.appbuilder.add_view(Model2TimeChartView, "Model2 Time Chart")
self.appbuilder.add_view(Model2DirectChartView, "Model2 Direct Chart")
import os
import logging
from flask import Flask
from flask.ext.appbuilder import SQLA
from flask.ext.appbuilder import AppBuilder
from sqlalchemy.engine import Engine
from sqlalchemy import event
from .security import MySecurityManager
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
appbuilder = AppBuilder(app,
db.session,
security_manager_class=MySecurityManager)
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
from app import models, views
from flask import Flask
from flask.ext.appbuilder import SQLA, AppBuilder
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
appbuilder = AppBuilder(
app,
db.session,
base_template='airflow_webserver/base.html',
)
from app import views
import logging
from flask import Flask
from flask.ext.appbuilder import SQLA, AppBuilder
"""
Logging configuration
"""
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
appbuilder = AppBuilder(app, db.session, base_template='base.html')
"""
from sqlalchemy.engine import Engine
from sqlalchemy import event
#Only include this for SQLLite constraints
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
# Will force sqllite contraint foreign keys
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
"""
from app import views
import logging
from flask import Flask
from flask.ext.appbuilder import SQLA, AppBuilder
from sqlalchemy.engine import Engine
from sqlalchemy import event
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
appbuilder = AppBuilder(app, db.session)
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
from app import views, models
app.config.from_object(CONFIG_MODULE)
if not app.debug:
# In production mode, add log handler to sys.stderr.
app.logger.addHandler(logging.StreamHandler())
app.logger.setLevel(logging.INFO)
db = SQLA(app)
cache = Cache(app, config=app.config.get('CACHE_CONFIG'))
migrate = Migrate(app, db, directory=APP_DIR + "/migrations")
class MyIndexView(IndexView):
@expose('/')
def index(self):
return redirect('/caravel/welcome')
appbuilder = AppBuilder(
app,
db.session,
base_template='caravel/base.html',
indexview=MyIndexView,
security_manager_class=app.config.get("CUSTOM_SECURITY_MANAGER"))
sm = appbuilder.sm
get_session = appbuilder.get_session
from caravel import config, views # noqa
def setUp(self):
from flask import Flask
from flask.ext.appbuilder import AppBuilder
from flask.ext.appbuilder.models.datamodel import SQLAModel
from flask.ext.appbuilder.views import ModelView
self.app = Flask(__name__)
self.basedir = os.path.abspath(os.path.dirname(__file__))
self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///'
self.app.config['CSRF_ENABLED'] = False
self.app.config['SECRET_KEY'] = 'thisismyscretkey'
self.app.config['WTF_CSRF_ENABLED'] = False
self.db = SQLA(self.app)
self.appbuilder = AppBuilder(self.app, self.db.session)
sess = PSSession()
class PSView(ModelView):
datamodel = GenericInterface(PSModel, sess)
base_permissions = ['can_list', 'can_show']
list_columns = ['UID', 'C', 'CMD', 'TIME']
search_columns = ['UID', 'C', 'CMD']
class Model2View(ModelView):
datamodel = SQLAModel(Model2)
list_columns = [
'field_integer', 'field_float', 'field_string', 'field_method',
'group.field_string'
]
edit_form_query_rel_fields = [
('group', SQLAModel(Model1, self.db.session),
[['field_string', FilterEqual, 'G2']])
]
add_form_query_rel_fields = [('group',
SQLAModel(Model1, self.db.session),
[['field_string', FilterEqual,
'G1']])]
class Model1View(ModelView):
datamodel = SQLAModel(Model1)
related_views = [Model2View]
list_columns = ['field_string', 'field_file']
class Model1CompactView(CompactCRUDMixin, ModelView):
datamodel = SQLAModel(Model1)
class Model1Filtered1View(ModelView):
datamodel = SQLAModel(Model1)
base_filters = [['field_string', FilterStartsWith, 'a']]
class Model1MasterView(MasterDetailView):
datamodel = SQLAModel(Model1)
related_views = [Model2View]
class Model1Filtered2View(ModelView):
datamodel = SQLAModel(Model1)
base_filters = [['field_integer', FilterEqual, 0]]
class Model2ChartView(ChartView):
datamodel = SQLAModel(Model2)
chart_title = 'Test Model1 Chart'
group_by_columns = ['field_string']
class Model2GroupByChartView(GroupByChartView):
datamodel = SQLAModel(Model2)
chart_title = 'Test Model1 Chart'
definitions = [{
'group':
'field_string',
'series': [(aggregate_sum, 'field_integer', aggregate_avg,
'field_integer', aggregate_count, 'field_integer')]
}]
class Model2DirectByChartView(DirectByChartView):
datamodel = SQLAModel(Model2)
chart_title = 'Test Model1 Chart'
definitions = [{
'group': 'field_string',
'series': ['field_integer', 'field_float']
}]
class Model2TimeChartView(TimeChartView):
datamodel = SQLAModel(Model2)
chart_title = 'Test Model1 Chart'
group_by_columns = ['field_date']
class Model2DirectChartView(DirectChartView):
datamodel = SQLAModel(Model2)
chart_title = 'Test Model1 Chart'
direct_columns = {'stat1': ('group', 'field_integer')}
class Model1MasterView(MasterDetailView):
datamodel = SQLAModel(Model1)
related_views = [Model2View]
class Model1MasterChartView(MasterDetailView):
datamodel = SQLAModel(Model1)
related_views = [Model2DirectByChartView]
self.appbuilder.add_view(Model1View, "Model1", category='Model1')
self.appbuilder.add_view(Model1CompactView,
"Model1Compact",
category='Model1')
self.appbuilder.add_view(Model1MasterView,
"Model1Master",
category='Model1')
self.appbuilder.add_view(Model1MasterChartView,
"Model1MasterChart",
category='Model1')
self.appbuilder.add_view(Model1Filtered1View,
"Model1Filtered1",
category='Model1')
self.appbuilder.add_view(Model1Filtered2View,
"Model1Filtered2",
category='Model1')
self.appbuilder.add_view(Model2View, "Model2")
self.appbuilder.add_view(Model2View,
"Model2 Add",
href='/model2view/add')
self.appbuilder.add_view(Model2ChartView, "Model2 Chart")
self.appbuilder.add_view(Model2GroupByChartView,
"Model2 Group By Chart")
self.appbuilder.add_view(Model2DirectByChartView,
"Model2 Direct By Chart")
self.appbuilder.add_view(Model2TimeChartView, "Model2 Time Chart")
self.appbuilder.add_view(Model2DirectChartView, "Model2 Direct Chart")
self.appbuilder.add_view(PSView,
"Generic DS PS View",
category='PSView')
import logging
from flask import Flask
from flask.ext.appbuilder import AppBuilder
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.appbuilder.models import SQLA
from sqlalchemy import event
logging.basicConfig(format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
logging.getLogger().setLevel(logging.DEBUG)
app = Flask(__name__)
app.config.from_object('config')
db = SQLA(app)
session = db.session
appbuilder = AppBuilder(app, session)
"""
Only include this for SQLLite constraints
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
"""
from app.models import *
db.create_all()
from app import views
