def main(global_config, **settings):
config = Configurator(settings=settings)
config.include('pyramid_jinja2')
config.include('pyramid_tm')
config.include('pyramid_exclog')
config.include('pyramid_persona')
config.include('cornice')
# prevent conflicts with persona
# and beaker/photoapp config
config.commit()
config.include('pyramid_beaker')
# my stuff
config.include('photoapp.models')
config.include('photoapp.storage')
config.include('photoapp.auth')
config.include('photoapp.mail')
config.include('photoapp.assets')
config.include('photoapp.routes')
config.include('photoapp.tweens')
# caching
set_cache_regions_from_settings(settings)
config.scan()
return config.make_wsgi_app()
def config(request, pyramid_request, settings, registry):
""" returns a Pyramid `Configurator` object initialized
with Kotti's default (test) settings.
"""
os.environ['TZ'] = "Europe/Paris"
from pyramid_beaker import set_cache_regions_from_settings
config = testing.setUp(
registry=registry,
settings=settings,
request=pyramid_request
)
for include in settings['pyramid.includes'].split('\n'):
include = include.strip()
if include:
config.include(include)
set_cache_regions_from_settings(settings)
request.addfinalizer(testing.tearDown)
configure_filedepot(settings)
from autonomie import setup_services, add_static_views
setup_services(config, settings)
add_static_views(config, settings)
config.include('autonomie_celery')
from autonomie.utils.renderer import customize_renderers
customize_renderers(config)
return config
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application. """
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
session_factory = session_factory_from_settings(settings)
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings, session_factory=session_factory)
config.set_authentication_policy(
AuthTktAuthenticationPolicy(settings['authtkt.secret']))
config.set_authorization_policy(ACLAuthorizationPolicy())
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('submit', '/submit')
config.add_route('details', '/details')
config.add_route('admin', '/admin')
config.add_route('csv', '/csv')
config.add_route('approve', '/approve')
config.add_route('accept', '/accept')
config.add_route('save_address', '/save_address')
config.include('pyramid_mailer')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_view('fedorasummerofhardware.views.login_view',
renderer='fedorasummerofhardware:templates/login.mak',
context=Forbidden)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
session_factory = session_factory_from_settings(settings)
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.set_session_factory(session_factory)
config.include('pyramid_mako')
#start_scheduler()
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('data', 'data', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('entities_list', '/entity/all')
config.add_route('entities_table_json', '/entities/table/json')
config.add_route('entities_table_page', '/entities/table')
config.add_route('export_page', '/uik/export')
config.add_route('entity', '/entity/{id}')
config.add_route('register', '/register')
config.add_route('logs', '/logs')
config.add_route('entity_block', '/entity/block/{id}')
config.add_route('entity_unblock', '/entity/unblock/{id}')
config.scan()
return config.make_wsgi_app()
def test_add_cache_multiple_region(self):
from pyramid_beaker import set_cache_regions_from_settings
import beaker
settings = self._set_settings()
beaker.cache.cache_regions = {}
settings['cache.regions'] = 'default_term, short_term'
settings['cache.lock_dir'] = 'foo'
settings['cache.short_term.expire'] = '60'
settings['cache.default_term.type'] = 'file'
settings['cache.default_term.expire'] = '300'
settings['cache.default_term.enabled'] = 'false'
set_cache_regions_from_settings(settings)
default_term = beaker.cache.cache_regions.get('default_term')
short_term = beaker.cache.cache_regions.get('short_term')
self.assertEqual(short_term.get('expire'),
int(settings['cache.short_term.expire']))
self.assertEqual(short_term.get('lock_dir'),
settings['cache.lock_dir'])
self.assertEqual(short_term.get('type'), 'memory')
self.assertTrue(short_term.get('enabled'))
self.assertEqual(default_term.get('expire'),
int(settings['cache.default_term.expire']))
self.assertEqual(default_term.get('lock_dir'),
settings['cache.lock_dir'])
self.assertEqual(default_term.get('type'),
settings['cache.default_term.type'])
self.assertFalse(default_term.get('enabled'))
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
initialize_sql(settings)
session_factory = session_factory_from_settings(settings)
set_cache_regions_from_settings(settings)
authentication_policy = AuthTktAuthenticationPolicy('somesecret')
authorization_policy = ACLAuthorizationPolicy()
config = Configurator(
settings=settings,
session_factory=session_factory,
authentication_policy=authentication_policy,
authorization_policy=authorization_policy
)
config.add_subscriber(add_renderer_globals, BeforeRender)
config.add_subscriber(csrf_validation, NewRequest)
config.add_mako_renderer(".html")
config.add_static_view("static", "patchman:static", cache_max_age=3600)
config.add_static_view("store",settings["storage"], cache_max_age=3600)
MyRoutes(config)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
globalreg = getGlobalSiteManager()
set_cache_regions_from_settings(settings)
deserialized_settings = deserialize(settings)
config = Configurator(registry=globalreg)
config.setup_registry(settings=settings)
config.registry.registerUtility(
deserialized_settings,
ISettings,
name='settings'
)
config.add_directive('settings_reader', lambda c: SettingsReader(c))
config.reader = SettingsReader(config)
config.include('papaye.config.auth')
config.include('papaye.config.routes')
config.include('papaye.config.views')
config.include('papaye.config.startup')
config.add_renderer(
name='json_api_compat',
factory='papaye.views.api.compat.renderers.CompatAPIRendererFactory'
)
config.commit()
config.add_tween('papaye.tweens.LoginRequiredTweenFactory')
config.scan(ignore=['papaye.tests', 'papaye.conftest'])
config.set_request_property(
lambda x: deserialized_settings,
'papaye_settings',
reify=True
)
return config.make_wsgi_app()
def main(global_config, **settings):
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
session_factory = session_factory_from_settings(settings)
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.set_session_factory(session_factory)
#start_scheduler()
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('data', 'data', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('entities_list', '/entity/all')
config.add_route('entities_table_json', '/entities/table/json')
config.add_route('entities_table_page', '/entities/table')
config.add_route('export_page', '/uik/export')
config.add_route('entity', '/entity/{id}')
config.add_route('register', '/register')
config.add_route('logs', '/logs')
config.add_route('entity_block', '/entity/block/{id}')
config.add_route('entity_unblock', '/entity/unblock/{id}')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
cfg.setup(settings)
# Load cache config
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
# Session configuration
config.include('pyramid_beaker')
my_session_factory = SignedCookieSessionFactory(settings['session.secret'])
config.set_session_factory(my_session_factory)
# Get plotly credentials
plotly.tools.set_credentials_file(
username=settings['plotly_username'],
api_key=settings['plotly_key']
)
# Import routes
from lbsociamgame.config import routing
routing.make_routes(config)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
initialize_db(settings)
configure(settings)
# set beaker cache region
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings, root_factory=RootFactory)
# include edauth. Calls includeme
config.include(edauth)
# Pass edauth the roles/permission mapping that is defined in hpz
edauth.set_roles(RootFactory.__acl__)
# include add routes from frs. Calls includeme
config.include(frs)
config.include(swi)
config.include(services)
config.scan()
# Clean up old files from HPZ
run_cron_job(settings, HPZ_EXPIRATION + '.', cleanup)
logger.info("HPZ Started")
return config.make_wsgi_app()
def main(global_config, **settings):
authn_policy = AuthTktAuthenticationPolicy('sosecret', callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
session_factory = session_factory_from_settings(settings)
set_cache_regions_from_settings(settings)
config = Configurator(
settings=settings,
root_factory= 'innovation.models.RootFactory',
authentication_policy=authn_policy,
authorization_policy=authz_policy,
session_factory=session_factory
)
# Business owner / employee routes
config.add_route('root', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('add_employee', '/manage/employees/add')
config.add_route('manage_employees', '/manage/employees')
config.add_route('manage_all', '/manage')
config.add_route('manage', '/manage/{b_id}')
config.add_route('get_queue', '/get_queue')
config.add_route('remove_from_queue', '/remove')
config.add_route('add_to_queue_manual', '/add_to_queue_manual')
config.add_route('notify_user', '/notify_user')
config.add_route('check_in', '/check_in')
config.add_route('check_out', '/check_out')
# Admin routes
config.add_route('admin_main', '/admin')
config.add_route('admin_list_business', '/admin/business')
config.add_route('admin_edit_business', '/admin/business/edit')
config.add_route('admin_add_business', '/admin/business/add')
config.add_route('admin_list_user', '/admin/user')
config.add_route('admin_add_user', '/admin/user/add')
config.add_route('admin_edit_user', '/admin/user/edit')
#config.add_route('', '')
config.add_static_view('static', 'innovation:static')
# MongoDB
def add_mongo_db(event):
settings = event.request.registry.settings
url = settings['mongodb.url']
db_name = settings['mongodb.db_name']
db = settings['mongodb_conn'][db_name]
event.request.db = db
db_uri = settings['mongodb.url']
MongoDB = pymongo.Connection
if 'pyramid_debugtoolbar' in set(settings.values()):
class MongoDB(pymongo.Connection):
def __html__(self):
return 'MongoDB: <b>{}></b>'.format(self)
conn = MongoDB(db_uri)
config.registry.settings['mongodb_conn'] = conn
config.add_subscriber(add_mongo_db, NewRequest)
config.scan('innovation')
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
add_directives(config)
authn_policy = AuthTktAuthenticationPolicy(random_passphrase(), hashalg='sha512')
# authn_policy = AuthenticationStackPolicy()
# authn_policy.add_policy('basic', BasicAuthAuthenticationPolicy(check=auth_check_func))
# authn_policy.add_policy('tkt', AuthTktAuthenticationPolicy(secret='1234'))
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.set_session_factory(my_session_factory)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('islogged', '/islogged', factory=index_root_factory)
config.add_route('login', '/login', factory=user_root_factory)
config.add_route('logout', '/logout')
config.add_route('browse', '/browse', factory=index_root_factory)
config.add_route('simple', '/simple*traverse', factory=repository_root_factory)
config.add_notfound_view(notfound, append_slash=True)
config.add_jinja2_extension('webassets.ext.jinja2.AssetsExtension')
assets_env = config.get_webassets_env()
config.commit()
jinja2_env = config.get_jinja2_environment()
jinja2_env.assets_environment = assets_env
config.add_webasset('papaye_js', papaye_js)
config.add_webasset('papaye_css', papaye_css)
config.add_webasset('external_css', external_css)
config.add_webasset('papaye_fonts', papaye_fonts)
config.check_database_config()
config.scan(ignore='papaye.tests')
config.start_scheduler()
return config.make_wsgi_app()
def main(global_config, **settings):
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
session_factory = session_factory_from_settings(settings)
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.set_session_factory(session_factory)
start_scheduler()
config.include('pyramid_mako')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('data', 'data', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('uiks', '/uik/all')
config.add_route('stat_json', '/uik/stat/json')
config.add_route('statistic', '/uik/stat')
config.add_route('uik_export_page', '/uik/export')
config.add_route('uik', '/uik/{id}')
config.add_route('uik_block', '/uik/block/{id}')
config.add_route('uik_unblock', '/uik/unblock/{id}')
config.add_route('uik_by_off_number', '/uik/{region_id}/{official_number}')
config.add_route('register', '/register')
config.add_route('logs', '/logs')
config.add_route('uikp_all', '/uikp/all')
config.add_route('uikp', '/uikp/{id}')
config.scan()
return config.make_wsgi_app()
def test_add_cache_multiple_region(self):
from pyramid_beaker import set_cache_regions_from_settings
import beaker
settings = self._set_settings()
beaker.cache.cache_regions = {}
settings['cache.regions'] = 'default_term, short_term'
settings['cache.lock_dir'] = 'foo'
settings['cache.short_term.expire'] = '60'
settings['cache.default_term.type'] = 'file'
settings['cache.default_term.expire'] = '300'
settings['cache.default_term.enabled'] = 'false'
set_cache_regions_from_settings(settings)
default_term = beaker.cache.cache_regions.get('default_term')
short_term = beaker.cache.cache_regions.get('short_term')
self.assertEqual(short_term.get('expire'),
int(settings['cache.short_term.expire']))
self.assertEqual(short_term.get('lock_dir'), settings['cache.lock_dir'])
self.assertEqual(short_term.get('type'), 'memory')
self.assertTrue(short_term.get('enabled'))
self.assertEqual(default_term.get('expire'),
int(settings['cache.default_term.expire']))
self.assertEqual(default_term.get('lock_dir'),
settings['cache.lock_dir'])
self.assertEqual(default_term.get('type'),
settings['cache.default_term.type'])
self.assertFalse(default_term.get('enabled'))
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
sessionFactory = session_factory_from_settings(settings)
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.set_session_factory(sessionFactory)
get_current_registry().settings = settings
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('addContent', '/add')
config.add_route('oneContent', '/{idContent}')
config.add_route('oneContentRaw', '/{idContent}/raw')
config.add_route('update', '/{idContent}/update')
config.add_route('edit', '/{idContent}/edit')
config.add_route('deleteConfirm', '/{idContent}/deleteConfirm')
config.add_route('delete', '/{idContent}/delete')
config.add_route('rss2', '/feeds/rss2')
config.add_fanstatic_resources([resource.strip() for resource in settings['resources'].split(',')]
, r'.*\.pt')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
cfg.setup(settings)
# Load cache config
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
# Session configuration
config.include('pyramid_beaker')
my_session_factory = SignedCookieSessionFactory(settings['session.secret'])
config.set_session_factory(my_session_factory)
# Get plotly credentials
plotly.tools.set_credentials_file(username=settings['plotly_username'],
api_key=settings['plotly_key'])
# Import routes
from lbsociamgame.config import routing
routing.make_routes(config)
config.scan()
return config.make_wsgi_app()
def setUp(self):
self.workspace = self.mk_workspace()
settings = self.get_settings(self.workspace, **{
'unicorecomments.host': 'http://localhost/commentservice'})
self.config = testing.setUp(settings=settings)
self.config.include('cms')
set_cache_regions_from_settings(settings)
self.views = CmsViews(self.mk_request())
self.app_id = settings['unicorehub.app_id']
self.app = self.mk_app(self.workspace, settings=settings)
[category] = self.create_categories(self.workspace, count=1)
[page] = self.create_pages(
self.workspace, count=1, description='description',
primary_category=category.uuid)
self.page = page
self.stream = self.mk_comment_stream(
page.uuid, state='open', offset=10, limit=5)
self.patch_lazy_comment_page = mock.patch.object(
LazyCommentPage, 'data',
new=mock.PropertyMock(return_value=self.stream))
self.patch_lazy_comment_page.start()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
set_cache_regions_from_settings(settings)
authentication_policy = AuthTktAuthenticationPolicy('seekrit',
callback=groupfinder)
authorization_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
root_factory=RootFactory,
authentication_policy=authentication_policy,
authorization_policy=authorization_policy)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config.set_session_factory(session_factory_from_settings(settings))
config.add_mako_renderer('.html')
json_renderer = JSON()
def datetime_adapter(obj, request):
return obj.isoformat()
json_renderer.add_adapter(datetime.datetime, datetime_adapter)
config.add_renderer('json', json_renderer)
# Add static routes (required for static_path in Mako)
config.add_static_view(name=settings.get('webassets.base_url'),
path='static')
config.include(include_views)
config.include(include_css)
config.include(include_js)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
set_cache_regions_from_settings(settings)
session_factory = session_factory_from_settings(settings)
engine = engine_from_config(settings, 'sqlalchemy.')
models.DBSession.configure(bind=engine)
models.Base.metadata.bind = engine
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.set_session_factory(session_factory)
config.include('pyramid_beaker')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view(name='textures',
path='static/ED3D-Galaxy-Map/textures')
config.add_static_view(name='data', path='static/ED3D-Galaxy-Map/data')
config.add_static_view('deform_static', 'deform:static/')
config.add_route('home', '/')
config.add_route('galmap', '/galmap')
config.add_route('rats', '/rats')
config.add_route('view_rat', '/view_rat')
config.add_route('view_today', '/view_today')
config.add_route('view_api', '/api')
pyramid_jsonapi.create_jsonapi_using_magic_and_pixie_dust(
config, models, lambda view: models.DBSession)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
prepare_database(settings)
authn_policy = AuthTktAuthenticationPolicy(
'sikret;)', callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
root_factory=RootFactory)
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.set_default_permission('registered')
config.include('pyramid_jinja2')
config.include("pyramid_beaker")
set_cache_regions_from_settings(settings)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('main', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('engine.ajax', '/engine.ajax')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a WSGI application.
"""
# all your authz and authn belong to us
authn_policy = AuthTktAuthenticationPolicy('riotous4321',
callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
# gimmie that Beaker session and region caching YO!
session_factory = session_factory_from_settings(settings)
set_cache_regions_from_settings(settings)
# now make my app respect all of the stuff I just did
config = Configurator(settings=settings,
root_factory=root_factory_maker(),
authentication_policy=authn_policy,
authorization_policy=authz_policy,
request_factory=RequestWithUserAttribute,
session_factory=session_factory)
# setup the databasage
engine = engine_from_config(settings, 'sqlalchemy.')
config.scan('riotoustools.models')
initialize_sql(engine)
# view_config + scan = win!
config.add_static_view('static', 'riotoustools:static')
config.scan('riotoustools.views')
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
global check_username
check_username = lambda username, password:\
settings['gmusicapi_username'] == username and\
settings['gmusicapi_password'] == password
if not gm.login(settings['gmusicapi_username'],
settings['gmusicapi_password']):
logger.warn("Unable to login to Google Music!")
exit()
if not wc.login(settings['gmusicapi_username'],
settings['gmusicapi_password']):
logger.warn("Unable to login to Google Music!")
exit()
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.include('pyramid_chameleon')
config.include('gmusic.views')
config.add_static_view('static', 'static', cache_max_age=3600)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
sessionFactory = session_factory_from_settings(settings)
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.set_session_factory(sessionFactory)
get_current_registry().settings = settings
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('addContent', '/add')
config.add_route('oneContent', '/{idContent}')
config.add_route('oneContentRaw', '/{idContent}/raw')
config.add_route('update', '/{idContent}/update')
config.add_route('edit', '/{idContent}/edit')
config.add_route('deleteConfirm', '/{idContent}/deleteConfirm')
config.add_route('delete', '/{idContent}/delete')
config.add_route('rss2', '/feeds/rss2')
config.add_fanstatic_resources(
[resource.strip() for resource in settings['resources'].split(',')],
r'.*\.pt')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
session_factory = session_factory_from_settings(settings)
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.set_session_factory(session_factory)
start_scheduler()
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('uiks', '/uik/all')
config.add_route('stat_json', '/uik/stat/json')
config.add_route('statistic', '/uik/stat')
config.add_route('uik_export_page', '/uik/export')
config.add_route('uik', '/uik/{id}')
config.add_route('uik_block', '/uik/block/{id}')
config.add_route('uik_unblock', '/uik/unblock/{id}')
config.add_route('uik_by_off_number', '/uik/{region_id}/{official_number}')
config.add_route('register', '/register')
config.add_route('logs', '/logs')
config.add_route('uikp_all', '/uikp/all')
config.add_route('uikp', '/uikp/{id}')
config.add_route('uik_export', '/export/uiks/{file_type}/{region_id}')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
add_directives(config)
authn_policy = BasicAuthAuthenticationPolicy(check=auth_check_func)
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('browse', '/browse')
config.add_route('simple', '/simple*traverse', factory=repository_root_factory)
config.add_notfound_view(notfound, append_slash=True)
config.add_jinja2_extension('webassets.ext.jinja2.AssetsExtension')
assets_env = config.get_webassets_env()
config.commit()
jinja2_env = config.get_jinja2_environment()
jinja2_env.assets_environment = assets_env
# config.add_webasset('test', jst)
config.add_webasset('papaye_js', papaye_js)
config.add_webasset('papaye_css', papaye_css)
config.add_webasset('papaye_font', papaye_font)
config.check_database_config()
config.scan()
config.start_scheduler()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
sessionFactory = session_factory_from_settings(settings)
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.include('pyramid_fanstatic')
config.include('pyramid_beaker')
config.include('pyramid_rawes')
config.include('rebecca.fanstatic')
config.set_session_factory(sessionFactory)
settings['ES'] = config.get_rawes()
get_current_registry().settings = settings
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('addContent', '/addContent')
config.add_route('content', '/content/{imgID}')
config.add_route('image', '/image/{imgID}')
# print settings['resources'].split(',')
# print [resource.strip() for resource in settings['resources'].split(',')]
config.add_fanstatic_resources([resource.strip() for resource in settings['resources'].split(',')], r'.*\.pt')
config.scan()
return config.make_wsgi_app()
def setUp(self):
self.workspace = self.mk_workspace()
settings = self.get_settings(
self.workspace,
**{'unicorecomments.host': 'http://localhost/commentservice'})
self.config = testing.setUp(settings=settings)
self.config.include('cms')
set_cache_regions_from_settings(settings)
self.views = CmsViews(self.mk_request())
self.app_id = settings['unicorehub.app_id']
self.app = self.mk_app(self.workspace, settings=settings)
[category] = self.create_categories(self.workspace, count=1)
[page] = self.create_pages(self.workspace,
count=1,
description='description',
primary_category=category.uuid)
self.page = page
self.stream = self.mk_comment_stream(page.uuid,
state='open',
offset=10,
limit=5)
self.patch_lazy_comment_page = mock.patch.object(
LazyCommentPage,
'data',
new=mock.PropertyMock(return_value=self.stream))
self.patch_lazy_comment_page.start()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application. """
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
session_factory = session_factory_from_settings(settings)
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings, session_factory=session_factory)
config.set_authentication_policy(AuthTktAuthenticationPolicy(
settings['authtkt.secret']))
config.set_authorization_policy(ACLAuthorizationPolicy())
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('submit', '/submit')
config.add_route('details', '/details')
config.add_route('admin', '/admin')
config.add_route('csv', '/csv')
config.add_route('approve', '/approve')
config.add_route('accept', '/accept')
config.add_route('save_address', '/save_address')
config.include('pyramid_mailer')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_view('fedorasummerofhardware.views.login_view',
renderer='fedorasummerofhardware:templates/login.mak',
context=Forbidden)
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
set_cache_regions_from_settings(settings)
static_dir = os.path.join(os.path.dirname(__file__), 'static')
settings.setdefault('webassets.base_dir', static_dir)
settings.setdefault('webassets.base_url', 'static')
config = Configurator(settings=settings)
add_directives(config)
configure_authn_and_authz(config)
config.set_session_factory(my_session_factory)
configure_views(config) # Views
configure_routes(config) # Routes
config.commit()
# Web assets
config.add_jinja2_extension('webassets.ext.jinja2.AssetsExtension')
config.include('pyramid_webassets')
assets_env = config.get_webassets_env()
for item in WEBASSETS_DEFAULT_CONFIG.items():
assets_env.config.setdefault(*item)
jinja2_env = config.get_jinja2_environment()
jinja2_env.assets_environment = assets_env
config.add_webasset('papaye_js_assets', papaye_js_assets)
config.add_webasset('papaye_css_assets', papaye_css_assets)
config.add_webasset('requirejs', require_js_resources)
config.check_database_config()
config.scan(ignore='papaye.tests')
if 'papaye.worker.combined' not in settings or bool(settings['papaye.worker.combined']):
config.start_scheduler()
return config.make_wsgi_app()
def configurator_factory(self, container): # noqa: N805, R0201
# type: (AnySettingsContainer) -> Configurator
settings = get_settings(container)
set_cache_regions_from_settings(settings)
# disable rpcinterface which is conflicting with postgres db
settings["twitcher.rpcinterface"] = False
LOGGER.info("Loading MagpieAdapter config")
config = get_auth_config(container)
config.include("pyramid_beaker")
# use pyramid_tm to hook the transaction lifecycle to the request
# make request.db available for use in Pyramid
config.include("pyramid_tm")
session_factory = get_session_factory(get_engine(settings))
config.registry["dbsession_factory"] = session_factory
config.add_request_method(
# r.tm is the transaction manager used by pyramid_tm
lambda r: get_tm_session(session_factory, r.tm),
"db",
reify=True)
# use same 'get_user' method as ziggurat to access 'request.user' from
# request with auth token with exactly the same behaviour in Twitcher
config.add_request_method(get_user, "user", reify=True)
# add route to verify user token matching between Magpie/Twitcher
config.add_route("verify-user", "/verify")
config.add_view(verify_user, route_name="verify-user")
return config
def main(global_config, **app_settings):
""" This function returns a Pyramid WSGI application.
"""
settings = global_config
settings.update(app_settings)
initialize_web_database(settings)
session_factory = session_factory_from_settings(settings)
auth_policy = AuthTktAuthenticationPolicy(
settings['auth_tkt.secret'],
callback=models.user.get_user_groups,
hashalg='sha512',
)
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings,
request_factory=NDRequest,
session_factory=session_factory,
root_factory=_rsr.Root,
authentication_policy=auth_policy)
config.include('pyramid_mako')
config.include('pyramid_layout')
config.include('notification_demo.lib.client_script')
config.include("pyramid_vgid_oauth2")
config.include("notification_demo.views")
config.include("notification_demo.lib.notification")
config.add_static_view('static', STATIC_DIR, cache_max_age=3600)
config.add_route('home', '/')
config.scan()
return config.make_wsgi_app()
def setUp(self):
self.workspace = self.mk_workspace()
self.workspace.setup_custom_mapping(
Page, {
'properties': {
'slug': {
'type': 'string',
'index': 'not_analyzed',
},
'language': {
'type': 'string',
'index': 'not_analyzed',
}
}
})
self.workspace.setup_custom_mapping(
Category, {
'properties': {
'slug': {
'type': 'string',
'index': 'not_analyzed',
},
'language': {
'type': 'string',
'index': 'not_analyzed',
},
'position': {
'type': 'long'
}
}
})
self.workspace.setup_custom_mapping(
Localisation, {
'properties': {
'locale': {
'type': 'string',
'index': 'not_analyzed',
}
}
})
languages = ("[('eng_GB', 'English'), ('swa_KE', 'Swahili'),"
"('spa_ES', 'Spanish'), ('fre_FR', 'French'),"
"('hin_IN', 'Hindi'), ('ind_ID', 'Bahasa'),"
"('per_IR', 'Persian'), ('grn_PY', 'Guarani')]")
featured_langs = "[('spa_ES', 'Spanish'), ('eng_GB', 'English')]"
settings = self.get_settings(self.workspace,
available_languages=languages,
featured_languages=featured_langs)
self.config = testing.setUp(settings=settings)
self.config.include('pyramid_chameleon')
set_cache_regions_from_settings(settings)
self.config.set_locale_negotiator(locale_negotiator_with_fallbacks)
self.views = CmsViews(self.mk_request())
self.app = self.mk_app(self.workspace, settings=settings)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.include('cms')
config.configure_celery(global_config['__file__'])
return config.make_wsgi_app()
def test_add_cache_no_regions(self):
from pyramid_beaker import set_cache_regions_from_settings
import beaker
settings = self._set_settings()
beaker.cache.cache_regions = {}
settings['cache.regions'] = ''
set_cache_regions_from_settings(settings)
self.assertEqual(beaker.cache.cache_regions, {})
def test_add_cache_no_regions(self):
from pyramid_beaker import set_cache_regions_from_settings
import beaker
settings = self._set_settings()
beaker.cache.cache_regions = {}
settings['cache.regions'] = ''
set_cache_regions_from_settings(settings)
self.assertEqual(beaker.cache.cache_regions, {})
def process(settings):
_setup_db_connection(settings)
if not cache_only:
_delete_data(public_tenant)
copy_data_without_PII(private_tenant, public_tenant)
if not no_recache:
filter_settings = read_config_from_json_file(settings.get('migrate_public.recache.filter.file'))
set_cache_regions_from_settings(settings)
trigger_public_report_precache(public_tenant, filter_settings)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
# i define a method_name_xformer in the handlers above. it simply turns /this-url into /this_url so we can have happier methods
settings['pyramid_handlers.method_name_xformer'] = url_transformer
config = Configurator(settings=settings)
# Create the Pyramid Configurator.
config = Configurator(settings=settings)
config.include("pyramid_handlers")
# Configure Beaker sessions and caching
session_factory = pyramid_beaker.session_factory_from_settings(settings)
config.set_session_factory(session_factory)
pyramid_beaker.set_cache_regions_from_settings(settings)
# Add in our session_https property ( see import above )
initialize_https_session_set_request_property( config , settings )
# Configure renderers
config.add_renderer('jsonp', JSONP(param_name='callback'))
# Set up views & handlers
config.include("exampleapp.routes")
## add static view will mount the 'static' folder as a /static
#config.add_static_view("static", "static", cache_max_age=int(settings['static.cache_max_age']))
## the akhet app provides for add_static_route working as an 'overlay', which i prefer
## this means that urls are viewed as /img/logo.png instead of /static/img/logo.png
## this is really only affected on the dev environment, as static files would be served by nginx on production
config.include('akhet')
## make your caching dependent on the environment.ini
config.add_static_route("exampleapp", "static", cache_max_age=int(settings['static.cache_max_age']))
# initialize pyramid_subscribers_cookiexfer
pyramid_subscribers_cookiexfer.initialize_subscribers( config , settings )
# Initialize mongodb , which is a subscriber
mongodb.initialize_mongo_db( config , settings )
# get 'h' into the templates
config.add_subscriber(\
"exampleapp.subscribers.add_renderer_globals",
"pyramid.events.BeforeRender")
# Set up of views and handlers occurs in routes
config.include("exampleapp.routes")
return config.make_wsgi_app()
def setUp(self):
self.workspace = self.mk_workspace()
self.workspace.setup_custom_mapping(Page, {
'properties': {
'slug': {
'type': 'string',
'index': 'not_analyzed',
},
'language': {
'type': 'string',
'index': 'not_analyzed',
}
}
})
self.workspace.setup_custom_mapping(Category, {
'properties': {
'slug': {
'type': 'string',
'index': 'not_analyzed',
},
'language': {
'type': 'string',
'index': 'not_analyzed',
},
'position': {
'type': 'long'
}
}
})
self.workspace.setup_custom_mapping(Localisation, {
'properties': {
'locale': {
'type': 'string',
'index': 'not_analyzed',
}
}
})
languages = ("[('eng_GB', 'English'), ('swa_KE', 'Swahili'),"
"('spa_ES', 'Spanish'), ('fre_FR', 'French'),"
"('hin_IN', 'Hindi'), ('ind_ID', 'Bahasa'),"
"('per_IR', 'Persian'), ('grn_PY', 'Guarani')]")
featured_langs = "[('spa_ES', 'Spanish'), ('eng_GB', 'English')]"
settings = self.get_settings(
self.workspace,
available_languages=languages,
featured_languages=featured_langs)
self.config = testing.setUp(settings=settings)
self.config.include('pyramid_chameleon')
set_cache_regions_from_settings(settings)
self.config.set_locale_negotiator(locale_negotiator_with_fallbacks)
self.views = CmsViews(self.mk_request())
self.app = self.mk_app(self.workspace, settings=settings)
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("sosecret", callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings, root_factory="scm.models.RootFactory")
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
# config.add_static_view('static', 'static', cache_max_age=3600)
# config.add_route('home', '/')
# config.scan()
# return config.make_wsgi_app()
config.add_view("scm.views.suppliers", name="supplier", renderer="json")
config.add_static_view("static", "static", cache_max_age=3600)
# config.add_static_view(name='static', path='/var/www/static', cache_max_age=3600)
config.add_route("login", "/login")
config.add_route("logout", "/logout")
config.add_route("home", "/")
config.add_route("proc", "/proc/")
config.add_route("modem_page", "/modem/")
###finance
config.add_route("banks_page", "/banks/")
# procurement
config.add_route("purchase_orders_page", "/purchase_orders/")
config.add_route("requisitions_page", "/requisitions/")
config.add_route("departments_page", "/departments/")
config.add_route("suppliers_page", "/suppliers/")
config.add_route("store_issues_page", "/store_issues/")
config.add_route("delivery_note_page", "/delivery_note/")
config.add_route("goods_received_page", "/goods_received/")
config.add_route("goods_returned_page", "/goods_returned/")
config.add_route("users_page", "/users/")
config.add_route("bincard_page", "/bincard/")
config.add_route("purchase_orders_by_status_page", "/purchase_orders_by_status/")
config.add_route("purchase_orders_by_supplier_page", "/purchase_orders_by_supplier/")
config.add_route("store_issues_report_page", "/store_issues_report/")
config.add_route("goods_received_report_page", "/goods_received_report/")
config.add_route("goods_returned_report_page", "/goods_returned_report/")
config.add_route("permissions", "/permissions/")
#######controller operations###############################################
config.add_route("supplier_controller", "/supplier/operations")
####admin###################
config.add_route("user_controller", "/users/operations")
config.scan()
return config.make_wsgi_app()
def create_test_app(config):
""" This function returns a Pyramid WSGI application for functional tests.
"""
config.include('pyramid_jinja2')
set_cache_regions_from_settings(config.registry.settings)
config.add_jinja2_search_path("papaye:templates")
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('simple', '/simple/*traverse', factory='papaye:root_factory')
config.scan()
return config.make_wsgi_app()
def setUp(self):
self.workspace = self.mk_workspace()
settings = self.get_settings(self.workspace)
self.config = testing.setUp(settings=settings)
self.config.include('cms')
set_cache_regions_from_settings(settings)
self.views = CmsViews(self.mk_request())
self.app = self.mk_app(self.workspace, settings=settings)
def test_region_inherit_enabled(self):
from pyramid_beaker import set_cache_regions_from_settings
import beaker
settings = self._set_settings()
settings['cache.enabled'] = 'false'
beaker.cache.cache_regions = {}
set_cache_regions_from_settings(settings)
default_term = beaker.cache.cache_regions.get('default_term')
short_term = beaker.cache.cache_regions.get('short_term')
self.assertFalse(short_term.get('enabled'))
self.assertFalse(default_term.get('enabled'))
def disable_cache(settings=None):
cache_settings = {
'cache.regions': 'pypi',
'cache.enabled': 'false',
}
if settings:
settings.update(cache_settings)
else:
settings = cache_settings
set_cache_regions_from_settings(settings)
return settings
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
css = webassets.Bundle('bootstrap.min.css',
webassets.Bundle('styles.css', filters='yui_css'),
output='bundle.min.css')
config.add_webasset('css', css)
config.registry.settings['webassets_env'] = config.get_webassets_env()
config.add_subscriber(add_webassets_env, NewRequest)
db_uri = settings['mongodb.db_uri']
conn = pymongo.Connection(db_uri)
config.registry.settings['db_conn'] = conn
try:
if asbool(settings.get('nurl.check_whitelist', False)):
with open(os.path.join(APP_PATH, '..',
'whitelist.txt')) as whitelist:
config.registry.settings['nurl.whitelist'] = get_whitelist(
whitelist,
asbool(settings.get('nurl.check_whitelist_auto_www',
False)))
except IOError:
config.registry.settings['nurl.check_whitelist'] = False
config.add_subscriber(add_mongo_db, NewRequest)
config.add_renderer('jsonp', JSONP(param_name='callback'))
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('shortened', '/{short_ref}')
#rest api version 1
config.add_route('shortener_v1', '/api/v1/shorten')
config.scan()
application = config.make_wsgi_app()
#newrelic agent
try:
if asbool(settings.get('newrelic.enable', False)):
newrelic.agent.initialize(
os.path.join(APP_PATH, '..', 'newrelic.ini'),
settings['newrelic.environment'])
return newrelic.agent.wsgi_application()(application)
else:
return application
except IOError:
config.registry.settings['newrelic.enable'] = False
return application
def test_add_cache_single_region_no_expire(self):
from pyramid_beaker import set_cache_regions_from_settings
import beaker
settings = self._set_settings()
beaker.cache.cache_regions = {}
settings['cache.regions'] = 'default_term'
del settings['cache.default_term.expire']
set_cache_regions_from_settings(settings)
default_term = beaker.cache.cache_regions.get('default_term')
self.assertEqual(default_term, {'url': None, 'expire': 60,
'type': 'memory', 'lock_dir': None})
def test_resource_generation(self):
from pyramid_beaker import set_cache_regions_from_settings
request = testing.DummyRequest()
request.db = DummyMongoDB()
settings = self.required_settings()
set_cache_regions_from_settings(settings) #setting cache_regions
resource_gen = ResourceGenerator(request, generation_tool=DummyBase28)
url = 'http://www.scielo.br'
self.assertEqual(resource_gen.generate(url), '4kgjc')
def disable_cache(settings=None):
cache_settings = {
'cache.regions': 'pypi',
'cache.enabled': 'false',
}
if settings:
settings.update(cache_settings)
else:
settings = cache_settings
set_cache_regions_from_settings(settings)
return settings
def test_region_inherit_enabled(self):
from pyramid_beaker import set_cache_regions_from_settings
import beaker
settings = self._set_settings()
settings['cache.enabled'] = 'false'
beaker.cache.cache_regions = {}
set_cache_regions_from_settings(settings)
default_term = beaker.cache.cache_regions.get('default_term')
short_term = beaker.cache.cache_regions.get('short_term')
self.assertFalse(short_term.get('enabled'))
self.assertFalse(default_term.get('enabled'))
def create_test_app(config):
""" This function returns a Pyramid WSGI application for functional tests.
"""
config.include('pyramid_jinja2')
set_cache_regions_from_settings(config.registry.settings)
config.add_jinja2_search_path("papaye:templates")
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('simple',
'/simple/*traverse',
factory='papaye:root_factory')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
sessionFactory = session_factory_from_settings(settings)
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.set_session_factory(sessionFactory)
get_current_registry().settings = settings
config = Configurator(settings=settings)
config.include("cornice")
config.include('pyramid_beaker')
config.scan("door.views")
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
set_cache_regions_from_settings(settings)
# SQLA not used in this project
#engine = engine_from_config(settings, 'sqlalchemy.')
#DBSession.configure(bind=engine)
session_factory = UnencryptedCookieSessionFactoryConfig('teachprogramming')
config = Configurator(settings=settings, session_factory=session_factory)
config.include(
'pyramid_mako'
) # The mako.directories value is updated in the scan for addons. We trigger the import here to include the correct folders.
config.add_static_view('static', 'static') #cache_max_age=3600
config.add_static_view('projects/game/images',
'static/projects/game/images')
# Plain Template routes
from .templates.helpers import get_templates
import teachprogramming.views.static_views as static_views
config.add_route('root', '/')
config.add_view(static_views.home, route_name='root')
for route_name in get_templates('static'):
#print ("register {0}".format(route_name))
config.add_route(route_name, '/{0}'.format(route_name))
config.add_view(getattr(static_views, route_name),
route_name=route_name)
config.add_route('project',
'/projects/{project_type}/{project}') # .{selected_lang}
config.add_route(
'project_code',
'/projects/{project_type}/{project}/{selected_lang}/{version}/')
#config.add_route('select_language_redirect', '/select_language_redirect/{selected_lang}')
config.add_route('language_reference', '/language_reference')
# Old for reference
#config.add_view('myproject.views.mako_test', route_name='mako_test')
#config.add_route('hello_world', '/hello_world')
#config.add_route('mako_test', '/mako_test/{one}/{two}') #'/prefix/{one}/{two}'
# Events -------------------------------------------------------------------
config.add_subscriber(add_template_helpers_to_event,
pyramid.events.BeforeRender)
# Return -------------------------------------------------------------------
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
set_cache_regions_from_settings(settings)
config = Configurator(settings=settings)
config.include('pyramid_jinja2')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('controller', '/api/controller')
config.add_route('game_state', '/api/game_state')
config.add_route('game_config', '/api/game_config')
config.scan()
return config.make_wsgi_app()
def test_resource_generation_existing(self):
from pyramid_beaker import set_cache_regions_from_settings
from beaker.cache import region_invalidate
request = testing.DummyRequest()
request.db = DummyMongoDB_2()
settings = self.required_settings()
set_cache_regions_from_settings(settings) #setting cache_regions
resource_gen = ResourceGenerator(request, generation_tool=DummyBase28)
url = 'http://www.scielo.br'
region_invalidate(resource_gen.generate, None, url) #invalidate cache
self.assertEqual(resource_gen.generate(url), '4kgxx')
def includeme(config):
config.add_route('login', '/login/')
config.add_route('logout', '/logout/')
config.add_route('redirect_to_login', '/login/hub/')
config.scan('.auth')
# set up sessions
config.include('pyramid_beaker')
set_cache_regions_from_settings(config.registry.settings)
# set up unicore.hub client
hubclient = HubUserClient.from_config(config.registry.settings)
config.registry.hubclient = hubclient
init_auth(config)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
# add policies
authentication_policy = AuthTktAuthenticationPolicy('pyramidhq_seekrit',
callback=groupfinder)
authorization_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings,
authentication_policy=authentication_policy,
authorization_policy=authorization_policy,
request_factory=request.PylonsHQRequest)
# initialize database
pyramid_sqla.add_engine(settings, prefix='sqlalchemy.')
# configure beaker sessions
session_factory = pyramid_beaker.session_factory_from_settings(settings)
config.set_session_factory(session_factory)
# configure beaker cache regions
pyramid_beaker.set_cache_regions_from_settings(settings)
# add i18n dirs
config.add_translation_dirs('pylonshq:locale/')
# initialize handlers
config.include('pyramid_handlers')
# initialize github client
config.registry['github'] = init_github(settings)
# configure renderers
config.add_subscriber('pylonshq.lib.subscribers.add_renderer_globals',
'pyramid.events.BeforeRender')
config.add_subscriber('pylonshq.lib.subscribers.add_localizer',
'pyramid.events.ContextFound')
config.add_static_view('static', 'pylonshq:static')
# add mako templating
config.include('pyramid_mako')
# set up handlers
config.include(add_handlers)
# scan packages
config.scan('pylonshq')
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
# sqlalchemy setup
engine = engine_from_config(settings)
config.registry.dbmaker = sessionmaker(bind=engine)
# NOTE: db session is tied to request lifespan
config.add_request_method(db, reify=True)
# beaker and cache setup
set_cache_regions_from_settings(settings)
config.scan()
return config.make_wsgi_app()
def test_region_inherit_url(self):
from pyramid_beaker import set_cache_regions_from_settings
import beaker
settings = self._set_settings()
beaker.cache.cache_regions = {}
settings['cache.regions'] = 'default_term, short_term'
settings['cache.lock_dir'] = 'foo'
settings['cache.url'] = '127.0.0.1'
settings['cache.short_term.expire'] = '60'
settings['cache.default_term.type'] = 'file'
settings['cache.default_term.expire'] = '300'
set_cache_regions_from_settings(settings)
default_term = beaker.cache.cache_regions.get('default_term')
short_term = beaker.cache.cache_regions.get('short_term')
self.assertEqual(short_term.get('url'), settings['cache.url'])
self.assertEqual(default_term.get('url'), settings['cache.url'])
