# Licensed under a 3-clause BSD style license - see LICENSE.rst

from __future__ import (absolute_import, division, print_function,

unicode_literals)

from ..extern import six

from ..extern.six.moves import zip as izip

from ..extern.six.moves import range as xrange

import re

from copy import deepcopy

import numpy as np

from numpy import ma

from .. import log

from ..io import registry as io_registry

from ..units import Quantity

from ..utils import OrderedDict, isiterable, deprecated, minversion

from ..utils.console import color_print

from ..utils.metadata import MetaData

from . import groups

from .pprint import TableFormatter

from .column import (BaseColumn, Column, MaskedColumn, _auto_names, FalseArray,

col_getattr, col_setattr, col_copy, _col_update_attrs_from)

from .row import Row

from .np_utils import fix_column_name, recarray_fromrecords

# Prior to Numpy 1.6.2, there was a bug (in Numpy) that caused

# sorting of structured arrays containing Unicode columns to

# silently fail.

_BROKEN_UNICODE_TABLE_SORT = not minversion(np, '1.6.2')

__doctest_skip__ = ['Table.read', 'Table.write',

'Table.convert_bytestring_to_unicode',

'Table.convert_unicode_to_bytestring',

]

def descr(col):

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

This returns a 3-tuple (name, type, shape) that can always be

used in a structured array dtype definition.

"""

col_dtype_str = col.dtype.str if hasattr(col, 'dtype') else 'O'

col_shape = col.shape[1:] if hasattr(col, 'shape') else ()

return (col_getattr(col, 'name'), col_dtype_str, col_shape)

def is_mixin_class(obj):

"""

Abstraction to determine if ``obj`` should be used as a mixin column

when input to a table. This function does not apply to ``Quantity``.

Parameters

----------

obj : object

Object being queried for mixin compatibility

"""

return hasattr(obj, '_astropy_column_attrs')

class TableColumns(OrderedDict):

"""OrderedDict subclass for a set of columns.

This class enhances item access to provide convenient access to columns

by name or index, including slice access. It also handles renaming

of columns.

The initialization argument ``cols`` can be a list of ``Column`` objects

or any structure that is valid for initializing a Python dict. This

includes a dict, list of (key, val) tuples or [key, val] lists, etc.

Parameters

----------

cols : dict, list, tuple; optional

Column objects as data structure that can init dict (see above)

"""

def __init__(self, cols={}):

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

# `cols` should be a list of two-tuples, but it is allowed to have

# columns (BaseColumn or mixins) in the list.

newcols = []

for col in cols:

if (isinstance(col, (BaseColumn, Quantity))

or is_mixin_class(col)):

newcols.append((col_getattr(col, 'name'), col))

else:

newcols.append(col)

cols = newcols

super(TableColumns, self).__init__(cols)

def __getitem__(self, item):

"""Get items from a TableColumns object.

::

tc = TableColumns(cols=[Column(name='a'), Column(name='b'), Column(name='c')])

tc['a'] # Column('a')

tc[1] # Column('b')

tc['a', 'b'] # <TableColumns names=('a', 'b')>

tc[1:3] # <TableColumns names=('b', 'c')>

"""

if isinstance(item, six.string_types):

return OrderedDict.__getitem__(self, item)

elif isinstance(item, int):

return self.values()[item]

elif isinstance(item, tuple):

return self.__class__([self[x] for x in item])

elif isinstance(item, slice):

return self.__class__([self[x] for x in list(self)[item]])

else:

raise IndexError('Illegal key or index value for {} object'

.format(self.__class__.__name__))

def __repr__(self):

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

return "<{1} names=({0})>".format(",".join(names), self.__class__.__name__)

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 = list(six.itervalues(self))

self.clear()

self.update(list(izip(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):

return list(OrderedDict.values(self))

class Table(object):

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

`Table` provides a class for heterogeneous tabular data, making use of a

`numpy` structured array internally to store the data values. A key

enhancement provided by the `Table` class is the ability to easily modify

the structure of the table by adding or removing columns, or adding new

rows of data. In addition table and column metadata are fully supported.

`Table` differs from `~astropy.nddata.NDData` by the assumption that the

input data consists of columns of homogeneous data, where each column

has a unique identifier and may contain additional metadata such as the

data unit, format, and description.

Parameters

----------

data : numpy ndarray, dict, list, or Table, optional

Data to initialize table.

masked : bool, optional

Specify whether the table is masked.

names : list, optional

Specify column names

dtype : list, optional

Specify column data types

meta : dict, optional

Metadata associated with the table.

copy : bool, optional

Copy the input data (default=True).

rows : numpy ndarray, list of lists, optional

Row-oriented data for table instead of ``data`` argument

"""

