python类Configurator()的实例源码

def configuration(request):
    """Set up a Configurator instance.

    This Configurator instance sets up a pointer to the location of the
        database.
    It also includes the models from your app's model package.
    Finally it tears everything down, including the Postgres database.

    This configuration will persist for the entire duration of your PyTest run.
    """
    settings = {
        'sqlalchemy.url': TEST_DB}
    config = testing.setUp(settings=settings)
    config.include('pylistener.models')
    config.include('pylistener.routes')

    def teardown():
        testing.tearDown()

    request.addfinalizer(teardown)
    return config

def create_app(_crypto=None, _kinesis=None, _raven=None, _stats=None):
    configure_logging()
    raven = create_raven(transport='gevent', _raven=_raven)

    try:
        config = Configurator(settings={})
        config.add_tween('miracle.log.log_tween_factory', under=EXCVIEW)

        configure_api_views(config)
        configure_web_views(config)

        config.registry.crypto = create_crypto(_crypto=_crypto)
        config.registry.kinesis = create_kinesis(_kinesis=_kinesis)
        config.registry.raven = raven
        config.registry.stats = create_stats(_stats=_stats)

        wsgi_app = config.make_wsgi_app()
    except Exception:  # pragma: no cover
        raven.captureException()
        raise

    return wsgi_app

def test_tween_overriden():
    """ In case our tween is overriden by the user config we should not log
    rendering """
    from ...test_tracer import get_dummy_tracer
    from ...util import override_global_tracer
    tracer = get_dummy_tracer()
    with override_global_tracer(tracer):
        config = Configurator(settings={'pyramid.tweens': 'pyramid.tweens.excview_tween_factory'})
        trace_pyramid(config)

        def json(request):
            return {'a': 1}
        config.add_route('json', '/json')
        config.add_view(json, route_name='json', renderer='json')
        app = webtest.TestApp(config.make_wsgi_app())
        app.get('/json', status=200)
        spans = tracer.writer.pop()
        assert not spans

def main(global_config, **settings):

    print
    for name in ENV_SETTINGS:
        settings[name] = get_config_environ(name) or settings.get(name)

    for name in REQUIRED_SETTINGS:
        if settings.get(name) is None:
            error = 'confiration entry for {} is missing'.format(name)
            logger.critical(error)
            raise ConfigurationError(error)

    config = Configurator(settings=settings)
    config.include("cornice")
    config.scan("edwiges.views")

    host = settings['edwiges.provider_host']
    port = settings['edwiges.provider_port']

    logger.info("Starting server", extra={'host': host, 'port': port})
    return config.make_wsgi_app()

def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.bind = engine
    config = Configurator(settings=settings)
    config.add_renderer('json', custom_json_renderer())
    config.add_renderer('json2', custom_json_renderer2())

    config.include('pyramid_jinja2')
    config.include('.models')
    config.include('.routes')

    config.scan()
    return config.make_wsgi_app()

def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.bind = engine
    config = Configurator(settings=settings)
    config.add_renderer('json', custom_json_renderer())
    config.add_renderer('json2', custom_json_renderer2())

    config.include('pyramid_jinja2')
    config.include('.models')
    config.include('.routes')

    config.scan()
    return config.make_wsgi_app()

def add_template_only_view(config: Configurator, pattern: str, name: str, template: str, view_args: t.Optional[dict]=None, route_args: t.Optional[dict]=None):
    """Adds a view which do not have a specific view function assgined.

    The view will render a template with the default template context.

    :param pattern: A path where the view is, e.g. ``/features``
    :param name: View name for ``route_url()``
    :param tempalte: A template to render
    :param view_args: kwargs passed to :py:meth:`pyramid.config.Configurator.add_view`
    :param route_args: kwargs passed to :py:meth:`pyramid.config.Configurator.add_view`
    """
    def _default_view(request):
        return {}

    config.add_route(name, pattern)
    config.add_view(view=_default_view, route_name=name, renderer=template)

def add_static_view(self, name: str, path: str):
        """Include a path in static assets and configures cache busting for it.

        This does not only include the static resources in the routing, but sets the default cache busting policy for them in the :term:`production` environment.

        See :py:meth:`pyramid.config.Configurator.add_static_view` and :py:meth:`websauna.system.Initializer.add_cache_buster`
        """

        # Default value is 0
        cache_max_age = self.settings.get("websauna.cache_max_age_seconds")
        if cache_max_age:
            cache_max_age = int(cache_max_age)

        self.config.add_static_view(name, path, cache_max_age=cache_max_age)

        # If we have caching... we need cachebusters!
        if cache_max_age:
            self.config.add_cache_buster(path, CollectedStaticCacheBuster(name, path, self.settings))

        self.views[name] = path

