Python MultiDict.add方法代码示例

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
def strip_sensitive_data_from_multidict(multidict):
    """
    Creates a new MultiDict with sensitive data blotted out for logging purposes.  Tightly coupled to the Flask
    logger and werkzeug.datastructures classes, we might want to make this more generic in the future.
    :param multidict: Multidict
    :return: Dictionary of keys and values (potentially stripped)
    """
    from werkzeug.datastructures import MultiDict

    # A bit overkill for now, since we have so few exceptions, and I'd hate for something to actually sneak through
    sensitive_regex = [
        r'.*account.*',
        r'.*bank.*',
        r'.*password.*',
        r'.*routing.*'
    ]

    stripped_multidict = MultiDict()

    # We perform an iterlists so that we get duplicates of the same key.
    for key, value in multidict.iterlists():
        for regex in sensitive_regex:
            match = re.match(regex, key, re.DOTALL | re.IGNORECASE)
            if match:
                value = u'************'
                break

        stripped_multidict.add(key, value)

    return stripped_multidict

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
def inspire_search_factory(self, search):
    """Parse query using Inspire-Query-Parser.

    :param self: REST view.
    :param search: Elastic search DSL search instance.
    :returns: Tuple with search instance and URL arguments.
    """
    query_string = request.values.get('q', '')
    urlkwargs = MultiDict()

    try:
        search = search.query_from_iq(query_string)
    except SyntaxError:
        current_app.logger.debug(
            "Failed parsing query: {0}".format(
                request.values.get('q', '')),
            exc_info=True)
        raise InvalidQueryRESTError()

    search_index = search._index[0]
    search, urlkwargs = inspire_filter_factory(search, urlkwargs, search_index)
    search, sortkwargs = default_sorter_factory(search, search_index)
    search = select_source(search)

    urlkwargs.add('q', query_string)
    current_app.logger.debug(json.dumps(search.to_dict(), indent=4))

    return search, urlkwargs

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
 def get_url(self, **kwargs):
     """Returns the URL for the viz"""
     d = self.orig_form_data.copy()
     if 'json' in d:
         del d['json']
     if 'action' in d:
         del d['action']
     d.update(kwargs)
     # Remove unchecked checkboxes because HTML is weird like that
     od = MultiDict()
     for key in sorted(d.keys()):
         if d[key] is False:
             del d[key]
         else:
             if isinstance(d, MultiDict):
                 v = d.getlist(key)
             else:
                 v = d.get(key)
             if not isinstance(v, list):
                 v = [v]
             for item in sorted(v):
                 od.add(key, item)
     href = Href(
         '/caravel/explore/{self.datasource.type}/'
         '{self.datasource.id}/'.format(**locals()))
     return href(od)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
def test_meeting_multicheckbox_field_non_editable(app, user):
    category = MeetingCategoryFactory(meeting__owner=user.staff)
    meeting = category.meeting
    data = MultiDict(ParticipantFactory.attributes())
    data['category_id'] = category.id
    field_data = MultiDict(CustomFieldFactory.attributes())
    field_data['label-english'] = field_data['label'].english
    field_data['hint-english'] = field_data['hint'].english
    field_data['field_type'] = CustomField.MULTI_CHECKBOX
    field_data.setlist('custom_field_choices',
                       ['first_choice', 'second_choice', 'third_choice'])

    client = app.test_client()
    with app.test_request_context():
        with client.session_transaction() as sess:
            sess['user_id'] = user.id
        add_custom_fields_for_meeting(meeting)
        add_multicheckbox_field(client, meeting, field_data)
        field = (CustomField.query
                 .filter_by(slug=field_data['label-english'])
                 .one())

        populate_participant_form(meeting, data)
        data.setlist(field.slug, ['first_choice', 'third_choice'])
        resp = client.post(url_for('meetings.participant_edit',
                                   meeting_id=meeting.id), data=data)
        assert resp.status_code == 302
        assert Participant.query.current_meeting().participants().first()
        assert CustomFieldValue.query.count() == 2
        assert field.choices.count() == 3

        field_data.add('custom_field_choices', 'fourth_choice')
        add_multicheckbox_field(client, meeting, field_data, field.id,
                                302)
        assert field.choices.count() == 3

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
def reset_password():
    if current_user.is_authenticated():
        logout_user()
    form = ResetPasswordForm()
    if form.is_submitted():
        if form.validate_on_submit():
            try:
                user = auth_service.user_by_username_or_email(form.email.data)
            except NoResultFound:
                form.email.errors = ['User with this email doesn\'t exist.']
            else:
                if user.active:
                    profile = profiles_service.profile(user.id)
                    auth_service.send_password_reset_mail(profile)
                    flash('We sent a letter that will allow you to change your password. Please check your mailbox.', 'success')
                    return redirect(url_for('auth.login'))
                else:
                    form.email.errors = ['This email address is not confirmed. Please, confirm it first.']
    else:
        initial = MultiDict()
        email = request.values.get('email')
        if email:
            initial.add('email', email)
        form = ResetPasswordForm(formdata=initial)
    return render_template('auth/reset_password.html',
        reset_password_form=form)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