meta = MetaData()

# Define class attributes for core container objects to allow for subclass

# customization.

Row = Row

Column = Column

MaskedColumn = MaskedColumn

TableColumns = TableColumns

TableFormatter = TableFormatter

@property

@deprecated('0.4', alternative=':attr:`Table.as_array`')

def _data(self):

"""

Return a new copy of the table in the form of a structured np.ndarray or

np.ma.MaskedArray object (as appropriate).

Prior to version 1.0 of astropy this private property was a modifiable

view of the table data, but since 1.0 it is a copy.

"""

return self.as_array()

def as_array(self):

"""

Return a new copy of the table in the form of a structured np.ndarray or

np.ma.MaskedArray object (as appropriate).

Returns

-------

table_array : np.ndarray (unmasked) or np.ma.MaskedArray (masked)

Copy of table as a numpy structured array

"""

if len(self.columns) == 0:

return None

cols = self.columns.values()

dtype = [descr(col) for col in cols]

empty_init = ma.empty if self.masked else np.empty

data = empty_init(len(self), dtype=dtype)

for col in cols:

data[col_getattr(col, 'name')] = col

return data

def __init__(self, data=None, masked=None, names=None, dtype=None,

meta=None, copy=True, rows=None):

# Set up a placeholder empty table

self._set_masked(masked)

self.columns = self.TableColumns()

self.meta = meta

self.formatter = self.TableFormatter()

# Must copy if dtype are changing

if not copy and dtype is not None:

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

# Row-oriented input, e.g. list of lists or list of tuples, list of

# dict, Row instance. Set data to something that the subsequent code

# will parse correctly.

is_list_of_dict = False

if rows is not None:

if data is not None:

raise ValueError('Cannot supply both `data` and `rows` values')

if all(isinstance(row, dict) for row in rows):

is_list_of_dict = True # Avoid doing the all(...) test twice.

data = rows

elif isinstance(rows, self.Row):

data = rows

else:

rec_data = recarray_fromrecords(rows)

data = [rec_data[name] for name in rec_data.dtype.names]

# 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, np.ndarray) and

data.shape == (0,) and

not data.dtype.names):

data = None

if isinstance(data, self.Row):

data = data._table[data._index:data._index + 1]

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

init_func = self._init_from_list

if data and (is_list_of_dict or all(isinstance(row, dict) for row in data)):

n_cols = len(data[0])

else:

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

if data.shape == ():

raise ValueError('Can not initialize a Table with a scalar')

elif len(data.shape) == 1:

data = data[np.newaxis, :]

n_cols = data.shape[1]

elif isinstance(data, dict):

init_func = self._init_from_dict

default_names = list(data)

n_cols = len(default_names)

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 dtype 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 dtype is None:

dtype = [None] * n_cols

# Numpy does not support Unicode column names on Python 2, or

# bytes column names on Python 3, so fix them up now.

names = [fix_column_name(name) for name in names]

self._check_names_dtype(names, dtype, n_cols)

# Finally do the real initialization

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

# Whatever happens above, the masked property should be set to a boolean

if type(self.masked) != bool:

raise TypeError("masked property has not been set to True or False")

def __getstate__(self):

return (self.columns.values(), self.meta)

def __setstate__(self, state):

columns, meta = state

self.__init__(columns, meta=meta)

@property

def mask(self):

# Dynamic view of available masks

if self.masked:

return Table([col.mask for col in self.columns.values()],

names=self.colnames, copy=False)

else:

return None

@mask.setter

def mask(self, val):

self.mask[:] = val

@property

def _mask(self):

"""This is needed so that comparison of a masked Table and a

MaskedArray works. The requirement comes from numpy.ma.core

so don't remove this property."""

return self.as_array().mask

