"""OrderedDict subclass for a set of columns.

def __init__(self, cols={}):

if isinstance(cols, (list, tuple)):

cols = [(col.name, col) for col in cols]

super(TableColumns, self).__init__(cols)

def __getitem__(self, item):

"""Get items from a TableColumns object.

if isinstance(item, basestring):

return OrderedDict.__getitem__(self, item)

elif isinstance(item, int):

return self.values()[item]

elif isinstance(item, tuple):

return TableColumns([self[x] for x in item])

elif isinstance(item, slice):

return TableColumns([self[x] for x in self.keys()[item]])

else:

raise IndexError('Illegal key or index value for TableColumns '

'object')

def __repr__(self):

names = ("'{0}'".format(x) for x in self.keys())

return "<TableColumns names=({0})>".format(",".join(names))

def _rename_column(self, name, new_name):

if new_name in self:

raise KeyError("Column {0} already exists".format(new_name))

mapper = {name: new_name}

new_names = [mapper.get(name, name) for name in self]

cols = self.values()

self.clear()

self.update(zip(new_names, cols))

# Define keys and values for Python 2 and 3 source compatibility

def keys(self):

return list(OrderedDict.keys(self))

def values(self):

"""Define a data column for use in a Table object.

def __new__(cls, name, data=None,

dtype=None, shape=(), length=0,

description=None, units=None, format=None, meta=None):

if data is None:

dtype = (np.dtype(dtype).str, shape)

self_data = np.zeros(length, dtype=dtype)

elif isinstance(data, Column):

self_data = np.asarray(data.data, dtype=dtype)

if description is None:

description = data.description

if units is None:

units = units or data.units

if format is None:

format = data.format

if meta is None:

meta = deepcopy(data.meta)

else:

self_data = np.asarray(data, dtype=dtype)

self = self_data.view(cls)

self._name = name

self.units = units

self.format = format

self.description = description

self.parent_table = None

self.meta = OrderedDict()

if meta is not None:

self.meta.update(meta)

return self

def __array_finalize__(self, obj):

# Obj will be none for direct call to Column() creator

if obj is None:

return

# Self was created from template (e.g. obj[slice] or (obj * 2))

# or viewcast e.g. obj.view(Column). In either case we want to

# init Column attributes for self from obj if possible.

self.parent_table = None

for attr in ('name', 'units', 'format', 'description'):

val = getattr(obj, attr, None)

setattr(self, attr, val)

self.meta = deepcopy(getattr(obj, 'meta', {}))

def _get_name(self):

return self._name

def _set_name(self, val):

if self.parent_table is not None:

table = self.parent_table

table.columns._rename_column(self.name, val)

table._data.dtype.names = table.columns.keys()

self._name = val

name = property(_get_name, _set_name)

@property

def data(self):

return self.view(np.ndarray)

def copy(self, data=None, copy_data=True):

"""Return a copy of the current Column instance.

if data is None:

data = self.view(np.ndarray)

if copy_data:

data = data.copy()

return Column(self.name, data, units=self.units, format=self.format,

description=self.description, meta=deepcopy(self.meta))

@property

def descr(self):

"""Array-interface compliant full description of the column.

return (self.name, self.dtype.str, self.shape[1:])

def __repr__(self):

if self.name:

out = "<Column name={0} units={1} format={2} " \

"description={3}>\n{4}".format(

repr(self.name), repr(self.units),

repr(self.format), repr(self.description), repr(self.data))

else:

out = repr(self.data)

return out

def attrs_equal(self, col):

"""Compare the column attributes of ``col`` to this object.

if not isinstance(col, Column):

raise ValueError('Comparison `col` must be a Column object')

attrs = ('name', 'units', 'dtype', 'format', 'description', 'meta')

equal = all(getattr(self, x) == getattr(col, x) for x in attrs)

return equal

def pformat(self, max_lines=None, show_name=True, show_units=False):

