Python settings.aslist函数代码示例

    def configure(cls, settings):
        super(ConfigAccessBackend, cls).configure(settings)
        cls._settings = settings
        cls.zero_security_mode = asbool(settings.get('auth.zero_security_mode',
                                                     False))
        cls.admins = aslist(settings.get('auth.admins', []))
        cls.user_groups = defaultdict(list)
        cls.group_map = {}

        if cls.zero_security_mode:
            cls.ROOT_ACL = [
                (Allow, Everyone, 'login'),
                (Allow, Everyone, 'read'),
                (Allow, Authenticated, 'write'),
                (Allow, 'admin', ALL_PERMISSIONS),
                (Deny, Everyone, ALL_PERMISSIONS),
            ]
        else:
            cls.ROOT_ACL = IAccessBackend.ROOT_ACL

        # Build dict that maps users to list of groups
        for key, value in settings.iteritems():
            if not key.startswith('group.'):
                continue
            group_name = key[len('group.'):]
            members = aslist(value)
            cls.group_map[group_name] = members
            for member in members:
                cls.user_groups[member].append(group_name)

    def configure(cls, settings):
        kwargs = super(ConfigAccessBackend, cls).configure(settings)
        if asbool(settings.get('auth.zero_security_mode', False)):
            LOG.warn("Using deprecated option 'auth.zero_security_mode' "
                     "(replaced by 'pypi.default_read' and "
                     "'pypi.default_write'")
            kwargs['default_read'] = [Everyone]
            kwargs['default_write'] = [Authenticated]
        kwargs['settings'] = settings
        kwargs['admins'] = aslist(settings.get('auth.admins', []))
        user_groups = defaultdict(list)
        group_map = {}

        # Build dict that maps users to list of groups
        for key, value in settings.iteritems():
            if not key.startswith('group.'):
                continue
            group_name = key[len('group.'):]
            members = aslist(value)
            group_map[group_name] = members
            for member in members:
                user_groups[member].append(group_name)
        kwargs['group_map'] = group_map
        kwargs['user_groups'] = user_groups
        return kwargs

def setup_listeners(config):
    write_actions = (ACTIONS.CREATE, ACTIONS.UPDATE, ACTIONS.DELETE)
    settings = config.get_settings()
    listeners = aslist(settings['event_listeners'])

    for name in listeners:
        logger.info('Setting up %r listener')
        prefix = 'event_listeners.%s.' % name

        try:
            listener_mod = config.maybe_dotted(name)
            prefix = 'event_listeners.%s.' % name.split('.')[-1]
            listener = listener_mod.load_from_config(config, prefix)
        except (ImportError, AttributeError):
            listener_mod = config.maybe_dotted(settings[prefix + 'use'])
            listener = listener_mod.load_from_config(config, prefix)

        actions = aslist(settings.get(prefix + 'actions', '')) or write_actions
        resource_names = aslist(settings.get(prefix + 'resources', ''))
        decorated = _filter_events(listener, actions, resource_names)

        if ACTIONS.READ in actions:
            config.add_subscriber(decorated, ResourceRead)
            if len(actions) == 1:
                return

        config.add_subscriber(decorated, ResourceChanged)

def includeme(config):
    """Plug daybed-browserid to daybed"""
    settings = config.get_settings()
    if 'browserid.audiences' not in settings:
        raise ConfigurationError(
            'Missing browserid.audiences settings. This is needed for '
            'security reasons. See https://developer.mozilla.org/en-US/docs/'
            'Persona/Security_Considerations for details.')

    if 'browserid.trusted_issuers' not in settings:
        raise ConfigurationError(
            'Missing browserid.trusted_issuers settings. This is needed for '
            'security reasons. See https://developer.mozilla.org/en-US/docs/'
            'Persona/Security_Considerations for details.')

    verifier_url = settings.get("browserid.verifier_url", None)
    audiences = aslist(settings['browserid.audiences'])
    trusted_issuers = aslist(settings['browserid.trusted_issuers'])

    config.registry['browserid.verifier_url'] = verifier_url
    config.registry['browserid.audiences'] = audiences
    config.registry['browserid.trusted_issuers'] = trusted_issuers

    # Create a backend
    backend_class = config.maybe_dotted(
        settings.get(
            'browserid.backend',
            settings['daybed.backend'].replace('daybed', 'daybed_browserid')
        )
    )
    config.registry.browserid_db = backend_class.load_from_config(config)
    config.scan("daybed_browserid.views")