def filled(self, fill_value=None):

"""Return a copy of self, with masked values filled.

If input ``fill_value`` supplied then that value is used for all

masked entries in the table. Otherwise the individual

``fill_value`` defined for each table column is used.

Parameters

----------

fill_value : str

If supplied, this ``fill_value`` is used for all masked entries

in the entire table.

Returns

-------

filled_table : Table

New table with masked values filled

"""

if self.masked:

data = [col.filled(fill_value) for col in six.itervalues(self.columns)]

else:

data = self

return self.__class__(data, meta=deepcopy(self.meta))

def __array__(self, dtype=None):

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

Coercion to a different dtype via np.array(table, dtype) is not

supported and will raise a ValueError.

"""

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.as_array().data if self.masked else self.as_array()

def _check_names_dtype(self, names, dtype, n_cols):

"""Make sure that names and dtype are both iterable and have

the same length as data.

"""

for inp_list, inp_str in ((dtype, 'dtype'), (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(dtype) != n_cols:

raise ValueError(

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

.format(inp_str))

def _set_masked_from_cols(self, cols):

if self.masked is None:

if any(isinstance(col, (MaskedColumn, ma.MaskedArray)) for col in cols):

self._set_masked(True)

else:

self._set_masked(False)

elif not self.masked:

if any(np.any(col.mask) for col in cols if isinstance(col, (MaskedColumn, ma.MaskedArray))):

self._set_masked(True)

def _init_from_list_of_dicts(self, data, names, dtype, n_cols, copy):

names_from_data = set()

for row in data:

names_from_data.update(row)

cols = {}

for name in names_from_data:

cols[name] = []

for i, row in enumerate(data):

try:

cols[name].append(row[name])

except KeyError:

raise ValueError('Row {0} has no value for column {1}'.format(i, name))

if all(name is None for name in names):

names = sorted(names_from_data)

self._init_from_dict(cols, names, dtype, n_cols, copy)

return

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

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

Column object, np.ndarray, mixin, or any other iterable object.

"""

if data and all(isinstance(row, dict) for row in data):

self._init_from_list_of_dicts(data, names, dtype, n_cols, copy)

return

# Set self.masked appropriately, then get class to create column instances.

self._set_masked_from_cols(data)

cols = []

def_names = _auto_names(n_cols)

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

if isinstance(col, (Column, MaskedColumn)):

col = self.ColumnClass(name=(name or col_getattr(col, 'name') or def_name),

data=col, dtype=dtype,

copy=copy)

elif self._is_mixin_column(col):

# Copy the mixin column attributes if they exist since the copy below

# may not get this attribute.

if copy:

col = col_copy(col)

col_setattr(col, 'name', name or col_getattr(col, 'name') or def_name)

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

col = self.ColumnClass(name=(name or def_name), data=col, dtype=dtype,

copy=copy)

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, dtype, 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)])

# Set self.masked appropriately, then get class to create column instances.

self._set_masked_from_cols(cols)

if copy:

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

else:

dtype = [(name, col.dtype, col.shape[1:]) for name, col in zip(names, cols)]

newdata = data.view(dtype).ravel()

columns = self.TableColumns()

for name in names:

columns[name] = self.ColumnClass(name=name, data=newdata[name])

col_setattr(columns[name], 'parent_table', self)

self.columns = columns

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

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

# TODO: is this restriction still needed with no ndarray?

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, dtype, n_cols, copy)

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

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

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

self.meta.clear()

self.meta.update(deepcopy(table.meta))

cols = list(table.columns.values())

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

def _init_from_cols(self, cols):

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

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

if len(lengths) != 1:

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

.format(lengths))

# Set the table masking

self._set_masked_from_cols(cols)

# Make sure that all Column-based objects have class self.ColumnClass

newcols = []

for col in cols:

# Convert any Columns with units to Quantity for a QTable

if (isinstance(self, QTable) and isinstance(col, Column)

and getattr(col, 'unit', None) is not None):

qcol = Quantity(col, unit=col.unit, copy=False)

_col_update_attrs_from(qcol, col, exclude_attrs=['unit', 'dtype', 'parent_table'])

newcols.append(qcol)

continue

if isinstance(col, Column) and not col.__class__ is self.ColumnClass:

