Yield all featuresets that subsume any of the given ones.
971622
def upset_union(self, featuresets):
        """"""
        concepts = (f.concept for f in featuresets)
        indexes = (c.index for c in self.lattice.upset_union(concepts))
        return map(self._featuresets.__getitem__, indexes)
1258539
def all_subslices(itr):
    
    assert iterable(itr), 'generators.all_subslices only accepts iterable arguments, not {}'.format(itr)
    if not hasattr(itr, '__len__'): # if itr isnt materialized, make it a deque
        itr = deque(itr)
    len_itr = len(itr)
    for start,_ in enumerate(itr):
        d = deque()
        for i in islice(itr, start, len_itr): # how many slices for this round
            d.append(i)
            yield tuple(d)
2376
def getAllAnnotationSets(self):
        
        for variantSet in self.getAllVariantSets():
            iterator = self._client.search_variant_annotation_sets(
                variant_set_id=variantSet.id)
            for variantAnnotationSet in iterator:
                yield variantAnnotationSet
306189
def iflatten(L):
    """"""
    for sublist in L:
        if hasattr(sublist, '__iter__'):
            for item in iflatten(sublist): yield item
        else: yield sublist
140822
def iter(self):
        """"""
        if self.patterns:
            patterns = list(self.patterns)
            for pattern in patterns:
                yield pattern
1191104
def _all_dicts(bases, seen=None):
    
    if seen is None:
        seen = set()
    for cls in bases:
        if cls in seen:
            continue
        seen.add(cls)
        yield cls.__dict__
        for b in _all_dicts(cls.__bases__, seen):
            yield b
244915
def each_sequence(self, fp):
        ''''''
        for name, seq, _ in self.each(fp):
            yield Sequence(name, seq)
854696
def substring_names(features):
    
    names = tools.uniqued(map(remove_sign, features))
    for l, r in permutations(names, 2):
        if l in r:
            yield (l, r)
902023
def generate_all_deps(self, target: Target):
        """"""
        yield from (self.targets[dep_name]
                    for dep_name in self.generate_dep_names(target))
1061549
def getAllVariantSets(self):
        
        for dataset in self.getAllDatasets():
            iterator = self._client.search_variant_sets(
                dataset_id=dataset.id)
            for variantSet in iterator:
                yield variantSet
1159558
def all_synsets(self):
        '''
        
        '''
        for synset_dict in self._mongo_db.synsets.find():
            yield Synset(self, synset_dict)
147591
def filter_tree(condition, tree):
    """"""
    if condition(tree):
        for node in tree.nodes:
            # this works in python > 3.3
            # yield from filter_tree(condition, node)
            for n in filter_tree(condition, node):
                yield n
    yield tree
601721
def _yield_all(self, l):
        '''
        
        '''
        if l is not None:
            if type(l) in [list, tuple]:
                for f in l:
                    for x in self._yield(f): yield x
            else:
                for x in self._yield(l): yield x
963985
@VisibleForTesting
  public FeatureSet with(Feature... newFeatures) {
    return new FeatureSet(union(features, ImmutableSet.copyOf(newFeatures)));
  }
800454
def all_connections(self):
        """"""
        for i in _xrange(self.num_patterns):
            for c in self._available_connections[i]:
                yield c
            for c in self._in_use_connections[i]:
                yield c
104263
def all_generators(self):
        
        for arg_gen in self.arg_gens:
            yield arg_gen

        for kwarg_gen in self.kwarg_gens.values():
            yield kwarg_gen
1111402
def flatten( iterables ):
    
    for it in iterables:
        if isinstance(it, str):
            yield it
        else:
            for element in it:
                yield element