Python MultiDict.getlist方法代码示例

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import getlist [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 getlist [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 getlist [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 getlist [as 别名]
def peek_query(args):
    if not isinstance(args, MultiDict):
        args = MultiDict(args)
    text = args.get('q', '').strip()
    q = text_query(text)

    filters = parse_filters(args)
    for entity in args.getlist('entity'):
        filters.append(('entities.id', entity))

    q = filter_query(q, filters, [])
    q = add_filter(q, {
        'not': {
            'terms': {
                'collection_id': authz.collections(authz.READ)
            }
        }
    })
    q = {
        'query': q,
        'size': 0,
        'aggregations': {
            'collections': {
                'terms': {'field': 'collection_id', 'size': 30}
            }
        },
        '_source': False
    }
    # import json
    # print json.dumps(q, indent=2)
    result = get_es().search(index=get_es_index(), body=q,
                             doc_type=TYPE_DOCUMENT)

    aggs = result.get('aggregations', {}).get('collections', {})
    buckets = aggs.get('buckets', [])
    q = Collection.all_by_ids([b['key'] for b in buckets])
    q = q.filter(Collection.creator_id != None)  # noqa
    objs = {o.id: o for o in q.all()}
    roles = {}
    for bucket in buckets:
        collection = objs.get(bucket.get('key'))
        if collection is None or collection.private:
            continue
        if collection.creator_id in roles:
            roles[collection.creator_id]['total'] += bucket.get('doc_count')
        else:
            roles[collection.creator_id] = {
                'name': collection.creator.name,
                'email': collection.creator.email,
                'total': bucket.get('doc_count')
            }

    roles = sorted(roles.values(), key=lambda r: r['total'], reverse=True)
    roles = [format_total(r) for r in roles]
    total = result.get('hits', {}).get('total')
    return format_total({
        'roles': roles,
        'active': total > 0,
        'total': total
    })

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

    # 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']

    filters = parse_filters(args)
    for entity in args.getlist('entity'):
        filters.append(('entities.id', entity))

    aggs = {'scoped': {'global': {}, 'aggs': {}}}
    if facets:
        facets = args.getlist('facet')
        if 'collections' in facets:
            aggs = facet_collections(q, aggs, filters)
            facets.remove('collections')
        if 'entities' in facets:
            aggs = facet_entities(aggs, args)
            facets.remove('entities')
        aggs = aggregate(q, aggs, facets)

    signals.document_query_process.send(q=q, args=args)
    return {
        'sort': sort,
        'query': filter_query(q, filters, OR_FIELDS),
        'aggregations': aggs,
        '_source': fields or DEFAULT_FIELDS
    }

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import getlist [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 getlist [as 别名]
def _normalize_networks(provider, networks):
    _provider = {"provider": provider, "networks": []}
    for netw, stats in groupby(networks, lambda r: r["network_code"]):
        _network = MultiDict()

        for s in stats:
            _network.add(netw, {"type": s["type"], "count": s["count"]})

        _provider["networks"].append({
            "network": netw, "stats": _network.getlist(netw)
            })
    return _provider

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import getlist [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 getlist [as 别名]
    def args(self):
        if PY2:
            args_items = request.args.iteritems(multi=True)
        else:
            args_items = request.args.items(multi=True)

        args = MultiDict(list(args_items) + list(request.view_args.items()))
        args.pop('page', None)
        # flat dict if non-multi values used
        for k in args:
            if len(args.getlist(k)) > 1:
                return args

        return args.to_dict()

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import getlist [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 getlist [as 别名]
def entities_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()
    if text is None or not len(text):
        q = match_all()
    else:
        q = {
            "query_string": {
                "query": text,
                "fields": ['name^15', 'name_latin^5',
                           'terms^12', 'terms_latin^3',
                           'summary^10', 'summary_latin^7',
                           'description^5', 'description_latin^3'],
                "default_operator": "AND",
                "use_dis_max": True
            }
        }

    q = authz_filter(q)
    filters = parse_filters(args)
    aggs = {'scoped': {'global': {}, 'aggs': {}}}
    if facets:
        facets = args.getlist('facet')
        if 'collections' in facets:
            aggs = facet_collections(q, aggs, filters)
            facets.remove('collections')
        aggs = aggregate(q, aggs, facets)

    sort_mode = args.get('sort', '').strip().lower()
    default_sort = 'score' if len(text) else 'doc_count'
    sort_mode = sort_mode or default_sort
    if sort_mode == 'doc_count':
        sort = [{'doc_count': 'desc'}, '_score']
    elif sort_mode == 'alphabet':
        sort = [{'name': 'asc'}, '_score']
    elif sort_mode == 'score':
        sort = ['_score']

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

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import getlist [as 别名]
    def _produce_candidate_bars(self):
        blocked_rooms_by_room = MultiDict((br.room_id, br) for br in self.blocked_rooms)

        for room in self.rooms:
            blocked_rooms = blocked_rooms_by_room.getlist(room.id)
            for (start_dt, end_dt), candidates in self.candidates.iteritems():
                # Check if there's a blocking
                for blocked_room in blocked_rooms:
                    blocking = blocked_room.blocking
                    if overlaps((start_dt.date(), end_dt.date()), (blocking.start_date, blocking.end_date),
                                inclusive=True):
                        break
                else:
                    # In case we didn't break the loop due to a match
                    blocking = None
                for cand in candidates:
                    bar = Bar.from_candidate(cand, room.id, start_dt, end_dt, blocking)
                    self.bars.append(bar)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import getlist [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 getlist [as 别名]
    def from_params(params: MultiDict, customers=None, query_time=None):

        # q
        if params.get('q', None):
            try:
                parser = QueryParser()
                query = [parser.parse(
                    query=params['q'],
                    default_field=params.get('q.df')
                )]
                qvars = dict()  # type: Dict[str, Any]
            except ParseException as e:
                raise ApiError('Failed to parse query string.', 400, [e])
        else:
            query = ['1=1']
            qvars = dict()

        # customer
        if customers:
            query.append('AND customer=ANY(%(customers)s)')
            qvars['customers'] = customers

        # from-date, to-date
        from_date = params.get('from-date', default=None, type=DateTime.parse)
        to_date = params.get('to-date', default=query_time, type=DateTime.parse)

        if from_date:
            query.append('AND last_receive_time > %(from_date)s')
            qvars['from_date'] = from_date.replace(tzinfo=pytz.utc)
        if to_date:
            query.append('AND last_receive_time <= %(to_date)s')
            qvars['to_date'] = to_date.replace(tzinfo=pytz.utc)

        # duplicateCount, repeat
        if params.get('duplicateCount', None):
            query.append('AND duplicate_count=%(duplicate_count)s')
            qvars['duplicate_count'] = params.get('duplicateCount', int)
        if params.get('repeat', None):
            query.append('AND repeat=%(repeat)s')
            qvars['repeat'] = params.get('repeat', default=True, type=lambda x: x.lower()
                                         in ['true', 't', '1', 'yes', 'y', 'on'])

        def reverse_sort(direction):
            return 'ASC' if direction == 'DESC' else 'DESC'

        # sort-by
        sort = list()
        direction = 'ASC'
        if params.get('reverse', None):
            direction = 'DESC'
        if params.get('sort-by', None):
            for sort_by in params.getlist('sort-by'):
                if sort_by == 'createTime':
                    sort.append('create_time ' + reverse_sort(direction))
                elif sort_by == 'receiveTime':
                    sort.append('receive_time ' + reverse_sort(direction))
                elif sort_by == 'lastReceiveTime':
                    sort.append('last_receive_time ' + reverse_sort(direction))
                elif sort_by == 'duplicateCount':
                    sort.append('duplicate_count ' + direction)
                else:
                    sort.append(sort_by + ' ' + direction)
        else:
            sort.append('last_receive_time ' + reverse_sort(direction))

        # group-by
        group = params.getlist('group-by')

        # id
        ids = params.getlist('id')
        if len(ids) == 1:
            query.append('AND (id LIKE %(id)s OR last_receive_id LIKE %(id)s)')
            qvars['id'] = ids[0] + '%'
        elif ids:
            query.append('AND (id ~* (%(regex_id)s) OR last_receive_id ~* (%(regex_id)s))')
            qvars['regex_id'] = '|'.join(['^' + i for i in ids])

        EXCLUDE_QUERY = ['_', 'callback', 'token', 'api-key', 'q', 'q.df', 'id',
                         'from-date', 'to-date', 'duplicateCount', 'repeat', 'sort-by',
                         'reverse', 'group-by', 'page', 'page-size', 'limit']

        # fields
        for field in params:
            if field in EXCLUDE_QUERY:
                continue
            value = params.getlist(field)
            if field in ['service', 'tags', 'roles', 'scopes']:
                query.append('AND {0} && %({0})s'.format(field))
                qvars[field] = value
            elif field.startswith('attributes.'):
                field = field.replace('attributes.', '')
                query.append('AND attributes @> %(attr_{})s'.format(field))
                qvars['attr_' + field] = {field: value[0]}
            elif len(value) == 1:
                value = value[0]
                if field.endswith('!'):
                    if value.startswith('~'):
                        query.append('AND NOT "{0}" ILIKE %(not_{0})s'.format(field[:-1]))
                        qvars['not_' + field[:-1]] = '%' + value[1:] + '%'
                    else:
#.........这里部分代码省略.........

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import getlist [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
#.........这里部分代码省略.........