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):
authn_policy = AuthTktAuthenticationPolicy(settings.get('pumbaa.secret'),
callback=group_finder,
hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
pumbaa_session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings,
root_factory='pumbaa.acl.RootFactory',
authentication_policy=authn_policy,
authorization_policy=authz_policy,
session_factory=pumbaa_session_factory)
models.initial(settings)
config.include('velruse.providers.facebook')
config.add_facebook_login_from_settings(prefix='velruse.facebook.')
config.include('velruse.providers.google_oauth2')
config.add_google_oauth2_login_from_settings(prefix='velruse.google.')
config.include('velruse.providers.twitter')
config.add_twitter_login_from_settings(prefix='velruse.twitter.')
add_routes(config)
config.scan('pumbaa.views')
from .request_factory import RequestWithUserAttribute
config.set_request_factory(RequestWithUserAttribute)
return config.make_wsgi_app()
def main(global_config, **settings): # pragma: no cover
""" 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)
config = Configurator(settings=settings)
config.set_session_factory(session_factory)
config.set_root_factory(RootFactory)
config.set_request_property(remote_addr)
config.add_request_method(tagged_static_path)
config.include(pyramid_jinja2)
# Redis setup.
redis_conn = redis.StrictRedis.from_url(settings['redis.url'])
config.registry.settings['redis_conn'] = redis_conn
def _add_redis(event):
settings = event.request.registry.settings
event.request.redis = settings['redis_conn']
config.add_subscriber(_add_redis, NewRequest)
jinja2_env = config.get_jinja2_environment()
jinja2_env.filters['datetime'] = format_datetime
jinja2_env.filters['formatpost'] = format_post
jinja2_env.filters['isotime'] = format_isotime
jinja2_env.filters['markdown'] = format_markdown
jinja2_env.filters['markup'] = format_text
config.add_static_view('static', path='static', cache_max_age=3600)
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 = 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):
NotSoSecret = 'CIeUz0RK8fjRq1wJSrID'
authn_policy = AuthTktAuthenticationPolicy(NotSoSecret,
callback=groupfinder,
hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
engine = engine_from_config(settings, 'sqlalchemy.')
event.listen(engine, 'connect', _execute_pragma_on_connect)
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings, root_factory=Root)
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.include('velruse.providers.google_oauth2')
session_factory = session_factory_from_settings(settings)
config.set_session_factory(session_factory)
config.add_google_oauth2_login_from_settings(prefix='velruse.google.')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('logout', '/logout')
config.add_route('ListChangelogs', '/changelogs')
config.add_route('GetChangelog', '/changelog/{id}')
config.add_route('home', '/')
config.scan("changelog.views")
config.add_request_method(LookupUser, 'user', reify=True)
config.add_request_method(GetDB, 'db', reify=True)
return config.make_wsgi_app()
def get_session_factory(settings):
"""
Wrap the beaker session factory to add longtimeout support
"""
factory = session_factory_from_settings(settings)
class AutonomieSessionObject(factory):
"""
Our pyramid session object
"""
_longtimeout = factory._options.pop("longtimeout")
def __init__(self, request):
options = self._options.copy()
if "remember_me" in request.cookies.keys():
options['timeout'] = self._longtimeout
SessionObject.__init__(self, request.environ, **options)
def session_callback(request, response):
exception = getattr(request, 'exception', None)
if (exception is None
or self._cookie_on_exception and self.accessed()):
self.persist()
headers = self.__dict__['_headers']
if headers['set_cookie'] and headers['cookie_out']:
response.headerlist.append(
('Set-Cookie', headers['cookie_out']))
request.add_response_callback(session_callback)
return AutonomieSessionObject
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
config.include("solute.epfl")
session_factory = session_factory_from_settings(settings)
config.set_session_factory(session_factory)
config.add_static_view(name='static',
path='epfl_pyramid_barebone:static',
cache_max_age=3600)
authn_policy = AuthTktAuthenticationPolicy('seekrit', hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
temp_data_provider = epfltempdata.LocalMemoryProvider(config)
config.set_tempdata_provider(temp_data_provider)
nodeglobal_data_provider = epfltempdata.LocalMemoryProvider(config)
config.set_nodeglobaldata_provider(nodeglobal_data_provider)
config.scan()
return config.make_wsgi_app()
def main(self, global_config, **settings):
settings['su.using_tm'] = True
config = global_config
config.add_settings(settings)
def index(request):
return Response('index!')
config.add_route('index', '/')
config.add_view(index, route_name='index')
authz_policy = ACLAuthorizationPolicy()
config.set_authorization_policy(authz_policy)
authn_policy = AuthTktAuthenticationPolicy('secret')
config.set_authentication_policy(authn_policy)
session_factory = session_factory_from_settings(settings)
config.set_session_factory(session_factory)
# config.include('pyramid_tm')
config.registry.registerUtility(DBSession, ISUSession)
if settings.get('su.require_activation', True):
config.include('pyramid_mailer')
config.include('pyramid_signup')
app = config.make_wsgi_app()
return app
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
db = models.DBConnect(**settings)
db.connect()
# A very simple default Authentication Policy
authn_policy = AuthTktAuthenticationPolicy('somesecret',
callback=security.groupfinder)
# A very simple default ACL Authorization Policy
authz_policy = ACLAuthorizationPolicy()
# Setting up the config settings to the application config
config = Configurator(settings=settings,
root_factory='qrevent.security.RootFactory',
authentication_policy=authn_policy,
authorization_policy=authz_policy)
config.add_renderer('jsonp', JSONP(param_name='callback'))
# Setup pyramid_beaker as session factory
session_factory = session_factory_from_settings(settings)
# Set session factory to the pyramid_beaker session factory
config.set_session_factory(session_factory)
config.add_static_view('static', 'qrevent:static')
config.include('qrevent.api.api_include')
config.include('qrevent.web.web_include')
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
# load app cfg
app_cfg = load_app_cfg()
settings.update(app_cfg)
# setup database
settings = setup_database(global_config, **settings)
authentication_policy = AuthTktAuthenticationPolicy(
secret=settings['auth_secret_key'],
callback=get_group)
authorization_policy = ACLAuthorizationPolicy()
session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings,
authentication_policy=authentication_policy,
authorization_policy=authorization_policy,
session_factory=session_factory,
request_factory=WebRequest)
# activate translation
config.add_translation_dirs('ez2pay:locale/')
# add the mailer
config.include('pyramid_mailer')
if asbool(settings.get('use_dummy_mailer', False)):
config.include('pyramid_mailer.testing')
# add Genshi renderer
config.include('pyramid_genshi')
# setup modules
config.include('.modules')
# add static view
config.add_static_view('static', 'ez2pay:static')
# scan modules
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
settings['db'] = {'host':'localhost', 'port': 27017}
session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings,session_factory=session_factory)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_renderer('jsonp', JSONP(param_name = 'callback'))
config.add_route('home', '/')
config.add_route('home_jiang', '/home')
config.add_route('index', '/index')
config.add_route('preview', '/i/{short_url}')
config.add_route('img', '/html/img/{filename}')
config.add_route('test', '/test')
config.add_route('create', '/create')
config.add_route('get_info', '/get_info')
config.add_route('pull', '/pull')
config.add_route('tencent', '/qq')
config.add_route('login', '/login')
config.add_route('site_view', '/site_view')
config.add_route('register', '/register')
config.add_route('qqlogin', '/qqlogin')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
init_DBSession(settings)
config = Configurator(settings=settings)
config.include('pyramid_mako')
# Beaker Session Manager
import pyramid_beaker
session_factory = pyramid_beaker.session_factory_from_settings(settings)
config.set_session_factory(session_factory)
# Parse/Convert setting keys that have specifyed datatypes
for key in config.registry.settings.keys():
config.registry.settings[key] = convert_str_with_type(config.registry.settings[key])
config.add_static_view('static', 'static', cache_max_age=3600)
# Routes
def append_format_pattern(route):
return re.sub(r'{(.*)}', r'{\1:[^/\.]+}', route) + r'{spacer:[.]?}{format:(%s)?}' % '|'.join(registered_formats())
config.add_route('home' , append_format_pattern('/') )
config.add_route('position_update', append_format_pattern('/position_update'))
config.add_route('position_get' , append_format_pattern('/position_get') )
config.add_route('last_checkin' , append_format_pattern('/last_checkin') )
config.add_route('near_stops' , append_format_pattern('/near_stops') )
config.add_route('near_bus' , append_format_pattern('/near_bus') )
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)
authn_policy = AuthTktAuthenticationPolicy(
'sosecret', callback=groupfinder, hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
session_factory = session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings,
root_factory='.models.RootFactory',
session_factory=session_factory)
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
# Routes
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home_page', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
# Admin
config.add_route('admin_list_users', '/admin/users')
config.add_route('admin_create_user', '/admin/users/create')
config.add_route('admin_delete_user', '/admin/user/delete/{id}')
config.add_route('admin_list_teams', '/admin/teams')
config.add_route('admin_create_team', '/admin/teams/create')
config.add_route('admin_delete_team', '/admin/teams/delete/{id}')
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_config = session_factory_from_settings(settings)
config = Configurator(settings=settings, session_factory=session_config, root_factory='.models.RootFactory')
config.set_authentication_policy(authetntication_policy)
config.set_authorization_policy(authorization_policy)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_renderer('.html', mako_factory)
config.add_route('home', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('about', '/about')
config.add_route('contact', '/contact')
config.add_route('income', '/income')
config.add_route('income_category', '/income-category')
config.add_route('expense', '/expense')
config.add_route('expense_category', '/expense-category')
config.add_route('balance', '/balance')
config.add_subscriber('.subscribers.csrf_validation', NewRequest)
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.
"""
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.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
# pyramid_beaker add-on
session_factory = session_factory_from_settings(settings)
authn_policy = SessionAuthenticationPolicy()
authz_policy = ACLAuthorizationPolicy()
Base.metadata.bind = engine
config = Configurator(
settings=settings,
root_factory=RootFactory,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
session_factory=session_factory,
)
config.add_static_view('static', 'static', cache_max_age=3600)
# config.add_subscriber(add_renderer_globals, BeforeRender)
# mako settings for file extension .html
config.add_renderer(".html", "pyramid.mako_templating.renderer_factory")
config.include(addroutes)
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
session_factory = session_factory_from_settings(settings)
authn_policy = AuthTktAuthenticationPolicy('s0secret', callback=groupfinder, hashalg='md5')
#authn_policy = AuthTktAuthenticationPolicy('s0secret')
authz_policy = ACLAuthorizationPolicy()
config = Configurator(
settings=settings,
root_factory=RootFactory,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
session_factory=session_factory
)
# since version 1.5 templating is not included by default
config.include('pyramid_chameleon')
config.add_static_view('static', 'static', cache_max_age=3600)
config.include(addroutes)
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.')
initialize_sql(engine)
session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings, session_factory=session_factory)
config.include('pyramid_mailer')
config.add_translation_dirs('colander:locale/', 'deform:locale/',
'c3sintent:locale/')
config.add_static_view('static', 'c3sintent:static', cache_max_age=3600)
config.add_subscriber('c3sintent.subscribers.add_base_template',
'pyramid.events.BeforeRender')
config.add_subscriber('c3sintent.subscribers.add_locale_to_cookie',
'pyramid.events.NewRequest')
# home /
# intent form
config.add_route('intent', '/')
config.add_route('disclaimer', '/disclaimer')
config.add_route('faq', '/faq')
config.add_route('success', '/success')
config.add_route('success_check_email', '/check_email')
config.add_route('success_verify_email', '/verify/{email}/{code}')
config.add_route('success_pdf', '/C3S_DeclarationOfIntent_{namepart}.pdf')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
logger = logging.getLogger('__init__')
logger.setLevel(logging.DEBUG)
logger.info('Application initialization...')
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
session_factory = session_factory_from_settings(settings)
config = Configurator(
settings=settings,
session_factory=session_factory
)
config.add_subscriber(
'similarimages.subscribers.add_base_template',
'pyramid.events.BeforeRender'
)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('upload', '/upload')
config.add_route('choose', '/choose')
config.add_route('result', '/result')
config.scan()
logger.info('Application initialization finished.')
return config.make_wsgi_app()
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.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
config = Configurator(
root_factory=Root,
settings=settings,
authentication_policy=FamosoAuthenticationPolicy(),
authorization_policy=ACLAuthorizationPolicy(),
)
session_factory = session_factory_from_settings(settings)
config.set_session_factory(session_factory)
config.set_request_property(get_user, 'user', reify=True)
config.add_static_view('static', 'static', cache_max_age=3600)
add_routes(config)
config.scan('famoso_reports.views')
config.add_forbidden_view(forbidden)
return config.make_wsgi_app()
def main(self, global_config, **settings):
settings['su.using_tm'] = True
config = global_config
config.add_settings(settings)
config.registry.registerUtility(Activation, IActivationClass)
config.registry.registerUtility(User, IUserClass)
def index(request):
return Response('index!')
config.add_route('index', '/')
config.add_view(index, route_name='index')
authz_policy = ACLAuthorizationPolicy()
config.set_authorization_policy(authz_policy)
authn_policy = AuthTktAuthenticationPolicy('secret')
config.set_authentication_policy(authn_policy)
session_factory = session_factory_from_settings(settings)
config.set_session_factory(session_factory)
config.registry.registerUtility(DBSession, IDBSession)
if settings.get('su.require_activation', True):
config.include('pyramid_mailer')
config.include('pyramid_mako')
config.include('horus')
app = config.make_wsgi_app()
return app
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('register', '/register')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('upload', '/upload')
config.scan()
''' set session factory '''
session_factory = session_factory_from_settings(settings)
config.set_session_factory(session_factory)
''' make user variable available in request '''
config.add_request_method(get_user, 'user', reify=True)
''' Connect to mongodb '''
connect('tigress')
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
for p in ['rte', 'enedis', 'ogm']:
PROFILES[settings['profile.%s' % p]] = p
session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings, session_factory=session_factory)
config.include('pyramid_mako')
# initialize database
engine = sqlalchemy.engine_from_config(settings, 'sqlalchemy.')
sqlahelper.add_engine(engine)
# add the "geojson" renderer
config.add_renderer(name='csv', factory='cables.renderers.CSVRenderer')
# add routes to the entry view class
config.add_route('export_zonessensibles', '/export/zonessensibles')
config.add_route('export_communes', '/export/communes')
config.add_route('export_departements', '/export/departements')
config.add_route('profile', '/profile')
config.scan()
# add the static view (for static resources)
config.add_static_view('static', 'cables:static')
return config.make_wsgi_app()
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 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. """
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.
"""
settings["g"] = g = Globals(**settings)
config = Configurator(
settings=settings,
root_factory=WebsiteRootContext,
session_factory=session_factory_from_settings(settings),
authentication_policy=Security(),
authorization_policy=ACLAuthorizationPolicy(),
default_permission='view')
request.extend_request_traversal(config)
config.add_directive('add_mako_renderer', pyramid_mako.add_mako_renderer)
config.add_mako_renderer(".html")
config.add_mako_renderer(".xml")
config.add_renderer('json', jsonRenderer)
def _(request, string):
return string
config.add_request_method(_, '_')
config.add_subscriber(add_renderer_variables,
'pyramid.events.BeforeRender')
config.include("ufostart.handlers")
config.include("ufostart.admin")
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.")
settings["db.sessionmaker"] = DBSession
DBSession.configure(bind=engine)
Base.metadata.bind = engine
Base.metadata.create_all(engine)
initialize_sql(engine, [populate, populate_wiki, populate_feeds])
session_factory = session_factory_from_settings(settings)
root_factory = "trumpet.resources.RootGroupFactory"
request_factory = "trumpet.request.AlchemyRequest"
config = Configurator(
settings=settings,
root_factory=root_factory,
request_factory=request_factory,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
session_factory=session_factory,
)
configure_static(config)
# config.include('pyramid_fanstatic')
configure_base_layout(config)
config.add_static_view("static", "static", cache_max_age=3600)
config.add_route("home", "/")
config.add_view("plum.views.MainViewer", route_name="home", renderer=basetemplate, layout="base")
configure_login(config)
configure_rssviewer(config, "/rssviewer")
configure_wiki(config, "/wiki")
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
authn_policy = SessionAuthenticationPolicy('secret_word', callback=role_finder)
authz_policy = ACLAuthorizationPolicy()
session_factory = session_factory_from_settings(settings)
# In case you use MySQL
# engine = engine_from_config(settings, 'sqlalchemy.',listeners=[MySqlListener()])
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings,
root_factory='pyramidsite.security.ContentFactory',
authentication_policy=authn_policy,
authorization_policy=authz_policy,
session_factory=session_factory)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.set_request_property(get_current_user, 'user', reify=True)
config.scan()
# Utilities
config.registry.registerUtility(MailHost(config.registry.settings), IMailSender)
# Modules
config.include('pyramidsite.modules.account')
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
models.initialize(engine)
config = Configurator(settings=settings,
root_factory='bonanza.lib:RootFactory',
session_factory=session_factory_from_settings(settings),
# authentication_policy=AuthTktAuthenticationPolicy(
# '5e04c5f06208def3c5becd6db74f8d11733a912a',
# callback=bonanza.security.lookup_userid),
# authorization_policy=ACLAuthorizationPolicy()
)
config.include('pyramid_jinja2')
config.include('pyramid_scss')
config.add_static_view('static', 'bonanza:static', cache_max_age=3600)
# entity
config.add_route('home', '/')
config.add_view(route_name='home', view='bonanza.controllers.home.get_index',
renderer='/home/index.jinja2', request_method='GET')
# scss
config.add_route('css', '/css/{stylesheet}.css')
config.add_view(route_name='css', view='bonanza.controllers.static.get_css',
renderer='scss', request_method='GET')
config.commit()
add_template_filters(config)
return config.make_wsgi_app()
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.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
initialize_sql(engine)
session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings,
session_factory=session_factory)
config.include('pyramid_mailer')
config.add_translation_dirs(
'colander:locale/',
'deform:locale/',
'c3sintent:locale/')
config.add_static_view('static',
'c3sintent:static', cache_max_age=3600)
config.add_subscriber('c3sintent.subscribers.add_base_template',
'pyramid.events.BeforeRender')
config.add_subscriber('c3sintent.subscribers.add_locale_to_cookie',
'pyramid.events.NewRequest')
# home /
# intent form
config.add_route('intent', '/')
config.add_route('disclaimer', '/disclaimer')
config.add_route('faq', '/faq')
config.add_route('success', '/success')
config.add_route('success_check_email', '/check_email')
config.add_route('success_verify_email', '/verify/{email}/{code}')
config.add_route('success_pdf', '/C3S_DeclarationOfIntent_{namepart}.pdf')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
logger = logging.getLogger('__init__')
logger.setLevel(logging.DEBUG)
logger.info('Application initialization...')
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings, session_factory=session_factory)
config.add_subscriber('similarimages.subscribers.add_base_template',
'pyramid.events.BeforeRender')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('upload', '/upload')
config.add_route('choose', '/choose')
config.add_route('result', '/result')
config.scan()
logger.info('Application initialization finished.')
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
config = Configurator(settings=settings)
# Initialize database
pyramid_sqla.add_engine(settings, prefix='sqlalchemy.',
convert_unicode=True)
# Configure Beaker sessions
session_factory = pyramid_beaker.session_factory_from_settings(settings)
config.set_session_factory(session_factory)
# Configure renderers
config.add_renderer('.html', 'pyramid.mako_templating.renderer_factory')
config.add_subscriber('simpledemo.subscribers.add_renderer_globals',
'pyramid.events.BeforeRender')
# Set up routes and views
config.add_handler('home', '/', 'simpledemo.handlers:MainHandler',
action='index')
config.add_handler('main', '/{action}', 'simpledemo.handlers:MainHandler',
path_info=r'/(?!favicon\.ico|robots\.txt|w3c)')
add_static_route(config, 'simpledemo', 'static', cache_max_age=3600)
return config.make_wsgi_app()
def main(global_config, **settings):
"""
Main function : returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
initialize_sql(engine)
auth_policy = SessionAuthenticationPolicy(callback=build_avatar)
acl_policy = ACLAuthorizationPolicy()
session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings,
session_factory=session_factory,
authentication_policy=auth_policy,
authorization_policy=acl_policy,
root_factory=RootFactory
)
config.add_static_view('static', 'crmbase:static', cache_max_age=3600)
config.add_route('index', '/')
# REST API
## using the four HTTP methods (POST, GET, PUT, DELETE),
## translating them in (add, get, update, delete)
## and the two following routes,
## we can get a very clean REST API
config.add_route("users", "/users")
config.add_route("user", "/users/{uid}")
config.add_route("contacts", "/contacts")
config.add_route("login", "/login")
config.add_route("logout", "/logout")
return config.make_wsgi_app()
def main(self, global_config, **settings):
settings["su.using_tm"] = True
config = global_config
config.add_settings(settings)
self.config.registry.registerUtility(Activation, IActivationClass)
self.config.registry.registerUtility(User, IUserClass)
def index(request):
return Response("index!")
config.add_route("index", "/")
config.add_view(index, route_name="index")
authz_policy = ACLAuthorizationPolicy()
config.set_authorization_policy(authz_policy)
authn_policy = AuthTktAuthenticationPolicy("secret")
config.set_authentication_policy(authn_policy)
session_factory = session_factory_from_settings(settings)
config.set_session_factory(session_factory)
config.registry.registerUtility(DBSession, IDBSession)
if settings.get("su.require_activation", True):
config.include("pyramid_mailer")
config.include("horus")
app = config.make_wsgi_app()
return app
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings)
config.set_session_factory(session_factory)
config.include('pyramid_mako')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_static_view('css', 'static/css')
config.add_static_view('images', 'static/images')
config.add_static_view('js', 'static/js')
config.add_route('/about', '/')
config.add_route('/genes', '/genes')
config.add_route('/gene_search', '/gene_search')
config.add_route('/datasets', '/datasets')
config.add_route('/pca', '/pca')
config.add_route('/expression', '/expression')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
authn_policy = AuthTktAuthenticationPolicy(settings.get('pumbaa.secret'), callback=group_finder)
authz_policy = ACLAuthorizationPolicy()
pumbaa_session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings,
root_factory='pumbaa.acl.RootFactory',
authentication_policy=authn_policy,
authorization_policy=authz_policy,
session_factory = pumbaa_session_factory)
models.initial(settings)
config.include('velruse.providers.facebook')
config.add_facebook_login_from_settings(prefix='velruse.facebook.')
config.include('velruse.providers.google_oauth2')
config.add_google_oauth2_login_from_settings(prefix='velruse.google.')
config.include('velruse.providers.twitter')
config.add_twitter_login_from_settings(prefix='velruse.twitter.')
add_routes(config)
config.scan('pumbaa.views')
from .request_factory import RequestWithUserAttribute
config.set_request_factory(RequestWithUserAttribute)
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
settings["g"] = g = Globals(**settings)
config = Configurator(settings=settings
, session_factory = session_factory_from_settings(settings)
, locale_negotiator = DefaultLocaleNegotiator(g.available_locales, g.default_locale_name))
extend_request(config)
config.add_translation_dirs('formencode:i18n')
config.add_translation_dirs('larryslist:locale')
config.add_renderer(".html", renderer_factory)
config.add_renderer(".xml", renderer_factory)
config.add_renderer('json', jsonRenderer)
config.add_subscriber(add_localizer, 'pyramid.events.NewRequest')
config.add_subscriber(context_authorization, 'pyramid.events.ContextFound')
config.add_subscriber(add_renderer_variables, 'pyramid.events.BeforeRender')
if g.is_debug:
config.add_static_view('static', 'static', cache_max_age=3600)
if settings['deploy.admin'] == 'True':
config.include("larryslist.admin.apps", route_prefix='/admin')
if settings['deploy.website']:
config.include("larryslist.website.apps")
if settings['deploy.reports'] =='True':
config.include("larryslist.reports.apps", route_prefix='/reports')
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
authentication_policy = AuthTktAuthenticationPolicy('somesecret')
authorization_policy = ACLAuthorizationPolicy()
session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings,
authentication_policy=authentication_policy,
authorization_policy=authorization_policy,
root_factory=Root,
)
config.set_session_factory(session_factory)
# jinja 2 config
config.add_jinja2_search_path("chessnut:templates")
config.include('pyramid_jinja2')
# views
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('twauth', '/twauth')
config.add_route('index', '/index')
config.add_route('register', '/register')
config.add_route('mentions', '/mentions')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
config = Configurator(settings=settings)
config.add_route('index', '/')
authn_policy = AuthTktAuthenticationPolicy('secret', callback=groupfinder)
config.set_authentication_policy(authn_policy)
authz_policy = ACLAuthorizationPolicy()
config.set_authorization_policy(authz_policy)
session_factory = session_factory_from_settings(settings)
config.set_session_factory(session_factory)
engine = engine_from_config(settings, prefix='sqlalchemy.')
DBSession.configure(bind=engine)
config.registry.registerUtility(DBSession, ISUSession)
config.include('pyramid_tm')
if settings.get('su.require_activation', True):
config.include('pyramid_mailer')
config.scan('demo')
config.include('pyramid_signup')
app = config.make_wsgi_app()
return app
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
import logging
logging.basicConfig(level=logging.DEBUG)
config = Configurator(root_factory=get_root, settings=settings)
config.begin()
from pyramid_jinja2 import renderer_factory
config.add_renderer('.jinja2', renderer_factory)
# configure views, templates
configure(config)
# configure session
import pyramid_beaker
session_factory = pyramid_beaker.session_factory_from_settings(settings)
config.set_session_factory(session_factory)
# configure OpenID-specific storage
import stucco_openid.models
from openid.store import filestore
stucco_openid.models.root.store = \
filestore.FileOpenIDStore(settings['openid.store_file_path'])
config.end()
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)
authn_policy = AuthTktAuthenticationPolicy(settings['auth.secret'],
callback=User.groupfinder)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(
settings=settings,
session_factory=session_factory,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
root_factory=Root
)
config.add_static_view('images', 'duckly:static/images')
config.add_static_view('js', 'duckly:static/js')
config.add_static_view('css', 'duckly:static/css')
config.add_google_oauth2_login_from_settings(prefix='google.')
config.add_route('logout', '/logout')
config.add_route('home.unauth', '/', custom_predicates=(unauthorized,))
config.add_route('home', '/', custom_predicates=(authorized,))
config.add_route('signup', '/signup')
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.')
initialize_sql(engine)
session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings,
session_factory=session_factory)
config.include('pyramid_mailer')
config.add_translation_dirs(
'colander:locale/',
'deform:locale/',
'c3sintent:locale/')
config.add_static_view('static',
'c3sintent:static', cache_max_age=3600)
config.add_subscriber('c3sintent.subscribers.add_base_template',
'pyramid.events.BeforeRender')
config.add_subscriber('c3sintent.subscribers.add_locale_to_cookie',
'pyramid.events.NewRequest')
# home /
# membership application form
config.add_route('intent', '/')
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)
LogSession.configure(bind=engine)
Base.metadata.bind = engine
authn_policy = AuthTktAuthenticationPolicy(
'sosecret', callback=groupfinder, hashalg='sha512')
authz_policy = ACLAuthorizationPolicy()
my_session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings,
root_factory='loginproject.models.RootFactory',
#session_factory=my_session_factory
)
config.include('pyramid_beaker')
config.set_session_factory(my_session_factory)
config.set_authentication_policy(authn_policy)
config.set_authorization_policy(authz_policy)
config.add_request_method(models.get_user, 'user', reify=True)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('protected', '/protected')
config.add_route('login', '/login/{provider}')
config.add_route('logout', '/logout')
config.scan()
return config.make_wsgi_app()
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
session_factory = session_factory_from_settings(settings)
authn_policy = AuthTktAuthenticationPolicy('secretstring',
callback=groupfinder)
authz_policy = ACLAuthorizationPolicy()
config = Configurator(settings=settings, session_factory=session_factory,
root_factory='portfolio.models.permissions.RootFactory',
authentication_policy=authn_policy,
authorization_policy=authz_policy)
config.include('pyramid_chameleon')
config.include('pyramid_beaker')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('list_user', '/list_user/')
config.add_route('ajax_user', '/ajax_user/')
config.add_route('datatable','/datatable/')
config.add_route('download','/download/{id_doc}')
get_routes(config)
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.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 main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
#engine.echo = True
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='egaji.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_months, 'months', 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_renderer('csv', '.tools.CSVRenderer')
#routes = DBSession.query(RouteModel.kode, RouteModel.path, RouteModel.nama, RouteModel.factory).all()
"""
for route in routes:
if route.factory:
config.add_route(route.kode, route.path, factory=(route.factory).encode("utf8"))
else:
config.add_route(route.kode, route.path)
"""
# if route.nama:
# titles[route.kode] = route.nama #' - '.join([main_title, title])
for name, path, title, factory in routes:
if factory:
config.add_route(name, path, factory=factory)
else:
config.add_route(name, path)
if name:
titles[name] = ' - '.join([path, title])
print list(title)
config.scan()
return config.make_wsgi_app()
def get_session(self, settings):
old_name = settings['old_name']
try:
return self.session_factories[old_name]
except KeyError:
self.session_factories[old_name] = session_factory_from_settings(
settings)
return self.session_factories[old_name]
def main(global_config, **settings):
# defaults
if 'mako.directories' not in settings:
settings['mako.directories'] = 'marteauweb:templates'
session_factory = session_factory_from_settings(settings)
# configure the waitress logger
logger = logging.getLogger('waitress')
logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
logger.addHandler(ch)
# creating the config and the queue
config = Configurator(settings=settings, session_factory=session_factory)
config.registry['queue'] = queue.Queue()
# Use our custom Request class
config.set_request_factory(Request)
# Both of our chosen policies configure a "forbidden view" to handle
# unauthenticated access. We have to resolve this conflict by explicitly
# picking which one we want to use.
config.add_forbidden_view("pyramid_persona.views.forbidden")
# routing
config.add_route('index', '/')
config.add_route('profile', '/profile')
config.add_route('purge', '/purge')
config.add_route('reset', '/reset')
config.add_route('test', '/test')
config.add_route('cancel', '/test/{jobid}/cancel')
config.add_route('delete', '/test/{jobid}/delete')
config.add_route('replay', '/test/{jobid}/replay')
config.add_route('job', '/test/{jobid}')
config.add_route('nodes', '/nodes')
config.add_route('node_enable', '/nodes/{name}/enable')
config.add_route('node_test', '/nodes/{name}/test')
config.add_route('node', '/nodes/{name}')
config.add_route('report_index', '/report/{jobid}')
config.add_route('report_file', '/report/{jobid}/{filename:.*}')
config.add_route('docs_file', '/docs/{file:.*}')
config.add_route('docs_index', '/docs')
config.add_route('addjob', '/addjob')
config.add_route('fixture_options', '/fixture_options/{fixture:.*}')
config.add_route('project_options', '/project_options/{project:.*}')
config.add_route('hosts', '/hosts')
config.add_route('verify_host', '/hosts/{host:.*}/verify')
config.add_route('host', '/hosts/{host:.*}')
config.add_static_view('media', 'marteauweb:media/')
config.add_route('karaoke', '/media/marteau.kar')
config.add_route('socket_io', 'socket.io/*remaining')
config.scan("marteauweb.views")
config.scan("marteauweb.socketio_service")
return config.make_wsgi_app()
def main(global_config, **settings):
"""Constructs a WSGI application."""
settings['paste_config'] = global_config
### Settings
# Set up SQLAlchemy stuff
engine = engine_from_config(settings, 'sqlalchemy.')
floof.model.initialize(engine, extension=ZopeTransactionExtension())
# floof debug panel
settings['debug'] = asbool(settings.get('floof.debug', False))
# Misc other crap
settings['rating_radius'] = int(settings['rating_radius'])
settings['filestore_factory'] = filestore.get_storage_factory(settings)
### Configuratify
# Session factory needs to subclass our mixin above. Beaker's
# verbosely-named function just returns a class, so do some MI
FloofSessionFactory = type(
'FloofSessionFactory',
(_RichSessionFlashMixin, session_factory_from_settings(settings)), {})
config = Configurator(
settings=settings,
root_factory=FloofRoot,
request_factory=FloofRequest,
session_factory=FloofSessionFactory,
authentication_policy=FloofAuthnPolicy(),
authorization_policy=ACLAuthorizationPolicy(),
)
# PySCSS support
config.include('pyramid_scss')
config.add_route('pyscss', '/css/{css_path:[^/]+}.css')
config.add_view(route_name='pyscss',
view='pyramid_scss.controller.get_scss',
renderer='scss',
request_method='GET')
# Added manually because @subscriber only works with a
# scan, and we don't want to scan ourselves
config.add_subscriber(prevent_csrf, NewRequest)
config.add_subscriber(manage_stashes, NewRequest)
config.add_subscriber(auto_privilege_escalation, ContextFound)
config.add_subscriber(add_renderer_globals, BeforeRender)
floof.routing.configure_routing(config)
config.scan(floof.views)
if not settings['debug']:
from floof.views.errors import error500
config.add_view(error500, context=Exception)
app = config.make_wsgi_app()
app = HTTPOnlyCookieMiddleware(app)
return app
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
engine = engine_from_config(settings, 'sqlalchemy.')
session_factory = session_factory_from_settings(settings)
authn_policy = AuthTktAuthenticationPolicy(
's0secret!!',
callback=groupfinder,)
authz_policy = ACLAuthorizationPolicy()
DBSession.configure(bind=engine)
Base.metadata.bind = engine
config = Configurator(settings=settings,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
session_factory=session_factory,
root_factory=Root)
# using a custom request with user information
config.set_request_factory(RequestWithUserAttribute)
config.include('pyramid_mailer')
config.add_translation_dirs(
'colander:locale/',
'deform:locale/',
'c3smembership:locale/')
config.add_static_view('static',
'c3smembership:static', cache_max_age=3600)
config.add_subscriber('c3smembership.subscribers.add_base_template',
'pyramid.events.BeforeRender')
config.add_subscriber('c3smembership.subscribers.add_locale_to_cookie',
'pyramid.events.NewRequest')
# home is /, the membership application form
config.add_route('join', '/')
# info pages
config.add_route('disclaimer', '/disclaimer')
config.add_route('faq', '/faq')
config.add_route('statute', '/statute')
config.add_route('manifesto', '/manifesto')
# success and further steps
config.add_route('success', '/success')
config.add_route('success_check_email', '/check_email')
config.add_route('verify_email_password', '/verify/{email}/{code}')
config.add_route('success_pdf', '/C3S_SCE_AFM_{namepart}.pdf')
# routes & views for staff
config.add_route('dashboard', '/dashboard/{number}')
config.add_route('detail', '/detail/{memberid}')
config.add_route('switch_sig', '/switch_sig/{memberid}')
config.add_route('switch_pay', '/switch_pay/{memberid}')
config.add_route('delete_entry', '/delete/{memberid}')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.scan()
return config.make_wsgi_app()
def includeme(config):
""" Set up and configure the pypicloud app """
config.set_root_factory(Root)
config.include('pyramid_tm')
config.include('pyramid_beaker')
config.include('pyramid_duh')
config.include('pyramid_duh.auth')
config.include('pypicloud.auth')
config.include('pypicloud.access')
settings = config.get_settings()
config.add_renderer('json', json_renderer)
# Jinja2 configuration
settings['jinja2.filters'] = {
'static_url': 'pyramid_jinja2.filters:static_url_filter',
'tojson': to_json,
}
settings['jinja2.directories'] = ['pypicloud:templates']
config.include('pyramid_jinja2')
# BEAKER CONFIGURATION
settings.setdefault('session.type', 'cookie')
settings.setdefault('session.httponly', 'true')
config.set_session_factory(session_factory_from_settings(settings))
# PYPICLOUD SETTINGS
config.registry.fallback_url = settings.get('pypi.fallback_url',
'http://pypi.python.org/simple')
config.registry.use_fallback = asbool(settings.get('pypi.use_fallback',
True))
realm = settings.get('pypi.realm', 'pypi')
config.registry.realm = realm
# CACHING DATABASE SETTINGS
resolver = DottedNameResolver(__name__)
dotted_cache = settings.get('pypi.db', 'sql')
if dotted_cache == 'sql':
dotted_cache = 'pypicloud.cache.SQLCache'
elif dotted_cache == 'redis':
dotted_cache = 'pypicloud.cache.RedisCache'
cache_impl = resolver.resolve(dotted_cache)
cache_impl.configure(config)
cache_impl.reload_if_needed()
config.add_request_method(cache_impl, name='db', reify=True)
# Special request methods
config.add_request_method(_app_url, name='app_url')
config.add_request_method(lambda x: __version__, name='pypicloud_version',
reify=True)
cache_max_age = int(settings.get('pyramid.cache_max_age', 3600))
config.add_static_view(name='static/%s' % __version__,
path='pypicloud:static',
cache_max_age=cache_max_age)
def includeme(config):
""" Set up and configure the pypicloud app """
config.set_root_factory(Root)
config.include('pyramid_tm')
config.include('pyramid_beaker')
config.include('pyramid_duh')
config.include('pyramid_duh.auth')
config.include('pypicloud.auth')
config.include('pypicloud.access')
config.include('pypicloud.cache')
settings = config.get_settings()
config.add_renderer('json', json_renderer)
# Jinja2 configuration
settings['jinja2.filters'] = {
'static_url': 'pyramid_jinja2.filters:static_url_filter',
'tojson': to_json,
}
settings['jinja2.directories'] = ['pypicloud:templates']
config.include('pyramid_jinja2')
# BEAKER CONFIGURATION
config.registry.secure_cookie = asbool(
settings.get('session.secure', False))
settings.setdefault('session.type', 'cookie')
settings.setdefault('session.httponly', 'true')
config.set_session_factory(session_factory_from_settings(settings))
# PYPICLOUD SETTINGS
default_url = 'https://pypi.python.org/simple'
config.registry.fallback_url = settings.get('pypi.fallback_url',
default_url)
fallback_mode = settings.get('pypi.fallback', 'redirect')
# Compatibility with the deprecated pypi.use_fallback option
if 'pypi.fallback' not in settings and 'pypi.use_fallback' in settings:
LOG.warn("Using deprecated option 'pypi.use_fallback'")
use_fallback = asbool(settings['pypi.use_fallback'])
fallback_mode = 'redirect' if use_fallback else 'none'
modes = ('redirect', 'cache', 'mirror', 'none')
if fallback_mode not in modes:
raise ValueError("Invalid value for 'pypi.fallback'. "
"Must be one of %s" % ', '.join(modes))
config.registry.fallback = fallback_mode
# Special request methods
config.add_request_method(_app_url, name='app_url')
config.add_request_method(_locator, name='locator', reify=True)
config.add_request_method(lambda x: __version__,
name='pypicloud_version',
reify=True)
cache_max_age = int(settings.get('pyramid.cache_max_age', 3600))
config.add_static_view(name='static/%s' % __version__,
path='pypicloud:static',
cache_max_age=cache_max_age)
def demo_app(global_config, **settings):
"""Return the example application for stucco_auth."""
from stucco_auth.models import get_root
engine = sqlalchemy.engine_from_config(settings)
Session = sqlalchemy.orm.sessionmaker(bind=engine)
settings[SESSION_FACTORY_KEY] = Session
session = Session()
try:
import stucco_evolution
stucco_evolution.initialize(session.connection())
stucco_evolution.create_or_upgrade_packages(session.connection(),
'stucco_auth')
tkt_secret = auth_tkt_secret(session)
authentication_policy = AuthTktAuthenticationPolicy(
tkt_secret.value, callback=security.lookup_groups)
authorization_policy = ACLAuthorizationPolicy()
config = Configurator(root_factory=get_root,
settings=settings,
authentication_policy=authentication_policy,
authorization_policy=authorization_policy)
config.add_renderer('.jinja2', pyramid_jinja2.renderer_factory)
# Configure beaker session:
import pyramid_beaker
session_factory = \
pyramid_beaker.session_factory_from_settings(settings)
config.set_session_factory(session_factory)
config.include('stucco_auth.includeme')
config.add_static_view('static', 'stucco_auth:static')
config.add_view(context=IAuthRoot, renderer='welcome.jinja2')
# event handler will only work if stucco_auth.tm is being used
config.add_subscriber(new_request_listener, NewRequest)
app = config.make_wsgi_app()
tm = TM(app, Session)
# For pshell compatibility:
tm.registry, tm.threadlocal_manager, tm.root_factory = \
app.registry, app.threadlocal_manager, app.root_factory
# In case database work was done during init:
session.commit()
except:
session.rollback()
raise
finally:
session.close()
return tm
def configure(config, settings={}):
# Include template renderers
config.include('pyramid_chameleon')
config.include('pyramid_mako')
# Include pyramid layout
config.include('pyramid_layout')
# Add route to deform's static resources
config.add_static_view('deform_static', 'deform:static')
# Add helpful properties to the request object
config.set_request_property(get_authenticated_user, 'user', reify=True)
# Setup session factory
session_factory = session_factory_from_settings(settings)
config.set_session_factory(session_factory)
# Set sudo as default permission
config.set_default_permission(BimtPermissions.sudo)
# configure routes
add_routes_auth(config)
add_routes_user(config)
add_routes_group(config)
add_routes_audit_log(config)
add_routes_portlet(config)
add_routes_mailing(config)
add_routes_other(config)
# register ZCA utilities
register_utilities(config)
add_custom_deform_templates()
# enable views that we need in Robot tests
ignores = ['pyramid_bimt.tests']
if asbool(settings.get('robot_testing', 'false')): # pragma: no cover
config.add_route('ping', '/ping/')
config.add_route('robot_commands', '/robot/{command}')
config.add_tween('pyramid_bimt.testing.inject_js_errorlogger')
config.add_tween('pyramid_bimt.testing.log_notfound')
else:
ignores.append('pyramid_bimt.testing')
# Run a venusian scan to pick up the declarative configuration.
config.scan('pyramid_bimt', ignore=ignores)
if settings.get('bimt.kill_cloudamqp_connections'): # pragma: no cover
kill_connections(username=settings.get('bimt.amqp_username', ''),
password=settings.get('bimt.amqp_password', ''),
apiurl=settings.get('bimt.amqp_apiurl', ''))
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
import ldap
my_session_factory = session_factory_from_settings(settings)
config = Configurator(settings=settings, root_factory=models.Resource, session_factory=my_session_factory)
from pyramid.authentication import SessionAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
#config.set_authentication_policy(SessionAuthenticationPolicy(callback=groupfinder))
#config.set_authorization_policy(ACLAuthorizationPolicy())
#config.ldap_setup(
#'ldap://ldap.iplantcollaborative.org',
#)
#config.ldap_set_login_query(
#base_dn='CN=people,DC=iplantcollaborative,DC=org',
#filter_tmpl='(uid=%(login)s)',
#scope = ldap.SCOPE_ONELEVEL,
#)
#config.ldap_set_groups_query(
#base_dn='CN=people,DC=iplantcollaborative,DC=org',
#filter_tmpl='(&(objectCategory=group)(member=%(userdn)s))',
#scope = ldap.SCOPE_SUBTREE,
#cache_period = 600,
#)
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('user_search', '/users/search' )
config.add_route('user', '/users/{user}')
config.add_route('users', '/users/')
config.add_route('user_memberships', '/users/{user}/memberships')
config.add_route('group_search', '/groups/search')
config.add_route('group', '/groups/{group}')
config.add_route('groups', '/groups/')
config.add_route('group_members', '/groups/{group}/members')
config.add_route('cypher', '/cypher')
config.scan()
return config.make_wsgi_app()
