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()