def includeme(config):
    if hasattr(config.registry, "tonnikala_renderer_factory"):
        return

    config.registry.tonnikala_renderer_factory = TonnikalaRendererFactory()

    config.add_directive("add_tonnikala_extensions", add_tonnikala_extensions)
    config.add_directive("add_tonnikala_search_paths", add_tonnikala_search_paths)
    config.add_directive("set_tonnikala_reload", set_tonnikala_reload)

    settings = config.registry.settings

    if "tonnikala.extensions" in settings:
        extensions = settings["tonnikala.extensions"]
        if not is_nonstr_iter(extensions):
            extensions = aslist(extensions, flatten=True)

        config.add_tonnikala_extensions(*extensions)

    if "tonnikala.search_paths" in settings:
        paths = settings["tonnikala.search_paths"]
        if not is_nonstr_iter(paths):
            paths = aslist(paths, flatten=True)

        config.add_tonnikala_search_paths(*paths)

    tk_reload = settings.get("tonnikala.reload")
    if tk_reload is None:
        tk_reload = settings.get("pyramid.reload_templates")

    config.set_tonnikala_reload(asbool(tk_reload))

def depsjs(request):
    path_to_source = {}

    settings = request.registry.settings
    pyramid_closure = settings.get("pyramid_closure")

    roots = pyramid_closure.get("roots") if pyramid_closure else \
        settings.get("pyramid_closure.roots")

    if roots is None:
        roots = []
    elif isinstance(roots, basestring):
        roots = aslist(roots)

    for root in roots:
        path_to_source.update(depswriter._GetRelativePathToSourceDict(root))

    roots_with_prefix = pyramid_closure.get("roots_with_prefix") if \
        pyramid_closure else \
        settings.get("pyramid_closure.roots_with_prefix")

    if roots_with_prefix is None:
        roots_with_prefix = []
    elif isinstance(roots_with_prefix, basestring):
        roots_with_prefix = [aslist(roots_with_prefix)]

    for prefix, root in pairwise(roots_with_prefix):
        path_to_source.update(
            depswriter._GetRelativePathToSourceDict(
                root, prefix=request.static_url(prefix)))

    request.response.content_type = 'text/javascript'

    return depswriter.MakeDepsFile(path_to_source)

def includeme(config):
    settings = config.get_settings()

    # Add CORS settings to the base cliquet Service class.
    cors_origins = settings["cliquet.cors_origins"]
    Service.cors_origins = tuple(aslist(cors_origins))
    Service.default_cors_headers = ("Backoff", "Retry-After", "Alert", "Content-Length")
    Service.error_handler = lambda self, e: errors.json_error_handler(e)

    # Heartbeat registry.
    config.registry.heartbeats = {}

    # Public settings registry.
    config.registry.public_settings = {"cliquet.batch_max_requests"}

    # Setup components.
    for step in aslist(settings["cliquet.initialization_sequence"]):
        step_func = config.maybe_dotted(step)
        step_func(config)

    # Setup cornice.
    config.include("cornice")

    # Scan views.
    config.scan("cliquet.views")

    # Give sign of life.
    msg = "%(cliquet.project_name)s %(cliquet.project_version)s starting."
    logger.info(msg % settings)