"""Return a list of formatted string representation of column values.

lines, n_header = _pformat_col(self, max_lines, show_name, show_units)

return lines

def pprint(self, max_lines=None, show_name=True, show_units=False):

"""Print a formatted string representation of column values.

lines, n_header = _pformat_col(self, max_lines, show_name, show_units)

for i, line in enumerate(lines):

if i < n_header:

color_print(line, 'red')

else:

print line

def more(self, max_lines=None, show_name=True, show_units=False):

"""Interactively browse column with a paging interface.

_more_tabcol(self, max_lines=max_lines, show_name=show_name,

show_units=show_units)

def __str__(self):

lines, n_header = _pformat_col(self)

"""A class to represent one row of a Table object.

def __init__(self, table, index):

self._table = table

self._index = index

self._data = table._data[index]

def __getitem__(self, item):

return self.data[item]

def __setitem__(self, item, val):

self.data[item] = val

def __eq__(self, other):

return self.data == other

def __ne__(self, other):

return self.data != other

def __array__(self, dtype=None):

"""Support converting Row to np.array via np.array(table).

if dtype is not None:

raise ValueError('Datatype coercion is not allowed')

return np.array(self._data)

def __len__(self):

return len(self._data)

@property

def table(self):

return self._table

@property

def index(self):

return self._index

@property

def data(self):

return self._data

@property

def meta(self):

return self.table.meta

@property

def columns(self):

return self.table.columns

@property

def colnames(self):

return self.table.colnames

@property

def dtype(self):

return self.data.dtype

def __repr__(self):

return "<Row {0} of table\n values={1}\n dtype={2}>".format(

"""A class to represent tables of heterogeneous data.

def __init__(self, data=None, names=None, dtypes=None, meta=None,

copy=True):

# Set up a placeholder empty table

self._data = None

self.columns = TableColumns()

self.meta = OrderedDict() if meta is None else deepcopy(meta)

# Must copy if dtypes are changing

if not copy and dtypes is not None:

raise ValueError('Cannot specify dtypes when copy=False')

# Infer the type of the input data and set up the initialization

# function, number of columns, and potentially the default col names

default_names = None

if isinstance(data, (list, tuple)):

init_func = self._init_from_list

n_cols = len(data)

elif isinstance(data, np.ndarray):

if data.dtype.names:

init_func = self._init_from_ndarray # _struct

n_cols = len(data.dtype.names)

default_names = data.dtype.names

else:

init_func = self._init_from_ndarray # _homog

n_cols = data.shape[1]

elif isinstance(data, dict):

init_func = self._init_from_dict

n_cols = len(data.keys())

default_names = data.keys()

elif isinstance(data, Table):

init_func = self._init_from_table

n_cols = len(data.colnames)

default_names = data.colnames

elif data is None:

if names is None:

return # Empty table

else:

init_func = self._init_from_list

n_cols = len(names)

data = [[]] * n_cols

else:

raise ValueError('Data type {0} not allowed to init Table'

.format(type(data)))

# Set up defaults if names and/or dtypes are not specified.

# A value of None means the actual value will be inferred

# within the appropriate initialization routine, either from

# existing specification or auto-generated.

if names is None:

names = default_names or [None] * n_cols

if dtypes is None:

dtypes = [None] * n_cols

self._check_names_dtypes(names, dtypes, n_cols)

# Finally do the real initialization

init_func(data, names, dtypes, n_cols, copy)

def __array__(self, dtype=None):

"""Support converting Table to np.array via np.array(table).

if dtype is not None:

raise ValueError('Datatype coercion is not allowed')

# This limitation is because of the following unexpected result that

# should have made a table copy while changing the column names.

#

# >>> d = astropy.table.Table([[1,2],[3,4]])

# >>> np.array(d, dtype=[('a', 'i8'), ('b', 'i8')])

# array([(0, 0), (0, 0)],

# dtype=[('a', '<i8'), ('b', '<i8')])

return self._data

def _check_names_dtypes(self, names, dtypes, n_cols):

"""Make sure that names and dtypes are boths iterable and have