col = self.ColumnClass(col) # copy attributes and reference data

newcols.append(col)

self._update_table_from_cols(self, newcols)

def _new_from_slice(self, slice_):

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

table = self.__class__(masked=self.masked)

table.meta.clear()

table.meta.update(deepcopy(self.meta))

cols = self.columns.values()

names = [col_getattr(col, 'name') for col in cols]

newcols = [col[slice_] for col in cols]

# Mixin column classes are not responsible for copying column attributes

# for item/slicing operations. Do this here in table.

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

if is_mixin_class(col):

_col_update_attrs_from(newcol, col, exclude_attrs=['parent_table'])

self._update_table_from_cols(table, newcols)

return table

@staticmethod

def _update_table_from_cols(table, cols):

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

``data`` (a structured ndarray) with ``cols`` and ``names``."""

colnames = set(col_getattr(col, 'name') for col in cols)

if None in colnames:

raise TypeError('Cannot have None for column name')

if len(colnames) != len(cols):

raise ValueError('Duplicate column names')

columns = table.TableColumns((col_getattr(col, 'name'), col) for col in cols)

for col in cols:

col_setattr(col, 'parent_table', table)

if table.masked and not hasattr(col, 'mask'):

col.mask = FalseArray(col.shape)

table.columns = columns

def _base_repr_(self, html=False):

descr_vals = [self.__class__.__name__]

for attr, val in (('masked', self.masked),

('length', len(self))):

descr_vals.append('{0}={1}'.format(attr, repr(val)))

descr = '<' + ' '.join(descr_vals) + '>\n'

if html:

from ..utils.xml.writer import xml_escape

descr = xml_escape(descr)

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

data_lines, outs = self.formatter._pformat_table(self,

tableid=tableid, html=html, max_width=(-1 if html else None),

show_name=True, show_unit=None, show_dtype=True)

out = descr + '\n'.join(data_lines)

if six.PY2 and isinstance(out, six.text_type):

out = out.encode('utf-8')

return out

def _repr_html_(self):

return self._base_repr_(html=True)

def __repr__(self):

return self._base_repr_(html=False)

def __unicode__(self):

return '\n'.join(self.pformat())

if six.PY3:

__str__ = __unicode__

def __bytes__(self):

return six.text_type(self).encode('utf-8')

if six.PY2:

__str__ = __bytes__

@property

def has_mixin_columns(self):

"""

True if table has any mixin columns (defined as columns that are not Column

subclasses)

"""

return any(not isinstance(col, BaseColumn) for col in self.columns.values())

def _is_mixin_column(self, col, quantity_is_mixin=False):

"""

Determine if ``col`` meets the protocol for a mixin Table column for

this table. By definition a BaseColumn instance is not a mixin.

"""

if isinstance(col, BaseColumn):

is_mixin = False

elif isinstance(col, Quantity):

is_mixin = quantity_is_mixin

else:

is_mixin = is_mixin_class(col)

return is_mixin

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

show_unit=None, show_dtype=False, align='right'):

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

If no value of ``max_lines`` is supplied then the height of the

screen terminal is used to set ``max_lines``. If the terminal

height cannot be determined then the default is taken from the

configuration item ``astropy.conf.max_lines``. If a negative

value of ``max_lines`` is supplied then there is no line limit

applied.

The same applies for max_width except the configuration item is

``astropy.conf.max_width``.

Parameters

----------

max_lines : int

Maximum number of lines in table output

max_width : int or `None`

Maximum character width of output

show_name : bool

Include a header row for column names (default=True)

show_unit : bool

Include a header row for unit. Default is to show a row

for units only if one or more columns has a defined value

for the unit.

show_dtype : bool

Include a header row for column dtypes (default=True)

align : str

Left/right alignment of a column. Default is 'right'.

"""

lines, outs = self.formatter._pformat_table(self, max_lines, max_width,

show_name=show_name, show_unit=show_unit,

show_dtype=show_dtype, align=align)

if outs['show_length']:

lines.append('Length = {0} rows'.format(len(self)))

n_header = outs['n_header']

for i, line in enumerate(lines):

if i < n_header:

color_print(line, 'red')

else:

print(line)