def parse_args(raw_args):
    args = MultiDict()
    for (arg_name, arg_outer_values) in raw_args.iterlists():
        for arg_inner_values in arg_outer_values:
            for arg_value in arg_inner_values.split(','):
                args.add(arg_name, arg_value.strip())
    return args

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
def test_should_strip_page_from_multidict():
    params = MultiDict()
    params.add("this", "that")
    params.add("page", 100)

    parsed = search_helpers.query_args_for_pagination(params)
    assert_equal(parsed['this'], 'that')
    assert_false('page' in parsed)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
def get_available_products():
    '''
    Search with given arguments,
    but also limit the minimum amount to at least 1.
    '''
    args = MultiDict(request.args)
    args.add('minamount', 1)
    return dumps(backend.get_products(args))

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
def get_by_category(category):
    '''
    Search with given arguments,
    but also limit the search to the given category.
    '''
    args = MultiDict(request.args)
    args.add('category', category)
    return dumps(backend.get_products(args))

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
def to_wsgi_environment(headers: list, method: str, path: str,
                        http_version: str, body: BytesIO = None) -> MultiDict:
    """
    Produces a new WSGI environment from a set of data that is passed in.

    This will return a dictionary that is directly compatible with Werkzeug's Request wrapper.

    .. code-block:: python

        d = to_wsgi_environment([("Host", "127.0.0.1"), "GET", "/", None)
        request = werkzeug.wrappers.Request(d)

    :param headers: The headers of the HTTP request.
    :param method: The HTTP method of this request, e.g GET or POST.
    :param path: The HTTP path to get, in raw form.
        This should NOT be urldecoded, as the path is manually decoded.

    :param http_version: The HTTP version to use.
    :param body: A :class:`BytesIO` representing the body wrapper for this dict, or None if there \ 
        is no request body.

    :return: A new dict containing the fake WSGI environment.
    """
    if isinstance(headers, dict):
        headers = headers.items()

    # urlsplit the path
    sp_path = urlsplit(path)

    if body is None:
        body = BytesIO()

    environ = MultiDict({
        # Basic items
        "PATH_INFO": sp_path.path,
        "QUERY_STRING": sp_path.query,
        "SERVER_PROTOCOL": "HTTP/%s" % http_version,
        "REQUEST_METHOD": method,
        # WSGI protocol things
        "wsgi.errors": sys.stderr,
        "wsgi.url_scheme": "http",
        "wsgi.input": body,
        "wsgi.input_terminated": True,
        "wsgi.async": True,
        "wsgi.multithread": True,  # technically false sometimes, but oh well
        "wsgi.multiprocess": False,
        "wsgi.run_once": False
    })
    environ["wsgi.version"] = (1, 0)

    for header, value in headers:
        name = header.upper().replace("-", "_")
        if header not in ("Content-Type", "Content-Length"):
            name = "HTTP_{}".format(name)

        environ.add(name, value)

    return environ

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
def transformFile(files):
    result= MultiDict([])
    for f in files:
        file = files[f]
        unique_filename = str(uuid.uuid4())+secure_filename(file.filename)
        filepath=os.path.join(os.getcwd(), unique_filename)
        file.save(filepath)
        result.add(f, filepath)
    return result

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
def get_post_multidict():
    data = MultiDict()
    for k, v in request_data().items():
        if isinstance(v, (list, set, tuple)):
            for iv in v:
                data.add(k, iv)
        else:
            data.add(k, v)
    return data

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
def _normalize_networks(provider, networks):
    _provider = {"provider": provider, "networks": []}
    for netw, stats in groupby(networks, lambda r: r["network_code"]):
        _network = MultiDict()

        for s in stats:
            _network.add(netw, {"type": s["type"], "count": s["count"]})

        _provider["networks"].append({
            "network": netw, "stats": _network.getlist(netw)
            })
    return _provider

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
def build_query_params(keywords=None, service_types=None, lot=None, page=None):
    query_params = MultiDict()
    if keywords:
        query_params["q"] = keywords
    if service_types:
        for service_type in service_types:
            query_params.add("filter_serviceTypes", service_type)
    if lot:
        query_params["filter_lot"] = lot
    if page:
        query_params["page"] = page
    return query_params

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import add [as 别名]
    def process_python(self, values):
        """Turn raw python values back to strings"""
        values = self._to_strings(values)
        results = MultiDict()
        for k, v in values.iteritems():
            if k in self.fields:
                if self.fields[k].is_dict and isinstance(v, dict):
                    for key, value in v.items():
                        results.add('{}[{}]'.format(k, key), self.fields[k].python_to_string(value))
                else:
                    results.add(k, self.fields[k].python_to_string(v))

        return to_mixed(results)