def setup_wsgi():
    configurator = Configurator()

    configurator.include("pyramid_jinja2")
    configurator.add_jinja2_renderer('.html')
    configurator.add_jinja2_search_path('websauna.tests:templates/viewconfig', name='.html')

    configurator.add_route("parent_hello", "/parent_hello")
    configurator.add_route("child_hello", "/child_hello")

    from websauna.tests.viewconfig import testmodule
    configurator.set_root_factory(testmodule.Root)
    configurator.scan(testmodule)

    wsgi = TestApp(configurator.make_wsgi_app())
    return wsgi

def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    config = Configurator(settings=settings)
    config.include('pyramid_jinja2')
    config.include('.models')
    config.include('.routes')
    config.scan()

    config.commit()

    config.add_request_method(
        lambda x: config.get_jinja2_environment(),
        'jinja2_env',
        reify=True
    )

    return config.make_wsgi_app()

def main(global_config, **settings):
    """Return a Pyramid WSGI application."""
    if not settings.get('sqlalchemy.url'):
        try:
            settings['sqlalchemy.url'] = os.environ['MARS_DATABASE_URL']
        except KeyError:
            print('Required MARS_DATABASE_URL not set in global os environ.')
            sys.exit()
        try:
            settings['nasa_api_key'] = os.environ['NASA_API_KEY']
        except KeyError:
            print('Required NASA_API_KEY not set in global os environment.')
            sys.exit()

    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.bind = engine
    config = Configurator(settings=settings)
    config.include('pyramid_jinja2')
    config.add_static_view('static', 'static', cache_max_age=3600)
    config.add_route('home', '/')
    config.add_route('rover', '/{rover_name}/{sol}')
    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.')
    mymodels.DBSession.configure(bind=engine)
    mymodels.Base.metadata.bind = engine
    config = Configurator(settings=settings)
    config.include('pyramid_chameleon')
    config.include('pyramid_jinja2')
    config.set_session_factory(session_factory)
    config.include('pyramid_beaker')
    config.add_static_view('static', 'static', cache_max_age=3600)
    config.add_route('home', '/')
    config.add_route('nearest', '/nearest')
    pyramid_jsonapi.create_jsonapi_using_magic_and_pixie_dust(
        config, mymodels, lambda view: mymodels.DBSession)

    config.scan()

    return config.make_wsgi_app()

def main(global_config, **settings):
    config = Configurator(settings=settings)
    config.add_subscriber(add_cors_headers_response_callback, NewRequest)

    config.add_settings({'MODELERLOCATION': settings['modelerlocation'] })

    config.add_route('questionanalysis', '/questionanalysis/{question}')
    config.add_route('topicmatching', '/topicmatching/{domain}')
    config.add_route('datasetranking', '/datasetranking/{domain}/{analytic_type}/{interpretation}')
    config.add_route('vizranking', '/vizranking')
# Knowledgemodel and domain models
    # config.add_route('getcorpus', '/getcorpus/{corpus}')
    # config.add_route('gettaxonomyfordomain', '/gettaxonomyfordomain/{domain}')
    # config.add_route('gettfidffordomainX', '/gettfidffordomain/{domain}/{corpus}')

    config.scan('.views')
    return config.make_wsgi_app()

def main(global_config, **settings):
    """This function returns a Pyramid WSGI application."""

    settings['SOFTWARE_VERSION'] = __VERSION__

    config = Configurator(settings=settings)

    # Addons
    config.include('pyramid_jinja2')
    # http://docs.pylonsproject.org/projects/pyramid-jinja2/en/latest/#adding-or-overriding-a-renderer
    config.add_jinja2_renderer('.html')
    config.include('cornice')

    # Views and routes
    config.add_static_view('static/app', 'static/app', cache_max_age=0)
    config.add_static_view('static/lib', 'static/lib', cache_max_age=60 * 24)
    config.add_route('index', '/')

    config.scan()

    return config.make_wsgi_app()

