Add this instance as a row on a `astropy.table.Table`
351684
def append_to_tables(self, table, table_ids):
        
        infile_refs = np.zeros((2), int)
        outfile_refs = np.zeros((2), int)
        rmfile_refs = np.zeros((2), int)
        intfile_refs = np.zeros((2), int)
        f_ptr = len(table_ids['file_id'])
        infile_refs[0] = f_ptr
        if self.infile_ids is not None:
            for fid in self.infile_ids:
                table_ids.add_row(dict(file_id=fid))
                f_ptr += 1
        infile_refs[1] = f_ptr
        outfile_refs[0] = f_ptr
        if self.outfile_ids is not None:
            for fid in self.outfile_ids:
                table_ids.add_row(dict(file_id=fid))
                f_ptr += 1
        outfile_refs[1] = f_ptr
        rmfile_refs[0] = f_ptr
        if self.rmfile_ids is not None:
            for fid in self.rmfile_ids:
                table_ids.add_row(dict(file_id=fid))
                f_ptr += 1
        rmfile_refs[1] = f_ptr
        intfile_refs[0] = f_ptr
        if self.intfile_ids is not None:
            for fid in self.intfile_ids:
                table_ids.add_row(dict(file_id=fid))
                f_ptr += 1
        intfile_refs[1] = f_ptr

        table.add_row(dict(dbkey=self.dbkey,
                           jobname=self.jobname,
                           jobkey=self.jobkey,
                           appname=self.appname,
                           logfile=self.logfile,
                           job_config=str(self.job_config),
                           timestamp=self.timestamp,
                           infile_refs=infile_refs,
                           outfile_refs=outfile_refs,
                           rmfile_refs=rmfile_refs,
                           intfile_refs=intfile_refs,
                           status=self.status))
1034169
def push(cell)
      cell = Workbook::Cell.new(cell, {row:self}) unless cell.class == Workbook::Cell
      super(cell)
    end
1006106
def NewRow(self, value=""):
        
        newrow = self.row_class()
        newrow.row = self.size + 1
        newrow.table = self
        headers = self._Header()
        for header in headers:
            newrow[header] = value
        return newrow
1084176
def row(self, columnnames=[], exclude=False):
        
        from .tablerow import tablerow
        return tablerow(self, columnnames, exclude)
1221214
def _base_repr_(self, html=False, show_name=True, **kwargs):
        

        table_id = 'table{id}'.format(id=id(self))

        data_lines, outs = self.formatter._pformat_table(self,
                                                         tableid=table_id, html=html, max_width=(-1 if html else None),
                                                         show_name=show_name, show_unit=None, show_dtype=False)

        out = '\n'.join(data_lines)

        # if astropy.table.six.PY2 and isinstance(out, astropy.table.six.text_type):
        #    out = out.encode('utf-8')

        return out
501584
def table(table_name, options={}, &block)
      table = Mongify::Database::Table.new(table_name, options, &block)
      add_table(table)
    end
969582
def create_table(self, table_name, obj=None, **kwargs):
        
        return self.client.create_table(
            table_name, obj=obj, database=self.name, **kwargs
        )
136752
def pretty_print_table(headers, rows):
    """"""
    table = make_table(headers=headers, rows=rows)
    pretty_print_table_instance(table)
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))
220307
def data_frame_to_astropy_table (dataframe):
    
    from astropy.utils import OrderedDict
    from astropy.table import Table, Column, MaskedColumn
    from astropy.extern import six

    out = OrderedDict()

    for name in dataframe.columns:
        column = dataframe[name]
        mask = np.array (column.isnull ())
        data = np.array (column)

        if data.dtype.kind == 'O':
            # If all elements of an object array are string-like or np.nan
            # then coerce back to a native numpy str/unicode array.
            string_types = six.string_types
            if six.PY3:
                string_types += (bytes,)
            nan = np.nan
            if all(isinstance(x, string_types) or x is nan for x in data):
                # Force any missing (null) values to b''.  Numpy will
                # upcast to str/unicode as needed.
                data[mask] = b''

                # When the numpy object array is represented as a list then
                # numpy initializes to the correct string or unicode type.
                data = np.array([x for x in data])

        if np.any(mask):
            out[name] = MaskedColumn(data=data, name=name, mask=mask)
        else:
            out[name] = Column(data=data, name=name)

    return Table(out)
1219096
def add_row(self, label='', item=''):
        
        self.AppendRows(1)
        last_row = self.GetNumberRows() - 1
        self.SetCellValue(last_row, 0, str(label))
        self.row_labels.append(label)
        self.row_items.append(item)
284980
def add_instance(self, inst, index=None):
        
        if index is None:
            self.__append_instance(inst.jobject)
        else:
            self.__insert_instance(index, inst.jobject)
129905
def append_table(self, name, **kwargs):
        """"""
        self.stack.append(Table(name, **kwargs))
788756
def add(self, *args):
        
        row = []
        for index, button in enumerate(args, start=1):
            row.append(button)
            if index % self.row_width == 0:
                self.inline_keyboard.append(row)
                row = []
        if len(row) > 0:
            self.inline_keyboard.append(row)
        return self
863731
def insert_instance(instance, table, **kwargs):
        
        instancedict = instance.__dict__.copy()
        instancedictclone = instancedict.copy()

        # Remove all Nonetype values
        for k, v in instancedictclone.iteritems():
            if v is None:
                instancedict.pop(k)

        keys, values = CoyoteDb.get_insert_fields_and_values_from_dict(instancedict)
        sql = """INSERT INTO {table} ({keys}) VALUES ({values})""".format(
            table=table,
            keys=keys,
            values=values
        )

        insert = CoyoteDb.insert(sql=sql, **kwargs)
        return insert
1173092
def add_a_row
      new_rows = rows + 1
      pool, @page_data = @page_data.flatten, []

      until pool.empty?
        @page_data << pool.shift(new_rows)
      end
    end
592221
def add_table(self, name, columns, type_map=None, if_not_exists=False):
        """"""
        # Check types mapping #
        if type_map is None and isinstance(columns, dict): types = columns
        if type_map is None:                               types = {}
        # Safe or unsafe #
        if if_not_exists: query = 'CREATE TABLE IF NOT EXISTS "%s" (%s);'
        else:             query = 'CREATE table "%s" (%s);'
        # Do it #
        cols = ','.join(['"' + c + '"' + ' ' + types.get(c, 'text') for c in columns])
        self.own_cursor.execute(query % (self.main_table, cols))