def show_in_browser(self,

css="table,th,td,tr,tbody {border: 1px solid black; border-collapse: collapse;}",

max_lines=5000,

jsviewer=False,

jskwargs={'use_local_files': True},

tableid=None,

browser='default'):

"""

Render the table in HTML and show it in a web browser.

Parameters

----------

css : string

A valid CSS string declaring the formatting for the table

max_lines : int

Maximum number of rows to export to the table (set low by default

to avoid memory issues, since the browser view requires duplicating

the table in memory). A negative value of ``max_lines`` indicates

no row limit

jsviewer : bool

If `True`, prepends some javascript headers so that the table is

rendered as a https://datatables.net data table. This allows

in-browser searching & sorting. See `JSViewer

<http://www.jsviewer.com/>`_

jskwargs : dict

Passed to the `JSViewer`_ init.

tableid : str or `None`

An html ID tag for the table. Default is "table{id}", where id is

the unique integer id of the table object, id(self).

browser : str

Any legal browser name, e.g. ``'firefox'``, ``'chrome'``,

``'safari'`` (for mac, you may need to use ``'open -a

"/Applications/Google Chrome.app" %s'`` for Chrome). If

``'default'``, will use the system default browser.

"""

import os

import webbrowser

import tempfile

# We can't use NamedTemporaryFile here because it gets deleted as

# soon as it gets garbage collected.

tmpdir = tempfile.mkdtemp()

path = os.path.join(tmpdir, 'table.html')

with open(path, 'w') as tmp:

if jsviewer:

self.write(tmp, format='jsviewer', css=css, max_lines=max_lines,

jskwargs=jskwargs, table_id=tableid)

else:

self.write(tmp, format='html')

if browser == 'default':

webbrowser.open("file://" + path)

else:

webbrowser.get(browser).open("file://" + path)

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

show_unit=None, show_dtype=False, html=False, tableid=None,

align='right'):

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

the table.

If no value of ``max_lines`` is supplied then the height of the

screen terminal is used to set ``max_lines``. If the terminal

height cannot be determined then the default is taken from the

configuration item ``astropy.conf.max_lines``. If a negative

value of ``max_lines`` is supplied then there is no line limit

applied.

The same applies for ``max_width`` except the configuration item is

``astropy.conf.max_width``.

Parameters

----------

max_lines : int or `None`

Maximum number of rows to output

max_width : int or `None`

Maximum character width of output

show_name : bool

Include a header row for column names (default=True)

show_unit : bool

Include a header row for unit. Default is to show a row

for units only if one or more columns has a defined value

for the unit.

show_dtype : bool

Include a header row for column dtypes (default=True)

html : bool

Format the output as an HTML table (default=False)

tableid : str or `None`

An ID tag for the table; only used if html is set. Default is

"table{id}", where id is the unique integer id of the table object,

id(self)

align : str

Left/right alignment of a column. Default is 'right'.

Returns

-------

lines : list

Formatted table as a list of strings

"""

lines, outs = self.formatter._pformat_table(self, max_lines, max_width,

show_name=show_name, show_unit=show_unit,

show_dtype=show_dtype, html=html,

tableid=tableid, align=align)

if outs['show_length']:

lines.append('Length = {0} rows'.format(len(self)))

return lines

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

show_unit=None, show_dtype=False):

"""Interactively browse table with a paging interface.

Supported keys::

f, <space> : forward one page

b : back one page

r : refresh same page

n : next row

p : previous row

< : go to beginning

> : go to end

q : quit browsing

h : print this help

Parameters

----------

max_lines : int

Maximum number of lines in table output

max_width : int or `None`

Maximum character width of output

show_name : bool

Include a header row for column names (default=True)

show_unit : bool

Include a header row for unit. Default is to show a row

for units only if one or more columns has a defined value

for the unit.

show_dtype : bool

Include a header row for column dtypes (default=True)