for inp_list, inp_str in ((dtypes, 'dtypes'), (names, 'names')):

if not isiterable(inp_list):

raise ValueError('{0} must be a list or None'.format(inp_str))

if len(names) != n_cols or len(dtypes) != n_cols:

raise ValueError(

'Arguments "names" and "dtypes" must match number of columns'

.format(inp_str))

def _init_from_list(self, data, names, dtypes, n_cols, copy):

"""Initialize table from a list of columns. A column can be a

if not copy:

raise ValueError('Cannot use copy=False with a list data input')

cols = []

def_names = _auto_names(n_cols)

for col, name, def_name, dtype in zip(data, names, def_names, dtypes):

if isinstance(col, Column):

col = Column((name or col.name), col, dtype=dtype)

elif isinstance(col, np.ndarray) or isiterable(col):

col = Column((name or def_name), col, dtype=dtype)

else:

raise ValueError('Elements in list initialization must be '

'either Column or list-like')

cols.append(col)

self._init_from_cols(cols)

def _init_from_ndarray(self, data, names, dtypes, n_cols, copy):

"""Initialize table from an ndarray structured array"""

data_names = data.dtype.names or _auto_names(n_cols)

struct = data.dtype.names is not None

names = [name or data_names[i] for i, name in enumerate(names)]

cols = ([data[name] for name in data_names] if struct else

[data[:, i] for i in range(n_cols)])

if copy:

self._init_from_list(cols, names, dtypes, n_cols, copy)

else:

dtypes = [(name, col.dtype) for name, col in zip(names, cols)]

self._data = data.view(dtypes).ravel()

columns = TableColumns()

for name in names:

columns[name] = Column(name, self._data[name])

columns[name].parent_table = self

self.columns = columns

def _init_from_dict(self, data, names, dtypes, n_cols, copy):

"""Initialize table from a dictionary of columns"""

if not copy:

raise ValueError('Cannot use copy=False with a dict data input')

data_list = [data[name] for name in names]

self._init_from_list(data_list, names, dtypes, n_cols, copy)

def _init_from_table(self, data, names, dtypes, n_cols, copy):

"""Initialize table from an existing Table object """

table = data # data is really a Table, rename for clarity

data_names = table.colnames

self.meta = deepcopy(table.meta)

cols = table.columns.values()

if copy:

self._init_from_list(cols, names, dtypes, n_cols, copy)

else:

names = [vals[0] or vals[1] for vals in zip(names, data_names)]

dtypes = [(name, col.dtype) for name, col in zip(names, cols)]

data = table._data.view(dtypes)

self._update_table_from_cols(self, data, cols, names)

def _init_from_cols(self, cols):

"""Initialize table from a list of Column objects"""

lengths = set(len(col.data) for col in cols)

if len(lengths) != 1:

raise ValueError('Inconsistent data column lengths: {0}'

.format(lengths))

names = [col.name for col in cols]

dtypes = [col.descr for col in cols]

data = np.empty(lengths.pop(), dtype=dtypes)

for col in cols:

data[col.name] = col.data

self._update_table_from_cols(self, data, cols, names)

def _new_from_slice(self, slice_):

"""Create a new table as a referenced slice from self."""

table = Table()

table.meta = deepcopy(self.meta)

cols = self.columns.values()

names = [col.name for col in cols]

data = self._data[slice_]

self._update_table_from_cols(table, data, cols, names)

return table

@staticmethod

def _update_table_from_cols(table, data, cols, names):

"""Update the existing ``table`` so that it represents the given

columns = TableColumns()

table._data = data

for name, col in zip(names, cols):

newcol = col.copy(data=data[name], copy_data=False)

newcol.name = name

newcol.parent_table = table

columns[name] = newcol

table.columns = columns

def __repr__(self):

names = ("'{0}'".format(x) for x in self.colnames)

