Return a list of overlays that start at start.
481201
def _fit_overlay_lists(self, text, start, matchers, **kw):
        

        if matchers:
            for o in matchers[0].fit_overlays(text, start):
                for rest in self._fit_overlay_lists(text, o.end, matchers[1:]):
                    yield [o] + rest

        else:
            yield []
1125695
def slicelist(b):
    """"""

    slicelst = []
    started = False
    for i, e in enumerate(b):
        if e and not started:
            start = i
            started = True
        elif not e and started:
            slicelst.append(slice(start, i))
            started = False

    if e:
        slicelst.append(slice(start, i + 1))  # True in the end.

    return slicelst
1133196
def get_all_starts(year)
      results = []
      app = get_all_appearances(year)
      if app.start == true
        results << app
      end
    end
1266549
@WithBridgeMethods(List.class)
    @Deprecated
    public RunList<RunT> getBuildsByTimestamp(long start, long end) {
        return getBuilds().byTimestamp(start,end);
    }
480694
def keys(self, start=None, stop=None):
        """"""
        return (item[0] for item in self.items(start, stop))
1293134
def _init_edges(p2cs, c2ps):
        """"""
        edge_from_to = []
        for parent, children in p2cs.items():
            for child in children:
                # if child in goids_present and parent in goids_present:
                edge_from_to.append((child, parent))
        for parent, children in c2ps.items():
            for child in children:
                # if child in goids_present and parent in goids_present:
                edge_from_to.append((child, parent))
        return edge_from_to
951793
def starts(self, layer):
        """"""
        starts = []
        for data in self[layer]:
            starts.append(data[START])
        return starts
17343
def meta(self):
        """"""
        mount_points = []
        for overlay in self.overlays:
            mount_points.append(overlay.mount_point)
        return [self.end_dir, self.start_dir, mount_points]
1226484
def before_start(self, checkers):
        
        for point in entrypoints.get_group_all("kibitzr.before_start"):
            entry = point.load()
            entry(self, checkers)
497526
def initialize_outlineexplorer(self):
        """"""
        for index in range(self.get_stack_count()):
            if index != self.get_stack_index():
                self._refresh_outlineexplorer(index=index)
615579
def get_all_paths_from(self, start, seen=None):
        '''
        
        '''
        if seen is None:
            seen = frozenset()
        results = [(0, (start, ))]
        if start in seen or start not in self.edges:
            return results
        seen = seen | frozenset((start,))
        for node, edge_weight in self.edges[start].items():
            for subpath_weight, subpath in self.get_all_paths_from(node, seen):
                total_weight = edge_weight + subpath_weight
                full_path = (start, ) + subpath
                results.append((total_weight, full_path))
        return tuple(results)
844083
def overlays_at(self, key):
        

        if isinstance(key, slice):
            s, e, _ = key.indices(len(self.text))
        else:
            s = e = key

        return [o for o in self.overlays if o.start in Rng(s, e)]
894862
def map_beginning_of_each(unit, options = {}, &block)
      iterate(unit, options.merge(:map_result => true, :beginning_of => true), &block)
    end
1253833
def fit_overlays(self, text, start=None, end=None, **kw):
        

        _text = text[start or 0:]
        if end:
            _text = _text[:end]

        m = self.regex.match(unicode(_text))

        if m:
            yield Overlay(text, (start + m.start(), start + m.end()),
                          props=self.props,
                          value=self.value(rxmatch=m))
1238733
def find(self, chrom, start, end):
        """"""

        tree = self._trees.get( chrom, None )
        if tree:
            return tree.find( start, end )
        #return always a list
        return []
1323007
def overlay(self, matchers, force=False):
        

        for m in matchers:
            if m in self._ran_matchers:
                continue

            self._ran_matchers.append(m)
            self.overlays += list(m.offset_overlays(self))

        self.overlays.sort(key=lambda o: o.start, reverse=True)
1018727
def getStartNodes(fdefs,calls):
    ''''''
    s=[]
    for source in fdefs:
        for fn in fdefs[source]:
            inboundEdges=False
            for call in calls:
                if call.target==fn:
                    inboundEdges=True
            if not inboundEdges:
                s.append(fn)
    return s