Yield rows for the section
432830
def rows(self):
        """"""
        for t in self.terms:

            for row in t.rows:
                term, value = row  # Value can either be a string, or a dict

                if isinstance(value, dict):  # Dict is for properties, which might be arg-children
                    term, args, remain = self._args(term, value)
                    yield term, args

                    # 'remain' is all of the children that didn't have an arg-child column -- the
                    # section didn't have a column heder for that ther.
                    for k, v in remain.items():
                        yield term.split('.')[-1] + '.' + k, v
                else:
                    yield row
412833
def parts(self):
        

        for item in self.__parts_and_divisions:
            if item.tag == 'part':
                yield item
            else:
                # Divisions shouldn't be beneath a part, but here's a fallback
                # for if this does happen
                for part in item.parts:
                    yield part
914818
def iterrows(self):
        """"""



        row_proxy = None

        headers = None

        for row in self:

            if not headers:
                headers = row
                row_proxy = RowProxy(headers)
                continue

            yield row_proxy.set_row(row)
790757
def rows(self):
        

        # Translate the term value name so it can be assigned to a parameter.
        tvm = self.section.doc.decl_terms.get(self.qualified_term, {}).get('termvaluename', '@value')
        assert tvm
        # Terminal children have no arguments, just a value. Here we put the terminal children
        # in a property array, so they can be written to the parent's arg-children columns
        # if the section has any.

        properties = {tvm: self.value}

        for c in self.children:
            if c.is_terminal:
                if c.record_term_lc:
                    # This is rare, but can happen if a property child is not given
                    # a property name by the section -- the "Section" term has a blank column.
                    properties[c.record_term_lc] = c.value

        yield (self.qualified_term, properties)

        # The non-terminal children have to get yielded normally -- they can't be arg-children
        for c in self.children:
            if not c.is_terminal:
                for row in c.rows:
                    yield row
1092336
def parse(self, *nodes):
        
        for n in nodes:
            if not n.contents:
                continue
            row = self._parse(n)
            if not row.is_null:
                yield row
1050139
def group(self):
        """"""
        yield self.current
        # start enumerate at 1 because we already yielded the last saved item
        for num, item in enumerate(self.iterator, 1):
            self.current = item
            if num == self.limit:
                break
            yield item
        else:
            self.on_going = False
495880
private RowSet prepareFromRow(List<Object> rows, RowSet rowSet) throws Exception {
    for (Object row : rows) {
      rowSet.addRow((Object[]) row);
    }
    return rowSet;
  }
525019
def wrap_all(self, rows: Iterable[Union[Mapping[str, Any], Sequence[Any]]]):
        """"""
        return (self.wrap(r) for r in rows)
135903
def spans(self, container):
        """"""
        for child in self.children(container):
            container.register_styled(child)
            for span in child.spans(container):
                yield span
619552
def parse(self):
        
        data = []  # add name of section

        for row in self.soup.find_all("tr"):  # cycle through all rows
            parsed = self._parse_row(row)
            if parsed:
                data.append(parsed)

        return data
24666
def readrows(self):
        

        # Loop forever or until max_rows is reached
        num_rows = 0
        while True:

            # Yield the rows from the internal reader
            for row in self.log_reader.readrows():
                yield self.replace_timestamp(row)

                # Sleep and count rows
                time.sleep(next(self.eps_timer))
                num_rows += 1

                # Check for max_rows
                if self.max_rows and (num_rows >= self.max_rows):
                    return
938286
def block_yield(parent, indent)
      return unless accept :yield

      # Consume the newline from the end of the element
      error :yield unless accept(:line_feed).strip.empty?

      # Create a new node
      yield_node = [:yield, nil, {}, [], indent]

      parent[@children] << yield_node
    end
553784
def row_iter(self):
        """"""
        for k in utils.range_(self.side):
            yield self.row(k)
355943
def sort_rows(self, rows, section):
        
        #print("@@ SORT ROWS:\n{}".format(rows))
        # Section-specific determination of sort key
        if section.lower() == Differ.CHANGED.lower():
            sort_key = Differ.CHANGED_DELTA
        else:
            sort_key = None
        if sort_key is not None:
            rows.sort(key=itemgetter(sort_key))
1183648
def items(self, section):
        """"""
        for line in self.iter_lines(section):
            if line.kind == ConfigLine.KIND_DATA:
                yield line.key, line.value
777807
def list_to_rows(src, size):
    

    row = []
    for item in src:
        row.append(item)
        if len(row) == size:
            yield row
            row = []

    if row:
        yield row
807954
async def iterFormRows(self, form):
        '''
        
        '''

        # <form> 00 00 (no prop...)
        pref = form.encode() + b'\x00\x00'
        penc = b'*' + form.encode()

        for _, pval in self.layrslab.scanByPref(pref, db=self.byprop):

            buid = s_msgpack.un(pval)[0]

            byts = self.layrslab.get(buid + penc, db=self.bybuid)
            if byts is None:
                continue

            valu, indx = s_msgpack.un(byts)

            yield buid, valu