Return one of record in this batch in out-of-order.

        :raises: `StopIteration` when no more record is in this batch
344541
def next(self):
        
        if self._records_iter >= len(self._records):
            raise StopIteration
        self._records_iter += 1
        return self._records[self._records_iter - 1]
465714
def next(self) -> mx.io.DataBatch:
        
        if self.iter_next():
            return self.next_batch
        raise StopIteration
276854
def get_records(self):
        
        self.close()
        with open(self.path, 'r') as filep:
            first_line = filep.readline().split(',')
            if first_line[0] != self.fields[0]:
                yield first_line

            for line in filep:
                yield line.split(',')
291157
def next(self):
        
        if self.count < len(self.reservoir):
            self.count += 1
            return self.reservoir[self.count-1]

        raise StopIteration("Reservoir exhausted")
828324
def currentRecord(self):
        
        completion = nativestring(self._pywidget.text())
        options    = map(str, self.model().stringList())
        
        try:
            index = options.index(completion)
        except ValueError:
            return None
        
        return self._records[index]
740392
def next(self):
        

        if self._stopped_iteration:
            raise StopIteration()

        # we do this because if get blocks, we can't catch a KeyboardInterrupt
        # so the slight timeout allows for that.
        while True:
            try:
                chunk = self.process._pipe_queue.get(True, 0.001)
            except Empty:
                if self.call_args["iter_noblock"]:
                    return errno.EWOULDBLOCK
            else:
                if chunk is None:
                    self.wait()
                    self._stopped_iteration = True
                    raise StopIteration()
                try:
                    return chunk.decode(self.call_args["encoding"],
                        self.call_args["decode_errors"])
                except UnicodeDecodeError:
                    return chunk
295481
def _filter_deleted_records(self, batches):
        
        for batch in batches:
            for record in batch:
                if not self.must_delete_record(record):
                    yield record
30406
def next(self):
        
        try:
            child = self.children[self.pos]
            self.pos += 1
            return child
        except:
            raise StopIteration()
283028
def printBlastRecordForDerek(record):
    
    if len(record.alignments) == 0:
        return 0
    if record.descriptions[0].e > 1e-120:
        return 0
    print(record.query, end=' ')
    for i, alignment in enumerate(record.alignments):
        print(record.descriptions[i].e, end=' ')
        for hspIndex, hsp in enumerate(alignment.hsps, start=1):
            if hsp.sbjct_start < hsp.sbjct_end:
                sense = 1
                if hsp.sbjct_start < 2200:
                    side = 'left'
                else:
                    side = 'right'
            else:
                sense = -1
                if hsp.sbjct_end < 2200:
                    side = 'left'
                else:
                    side = 'right'
            print(sense, side)
            break
    return 1
1224940
def next(self):
        """"""
        # Block until a document is returnable.
        while self.alive:
            doc = self._try_next(True)
            if doc is not None:
                return doc

        raise StopIteration
315981
def next(self):
        
        if self.index < self.length:
            index = self.index
            self.index += 1
            return self.data[index]
        else:
            raise StopIteration()
1080822
def inorder(self):
        

        if not self:
            return

        if self.left:
            for x in self.left.inorder():
                yield x

        yield self

        if self.right:
            for x in self.right.inorder():
                yield x
553122
def next(self):
        
        if self._cur_col >= len(self._rec):
            self._cur_col = 0
            raise StopIteration
        col = self._rec[self._cur_col]
        self._cur_col += 1
        return col
1154624
def next(self):
        
        if self.rows is None:
            raise ProgrammingError(
                "No result available. " +
                "execute() or executemany() must be called first."
            )
        elif not self._closed:
            return next(self.rows)
        else:
            raise ProgrammingError("Cursor closed")
4464
def next(self):
        

        try:
            self._fetch()
            pkt = self.pkt_queue.popleft()
            try:
                self._infer_acked(pkt)
            except:
                pass
            try:
                self._infer_retry(pkt)
            except:
                pass

            return pkt
        except IndexError:
            raise StopIteration()
55932
def prune_empty(records):
    
    for record in records:
        if not all(c == '-' for c in str(record.seq)):
            yield record
202064
def take_ordereds_out_of_turn(self) -> tuple:
        
        for replica in self._replicas.values():
            yield replica.instId, replica._remove_ordered_from_queue()