s = "<Table rows={0} names=({1})>\n{2}".format(

self.__len__(), ','.join(names), repr(self._data))

return s

def __str__(self):

lines, n_header = _pformat_table(self)

return '\n'.join(lines)

def pprint(self, max_lines=None, max_width=None, show_name=True,

show_units=False):

"""Print a formatted string representation of the table.

lines, n_header = _pformat_table(self, max_lines, max_width, show_name,

show_units)

for i, line in enumerate(lines):

if i < n_header:

color_print(line, 'red')

else:

print line

def pformat(self, max_lines=None, max_width=None, show_name=True,

show_units=False):

"""Return a list of lines for the formatted string representation of

lines, n_header = _pformat_table(self, max_lines, max_width,

show_name, show_units)

return lines

def more(self, max_lines=None, max_width=None, show_name=True,

show_units=False):

"""Interactively browse table with a paging interface.

_more_tabcol(self, max_lines, max_width, show_name,

show_units)

def __getitem__(self, item):

if isinstance(item, basestring):

return self.columns[item]

elif isinstance(item, int):

return Row(self, item)

elif isinstance(item, tuple):

if any(x not in set(self.colnames) for x in item):

raise ValueError('Table column slice must contain only valid '

'column names')

return Table([self[x] for x in item], meta=deepcopy(self.meta))

elif (isinstance(item, slice) or isinstance(item, np.ndarray)

or isinstance(item, list)):

return self._new_from_slice(item)

else:

raise ValueError('Illegal type {0} for table item access'

.format(type(item)))

def __setitem__(self, item, value):

try:

self._data[item] = value

except (ValueError, KeyError, TypeError):

raise KeyError("Column {0} does not exist".format(item))

except:

raise

def __delitem__(self, item):

if isinstance(item, basestring):

self.remove_column(item)

elif isinstance(item, tuple):

self.remove_columns(item)

def __iter__(self):

self._iter_index = 0

return self

def __next__(self):

"""Python 3 iterator"""

if self._iter_index < len(self._data):

val = self[self._iter_index]

self._iter_index += 1

return val

else:

raise StopIteration

if sys.version_info[0] < 3: # pragma: py2

next = __next__

def field(self, item):

"""Return column[item] for recarray compatibility."""

return self.columns[item]

@property

def dtype(self):

return self._data.dtype

@property

def colnames(self):

return list(self.columns.keys())

def keys(self):

return list(self.columns.keys())

def __len__(self):

if self._data is None:

return 0

else:

return len(self._data)

def index_column(self, name):

"""

try:

return self.colnames.index(name)

except ValueError:

raise ValueError("Column {0} does not exist".format(name))

def add_column(self, col, index=None):

"""

if index is None:

index = len(self.columns)

self.add_columns([col], [index])

def add_columns(self, cols, indexes=None):

"""

if indexes is None:

indexes = [len(self.columns)] * len(cols)

elif len(indexes) != len(cols):

raise ValueError('Number of indexes must match number of cols')

if self._data is None:

# No existing table data, init from cols

newcols = cols

else:

newcols = list(self.columns.values())

new_indexes = list(range(len(newcols) + 1))

for col, index in zip(cols, indexes):

i = new_indexes.index(index)

new_indexes.insert(i, None)

newcols.insert(i, col)

self._init_from_cols(newcols)

def remove_column(self, name):

"""

self.remove_columns([name])

def remove_columns(self, names):

'''

for name in names:

if name not in self.columns:

raise KeyError("Column {0} does not exist".format(name))

for name in names:

self.columns.pop(name)

self._data = _drop_fields(self._data, names)

def keep_columns(self, names):

'''

if isinstance(names, basestring):

names = [names]

for name in names:

if name not in self.columns:

raise KeyError("Column {0} does not exist".format(name))

remove = list(set(self.keys()) - set(names))

self.remove_columns(remove)

def rename_column(self, name, new_name):

'''