def _makeOne(self, autocommit=True): from pyramid.config import Configurator import pyramid_handlers from papyrus import add_papyrus_routes config = Configurator(autocommit=autocommit) config.add_directive('add_papyrus_routes', add_papyrus_routes) return config
def _makeOne(self, autocommit=True): from pyramid.config import Configurator from pyramid_handlers import add_handler config = Configurator(autocommit=autocommit) config.add_directive("add_handler", add_handler) return config
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ engine = engine_from_config(settings, 'sqlalchemy.') initialize_sql(engine) config = Configurator(settings=settings) config.include('pyramid_handlers') config.include('pyramid_jinja2') config.include('pyramid_mailer') session_factory = session_factory_from_settings(settings) config.set_session_factory(session_factory) config.add_directive('add_magic_handler', add_magic_handler) config.add_subscriber(add_renderer_globals, BeforeRender) config.add_static_view('statics', 'blog:statics') # Home route config.add_handler('home', get_route(), get_handler('blog'), 'index') # Custom routes # Index/Action routes config.add_magic_handler('user') config.add_magic_handler('post') config.add_magic_handler('tag') return config.make_wsgi_app()
def main(global_config, **settings): ## Prepare database engine = engine_from_config(settings, 'sqlalchemy.') db.session.configure(bind=engine) db.Base.metadata.bind = engine # # FIXME: Pyramid whines about no configured authorization policy, probably # because we didn't set authn policy using the Configurator initializer. authz_policy = ACLAuthorizationPolicy() config = Configurator( settings=settings, root_factory=Root, request_factory=RequestFactory, authorization_policy=authz_policy, ) # Expose the authorization policy through requests. config.add_request_method(lambda x: authz_policy, "authz", reify=True) # Add a configurator method to add new nodes to the root factory config.add_directive("add_root_node", Root.add_node, action_wrap=False) # Provide a short-hand method for testing permissions. config.add_request_method(request_test_permission, "permits") ## Load and configure all views for path in settings['perpetualfailure.modules'].split("\n"): module = __import__(path, fromlist=[path]) module.configure(config) config.scan(module) # return config.make_wsgi_app()
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ globalreg = getGlobalSiteManager() set_cache_regions_from_settings(settings) deserialized_settings = deserialize(settings) config = Configurator(registry=globalreg) config.setup_registry(settings=settings) config.registry.registerUtility( deserialized_settings, ISettings, name='settings' ) config.add_directive('settings_reader', lambda c: SettingsReader(c)) config.reader = SettingsReader(config) config.include('papaye.config.auth') config.include('papaye.config.routes') config.include('papaye.config.views') config.include('papaye.config.startup') config.add_renderer( name='json_api_compat', factory='papaye.views.api.compat.renderers.CompatAPIRendererFactory' ) config.commit() config.add_tween('papaye.tweens.LoginRequiredTweenFactory') config.scan(ignore=['papaye.tests', 'papaye.conftest']) config.set_request_property( lambda x: deserialized_settings, 'papaye_settings', reify=True ) return config.make_wsgi_app()
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ config = Configurator(settings=settings) config.add_directive('add_restful_routes', routing.add_restful_routes) set_globals(**settings) from . import config as global_config secret = str(uuid.uuid4()) # Beaker include config.include('pyramid_beaker') if global_config.AUTH_ENABLED is True: authn_policy = AuthTktAuthenticationPolicy(secret, callback=model.user_callback, hashalg='sha512', include_ip=global_config.AUTH_INCLUDE_IP) authz_policy = ACLAuthorizationPolicy() config.set_authentication_policy(authn_policy) config.set_authorization_policy(authz_policy) model.make_restful_app() routing.make_routes(config) 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. """ config = Configurator(settings=settings) config.add_directive('add_restful_routes', routing.add_restful_routes) set_globals(**settings) from . import config as global_config secret = str(uuid.uuid4()) # Beaker include config.include('pyramid_beaker') if global_config.AUTH_ENABLED is True: authn_policy = AuthTktAuthenticationPolicy( secret, callback=model.user_callback, hashalg='sha512', include_ip=global_config.AUTH_INCLUDE_IP) authz_policy = ACLAuthorizationPolicy() config.set_authentication_policy(authn_policy) config.set_authorization_policy(authz_policy) model.make_restful_app() routing.make_routes(config) 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 _makeOne(self, autocommit=True): from pyramid.config import Configurator import pyramid_handlers from papyrus import add_papyrus_handler config = Configurator(autocommit=autocommit) config.include(pyramid_handlers) config.add_directive("add_papyrus_handler", add_papyrus_handler) return config
def includeme(config: Configurator): def set_authorization_policy(config: Configurator, policy: Any) -> None: policy = config.maybe_dotted(policy) if isinstance(policy, INewAuthorizationPolicy): policy = AuthorizationPolicyWrapper(policy) # noinspection PyCallByClass SecurityConfiguratorMixin.set_authorization_policy(config, policy) config.add_directive('set_authorization_policy', set_authorization_policy)
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ mem_profiler = asbool(settings.get('mem_profiler', 'False')) settings['mem_profiler'] = mem_profiler perf_profiler = asbool(settings.get('perf_profiler', 'False')) settings['perf_profiler'] = perf_profiler config = Configurator(settings=settings) config.add_directive('add_restful_routes', routing.add_restful_routes) set_globals(**settings) from . import config as global_config secret = str(uuid.uuid4()) # NOTE: Beaker include! By John Doe config.include('pyramid_beaker') # TODO: Talvez faça-se necessário "descomentar" o que vai abaixo! # By Questor # if global_config.AUTH_ENABLED is True: # authn_policy=AuthTktAuthenticationPolicy( # secret, # callback=verify_api_key, # hashalg='sha512', # include_ip=global_config.AUTH_INCLUDE_IP # ) # authz_policy=ACLAuthorizationPolicy() # config.set_authentication_policy(authn_policy) # config.set_authorization_policy(authz_policy) model.make_restful_app() routing.make_routes(config) config.scan() app = config.make_wsgi_app() # NOTE: Add memory profiler middleware! By John Doe if mem_profiler: from .mem_profiler import ProfilerMiddleware app = ProfilerMiddleware(app) if perf_profiler: from repoze.profile import ProfileMiddleware app = ProfileMiddleware( app, log_filename='/var/log/lbg_perf_profile.log', cachegrind_filename='./cachegrind.out.bar', discard_first_request=True, flush_at_shutdown=True, path='/__perf_profiler', unwind=False ) return app
def includeme(config: Configurator): config.include('restfw') settings = config.get_settings() prefix = settings.get('restfw_admin.prefix', 'admin').strip('/') settings['restfw_admin.prefix'] = prefix from .resources import Admin def add_to_root(event): root = event.root root[prefix] = Admin() from restfw.interfaces import IRootCreated config.add_subscriber(add_to_root, IRootCreated) from .views import admin_ui, redirect_to_admin_ui ui_url = f'/{prefix}/ui' config.add_route('admin_ui_ts', f'{ui_url}/') config.add_view(admin_ui, route_name='admin_ui_ts', request_method='GET') config.add_route('admin_ui', ui_url) config.add_view(redirect_to_admin_ui, route_name='admin_ui', request_method='GET') config.add_route('admin_ui_index', f'{ui_url}/index.html') config.add_view(redirect_to_admin_ui, route_name='admin_ui_index', request_method='GET') import os from pathlib import Path admin_ui_dir = Path(__file__).parent / 'admin_ui' config.add_static_view(name=ui_url, path=os.fspath(admin_ui_dir)) import re from .config import get_admin_ui_settings index_html = (admin_ui_dir / 'index.html').read_text('utf-8') index_html_tpl = re.sub( r'<script>window\.__RESTFW_ADMIN_PARAMS__.+?</script>', '__ADMIN_PARAMS__', index_html, ) ui_settings = get_admin_ui_settings(config.registry) ui_settings.index_html_tpl = index_html_tpl from .config import add_resource_admin config.add_directive('add_resource_admin', add_resource_admin) from .fields import add_field_converter config.add_directive('add_field_converter', add_field_converter) from restfw.utils import scan_ignore config.scan(ignore=scan_ignore(config.registry))
def includeme(config: Configurator): from .external_links import add_external_link_fabric, add_external_link_fabric_predicate from .sub_resources import add_sub_resource_fabric, add_sub_resource_fabric_predicate from .views import add_resource_view config.add_directive('add_sub_resource_fabric', add_sub_resource_fabric) config.add_directive('add_sub_resource_fabric_predicate', add_sub_resource_fabric_predicate) config.add_directive('add_external_link_fabric', add_external_link_fabric) config.add_directive('add_external_link_fabric_predicate', add_external_link_fabric_predicate) config.add_directive('add_resource_view', add_resource_view)
def includeme(config: Configurator): # The ChangeHandler is a configurable callback run when there is a # new Changeset. There should only be one. A default is provided # but it can be overridden with the directive. ch = ChangeHandler(config) config.registry.change_handler = ch config.add_directive('register_changehandler', register_changehandler) # The Threadrunner watches changes on disk and calls the callback. # Subscribe to ApplicationCreated to start the # threadrunner as late as possible config.add_subscriber(start_threadrunner, ApplicationCreated)
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ mem_profiler = asbool(settings.get('mem_profiler', 'False')) settings['mem_profiler'] = mem_profiler perf_profiler = asbool(settings.get('perf_profiler', 'False')) settings['perf_profiler'] = perf_profiler config = Configurator(settings=settings) config.add_directive('add_restful_routes', routing.add_restful_routes) set_globals(**settings) from . import config as global_config secret = str(uuid.uuid4()) # NOTE: Beaker include! By John Doe config.include('pyramid_beaker') # TODO: Talvez faça-se necessário "descomentar" o que vai abaixo! # By Questor # if global_config.AUTH_ENABLED is True: # authn_policy=AuthTktAuthenticationPolicy( # secret, # callback=verify_api_key, # hashalg='sha512', # include_ip=global_config.AUTH_INCLUDE_IP # ) # authz_policy=ACLAuthorizationPolicy() # config.set_authentication_policy(authn_policy) # config.set_authorization_policy(authz_policy) model.make_restful_app() routing.make_routes(config) config.scan() app = config.make_wsgi_app() # NOTE: Add memory profiler middleware! By John Doe if mem_profiler: from .mem_profiler import ProfilerMiddleware app = ProfilerMiddleware(app) if perf_profiler: from repoze.profile import ProfileMiddleware app = ProfileMiddleware(app, log_filename='/var/log/lbg_perf_profile.log', cachegrind_filename='./cachegrind.out.bar', discard_first_request=True, flush_at_shutdown=True, path='/__perf_profiler', unwind=False) return app
def includeme(config: Configurator): rest_config = config.registry.restalchemy # Pyramid requires an authorization policy to be active. config.set_authorization_policy(ACLAuthorizationPolicy()) # Enable JWT authentication. config.include("pyramid_jwt") config.set_jwt_authentication_policy(auth_type="Bearer") config.add_route("restalchemy.login", "/" + rest_config.api_version + "/login") config.add_directive("set_authenticate_function", set_authenticate_function, action_wrap=True)
def test_start_scheduler_without_cache_in_configuration(mock): from papaye.config.startup import start_scheduler from papaye.tasks.devices import DummyScheduler from papaye.config.utils import SettingsReader config = Configurator() config.registry.settings = { 'papaye.cache': 'true', } config.add_directive('settings_reader', lambda c: SettingsReader(c)) start_scheduler(config) get_current_request() assert isinstance(mock.call_args[0][0], DummyScheduler)
def test_start_scheduler(mock): from papaye.config.startup import start_scheduler from papaye.config.utils import SettingsReader config = Configurator() config.registry.settings = { 'papaye.cache': 'true', 'papaye.scheduler': 'papaye.tests.test_config:SchedulerTest', } config.add_directive('settings_reader', lambda c: SettingsReader(c)) start_scheduler(config) get_current_request() assert isinstance(mock.call_args[0][0], SchedulerTest)
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ engine = engine_from_config(settings, 'sqlalchemy.') initialize_sql(engine) config = Configurator(settings=settings) config.include('pyramid_handlers') config.include('pyramid_jinja2') session_factory = session_factory_from_settings(settings) config.set_session_factory(session_factory) config.add_directive('add_magic_handler', add_magic_handler) config.add_subscriber(add_renderer_globals, BeforeRender) config.add_static_view('statics', 'blog:statics') # Home route config.add_handler('home', get_route(), get_handler('blog'), 'index') # Index/Action routes config.add_magic_handler('user') config.add_magic_handler('post') config.add_magic_handler('tag') config.add_magic_handler('snippet') config.add_magic_handler('media') config.add_magic_handler('feed') # Compatibilidade config.add_handler('feed_comp', get_route('feed'), get_handler('feed'), 'feed') # Custom routes config.add_handler('blog_index', get_route('blogs'), get_handler('blog'), 'index') config.add_handler('blog_entry', get_route('blogs', '{id}', '{alias}'), get_handler('blog'), 'view') config.add_handler('snippet_index', get_route('snippet'), get_handler('blog'), 'snippet_index') config.add_handler('snippet_entry', get_route('snippet', '{id}', '{alias}'), get_handler('blog'), 'snippet_view') config.add_handler('article', get_route('articles'), get_handler('blog'), 'article') config.add_handler('page', get_route('{alias}'), get_handler('blog'), 'page') return config.make_wsgi_app()
def includeme(config: Configurator): registry = config.registry # type: Registry cli = Cli(registry=registry) # Add `add_command` directive config.add_directive('add_command', add_command) # Register CLI component registry.registerUtility(cli, ICli) commands = registry.settings.get('cli.commands', []) # Register commands from settings for command in commands: config.add_command(command)
def includeme(config: Configurator): def action(): logger.info("Executing config action [exception views].") config.app_exception_view(Exception, ExceptionView, "templates/exception/exception.jinja2") config.app_exception_view(OperationArgumentException, OperationArgumentExceptionView, "templates/exception/exception.jinja2") config.app_exception_view(HTTPNotFound, ExceptionView, "templates/exception/exception.jinja2") intr = config.introspectable('app modules', __name__, "App module %r" % __name__, 'app modules') config.add_directive("app_exception_view", app_exception_view) disc = ('exception views', ) config.action(None, action, introspectables=(intr, ))
def includeme(config: Configurator) -> None: """Pyramid knob.""" config.add_view_deriver(openapi_view) config.add_directive("pyramid_openapi3_add_formatter", add_formatter) config.add_directive("pyramid_openapi3_add_explorer", add_explorer_view) config.add_directive("pyramid_openapi3_spec", add_spec_view) config.add_directive( "pyramid_openapi3_validation_error_view", add_validation_error_view )
def includeme(config: Configurator): ep_factory = EntryPointFactory() config.registry.registerUtility(ep_factory, IEntryPointFactory) config.add_directive('get_root_resource', _get_root_resource) # config.add_directive('get_resource_root', _get_root_resource) config.add_directive('get_resource_context', _get_resource_context) config.add_directive('set_resource_context', _set_resource_context) config.include('.myapp_config') # this "looks" redundant, but we have "views" and "view" - fun. FIXME config.include('.view') config.registry.registerUtility(NamespaceStore('form_name'), INamespaceStore, 'form_name') config.registry.registerUtility(NamespaceStore('namespace'), INamespaceStore, 'namespace')
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ # respect Heroku Environment VAR resolve_env_value(settings, 'sqlalchemy.url') resolve_env_value(settings, 'frontend.domain') resolve_env_value(settings, 'mandrill.sender', '') resolve_env_value(settings, 'admin.emails') engine = engine_from_config(settings, 'sqlalchemy.') log.info("DB Connected at: %s" % settings['sqlalchemy.url']) DBSession.configure(bind=engine) Base.metadata.bind = engine config = Configurator(settings=settings, authentication_policy=AuthProvider(settings), authorization_policy=ACLAuthorizationPolicy(), session_factory=session_factory_from_settings(settings), root_factory=RootResource, default_permission='default_permission') def get_front_end_domain(request): return settings['frontend.domain'] config.add_request_method(get_front_end_domain, 'frontend_domain', reify=True) config.add_directive('add_mako_renderer', pyramid_mako.add_mako_renderer) config.add_mako_renderer(".html") config.add_renderer('json', jsonRenderer) config.add_renderer(None, jsonRenderer) config.add_view_predicate('content_type', ContentTypePredicate) config.add_request_method(log_activity, 'log_activity', reify=True) config.add_request_method(emailer_factory(settings), 'emailer', reify=True) config.add_request_method(get_candidate_id, 'candidate_id', property=True) config.add_request_method(get_employer_id, 'employer_id', property=True) config.add_static_view('static', 'static', cache_max_age=3600) config.include('scotty.views') config.scan() app = config.make_wsgi_app() return CORS(app)
def main(global_config, **settings): """This function returns a Pyramid WSGI application.""" config = Configurator(settings=settings) config.include("pyramid_chameleon") config.add_directive("add_cors_preflight_handler", add_cors_preflight_handler) config.add_route_predicate("cors_preflight", CorsPreflightPredicate) config.add_subscriber(add_cors_to_response, "pyramid.events.NewResponse") config.add_route( "cors-options-preflight", "/{catch_all:.*}", cors_preflight=True, ) config.add_view( cors_options_view, route_name="cors-options-preflight", permission=NO_PERMISSION_REQUIRED, ) config.add_renderer("prettyjson", JSON(indent=4, sort_keys=True)) config.add_static_view("static", "static", cache_max_age=3600) config.add_route("home", "/") config.add_route("programs", "/playlist") config.add_route("program-type-list", "/program-type-list") config.add_route("program-type-news", "/program-type-news") config.add_route("playlist", "/playlist/{playlist_id}") config.add_route("playlist-per-type", "/type-playlist/{playlist_id}") config.add_route("radio", "/radio") config.add_route("radio-program-type-list", "/radio-program-type-list") config.add_route("radio-playlist-per-type", "/type-rplaylist/{playlist_id}") config.add_route("radio-stations", "/radio-stations") config.add_route("radio-station-program-list", "/radio-station-programs/{station_id}") config.add_route("radioplaylist", "/rplaylist/{playlist_id:[a-zA-Z0-9\.\-\/]+}") config.add_route("episode", "/episode/{episode_url:[a-zA-Z0-9\.\-\/]+}") config.add_route('last-broadcast-list', '/last-broadcast-list') config.scan() return config.make_wsgi_app()
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ # TODO learn logging package # TODO drink double coffee config = Configurator(settings=settings) config.include('pyramid_jinja2') config.include('iap.common.repository.db') config.include(common_routing) config.include(forecast_routing, route_prefix='/forecast') # Add routing for another tools config.add_directive('create_error_manager', create_error_manager) config.create_error_manager() return config.make_wsgi_app()
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ config = Configurator(settings=settings) urihand_settings = _parse_settings(config.registry.settings) handlerconfig = _load_configuration(urihand_settings['config']) _build_uri_handler(config.registry, handlerconfig) config.add_directive('get_uri_handler', get_uri_handler) config.add_request_method(get_uri_handler, 'uri_handler', reify=True) config.add_route('handle', '/handle') config.add_route('uris', '/uris') config.add_route('redirect', '/{uri:.*}') config.scan() return config.make_wsgi_app()
def make_toolbar_app(settings, parent_registry): """ WSGI application for rendering the debug toolbar.""" config = Configurator(settings=settings) config.registry.parent_registry = parent_registry config.registry.registerUtility(OrderedDict(), IPanelMap) config.add_directive('add_debugtoolbar_panel', add_debugtoolbar_panel) config.add_directive('inject_parent_action', inject_parent_action) config.include('pyramid_mako') config.add_mako_renderer('.dbtmako', settings_prefix='dbtmako.') config.add_request_method( lambda r: r.matchdict.get('request_id'), 'pdtb_id', reify=True, ) config.add_request_method( lambda r: r.registry.parent_registry.pdtb_history, 'pdtb_history', reify=True, ) config.add_static_view('static', STATIC_PATH) config.add_route(ROOT_ROUTE_NAME, '/', static=True) config.add_route('debugtoolbar.sse', '/sse') config.add_route('debugtoolbar.redirect', '/redirect') config.add_route('debugtoolbar.request', '/{request_id}') config.add_route('debugtoolbar.main', '/') config.scan(__name__) for include in bundled_includes: config.include(include) # commit the toolbar config and include any user-defined includes config.commit() includes = settings.get(SETTINGS_PREFIX + 'includes', ()) for include in includes: config.include(include) return config.make_wsgi_app()
def includeme(config: Configurator) -> None: """ Include the simple SQLAlchemy configuration with reasonable defaults. :param config: the configurator """ try: import sqlalchemy except ImportError as e: raise RuntimeError('sqlalchemy cannot be imported, ' 'unable to include tet.sqlalchemy.simple') from e config.include('pyramid_services') settings = config.get_settings() settings['tm.manager_hook'] = 'pyramid_tm.explicit_manager' # use pyramid_tm to hook the transaction lifecycle to the request config.include('pyramid_tm') config.add_directive('setup_sqlalchemy', setup_sqlalchemy)
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) , authentication_policy=Security() , authorization_policy=ACLAuthorizationPolicy() , default_permission='view' ) request.extend_request_dispatch(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(_) def pluralize(request, singular, plural, num): return singular.format(num=num) if num == 1 else plural.format(num=num) config.add_request_method(pluralize) config.add_subscriber(add_renderer_variables, 'pyramid.events.BeforeRender') def dictionary_factory(request): result = GetStaticContentProc(request) return {k.key:k.value for k in result.Static} POFILE = set_up_content_mgmt_app(config, "klinik:locale/klinik.pot", dictionary_factory) g.set_po_file(POFILE) config.include("klinik.views.website") config.include("klinik.views.admin", route_prefix="/admin") config.add_route("admin_home", "/admin", factory=AdminResource) # this is required to admin tool is at /admin and not /admin/ return config.make_wsgi_app()
def includeme(config: Configurator) -> None: """Pyramid knob.""" config.add_view_deriver(openapi_view) config.add_directive("pyramid_openapi3_add_formatter", add_formatter) config.add_directive("pyramid_openapi3_add_explorer", add_explorer_view) config.add_directive("pyramid_openapi3_spec", add_spec_view) config.add_tween("pyramid_openapi3.tween.response_tween_factory", over=EXCVIEW)
def main(global_config, **settings): """This function returns a Pyramid WSGI application.""" config = Configurator(settings=settings) config.include('pyramid_chameleon') config.add_directive( 'add_cors_preflight_handler', add_cors_preflight_handler) config.add_route_predicate('cors_preflight', CorsPreflightPredicate) config.add_subscriber(add_cors_to_response, 'pyramid.events.NewResponse') config.add_route( 'cors-options-preflight', '/{catch_all:.*}', cors_preflight=True, ) config.add_view( cors_options_view, route_name='cors-options-preflight', permission=NO_PERMISSION_REQUIRED, ) config.add_renderer('prettyjson', JSON(indent=4, sort_keys=True)) config.add_static_view('static', 'static', cache_max_age=3600) config.add_route('home', '/') config.add_route('programs', '/playlist') config.add_route('program-type-list', '/program-type-list') config.add_route('program-type-news', '/program-type-news') config.add_route('playlist', '/playlist/{playlist_id}') config.add_route('playlist-per-type', '/type-playlist/{playlist_id}') config.add_route('radio', '/radio') config.add_route('radio-program-type-list', '/radio-program-type-list') config.add_route('radio-playlist-per-type', '/type-rplaylist/{playlist_id}') config.add_route('radio-stations', '/radio-stations') config.add_route('radio-station-program-list', '/radio-station-programs/{station_id}') config.add_route('radioplaylist', '/rplaylist/{playlist_id:[a-zA-Z0-9\.\-\/]+}') config.add_route('episode', '/episode/{episode_url:[a-zA-Z0-9\.\-\/]+}') config.scan() return config.make_wsgi_app()
def includeme(config: Configurator): config.include('restfw.config') from . import predicates from .viewderivers import register_view_derivers config.set_root_factory('restfw.root.root_factory') config.add_renderer(None, 'restfw.renderers.json_renderer') predicates = [ ('debug', predicates.DebugPredicate), ('testing', predicates.TestingPredicate), ('debug_or_testing', predicates.DebugOrTestingPredicate), ] for name, fabric in predicates: config.add_view_predicate(name, fabric) config.add_subscriber_predicate(name, fabric) from .usage_examples.config import add_usage_examples_fabric_predicate from .usage_examples.config import add_usage_examples_fabric config.add_directive('add_usage_examples_fabric', add_usage_examples_fabric) config.add_directive('add_usage_examples_fabric_predicate', add_usage_examples_fabric_predicate) register_view_derivers(config) # Fix memory leaks on pyramid segment cache import pyramid.traversal if pyramid.traversal._segment_cache.__class__ is dict: from lru import LRU pyramid.traversal._segment_cache = LRU(1000) from .utils import scan_ignore ignore = scan_ignore(config.registry) ignore.extend([ '.docs_gen', ]) config.scan(ignore=ignore)
def includeme(config: Configurator) -> None: """Pyramid knob.""" config.add_view_deriver(openapi_view) config.add_directive("pyramid_openapi3_add_formatter", add_formatter) config.add_directive("pyramid_openapi3_add_explorer", add_explorer_view) config.add_directive("pyramid_openapi3_spec", add_spec_view) config.add_directive("pyramid_openapi3_spec_directory", add_spec_view_directory) config.add_directive("pyramid_openapi3_register_routes", register_routes) config.add_tween("pyramid_openapi3.tween.response_tween_factory", over=EXCVIEW) config.add_subscriber(check_all_routes, ApplicationCreated) if not config.registry.settings.get( # pragma: no branch "pyramid_openapi3_extract_errors" ): config.registry.settings["pyramid_openapi3_extract_errors"] = extract_errors config.add_exception_view( view=openapi_validation_error, context=RequestValidationError, renderer="json" ) config.add_exception_view( view=openapi_validation_error, context=ResponseValidationError, renderer="json" )
def main(global_config, **settings): config = Configurator( autocommit=True, settings=settings, authentication_policy=AuthenticationPolicy(settings['auth.file'], __name__), authorization_policy=AuthorizationPolicy(), route_prefix=route_prefix(settings), ) config.include('pyramid_exclog') config.include("cornice") config.add_forbidden_view(forbidden) config.add_request_method(request_params, 'params', reify=True) config.add_request_method(authenticated_role, reify=True) config.add_request_method(extract_tender, 'tender', reify=True) config.add_request_method(check_accreditation) config.add_request_method(json_body, 'json_body', reify=True) config.add_renderer('json', JSON(serializer=simplejson.dumps)) config.add_renderer('prettyjson', JSON(indent=4, serializer=simplejson.dumps)) config.add_renderer('jsonp', JSONP(param_name='opt_jsonp', serializer=simplejson.dumps)) config.add_renderer('prettyjsonp', JSONP(indent=4, param_name='opt_jsonp', serializer=simplejson.dumps)) config.add_subscriber(add_logging_context, NewRequest) config.add_subscriber(set_logging_context, ContextFound) config.add_subscriber(set_renderer, NewRequest) config.add_subscriber(beforerender, BeforeRender) config.scan("openprocurement.api.views.spore") config.scan("openprocurement.api.views.health") # tender procurementMethodType plugins support config.add_route_predicate('procurementMethodType', isTender) config.registry.tender_procurementMethodTypes = {} config.add_request_method(tender_from_data) config.add_directive('add_tender_procurementMethodType', register_tender_procurementMethodType) # search for plugins plugins = settings.get('plugins') and settings['plugins'].split(',') for entry_point in iter_entry_points('openprocurement.api.plugins'): if not plugins or entry_point.name in plugins: plugin = entry_point.load() plugin(config) # CouchDB connection db_name = os.environ.get('DB_NAME', settings['couchdb.db_name']) server = Server(settings.get('couchdb.url'), session=Session(retry_delays=range(10))) if 'couchdb.admin_url' not in settings and server.resource.credentials: try: server.version() except Unauthorized: server = Server(extract_credentials(settings.get('couchdb.url'))[0]) config.registry.couchdb_server = server if 'couchdb.admin_url' in settings and server.resource.credentials: aserver = Server(settings.get('couchdb.admin_url'), session=Session(retry_delays=range(10))) config.registry.admin_couchdb_server = aserver users_db = aserver['_users'] if SECURITY != users_db.security: LOGGER.info("Updating users db security", extra={'MESSAGE_ID': 'update_users_security'}) users_db.security = SECURITY username, password = server.resource.credentials user_doc = users_db.get('org.couchdb.user:{}'.format(username), {'_id': 'org.couchdb.user:{}'.format(username)}) if not user_doc.get('derived_key', '') or PBKDF2(password, user_doc.get('salt', ''), user_doc.get('iterations', 10)).hexread(int(len(user_doc.get('derived_key', '')) / 2)) != user_doc.get('derived_key', ''): user_doc.update({ "name": username, "roles": [], "type": "user", "password": password }) LOGGER.info("Updating api db main user", extra={'MESSAGE_ID': 'update_api_main_user'}) users_db.save(user_doc) security_users = [username, ] if 'couchdb.reader_username' in settings and 'couchdb.reader_password' in settings: reader_username = settings.get('couchdb.reader_username') reader = users_db.get('org.couchdb.user:{}'.format(reader_username), {'_id': 'org.couchdb.user:{}'.format(reader_username)}) if not reader.get('derived_key', '') or PBKDF2(settings.get('couchdb.reader_password'), reader.get('salt', ''), reader.get('iterations', 10)).hexread(int(len(reader.get('derived_key', '')) / 2)) != reader.get('derived_key', ''): reader.update({ "name": reader_username, "roles": ['reader'], "type": "user", "password": settings.get('couchdb.reader_password') }) LOGGER.info("Updating api db reader user", extra={'MESSAGE_ID': 'update_api_reader_user'}) users_db.save(reader) security_users.append(reader_username) if db_name not in aserver: aserver.create(db_name) db = aserver[db_name] SECURITY[u'members'][u'names'] = security_users if SECURITY != db.security: LOGGER.info("Updating api db security", extra={'MESSAGE_ID': 'update_api_security'}) db.security = SECURITY auth_doc = db.get(VALIDATE_DOC_ID, {'_id': VALIDATE_DOC_ID}) if auth_doc.get('validate_doc_update') != VALIDATE_DOC_UPDATE % username: auth_doc['validate_doc_update'] = VALIDATE_DOC_UPDATE % username LOGGER.info("Updating api db validate doc", extra={'MESSAGE_ID': 'update_api_validate_doc'}) db.save(auth_doc) # sync couchdb views sync_design(db) db = server[db_name] else: if db_name not in server: server.create(db_name) db = server[db_name] # sync couchdb views sync_design(db) config.registry.db = db # readjust couchdb json decoder couchdb_json_decode() # Document Service key config.registry.docservice_url = settings.get('docservice_url') config.registry.docservice_username = settings.get('docservice_username') config.registry.docservice_password = settings.get('docservice_password') config.registry.docservice_upload_url = settings.get('docservice_upload_url') config.registry.docservice_key = dockey = Signer(settings.get('dockey', '').decode('hex')) config.registry.keyring = keyring = {} dockeys = settings.get('dockeys') if 'dockeys' in settings else dockey.hex_vk() for key in dockeys.split('\0'): keyring[key[:8]] = Verifier(key) # migrate data if not os.environ.get('MIGRATION_SKIP'): for entry_point in iter_entry_points('openprocurement.api.migrations'): plugin = entry_point.load() plugin(config.registry) config.registry.server_id = settings.get('id', '') config.registry.health_threshold = float(settings.get('health_threshold', 99)) config.registry.update_after = asbool(settings.get('update_after', True)) return config.make_wsgi_app()
def main(global_config, **settings): config = Configurator( autocommit=True, settings=settings, authentication_policy=AuthenticationPolicy(settings['auth.file'], __name__), authorization_policy=AuthorizationPolicy(), route_prefix=ROUTE_PREFIX, ) config.include('pyramid_exclog') config.include("cornice") config.add_forbidden_view(forbidden) config.add_request_method(request_params, 'params', reify=True) config.add_request_method(authenticated_role, reify=True) config.add_request_method(extract_tender, 'tender', reify=True) config.add_renderer('prettyjson', JSON(indent=4)) config.add_renderer('jsonp', JSONP(param_name='opt_jsonp')) config.add_renderer('prettyjsonp', JSONP(indent=4, param_name='opt_jsonp')) config.add_subscriber(add_logging_context, NewRequest) config.add_subscriber(set_logging_context, ContextFound) config.add_subscriber(set_renderer, NewRequest) config.add_subscriber(beforerender, BeforeRender) config.scan("openprocurement.api.views.spore") # tender procurementMethodType plugins support config.add_route_predicate('procurementMethodType', isTender) config.registry.tender_procurementMethodTypes = {} config.add_request_method(tender_from_data) config.add_directive('add_tender_procurementMethodType', register_tender_procurementMethodType) # search for plugins plugins = settings.get('plugins') and settings['plugins'].split(',') for entry_point in iter_entry_points('openprocurement.api.plugins'): if not plugins or entry_point.name in plugins: plugin = entry_point.load() plugin(config) # CouchDB connection db_name = os.environ.get('DB_NAME', settings['couchdb.db_name']) server = Server(settings.get('couchdb.url'), session=Session(retry_delays=range(10))) if 'couchdb.admin_url' not in settings and server.resource.credentials: try: server.version() except Unauthorized: server = Server( extract_credentials(settings.get('couchdb.url'))[0]) config.registry.couchdb_server = server if 'couchdb.admin_url' in settings and server.resource.credentials: aserver = Server(settings.get('couchdb.admin_url'), session=Session(retry_delays=range(10))) users_db = aserver['_users'] if SECURITY != users_db.security: LOGGER.info("Updating users db security", extra={'MESSAGE_ID': 'update_users_security'}) users_db.security = SECURITY username, password = server.resource.credentials user_doc = users_db.get( 'org.couchdb.user:{}'.format(username), {'_id': 'org.couchdb.user:{}'.format(username)}) if not user_doc.get( 'derived_key', '') or PBKDF2(password, user_doc.get( 'salt', ''), user_doc.get('iterations', 10)).hexread( int(len(user_doc.get('derived_key', '')) / 2)) != user_doc.get('derived_key', ''): user_doc.update({ "name": username, "roles": [], "type": "user", "password": password }) LOGGER.info("Updating api db main user", extra={'MESSAGE_ID': 'update_api_main_user'}) users_db.save(user_doc) security_users = [ username, ] if 'couchdb.reader_username' in settings and 'couchdb.reader_password' in settings: reader_username = settings.get('couchdb.reader_username') reader = users_db.get( 'org.couchdb.user:{}'.format(reader_username), {'_id': 'org.couchdb.user:{}'.format(reader_username)}) if not reader.get('derived_key', '') or PBKDF2( settings.get('couchdb.reader_password'), reader.get('salt', ''), reader.get( 'iterations', 10)).hexread( int(len(reader.get('derived_key', '')) / 2)) != reader.get('derived_key', ''): reader.update({ "name": reader_username, "roles": ['reader'], "type": "user", "password": settings.get('couchdb.reader_password') }) LOGGER.info("Updating api db reader user", extra={'MESSAGE_ID': 'update_api_reader_user'}) users_db.save(reader) security_users.append(reader_username) if db_name not in aserver: aserver.create(db_name) db = aserver[db_name] SECURITY[u'members'][u'names'] = security_users if SECURITY != db.security: LOGGER.info("Updating api db security", extra={'MESSAGE_ID': 'update_api_security'}) db.security = SECURITY auth_doc = db.get(VALIDATE_DOC_ID, {'_id': VALIDATE_DOC_ID}) if auth_doc.get( 'validate_doc_update') != VALIDATE_DOC_UPDATE % username: auth_doc['validate_doc_update'] = VALIDATE_DOC_UPDATE % username LOGGER.info("Updating api db validate doc", extra={'MESSAGE_ID': 'update_api_validate_doc'}) db.save(auth_doc) # sync couchdb views sync_design(db) db = server[db_name] else: if db_name not in server: server.create(db_name) db = server[db_name] # sync couchdb views sync_design(db) config.registry.db = db # migrate data migrate_data(config.registry.db) # S3 connection if 'aws.access_key' in settings and 'aws.secret_key' in settings and 'aws.s3_bucket' in settings: connection = S3Connection(settings['aws.access_key'], settings['aws.secret_key']) config.registry.s3_connection = connection bucket_name = settings['aws.s3_bucket'] if bucket_name not in [b.name for b in connection.get_all_buckets()]: connection.create_bucket(bucket_name, location=Location.EU) config.registry.bucket_name = bucket_name config.registry.server_id = settings.get('id', '') return config.make_wsgi_app()
def main(argv=sys.argv): if len(argv) != 3: usage(argv) config_uri = argv[1] try: num_users = int(argv[2]) except ValueError: usage(argv) setup_logging(config_uri) settings = get_appsettings(config_uri) config = Configurator(settings=settings) config.add_directive('set_password_context', set_password_context) db_session = init_sa(config) logger = logging.getLogger('speak_friend.createusers') if 'speak_friend.password_hasher' in settings: config.include(settings['speak_friend.password_hasher']) else: from passlib.apps import ldap_context config.set_password_context(context=ldap_context) # makes the password_context available on the registry config.commit() pass_ctx = config.registry.password_context user_num = 1 buf = StringIO() cols = [ 'username', 'first_name', 'last_name', 'email', 'password_hash', 'password_salt', 'login_attempts', 'admin_disabled', 'is_superuser' ] csv_file = csv.DictWriter(buf, cols, delimiter='\t', lineterminator='\n') logger.info("Beginning to create %d users,", num_users) cxn = db_session.connection() cur = cxn.connection.cursor() user_num += 0 user_passwords = {} while user_num <= num_users: first_name = u'Test' last_name = pwgen(num_pw=1, pw_length=10, no_numerals=True, no_symbols=True) username = u'%s.%s' % (first_name, last_name) password = pwgen(num_pw=1, pw_length=20) user_passwords[username] = password csv_file.writerow( dict( username=username, first_name=first_name, last_name=last_name, email=u'*****@*****.**' % username, password_hash=pass_ctx.encrypt(password), password_salt='', login_attempts=0, admin_disabled=False, is_superuser=False, )) logger.info("Created user %s, %04d/%04d.", username, user_num, num_users) user_num += 1 logger.info("Committing...") tname = '%s.%s' % (UserProfile.__table__.schema, UserProfile.__table__.name) buf.seek(0) cur.copy_from(buf, tname, columns=cols) cxn.connection.commit() for uname, pw in user_passwords.items(): print uname, pw
def main(global_settings, **settings): # TODO should allow end user to configure logging, of course; this is just # a nice default coloredlogs.install(level=logging.INFO) # TODO this doesn't actually work as a paste entry point, because the ini # values need converting :S datadir = Path(settings['spline.datadir']) # Built-in core settings we have to have. These are part of the app # propert and it makes zero sense for either a deployer or a developer to # ever change them. # TODO is this where this kind of thing should go? seems, y'know, clunky settings.update({ 'pyramid.default_locale_name': u'en', 'mako.directories': ['spline:templates'], 'mako.module_directory': str(datadir / '_mako_cache'), 'mako.strict_undefined': True, # TODO i am not thrilled that only a string works here # TODO: pyramid_scss should learn to do asset specs in imports as well, # but scss needs import hooking for that to work 'scss.asset_path': 'spline:assets/scss\n' 'spline:assets/vendor/archetype/scss', # These are reversed in debug mode # TODO scss should really be built and served directly in production 'scss.compress': True, 'scss.cache': True, }) # Prefill some paths for stuff stored on disk. # TODO this is pretty grody :) # TODO this should be a little more organized and enforce that the # directories exist and are writable by us -- or at least that the datadir # itself is? settings.update({ 'spline.search.whoosh.path': str(datadir / 'whoosh-index'), 'spline.wiki.root': str(datadir / 'wiki'), # TODO this is all going away, i think. lol CHANGEME. what is that # even for? 'session.type': 'file', 'session.data_dir': str(datadir / 'sessions/data'), 'session.lock_dir': str(datadir / 'sessions/lock'), 'session.secret': 'CHANGEME', 'session.cookie_on_exception': True, }) debug = settings.get('spline.debug') if debug: settings.update({ # TODO maybe i want to turn these on... why didn't i? 'pyramid.debug_authorization': True, 'pyramid.debug_notfound': True, 'pyramid.debug_routematch': True, 'pyramid.reload_templates': True, 'scss.compress': False, 'scss.cache': False, }) engine = engine_from_config(settings, 'sqlalchemy.') session.configure(bind=engine) session_factory = pyramid_beaker.session_factory_from_settings(settings) config = Configurator(settings=settings) if debug: # TODO only if importable? config.include('pyramid_debugtoolbar') config.include('pyramid_tm') config.include('pyramid_mako') from spline.feature.filestore import IStorage, FilesystemStorage filestore_dir = (datadir / 'filestore').resolve() config.registry.registerUtility(FilesystemStorage(filestore_dir), IStorage) config.add_static_view('filestore', str(filestore_dir)) # Sessions config.include(pyramid_beaker) config.set_session_factory(session_factory) config.add_tween('spline.web.auth.csrf_tween_factory') # Auth config.set_authentication_policy(DatabaseAuthenticationPolicy()) config.set_authorization_policy(RoleAuthorizationPolicy()) config.add_request_method(authenticated_userid, 'user', reify=True) # Events config.add_subscriber(inject_template_vars, BeforeRender) # Static assets config.add_static_view('static', 'spline:assets', cache_max_age=3600) # Load core stuff first config.include(core_plugin_includeme) # Plugin loading # TODO this could totally be inside the app proper, as long as i know how # to restart myself. mamayo problem? # TODO there are really two steps here, of scanning and then importing. # but i doubt the web app itself wants to scan just to import, right? # TODO now there's both a plugin dict here AND a "registry" in the Plugin # class itself (which is still in spline_comic btw) -- which is correct? # TODO SIGH should i just give up and use setuptools f*****g entry points # TODO or actually maybe i should be taking advantage of zope things here # -- you can have named implementations of an interface after all! config.registry.spline_plugins = {} config.add_directive('register_spline_plugin', config_register_spline_plugin) for plugins in settings.get('spline.plugins', ()): plugin, route_prefix = plugins.split(':', 1) config.include(plugin, route_prefix=route_prefix) # Sass compilation # TODO this has to appear after the includes, or pyramid_scss won't see any # additional paths added. needs a real api for doing that 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') return config.make_wsgi_app()
def main(global_settings, **settings): # TODO should allow end user to configure logging, of course; this is just # a nice default coloredlogs.install(level=logging.INFO) # TODO this doesn't actually work as a paste entry point, because the ini # values need converting :S datadir = Path(settings['spline.datadir']) # Built-in core settings we have to have. These are part of the app # propert and it makes zero sense for either a deployer or a developer to # ever change them. # TODO is this where this kind of thing should go? seems, y'know, clunky settings.update({ 'pyramid.default_locale_name': u'en', 'mako.directories': ['spline:templates'], 'mako.module_directory': str(datadir / '_mako_cache'), 'mako.strict_undefined': True, # TODO i am not thrilled that only a string works here # TODO: pyramid_scss should learn to do asset specs in imports as well, # but scss needs import hooking for that to work 'scss.asset_path': 'spline:assets/scss\n' 'spline:assets/vendor/archetype/scss', # These are reversed in debug mode # TODO scss should really be built and served directly in production 'scss.compress': True, 'scss.cache': True, }) # Prefill some paths for stuff stored on disk. # TODO this is pretty grody :) # TODO this should be a little more organized and enforce that the # directories exist and are writable by us -- or at least that the datadir # itself is? settings.update({ 'spline.search.whoosh.path': str(datadir / 'whoosh-index'), 'spline.wiki.root': str(datadir / 'wiki'), # TODO this is all going away, i think. lol CHANGEME. what is that # even for? 'session.type': 'file', 'session.data_dir': str(datadir / 'sessions/data'), 'session.lock_dir': str(datadir / 'sessions/lock'), 'session.secret': 'CHANGEME', 'session.cookie_on_exception': True, }) debug = settings.get('spline.debug') if debug: settings.update({ # TODO maybe i want to turn these on... why didn't i? 'pyramid.debug_authorization': True, 'pyramid.debug_notfound': True, 'pyramid.debug_routematch': True, 'pyramid.reload_templates': True, 'scss.compress': False, 'scss.cache': False, }) engine = engine_from_config(settings, 'sqlalchemy.') session.configure(bind=engine) session_factory = pyramid_beaker.session_factory_from_settings(settings) config = Configurator(settings=settings) if debug: # TODO only if importable? config.include('pyramid_debugtoolbar') config.include('pyramid_tm') config.include('pyramid_mako') from spline.feature.filestore import IStorage, FilesystemStorage filestore_dir = (datadir / 'filestore').resolve() config.registry.registerUtility(FilesystemStorage(filestore_dir), IStorage) config.add_static_view('filestore', str(filestore_dir)) # Sessions config.include(pyramid_beaker) config.set_session_factory(session_factory) config.add_tween('spline.web.auth.csrf_tween_factory') # Auth config.set_authentication_policy(DatabaseAuthenticationPolicy()) config.set_authorization_policy(RoleAuthorizationPolicy()) config.add_request_method(authenticated_userid, 'user', reify=True) # Events config.add_subscriber(inject_template_vars, BeforeRender) # Static assets config.add_static_view('static', 'spline:assets', cache_max_age=3600) # Load core stuff first config.include(core_plugin_includeme) # Plugin loading # TODO this could totally be inside the app proper, as long as i know how # to restart myself. mamayo problem? # TODO there are really two steps here, of scanning and then importing. # but i doubt the web app itself wants to scan just to import, right? # TODO now there's both a plugin dict here AND a "registry" in the Plugin # class itself (which is still in spline_comic btw) -- which is correct? # TODO SIGH should i just give up and use setuptools f*****g entry points # TODO or actually maybe i should be taking advantage of zope things here # -- you can have named implementations of an interface after all! config.registry.spline_plugins = {} config.add_directive( 'register_spline_plugin', config_register_spline_plugin) for plugins in settings.get('spline.plugins', ()): plugin, route_prefix = plugins.split(':', 1) config.include(plugin, route_prefix=route_prefix) # Sass compilation # TODO this has to appear after the includes, or pyramid_scss won't see any # additional paths added. needs a real api for doing that 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') return config.make_wsgi_app()
def includeme(config: Configurator): config.add_directive('add_dotdo_route', struts_one_like)
def main(global_config, **settings): config = Configurator( autocommit=True, settings=settings, authentication_policy=AuthenticationPolicy(settings['auth.file'], __name__), authorization_policy=AuthorizationPolicy(), route_prefix=route_prefix(settings), ) config.include('pyramid_exclog') config.include("cornice") config.add_forbidden_view(forbidden) config.add_request_method(request_params, 'params', reify=True) config.add_request_method(authenticated_role, reify=True) config.add_request_method(extract_tender, 'tender', reify=True) config.add_request_method(check_accreditation) config.add_renderer('prettyjson', JSON(indent=4)) config.add_renderer('jsonp', JSONP(param_name='opt_jsonp')) config.add_renderer('prettyjsonp', JSONP(indent=4, param_name='opt_jsonp')) config.add_subscriber(add_logging_context, NewRequest) config.add_subscriber(set_logging_context, ContextFound) config.add_subscriber(set_renderer, NewRequest) config.add_subscriber(beforerender, BeforeRender) config.scan("openprocurement.api.views.spore") config.scan("openprocurement.api.views.health") # tender procurementMethodType plugins support config.add_route_predicate('procurementMethodType', isTender) config.registry.tender_procurementMethodTypes = {} config.add_request_method(tender_from_data) config.add_directive('add_tender_procurementMethodType', register_tender_procurementMethodType) # search for plugins plugins = settings.get('plugins') and settings['plugins'].split(',') for entry_point in iter_entry_points('openprocurement.api.plugins'): if not plugins or entry_point.name in plugins: plugin = entry_point.load() plugin(config) # CouchDB connection db_name = os.environ.get('DB_NAME', settings['couchdb.db_name']) server = Server(settings.get('couchdb.url'), session=Session(retry_delays=range(10))) if 'couchdb.admin_url' not in settings and server.resource.credentials: try: server.version() except Unauthorized: server = Server(extract_credentials(settings.get('couchdb.url'))[0]) config.registry.couchdb_server = server if 'couchdb.admin_url' in settings and server.resource.credentials: aserver = Server(settings.get('couchdb.admin_url'), session=Session(retry_delays=range(10))) config.registry.admin_couchdb_server = aserver users_db = aserver['_users'] if SECURITY != users_db.security: LOGGER.info("Updating users db security", extra={'MESSAGE_ID': 'update_users_security'}) users_db.security = SECURITY username, password = server.resource.credentials user_doc = users_db.get('org.couchdb.user:{}'.format(username), {'_id': 'org.couchdb.user:{}'.format(username)}) if not user_doc.get('derived_key', '') or PBKDF2(password, user_doc.get('salt', ''), user_doc.get('iterations', 10)).hexread(int(len(user_doc.get('derived_key', '')) / 2)) != user_doc.get('derived_key', ''): user_doc.update({ "name": username, "roles": [], "type": "user", "password": password }) LOGGER.info("Updating api db main user", extra={'MESSAGE_ID': 'update_api_main_user'}) users_db.save(user_doc) security_users = [username, ] if 'couchdb.reader_username' in settings and 'couchdb.reader_password' in settings: reader_username = settings.get('couchdb.reader_username') reader = users_db.get('org.couchdb.user:{}'.format(reader_username), {'_id': 'org.couchdb.user:{}'.format(reader_username)}) if not reader.get('derived_key', '') or PBKDF2(settings.get('couchdb.reader_password'), reader.get('salt', ''), reader.get('iterations', 10)).hexread(int(len(reader.get('derived_key', '')) / 2)) != reader.get('derived_key', ''): reader.update({ "name": reader_username, "roles": ['reader'], "type": "user", "password": settings.get('couchdb.reader_password') }) LOGGER.info("Updating api db reader user", extra={'MESSAGE_ID': 'update_api_reader_user'}) users_db.save(reader) security_users.append(reader_username) if db_name not in aserver: aserver.create(db_name) db = aserver[db_name] SECURITY[u'members'][u'names'] = security_users if SECURITY != db.security: LOGGER.info("Updating api db security", extra={'MESSAGE_ID': 'update_api_security'}) db.security = SECURITY auth_doc = db.get(VALIDATE_DOC_ID, {'_id': VALIDATE_DOC_ID}) if auth_doc.get('validate_doc_update') != VALIDATE_DOC_UPDATE % username: auth_doc['validate_doc_update'] = VALIDATE_DOC_UPDATE % username LOGGER.info("Updating api db validate doc", extra={'MESSAGE_ID': 'update_api_validate_doc'}) db.save(auth_doc) # sync couchdb views sync_design(db) db = server[db_name] else: if db_name not in server: server.create(db_name) db = server[db_name] # sync couchdb views sync_design(db) config.registry.db = db # migrate data if not os.environ.get('MIGRATION_SKIP'): migrate_data(config.registry.db) # S3 connection if 'aws.access_key' in settings and 'aws.secret_key' in settings and 'aws.s3_bucket' in settings: connection = S3Connection(settings['aws.access_key'], settings['aws.secret_key']) config.registry.s3_connection = connection bucket_name = settings['aws.s3_bucket'] if bucket_name not in [b.name for b in connection.get_all_buckets()]: connection.create_bucket(bucket_name, location=Location.EU) config.registry.bucket_name = bucket_name config.registry.server_id = settings.get('id', '') config.registry.health_threshold = float(settings.get('health_threshold', 99)) config.registry.update_after = asbool(settings.get('update_after', True)) return config.make_wsgi_app()
def includeme(config: Configurator) -> None: config.include("pyramid_services") config.add_directive("register_autowire", register_autowire)
def main(global_config, **settings): config = Configurator(settings=settings, root_factory=RootFactory) # adiciona metodos cross origin resource sharing (CORS) config.add_directive('add_cors_preflight_handler', add_cors_preflight_handler) config.add_route_predicate('cors_preflight', CorsPreflightPredicate) config.add_subscriber(add_cors_to_response, 'pyramid.events.NewResponse') config.add_cors_preflight_handler() # inclui dependencias config.include('pyramid_jinja2') config.include('pyramid_chameleon') config.include('pyramid_sqlalchemy') # escaneia views config.scan() # cria metadados de persistencia metadata.create_all() # adiciona rodas estaticas # config.add_static_view(name='static', path='zapizza.site:static') # todo: levar rotas para dentro de seus módulos # registro config.add_route('signup', '/signup') config.add_route('confirm', '/confirm') # login/logout config.add_route('login', '/login') config.add_route('logout', '/logout') config.add_route('authenticated', '/authenticated') # esqueci a senha config.add_route('pass_forgot', '/forgot') config.add_route('pass_reset', '/reset') # /user config.add_route('users_profile', '/user/{username}/profile', factory='.users.models.user_factory') # /tamanhos config.add_route('tamanhos', '/tamanhos', factory='.pizzas.tamanhos.models.tamanho_factory') config.add_route('tamanhos_edit', '/tamanhos/{hashid}', factory='.pizzas.tamanhos.models.tamanho_factory') config.add_route('tamanhos_enable', '/tamanhos/{hashid}/enable', factory='.pizzas.tamanhos.models.tamanho_factory') # /sabores config.add_route('sabores', '/sabores', factory='.pizzas.sabores.models.sabor_factory') config.add_route('sabores_edit', '/sabores/{hashid}', factory='.pizzas.sabores.models.sabor_factory') config.add_route('sabores_enable', '/sabores/{hashid}/enable', factory='.pizzas.sabores.models.sabor_factory') # /bordas config.add_route('bordas', '/bordas', factory='.pizzas.bordas.models.borda_factory') config.add_route('bordas_edit', '/bordas/{hashid}', factory='.pizzas.bordas.models.borda_factory') config.add_route('bordas_enable', '/bordas/{hashid}/enable', factory='.pizzas.bordas.models.borda_factory') # /adicionais config.add_route('adicionais', '/adicionais', factory='.adicionais.models.adicional_factory') config.add_route('adicionais_edit', '/adicionais/{hashid}', factory='.adicionais.models.adicional_factory') config.add_route('adicionais_enable', '/adicionais/{hashid}/enable', factory='.adicionais.models.adicional_factory') # /clientes config.add_route('clientes', '/clientes', factory='.clientes.models.cliente_factory') config.add_route('clientes_edit', '/clientes/{hashid}', factory='.clientes.models.cliente_factory') config.add_route('clientes_enable', '/clientes/{hashid}/enable', factory='.clientes.models.cliente_factory') # /clientes/enderecos config.add_route('enderecos', '/clientes/{cliHashid}/enderecos', factory='.clientes.enderecos.models.endereco_factory') config.add_route('enderecos_edit', '/clientes/{cliHashid}/enderecos/{endHashid}', factory='.clientes.enderecos.models.endereco_factory') # /clientes/telefones config.add_route('telefones', '/clientes/{cliHashid}/telefones', factory='.clientes.telefones.models.telefone_factory') config.add_route('telefones_edit', '/clientes/{cliHashid}/telefones/{telHashid}', factory='.clientes.telefones.models.telefone_factory') # /pedidos config.add_route('pedidos', '/pedidos', factory='.pedidos.models.pedido_factory') config.add_route('pedidos_edit', '/pedidos/{hashid}', factory='.pedidos.models.pedido_factory') config.add_route('pedidos_enable', '/pedidos/{hashid}/enable', factory='.pedidos.models.pedido_factory') # Factory da sessao session_secret = settings['session.secret'] session_factory = SignedCookieSessionFactory(session_secret) config.set_session_factory(session_factory) # Politicas de segurança authn_policy = AuthTktAuthenticationPolicy(settings['auth.secret'], callback=groupfinder, hashalg='sha512') authz_policy = ACLAuthorizationPolicy() config.set_authentication_policy(authn_policy) config.set_authorization_policy(authz_policy) # Objeto User disponivel como um atributo de Request config.add_request_method(get_user, 'user', reify=True) # cria aplicacao return config.make_wsgi_app()
def main(argv=sys.argv): if len(argv) != 3: usage(argv) config_uri = argv[1] try: num_users = int(argv[2]) except ValueError: usage(argv) setup_logging(config_uri) settings = get_appsettings(config_uri) config = Configurator(settings=settings) config.add_directive('set_password_context', set_password_context) db_session = init_sa(config) logger = logging.getLogger('speak_friend.createusers') if 'speak_friend.password_hasher' in settings: config.include(settings['speak_friend.password_hasher']) else: from passlib.apps import ldap_context config.set_password_context(context=ldap_context) # makes the password_context available on the registry config.commit() pass_ctx = config.registry.password_context user_num = 1 buf = StringIO() cols = ['username', 'first_name', 'last_name', 'email', 'password_hash', 'password_salt', 'login_attempts', 'admin_disabled', 'is_superuser'] csv_file = csv.DictWriter(buf, cols, delimiter='\t', lineterminator='\n') logger.info("Beginning to create %d users,", num_users) cxn = db_session.connection() cur = cxn.connection.cursor() user_num += 0 user_passwords = {} while user_num <= num_users: first_name = u'Test' last_name = pwgen(num_pw=1, pw_length=10, no_numerals=True, no_symbols=True) username = u'%s.%s' % (first_name, last_name) password = pwgen(num_pw=1, pw_length=20) user_passwords[username] = password csv_file.writerow(dict( username=username, first_name=first_name, last_name=last_name, email=u'*****@*****.**' % username, password_hash=pass_ctx.encrypt(password), password_salt='', login_attempts=0, admin_disabled=False, is_superuser=False, )) logger.info("Created user %s, %04d/%04d.", username, user_num, num_users) user_num += 1 logger.info("Committing...") tname = '%s.%s' % (UserProfile.__table__.schema, UserProfile.__table__.name) buf.seek(0) cur.copy_from(buf, tname, columns=cols) cxn.connection.commit() for uname, pw in user_passwords.items(): print uname, pw
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ settings['available_locales'] = settings.get( 'available_locales', '').split() static_prefix = settings.get('static_prefix', 'static') config = Configurator(settings=settings) config.include('pyramid_jinja2') config.add_jinja2_search_path('oscad:templates') config.include('oscad_i18n') config.set_default_i18n_domain('oscad') config.add_directive('set_toplevel_links', set_toplevel_links) config.add_directive('add_toplevel_link', add_toplevel_link) config.add_request_method(scss_path) config.add_request_method(oscad_settings, property=True) config.add_request_method(oslic_chapter_url) config.add_renderer('scss', renderer_factory) config.set_locale_negotiator(locale_negotiator) config.set_session_factory(UnencryptedCookieSessionFactoryConfig('')) config.add_subscriber('oscad.subscribers.add_renderer_globals', 'pyramid.events.BeforeRender') config.add_subscriber('oscad.subscribers.jsonify', 'pyramid.events.NewRequest') config.add_translation_dirs('oscad:locale') config.add_route('scss', static_prefix + '/css/{css_path:.*}.css') config.add_static_view(static_prefix, 'static', cache_max_age=3600) config.add_static_view( settings.get('bootstrap_location', static_prefix + '/bootstrap'), 'bootstrap') config.add_static_view( settings.get('jquery_location', static_prefix + '/jquery'), 'jquery') config.registry.settings.oscad_settings = oscad_default_settings config.add_route('index', '') config.add_route('request', 'request') config.add_route('matrix_request', 'matrix') config.add_route('result', 'result') config.add_route('imprint', 'imprint') config.add_route('about', 'about') config.add_route('help', 'help') config.add_route('components', 'components') config.add_route('change_language', 'language/{lang}') config.add_route('translation_template', 'translations/oscad.pot') config.add_route('translation_file', 'translations/{lang}') if asbool(settings.get('allow_export')): config.add_view('export', 'views:export') config.add_route('export', 'export') load_themes(config, settings) config.scan() config.commit() jenv = config.get_jinja2_environment() jenv.filters['htmlize'] = htmlize jenv.undefined = jinja2.StrictUndefined return config.make_wsgi_app()
config.add_route(route_name, path) config.add_view(view, route_name=route_name) discriminator = ('add_simple_view', path) config.action(discriminator, callback, order=PHASE1_CONFIG) class simple_view(object): def __init__(self, path): self.path = path def register(self, scanner, name, wrapped): scanner.config.add_simple_view(wrapped, self.path) def __call__(self, wrapped): venusian.attach(wrapped, self.register) return wrapped @simple_view("/hello/{name}") def hello_world(request): return Response('Hello %(name)s!' % request.matchdict) if __name__ == '__main__': config = Configurator() config.add_directive("add_simple_view", add_simple_view) config.scan(__name__) app = config.make_wsgi_app() server = make_server('0.0.0.0', 8080, app) server.serve_forever()
def get_default_config(global_config, base_config=None, **settings): """Provide a default configuration for a Petrel-based application. """ if base_config is not None: config = base_config else: zodb_uri = settings.get('zodb_uri', None) or \ global_config.get('zodb_uri', None) if not zodb_uri: raise ValueError("No 'zodb_uri' in application configuration.") finder = PersistentApplicationFinder(zodb_uri, app_maker) def get_root(request): return finder(request.environ) session_factory = session_factory_from_settings(settings) config = Configurator(root_factory=get_root, session_factory=session_factory, settings=settings) config.add_directive('register_template_api', _register_template_api) config.add_directive('register_content_type', _register_content_type) config.add_directive('customize_content_type', _customize_content_type) ## Register default content types from petrel.content.document import Document from petrel.content.file import File from petrel.content.file import file_download from petrel.content.folder import Folder from petrel.content.folder import folder_contents from petrel.content.folder import folder_delete from petrel.content.folder import folder_rename from petrel.content.folder import folder_rename_form from petrel.content.image import Image from petrel.content.site import Site from petrel.views.admin import toolbar ## FIXME: look at the new cache_max_age argument config.add_static_view(name='static-petrel', path='petrel:static') config.register_content_type(Site, addable=False) config.register_content_type(Document) config.register_content_type( File, display_view=file_download) config.register_content_type( Image, display_view=file_download) config.register_content_type(Folder) config.add_view(name='contents', context=IFolderish, view=folder_contents, renderer='templates/folder_contents.pt') config.add_view(name='folder_action_handler', context='petrel.interfaces.IFolderish', request_param="action=delete", view=folder_delete) config.add_view(name='folder_action_handler', context='petrel.interfaces.IFolderish', request_param='action=rename', view=folder_rename_form, renderer='templates/folder_rename.pt') config.add_view(name='rename', context='petrel.interfaces.IFolderish', view=folder_rename) config.add_view(name='_toolbar.html', renderer='petrel:templates/toolbar.pt', view=toolbar) ## Register default subscribers from repoze.folder.interfaces import IObjectAddedEvent from repoze.folder.interfaces import IObjectWillBeRemovedEvent from petrel.search import index from petrel.search import reindex from petrel.search import unindex from petrel.interfaces import IObjectModifiedEvent config.add_subscriber(index, IObjectAddedEvent) config.add_subscriber(reindex, IObjectModifiedEvent) config.add_subscriber(unindex, IObjectWillBeRemovedEvent) ## Enable authorization system and related views from petrel.auth import setup_who_api_factory from petrel.views.auth import login from petrel.views.auth import login_form from petrel.views.auth import logout setup_who_api_factory(global_config, settings['auth_config_file']) config.add_view(name='login', renderer='petrel:templates/login.pt', view=login_form) config.add_view(name='login', request_method='POST', renderer='petrel:templates/login.pt', view=login) config.add_view(name='logout', view=logout) return config
def get_configurator(pkg, *utilities, **kw): """ .. seealso:: https://groups.google.com/d/msg/pylons-discuss/Od6qIGaLV6A/3mXVBQ13zWQJ """ kw.setdefault('package', pkg) routes = kw.pop('routes', []) config = Configurator(**kw) for name, pattern in routes: config.add_route(name, pattern) config.set_request_factory(ClldRequest) config.registry.registerUtility(CtxFactoryQuery(), interfaces.ICtxFactoryQuery) config.registry.registerUtility(OlacConfig(), interfaces.IOlacConfig) # initialize the db connection engine = engine_from_config(config.registry.settings, 'sqlalchemy.') DBSession.configure(bind=engine) Base.metadata.bind = engine config.add_settings({'pyramid.default_locale_name': 'en'}) if 'clld.files' in config.registry.settings: # deployment-specific location of static data files abspath = path(config.registry.settings['clld.files']).abspath() config.add_settings({'clld.files': abspath}) config.add_static_view('files', abspath) # event subscribers: config.add_subscriber(add_localizer, events.NewRequest) config.add_subscriber(init_map, events.ContextFound) config.add_subscriber( partial(add_renderer_globals, maybe_import('%s.util' % config.package_name)), events.BeforeRender) # # make it easy to register custom functionality # for name, func in { 'register_datatable': partial(register_cls, interfaces.IDataTable), 'register_map': partial(register_cls, interfaces.IMap), 'register_menu': register_menu, 'register_resource': register_resource, 'register_adapter': register_adapter, 'register_download': register_download, 'add_route_and_view': add_route_and_view, 'add_settings_from_file': add_settings_from_file, }.items(): config.add_directive(name, func) # # routes and views # config.add_static_view('clld-static', 'clld:web/static') config.add_static_view('static', '%s:static' % config.package_name) config.add_route_and_view('legal', '/legal', lambda r: {}, renderer='legal.mako') config.add_route_and_view('download', '/download', lambda r: {}, renderer='download.mako') config.add_route_and_view('contact', '/contact', lambda r: {}, renderer='contact.mako') config.add_route_and_view('_js', '/_js', js, http_cache=3600) # add some maintenance hatches config.add_route_and_view('_raise', '/_raise', _raise) config.add_route_and_view('_ping', '/_ping', _ping, renderer='json') # sitemap support: config.add_route_and_view('robots', '/robots.txt', robots) config.add_route_and_view('sitemapindex', '/sitemap.xml', sitemapindex) config.add_route_and_view('sitemap', '/sitemap.{rsc}.{n}.xml', sitemap) config.add_route('google-site-verification', 'googlebbc8f4da1abdc58b.html') config.add_view( lambda r: Response('google-site-verification: googlebbc8f4da1abdc58b.html'), route_name='google-site-verification') config.add_route_and_view('unapi', '/unapi', unapi) config.add_route_and_view('olac', '/olac', olac) for rsc in RESOURCES: name, model = rsc.name, rsc.model factory = partial(ctx_factory, model, 'index') config.add_route_and_view(rsc.plural, '/%s' % rsc.plural, index_view, factory=factory) config.register_datatable( rsc.plural, getattr(datatables, rsc.plural.capitalize(), DataTable)) config.register_adapter( getattr(excel, rsc.plural.capitalize(), excel.ExcelAdapter), rsc.interface) kw = dict(factory=partial(ctx_factory, model, 'rsc')) if model == common.Dataset: pattern = '/' kw['alt_route_pattern'] = '/void.{ext}' else: pattern = '/%s/{id:[^/\.]+}' % rsc.plural config.add_route_and_view(name, pattern, resource_view, **kw) # maps config.register_map('languages', Map) config.register_map('language', LanguageMap) config.register_map('parameter', ParameterMap) config.include('clld.web.adapters') for icon in ICONS: config.registry.registerUtility(icon, interfaces.IIcon, name=icon.name) config.registry.registerUtility(MapMarker(), interfaces.IMapMarker) # # now we exploit the default package layout as created via the CLLD scaffold: # # note: the following exploits the import time side effect of modifying the webassets # environment! maybe_import('%s.assets' % config.package_name) pkg_dir = path(config.package.__file__).dirname().abspath() if 'clld.favicon' not in config.registry.settings: favicon = {'clld.favicon': 'clld:web/static/images/favicon.ico'} # hard to test (in particular on travis) and without too much consequence # (and the consequences faced are easy to spot). if pkg_dir.joinpath('static', 'favicon.ico').exists(): # pragma: no cover favicon['clld.favicon'] = config.package_name + ':static/favicon.ico' config.add_settings(favicon) with open(abspath_from_asset_spec(config.registry.settings['clld.favicon'])) as fp: fh = md5() fh.update(fp.read()) config.add_settings({'clld.favicon_hash': fh.hexdigest()}) if pkg_dir.joinpath('locale').exists(): config.add_translation_dirs('%s:locale' % config.package_name) config.add_translation_dirs('clld:locale') config.add_settings_from_file(pkg_dir.joinpath('appconf.ini')) v = maybe_import('%s.views' % config.package_name) if v: config.scan(v) # pragma: no cover menuitems = OrderedDict(dataset=partial(menu_item, 'dataset', label='home')) for plural in config.registry.settings.get( 'clld.menuitems_list', ['contributions', 'parameters', 'languages', 'contributors'] ): menuitems[plural] = partial(menu_item, plural) config.registry.registerUtility(menuitems, interfaces.IMenuItems) for utility, interface in utilities: config.registry.registerUtility(utility, interface) return config
def _makeOne(self, autocommit=True): from pyramid.config import Configurator from pyramid_handlers import add_handler config = Configurator(autocommit=autocommit) config.add_directive('add_handler', add_handler) return config
config.add_view(view, route_name=route_name) discriminator = ('add_simple_view', path) config.action(discriminator, callback, order=PHASE1_CONFIG) class simple_view(object): def __init__(self, path): self.path = path def register(self, scanner, name, wrapped): scanner.config.add_simple_view(wrapped, self.path) def __call__(self, wrapped): venusian.attach(wrapped, self.register) return wrapped @simple_view("/hello/{name}") def hello_world(request): return Response('Hello %(name)s!' % request.matchdict) if __name__ == '__main__': config = Configurator() config.add_directive("add_simple_view", add_simple_view) config.scan(__name__) app = config.make_wsgi_app() server = make_server('0.0.0.0', 8080, app) server.serve_forever()
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 = SessionAuthenticationPolicy(callback=groupfinder) authz_policy = ACLAuthorizationPolicy() config = Configurator(settings=settings, root_factory=RootFactory, authentication_policy=authn_policy, authorization_policy=authz_policy, session_factory=session_factory) config.include('pyramid_jinja2') add_jinja2_extension(config, ext.do) add_jinja2_extension(config, ext.loopcontrols) add_jinja2_extension(config, SelectiveHTMLCompress) add_jinja2_search_path(config, 'alchemist:templates') add_jinja2_search_path(config, 'alchemist:templates/layout') add_jinja2_search_path(config, 'alchemist:templates/helpers') add_jinja2_search_path(config, 'alchemist:templates/auth') add_jinja2_search_path(config, 'alchemist:templates/company') add_jinja2_search_path(config, 'alchemist:templates/blocks') add_jinja2_search_path(config, 'alchemist:templates/helpers') config.include('pyramid_dogpile_cache') cache = get_region('main') config.include('pyramid_mailer') def add_path(config, view, path, **kwargs): route_name = '%s_%s' % (qualname(view), path.replace('/', '_').split('{')[0]) config.add_route(route_name, path) config.add_view(view, route_name=route_name, **kwargs) config.add_directive('add_path', add_path) def get_user(request): id = authenticated_userid(request) if not id: return None return User.bid(id) config.add_request_method(get_user, 'user', reify=True) config.add_static_view('static', 'static', cache_max_age=3600) config.add_static_view('export-dumps', 'export-dumps', cache_max_age=3600) config.add_static_view('img', 'static/img', cache_max_age=3600) config.add_static_view('css', 'static/css', cache_max_age=3600) config.add_static_view('js', 'static/js', cache_max_age=3600) config.add_static_view('fonts', 'static/fonts', cache_max_age=3600) config.add_static_view('upload', 'upload', cache_max_age=3600) from alchemist import routes_admin from alchemist import routes_other from alchemist import routes_auth from alchemist import routes_user config.include(routes_admin.includeme) config.include(routes_other.includeme) config.include(routes_auth.includeme) config.include(routes_user.includeme) config.scan('alchemist.views.system') return config.make_wsgi_app()
def get_configurator(pkg, *utilities, **kw): """ .. seealso:: https://groups.google.com/d/msg/pylons-discuss/Od6qIGaLV6A/3mXVBQ13zWQJ """ kw.setdefault('package', pkg) routes = kw.pop('routes', []) config = Configurator(**kw) json_renderer = JSON() json_renderer.add_adapter(datetime.datetime, lambda obj, req: obj.isoformat()) json_renderer.add_adapter(datetime.date, lambda obj, req: obj.isoformat()) config.add_renderer('json', json_renderer) jsonp_renderer = JSONP(param_name='callback') jsonp_renderer.add_adapter(datetime.datetime, lambda obj, req: obj.isoformat()) jsonp_renderer.add_adapter(datetime.date, lambda obj, req: obj.isoformat()) config.add_renderer('jsonp', jsonp_renderer) for name, pattern in routes: config.add_route(name, pattern) config.set_request_factory(ClldRequest) config.registry.registerUtility(CtxFactoryQuery(), interfaces.ICtxFactoryQuery) config.registry.registerUtility(OlacConfig(), interfaces.IOlacConfig) # initialize the db connection engine = engine_from_config(config.registry.settings, 'sqlalchemy.') DBSession.configure(bind=engine) Base.metadata.bind = engine config.add_settings({ 'pyramid.default_locale_name': 'en', 'clld.pkg': config.package_name, 'clld.parameters': {} }) if 'clld.files' in config.registry.settings: # deployment-specific location of static data files abspath = path(config.registry.settings['clld.files']).abspath() config.add_settings({'clld.files': abspath}) config.add_static_view('files', abspath) # event subscribers: config.add_subscriber(add_localizer, events.NewRequest) config.add_subscriber(init_map, events.ContextFound) config.add_subscriber( partial(add_renderer_globals, maybe_import('%s.util' % config.package_name)), events.BeforeRender) # # make it easy to register custom functionality # for name, func in { 'register_datatable': partial(register_cls, interfaces.IDataTable), 'register_map': partial(register_cls, interfaces.IMap), 'register_menu': register_menu, 'register_resource': register_resource, 'register_adapter': register_adapter, 'register_download': register_download, 'add_route_and_view': add_route_and_view, 'add_settings_from_file': add_settings_from_file, 'add_301': add_301, 'add_410': add_410, }.items(): config.add_directive(name, func) # # routes and views # config.add_static_view('clld-static', 'clld:web/static') config.add_static_view('static', '%s:static' % config.package_name) config.add_route_and_view('_js', '/_js', js, http_cache=3600) # add some maintenance hatches config.add_route_and_view('_raise', '/_raise', _raise) config.add_route_and_view('_ping', '/_ping', _ping, renderer='json') # sitemap support: config.add_route_and_view('robots', '/robots.txt', robots) config.add_route_and_view('sitemapindex', '/sitemap.xml', sitemapindex) config.add_route_and_view('sitemap', '/sitemap.{rsc}.{n}.xml', sitemap) config.add_route('resourcemap', '/resourcemap.json') config.add_view(resourcemap, route_name='resourcemap', renderer='jsonp') config.add_route_and_view('select_combination', '/_select_combination', select_combination) # TODO: remove google site verification for personal account! should be configurable! config.add_route('google-site-verification', 'googlebbc8f4da1abdc58b.html') config.add_view(lambda r: Response( 'google-site-verification: googlebbc8f4da1abdc58b.html'), route_name='google-site-verification') config.add_route_and_view('unapi', '/unapi', unapi) config.add_route_and_view('olac', '/olac', olac) for rsc in RESOURCES: name, model = rsc.name, rsc.model factory = partial(ctx_factory, model, 'index') config.add_route_and_view(rsc.plural, '/%s' % rsc.plural, index_view, factory=factory) config.register_datatable( rsc.plural, getattr(datatables, rsc.plural.capitalize(), DataTable)) config.register_adapter( getattr(excel, rsc.plural.capitalize(), excel.ExcelAdapter), rsc.interface) _kw = dict(factory=partial(ctx_factory, model, 'rsc')) if model == common.Dataset: pattern = '/' _kw['alt_route_pattern'] = '/void.{ext}' else: pattern = '/%s/{id:[^/\.]+}' % rsc.plural config.add_route_and_view(name, pattern, resource_view, **_kw) # maps config.register_map('languages', Map) config.register_map('language', LanguageMap) config.register_map('parameter', ParameterMap) config.register_map('combination', CombinationMap) config.include('clld.web.adapters') for icon in ICONS: config.registry.registerUtility(icon, interfaces.IIcon, name=icon.name) config.registry.registerUtility(MapMarker(), interfaces.IMapMarker) # # now we exploit the default package layout as created via the CLLD scaffold: # # note: the following exploits the import time side effect of modifying the webassets # environment! maybe_import('%s.assets' % config.package_name) pkg_dir = path(config.package.__file__).dirname().abspath() # # inspect default locations for views and templates: # home_comp = OrderedDict() for name, template in [ ('introduction', False), ('about', False), ('terms', False), ('glossary', False), ('history', False), ('changes', False), ('credits', False), ('legal', True), ('download', True), ('contact', True), ('help', False), ]: home_comp[name] = template if pkg_dir.joinpath('templates').exists(): for p in pkg_dir.joinpath('templates').files(): if p.namebase in home_comp and p.ext == '.mako': home_comp[p.namebase] = True views = maybe_import('%s.views' % config.package_name) for name, template in home_comp.items(): if template: config.add_route_and_view(name, '/' + name, getattr(views, name, lambda r: {}), renderer=name + '.mako') config.add_settings( {'home_comp': [k for k in home_comp.keys() if home_comp[k]]}) if 'clld.favicon' not in config.registry.settings: favicon = {'clld.favicon': 'clld:web/static/images/favicon.ico'} # hard to test (in particular on travis) and without too much consequence # (and the consequences faced are easy to spot). if pkg_dir.joinpath('static', 'favicon.ico').exists(): # pragma: no cover favicon[ 'clld.favicon'] = config.package_name + ':static/favicon.ico' config.add_settings(favicon) with open(abspath_from_asset_spec( config.registry.settings['clld.favicon'])) as fp: fh = md5() fh.update(fp.read()) config.add_settings({'clld.favicon_hash': fh.hexdigest()}) if pkg_dir.joinpath('locale').exists(): config.add_translation_dirs('clld:locale', '%s:locale' % config.package_name) if pkg_dir.joinpath( 'static/publisher_logo.png').exists(): # pragma: no cover config.add_settings({ 'clld.publisher_logo': '%s:static/publisher_logo.png' % config.package_name }) config.add_settings_from_file(pkg_dir.joinpath('appconf.ini')) v = maybe_import('%s.views' % config.package_name) if v: config.scan(v) # pragma: no cover menuitems = OrderedDict( dataset=partial(menu_item, 'dataset', label='Home')) for plural in config.registry.settings.get( 'clld.menuitems_list', ['contributions', 'parameters', 'languages', 'contributors']): menuitems[plural] = partial(menu_item, plural) config.registry.registerUtility(menuitems, interfaces.IMenuItems) config.include('pyramid_mako') for utility, interface in utilities: config.registry.registerUtility(utility, interface) return config