Python MultiDict.keys方法代码示例

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [as 别名]
    def get_form(self, formdata=None, load_draft=True,
                 validate_draft=False):
        """
        Create form instance with draft data and form data if provided.

        :param formdata: Incoming form data.
        :param files: Files to ingest into form
        :param load_draft: True to initialize form with draft data.
        :param validate_draft: Set to true to validate draft data, when no form
             data is provided.
        """
        if not self.has_form():
            raise FormDoesNotExists(self.id)

        draft_data = unicodifier(self.values) if load_draft else {}
        formdata = MultiDict(formdata or {})

        form = self.form_class(
            formdata=formdata, **draft_data
        )

        if formdata:
            form.reset_field_data(exclude=formdata.keys())

        # Set field flags
        if load_draft and self.flags:
            form.set_flags(self.flags)

        if validate_draft and draft_data and formdata is None:
            form.validate()

        return form

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [as 别名]
    def _compute_dependency_order(skills):
        """
        Add a field to each skill indicating the order it was learned
        based on the skill's dependencies. Multiple skills will have the same
        position if they have the same dependencies.
        """
        # Key skills by first dependency. Dependency sets can be uniquely
        # identified by one dependency in the set.
        dependency_to_skill = MultiDict(
            [(skill["dependencies_name"][0] if skill["dependencies_name"] else "", skill) for skill in skills]
        )

        # Start with the first skill and trace the dependency graph through
        # skill, setting the order it was learned in.
        index = 0
        previous_skill = ""
        while True:
            for skill in dependency_to_skill.getlist(previous_skill):
                skill["dependency_order"] = index
            index += 1

            # Figure out the canonical dependency for the next set of skills.
            skill_names = set([skill["name"] for skill in dependency_to_skill.getlist(previous_skill)])
            canonical_dependency = skill_names.intersection(set(dependency_to_skill.keys()))
            if canonical_dependency:
                previous_skill = canonical_dependency.pop()
            else:
                # Nothing depends on these skills, so we're done.
                break

        return skills

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [as 别名]
def _parse_filter_args(filter_dict):
    if not isinstance(filter_dict, MultiDict):
        filter_dict = MultiDict(filter_dict)

    return MultiDict(
        (key, (",".join(filter_dict.getlist(key))).split(","))
        for key in filter_dict.keys()
        if "".join(filter_dict.getlist(key))
    )

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [as 别名]
def documents_query(args, fields=None, facets=True, newer_than=None):
    """Parse a user query string, compose and execute a query."""
    if not isinstance(args, MultiDict):
        args = MultiDict(args)
    text = args.get('q', '').strip()
    q = text_query(text)
    q = authz_filter(q)

    if newer_than is not None:
        q = add_filter(q, {
            "range": {
                "created_at": {
                    "gt": newer_than
                }
            }
        })

    # Sorting -- should this be passed into search directly, instead of
    # these aliases?
    sort_mode = args.get('sort', '').strip().lower()
    if text or sort_mode == 'score':
        sort = ['_score']
    elif sort_mode == 'newest':
        sort = [{'dates': 'desc'}, {'created_at': 'desc'}, '_score']
    elif sort_mode == 'oldest':
        sort = [{'dates': 'asc'}, {'created_at': 'asc'}, '_score']
    else:
        sort = [{'updated_at': 'desc'}, {'created_at': 'desc'}, '_score']

    # Extract filters, given in the form: &filter:foo_field=bla_value
    filters = []
    for key in args.keys():
        for value in args.getlist(key):
            if not key.startswith('filter:'):
                continue
            _, field = key.split(':', 1)
            filters.append((field, value))

    for entity in args.getlist('entity'):
        filters.append(('entities.uuid', entity))

    aggs = {}
    if facets:
        aggs = aggregate(q, args, filters)
        aggs = facet_source(q, aggs, filters)
        q = entity_collections(q, aggs, args, filters)

    return {
        'sort': sort,
        'query': filter_query(q, filters),
        'aggregations': aggs,
        '_source': fields or DEFAULT_FIELDS
    }

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [as 别名]
def make_grouping(flatlist):
    """
    Gets a grouped list of items from the provided flat list.
    Each item will be grouped by its "grouping" property (as identified by
    "grouping_id") and then sorted by name.

    Items without a group will go in at the top. After that,
    the groups will be sorted by "grouporder" and then by "name" and
    the items within them will be sorted by name.

    The returned result will start with ID/name tuples of any
    top-level items, and then follow with group tuples,
    which consist of a name and a list of the equivalent
    ID/name tuples within that group.

    Args:
        flatlist: The flat list of items to group.

    Returns:
        A grouped list of items.
    """

    # Set up our group dictionary and list of top items
    groups_dict = MultiDict()
    top_items = []

    # Classify each item appropriately
    for item in flatlist:
        if item.grouping_id is None:
            top_items.append(item)
        else:
            groups_dict.add(item.grouping, item)

    # Kickstart our grouped result with the top-level options.
    grouped_result = get_sorted_options(top_items)

    # Get the groups in the MultiDict - first sorted by name (innermost)
    # and finally by grouporder (outermost)
    sorted_groups = sorted(
        sorted(groups_dict.keys(), key=attrgetter('name')),
        key=attrgetter('grouporder'))

    for grouping in sorted_groups:
        # Convert the group to a tuple - the first item
        # is the group name and the second is the equivalent
        # options in that group.
        grouped_result.append((
            grouping.name,
            get_sorted_options(groups_dict.getlist(grouping))))

    return grouped_result

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [as 别名]
    def autosave_post(self, obj=None):
        """
        Handles autosave POST requests
        """
        obj = obj if obj is not None else self.obj
        if 'form.revision' not in request.form:
            # as form.autosave is true, the form should have `form.revision` field even if it's empty
            return {'status': 'error', 'error_identifier': 'form_missing_revision_field', 'error_description': _("Form must contain a revision ID.")}, 400

        # CSRF check
        if forms.Form().validate_on_submit():
            incoming_data = MultiDict(request.form.items(multi=True))
            client_revision = incoming_data.pop('form.revision')
            incoming_data.pop('csrf_token', None)

            # find the last draft
            draft = self.get_draft(obj)

            if draft is not None:
                if client_revision is None or (client_revision is not None and str(draft.revision) != client_revision):
                    # draft exists, but the form did not send a revision ID,
                    # OR revision ID sent by client does not match the last revision ID
                    return {'status': 'error', 'error_identifier': 'missing_or_invalid_revision', 'error_description': _("There have been changes to this draft since you last edited it. Please reload.")}, 400
                elif client_revision is not None and str(draft.revision) == client_revision:
                    # revision ID sent my client matches, save updated draft data and update revision ID
                    existing = draft.formdata
                    for key in incoming_data.keys():
                        if existing[key] != incoming_data[key]:
                            existing[key] = incoming_data[key]
                    draft.formdata = existing
                    draft.revision = uuid4()
            elif draft is None and client_revision:
                # The form contains a revision ID but no draft exists.
                # Somebody is making autosave requests with an invalid draft ID.
                return {'status': 'error', 'error_identifier': 'invalid_or_expired_revision', 'error_description': _("Invalid revision ID or the existing changes have been submitted already. Please reload.")}, 400
            else:
                # no draft exists, create one
                draft = Draft(
                    table=Project.__tablename__, table_row_id=obj.uuid,
                    formdata=incoming_data, revision=uuid4()
                    )
            db.session.add(draft)
            db.session.commit()
            return {'revision': draft.revision}
        else:
            return {'status': 'error', 'error_identifier': 'invalid_csrf', 'error_description': _("Invalid CSRF token")}, 400

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [as 别名]
def validate():
    """Validate form and return validation errors."""
    if request.method != 'POST':
        abort(400)
    data = request.json or MultiDict({})
    formdata = MultiDict(data or {})
    form = AuthorUpdateForm(formdata=formdata)
    form.validate()

    result = {}
    changed_msgs = dict(
        (name, messages) for name, messages in form.messages.items()
        if name in formdata.keys()
    )
    result['messages'] = changed_msgs

    return jsonify(result)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [as 别名]
def extract_query(q):
    """Remove parts of the query which do not affect the result set."""
    q = MultiDict(q)
    cleaned = MultiDict()
    for key in q.keys():
        values = q.getlist(key)
        if key == 'q':
            values = [v.strip() for v in values]
        if key.startswith('filter:') or key in ['entity', 'q']:
            for val in values:
                if not isinstance(val, (list, tuple, set)):
                    val = [val]
                for v in val:
                    if v is None:
                        continue
                    v = unicode(v).lower()
                    if len(v):
                        cleaned.add(key, v)
    return cleaned

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [as 别名]
def query(args):
    """ Parse a user query string, compose and execute a query. """
    if not isinstance(args, MultiDict):
        args = MultiDict(args)
    q = text_query(args.get('q', ''))
    q = authz_filter(q)

    # Extract filters, given in the form: &filter:foo_field=bla_value
    filters = []
    for key in args.keys():
        for value in args.getlist(key):
            if not key.startswith('filter:'):
                continue
            _, field = key.split(':', 1)
            filters.append((field, value))

    facets = args.getlist('facet')
    aggs = aggregate(q, facets, filters)

    sort = ['_score']
    if args.get('sort') == 'linkcount':
        sort.insert(0, {'$linkcount': 'desc'})

    q = {
        'sort': sort,
        'query': filter_query(q, filters),
        'aggregations': aggs,
        '_source': DEFAULT_FIELDS
    }

    if args.get('hl'):
        q["highlight"] = {
            "pre_tags": ["<em>"],
            "post_tags": ["</em>"],
            "fields": {
                "$text": {}
            }
        }

    q = paginate(q, args.get('limit'), args.get('offset'))
    return execute_query(args, q, facets)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [as 别名]
def validate():
    """Validate form and return validation errors.

    FIXME: move to forms module as a generic /validate where we can pass
    the for class to validate.
    """
    if request.method != 'POST':
        abort(400)
    data = request.json or MultiDict({})
    formdata = MultiDict(data or {})
    form = LiteratureForm(formdata=formdata)
    form.validate()

    result = {}
    changed_msgs = dict(
        (name, messages) for name, messages in form.messages.items()
        if name in formdata.keys()
    )
    result['messages'] = changed_msgs

    return jsonify(result)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [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 keys [as 别名]
def validate():
    """Validate form and return validation errors.

    FIXME: move to forms module as a generic /validate where we can pass
    the for class to validate.
    """
    if request.method != 'POST':
        abort(400)

    is_update = True if request.args.get('is_update') == 'True' else False
    data = request.json or MultiDict({})
    formdata = MultiDict(data or {})
    form = AuthorUpdateForm(formdata=formdata, is_update=is_update)
    form.validate()

    result = {}
    changed_msgs = dict(
        (name, messages) for name, messages in form.messages.items()
        if name in formdata.keys()
    )
    result['messages'] = changed_msgs

    return jsonify(result)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [as 别名]
def documents_query(args, fields=None, facets=True):
    """ Parse a user query string, compose and execute a query. """
    if not isinstance(args, MultiDict):
        args = MultiDict(args)
    text = args.get('q', '').strip()
    q = text_query(text)
    q = authz_filter(q)

    if text:
        sort = ['_score']
    else:
        sort = [{'updated_at': 'desc'}, {'created_at': 'desc'}, '_score']

    # Extract filters, given in the form: &filter:foo_field=bla_value
    filters = []
    for key in args.keys():
        for value in args.getlist(key):
            if not key.startswith('filter:'):
                continue
            _, field = key.split(':', 1)
            filters.append((field, value))

    for entity in args.getlist('entity'):
        filters.append(('entities.entity_id', entity))

    aggs = {}
    if facets:
        aggs = aggregate(q, args, filters)
        aggs = facet_source(q, aggs, filters)
        q = entity_watchlists(q, aggs, args, filters)

    return {
        'sort': sort,
        'query': filter_query(q, filters),
        'aggregations': aggs,
        '_source': fields or DEFAULT_FIELDS
    }

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [as 别名]
def test_multidict():
    """Multidict behavior"""
    md = MultiDict()
    assert isinstance(md, dict)

    mapping = [('a', 1), ('b', 2), ('a', 2), ('d', 3),
               ('a', 1), ('a', 3), ('d', 4), ('c', 3)]
    md = MultiDict(mapping)

    # simple getitem gives the first value
    assert md['a'] == 1
    assert md['c'] == 3
    assert_raises(KeyError, lambda: md['e'])
    assert md.get('a') == 1

    # list getitem
    assert md.getlist('a') == [1, 2, 1, 3]
    assert md.getlist('d') == [3, 4]
    # do not raise if key not found
    assert md.getlist('x') == []

    # simple setitem overwrites all values
    md['a'] = 42
    assert md.getlist('a') == [42]

    # list setitem
    md.setlist('a', [1, 2, 3])
    assert md['a'] == 1
    assert md.getlist('a') == [1, 2, 3]

    # verify that it does not change original lists
    l1 = [1, 2, 3]
    md.setlist('a', l1)
    del l1[:]
    assert md['a'] == 1

    # setdefault, setlistdefault
    assert md.setdefault('u', 23) == 23
    assert md.getlist('u') == [23]
    del md['u']

    assert md.setlistdefault('u', [-1, -2]) == [-1, -2]
    assert md.getlist('u') == [-1, -2]
    assert md['u'] == -1

    # delitem
    del md['u']
    assert_raises(KeyError, lambda: md['u'])
    del md['d']
    assert md.getlist('d') == []

    # keys, values, items, lists
    assert list(sorted(md.keys())) == ['a', 'b', 'c']
    assert list(sorted(md.iterkeys())) == ['a', 'b', 'c']

    assert list(sorted(md.values())) == [1, 2, 3]
    assert list(sorted(md.itervalues())) == [1, 2, 3]

    assert list(sorted(md.items())) == [('a', 1), ('b', 2), ('c', 3)]
    assert list(sorted(md.items(multi=True))) == \
           [('a', 1), ('a', 2), ('a', 3), ('b', 2), ('c', 3)]
    assert list(sorted(md.iteritems())) == [('a', 1), ('b', 2), ('c', 3)]
    assert list(sorted(md.iteritems(multi=True))) == \
           [('a', 1), ('a', 2), ('a', 3), ('b', 2), ('c', 3)]

    assert list(sorted(md.lists())) == [('a', [1, 2, 3]), ('b', [2]), ('c', [3])]
    assert list(sorted(md.iterlists())) == [('a', [1, 2, 3]), ('b', [2]), ('c', [3])]

    # copy method
    copy = md.copy()
    assert copy['a'] == 1
    assert copy.getlist('a') == [1, 2, 3]

    # update with a multidict
    od = MultiDict([('a', 4), ('a', 5), ('y', 0)])
    md.update(od)
    assert md.getlist('a') == [1, 2, 3, 4, 5]
    assert md.getlist('y') == [0]

    # update with a regular dict
    md = copy
    od = {'a': 4, 'y': 0}
    md.update(od)
    assert md.getlist('a') == [1, 2, 3, 4]
    assert md.getlist('y') == [0]

    # pop, poplist, popitem, popitemlist
    assert md.pop('y') == 0
    assert 'y' not in md
    assert md.poplist('a') == [1, 2, 3, 4]
    assert 'a' not in md
    assert md.poplist('missing') == []

    # remaining: b=2, c=3
    popped = md.popitem()
    assert popped in [('b', 2), ('c', 3)]
    popped = md.popitemlist()
    assert popped in [('b', [2]), ('c', [3])]

    # type conversion
#.........这里部分代码省略.........

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import keys [as 别名]
def test_multidict():
    """Multidict behavior"""
    md = MultiDict()
    assert isinstance(md, dict)

    mapping = [('a', 1), ('b', 2), ('a', 2), ('d', 3),
               ('a', 1), ('a', 3), ('d', 4), ('c', 3)]
    md = MultiDict(mapping)

    # simple getitem gives the first value
    assert md['a'] == 1
    assert md['c'] == 3
    assert_raises(KeyError, lambda: md['e'])
    assert md.get('a') == 1

    # list getitem
    assert md.getlist('a') == [1, 2, 1, 3]
    assert md.getlist('d') == [3, 4]
    # do not raise if key not found
    assert md.getlist('x') == []

    # simple setitem overwrites all values
    md['a'] = 42
    assert md.getlist('a') == [42]

    # list setitem
    md.setlist('a', [1, 2, 3])
    assert md['a'] == 1
    assert md.getlist('a') == [1, 2, 3]

    # verify that it does not change original lists
    l1 = [1, 2, 3]
    md.setlist('a', l1)
    del l1[:]
    assert md['a'] == 1

    # setdefault, setlistdefault
    assert md.setdefault('u', 23) == 23
    assert md.getlist('u') == [23]
    del md['u']

    assert md.setlistdefault('u', [-1, -2]) == [-1, -2]
    assert md.getlist('u') == [-1, -2]
    assert md['u'] == -1

    # delitem
    del md['u']
    assert_raises(KeyError, lambda: md['u'])
    del md['d']
    assert md.getlist('d') == []

    # keys, values, items, lists
    assert list(sorted(md.keys())) == ['a', 'b', 'c']
    assert list(sorted(md.iterkeys())) == ['a', 'b', 'c']

    assert list(sorted(md.values())) == [1, 2, 3]
    assert list(sorted(md.itervalues())) == [1, 2, 3]

    assert list(sorted(md.items())) == [('a', 1), ('b', 2), ('c', 3)]
    assert list(sorted(md.items(multi=True))) == \
           [('a', 1), ('a', 2), ('a', 3), ('b', 2), ('c', 3)]
    assert list(sorted(md.iteritems())) == [('a', 1), ('b', 2), ('c', 3)]
    assert list(sorted(md.iteritems(multi=True))) == \
           [('a', 1), ('a', 2), ('a', 3), ('b', 2), ('c', 3)]

    assert list(sorted(md.lists())) == [('a', [1, 2, 3]), ('b', [2]), ('c', [3])]
    assert list(sorted(md.iterlists())) == [('a', [1, 2, 3]), ('b', [2]), ('c', [3])]

    # copy method
    copy = md.copy()
    assert copy['a'] == 1
    assert copy.getlist('a') == [1, 2, 3]

    # update with a multidict
    od = MultiDict([('a', 4), ('a', 5), ('y', 0)])
    md.update(od)
    assert md.getlist('a') == [1, 2, 3, 4, 5]
    assert md.getlist('y') == [0]

    # update with a regular dict
    md = copy
    od = {'a': 4, 'y': 0}
    md.update(od)
    assert md.getlist('a') == [1, 2, 3, 4]
    assert md.getlist('y') == [0]

    # pop, poplist, popitem, popitemlist
    assert md.pop('y') == 0
    assert 'y' not in md
    assert md.poplist('a') == [1, 2, 3, 4]
    assert 'a' not in md
    assert md.poplist('missing') == []

    # remaining: b=2, c=3
    popped = md.popitem()
    assert popped in [('b', 2), ('c', 3)]
    popped = md.popitemlist()
    assert popped in [('b', [2]), ('c', [3])]

    # type conversion
#.........这里部分代码省略.........