def factory(handler, registry):
  get          = morph.pick(registry.settings, prefix=CONFIG_PREFIX).get
  conf         = aadict()
  conf.enabled = asbool(get('enabled', True))
  conf.include = [globre.compile(el, globre.EXACT)
                  for el in aslist(get('include', []))]
  conf.exclude = [globre.compile(el, globre.EXACT)
                  for el in aslist(get('exclude', []))]
  conf.reparse = aslist(get('reparse-methods', DEFAULT_REPARSE_METHODS))
  conf.name    = get('attribute-name', DEFAULT_ATTRIBUTE_NAME)
  conf.deep    = asbool(get('combine.deep', True))
  conf.reqdict = asbool(get('require-dict', True))
  conf.failunk = asbool(get('fail-unknown', True))
  conf.ndict   = asbool(get('native-dict', False))
  conf.error   = get('error-handler', None)
  if conf.error:
    conf.error = asset.symbol(conf.error)
  conf.xfmt    = asbool(get('xml.enable', True))
  conf.jfmt    = asbool(get('json.enable', True))
  conf.yfmt    = asbool(get('yaml.enable', bool(yaml or get('yaml.parser'))))
  if conf.jfmt:
    conf.jparser = get('json.parser', None)
    if conf.jparser:
      conf.jparser = asset.symbol(conf.jparser)
  if conf.yfmt:
    conf.yparser = asset.symbol(get('yaml.parser', 'yaml.load'))
  if conf.xfmt:
    conf.xparser = asset.symbol(get('xml.parser', 'xml.etree.ElementTree.fromstring'))
  def input_tween(request):
    return process(handler, request, conf)
  return input_tween

def includeme(config):
    load_default_settings(config, DEFAULT_SETTINGS)
    settings = config.get_settings()

    # Add CORS settings to the base cliquet Service class.
    cors_origins = settings['cliquet.cors_origins']
    Service.cors_origins = tuple(aslist(cors_origins))
    Service.default_cors_headers = ('Backoff', 'Retry-After', 'Alert')

    # Heartbeat registry.
    config.registry.heartbeats = {}

    # Setup components.
    for step in aslist(settings['cliquet.initialization_sequence']):
        step_func = config.maybe_dotted(step)
        step_func(config)

    # Setup cornice.
    config.include("cornice")

    # Scan views.
    config.scan("cliquet.views")

    # Give sign of life.
    msg = "%(cliquet.project_name)s %(cliquet.project_version)s starting."
    logger.info(msg % settings)

def setup_listeners(config):
    # Register basic subscriber predicates, to filter events.
    config.add_subscriber_predicate('for_actions', EventActionFilter)
    config.add_subscriber_predicate('for_resources', EventResourceFilter)

    write_actions = (ACTIONS.CREATE, ACTIONS.UPDATE, ACTIONS.DELETE)
    settings = config.get_settings()
    project_name = settings.get('project_name', '')
    listeners = aslist(settings['event_listeners'])

    for name in listeners:
        logger.info('Setting up %r listener' % name)
        prefix = 'event_listeners.%s.' % name

        try:
            listener_mod = config.maybe_dotted(name)
            prefix = 'event_listeners.%s.' % name.split('.')[-1]
            listener = listener_mod.load_from_config(config, prefix)
        except (ImportError, AttributeError):
            module_setting = prefix + "use"
            # Read from ENV or settings.
            module_value = utils.read_env(project_name + "." + module_setting,
                                          settings.get(module_setting))
            listener_mod = config.maybe_dotted(module_value)
            listener = listener_mod.load_from_config(config, prefix)

        # If StatsD is enabled, monitor execution time of listeners.
        if getattr(config.registry, "statsd", None):
            statsd_client = config.registry.statsd
            key = 'listeners.%s' % name
            listener = statsd_client.timer(key)(listener.__call__)

        # Optional filter by event action.
        actions_setting = prefix + "actions"
        # Read from ENV or settings.
        actions_value = utils.read_env(project_name + "." + actions_setting,
                                       settings.get(actions_setting, ""))
        actions = aslist(actions_value)
        if len(actions) > 0:
            actions = ACTIONS.from_string_list(actions)
        else:
            actions = write_actions

        # Optional filter by event resource name.
        resource_setting = prefix + "resources"
        # Read from ENV or settings.
        resource_value = utils.read_env(project_name + "." + resource_setting,
                                        settings.get(resource_setting, ""))
        resource_names = aslist(resource_value)

        # Pyramid event predicates.
        options = dict(for_actions=actions, for_resources=resource_names)

        if ACTIONS.READ in actions:
            config.add_subscriber(listener, ResourceRead, **options)
            if len(actions) == 1:
                return

        config.add_subscriber(listener, ResourceChanged, **options)