def configuration(request):
    """Set up a Configurator instance.

    This Configurator instance sets up a pointer to the location of the
    database. It also includes the models from the octojobs model package.
    Finally it tears everything down, including the in-memory database.

    This configuration will persist for the entire duration of your PyTest run.
    """
    settings = {
        'sqlalchemy.url': 'postgres:///test_jobs'}
    config = testing.setUp(settings=settings)
    config.include('octojobs.models')
    config.include('octojobs.routes')

    def teardown():
        testing.tearDown()

    request.addfinalizer(teardown)
    return config

def get_app(overrides=None):
    settings = {
        'odata_metadata': db.get_odata_metadata(),
        'django_metadata': db.get_django_metadata(),
        'cdms_client': api.CDMSRestApi()
    }
    if overrides is not None:
        settings.update(overrides)

    app_cfg = Configurator(root_factory=auth.Root, settings=settings)
    app_cfg.set_authentication_policy(auth.AuthenticationPolicy())
    app_cfg.set_authorization_policy(ACLAuthorizationPolicy())
    app_cfg.set_default_permission('access')
    app_cfg.add_route('create', '/create/{django_tablename}/')
    app_cfg.add_route('update', '/update/{django_tablename}/')
    app_cfg.add_route('get', '/get/{django_tablename}/{ident}/')
    app_cfg.scan('korben.bau.views')
    return app_cfg.make_wsgi_app()

def configuration(request):
    """Set up a Configurator instance.

    This Configurator instance sets up a pointer to the location of the
        database.
    It also includes the models from your app's model package.
    Finally it tears everything down, including the in-memory SQLite database.

    This configuration will persist for the entire duration of your PyTest run.
    """
    config = testing.setUp(settings={
        'sqlalchemy.url': 'postgres://localhost:5432/test_expenses'
    })
    config.include("expense_tracker.models")
    config.include("expense_tracker.routes")

    def teardown():
        testing.tearDown()

    request.addfinalizer(teardown)
    return config

def main(global_config, **settings):
    """ Return a Pyramid WSGI application. """
    settings['config_uri'] = global_config['__file__']

    config = Configurator(registry=getGlobalSiteManager())
    config.setup_registry(settings=settings)
    config.add_translation_dirs('assembl:locale/')
    def my_locale_negotiator(request):
        locale = default_locale_negotiator(request)
        available = settings['available_languages'].split()
        locale = locale if locale in available else None
        if not locale:
            locale = request.accept_language.best_match(
                available, settings.get('pyramid.default_locale_name', 'en'))
        request._LOCALE_ = locale
        return locale

    config.set_locale_negotiator(my_locale_negotiator)

    config.add_static_view('static', 'static', cache_max_age=3600)
    config.add_static_view('widget', 'widget', cache_max_age=3600)

    config.add_view(maintenance_message)
    config.add_notfound_view(maintenance_message)
    return config.make_wsgi_app()

def test_declarative_config(dummy_request):
    from snovault.interfaces import AUDITOR
    from pyramid.config import Configurator
    config = Configurator()
    config.include('snovault.config')
    config.include('snovault.auditor')
    config.include('.testing_auditor')
    config.commit()

    auditor = config.registry[AUDITOR]
    value = {'condition1': True}
    dummy_request._embed['/foo/@@embedded'] = value
    error, = auditor.audit(request=dummy_request, path='/foo/', types='TestingLinkSource')
    assert error['detail'] == 'Missing checker1'
    assert error['category'] == 'testchecker'
    assert error['level'] == 0
    assert error['path'] == '/foo/'

def main(global_config, **settings):
    config = Configurator(settings=settings)
    config.add_renderer('jsonp', JSONP(param_name='callback', indent=None, separators=(',', ':')))
    config.add_route('mapprint', '/print')

    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)
    config = Configurator(
        root_factory=root_factory,
        session_factory=session_factory,
        settings=settings,
    )
    config.add_static_view('static', 'static', cache_max_age=3600)
    config.include('ticketing.setup')
    config.include('ticketing.mainviews')
    config.include('ticketing.raven')
    config.include('ticketing.profile')
    config.include('ticketing.boxoffice')
    config.include('ticketing.queue')
    config.include('ticketing.manage', route_prefix="/admin")
    config.include('ticketing.checkin')
    config.add_renderer('api_renderer', 'ticketing.api.api_renderer.APIRenderer')
    config.include('ticketing.api')
    config.add_route("admin_catch","/admin")

    # Add authentication policies
    authentication_policy = AuthTktAuthenticationPolicy('ticketing', callback=checkGroups, hashalg='sha512')
    authorization_policy = ACLAuthorizationPolicy()
    config.set_authentication_policy(authentication_policy)
    config.set_authorization_policy(authorization_policy)
    config.set_default_permission("public")

    # Scan for views
    config.scan()

    return config.make_wsgi_app()

