Python MultiDict.get方法代码示例

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import get [as 别名]
    def test_without_a_query(self, monkeypatch, db_request, page):
        params = MultiDict()
        if page is not None:
            params["page"] = page
        db_request.params = params

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

        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": [],
            "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)]

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import get [as 别名]
    def test_with_an_ordering(self, monkeypatch, db_request, page):
        params = MultiDict({"q": "foo bar", "o": "-created"})
        if page is not None:
            params["page"] = page
        db_request.params = params

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

        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": [],
            "available_filters": [],
        }
        assert page_cls.calls == [
            pretend.call(sort, 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 suggest.sort.calls == [
            pretend.call("-created")
        ]

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import get [as 别名]
    def test_with_an_ordering(self, monkeypatch, db_request, page, order,
                              expected):
        params = MultiDict({"q": "foo bar"})
        if page is not None:
            params["page"] = page
        if order is not None:
            params["o"] = order
        db_request.params = params

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

        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": [],
            "available_filters": [],
        }
        assert page_cls.calls == [
            pretend.call(
                sort if order is not None else suggest,
                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 suggest.sort.calls == [pretend.call(i) for i in expected]

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import get [as 别名]
    def test_with_a_single_char_query(self, monkeypatch, db_request, page):
        params = MultiDict({"q": "a"})
        if page is not None:
            params["page"] = page
        db_request.params = params

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

        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)

        assert search(db_request) == {
            "page": page_obj,
            "term": params.get("q", ''),
            "order": params.get("o", ''),
            "applied_filters": [],
            "available_filters": [],
        }
        assert page_cls.calls == [
            pretend.call(suggest, 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 db_request.registry.datadog.histogram.calls == [
            pretend.call('warehouse.views.search.results', 1000)
        ]

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import get [as 别名]
class MulticaseParentAction (object):
	def __init__ (self, websocket, params):
		self.websocket = websocket
		self.params = MultiDict(params)

	def handle (self):
		return self.params

	def check_and_process (self):
		if self.websocket not in State.clients_sockets:
			response = error_response('Forbidden')
			response['request_id'] = self.params.get('request_id')
			return response

		response = self.handle()
		if 'request_id' in self.params:
			response['request_id'] = self.params['request_id']

		return response

	# TODO: Move to the State?
	def call_client_action (self, character_id, action_name, params):
		data = json.dumps({'call_action': action_name, 'params': params}, cls = CustomJSONEncoder)
		websocket, _ = State.clients_by_character[character_id] # TODO: Validate if receiver is in the same session with sender
		websocket.send(data)

	def group_call_client_action (self, action_name, params, include_sender = False):
		data = json.dumps({'call_action': action_name, 'params': params}, cls = CustomJSONEncoder)

		character_id = State.clients_sockets[self.websocket]
		_, session_id = State.clients_by_character[character_id]

		for _, websocket in State.clients_by_session[session_id].viewitems():
			if include_sender or (websocket is not self.websocket):
				websocket.send(data)

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import get [as 别名]
    def test_does_not_remove_group_term_from_query_if_group_does_not_exist(
        self, pyramid_request, unparse
    ):
        query = MultiDict({"group": "does_not_exist"})

        check_url(pyramid_request, query, unparse=unparse)

        assert query.get("group") == "does_not_exist"
        assert not unparse.called

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import get [as 别名]
    def test_does_not_remove_group_term_from_query_if_group_does_not_exist(self,
                                                                           pyramid_request,
                                                                           unparse):
        query = MultiDict({'group': 'does_not_exist'})

        check_url(pyramid_request, query, unparse=unparse)

        assert query.get('group') == 'does_not_exist'
        assert not unparse.called

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import get [as 别名]
    def test_does_not_remove_user_term_from_query_if_user_does_not_exist(
        self, pyramid_request, unparse, user_service
    ):
        query = MultiDict({"user": "jose"})
        user_service.fetch.return_value = None

        check_url(pyramid_request, query, unparse=unparse)

        assert query.get("user") == "jose"
        assert not unparse.called

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import get [as 别名]
def application(env, start_response):
    res = None
    path = env['PATH_INFO'].lstrip('/')
    method = env['REQUEST_METHOD']
    args = MultiDict(parse_qsl(env.get('QUERY_STRING', '')))

    parts = path.split('/')
    volume = args.get('volume')
    if not volume:
        volumes = cluster.get_volumes(args['key'])
        for v in volumes:
            if v.node is current_node and v.id in current_node.volumes:
                volume = v.id
                break

    if volume:
        v = current_node.volumes[volume]
        collection = parts[0]
        if method == 'PUT':
            return put_file(env, start_response,
                            v, collection, args['key'])
        elif method == 'GET':
            fname, meta = v.get(collection, args['key'])
            res = Response()
            res.charset = None
            res.headers['X-Sendfile'] = fname
            res.headers['X-Crc'] = str(meta['crc'])
            res.content_length = os.path.getsize(fname)
            if 'ct' in meta:
                res.content_type = meta['ct']
    else:
        collection = parts[0]
        key = args['key']
        v = volumes[0]
        res = HTTPTemporaryRedirect(
            location='http://{}/{}?key={}&volume={}'.format(v.node.id, collection, key, v.id))
        for v in volumes:
            res.headers.add(
                'X-Location',
                'http://{}/{}?key={}&volume={}'.format(v.node.id, collection, key, v.id))

    if not res:
        res = HTTPNotFound()

    return res(env, start_response)

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import get [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 get [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 __nonzero__(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 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)
#.........这里部分代码省略.........

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import get [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 get [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 get [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)
        ]

# 需要导入模块: from webob.multidict import MultiDict [as 别名]
# 或者: from webob.multidict.MultiDict import get [as 别名]
    def GET(self, req):
        """
        Handles listing of in-progress multipart uploads,
        handles list objects request.
        """
        # any operations with multipart buckets are not allowed to user
        check_container_name_no_such_bucket_error(self.container_name)

        if 'uploads' in req.GET:
            return self.get_uploads(req)
        else:
            acl = req.GET.get('acl')
            params = MultiDict([('format', 'json')])
            max_keys = req.GET.get('max-keys')
            if (max_keys is not None and max_keys.isdigit()):
                max_keys = min(int(max_keys), MAX_BUCKET_LISTING)
            else:
                max_keys = MAX_BUCKET_LISTING
            params['limit'] = str(max_keys + 1)
            for param_name in ('marker', 'prefix', 'delimiter'):
                if param_name in req.GET:
                    params[param_name] = req.GET[param_name]

            req.GET.clear()
            req.GET.update(params)

            resp = req.get_response(self.app)
            status = resp.status_int
            body = resp.body

            if status != 200:
                if status == 401:
                    return get_err_response('AccessDenied')
                elif status == 404:
                    return get_err_response('InvalidBucketName')
                else:
                    return get_err_response('InvalidURI')

            if acl is not None:
                return get_acl(self.account_name)

            objects = json.loads(resp.body)
            body = ('<?xml version="1.0" encoding="UTF-8"?>'
                '<ListBucketResult '
                    'xmlns="http://s3.amazonaws.com/doc/2006-03-01/">'
                '<Prefix>%s</Prefix>'
                '<Marker>%s</Marker>'
                '<Delimiter>%s</Delimiter>'
                '<IsTruncated>%s</IsTruncated>'
                '<MaxKeys>%s</MaxKeys>'
                '<Name>%s</Name>'
                '%s'
                '%s'
                '</ListBucketResult>' %
                (
                    xml_escape(params.get('prefix', '')),
                    xml_escape(params.get('marker', '')),
                    xml_escape(params.get('delimiter', '')),
                    'true' if len(objects) == (max_keys + 1) else 'false',
                    max_keys,
                    xml_escape(self.container_name),
                    "".join(['<Contents><Key>%s</Key><LastModified>%sZ</Last'\
                             'Modified><ETag>%s</ETag><Size>%s</Size><Storage'\
                             'Class>STANDARD</StorageClass></Contents>' %
                             (xml_escape(i['name']), i['last_modified'][:-3],
                                                         i['hash'], i['bytes'])
                            for i in objects[:max_keys] if 'subdir' not in i]),
                    "".join(['<CommonPrefixes><Prefix>%s</Prefix></Common'\
                             'Prefixes>' % xml_escape(i['subdir'])
                             for i in objects[:max_keys] if 'subdir' in i])))

            return Response(body=body, content_type='application/xml')