Python MultiDict.items方法代码示例

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import items [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 items [as 别名]
 def qs_add(self, *args, **kwargs):
     query = self.query.copy()
     if args:
         mdict = MultiDict(args[0])
         for k, v in mdict.items():
             query.add(k, v)
     for k, v in kwargs.items():
         query.add(k, v)
     return self._copy(query=query)

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import items [as 别名]
 def add(self, *args, **kwargs):
     '''Adds values to URL's query'''
     query = self.query.copy()
     if args:
         mdict = MultiDict(args[0])
         for k, v in mdict.items():
             query.add(k, v)
     for k, v in kwargs.items():
         query.add(k, v)
     return self._copy(query=query)

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import items [as 别名]
def test_multidict():
    d = MultiDict(a=1, b=2)
    assert d['a'] == 1
    assert d.getall('c') == []

    d.add('a', 2)
    assert d['a'] == 2
    assert d.getall('a') == [1, 2]

    d['b'] = 4
    assert d.getall('b') == [4]
    assert list(d.keys()) == ['a', 'a', 'b']
    assert list(d.items()) == [('a', 1), ('a', 2), ('b', 4)]
    assert d.mixed() == {'a': [1, 2], 'b': 4}

    # test getone

    # KeyError: "Multiple values match 'a': [1, 2]"
    with pytest.raises(KeyError):
        d.getone('a')

    assert d.getone('b') == 4
    # KeyError: "Key not found: 'g'"
    with pytest.raises(KeyError):
        d.getone('g')

    assert d.dict_of_lists() == {'a': [1, 2], 'b': [4]}
    assert 'b' in d
    assert 'e' not in d
    d.clear()
    assert 'b' not in d
    d['a'] = 4
    d.add('a', 5)
    e = d.copy()
    assert 'a' in e
    e.clear()
    e['f'] = 42
    d.update(e)
    assert d == MultiDict([('a', 4), ('a', 5), ('f', 42)])
    f = d.pop('a')
    assert f == 4
    assert d['a'] == 5

    assert d.pop('g', 42) == 42
    with pytest.raises(KeyError):
        d.pop('n')
    # TypeError: pop expected at most 2 arguments, got 3
    with pytest.raises(TypeError):
        d.pop(4, 2, 3)
    d.setdefault('g', []).append(4)
    assert d == MultiDict([('a', 5), ('f', 42), ('g', [4])])

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import items [as 别名]
 def get_data(self, compact=True):
     '''
     Returns data representing current state of the form. While
     Form.raw_data may contain alien fields and invalid data, this method
     returns only valid fields that belong to this form only. It's designed
     to pass somewhere current state of the form (as query string or by
     other means).
     '''
     data = MultiDict()
     for field in self.fields:
         raw_value = field.from_python(self.python_data[field.name])
         field.set_raw_value(data, raw_value)
     if compact:
         data = MultiDict([(k, v) for k, v in data.items() if v])
     return data

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import items [as 别名]
 def qs_set(self, *args, **kwargs):
     if args and kwargs:
         raise TypeError('Use positional args or keyword args not both')
     query = self.query.copy()
     if args:
         mdict = MultiDict(args[0])
         for k in mdict.keys():
             if k in query:
                 del query[k]
         for k, v in mdict.items():
             query.add(k, v)
     else:
         for k, v in kwargs.items():
             query[k] = v
     return self._copy(query=query)

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import items [as 别名]
    def build_url(self, page=None, size=None, sort=None, facets=tuple(),
                  unselect_facets=tuple(), **kwargs):
        '''
        b/w compat
        '''
        query = MultiDict(request.params.items())
        query.update(kwargs)
        query["%s_page" % self.name] = page if page else 1
        query["%s_size" % self.name] = size if size else self.size
        query["%s_sort" % self.name] = sort if sort else self.selected_sort

        # sanitize the the query arguments
        query_items = ([(str(key), unicode(value).encode('utf-8')) for
                        (key, value) in query.items()])
        url_base = url.current(qualified=True)
        return url_base + "?" + urllib.urlencode(query_items)

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import items [as 别名]
def test_multidict():
    d = MultiDict(a=1, b=2)
    eq(d['a'], 1)
    eq(d.getall('c'), [])

    d.add('a', 2)
    eq(d['a'], 2)
    eq(d.getall('a'), [1, 2])

    d['b'] = 4
    eq(d.getall('b'), [4])
    eq(list(d.keys()), ['a', 'a', 'b'])
    eq(list(d.items()), [('a', 1), ('a', 2), ('b', 4)])
    eq(d.mixed(), {'a': [1, 2], 'b': 4})

    # test getone

    # KeyError: "Multiple values match 'a': [1, 2]"
    assert_raises(KeyError, d.getone, 'a')
    eq(d.getone('b'), 4)
    # KeyError: "Key not found: 'g'"
    assert_raises(KeyError, d.getone, 'g')

    eq(d.dict_of_lists(), {'a': [1, 2], 'b': [4]})
    assert 'b' in d
    assert 'e' not in d
    d.clear()
    assert 'b' not in d
    d['a'] = 4
    d.add('a', 5)
    e = d.copy()
    assert 'a' in e
    e.clear()
    e['f'] = 42
    d.update(e)
    eq(d, MultiDict([('a', 4), ('a', 5), ('f', 42)]))
    f = d.pop('a')
    eq(f, 4)
    eq(d['a'], 5)


    eq(d.pop('g', 42), 42)
    assert_raises(KeyError, d.pop, 'n')
    # TypeError: pop expected at most 2 arguments, got 3
    assert_raises(TypeError, d.pop, 4, 2, 3)
    d.setdefault('g', []).append(4)
    eq(d, MultiDict([('a', 5), ('f', 42), ('g', [4])]))

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import items [as 别名]
    def build_url(self, page=None, size=None, sort=None, facets=tuple(),
                  unselect_facets=tuple(), **kwargs):
        '''
        b/w compat
        '''
        query = MultiDict(request.params.items())
        query.update(kwargs)
        query[self.page_param] = page if page else 1
        query[self.size_param] = size if size else self.size
        query[self.sort_param] = sort if sort else self.selected_sort

        # sanitize the the query arguments
        query_items = ([(str(key), unicode(value).encode('utf-8')) for
                        (key, value) in query.items()])
        url_base = url.current(qualified=True)
        protocol = config.get('adhocracy.protocol', 'http').strip()
        if ', ' in url_base:
            # hard coded fix for enquetebeteiligung.de
            url_base = '%s://%s' % (protocol, url_base.split(', ')[1])
        else:
            url_base = '%s://%s' % (protocol, url_base.split('://')[1])
        return url_base + "?" + urllib.urlencode(query_items)

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import items [as 别名]
    def params(self, key=None):
        result = []
        if key is None:
            return self.request.params

        islist = False
        list_key = key + '[]'
        if list_key in self.request.params:
            islist = True

        if key in self.request.params or list_key in self.request.params:
            dict_copy = self.request.params.copy()
            dict_copy = MultiDict([(k.replace('[]', ''), value)
                                   for (k, value) in dict_copy.items()])
            while key in dict_copy:
                result.append(dict_copy.pop(key))

            len_result = len(result)
            if not islist and len_result == 1:
                return result[0]
            elif islist or len_result > 1:
                return result

        return None

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

    @pytest.fixture(autouse=True)
    def _prepare(self, any_form, form_factory, model_factory):
        fields = {
            'test_text': StringField(),
            'test_int': IntegerField(),
        }
        self.form = form_factory(fields=fields, base=any_form)
        self.formdata = MultiDict(test_text='Test123', test_int='17')
        cols = [
            Column('id', Integer, primary_key=True),
            Column('test_text', String),
            Column('test_int', Integer),
        ]
        self.obj = model_factory(cols, name='GenericModel')

    def test_init(self):
        form = self.form(self.formdata)
        for key, value in self.formdata.items():
            assert str(getattr(form, key).data) == value

    def test_init_obj_only(self):
        obj = self.obj(**self.formdata)
        form = self.form(obj=obj)
        for key, value in self.formdata.items():
            assert getattr(form, key).data == getattr(obj, key)

    def test_init_form_obj(self):
        obj = self.obj(test_text='ABC', test_int=3)
        form = self.form(self.formdata, obj)
        for key, value in self.formdata.items():
            assert str(getattr(form, key).data) == value

    def test_init_form_one_val(self):
        obj = self.obj(**self.formdata)
        form = self.form(MultiDict(test_text='ABC'), obj)
        assert form.test_text.data == 'ABC'
        del self.formdata['test_text']
        for key, value in self.formdata.items():
            assert getattr(form, key).data == getattr(obj, key)

    def test_init_none(self):
        form = self.form()
        for key in self.formdata:
            assert getattr(form, key).data is None

    def test_title(self, form_factory, Model_one_pk, any_form):
        Form = form_factory(base=any_form, model=Model_one_pk)
        assert Form.title == 'Model'

    def test_title_plural(self, form_factory, Model_one_pk, any_form):
        Form = form_factory(base=any_form, model=Model_one_pk)
        assert Form.title_plural == 'Models'

    def test_name(self, form_factory, Model_one_pk, any_form):
        Form = form_factory(base=any_form, model=Model_one_pk)
        assert Form.name == 'model'

    def test_field_names(self, model_factory, form_factory, any_form):
        Model = model_factory([Column('val', Integer)])
        Form = form_factory(base=any_form, model=Model)
        field_names = ['val']
        assert Form.field_names == field_names

    def test_get_fieldsets(self, model_factory, form_factory, any_form):
        Model = model_factory([Column('val', Integer)])
        Form = form_factory(base=any_form, model=Model)
        form = Form()
        fieldsets = [{'title': '', 'fields': [form.val],
                      'template': 'horizontal'}]
        assert form.get_fieldsets() == fieldsets

    def test_get_fieldsets_empty(self, model_factory, form_factory, any_form):
        Model = model_factory()
        Form = form_factory(base=any_form, model=Model)
        form = Form()
        fieldsets = [{'title': '', 'fields': [], 'template': 'horizontal'}]
        assert form.get_fieldsets() == fieldsets

    def test_get_fieldsets_override(self, model_factory, form_factory,
                                    any_form):
        fieldsets = [{'title': 'Test', 'fields': ['test_text'],
                      'template': 'horizontal'}]
        self.form.fieldsets = fieldsets
        form = self.form()
        expected = []
        for fieldset in fieldsets:
            copy = dict(fieldset)
            expected.append(copy)
        expected[0]['fields'] = [form.test_text]
        assert form.get_fieldsets() == expected

    def test_get_fieldsets_override_default_template(
            self, model_factory, form_factory, any_form):
        fieldsets = [{'title': 'Test', 'fields': ['test_text']}]
        self.form.fieldsets = fieldsets
        form = self.form()
        expected = []
        for fieldset in fieldsets:
#.........这里部分代码省略.........

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import items [as 别名]
class MimeHeaders(object):
    """Dictionary-like object that preserves the order and
    supports multiple values for the same key, knows
    whether it has been changed after the creation
    """

    def __init__(self, items=()):
        self._v = MultiDict([(normalize(key), remove_newlines(val))
                             for (key, val) in items])
        self.changed = False
        self.num_prepends = 0

    def __getitem__(self, key):
        v = self._v.get(normalize(key), None)
        if v is not None:
            return encodedword.decode(v)
        return None

    def __len__(self):
        return len(self._v)

    def __iter__(self):
        return iter(self._v)

    def __contains__(self, key):
        return normalize(key) in self._v

    def __setitem__(self, key, value):
        key = normalize(key)
        if key in self._v:
            self._v[key] = remove_newlines(value)
            self.changed = True
        else:
            self.prepend(key, remove_newlines(value))

    def __delitem__(self, key):
        del self._v[normalize(key)]
        self.changed = True

    def __bool__(self):
        return len(self._v) > 0

    def prepend(self, key, value):
        self._v._items.insert(0, (normalize(key), remove_newlines(value)))
        self.num_prepends += 1

    def add(self, key, value):
        """Adds header without changing the
        existing headers with same name"""
        self.prepend(key, value)

    def keys(self):
        """
        Returns the keys. (message header names)
        It remembers the order in which they were added, what
        is really important
        """
        return list(self._v.keys())

    def transform(self, fn, decode=False):
        """Accepts a function, getting a key, val and returning
        a new pair of key, val and applies the function to all
        header, value pairs in the message.
        """

        changed = [False]

        def tracking_fn(key, val):
            new_key, new_val = fn(key, val)
            if new_val != val or new_key != key:
                changed[0] = True
            return new_key, new_val

        v = MultiDict(tracking_fn(key, val) for key, val in self.iteritems(raw=not decode))
        if changed[0]:
            self._v = v
            self.changed = True

    def items(self):
        """
        Returns header,val pairs in the preserved order.
        """
        return list(self.items())

    def iteritems(self, raw=False):
        """
        Returns iterator header,val pairs in the preserved order.
        """
        if raw:
            return iter(self._v.items())

        return iter([(x[0], encodedword.decode(x[1]))
                     for x in self._v.items()])

    def get(self, key, default=None):
        """
        Returns header value (case-insensitive).
        """
        v = self._v.get(normalize(key), default)
        if v is not None:
#.........这里部分代码省略.........