Python MultiDict.add方法代码示例

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
    def build_params(self, request, facet_values):
        '''
        Build query parameters using the facet_values for this facet
        and the request.

        Returns: a list of (parameter, value) two-tuples
        '''
        params = MultiDict(request.params)

        # removing all ..._facet parameters and add them again
        current_facet_parameters = params.getall(self.request_key)
        if self.request_key in params:
            del params[self.request_key]

        # readd all _facet parameters not related to us
        for parameter in current_facet_parameters:
            name, value = parameter.split(':')
            if name != self.name:
                params.add(self.request_key, parameter)

        # add parameters for our facets
        facet_values = list(set(facet_values))
        for value in facet_values:
            params.add(self.request_key, "%s:%s" % (self.name, value))

        # sanitize and encode
        items = ([(str(key), unicode(value).encode('utf-8')) for
                  (key, value) in params.items()])
        return items

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
 def test_parse_filter_params(self):
     query_params = MultiDict()
     query_params.add('type', 1)
     query_params.add('type', 2)
     query_params.add('test', 22)
     res = parse_filter_params(query_params, self.filterable)
     self.assertEqual({'type': [1, 2]}, res)

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
 def test_multiple_values(self):
     formdata = MultiDict()
     formdata.add('items', '1')
     formdata.add('items', '2')
     form = self.Form(formdata)
     assert form.items.data == ['1', '2']
     assert form.validate()

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
class Utility(object):

    def __init__(self):
        self.accept_headers = MultiDict()
        self.deserializers = {}

    def add_deserializer(self, content_type, callable):
        self.deserializers[content_type] = callable
        self.accept_headers.add('Accept', content_type)

    def deserialize_request_body(self, request):
        content_type = request.content_type
        deserialized = None
        request.response.headers.extend(self.accept_headers)

        if content_type in self.deserializers:
            try:
                deserialized = self.deserializers[content_type](request)
            except HTTPException as http_exc:
                http_exc.headers.extend(self.accept_headers)
                raise
        else:
            raise HTTPUnsupportedMediaType(content_type,
                                           headers=self.accept_headers)

        return deserialized

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
 def test_jsonify_multidict(self):
     data = MultiDict()
     data.add('a', 1)
     data.add('a', 2)
     data.add('b', 3)
     json_data = jsonify.encode(data)
     self.assertEqual('{"a": [1, 2], "b": 3}', json_data)

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
    def test_a_list_field_can_have_a_single_value(self):
        schema = QueryParamSchema()
        params = MultiDict()
        params.add("list_field", "first")

        parsed = validate_query_params(schema, params)

        assert parsed.getall("list_field") == ["first"]

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
def ignore_request_params_fields (request_params):
	result_data = MultiDict()

	for name, value in request_params.items():
		if value != "IGNORE-THIS-FIELD":
			result_data.add(name, value)

	return result_data

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
 def test_repeated_argument(self):
     params = MultiDict(verb='a')
     params.add('repeated', 'b')
     params.add('repeated', 'b')
     self.assertRaises(BadArgument,
                       views._check_params,
                       params,
                       ['repeated'])

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
        def _w(*args, **kwargs):
            page = int(kwargs.pop(own_parameters["page"], 1))
            real_items_per_page = int(kwargs.pop(own_parameters["items_per_page"], items_per_page))

            # Iterate over all of the named arguments expected by the function f
            # if any of those arguments have values present in the kwargs dict,
            # add the value to the positional args list, and remove it from the
            # kwargs dict
            argvars = inspect.getargspec(f)[0][1:]
            if argvars:
                args = list(args)
                for i, var in enumerate(args):
                    if i >= len(argvars):
                        break
                    var = argvars[i]
                    if var in kwargs:
                        if i + 1 >= len(args):
                            args.append(kwargs[var])
                        else:
                            args[i + 1] = kwargs[var]
                        del kwargs[var]

            res = f(*args, **kwargs)
            if isinstance(res, dict) and name in res:
                additional_parameters = MultiDict()
                for key, value in request.params.iteritems():
                    if key not in own_parameters:
                        additional_parameters.add(key, value)

                collection = res[name]

                # Use CustomPage if our extra custom arg was provided
                if items_first_page is not None:
                    page_class = CustomPage
                else:
                    page_class = Page

                page = page_class(
                    collection,
                    page,
                    items_per_page=real_items_per_page,
                    items_first_page=items_first_page,
                    **additional_parameters.dict_of_lists()
                )
                # wrap the pager so that it will render
                # the proper page-parameter
                page.pager = partial(page.pager, page_param=own_parameters["page"])
                res[name] = page
                # this is a bit strange - it appears
                # as if c returns an empty
                # string for everything it dosen't know.
                # I didn't find that documented, so I
                # just put this in here and hope it works.
                if not hasattr(tmpl_context, "paginators") or type(tmpl_context.paginators) == str:
                    tmpl_context.paginators = Bunch()
                tmpl_context.paginators[name] = page
            return res

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
 def get_data(self, compact=True):
     data = MultiDict(self.raw_data) # XXX
     if compact:
         compact_data = MultiDict()
         for key, value in data.iteritems():
             if value:
                 compact_data.add(key, value)
         data = compact_data
     return data

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
    def test_it_does_not_include_unknown_fields(self):
        schema = QueryParamSchema()
        params = MultiDict()
        params.add("string_field", "include_me")
        params.add("unknown_field", "ignore_me")

        parsed = validate_query_params(schema, params)

        assert "unknown_field" not in parsed

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
    def test_it_keeps_only_last_value_for_non_sequence_fields(self):
        schema = QueryParamSchema()
        params = MultiDict()
        params.add("string_field", "first")
        params.add("string_field", "second")

        parsed = validate_query_params(schema, params)

        assert parsed.getall("string_field") == ["second"]

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
    def test_it_keeps_all_values_for_sequence_fields(self):
        schema = QueryParamSchema()
        params = MultiDict()
        params.add("list_field", "first")
        params.add("list_field", "second")

        parsed = validate_query_params(schema, params)

        assert parsed.getall("list_field") == ["first", "second"]

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
def _dict_to_multidict(dict_):
    """Convert a validated query param dict back to a ``MultiDict``."""
    result = MultiDict()
    for key, value in dict_.items():
        if isinstance(value, list):
            for item in value:
                result.add(key, item)
        else:
            result.add(key, value)
    return result

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import add [as 别名]
 def test_mf_search(self):
     mdict = MultiDict()
     mdict.add('SearchUser[email]', 'other')
     request = testing.DummyRequest(mdict)
     request.matchdict['objname'] = 'user'
     response = mf_search(request)
     #users = json.loads(response.body)
     users = response
     assert(len(users) == 1)
     assert(users[0]['email'] == '[email protected]')