Parses HTML row

        :param row: HTML row
        :return: list of values in row
195487
def _parse_row(row):
        

        data = []

        labels = HtmlTable._get_row_tag(row, "th")
        if labels:
            data += labels

        columns = HtmlTable._get_row_tag(row, "td")
        if columns:
            data += columns

        return data
291687
def process_row(self):
        
        self.log_response_message("got ROW message")
        r = self._reader
        info = self.res_info
        info.row_count += 1
        for i, curcol in enumerate(info.columns):
            curcol.value = self.row[i] = curcol.serializer.read(r)
99250
def __get_tokens(self, row):
        """"""
        row_tokenizer = RowTokenizer(row, self.config)

        line = row_tokenizer.next()
        while line:
            # print("RETURN line", line[0:100])
            yield line
            line = row_tokenizer.next()
230347
def item_at(self, row, column):
        
        return self.children[str(row)].children[str(column)]
912944
public String getValueFromCell(int row, int column) {
        if (row < 1 || column < 1) {
            throw new IllegalArgumentException("Row and column must start from 1");
        }
        List<WebElement> elements = HtmlElementUtils.locateElements(getXPathBase() + "tr");
        List<WebElement> cells = elements.get(row - 1).findElements(By.xpath(".//td"));

        if (cells.size() > 0) {
            return cells.get(column - 1).getText();
        }

        return null;
    }
118085
def get_rows(self):
        """"""
        table = self.soup.find_all('tr')[1:-3]
        return [row for row in table if row.contents[3].string]
831364
def rows(self) -> List[List[str]]:
        
        return [list(d.values()) for d in self.data]
4556
def parse_100_row(row: list, file_name: str) -> HeaderRecord:
    
    return HeaderRecord(
        row[1],
        parse_datetime(row[2]),
        row[3],
        row[4],
        file_name,
    )
144487
def from_row(row):
    ''''''
    subject = (row[5][0].upper() + row[5][1:]) if row[5] else row[5]
    return Advice.objects.create(
        id=row[0],
        administration=cleanup(row[1]),
        type=row[2],
        session=datetime.strptime(row[4], '%d/%m/%Y'),
        subject=cleanup(subject),
        topics=[t.title() for t in cleanup(row[6]).split(', ')],
        tags=[tag.strip() for tag in row[7].split(',') if tag.strip()],
        meanings=cleanup(row[8]).replace(' / ', '/').split(', '),
        part=_part(row[9]),
        content=cleanup(row[10]),
    )
784944
def _get_row_tag(row, tag):
        

        is_empty = True
        data = []
        for column_label in row.find_all(tag):  # cycle through all labels
            data.append(
                String(column_label.text).strip_bad_html()
            )
            if data[-1]:
                is_empty = False

        if not is_empty:
            return data

        return None
75417
def parse_250_row(row: list) -> BasicMeterData:
    
    return BasicMeterData(row[1], row[2], row[3], row[4], row[5],
                             row[6], row[7], float(row[8]),
                             parse_datetime(row[9]), row[10], row[11], row[12],
                             float(row[13]), parse_datetime(
                                 row[14]), row[15], row[16], row[17],
                             float(row[18]), row[19], row[20],
                             parse_datetime(row[21]), parse_datetime(row[22]))
655456
def format_row(self, row):
        
        assert all(isinstance(x, VTMLBuffer) for x in row)
        raw = (fn(x) for x, fn in zip(row, self.formatters))
        for line in itertools.zip_longest(*raw):
            line = list(line)
            for i, col in enumerate(line):
                if col is None:
                    line[i] = self._get_blank_cell(i)
            yield line
1138715
def rowkey(self, row):
        ''
        return tuple(c.getTypedValueOrException(row) for c in self.keyCols)
1281238
def split_table_cells(self, row):
        

        row = iter(row)
        col = 0
        start_col = col + 1
        cell = ''
        first_cell = True
        while True:
            char = next(row, None)
            col += 1
            if char == '|':
                if first_cell:
                    # First cell (content before the first |) is skipped
                    first_cell = False
                else:
                    yield (cell, start_col)
                cell = ''
                start_col = col + 1
            elif char == '\\':
                char = next(row)
                col += 1
                if char == 'n':
                    cell += '\n'
                else:
                    if char not in ['|', '\\']:
                        cell += '\\'
                    cell += char
            elif char:
                cell += char
            else:
                break
602516
def ParseRow(header,
             row):
  
  precondition.AssertDictType(row, Text, Text)

  result = rdf_osquery.OsqueryRow()
  for column in header.columns:
    result.values.append(row[column.name])
  return result
870617
def parse_n3(row, src='csv'):
    
    if row.strip() == '':
        return '',''
    l_root = 'opencyc'
    key = ''
    val = ''
    if src == 'csv': 
        cols = row.split(',')
        if len(cols) < 3:
            #print('PARSE ISSUE : ', row)
            return '',''
        key = ''
        val = ''
        key = l_root + ':' + cols[1].strip('"').strip() + ':' + cols[2].strip('"').strip()
        try:
            val = cols[3].strip('"').strip()
        except Exception:
            val = "Error parsing " + row
    elif src == 'n3':
        pass
    return key, val
1337427
def get_html_row_count(spans):
    """"""

    if spans == []:
        return 0
    row_counts = {}
    for span in spans:
        span = sorted(span)
        try:
            row_counts[str(span[0][1])] += get_span_row_count(span)
        except KeyError:
            row_counts[str(span[0][1])] = get_span_row_count(span)

    values = list(row_counts.values())
    return max(values)