"""

self.formatter._more_tabcol(self, max_lines, max_width, show_name=show_name,

show_unit=show_unit, show_dtype=show_dtype)

def __getitem__(self, item):

if isinstance(item, six.string_types):

return self.columns[item]

elif isinstance(item, (int, np.integer)):

return self.Row(self, item)

elif (isinstance(item, (tuple, list)) and item and

all(isinstance(x, six.string_types) for x in item)):

bad_names = [x for x in item if x not in self.colnames]

if bad_names:

raise ValueError('Slice name(s) {0} not valid column name(s)'

.format(', '.join(bad_names)))

out = self.__class__([self[x] for x in item], meta=deepcopy(self.meta))

out._groups = groups.TableGroups(out, indices=self.groups._indices,

keys=self.groups._keys)

return out

elif ((isinstance(item, np.ndarray) and len(item) == 0) or

(isinstance(item, (tuple, list)) and not item)):

# If item is an empty array/list/tuple then return the table with no rows

return self._new_from_slice([])

elif (isinstance(item, slice) or

isinstance(item, np.ndarray) or

isinstance(item, list) or

isinstance(item, tuple) and all(isinstance(x, np.ndarray)

for x in item)):

# here for the many ways to give a slice; a tuple of ndarray

# is produced by np.where, as in t[np.where(t['a'] > 2)]

# For all, a new table is constructed with slice of all columns

return self._new_from_slice(item)

else:

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

.format(type(item)))

def __setitem__(self, item, value):

# If the item is a string then it must be the name of a column.

# If that column doesn't already exist then create it now.

if isinstance(item, six.string_types) and item not in self.colnames:

NewColumn = self.MaskedColumn if self.masked else self.Column

# Make sure value has a dtype. If not make it into a numpy array

if not hasattr(value, 'dtype') and not self._is_mixin_column(value):

value = np.asarray(value)

# Make new column and assign the value. If the table currently

# has no rows (len=0) of the value is already a Column then

# define new column directly from value. In the latter case

# this allows for propagation of Column metadata. Otherwise

# define a new column with the right length and shape and then

# set it from value. This allows for broadcasting, e.g. t['a']

# = 1.

name = item

if isinstance(value, BaseColumn) or self._is_mixin_column(value):

new_column = col_copy(value)

col_setattr(new_column, 'name', name)

elif len(self) == 0:

new_column = NewColumn(value, name=name)

else:

new_column = NewColumn(name=name, length=len(self), dtype=value.dtype,

shape=value.shape[1:])

new_column[:] = value

if isinstance(value, Quantity):

new_column.unit = value.unit

# Now add new column to the table

self.add_columns([new_column], copy=False)

else:

n_cols = len(self.columns)

if isinstance(item, six.string_types):

# Set an existing column

self.columns[item][:] = value

elif isinstance(item, (int, np.integer)):

# Set the corresponding row assuming value is an iterable.

if not hasattr(value, '__len__'):

raise TypeError('Right side value must be iterable')

if len(value) != n_cols:

raise ValueError('Right side value needs {0} elements (one for each column)'

.format(n_cols))

for col, val in izip(self.columns.values(), value):

col[item] = val

elif (isinstance(item, slice) or

isinstance(item, np.ndarray) or

isinstance(item, list) or

(isinstance(item, tuple) and # output from np.where

all(isinstance(x, np.ndarray) for x in item))):

if isinstance(value, Table):

vals = (col for col in value.columns.values())

elif isinstance(value, np.ndarray) and value.dtype.names:

vals = (value[name] for name in value.dtype.names)

elif np.isscalar(value):

import itertools

vals = itertools.repeat(value, n_cols)

else: # Assume this is an iterable that will work

if len(value) != n_cols:

raise ValueError('Right side value needs {0} elements (one for each column)'

.format(n_cols))

vals = value

for col, val in izip(self.columns.values(), vals):

col[item] = val

else:

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

.format(type(item)))

def __delitem__(self, item):

if isinstance(item, six.string_types):

self.remove_column(item)

elif isinstance(item, tuple):

self.remove_columns(item)

def field(self, item):

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

return self.columns[item]

@property

def masked(self):

return self._masked

@masked.setter

def masked(self, masked):

raise Exception('Masked attribute is read-only (use t = Table(t, masked=True)'

' to convert to a masked table)')

def _set_masked(self, masked):

"""

Set the table masked property.

Parameters

----------

masked : bool

State of table masking (`True` or `False`)

"""

if hasattr(self, '_masked'):

# The only allowed change is from None to False or True, or False to True

if self._masked is None and masked in [False, True]: