Returns a list of tuples [(FILTER, value),(...,...),....]
482276
def get_filters_values(self):
        
        return [(flt, value) for flt, value in zip(self.filters, self.values)]
487110
def tuple(self):
        
        return (self.value, {dv.id: dv.value for dv in self.dimensionvalues})
930432
def get_all(self):
        # type: () -> typing.Iterable[typing.Tuple[str, str]]
        
        for name, values in six.iteritems(self._as_list):
            for value in values:
                yield (name, value)
103494
def _build_filter_list(self, filters):
        
        i = 0
        for (filter_type, values) in filters.items():
            if isinstance(values[0], str):
                for line in values[0].split('\n'):
                    line = line.strip()
                    yield "{filter_name} {filter_type} {filter_value}".format(
                        filter_name="filter" + str(i),
                        filter_type=filter_type,
                        filter_value='"{}" {}'.format(line, " ".join([str(v) for v in values[1:]]))).strip()
                    i += 1
            else:
                yield "{filter_name} {filter_type} {filter_value}".format(
                    filter_name="filter" + str(i),
                    filter_type=filter_type,
                    filter_value=" ".join([str(v) for v in values]))
                i += 1
677718
def filters(self):
        
        params = {}
        for _filter in self._filters:
            params.update(_filter)

        return params
42419
def items(self):
        ""
        return list(zip(list(self.keys()), list(self.values())))
114817
def _items(self, type_filter=None, name=None):
        

        if name:
            if type_filter and self._key_attr == 'type':
                if name in type_filter and name in self:
                    yield name, self[name]
            elif name in self:
                yield name, self[name]

        elif type_filter and self._key_attr == 'type':
            for key, val in self.items():
                if key in type_filter:
                    yield key, val
        else:
            for key, val in self.items():
                yield key, val
22496
def getAllTriples(self):
        
        return [(str(s), str(p), str(o)) for s, p, o in self]
410819
def ver_to_tuple(value):
    
    return tuple(int(_f) for _f in re.split(r'\D+', value) if _f)
338967
function (filters, tpl) {
      for (var i = 0; i < filters.length; ++i) {
        tpl = filters[i](tpl)
      }
      return tpl
    }
1249031
def _build_filters(_filters):
    
    root = utils.NestedDict({})
    for _filter in _filters:
        operation = None
        for operation, token in SPLIT_TOKENS:
            # split "some.key=value" into ["some.key", "value"]
            top_parts = _filter.split(token, 1)
            if len(top_parts) == 2:
                break
        else:
            raise exceptions.CLIAbort('Failed to find valid operation for: %s'
                                      % _filter)

        key, value = top_parts
        current = root
        # split "some.key" into ["some", "key"]
        parts = [part.strip() for part in key.split('.')]

        # Actually drill down and add the filter
        for part in parts[:-1]:
            current = current[part]

        if operation == 'eq':
            current[parts[-1]] = utils.query_filter(value.strip())
        elif operation == 'in':
            current[parts[-1]] = {
                'operation': 'in',
                'options': [{
                    'name': 'data',
                    'value': [p.strip() for p in value.split(',')],
                }],
            }

    return root.to_dict()
1370111
def get_attr_filters(self):
        
        for f in self.data.keys():
            if f not in self.multi_attrs:
                continue
            fv = self.data[f]
            if isinstance(fv, dict):
                fv['key'] = f
            else:
                fv = {f: fv}
            vf = ValueFilter(fv)
            vf.annotate = False
            yield vf
122978
def _parse_cli_filters(filters):
        
        parsed_filters = []
        for filter_entry in filters:
            filter_parts = re.match('^Name=(?P<name_value>[^,]+),Values=\[?(?P<key_values>[^\]]+)\]?', filter_entry)
            parsed_filters.append({
                'Name': filter_parts.group('name_value'),
                'Values': filter_parts.group('key_values').split(',')
            })
        return parsed_filters
905809
def types(self):
        
        out = []
        if self._transform_bytes:
            out.append(bytes)
        if self._transform_str:
            out.append(str)
        return tuple(out)
619425
def retrieve_flags(flag_dict, flag_filter):
    
    
    return [(f[0], f[1]) for f in flag_dict.items() if
            isinstance(f[0], str) and f[0].startswith(flag_filter)]
238966
def prior_model_tuples(self):
        
        return list(filter(lambda t: isinstance(t[1], AbstractPriorModel), self.__dict__.items()))
414401
private static List<AbstractExpression> filterSingleTVEExpressions(List<AbstractExpression> exprs,
            List<AbstractExpression> otherExprs) {
        List<AbstractExpression> singleTVEExprs = new ArrayList<>();
        for (AbstractExpression expr : exprs) {
            List<TupleValueExpression> tves = ExpressionUtil.getTupleValueExpressions(expr);
            if (tves.size() == 1) {
                singleTVEExprs.add(expr);
            } else {
                otherExprs.add(expr);
            }
        }
        return singleTVEExprs;
    }