Python MultiDict.getall方法代码示例

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import getall [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 getall [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 getall [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 getall [as 别名]
    def test_vote(self):
        views.includeme(self.config)
        tags = set(["ponies", "thunderstorms", "giant robots", "archeological digs", "trombones"])
        q = models.Question(text="Which are cool?", min=3, max=3, active=True, tags=tags)
        models.DBSession.add(q)
        transaction.commit()

        q = models.Question.query.one()
        assert models.Vote.query.filter(models.Vote.question == q).count() == 0

        data = MultiDict()
        data.add('tag', 'thunderstorms')
        data.add('tag', 'giant robots')
        data.add('tag', 'trombones')

        request = testing.DummyRequest(post=data)
        response = views.record_vote(request)

        assert isinstance(response, HTTPSeeOther)
        v = models.Vote.query.filter(models.Vote.question == q).one()
        assert v.tags == set(data.getall('tag'))

        assert v.uuid == request.session['uuid']

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import getall [as 别名]
    def test_with_classifiers(self, monkeypatch, db_request, page):
        params = MultiDict([
            ("q", "foo bar"),
            ("c", "foo :: bar"),
            ("c", "fiz :: buz"),
        ])
        if page is not None:
            params["page"] = page
        db_request.params = params

        es_query = pretend.stub(
            suggest=pretend.call_recorder(lambda *a, **kw: es_query),
            filter=pretend.call_recorder(lambda *a, **kw: es_query),
            sort=pretend.call_recorder(lambda *a, **kw: es_query),
        )
        db_request.es = pretend.stub(
            query=pretend.call_recorder(lambda *a, **kw: es_query)
        )

        classifier1 = ClassifierFactory.create(classifier="foo :: bar")
        classifier2 = ClassifierFactory.create(classifier="foo :: baz")
        classifier3 = ClassifierFactory.create(classifier="fiz :: buz")

        project = ProjectFactory.create()
        release1 = ReleaseFactory.create(project=project)
        release1.created = datetime.date(2011, 1, 1)
        release1._classifiers.append(classifier1)
        release1._classifiers.append(classifier2)

        page_obj = pretend.stub(page_count=(page or 1) + 10)
        page_cls = pretend.call_recorder(lambda *a, **kw: page_obj)
        monkeypatch.setattr(views, "ElasticsearchPage", page_cls)

        url_maker = pretend.stub()
        url_maker_factory = pretend.call_recorder(lambda request: url_maker)
        monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory)

        search_view = search(db_request)
        assert search_view == {
            "page": page_obj,
            "term": params.get("q", ''),
            "order": params.get("o", ''),
            "applied_filters": params.getall("c"),
            "available_filters": [
                ('foo', [
                    classifier1.classifier,
                    classifier2.classifier,
                ])
            ],
        }
        assert (
            ("fiz", [
                classifier3.classifier
            ]) not in search_view["available_filters"]
        )
        assert page_cls.calls == [
            pretend.call(es_query, url_maker=url_maker, page=page or 1),
        ]
        assert url_maker_factory.calls == [pretend.call(db_request)]
        assert db_request.es.query.calls == [
            pretend.call(
                "dis_max",
                queries=self._gather_es_queries(params["q"])
            )
        ]
        assert es_query.suggest.calls == [
            pretend.call(
                "name_suggestion",
                params["q"],
                term={"field": "name"},
            ),
        ]
        assert es_query.filter.calls == [
            pretend.call('terms', classifiers=['foo :: bar', 'fiz :: buz'])
        ]

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import getall [as 别名]

#.........这里部分代码省略.........
    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 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 wrapper(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(wrapper(k, v) for k, v 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.iteritems())

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

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

    def get(self, key, default=None):
        """
        Returns header value (case-insensitive).
        """
        v = self._v.get(normalize(key), default)
        if v is not None:
            return encodedword.decode(v)
        return None

    def getraw(self, key, default=None):
        """
        Returns raw header value (case-insensitive, non-decoded.
        """
        return self._v.get(normalize(key), default)

    def getall(self, key):
        """
        Returns all header values by the given header name (case-insensitive).
        """
        v = self._v.getall(normalize(key))
        return [encodedword.decode(x) for x in v]

    def have_changed(self, ignore_prepends=False):
        """
        Tells whether someone has altered the headers after creation.
        """
        return self.changed or (self.num_prepends > 0 and not ignore_prepends)

    def __str__(self):
        return str(self._v)

    @classmethod
    def from_stream(cls, stream):
        """
        Takes a stream and reads the headers, decodes headers to unicode dict
        like object.
        """
        return cls(parse_stream(stream))

    def to_stream(self, stream, prepends_only=False):
        """
        Takes a stream and serializes headers in a mime format.
        """
        i = 0
        for h, v in self.iteritems(raw=True):
            if prepends_only and i == self.num_prepends:
                break
            i += 1
            try:
                h.encode('ascii')
            except UnicodeDecodeError:
                raise EncodingError("Non-ascii header name")
            stream.write("{0}: {1}\r\n".format(h, to_mime(h, v)))

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import getall [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), val) for (key, val) in items])
        self.changed = False

    def __getitem__(self, key):
        return self.v.get(normalize(key), 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):
        self.v[normalize(key)] = _remove_newlines(value)
        self.changed = True

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

    def __nonzero__(self):
        return len(self.v) > 0

    def prepend(self, key, val):
        self.v._items.insert(0, (key, _remove_newlines(val)))
        self.changed = True

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

        self.v.add(normalize(key), _remove_newlines(value))
        self.changed = True

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

    def transform(self, fn):
        """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.v.iteritems())
        if changed[0]:
            self.v = v
            self.changed = True


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


    def iteritems(self):
        """
        Returns iterator header,val pairs in the preserved order.
        """
        return self.v.iteritems()


    def get(self, key, default=None):
        """
        Returns header value (case-insensitive).
        """
        return self.v.get(normalize(key), default)

    def getall(self, key):
        """
        Returns all header values by the given header name
        (case-insensitive)
        """
        return self.v.getall(normalize(key))

    def have_changed(self):
#.........这里部分代码省略.........

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import getall [as 别名]
    def test_with_classifiers(self, monkeypatch, db_request, page):
        params = MultiDict([
            ("q", "foo bar"),
            ("c", "foo :: bar"),
            ("c", "fiz :: buz"),
        ])
        if page is not None:
            params["page"] = page
        db_request.params = params

        es_query = pretend.stub(
            suggest=pretend.call_recorder(lambda *a, **kw: es_query),
            filter=pretend.call_recorder(lambda *a, **kw: es_query),
            sort=pretend.call_recorder(lambda *a, **kw: es_query),
        )
        db_request.es = pretend.stub(
            query=pretend.call_recorder(lambda *a, **kw: es_query)
        )

        classifier1 = ClassifierFactory.create(classifier="foo :: bar")
        classifier2 = ClassifierFactory.create(classifier="foo :: baz")
        classifier3 = ClassifierFactory.create(classifier="fiz :: buz")

        page_obj = pretend.stub(page_count=(page or 1) + 10)
        page_cls = pretend.call_recorder(lambda *a, **kw: page_obj)
        monkeypatch.setattr(views, "ElasticsearchPage", page_cls)

        url_maker = pretend.stub()
        url_maker_factory = pretend.call_recorder(lambda request: url_maker)
        monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory)

        assert search(db_request) == {
            "page": page_obj,
            "term": params.get("q", ''),
            "order": params.get("o", ''),
            "applied_filters": params.getall("c"),
            "available_filters": [
                ('fiz', [classifier3.classifier]),
                ('foo', [
                    classifier1.classifier,
                    classifier2.classifier,
                ])
            ],
        }
        assert page_cls.calls == [
            pretend.call(es_query, url_maker=url_maker, page=page or 1),
        ]
        assert url_maker_factory.calls == [pretend.call(db_request)]
        assert db_request.es.query.calls == [
            pretend.call(
                "multi_match",
                query="foo bar",
                fields=[
                    "name^2", "version", "author", "author_email",
                    "maintainer", "maintainer_email", "home_page", "license",
                    "summary", "description", "keywords", "platform",
                    "download_url",
                ],
            ),
        ]
        assert es_query.suggest.calls == [
            pretend.call(
                name="name_suggestion",
                term={"field": "name"},
                text="foo bar",
            ),
        ]
        assert es_query.filter.calls == [
            pretend.call('terms', classifiers=['foo :: bar', 'fiz :: buz'])
        ]

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import getall [as 别名]
    def test_with_classifiers(self, monkeypatch, db_request, metrics, page):
        params = MultiDict([("q", "foo bar"), ("c", "foo :: bar"), ("c", "fiz :: buz")])
        if page is not None:
            params["page"] = page
        db_request.params = params

        es_query = pretend.stub(
            suggest=pretend.call_recorder(lambda *a, **kw: es_query),
            filter=pretend.call_recorder(lambda *a, **kw: es_query),
            query=pretend.call_recorder(lambda *a, **kw: es_query),
            sort=pretend.call_recorder(lambda *a, **kw: es_query),
        )
        db_request.es = pretend.stub(
            query=pretend.call_recorder(lambda *a, **kw: es_query)
        )

        classifier1 = ClassifierFactory.create(classifier="foo :: bar")
        classifier2 = ClassifierFactory.create(classifier="foo :: baz")
        classifier3 = ClassifierFactory.create(classifier="fiz :: buz")

        project = ProjectFactory.create()
        release1 = ReleaseFactory.create(project=project)
        release1.created = datetime.date(2011, 1, 1)
        release1._classifiers.append(classifier1)
        release1._classifiers.append(classifier2)

        page_obj = pretend.stub(page_count=(page or 1) + 10, item_count=1000)
        page_cls = pretend.call_recorder(lambda *a, **kw: page_obj)
        monkeypatch.setattr(views, "ElasticsearchPage", page_cls)

        url_maker = pretend.stub()
        url_maker_factory = pretend.call_recorder(lambda request: url_maker)
        monkeypatch.setattr(views, "paginate_url_factory", url_maker_factory)

        search_view = search(db_request)
        assert search_view == {
            "page": page_obj,
            "term": params.get("q", ""),
            "order": params.get("o", ""),
            "applied_filters": params.getall("c"),
            "available_filters": [
                {
                    "foo": {
                        classifier1.classifier.split(" :: ")[1]: {},
                        classifier2.classifier.split(" :: ")[1]: {},
                    }
                }
            ],
        }
        assert ("fiz", [classifier3.classifier]) not in search_view["available_filters"]
        assert page_cls.calls == [
            pretend.call(es_query, url_maker=url_maker, page=page or 1)
        ]
        assert url_maker_factory.calls == [pretend.call(db_request)]
        assert db_request.es.query.calls == [
            pretend.call(views.gather_es_queries(params["q"]))
        ]
        assert es_query.suggest.calls == [
            pretend.call("name_suggestion", params["q"], term={"field": "name"})
        ]
        assert es_query.query.calls == [
            pretend.call("prefix", classifiers="foo :: bar"),
            pretend.call("prefix", classifiers="fiz :: buz"),
        ]
        assert metrics.histogram.calls == [
            pretend.call("warehouse.views.search.results", 1000)
        ]