This will add a row to the table
        :param row: obj, list, or dictionary
        :return: SeabornRow that was added to the table
348539
def append(self, row=None):
        
        self.table.append(self._normalize_row(row))
        return self.table[-1]
400994
def row(self, rownum):
        
        if rownum > len(self):
            raise IndexError("Invalid row index `%s` for DataTable" % rownum)
        return datarow_constructor(self.fields)([self[field][rownum]
                                                 for field in self.fields])
809984
def insert(self, rows):
        
        if len(rows) == 0:
            return

        sql, sql_args = self.get_insert_sql(rows)

        # get the cursor to execute the query
        cursor = self.get_cursor()

        # execute the query
        cursor.execute(sql, sql_args)
57601
def add_row(self, row):

        """"""

        if self._field_names and len(row) != len(self._field_names):
            raise Exception("Row has incorrect number of values, (actual) %d!=%d (expected)" %(len(row),len(self._field_names)))
        self._rows.append(list(row))
465425
def add_chart(self, chart, row, col):
        
        self.__charts.append((chart, (row, col)))
813912
def push(row)
      row = Workbook::Row.new(row) if row.class == Array
      super(row)
      row.set_table(self)
    end
523093
def add_row(self, data: list=None):
        
        # validation
        if self.headers and data:
            if len(self.headers) != len(data):
                raise ValueError

        offset = 0 if not self.headers else 1
        row = list()

        if data:
            for i, element in enumerate(data):
                contents = '' if element is None else str(element)
                entry = ttk.Entry(self)
                entry.insert(0, contents)
                entry.grid(row=len(self._rows) + offset,
                           column=i,
                           sticky='E,W')
                row.append(entry)
        else:
            for i in range(self.num_of_columns):
                entry = ttk.Entry(self)
                entry.grid(row=len(self._rows) + offset,
                           column=i,
                           sticky='E,W')
                row.append(entry)

        self._rows.append(row)

        # clear all bindings
        for row in self._rows:
            for widget in row:
                widget.unbind('<Tab>')

        def add(e):
            self.add_row()

        last_entry = self._rows[-1][-1]
        last_entry.bind('<Tab>', add)

        e = self._rows[-1][0]
        e.focus_set()

        self._redraw()
1229531
def cast_row(self, row, fail_fast=False):
        

        # Prepare
        result = []
        errors = []

        # Check row length
        if len(row) != len(self.fields):
            message = 'Row length %s doesn\'t match fields count %s'
            message = message % (len(row), len(self.fields))
            raise exceptions.CastError(message)

        # Cast row
        for field, value in zip(self.fields, row):
            try:
                result.append(field.cast_value(value))
            except exceptions.CastError as exception:
                if fail_fast:
                    raise
                errors.append(exception)

        # Raise errors
        if errors:
            message = 'There are %s cast errors (see exception.errors)' % len(errors)
            raise exceptions.CastError(message, errors=errors)

        return result
1310615
def add(self, item):
        
        if isinstance(item, list):
            self.rows.append(Row(item))
        elif isinstance(item, Row):
            self.rows.append(item)
        else:
            raise InvalidMessageItemError(item, item.__class__)
1338562
def +(row)
      rv = super(row)
      rv = Workbook::Row.new(rv) unless rv.class == Workbook::Row
      return rv
    end
933347
def make_row_dict(row):
    
    ind = row[row.notnull()].index
    values = row[row.notnull()].values
    # to transformation with extract_col_name here???
    return dict(list(zip(ind, values)))
564277
def add_row(row)
      case
        when row.is_a?(Array)
          @rows << Hash[@parameters.zip(row.collect { |value| value.strip })]
          @row_elements << Row.new("|#{row.join('|')}|")
        when row.is_a?(Hash)
          @rows << row.each_value { |value| value.strip! }
          @row_elements << Row.new("|#{ordered_row_values(row).join('|')}|")
        else
          raise(ArgumentError, "Can only add row from a Hash or an Array but received #{row.class}")
      end
    end
423773
def add_entry(self, row):
        
        var_call = VCFEntry(self.individuals)
        var_call.parse_entry( row )
        self.entries[(var_call.chrom, var_call.pos)] = var_call
        return var_call
599480
def on_add_rows(self, event):
        
        num_rows = self.rows_spin_ctrl.GetValue()
        #last_row = self.grid.GetNumberRows()
        for row in range(num_rows):
            self.grid.add_row()
            #if not self.grid.changes:
            #    self.grid.changes = set([])
            #self.grid.changes.add(last_row)
            #last_row += 1
        self.main_sizer.Fit(self)
246850
def Remove(self, row):
        
        if row == 0 or row > self.size:
            raise TableError("Attempt to remove header row")
        new_table = []
        # pylint: disable=E1103
        for t_row in self._table:
            if t_row.row != row:
                new_table.append(t_row)
                if t_row.row > row:
                    t_row.row -= 1
        self._table = new_table
989702
def add_table(self, rows, cols, width):
        
        from .table import Table
        tbl = CT_Tbl.new_tbl(rows, cols, width)
        self._element._insert_tbl(tbl)
        return Table(tbl, self)
1268569
def _wrap_row(cls, row):
        """"""
        doc = row.get('doc')
        if doc is not None:
            return cls.wrap(doc)
        data = row['value']
        data['_id'] = row['id']
        return cls.wrap(data)