Python MultiDict.update方法代码示例

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
def cheat():
    args = MultiDict()
    args.update(flask.request.form)
    if flask.request.method == "GET":
        args.update(flask.request.args)
    form = CheatForm(args)
    if flask.request.method == "POST" and form.validate():
        user = User.objects.with_id(form.name.data)
        m = False
        if form.item.data and form.quantity.data:
            m = True
            q = user.inventory.get(form.item.data, 0) + form.quantity.data
            user.inventory[form.item.data] = q
            flask.flash("Added {} item{}".format(form.quantity.data, 
                    "s" if form.quantity.data > 1 else ""))
        if form.coin.data:
            m = True
            user.balance += form.coin.data
            flask.flash("Added {} coin{}".format(form.coin.data, 
                    "s" if form.coin.data > 1 else ""))
        if not m:
            flask.flash("No changes made!","error")
        else:
            user.save()
            return flask.redirect(flask.url_for(".single_user", name=user.name))
    return flask.render_template("form.html", form=form)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
def url_for_other_page(page, anchor=None):
    """
    Generates a URL for the same page, with the only difference
    being that a new "page" query string value is updated
    with the provided page number.

    Args:
        page: The new page number to use.
        anchor: The anchor to use in the URL. Optional.

    Returns:
        The URL for the current page with a new page number.
    """
    # Set up our args based on query string arguments
    args = MultiDict(request.args)

    # Now merge in request.view_args to prevent strange query string
    # overrides of these values
    args.update(request.view_args)

    # Explicitly override the page
    args['page'] = page

    # We have to explicitly pass in the anchor here -
    # otherwise, it gets interpreted as a list with a single
    # element, which breaks the URL generation
    # (#['anchor'] versus #anchor)
    if anchor is not None and len(anchor) > 0:
        return url_for(request.endpoint, _anchor=anchor, **args)
    else:
        return url_for(request.endpoint, **args)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
def get_input_from_xml(doc):
    the_input = MultiDict()
    for input_el in xpath_ns(doc, '/wps:Execute/wps:DataInputs/wps:Input'):
        [identifier_el] = xpath_ns(input_el, './ows:Identifier')
        [value_el] = xpath_ns(input_el, './wps:Data/wps:LiteralData')
        the_input.update({identifier_el.text: text_type(value_el.text)})
    return the_input

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
 def identity_data(self):
     identity_data = self._identity_data.copy()
     # if we have data in identity_data, it was converted from a
     # MultiDict so we need to convert it back.
     if 'data' in identity_data:
         tmp = MultiDict()
         tmp.update(self._identity_data['data'])
         identity_data['data'] = tmp
     return identity_data

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
class CardFormTest(FormTests):
    def setUp(self):
        from werkzeug.datastructures import MultiDict

        super(CardFormTest, self).setUp()
        self.Form = self._get_target_class()
        self.required_data = {
            'key': u'CMSIF-199',
            'title': u'You gotta lock that down',
            'backlog_date': u"06/11/2011",
            'category': u'Bug',
            'state': u'Doing',
            'team': u'Team 1',
        }
        self.post_data = MultiDict(self.required_data)

    def _get_target_class(self):
        from kardboard.forms import get_card_form
        return get_card_form(new=True)

    def _test_form(self, post_data):
        f = self.Form(post_data)
        f.validate()
        self.assertEquals(0, len(f.errors))

        card = self._get_card_class()()
        f.populate_obj(card)
        card.save()

        for key, value in self.post_data.items():
            self.assertNotEqual(
                None,
                getattr(card, key, None))

    def test_fields(self):
        self.optional_data = {
            'start_date': u'06/11/2011',
            'done_date': u'06/12/2011',
            'priority': u'2',
        }
        self.post_data.update(self.optional_data)
        self._test_form(self.post_data)

    def test_datetime_coercing(self):
        f = self.Form(self.post_data)
        data = f.backlog_date.data
        self.assertEqual(6, data.month)

    def test_key_uniqueness(self):
        klass = self._get_card_class()
        c = klass(**self.required_data)
        c.backlog_date = datetime.datetime.now()
        c.save()

        f = self.Form(self.post_data)
        f.validate()
        self.assertIn('key', f.errors.keys())

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
    def source(self, request):
        """Pulls values off the request in the provided location
        :param request: The flask request object to parse arguments from
        """
        if isinstance(self.location, six.string_types):
            value = getattr(request, self.location, MultiDict())
            if callable(value):
                value = value()
            if value is not None:
                return value
        else:
            values = MultiDict()
            for l in self.location:
                value = getattr(request, l, None)
                if callable(value):
                    value = value()
                if value is not None:
                    values.update(value)
            return values

        return MultiDict()

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
def url_update_endpoint_args(endpoint, **kwargs):
	"""Like url_for by using current URL for unspecified parameters.

	Return the URL for passed endpoint using args from current request and kwargs.
	"""
	# request.args contains parameters from the query string
	# request.view_args contains parameters that matched the view signature
	args = MultiDict(request.args)
	args.update(request.view_args)
	for arg, value in kwargs.items():
		if isinstance(value, Iterable) and not isinstance(value, str):
			args.setlist(arg, value)
		else:
			args[arg] = value
	# Now set any individual args to the object instead of a list of len 1
	# TODO Issue #4
	#  this is broken if it supposed to be a list of Iterables (e.g. strings)
	args = args.to_dict(flat=False)
	for key in set(args.keys()):
		values = args[key]
		if len(values) == 1:
			args[key] = values[0]
	return url_for(endpoint, **args)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
def get_input_from_xml(doc):
    the_input = MultiDict()
    for input_el in xpath_ns(doc, '/wps:Execute/wps:DataInputs/wps:Input'):
        [identifier_el] = xpath_ns(input_el, './ows:Identifier')

        literal_data = xpath_ns(input_el, './wps:Data/wps:LiteralData')
        if literal_data:
            value_el = literal_data[0]
            the_input.update({identifier_el.text: text_type(value_el.text)})
            continue

        complex_data = xpath_ns(input_el, './wps:Data/wps:ComplexData')
        if complex_data:
            complex_data_el = complex_data[0]
            value_el = complex_data_el[0]
            tmp = StringIO(lxml.etree.tounicode(value_el))
            tmp.mime_type = complex_data_el.attrib.get('mimeType')
            the_input.update({identifier_el.text: tmp})
            continue

        # TODO bounding box data

    return the_input

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
    def _update_prefs(self):
        """update prefs"""
        args = self.parser.parse_args()
        sess = session._get_current_object()
        ret = {}
        req = MultiDict()
        for loc in ['values', 'json']:
            data = getattr(request, loc, None)
            if data:
                req.update(data)
        for key in args.keys():
            if key not in req:
                continue
            temp = args.get(key)
            if temp:
                if key == 'language':
                    self._user_language(temp)
                sess[key] = temp
            elif key in sess:  # pragma: no cover
                del sess[key]
            ret[key] = temp
            self._store_prefs(key, temp)

        return ret

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
    def handle_request_stage1(self, *a, **kw):
        "Build an injector instance to handle the current request."
        req_plan = self.injector_plan_class()
        url, method, session_uid = self.prepare_request(req_plan, *a, **kw)
        req_plan.value('url', url)
        req_plan.value('method', method)
        req_plan.value('session_uid', session_uid)

        parsed = urlparse(url)
        root_url = urlunparse((parsed[0], parsed[1], '', '', '', ''))
        req_plan.value('root_url', root_url)

        endpoint, fn, arguments = self.match(parsed.path, method)
        req_plan.value('endpoint', endpoint)

        if parsed.query:
            args = MultiDict()
            args.update(arguments)
            args.update(parse_qsl(parsed.query))
        else:
            args = arguments
        req_plan.provider('arg', self.build_dict_provider(args))
        req_plan.provider('args',
            self.build_multi_dict_provider(args, require_key=False))

        plan = self.fn_to_plan_map[fn]
        class RequestInjector(self.plan_to_injector_class_map[plan]):
            "Injector namespace for the current request."
        injector_class = \
            self.apply_injector_registration(RequestInjector, req_plan)

        with injector_class() as i:
            rsp = self.try_handler(i, self.handle_request_stage2, i, fn, plan)
            if rsp is None:
                raise ValueError('Response is None.')
            return rsp

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
 def search(self, parameters: MultiDict=None, **kwargs) -> SearchResponse:
     parameters.update(kwargs)
     response = self._search_request.get(parameters)
     logger.info('Antidot SEARCH Response: {}'.format(json.dumps(response.get_raw())))  # nopep8
     return response

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
def parse_message(form):
    message = form.get_message()
    submission = None
    had_errors = False
    (prefix, participant_id, form_type, responses, comment) = parse_text(
        message['text'])
    if (prefix and participant_id and form_type and responses):
        form_doc = retrieve_form(prefix, form_type)
        if form_doc:
            form_data = MultiDict(
                {'form': form_doc.pk, 'participant': participant_id,
                 'sender': message['sender'], 'comment': comment})
            form_data.update(parse_responses(responses, form_doc.form_type))
            questionnaire = build_questionnaire(form_doc, form_data)

            if questionnaire.validate():
                submission = questionnaire.save()
                return (
                    _('Thank you! Your report was received!'
                      ' You sent: {text}')
                    .format(text=message.get('text', '')),
                    submission,
                    had_errors
                )
            else:
                had_errors = True
                if 'participant' in questionnaire.errors:
                    return (
                        _('Observer ID not found. Please resend with valid '
                          'Observer ID. You sent: {text}')
                        .format(text=message.get('text', '')),
                        submission,
                        had_errors
                    )
                elif '__all__' in questionnaire.errors:
                    # Save any valid data
                    submission = questionnaire.save()
                    return (
                        _('Unknown question codes: "{questions}". '
                          'You sent: {text}')
                        .format(questions=', '.join(
                                sorted([
                                    q for q in questionnaire.errors['__all__']
                                ])),
                                text=message.get('text', '')),
                        submission,
                        had_errors
                    )
                else:
                    # Save any valid data
                    submission = questionnaire.save()
                    return (
                        _('Invalid response(s) for question(s):'
                          ' "{questions}". You sent: {text}')
                        .format(
                            questions=', '.join(sorted(
                                questionnaire.errors.keys())),
                            text=message.get('text', '')),
                        submission,
                        had_errors
                    )
    had_errors = True
    return (
        _('Invalid message: "{text}". Please check and resend!').format(
            text=message.get('text', '')),
        submission,
        had_errors
    )

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
from werkzeug.datastructures import MultiDict

post = MultiDict()
post.add("foo", "ham")

get = MultiDict()
get.add("lorem", "issue")

post.update(get)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
 def data(self):
     data = MultiDict()
     data.update(self._data)
     return data

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import update [as 别名]
 def acp(self, parameters: MultiDict=None, **kwargs) -> ACPResponse:
     parameters.update(kwargs)
     response = self._acp_request.get(parameters)
     logger.info('Antidot ACP Response: {}'.format(json.dumps(response.get_raw())))  # nopep8
     return response