def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    secret = settings['corpus.secret']
    session_factory = SignedCookieSessionFactory(secret)

    config = Configurator(settings=settings)
    config.set_session_factory(session_factory)

    config.include('pyramid_chameleon')

    config.add_static_view('static', 'static', cache_max_age=3600)

    config.add_route('home', '/')
    config.add_route('upload_csv', '/upload')
    config.add_route('corpus_view', '/view/{doc}/{corpus}/{page}')
    config.add_route('corpus_topics', '/topics/{doc}/{corpus}')
    config.add_route('delete_corpus', '/delete/{doc}/{corpus}')
    config.add_route('process_csv', '/process/{doc}/')
    config.add_route('corpus_classify', '/classify/{doc}/{corpus}')
    config.add_route('view_job', '/job-view/{doc}/{corpus}/job/{job}')
    config.add_route('demo', '/demo')

    config.add_request_method(corpus_cache, reify=True)

    config.include('eea.corpus.processing')

    config.scan()

    return config.make_wsgi_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.scan()
    return config.make_wsgi_app()

def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.bind = engine
    config = Configurator(settings=settings)
    config.include('pyramid_chameleon')
    config.add_static_view('static', 'static', cache_max_age=3600)
    config.add_route('home', '/')
    config.scan()
    return config.make_wsgi_app()

def main(global_config, **settings):
    if not global_config.get("testing"):  # pragma: no cover
        DefaultStorage.init_db()

    config = Configurator(settings=settings)
    config.include("cornice")
    config.scan("ensign.api.resources")
    return config.make_wsgi_app()

def add_site_facebook_login(site, app):
    registry = get_current_registry()
    config = Configurator(registry=registry, autocommit=True)
    name = app.application_site_id
    add_facebook_login(
        config,
        consumer_key=getattr(app, 'consumer_key', ''),
        consumer_secret=getattr(app, 'consumer_secret', ''),
        scope=getattr(app, 'scop', ''),
        login_path='/login/'+name,
        callback_path='/login/'+name+'/callback',
        name=name)

def add_site_twitter_login(site, app):
    registry = get_current_registry()
    config = Configurator(registry=registry, autocommit=True)
    name = app.application_site_id
    add_twitter_login(
        config,
        consumer_key=getattr(app, 'consumer_key', ''),
        consumer_secret=getattr(app, 'consumer_secret', ''),
        login_path='/login/'+name,
        callback_path='/login/'+name+'/callback',
        name=name)

def add_site_google_login(site, app):
    registry = get_current_registry()
    config = Configurator(registry=registry, autocommit=True)
    name = app.application_site_id
    add_google_login(
        config,
        consumer_key=getattr(app, 'consumer_key', ''),
        consumer_secret=getattr(app, 'consumer_secret', ''),
        scope=getattr(app, 'scope', ''),
        login_path='/login/'+name,
        callback_path='/login/'+name+'/callback',
        name=name)

def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    config = Configurator(settings=settings)
    config.include('pyramid_chameleon')
    config.add_static_view('static', 'static', cache_max_age=3600)
    config.add_route('home', '/')
    config.scan()
    return config.make_wsgi_app()

def configure(self, settings):
        """ This initial settings of pyramid Configurator
        :param settings: :dict settings of Configurator
        :return: pyramid.config.Configurator
        """
        if settings.get('environ') is None:
            environ = os.environ
        if settings is None:
            settings = {}

        if settings.get('env') is not None:
            for s in settings.get('env'):
                try:
                    result = s(environ)
                except SettingError as e:
                    log.warn(e)

                if result is not None:
                    settings.update(result)

        if 'secret_key' not in settings:
            log.warn('No secret key provided: using transient key. Please '
                     'configure the secret_key setting or the SECRET_KEY '
                     'environment variable!')
            settings['secret_key'] = os.urandom(64)

        # Set up SQLAlchemy debug logging
        if 'debug_query' in settings:
            level = logging.INFO
            if settings['debug_query'] == 'trace':
                level = logging.DEBUG
            logging.getLogger('sqlalchemy.engine').setLevel(level)

        # set from config file
        settings.update(
            config_yaml(self.import_name, _yaml=self.__trafaret))
        return Configurator(settings=settings)