def _parse_settings(settings):

    rawes_args = {}
    defaults = {
        'url': 'http://localhost:9200',
        'timeout': 30,
        'path': '',
        'json_encoder': encode_date_optional_time,
    }

    rawes_args = defaults.copy()

    # set string settings
    for short_key_name in ('path',):
        key_name = 'rawes.%s' % (short_key_name,)
        if key_name in settings:
            rawes_args[short_key_name] = \
                settings.get(key_name, defaults.get(short_key_name))

    # set list settings
    for short_key_name in ('url',):
        key_name = 'rawes.%s' % (short_key_name,)
        if key_name in settings:
            rawes_args[short_key_name] = \
                (aslist(settings.get(key_name, defaults.get(short_key_name)))
		        if len(aslist(settings.get(key_name, defaults.get(short_key_name)))) > 1
		        else settings.get(key_name, defaults.get(short_key_name)).strip())

    # integer settings
    for short_key_name in ('timeout',):
        key_name = 'rawes.%s' % (short_key_name,)
        if key_name in settings:
            rawes_args[short_key_name] = \
                int(settings.get(key_name, defaults.get(short_key_name)))

    # function settings
    for short_key_name in ('json_encoder',):
        key_name = 'rawes.%s' % (short_key_name,)
        r = DottedNameResolver()
        if key_name in settings:
            rawes_args[short_key_name] = \
                r.resolve(settings.get(key_name))
    for short_key_name in ('json_decoder',):
        key_name = 'rawes.%s' % (short_key_name,)
        r = DottedNameResolver()
        if key_name in settings:
            rawes_args[short_key_name] = \
                r.resolve(settings.get(key_name))().decode

    # removed settings
    for short_key_name in ('connection_type', 'except_on_error'):
        key_name = 'rawes.%s' % (short_key_name,)
        if key_name in settings:
            warnings.warn(
                '%s is no longer supported, please remove from your settings.',
                UserWarning
            )

    return rawes_args

 def configure(cls, settings):
     """ Configure the access backend with app settings """
     return {
         'default_read': aslist(settings.get('pypi.default_read',
                                             ['authenticated'])),
         'default_write': aslist(settings.get('pypi.default_write', [])),
         'cache_update': aslist(settings.get('pypi.cache_update',
                                             ['authenticated'])),
     }

def parse_options_from_settings(settings, settings_prefix, maybe_dotted):
    """ Parse options for use with Mako's TemplateLookup from settings."""
    def sget(name, default=None):
        return settings.get(settings_prefix + name, default)

    reload_templates = sget('reload_templates', None)
    if reload_templates is None:
        reload_templates = settings.get('pyramid.reload_templates', None)
    reload_templates = asbool(reload_templates)
    directories = sget('directories', [])
    module_directory = sget('module_directory', None)
    input_encoding = sget('input_encoding', 'utf-8')
    error_handler = sget('error_handler', None)
    default_filters = sget('default_filters', 'h')
    imports = sget('imports', None)
    future_imports = sget('future_imports', None)
    strict_undefined = asbool(sget('strict_undefined', False))
    preprocessor = sget('preprocessor', None)
    if not is_nonstr_iter(directories):
        # Since we parse a value that comes from an .ini config,
        # we treat whitespaces and newline characters equally as list item separators.
        directories = aslist(directories, flatten=True)
    directories = [abspath_from_asset_spec(d) for d in directories]

    if module_directory is not None:
        module_directory = abspath_from_asset_spec(module_directory)

    if error_handler is not None:
        error_handler = maybe_dotted(error_handler)

    if default_filters is not None:
        if not is_nonstr_iter(default_filters):
            default_filters = aslist(default_filters)

    if imports is not None:
        if not is_nonstr_iter(imports):
            imports = aslist(imports, flatten=False)

    if future_imports is not None:
        if not is_nonstr_iter(future_imports):
            future_imports = aslist(future_imports)

    if preprocessor is not None:
        preprocessor = maybe_dotted(preprocessor)

    return dict(
        directories=directories,
        module_directory=module_directory,
        input_encoding=input_encoding,
        error_handler=error_handler,
        default_filters=default_filters,
        imports=imports,
        future_imports=future_imports,
        filesystem_checks=reload_templates,
        strict_undefined=strict_undefined,
        preprocessor=preprocessor,
    )

