def main(global_config, **settings): # pylint: disable=W0613
"""Creates app."""
engine = engine_from_config(settings, "sqlalchemy.")
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings, root_factory="models.Root")
config.include("pyramid_chameleon")
# api views
config.add_route("home", "/")
config.add_route("operate_record", "/records/{record_id}")
config.add_route("records", "/records")
# user views
config.add_route("record_table", "/table")
config.scan(".views")
# add static assets
config.add_static_view(name="static", path="bp_app:templates")
# add openapi config
config.include("pyramid_openapi3")
config.pyramid_openapi3_spec(
os.path.join(os.path.dirname(__file__), "openapi.yaml"))
config.pyramid_openapi3_add_explorer(route="docs")
# Pyramid requires an authorization policy to be active.
config.set_authorization_policy(ACLAuthorizationPolicy())
# Enable JWT authentication.
config.include("pyramid_jwt")
config.set_jwt_authentication_policy("secret")
return config.make_wsgi_app()
def init_db(config_path):
setup_logging(config_path)
settings = get_appsettings(config_path)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
print 'Done'
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
LOG.debug("settings:{}".format(settings))
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('jasny-css', 'static/jasny-bootstrap/css', cache_max_age=3600)
config.add_static_view('jasny-js', 'static/jasny-bootstrap/js', cache_max_age=3600)
config.add_route('login', '/')
config.add_route('logout', '/logout')
config.add_route('show_empl', '/employee/{emp_no}',
factory=EmployeeRootFactory)
config.add_route('show_dept', '/department/{dept_no}',
factory=DeptRootFactory)
auth_engine = AuthEngine()
config.add_settings(auth_engine=auth_engine)
authn_policy = AuthTktAuthenticationPolicy(settings['secret_key'],
callback=auth_engine.get_groups,
hashalg='sha512')
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(ACLAuthorizationPolicy())
query_parser = FormQueryParser()
config.add_settings(query_parser=query_parser)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
session_factory = UnencryptedCookieSessionFactoryConfig("lolololseekret")
config = Configurator(settings=settings, session_factory=session_factory)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('graphs', 'graphs')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('meal', '/meals/{date}')
config.add_route('meal_edit', '/meals/edit/{date}')
config.add_route('weight', '/weight')
config.add_route('weight_add', '/weight/add/')
config.add_route('home', '/')
config.add_route('chat_add', '/chat/add')
config.add_route('note_add', '/notes/add')
config.add_route('workout', '/workouts/{date}')
config.add_route('workout_edit', 'workouts/edit/{date}')
config.add_route('recipe', '/recipes')
config.add_route('recipe_view', '/recipes/{id}')
config.add_route('recipe_add', '/recipes/add')
config.scan()
return config.make_wsgi_app()
def init_db(config_path):
setup_logging(config_path)
settings = get_appsettings(config_path)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
print 'Done'
def main(set, config):
engine = create_engine(settings.database.get("url"))
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
"""
Lists of Endpoint and Transfer objectwith locks are shared between threads.
The classes and objects store all locks and necessary information to
sychronized transfers.
"""
global endpoints
global transfers
endpoints = [Endpoint(e) for e in config.get("endpoints")]
datasets = list(config.get("datasets").keys())
params = config.get("params")
if params:
GlobusTransfer.deadline = params.get("deadline", 3600)
transfers = [
GlobusTransfer(set, s, d, t) for s in endpoints for d in endpoints
for t in datasets
]
executor = Executor(max_workers=4)
while GlobusTransfer.transfers2do > 0:
for t in transfers:
if t.done:
continue
if t.acquire():
executor.submit(t.run)
sleep(10)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
config = Configurator(settings=settings)
config.include('pyramid_mako')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('index', '/')
config.add_route('accueil', '/accueil')
config.add_route('map', '/map')
config.add_route('map_stop', '/map/{stop_id}')
config.add_route('form_stop', '/form/{stop_id}')
config.add_route('trip', '/trip/{trip_id}')
config.add_route('test', '/test')
config.add_route('test_map', '/test_map')
config.add_route('stop_stop', '/stop/{stop_id}')
config.add_route('savoir', '/savoir')
config.add_route('json_stop', '/json_stop')
config.add_route('json_stops', '/json_stops')
config.add_route('json_hor', '/json_hor')
config.add_route('json_map', '/json_map')
config.add_route('json_form', '/json_form')
config.add_route('json_trip', '/json_trip')
config.scan()
return config.make_wsgi_app()
def main():
# Stupid workaround to wait for mysql actually starting inside of a container
time.sleep(15)
# Just init the database at the start for simplicity
db.create.init()
p = BackgroundEventPersister(Events)
p.start()
DBSession.configure(bind=Engine)
Base.metadata.bind = Engine
with Configurator() as config:
config.include('pyramid_tm')
config.add_request_method(get_user, 'user', reify=True)
config.add_route('place_order', '/orders', request_method='POST')
config.add_route('list_orders', '/orders', request_method='GET')
config.add_route('cancel_order', '/order/{orderId}', request_method='DELETE')
config.scan('views')
auth_policy = BasicAuthAuthenticationPolicy(check_credentials)
config.set_authentication_policy(auth_policy)
config.set_authorization_policy(ACLAuthorizationPolicy())
config.set_root_factory(lambda request: Root())
app = config.make_wsgi_app()
serve(app, host='0.0.0.0', port=8888)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
load_project_settings()
session_factory = UnencryptedCookieSessionFactoryConfig(settings.get('session.secret', 'hello'))
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
config = Configurator(session_factory=session_factory, settings=settings)
config.include('pyramid_handlers')
config.add_view('pyramid.view.append_slash_notfound_view',
context='pyramid.httpexceptions.HTTPNotFound')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('status', '/status')
config.add_route('settings', '/settings')
configure_app_routes(config)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
load_project_settings()
session_factory = UnencryptedCookieSessionFactoryConfig(settings.get('session.secret', 'hello'))
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
config = Configurator(session_factory=session_factory, settings=settings)
config.add_tween('giteverywhere.auth.authenticator')
config.include('pyramid_handlers')
config.add_view('pyramid.view.append_slash_notfound_view',
context='pyramid.httpexceptions.HTTPNotFound')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('contact', '/contact')
config.add_route('pyckauth_login', '/login')
config.add_route('pyckauth_logout', '/logout')
config.add_route('pyckauth_manager', '/auth')
config.add_route('pyckauth_users', '/auth/users')
config.add_route('pyckauth_permissions', '/auth/permissions')
config.add_route('pyckauth_routes', '/auth/routes')
add_admin_handler(config, DBSession, get_models(giteverywhere), 'admin.', '/admin', AdminController)
configure_app_routes(config)
config.scan()
return config.make_wsgi_app()
def setUp(self):
self.config = testing.setUp()
from sqlalchemy import create_engine
engine = create_engine('sqlite://')
from .models import (
Base,
MyModel,
)
DBSession.configure(bind=engine)
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
def setUp(self):
self.config = testing.setUp()
from sqlalchemy import create_engine
engine = create_engine('sqlite://')
from models import Base, MyModel
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
model = MyModel(name='one', value=55)
DBSession.add(model)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
if not 'pyramid.secretcookie' in settings:
log.error('pyramid.secretcookie is not set. Refusing to start.')
quit(-1)
if not 'pyramid.auth.secret' in settings:
log.error('pyramid.auth.secret is not set. Refusing to start.')
quit(-1)
if not 'defcne.upload_path' in settings:
log.error('defcne.upload_path is not set. Refusing to start.')
quit(-1)
if not 'defcne.registration_open' in settings:
log.error('defcne.registration_open is not set. Refusing to start.')
quit(-1)
else:
settings['defcne.registration_open'] = asbool(settings['defcne.registration_open'])
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
config = Configurator(settings=settings)
_session_factory = SignedCookieSessionFactory(
settings['pyramid.secretcookie'],
httponly=True,
max_age=864000
)
_authn_policy = AuthTktAuthenticationPolicy(
settings['pyramid.auth.secret'],
max_age=864000,
http_only=True,
debug=True,
hashalg='sha512',
callback=auth.user_groups,
)
_authz_policy = ACLAuthorizationPolicy()
config.set_session_factory(_session_factory)
config.set_authentication_policy(_authn_policy)
config.set_authorization_policy(_authz_policy)
config.include(add_routes)
config.include(add_views)
config.include(add_events)
deform_bootstrap.includeme(config)
config.set_request_property(auth.current_user, 'user', reify=True)
config.include('pyramid_mailer')
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
init_model()
session_factory = session_factory_from_settings(settings)
if 'localization' not in settings:
settings['localization'] = 'id_ID.UTF-8'
locale.setlocale(locale.LC_ALL, settings['localization'])
if 'timezone' not in settings:
settings['timezone'] = DefaultTimeZone
config = Configurator(settings=settings,
root_factory='reklame.models.RootFactory',
session_factory=session_factory)
config.include('pyramid_beaker')
config.include('pyramid_chameleon')
authn_policy = AuthTktAuthenticationPolicy('sosecret',
callback=group_finder, hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_request_method(get_user, 'user', reify=True)
config.add_request_method(get_title, 'title', reify=True)
config.add_notfound_view(RemoveSlashNotFoundViewFactory())
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('deform_static', 'deform:static')
config.add_static_view('files', settings['static_files'])
############################################################################
config.include('pyramid_rpc.jsonrpc') # JSON RPC
json_renderer = JSON()
json_renderer.add_adapter(datetime.datetime, lambda v, request: v.isoformat())
json_renderer.add_adapter(datetime.date, lambda v, request: v.isoformat())
config.add_renderer('myjson', json_renderer)
config.add_jsonrpc_endpoint('ws_reklame', '/ws/reklame', default_renderer="myjson")
############################################################################
routes = DBSession.query(Route.kode, Route.path, Route.nama).all()
for route in routes:
config.add_route(route.kode, route.path)
if route.nama:
titles[route.kode] = ' - '.join([main_title, route.nama])
config.scan()
app = config.make_wsgi_app()
from paste.translogger import TransLogger
app = TransLogger(app, setup_console_handler=False)
return app
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
config = Configurator(settings=settings)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.scan()
return config.make_wsgi_app()
def bind_database_session(config_file='config.yml'):
logger.debug(f"Getting database session from {config_file}")
config = yml_config_as_dict(config_file)
engine = engine_from_config(config, 'sqlalchemy.')
db_exists = database_exists(engine.url)
logger.debug(f"Database {'' if db_exists else 'does not'} exists.")
if db_exists:
DBSession.configure(bind=engine)
def init_test_db():
"""Create testing database."""
engine = create_engine("sqlite://")
Base.metadata.create_all(engine)
DBSession.configure(bind=engine)
with transaction.manager:
model = Record(timestamp=datetime.utcnow(),
bp_upper=120,
bp_lower=70,
notes="")
DBSession.add(model) # pylint: disable=E1101
return DBSession
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
admin = Admin(name='admin', pw='admin')
DBSession.add(admin)
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, "sqlalchemy.")
DBSession.configure(bind=engine)
Base.metadata.create_all(engine, check=True)
with transaction.manager:
model = Page("FrontPage", "This is the front page")
DBSession.add(model)
def setUp(self):
self.config = testing.setUp()
# @TODO change this
from . import main
settings = {'sqlalchemy.url': 'sqlite://', 'session.secret': 'secret'}
app = main({}, **settings)
self.testapp = TestApp(app)
engine = create_engine('sqlite://')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
def setUp(self):
self.config = testing.setUp()
# @TODO change this
from . import main
settings = {'sqlalchemy.url': 'sqlite://', 'session.secret': 'secret'}
app = main({}, **settings)
self.testapp = TestApp(app)
engine = create_engine('sqlite://')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
model = BadCase(url='one')
DBSession.add(model)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
authn_policy = AuthTktAuthenticationPolicy('rklain', callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings, root_factory='myblog.models.RootFactory')
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.set_request_property(get_user, 'user', reify=True)
# routes/views
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('files', 'files', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
#User
#config.add_route('user_add', 'user/add')
config.add_route('user_edit', 'user/{id}/edit')
#config.add_route('user_delete', 'user/{id}/delete')
# Page
config.add_route('page_add', '/page/add')
config.add_route('page_view', '/page/{route}')
config.add_route('page_edit', '/page/{route}/edit')
config.add_route('page_delete', '/page/{route}/delete')
# Blog
config.add_route('post_add', '/blog/add')
config.add_route('post_view_y', '/blog/{year}')
config.add_route('post_view_ym', '/blog/{year}/{month}')
config.add_route('post_view_ymd', '/blog/{year}/{month}/{day}')
config.add_route('post_view', '/blog/{year}/{month}/{day}/{route}')
config.add_route('post_edit', '/blog/{year}/{month}/{day}/{route}/edit')
config.add_route('post_delete', '/blog/{year}/{month}/{day}/{route}/delete')
config.add_route('post_comment_delete', '/blog/{year}/{month}/{day}/{route}/comment/{id}/delete')
# Image
config.add_route('image_add', '/image/add')
config.add_route('image_view', '/image/{id}')
# config.add_route('image_edit', '/image/{route}/edit')
# config.add_route('image_delete', '/image/{route}/delete')
config.scan()
#jinja2
config.include('pyramid_jinja2')
#config.get_jinja2_environment().filters['rst2htmlbody'] = rst2htmlbody
config.get_jinja2_environment().filters['markdown'] = markup
return config.make_wsgi_app()
def main(global_config, **settings):
config = Configurator(settings=settings)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
config.include('pyramid_jinja2')
config.add_route('item', '/{id}')
config.add_route('list', '/')
config.scan('xtnews.views')
return config.make_wsgi_app()
def main(global_config, **settings):
config = Configurator(settings=settings)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
config.include('pyramid_jinja2')
config.add_route('item', '/{id}')
config.add_route('list', '/')
config.scan('xtnews.views')
return config.make_wsgi_app()
def main(argv=sys.argv):
print 'called'
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
model = Users(first_name='Julien', last_name='waddle')
DBSession.add(model)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
load_project_settings()
session_factory = UnencryptedCookieSessionFactoryConfig(settings.get('session.secret', 'hello'))
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
config = Configurator(session_factory=session_factory, settings=settings)
config.add_tween('smpp5web.auth.authenticator')
config.include('pyramid_handlers')
config.add_view('pyramid.view.append_slash_notfound_view',
context='pyramid.httpexceptions.HTTPNotFound')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('contact', '/contact')
config.add_route('sms_in', '/sms_in')
config.add_route('main_page', '/main_page')
config.add_route('admin_page', '/admin_page')
config.add_route('sms_history', '/sms_history')
config.add_route('billing', '/billing')
config.add_route('weeklygraphs', '/weeklygraphs')
config.add_route('dailygraphs', '/dailygraphs')
config.add_route('monthlygraphs', '/monthlygraphs')
config.add_route('usermonthlygraphs', '/usermonthlygraphs')
config.add_route('useryearlygraphs', '/useryearlygraphs')
config.add_route('packages', '/packages')
config.add_route('select_packages', '/select_packages')
config.add_route('reset_password', '/reset_password')
config.add_route('display_users', '/display_users')
config.add_route('sms_history_admin', '/sms_history_admin')
config.add_route('user_graphs', '/user_graphs')
config.add_route('pyckauth_login', '/login')
config.add_route('pyckauth_logout', '/logout')
config.add_route('pyckauth_manager', '/auth')
config.add_route('pyckauth_users', '/auth/users')
config.add_route('pyckauth_permissions', '/auth/permissions')
config.add_route('pyckauth_routes', '/auth/routes')
add_admin_handler(config, DBSession, get_models(smpp5web), 'admin.', '/admin', AdminController)
configure_app_routes(config)
config.scan()
return config.make_wsgi_app()
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
DBSession.add(JobOffers())
DBSession.add(JobCategories())
DBSession.add(Companies())
def main(**settings):
engine = create_engine('sqlite:///dev.db')
Base.metadata.create_all(engine)
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.add_route('server', '/api/server/{uid}')
config.add_route('servers', '/api/server')
config.scan("views")
config.add_static_view('www', '../www/', cache_max_age=86400)
app = config.make_wsgi_app()
return app
def setUp(self):
self.config = testing.setUp()
from sqlalchemy import create_engine
engine = create_engine('sqlite://')
from models import (
Base,
Node,
Post,
Comment,
Tag,
NodeTag,
)
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
def main(**settings):
engine = create_engine('sqlite:///dev.db')
Base.metadata.create_all(engine)
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.add_route('server', '/api/server/{uid}')
config.add_route('servers', '/api/server')
config.scan("views")
config.add_static_view('www', '../www/',
cache_max_age=86400)
app = config.make_wsgi_app()
return app
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
my_session_factory = UnencryptedCookieSessionFactoryConfig('itsaseekreet')
config = Configurator(settings=settings, session_factory=my_session_factory)
# config.add_request_method(get_user, 'user', reify=True)
config.add_renderer('json', JSON(indent=0))
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('main', '/main')
config.add_route('home1', '/home1')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('admin', '/admin')
config.add_route('admin_apps', '/admin/apps')
config.add_route('admin_apps_grid', '/admin/apps/grid')
config.add_route('admin_apps_update_stat', '/admin/apps/update_stat/{id}/{value}')
config.add_route('hello', '/hello')
config.add_route('get_pesan', '/get_pesan')
from admin_route import admin_route
add_route(config, admin_route)
from pbb_route import pbb_route
add_route(config, pbb_route)
from pbbm_route import pbbm_route
add_route(config, pbbm_route)
from apbd_route import apbd_route
add_route(config, apbd_route)
from aset_route import aset_route
print aset_route
add_route(config, aset_route)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
init_model()
session_factory = session_factory_from_settings(settings)
if 'localization' not in settings:
settings['localization'] = 'id_ID.UTF-8'
locale.setlocale(locale.LC_ALL, settings['localization'])
if 'timezone' not in settings:
settings['timezone'] = DefaultTimeZone
config = Configurator(settings=settings,
root_factory='inventory.models.RootFactory',
session_factory=session_factory)
config.include('pyramid_beaker')
config.include('pyramid_chameleon')
authn_policy = AuthTktAuthenticationPolicy('sosecret',
callback=group_finder,
hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_request_method(get_user, 'user', reify=True)
config.add_request_method(get_title, 'title', reify=True)
config.add_notfound_view(RemoveSlashNotFoundViewFactory())
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('deform_static', 'deform:static')
config.add_static_view('files', settings['static_files'])
routes = DBSession.query(Route.kode, Route.path, Route.nama).all()
for route in routes:
config.add_route(route.kode, route.path)
if route.nama:
titles[route.kode] = ' - '.join([main_title, route.nama])
config.scan()
app = config.make_wsgi_app()
from paste.translogger import TransLogger
app = TransLogger(app, setup_console_handler=False)
return app
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
# pyramid_jinja2 configuration
config.include('pyramid_jinja2')
config.include('sacrud.pyramid_ext')
settings = config.registry.settings
settings['sacrud_models'] = (User, Profile)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('tweets', '/tweets')
config.add_view(root_view, 'tweets')
config.add_route('topic', '/topic')
config.add_view(enqueue_topic, 'topic')
config.add_route('raw_topic', '/raw_topic')
config.add_view(raw_topic_enqueue, 'raw_topic')
# config.scan() significantly improves the runtime
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('tweets', '/tweets')
config.add_view(root_view, 'tweets')
config.add_route('topic', '/topic')
config.add_view(enqueue_topic, 'topic')
config.add_route('raw_topic', '/raw_topic')
config.add_view(raw_topic_enqueue, 'raw_topic')
# config.scan() significantly improves the runtime
return config.make_wsgi_app()
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
manager = Manager()
password = manager.encode('admin')
DBSession.add(Entry(title=u'title', body=u'body'))
DBSession.add(User(username=u'admin', password=password))
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, "sqlalchemy.")
DBSession.configure(bind=engine)
Base.metadata.bind = engine
init_model()
session_factory = session_factory_from_settings(settings)
if "localization" not in settings:
settings["localization"] = "id_ID.UTF-8"
locale.setlocale(locale.LC_ALL, settings["localization"])
if "timezone" not in settings:
settings["timezone"] = DefaultTimeZone
config = Configurator(
settings=settings, root_factory="inventory.models.RootFactory", session_factory=session_factory
)
config.include("pyramid_beaker")
config.include("pyramid_chameleon")
authn_policy = AuthTktAuthenticationPolicy("sosecret", callback=group_finder, hashalg="sha512")
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_request_method(get_user, "user", reify=True)
config.add_request_method(get_title, "title", reify=True)
config.add_notfound_view(RemoveSlashNotFoundViewFactory())
config.add_static_view("static", "static", cache_max_age=3600)
config.add_static_view("deform_static", "deform:static")
config.add_static_view("files", settings["static_files"])
routes = DBSession.query(Route.kode, Route.path, Route.nama).all()
for route in routes:
config.add_route(route.kode, route.path)
if route.nama:
titles[route.kode] = " - ".join([main_title, route.nama])
config.scan()
app = config.make_wsgi_app()
from paste.translogger import TransLogger
app = TransLogger(app, setup_console_handler=False)
return app
def main(argv=sys.argv): # pylint: disable=W0102
"""Initial database setup."""
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, "sqlalchemy.")
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
current_time = datetime.utcnow()
for i in range(14):
record = Record()
record.timestamp = current_time - timedelta(days=i)
record.bp_upper = random.randint(100, 160)
record.bp_lower = random.randint(50, 80)
DBSession.add(record) # pylint: disable=E1101
def main(global_config, **settings):
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
authentication_policy = AuthTktAuthenticationPolicy('somesecret')
authorization_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
authentication_policy=authentication_policy,
authorization_policy=authorization_policy)
config.include('pyramid_mako')
config.include('.models')
config.add_route('index', '/')
config.add_route('admin','/admin')
config.add_route('blog_action', '/blog/{action}',
factory='.models.Root')
config.add_route('blog_view','/blogview')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
load_project_settings()
session_factory = UnencryptedCookieSessionFactoryConfig(
settings.get('session.secret', 'hello'))
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
config = Configurator(session_factory=session_factory, settings=settings)
config.add_tween('giteverywhere.auth.authenticator')
config.include('pyramid_handlers')
config.add_view('pyramid.view.append_slash_notfound_view',
context='pyramid.httpexceptions.HTTPNotFound')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('contact', '/contact')
config.add_route('pyckauth_login', '/login')
config.add_route('pyckauth_logout', '/logout')
config.add_route('pyckauth_manager', '/auth')
config.add_route('pyckauth_users', '/auth/users')
config.add_route('pyckauth_permissions', '/auth/permissions')
config.add_route('pyckauth_routes', '/auth/routes')
#config.add_route('add_repo_names', '/add_repo_names')
#config.add_route('display', '/display')
config.add_route('view_repo_names', '/view_repo_names')
#config.add_route('delete_product', '/delete/{repo_id}')
add_admin_handler(config, DBSession, get_models(giteverywhere), 'admin.',
'/admin', AdminController)
configure_app_routes(config)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
LOG.debug("settings:{}".format(settings))
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('jasny-css',
'static/jasny-bootstrap/css',
cache_max_age=3600)
config.add_static_view('jasny-js',
'static/jasny-bootstrap/js',
cache_max_age=3600)
config.add_route('login', '/')
config.add_route('logout', '/logout')
config.add_route('show_empl',
'/employee/{emp_no}',
factory=EmployeeRootFactory)
config.add_route('show_dept',
'/department/{dept_no}',
factory=DeptRootFactory)
auth_engine = AuthEngine()
config.add_settings(auth_engine=auth_engine)
authn_policy = AuthTktAuthenticationPolicy(settings['secret_key'],
callback=auth_engine.get_groups,
hashalg='sha512')
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(ACLAuthorizationPolicy())
query_parser = FormQueryParser()
config.add_settings(query_parser=query_parser)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings)
config.include('pyramid_mako')
config.include('pyramid_tm')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('wizconfig', '/wizconfig')
config.add_route('wizconfig_start', '/wizconfig/start')
# config.add_route('kbhook_setprompt', '/kbhook/setprompt')
config.add_route('wizconfig_next', '/wizconfig/next/{id}')
config.add_route('wizconfig_prev', '/wizconfig/prev/{id}')
config.add_route('wizconfig_exit', '/wizconfig/exit/{id}')
config.add_route('wizconfig_review', '/wizconfig/review/{id}')
config.add_route('wizconfig_apply', '/wizconfig/apply/{id}')
config.scan()
config.set_session_factory(my_session_factory)
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
session_factory = session_factory_from_settings(settings)
authn_policy = AuthTktAuthenticationPolicy( 'sosecret', callback=groupfinder, hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings, root_factory='geogallery.models.models.RootFactory')
config.set_request_property(get_user, str('user'), reify=True)
config.include('bag.web.pyramid.flash_msg')
config.set_session_factory(session_factory)
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_static_view('static', 'static', cache_max_age=3600)
# Adding the static resources from Deform
config.add_static_view('deform_static', 'deform:static', cache_max_age=3600)
config.add_static_view('deform_bootstrap_static', 'deform_bootstrap:static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('login', '/login')
config.scan()
return config.make_wsgi_app()
def init_databases(config_file='config.yml', drop_old=False):
logger.debug(
f"Initializing database from {config_file}, drop_old={drop_old}")
# Set up a DB from config file
config = yml_config_as_dict(config_file)
engine = engine_from_config(config, 'sqlalchemy.') # TODO DRY or overkill?
db_preexists = database_exists(engine.url)
logger.debug(f"Database {'already' if db_preexists else 'does not'} exist")
if not db_preexists:
create_database(engine.url)
if drop_old and db_preexists: # Drop database?
logger.debug("Dropping databases...")
try:
drop_all_tables(engine)
except sqlalchemy.exc.DatabaseError as e:
logger.warning(
f"Intialize DB Error:\n{type(e).__name__}: {str(e)}")
logger.warning("Attempting to drop entire database.")
drop_database(engine.url)
elif not db_preexists:
logger.warning(
f"Not attempting to drop tables since it the database didn't exist beforehand."
)
DBSession.configure(bind=engine)
try:
logger.debug("Generating tables from Base.")
Base.metadata.create_all(engine)
logger.debug("Tables generated.")
except sqlalchemy.exc.InternalError as e:
usage(message=f"Intialize DB Error:\n{type(e).__name__}: {str(e)}")
from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound
#Import sqlalchemy objects
from models import DBSession as db, City, WeatherRecord
#import the session manager. This way commits will be handled automatically by the Zope Transaction Manager
import transaction
# Load Application Configuration and Return as Dictionary
conf = appconfig('config:' + '../development.ini',
name="main", relative_to=os.getcwd())
#configure SQLAlchemy engine
engine = engine_from_config(conf, 'sqlalchemy.')
db.configure(bind=engine)
def update_weather_data(city_id, start_dt):
timestamp = time.mktime(start_dt.timetuple())
api_url = 'http://api.openweathermap.org/data/2.5/history/city?id=%d&type=day&start=%d' % (city_id, timestamp)
response = urlopen(api_url)
data = json.loads(response.read().decode())
conditions = { }
for d in data['list']:
dt = datetime.datetime.fromtimestamp(int(d['dt'])).date()
cond = d['weather'][0]['main']
conditions.setdefault(dt, []).append(cond)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
init_model()
###Engine Tambahan
if settings['pbb.url']:
from models.pbb import (PbbDBSession, PbbBase)
os.environ["NLS_LANG"] = ".AL32UTF8"
pbb_engine = engine_from_config(
settings, 'pbb.') #, encoding='.AL32UTF8', convert_unicode=True)
PbbDBSession.configure(bind=pbb_engine)
PbbBase.metadata.bind = pbb_engine
pbb_schema = settings['pbb_schema']
if settings['pospbb.url']:
from models.pospbb import (
PosPbbDBSession,
PosPbbBase,
)
pospbb_engine = engine_from_config(settings, 'pospbb.')
PosPbbDBSession.configure(bind=pospbb_engine)
PosPbbBase.metadata.bind = pospbb_engine
pospbb_schema = settings['pospbb_schema']
session_factory = session_factory_from_settings(settings)
if 'localization' not in settings:
settings['localization'] = 'id_ID.UTF-8'
locale.setlocale(locale.LC_ALL, settings['localization'])
if 'timezone' not in settings:
settings['timezone'] = DefaultTimeZone
config = Configurator(settings=settings,
root_factory='pbbrekon.models.RootFactory',
session_factory=session_factory)
config.include('pyramid_beaker')
config.include('pyramid_chameleon')
authn_policy = AuthTktAuthenticationPolicy('sosecret',
callback=group_finder,
hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_request_method(get_user, 'user', reify=True)
config.add_request_method(get_title, 'title', reify=True)
config.add_notfound_view(RemoveSlashNotFoundViewFactory())
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('deform_static', 'deform:static')
config.add_static_view('files', settings['static_files'])
config.add_renderer('csv', '.tools.CSVRenderer')
for name, path, title in routes:
config.add_route(name, path)
config.scan()
app = config.make_wsgi_app()
from paste.translogger import TransLogger
app = TransLogger(app, setup_console_handler=False)
return app
Menu,
MenuItem,
Allergen,
Cafe,
)
MAIL_SECRETS = '/home/tina/mail_secrets.json'
HEALTH_COLORS = ['green', 'orange', 'red']
BREAKFAST_LUNCH_CUTOFF_HOUR = 10
LUNCH_DINNER_CUTOFF_HOUR = 14
if __name__ == '__main__':
config_uri = "/home/tina/MenuProject/production.ini"
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
now = datetime.datetime.now()
today = now.strftime('%Y-%m-%d')
#figure out which meal this is for
meal_filter = 1
if now.hour < BREAKFAST_LUNCH_CUTOFF_HOUR:
meal_filter = 1
elif BREAKFAST_LUNCH_CUTOFF_HOUR <= now.hour < LUNCH_DINNER_CUTOFF_HOUR:
meal_filter = 2
else:
meal_filter = 3
menu_query = DBSession.query(Menu).filter(Menu.date==today).filter(Menu.time_sort_key==meal_filter)
if len(menu_query.all()) > 0:
def tournament(args):
# Configuration
engine = create_engine('sqlite:///' + args.bdd, echo=False)
DBSession.configure(bind=engine)
# On récupere les donnes de la BDD
students = DBSession.query(Etudiant).filter(Etudiant.enseignant.is_(None))
nb_students = DBSession.query(Etudiant).filter(
Etudiant.enseignant.is_(None)).count()
nb_parcours = DBSession.query(Parcours).count()
# Capacité des groupes
capa_min_pec = 14
capa_max_pec = 16
capa_min_pel = 14
capa_max_pel = 16
# On construit le modèle
barre_min = args.b
model = CyClpSimplex()
x = []
s_list = {}
for s in students.all():
v = model.addVariable('etu' + str(s.id), nb_parcours, isInt=True)
x.append(v)
z = 0.0
i = 0
for s in students.all():
reorder = False
s_list[str(i)] = s.id
voeux = DBSession.query(Voeu).filter(Voeu.idEtudiant == s.id).order_by(
Voeu.idParcours).all()
s_voeux = []
rang_q = voeux[nb_parcours - 1].rang
if rang_q != nb_parcours and rang_q != -1:
if s.nom not in special or 'quebec' not in special[s.nom]:
reorder = True
else:
reorder = not special[s.nom]['quebec']
for v in voeux:
if v.rang == -1:
score = 0
else:
if reorder and v.rang > rang_q:
rang = v.rang - 1
elif reorder and v.rang == rang_q:
rang = 9
else:
rang = v.rang
malus = 0.0
if s.malus > 0:
malus += s.malus
if s.absences is not None:
malus += float(s.absences) / 15
score = 2.0**(rang - malus)
s_voeux.append(score)
a = CyLPArray(s_voeux)
b = CyLPArray([1.0 for j in range(nb_parcours)])
z += a * x[i]
model += b * x[i] >= 1
model += b * x[i] <= 1
model += x[i] >= 0
model += x[i] <= 1
i += 1
model.objective = z
# Taille des groupes MpInge (PEL)
for j in [
0, 3, 6
]: # Attention, dans la BDD, le parcours vont de 1 à 8 -> décalage de 1
c = 0
for i in range(nb_students):
c += x[i][j]
model += c <= capa_max_pel
model += c >= capa_min_pel
# Taille des groupes PEC
for j in [1, 2, 4, 5, 7]:
c = 0
for i in range(nb_students):
c += x[i][j]
model += c <= capa_max_pec
model += c >= capa_min_pec
# Etudiants trop bas en maths
i = 0
for s in students.all():
if s.moyenneMaths is not None and s.moyenneMaths < barre_min:
model += x[i][0] + x[i][3] + x[i][6] == 0
i += 1
# Québec
i = 0
for s in students.all():
if s.nom not in special or 'quebec' not in special[s.nom]:
model += x[i][nb_parcours - 1] == 0
i += 1
# Cas particuliers (cf special.py)
i = 0
for s in students.all():
if s.nom in special and 'force' in special[s.nom]:
for cas in special[s.nom]['force']:
if not special[s.nom]['force'][cas]:
model += x[i][int(cas) - 1] == 0
i += 1
cbc_model = model.getCbcModel()
cbc_model.logLevel = 0
cbc_model.branchAndBound()
if cbc_model.isRelaxationOptimal() and args.v:
for s in students.all():
r = cbc_model.primalVariableSolution['etu' + str(s.id)]
print s.nom + '|',
j = 1
reorder = False
for res in r:
if res == 1:
if j == 1 or j == 4 or j == 7:
print "!",
par = DBSession.query(Parcours).filter(
Parcours.id == j).one()
print par.nom,
voeux = DBSession.query(Voeu).filter(
Voeu.idEtudiant == s.id).order_by(
Voeu.idParcours).all()
rang_q = voeux[nb_parcours - 1].rang
if rang_q != nb_parcours and rang_q != -1:
if s.nom not in special or 'quebec' not in special[
s.nom]:
reorder = True
else:
reorder = not special[s.nom]['quebec']
son_voeu = DBSession.query(Voeu).filter(
Voeu.idEtudiant == s.id).filter(
Voeu.idParcours == j).one()
if reorder and son_voeu.rang == rang_q:
rang = 9
elif reorder and son_voeu.rang > rang_q:
rang = son_voeu.rang - 1
else:
rang = son_voeu.rang
print '|' + str(rang) + '',
print '|' + str(s.moyenneMaths),
print '|' + str(s.absences),
if reorder:
print '|*'
else:
print '|'
j += 1
nb_stu_grp = [0 for n in range(nb_parcours)]
rangs_stu = [0 for n in range(nb_parcours)]
indecis = 0
pec2pel = 0
pel2pec = 0
if cbc_model.isRelaxationOptimal() and (args.s or args.csv):
for s in students.all():
r = cbc_model.primalVariableSolution['etu' + str(s.id)]
j = 1
reorder = False
for res in r:
if res == 1:
nb_stu_grp[j - 1] += 1
voeux = DBSession.query(Voeu).filter(
Voeu.idEtudiant == s.id).order_by(
Voeu.idParcours).all()
rang_q = voeux[nb_parcours - 1].rang
if rang_q != nb_parcours and rang_q != -1:
if s.nom not in special or 'quebec' not in special[
s.nom]:
reorder = True
else:
reorder = not special[s.nom]['quebec']
son_voeu = DBSession.query(Voeu).filter(
Voeu.idEtudiant == s.id).filter(
Voeu.idParcours == j).one()
if reorder and son_voeu.rang == rang_q:
rang = 9
elif reorder and son_voeu.rang > rang_q:
rang = son_voeu.rang - 1
else:
rang = son_voeu.rang
if rang != -1:
rangs_stu[rang - 1] += 1
son_voeu_un = DBSession.query(Voeu).filter(
Voeu.idEtudiant == s.id).filter(
Voeu.rang == 1).one()
if son_voeu_un.idParcours in [
1, 4, 7
] and son_voeu.idParcours not in [1, 4, 7]:
pel2pec += 1
elif son_voeu_un.idParcours not in [
1, 4, 7
] and son_voeu.idParcours in [1, 4, 7]:
pec2pel += 1
else:
indecis += 1
j += 1
if args.s:
print "Etudiants par groupe : ", nb_stu_grp
print "Etudiants par rang de voeu : ", rangs_stu
print "Passages PEC->PEL", pec2pel
print "Passage PEL->PEC", pel2pec
print "Indécis : ", indecis
if args.csv:
print barre_min, ",",
for item in nb_stu_grp:
print item, ",",
for item in rangs_stu:
print item, ",",
print pec2pel, ",", pel2pec
if cbc_model.isRelaxationInfeasible():
print "Pas de solution possible"
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
init_model()
#if 'pbb.url' in settings and settings['pbb.url']:
pbb_engine = engine_from_config(settings, 'pbb.')
pbb_DBSession.configure(bind=pbb_engine)
pbb_Base.metadata.bind = pbb_engine
pbb_Base.pbb_schema = settings['pbb_schema'] or None
#pbb = {'kd_kanwil':settings['pbb_kd_kanwil'] or '01',
# 'kd_kantor':settings['pbb_kd_kantor'] or '01',}
session_factory = session_factory_from_settings(settings)
if 'localization' not in settings:
settings['localization'] = 'id_ID.UTF-8'
locale.setlocale(locale.LC_ALL, settings['localization'])
if 'timezone' not in settings:
settings['timezone'] = DefaultTimeZone
config = Configurator(settings=settings,
root_factory='opensipkdrpc.models.RootFactory',
session_factory=session_factory)
config.include('pyramid_beaker')
config.include('pyramid_chameleon')
authn_policy = AuthTktAuthenticationPolicy('sosecret',
callback=group_finder,
hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_request_method(get_user, 'user', reify=True)
config.add_request_method(get_title, 'title', reify=True)
config.add_notfound_view(RemoveSlashNotFoundViewFactory())
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('deform_static', 'deform:static')
config.add_static_view('files', settings['static_files'])
############################################################################
config.include('pyramid_rpc.jsonrpc') # JSON RPC
json_renderer = JSON()
json_renderer.add_adapter(datetime.datetime,
lambda v, request: v.isoformat())
json_renderer.add_adapter(datetime.date, lambda v, request: v.isoformat())
config.add_renderer('myjson', json_renderer)
config.add_jsonrpc_endpoint('ws_user',
'/ws/user',
default_renderer="myjson")
config.add_jsonrpc_endpoint('ws_pbb', '/ws/pbb', default_renderer="myjson")
############################################################################
routes = DBSession.query(Route.kode, Route.path, Route.nama).all()
for route in routes:
config.add_route(route.kode, route.path)
if route.nama:
titles[route.kode] = ' - '.join([main_title, route.nama])
config.scan()
app = config.make_wsgi_app()
from paste.translogger import TransLogger
app = TransLogger(app, setup_console_handler=False)
return app
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings,
'sqlalchemy.',
pool_size=settings['pool_size'],
max_overflow=settings['max_overflow'])
#engine.pool_size = settings['pool_size']
#engine.
DBSession.configure(bind=engine)
Base.metadata.bind = engine
init_model()
if 'sipkd.url' in settings and settings['sipkd.url']:
from sipkd.models import sipkdDBSession, sipkdBase
engineSipkd = engine_from_config(settings, 'sipkd.')
sipkdDBSession.configure(bind=engineSipkd,
pool_size=settings['pool_size'],
max_overflow=settings['max_overflow'])
sipkdBase.metadata.bind = engineSipkd
#added 09-08-2016
if 'pdl.url' in settings and settings['pdl.url']:
from pdl.models import pdlDBSession, pdlBase
enginePdl = engine_from_config(settings,
'pdl.',
pool_size=settings['pool_size'],
max_overflow=settings['max_overflow'])
pdlDBSession.configure(bind=enginePdl)
pdlBase.metadata.bind = enginePdl
pdl_schema = 'schema.pdl' in settings and settings[
'schema.pdl'] or 'public'
if 'pbb.url' in settings and settings['pbb.url']:
from pbb.models import pbbDBSession, pbbBase, pbb_schema
enginePbb = engine_from_config(settings,
'pbb.',
pool_size=settings['pool_size'],
max_overflow=settings['max_overflow'])
pbbDBSession.configure(bind=enginePbb)
pbbBase.metadata.bind = enginePbb
pbb_schema = 'schema.pbb' in settings and settings[
'schema.pbb'] or 'pbb'
if 'bphtb.url' in settings and settings['bphtb.url']:
from bphtb.models import bphtbDBSession, bphtbBase, bphtb_schema
engineBphtb = engine_from_config(settings,
'bphtb.',
pool_size=settings['pool_size'],
max_overflow=settings['max_overflow'])
bphtbDBSession.configure(bind=engineBphtb)
bphtbBase.metadata.bind = engineBphtb
bphtb_schema = 'schema.bphtb' in settings and settings[
'schema.bphtb'] or 'bphtb'
if 'esppt.url' in settings and settings['esppt.url']:
from esppt.models import EsDBSession, EsBase, es_schema
engineEsppt = engine_from_config(settings,
'esppt.',
pool_size=settings['pool_size'],
max_overflow=settings['max_overflow'])
EsDBSession.configure(bind=engineEsppt)
EsBase.metadata.bind = engineEsppt
es_schema = 'schema.esppt' in settings and settings[
'schema.esppt'] or 'esppt'
if 'im.url' in settings and settings['im.url']:
from im.models import ImDBSession, ImBase, im_schema
engineIm = engine_from_config(settings,
'im.',
pool_size=settings['pool_size'],
max_overflow=settings['max_overflow'])
ImDBSession.configure(bind=engineIm)
ImBase.metadata.bind = engineIm
im_schema = 'schema.im' in settings and settings['schema.im'] or 'im'
if 'pospbb.url' in settings and settings['pospbb.url']:
from pbb_tools.models import PosPbbDBSession, PosPbbBase, pospbb_schema
enginePosPbb = engine_from_config(
settings,
'pospbb.',
pool_size=settings['pool_size'],
max_overflow=settings['max_overflow'])
PosPbbDBSession.configure(bind=enginePosPbb)
PosPbbBase.metadata.bind = enginePosPbb
im_schema = 'schema.pospbb' in settings and settings[
'schema.pospbb'] or 'pbb'
session_factory = session_factory_from_settings(settings)
#session_factory.pool_size=settings['pool_size']
#session_factory.max_overflow = settings['max_overflow']
#if 'localization' not in settings:
# settings['localization'] = 'id_ID.UTF-8'
#locale.setlocale(locale.LC_ALL, settings['localization'])
#handling bug di locale.setlocale
localID = locale.normalize('id')
if 'localization' not in settings:
settings['localization'] = localID
if settings['localization'] != localID:
settings['localization'] = localID
#locale.setlocale(locale.LC_ALL, settings['localization'])
#bug : unsupported locale setting
locale.setlocale(locale.LC_ALL, '')
if 'timezone' not in settings:
settings['timezone'] = DefaultTimeZone
config = Configurator(settings=settings,
root_factory='piutang.models.RootFactory',
session_factory=session_factory)
config.include('pyramid_beaker')
config.include('pyramid_chameleon')
authn_policy = AuthTktAuthenticationPolicy('sosecret',
callback=group_finder,
hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_request_method(get_user, 'user', reify=True)
config.add_request_method(get_title, 'title', reify=True)
config.add_request_method(get_company, 'company', reify=True)
config.add_request_method(get_departement, 'departement', reify=True)
config.add_request_method(get_address, 'address', reify=True)
config.add_notfound_view(RemoveSlashNotFoundViewFactory())
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('deform_static', 'deform:static')
config.add_static_view('files', settings['static_files'])
config.add_renderer('csv', '.tools.CSVRenderer')
routes = DBSession.query(Route.kode, Route.path, Route.nama).all()
for route in routes:
#if route.factory and route.factory != 'None':
# config.add_route(route.kode, route.path) #(route.factory).encode("utf8"))
#else:
config.add_route(route.kode, route.path)
if route.nama:
titles[route.kode] = route.nama
############################################################################
config.include('pyramid_rpc.jsonrpc') # JSON RPC
json_renderer = JSON()
json_renderer.add_adapter(datetime.datetime,
lambda v, request: v.isoformat())
json_renderer.add_adapter(datetime.date, lambda v, request: v.isoformat())
config.add_renderer('myjson', json_renderer)
config.add_jsonrpc_endpoint('ws_pbb',
'/pbb/ws/api',
default_renderer="myjson")
config.add_jsonrpc_endpoint('ws_keuangan',
'/ws/keuangan',
default_renderer="myjson")
config.add_jsonrpc_endpoint('ws_simral',
'/simral/ws/api',
default_renderer="myjson")
config.add_jsonrpc_endpoint('ws_user',
'/ws/user',
default_renderer="myjson")
############################################################################
config.scan()
app = config.make_wsgi_app()
from paste.translogger import TransLogger
app = TransLogger(app, setup_console_handler=False)
return app
from models import DBSession, Base, Colleague, ColleagueLocus, Dbentity, Eco, Locusdbentity, LocusUrl, LocusAlias, Dnasequenceannotation, So, Locussummary, Phenotypeannotation, PhenotypeannotationCond, Phenotype, Goannotation, Go, Goslimannotation, Goslim, Apo, Straindbentity, Strainsummary, Reservedname, GoAlias, Goannotation, Referencedbentity, Referencedocument, Referenceauthor, ReferenceAlias, Chebi
from sqlalchemy import create_engine, and_, inspect
import os
import json
import re
import time
import sys
from random import randint
from datetime import datetime
from threading import Thread
import concurrent.futures
engine = create_engine(os.getenv('SQLALCHEMY_PROD_DB_URI'), pool_recycle=3600)
SUBMISSION_VERSION = os.getenv('SUBMISSION_VERSION', '_1.0.0.0_')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
THIS_FOLDER = os.path.dirname(os.path.abspath(__file__))
# populate text file with sgdis to be used to retrieve panther data
def get_sgdids_for_panther():
new_data = Locusdbentity.get_s288c_genes()
temp = []
for loc in new_data:
temp.append(loc.sgdid)
txt_file = os.path.join(THIS_FOLDER,
'data_assets/panther_search_input.txt')
result = json.dumps(temp, ensure_ascii=False)
with open(txt_file, 'w+') as res_file:
res_file.write(