def includeme(config):
    """ This function returns a Pyramid WSGI application."""

    def contextual_route(name, route, from_root=True):
        config.add_route('contextual_'+name, '/{discussion_slug}'+route)
        if from_root:
            config.add_route(name, route)

    contextual_route('login', '/login')
    contextual_route('login_forceproviders', '/login_showallproviders')
    contextual_route('logout', '/logout')
    # type in u(sername), id, email, {velruse-id-type}
    config.add_route('profile_user', '/user/{type}/{identifier}')
    config.add_route('avatar', '/user/{type}/{identifier}/avatar/{size:\d+}')
    contextual_route('register', '/register')
    contextual_route('user_confirm_email', '/users/email_confirm/{ticket}')
    # Do we want this?
    # config.add_route('profile_search', '/usernames/{user_name}')
    # TODO: secure next three methods to avoid spamming the user.
    contextual_route('confirm_emailid_sent',
                     '/confirm_email_sent_id/{email_account_id:\d+}')
    contextual_route('confirm_email_sent', '/confirm_email_sent/{email}')

    contextual_route('password_change_sent',
                     '/password_change_sent/{profile_id:\d+}')
    contextual_route('request_password_change', '/req_password_change')
    contextual_route('do_password_change', '/do_password_change/{ticket}')
    contextual_route('welcome', '/welcome/{ticket}')
    contextual_route('finish_password_change', '/finish_password_change')
    config.add_route('contextual_social_auth', '/{discussion_slug}/login/{backend}')
    contextual_route('add_social_account', '/add_account/{backend}')

    # determine which providers we want to configure
    settings = config.get_settings()
    providers = aslist(settings['login_providers'])
    config.add_settings(login_providers=providers)
    config.add_settings(trusted_login_providers=aslist(
        settings.get('trusted_login_providers', '')))
    if not any(providers):
        sys.stderr.write('no login providers configured, double check '
                         'your ini file and add a few')
    settings = config.registry.settings
    for name in ('SOCIAL_AUTH_AUTHENTICATION_BACKENDS',
                 'SOCIAL_AUTH_USER_FIELDS',
                 'SOCIAL_AUTH_PROTECTED_USER_FIELDS',
                 'SOCIAL_AUTH_FIELDS_STORED_IN_SESSION'):
        settings[name] = aslist(settings.get(name, ''))
    for k in settings.iterkeys():
        if k.endswith("_SCOPE") and k.startswith("SOCIAL_AUTH_"):
            settings[k] = aslist(settings.get(k, ''))
    config.add_request_method(
        'assembl.auth.social_auth.get_user', 'user', reify=True)
    config.include('social.apps.pyramid_app')
    config.scan()
    config.scan('social.apps.pyramid_app')

def load_from_config(config, prefix=''):
    settings = config.get_settings()

    collections = aslist(settings.get(prefix + 'collections', ''))

    changes_bucket = settings.get(prefix + 'bucket', 'monitor')
    changes_collection = settings.get(prefix + 'collection', 'changes')
    changes_principals = aslist(settings.get(prefix + 'principals', Everyone))

    return Listener(collections, changes_bucket, changes_collection,
                    changes_principals)