astropy.io.ascii API

An extensible ASCII table reader and writer.

Functions

astropy.io.ascii.read(table, numpy=True, guess=None, **kwargs)

Read the input table. If numpy is True (default) return the table in a numpy record array. Otherwise return the table as a dictionary of column objects using plain python lists to hold the data. Most of the default behavior for various parameters is determined by the Reader class.

Parameters:

• table – input table (file name, list of strings, or single newline-separated string)
• numpy – use the NumpyOutputter class else use BaseOutputter (default=True)
• guess – try to guess the table format (default=True)
• Reader – Reader class (default= BasicReader)
• Inputter – Inputter class
• Outputter – Outputter class
• delimiter – column delimiter string
• comment – regular expression defining a comment line in table
• quotechar – one-character string to quote fields containing special characters
• header_start – line index for the header line not counting comment lines
• data_start – line index for the start of data not counting comment lines
• data_end – line index for the end of data (can be negative to count from end)
• converters – dict of converters
• data_Splitter – Splitter class to split data columns
• header_Splitter – Splitter class to split header columns
• names – list of names corresponding to each data column
• include_names – list of names to include in output (default=None selects all names)
• exclude_names – list of names to exlude from output (applied after include_names)
• fill_values – specification of fill values for bad or missing table values
• fill_include_names – list of names to include in fill_values (default=None selects all names)
• fill_exclude_names – list of names to exlude from fill_values (applied after fill_include_names)

astropy.io.ascii.get_reader(Reader=None, Inputter=None, Outputter=None, numpy=True, **kwargs)

Initialize a table reader allowing for common customizations. Most of the default behavior for various parameters is determined by the Reader class.

Parameters:

• Reader – Reader class (default= BasicReader)
• Inputter – Inputter class
• Outputter – Outputter class
• numpy – use the NumpyOutputter class else use BaseOutputter (default=True)
• delimiter – column delimiter string
• comment – regular expression defining a comment line in table
• quotechar – one-character string to quote fields containing special characters
• header_start – line index for the header line not counting comment lines
• data_start – line index for the start of data not counting comment lines
• data_end – line index for the end of data (can be negative to count from end)
• converters – dict of converters
• data_Splitter – Splitter class to split data columns
• header_Splitter – Splitter class to split header columns
• names – list of names corresponding to each data column
• include_names – list of names to include in output (default=None selects all names)
• exclude_names – list of names to exlude from output (applied after include_names)
• fill_values – specification of fill values for bad or missing table values
• fill_include_names – list of names to include in fill_values (default=None selects all names)
• fill_exclude_names – list of names to exlude from fill_values (applied after fill_include_names)

astropy.io.ascii.write(table, output=<open file '<stdout>', mode 'w' at 0x7f3226e211e0>, Writer=None, **kwargs)

Write the input table to filename. Most of the default behavior for various parameters is determined by the Writer class.

Parameters:

• table – input table (Reader object, NumPy struct array, list of lists, etc)
• output – output [filename, file-like object] (default = sys.stdout)
• Writer – Writer class (default= Basic )
• delimiter – column delimiter string
• write_comment – string defining a comment line in table
• quotechar – one-character string to quote fields containing special characters
• formats – dict of format specifiers or formatting functions
• names – list of names corresponding to each data column
• include_names – list of names to include in output (default=None selects all names)
• exclude_names – list of names to exlude from output (applied after include_names)

astropy.io.ascii.get_writer(Writer=None, **kwargs)

Initialize a table writer allowing for common customizations. Most of the default behavior for various parameters is determined by the Writer class.

Parameters:

• Writer – Writer class (default= Basic )
• delimiter – column delimiter string
• write_comment – string defining a comment line in table
• quotechar – one-character string to quote fields containing special characters
• formats – dict of format specifiers or formatting functions
• names – list of names corresponding to each data column
• include_names – list of names to include in output (default=None selects all names)
• exclude_names – list of names to exlude from output (applied after include_names)

astropy.io.ascii.convert_list(python_type)

Return a tuple (converter_func, converter_type). The converter function converts a list into a list of the given python_type. This argument is a function that takes a single argument and returns a single value of the desired type. In general this will be one of int, float or str. The converter type is used to track the generic data type (int, float, str) that is produced by the converter function.

astropy.io.ascii.convert_numpy(numpy_type)

Return a tuple (converter_func, converter_type). The converter function converts a list into a numpy array of the given numpy_type. This type must be a valid numpy type, e.g. numpy.int, numpy.uint, numpy.int8, numpy.int64, numpy.float, numpy.float64, numpy.str. The converter type is used to track the generic data type (int, float, str) that is produced by the converter function.

astropy.io.ascii.set_guess(guess)

Set the default value of the guess parameter for read()

Parameters:guess – New default guess value (True|False)

Core Classes

class astropy.io.ascii.BaseReader

Bases: object

Class providing methods to read an ASCII table using the specified header, data, inputter, and outputter instances.

Typical usage is to instantiate a Reader() object and customize the header, data, inputter, and outputter attributes. Each of these is an object of the corresponding class.

There is one method inconsistent_handler that can be used to customize the behavior of read() in the event that a data row doesn’t match the header. The default behavior is to raise an InconsistentTableError.

comment_lines

Return lines in the table that match header.comment regexp

inconsistent_handler(str_vals, ncols)

Adjust or skip data entries if a row is inconsistent with the header.

The default implementation does no adjustment, and hence will always trigger an exception in read() any time the number of data entries does not match the header.

Note that this will not be called if the row already matches the header.

Parameters:

• str_vals – A list of value strings from the current row of the table.
• ncols – The expected number of entries from the table header.

Returns:

list of strings to be parsed into data entries in the output table. If the length of this list does not match ncols, an exception will be raised in read(). Can also be None, in which case the row will be skipped.

read(table)

Read the table and return the results in a format determined by the outputter attribute.

The table parameter is any string or object that can be processed by the instance inputter. For the base Inputter class table can be one of:

• File name
• String (newline separated) with all header and data lines (must have at least 2 lines)
• List of strings

Parameters:table – table input Returns:output table

write(table=None)

Write table as list of strings.

Parameters:table – asciitable Reader object Returns:list of strings corresponding to ASCII table

class astropy.io.ascii.BaseData

Bases: object

Base table data reader.

Parameters:

• start_line – None, int, or a function of lines that returns None or int
• end_line – None, int, or a function of lines that returns None or int
• comment – Regular expression for comment lines
• splitter_class – Splitter class for splitting data lines into columns

comment = None

default_formatter

alias of str

end_line = None

fill_exclude_names = None

fill_include_names = None

fill_values = []

formats = {}

get_data_lines(lines)

Set the data_lines attribute to the lines slice comprising the table data values.

get_str_vals()

Return a generator that returns a list of column values (as strings) for each data line.

masks(cols)

Set fill value for each column and then apply that fill value

In the first step it is evaluated with value from fill_values applies to which column using fill_include_names and fill_exclude_names. In the second step all replacements are done for the appropriate columns.

process_lines(lines)

Strip out comment lines and blank lines from list of lines

Parameters:lines – all lines in table Returns:list of lines

splitter_class

alias of DefaultSplitter

start_line = None

write(lines)

write_spacer_lines = ['ASCIITABLE_WRITE_SPACER_LINE']

class astropy.io.ascii.BaseHeader

Bases: object

Base table header reader

Parameters:

• auto_format – format string for auto-generating column names
• start_line – None, int, or a function of lines that returns None or int
• comment – regular expression for comment lines
• splitter_class – Splitter class for splitting data lines into columns
• names – list of names corresponding to each data column
• include_names – list of names to include in output (default=None selects all names)
• exclude_names – list of names to exlude from output (applied after include_names)

auto_format = 'col%d'

colnames

Return the column names of the table

comment = None

exclude_names = None

get_col_type(col)

get_cols(lines)

Initialize the header Column objects from the table lines.

Based on the previously set Header attributes find or create the column names. Sets self.cols with the list of Columns. This list only includes the actual requested columns after filtering by the include_names and exclude_names attributes. See self.names for the full list.

Parameters:lines – list of table lines Returns:None

get_type_map_key(col)

include_names = None

n_data_cols

Return the number of expected data columns from data splitting. This is either explicitly set (typically for fixedwidth splitters) or set to self.names otherwise.

names = None

process_lines(lines)

Generator to yield non-comment lines

splitter_class

alias of DefaultSplitter

start_line = None

write(lines)

write_spacer_lines = ['ASCIITABLE_WRITE_SPACER_LINE']

class astropy.io.ascii.BaseInputter

Bases: object

Get the lines from the table input and return a list of lines. The input table can be one of:

• File name
• String (newline separated) with all header and data lines (must have at least 2 lines)
• File-like object with read() method
• List of strings

get_lines(table)

Get the lines from the table input.

Parameters:table – table input Returns:list of lines

process_lines(lines)

Process lines for subsequent use. In the default case do nothing. This routine is not generally intended for removing comment lines or stripping whitespace. These are done (if needed) in the header and data line processing.

Override this method if something more has to be done to convert raw input lines to the table rows. For example the ContinuationLinesInputter derived class accounts for continuation characters if a row is split into lines.

class astropy.io.ascii.BaseOutputter

Bases: object

Output table as a dict of column objects keyed on column name. The table data are stored as plain python lists within the column objects.

converters = {}

default_converters = [(<function converter at 0x4bb7b90>, <class 'astropy.io.ascii.core.IntType'>), (<function converter at 0x4bb7c08>, <class 'astropy.io.ascii.core.FloatType'>), (<function converter at 0x4bb7c80>, <class 'astropy.io.ascii.core.StrType'>)]

class astropy.io.ascii.BaseSplitter

Bases: object

Base splitter that uses python’s split method to do the work.

This does not handle quoted values. A key feature is the formulation of __call__ as a generator that returns a list of the split line values at each iteration.

There are two methods that are intended to be overridden, first process_line() to do pre-processing on each input line before splitting and process_val() to do post-processing on each split string value. By default these apply the string strip() function. These can be set to another function via the instance attribute or be disabled entirely, for example:

reader.header.splitter.process_val = lambda x: x.lstrip()
reader.data.splitter.process_val = None

Parameters:delimiter – one-character string used to separate fields

delimiter = None

join(vals)

process_line(line)

Remove whitespace at the beginning or end of line. This is especially useful for whitespace-delimited files to prevent spurious columns at the beginning or end.

process_val(val)

Remove whitespace at the beginning or end of value.

class astropy.io.ascii.Column(name, index)

Bases: object

Table column.

The key attributes of a Column object are:

• name : column name
• index : column index (first column has index=0, second has index=1, etc)
• type : column type (NoType, StrType, NumType, FloatType, IntType)
• str_vals : list of column values as strings
• data : list of converted column values

class astropy.io.ascii.DefaultSplitter

Bases: astropy.io.ascii.core.BaseSplitter

Default class to split strings into columns using python csv. The class attributes are taken from the csv Dialect class.

Typical usage:

# lines = ..
splitter = asciitable.DefaultSplitter()
for col_vals in splitter(lines):
    for col_val in col_vals:
         ...

Parameters:

• delimiter – one-character string used to separate fields.
• doublequote – control how instances of quotechar in a field are quoted
• escapechar – character to remove special meaning from following character
• quotechar – one-character stringto quote fields containing special characters
• quoting – control when quotes are recognised by the reader
• skipinitialspace – ignore whitespace immediately following the delimiter

delimiter = ' '

doublequote = True

escapechar = None

join(vals)

process_line(line)

Remove whitespace at the beginning or end of line. This is especially useful for whitespace-delimited files to prevent spurious columns at the beginning or end. If splitting on whitespace then replace unquoted tabs with space first

process_val(val)

Remove whitespace at the beginning or end of value.

quotechar = '"'

quoting = 0

skipinitialspace = True

class astropy.io.ascii.DictLikeNumpy(*args, **kwargs)

Bases: dict

Provide minimal compatibility with numpy rec array API for BaseOutputter object:

table = asciitable.read('mytable.dat', numpy=False)
table.field('x')    # List of elements in column 'x'
table.dtype.names   # get column names in order
table[1]            # returns row 1 as a list
table[1][2]         # 3nd column in row 1
table['col1'][1]    # Row 1 in column col1
for row_vals in table:  # iterate over table rows
    print row_vals  # print list of vals in each row

class Dtype

Bases: object

DictLikeNumpy.field(colname)

DictLikeNumpy.next()

class astropy.io.ascii.InconsistentTableError

Bases: exceptions.ValueError

class astropy.io.ascii.NumpyOutputter

Bases: astropy.io.ascii.core.BaseOutputter

Output the table as a numpy.rec.recarray

Missing or bad data values are handled at two levels. The first is in the data reading step where if data.fill_values is set then any occurences of a bad value are replaced by the correspond fill value. At the same time a boolean list mask is created in the column object.

The second stage is when converting to numpy arrays which by default generates masked arrays, if data.fill_values is set and plain arrays if it is not. In the rare case that plain arrays are needed set auto_masked (default = True) and default_masked (default = False) to control this behavior as follows:

auto_masked	default_masked	fill_values	output
–	True	–	masked_array
–	False	None	array
True	–	dict(..)	masked_array
False	–	dict(..)	array

To set these values use:

Outputter = asciitable.NumpyOutputter()
Outputter.default_masked = True

auto_masked_array = True

converters = {}

default_converters = [(<function converter at 0x4bb7e60>, <class 'astropy.io.ascii.core.IntType'>), (<function converter at 0x4bb7ed8>, <class 'astropy.io.ascii.core.FloatType'>), (<function converter at 0x4bb7f50>, <class 'astropy.io.ascii.core.StrType'>)]

default_masked_array = False

Extension Reader Classes

The following classes extend the base Reader functionality to handle different table formats. Some, such as the Basic Reader class are fairly general and include a number of configurable attributes. Others such as Cds or Daophot are specialized to read certain well-defined but idiosyncratic formats.

• AASTex: AASTeX deluxetable used for AAS journals
• Basic: basic table with customizable delimiters and header configurations
• Cds: CDS format table (also Vizier and ApJ machine readable tables)
• CommentedHeader: column names given in a line that begins with the comment character
• Daophot: table from the IRAF DAOphot package
• FixedWidth: table with fixed-width columns (see also Fixed-width Gallery)
• FixedWidthNoHeader: table with fixed-width columns and no header
• FixedWidthTwoLine: table with fixed-width columns and a two-line header
• Ipac: IPAC format table
• Latex: LaTeX table with datavalue in the tabular environment
• NoHeader: basic table with no header where columns are auto-named
• Rdb: tab-separated values with an extra line after the column definition line
• Tab: tab-separated values

class astropy.io.ascii.AASTex(**kwargs)

Bases: astropy.io.ascii.latex.Latex

Write and read AASTeX tables.

This class implements some AASTeX specific commands. AASTeX is used for the AAS (American Astronomical Society) publications like ApJ, ApJL and AJ.

It derives from Latex and accepts the same keywords (see Latex for documentation). However, the keywords header_start, header_end, data_start and data_end in latexdict have no effect.

class astropy.io.ascii.Basic

Bases: astropy.io.ascii.core.BaseReader

Read a character-delimited table with a single header line at the top followed by data lines to the end of the table. Lines beginning with # as the first non-whitespace character are comments. This reader is highly configurable.

rdr = asciitable.get_reader(Reader=asciitable.Basic)
rdr.header.splitter.delimiter = ' '
rdr.data.splitter.delimiter = ' '
rdr.header.start_line = 0
rdr.data.start_line = 1
rdr.data.end_line = None
rdr.header.comment = r'\s*#'
rdr.data.comment = r'\s*#'

Example table:

# Column definition is the first uncommented line
# Default delimiter is the space character.
apples oranges pears

# Data starts after the header column definition, blank lines ignored
1 2 3
4 5 6

class astropy.io.ascii.Cds(readme=None)

Bases: astropy.io.ascii.core.BaseReader

Read a CDS format table: http://vizier.u-strasbg.fr/doc/catstd.htx. Example:

.. py:method:: Cds.write(table=None)

module:astropy.io.ascii

Not available for the Cds class (raises NotImplementedError)

class astropy.io.ascii.CommentedHeader

Bases: astropy.io.ascii.core.BaseReader

Read a file where the column names are given in a line that begins with the header comment character. The default delimiter is the <space> character.:

# col1 col2 col3
# Comment line
1 2 3
4 5 6

class astropy.io.ascii.Daophot

Bases: astropy.io.ascii.core.BaseReader

Read a DAOphot file. Example:

#K MERGERAD   = INDEF                   scaleunit  %-23.7g  
#K IRAF = NOAO/IRAFV2.10EXPORT version %-23s
#K USER = davis name %-23s
#K HOST = tucana computer %-23s
#
#N ID    XCENTER   YCENTER   MAG         MERR          MSKY           NITER    \
#U ##    pixels    pixels    magnitudes  magnitudes    counts         ##       \
#F %-9d  %-10.3f   %-10.3f   %-12.3f     %-14.3f       %-15.7g        %-6d     
#
#N         SHARPNESS   CHI         PIER  PERROR                                \
#U         ##          ##          ##    perrors                               \
#F         %-23.3f     %-12.3f     %-6d  %-13s
#
14       138.538   256.405   15.461      0.003         34.85955       4        \
-0.032      0.802       0     No_error

The keywords defined in the #K records are available via the Daophot reader object:

reader = asciitable.get_reader(Reader=asciitable.DaophotReader)
data = reader.read('t/daophot.dat')
for keyword in reader.keywords:
    print keyword.name, keyword.value, keyword.units, keyword.format

read(table)

write(table=None)

class astropy.io.ascii.FixedWidth(col_starts=None, col_ends=None, delimiter_pad=' ', bookend=True)

Bases: astropy.io.ascii.core.BaseReader

Read or write a fixed width table with a single header line that defines column names and positions. Examples:

# Bar delimiter in header and data

|  Col1 |   Col2      |  Col3 |
|  1.2  | hello there |     3 |
|  2.4  | many words  |     7 |

# Bar delimiter in header only

Col1 |   Col2      | Col3 
1.2    hello there    3 
2.4    many words     7 

# No delimiter with column positions specified as input

Col1       Col2Col3 
 1.2hello there   3 
 2.4many words    7 

See the Fixed-width Gallery for specific usage examples.

Parameters:

• col_starts – list of start positions for each column (0-based counting)
• col_ends – list of end positions (inclusive) for each column
• delimiter_pad – padding around delimiter when writing (default = None)
• bookend – put the delimiter at start and end of line when writing (default = False)

class astropy.io.ascii.FixedWidthNoHeader(col_starts=None, col_ends=None, delimiter_pad=' ', bookend=True)

Bases: astropy.io.ascii.fixedwidth.FixedWidth

Read or write a fixed width table which has no header line. Column names are either input (names keyword) or auto-generated. Column positions are determined either by input (col_starts and col_stops keywords) or by splitting the first data line. In the latter case a delimiter is required to split the data line.

Examples:

# Bar delimiter in header and data

|  1.2  | hello there |     3 |
|  2.4  | many words  |     7 |

# Compact table having no delimiter and column positions specified as input

1.2hello there3 
2.4many words 7 

This class is just a convenience wrapper around FixedWidth but with header.start_line = None and data.start_line = 0.

See the Fixed-width Gallery for specific usage examples.

Parameters:

• col_starts – list of start positions for each column (0-based counting)
• col_ends – list of end positions (inclusive) for each column
• delimiter_pad – padding around delimiter when writing (default = None)
• bookend – put the delimiter at start and end of line when writing (default = False)

class astropy.io.ascii.FixedWidthTwoLine(position_line=1, position_char='-', delimiter_pad=None, bookend=False)

Bases: astropy.io.ascii.fixedwidth.FixedWidth

Read or write a fixed width table which has two header lines. The first header line defines the column names and the second implicitly defines the column positions. Examples:

# Typical case with column extent defined by ---- under column names.

 col1    col2         <== header_start = 0
-----  ------------   <== position_line = 1, position_char = "-"
  1     bee flies     <== data_start = 2
  2     fish swims

# Pretty-printed table 

+------+------------+
| Col1 |   Col2     |
+------+------------+
|  1.2 | "hello"    |
|  2.4 | there world|
+------+------------+

See the Fixed-width Gallery for specific usage examples.

Parameters:

• position_line – row index of line that specifies position (default = 1)
• position_char – character used to write the position line (default = “-”)
• delimiter_pad – padding around delimiter when writing (default = None)
• bookend – put the delimiter at start and end of line when writing (default = False)

class astropy.io.ascii.Ipac

Bases: astropy.io.ascii.core.BaseReader

Read an IPAC format table: http://irsa.ipac.caltech.edu/applications/DDGEN/Doc/ipac_tbl.html:

\name=value                                                    
\ Comment                                                      
|  column1 |  column2 | column3 | column4  |    column5       |
|  double  |  double  |   int   |   double |     char         |
|   unit   |   unit   |   unit  |    unit  |     unit         |
|   null   |   null   |   null  |    null  |     null         |
 2.0978     29.09056   73765     2.06000    B8IVpMnHg          

Or:

|-----ra---|----dec---|---sao---|------v---|----sptype--------|
  2.09708   29.09056     73765    2.06000   B8IVpMnHg

Caveats:

• Data type, Units, and Null value specifications are ignored.
• Keywords are ignored.
• The IPAC spec requires the first two header lines but this reader only requires the initial column name definition line

Overcoming these limitations would not be difficult, code contributions welcome from motivated users.

write(table=None)

Not available for the Ipac class (raises NotImplementedError)

class astropy.io.ascii.Latex(ignore_latex_commands=['hline', 'vspace', 'tableline'], latexdict={}, caption='', col_align=None)

Bases: astropy.io.ascii.core.BaseReader

Write and read LaTeX tables.

This class implements some LaTeX specific commands. Its main purpose is to write out a table in a form that LaTeX can compile. It is beyond the scope of this class to implement every possible LaTeX command, instead the focus is to generate a syntactically valid LaTeX tables. This class can also read simple LaTeX tables (one line per table row, no \multicolumn or similar constructs), specifically, it can read the tables that it writes.

Reading a LaTeX table, the following keywords are accepted:

ignore_latex_commands :

Lines starting with these LaTeX commands will be treated as comments (i.e. ignored).

When writing a LaTeX table, the some keywords can customize the format. Care has to be taken here, because python interprets \ in a string as an escape character. In order to pass this to the output either format your strings as raw strings with the r specifier or use a double \\. Examples:

caption = r'My table \label{mytable}'
caption = 'My table \\label{mytable}'

latexdict : Dictionary of extra parameters for the LaTeX output

• tabletype : used for first and last line of table.

  The default is \begin{table}. The following would generate a table, which spans the whole page in a two-column document:

  asciitable.write(data, sys.stdout, Writer = asciitable.Latex,
               latexdict = {'tabletype': 'table*'})
  

• col_align : Alignment of columns

  If not present all columns will be centered.

• caption : Table caption (string or list of strings)

  This will appear above the table as it is the standard in many scientific publications. If you prefer a caption below the table, just write the full LaTeX command as latexdict['tablefoot'] = r'\caption{My table}'

• preamble, header_start, header_end, data_start, data_end, tablefoot: Pure LaTeX

  Each one can be a string or a list of strings. These strings will be inserted into the table without any further processing. See the examples below.

• units : dictionary of strings

  Keys in this dictionary should be names of columns. If present, a line in the LaTeX table directly below the column names is added, which contains the values of the dictionary. Example:

  import asciitable
  import asciitable.latex
  import sys
  data = {'name': ['bike', 'car'], 'mass': [75,1200], 'speed': [10, 130]}
  asciitable.write(data, sys.stdout, Writer = asciitable.Latex,
                   latexdict = {'units': {'mass': 'kg', 'speed': 'km/h'}})
  

  If the column has no entry in the units dictionary, it defaults to ' '.

Run the following code to see where each element of the dictionary is inserted in the LaTeX table:

import asciitable
import asciitable.latex
import sys
data = {'cola': [1,2], 'colb': [3,4]}
asciitable.write(data, sys.stdout, Writer = asciitable.Latex,
                 latexdict = asciitable.latex.latexdicts['template'])

Some table styles are predefined in the dictionary asciitable.latex.latexdicts. The following generates in table in style preferred by A&A and some other journals:

asciitable.write(data, sys.stdout, Writer = asciitable.Latex,
                 latexdict = asciitable.latex.latexdicts['AA'])

As an example, this generates a table, which spans all columns and is centered on the page:

asciitable.write(data, sys.stdout, Writer = asciitable.Latex,
                 col_align = '|lr|',
                 latexdict = {'preamble': r'egin{center}', 'tablefoot': r'\end{center}',
                              'tabletype': 'table*'})

caption : Set table caption

Shorthand for:

latexdict['caption'] = caption

col_align : Set the column alignment.

If not present this will be auto-generated for centered columns. Shorthand for:

latexdict['col_align'] = col_align

write(table=None)

class astropy.io.ascii.Memory

Bases: astropy.io.ascii.core.BaseReader

Read a table from a data object in memory. Several input data formats are supported:

Output of asciitable.read():

table = asciitable.get_reader(Reader=asciitable.Daophot)
data = table.read('t/daophot.dat')
mem_data_from_table = asciitable.read(table, Reader=asciitable.Memory)
mem_data_from_data = asciitable.read(data, Reader=asciitable.Memory)

Numpy structured array:

data = numpy.zeros((2,), dtype=[('col1','i4'), ('col2','f4'), ('col3', 'a10')])
data[:] = [(1, 2., 'Hello'), (2, 3., "World")]
mem_data = asciitable.read(data, Reader=asciitable.Memory)

Numpy masked structured array:

data = numpy.ma.zeros((2,), dtype=[('col1','i4'), ('col2','f4'), ('col3', 'a10')])
data[:] = [(1, 2., 'Hello'), (2, 3., "World")]
data['col2'] = ma.masked
mem_data = asciitable.read(data, Reader=asciitable.Memory)

In the current version all masked values will be converted to nan.

Sequence of sequences:

data = [[1, 2,   3      ],
        [4, 5.2, 6.1    ],
        [8, 9,   'hello']]
mem_data = asciitable.read(data, Reader=asciitable.Memory, names=('c1','c2','c3'))

Dict of sequences:

data = {'c1': [1, 2, 3],
        'c2': [4, 5.2, 6.1],
        'c3': [8, 9, 'hello']}
mem_data = asciitable.read(data, Reader=asciitable.Memory, names=('c1','c2','c3'))

read(table)

write(table=None)

Not available for the Memory class (raises NotImplementedError)

class astropy.io.ascii.NoHeader

Bases: astropy.io.ascii.basic.Basic

Read a table with no header line. Columns are autonamed using header.auto_format which defaults to “col%d”. Otherwise this reader the same as the Basic class from which it is derived. Example:

# Table data
1 2 "hello there"
3 4 world

class astropy.io.ascii.Rdb

Bases: astropy.io.ascii.basic.Tab

Read a tab-separated file with an extra line after the column definition line. The RDB format meets this definition. Example:

col1 <tab> col2 <tab> col3
N <tab> S <tab> N
1 <tab> 2 <tab> 5

In this reader the second line is just ignored.

class astropy.io.ascii.Tab

Bases: astropy.io.ascii.basic.Basic

Read a tab-separated file. Unlike the Basic reader, whitespace is not stripped from the beginning and end of lines. By default whitespace is still stripped from the beginning and end of individual column values.

Example:

col1 <tab> col2 <tab> col3
# Comment line
1 <tab> 2 <tab> 5

Other extension classes

These classes provide support for extension readers.

class astropy.io.ascii.cds.CdsData

Bases: astropy.io.ascii.core.BaseData

CDS table data reader

process_lines(lines)

Skip over CDS header by finding the last section delimiter

splitter_class

alias of FixedWidthSplitter

class astropy.io.ascii.cds.CdsHeader(readme=None)

Bases: astropy.io.ascii.core.BaseHeader

col_type_map = {'i': <class 'astropy.io.ascii.core.IntType'>, 'a': <class 'astropy.io.ascii.core.StrType'>, 'e': <class 'astropy.io.ascii.core.FloatType'>, 'f': <class 'astropy.io.ascii.core.FloatType'>}

get_cols(lines)

Initialize the header Column objects from the table lines for a CDS header.

Parameters:lines – list of table lines Returns:list of table Columns

get_type_map_key(col)

class astropy.io.ascii.basic.CommentedHeaderHeader

Bases: astropy.io.ascii.core.BaseHeader

Header class for which the column definition line starts with the comment character. See the CommentedHeader class for an example.

process_lines(lines)

Return only lines that start with the comment regexp. For these lines strip out the matching characters.

write(lines)

class astropy.io.ascii.ContinuationLinesInputter

Bases: astropy.io.ascii.core.BaseInputter

Inputter where lines ending in continuation_char are joined with the subsequent line. Example:

col1 col2 col3
1       2 3
4 5       6

continuation_char = '\\'

process_lines(lines)

class astropy.io.ascii.daophot.DaophotHeader

Bases: astropy.io.ascii.core.BaseHeader

Read the header from a file produced by the IRAF DAOphot routine.

get_cols(lines)

Initialize the header Column objects from the table lines for a DAOphot header. The DAOphot header is specialized so that we just copy the entire BaseHeader get_cols routine and modify as needed.

Parameters:lines – list of table lines Returns:list of table Columns

class astropy.io.ascii.FixedWidthSplitter

Bases: astropy.io.ascii.core.BaseSplitter

Split line based on fixed start and end positions for each col in self.cols.

This class requires that the Header class will have defined col.start and col.end for each column. The reference to the header.cols gets put in the splitter object by the base Reader.read() function just in time for splitting data lines by a data object.

Note that the start and end positions are defined in the pythonic style so line[start:end] is the desired substring for a column. This splitter class does not have a hook for process_lines since that is generally not useful for fixed-width input.

bookend = False

delimiter_pad = ''

join(vals, widths)

class astropy.io.ascii.FixedWidthHeader

Bases: astropy.io.ascii.core.BaseHeader

Fixed width table header reader.

The key settable class attributes are:

Parameters:

• auto_format – format string for auto-generating column names
• start_line – None, int, or a function of lines that returns None or int
• comment – regular expression for comment lines
• splitter_class – Splitter class for splitting data lines into columns
• names – list of names corresponding to each data column
• include_names – list of names to include in output (default=None selects all names)
• exclude_names – list of names to exlude from output (applied after include_names)
• position_line – row index of line that specifies position (default = 1)
• position_char – character used to write the position line (default = “-”)
• col_starts – list of start positions for each column (0-based counting)
• col_ends – list of end positions (inclusive) for each column
• delimiter_pad – padding around delimiter when writing (default = None)
• bookend – put the delimiter at start and end of line when writing (default = False)

get_cols(lines)

Initialize the header Column objects from the table lines.

Based on the previously set Header attributes find or create the column names. Sets self.cols with the list of Columns. This list only includes the actual requested columns after filtering by the include_names and exclude_names attributes. See self.names for the full list.

Parameters:lines – list of table lines Returns:None

get_fixedwidth_params(line)

Split line on the delimiter and determine column values and column start and end positions. This might include null columns with zero length (e.g. for header row = "| col1 || col2 | col3 |" or header2_row = "----- ------- -----"). The null columns are stripped out. Returns the values between delimiters and the corresponding start and end positions.

Parameters:line – input line Returns:(vals, starts, ends)

get_line(lines, index)

position_line = None

write(lines)

class astropy.io.ascii.FixedWidthData

Bases: astropy.io.ascii.core.BaseData

Base table data reader.

Parameters:

• start_line – None, int, or a function of lines that returns None or int
• end_line – None, int, or a function of lines that returns None or int
• comment – Regular expression for comment lines
• splitter_class – Splitter class for splitting data lines into columns

splitter_class

alias of FixedWidthSplitter

write(lines)

class astropy.io.ascii.ipac.IpacData

Bases: astropy.io.ascii.core.BaseData

IPAC table data reader

comment = '[|\\\\]'

splitter_class

alias of FixedWidthSplitter

class astropy.io.ascii.ipac.IpacHeader

Bases: astropy.io.ascii.core.BaseHeader

IPAC table header

col_type_map = {'real': <class 'astropy.io.ascii.core.FloatType'>, 'int': <class 'astropy.io.ascii.core.IntType'>, 'float': <class 'astropy.io.ascii.core.FloatType'>, 'char': <class 'astropy.io.ascii.core.StrType'>, 'date': <class 'astropy.io.ascii.core.StrType'>, 'c': <class 'astropy.io.ascii.core.StrType'>, 'd': <class 'astropy.io.ascii.core.FloatType'>, 'f': <class 'astropy.io.ascii.core.FloatType'>, 'i': <class 'astropy.io.ascii.core.IntType'>, 'double': <class 'astropy.io.ascii.core.FloatType'>, 'l': <class 'astropy.io.ascii.core.IntType'>, 'long': <class 'astropy.io.ascii.core.IntType'>, 'r': <class 'astropy.io.ascii.core.FloatType'>}

comment = '\\\\'

get_cols(lines)

Initialize the header Column objects from the table lines.

Based on the previously set Header attributes find or create the column names. Sets self.cols with the list of Columns. This list only includes the actual requested columns after filtering by the include_names and exclude_names attributes. See self.names for the full list.

Parameters:lines – list of table lines Returns:list of table Columns

process_lines(lines)

Generator to yield IPAC header lines, i.e. those starting and ending with delimiter character.

splitter_class

alias of BaseSplitter

class astropy.io.ascii.latex.LatexHeader

Bases: astropy.io.ascii.core.BaseHeader

header_start = '\\begin{tabular}'

start_line(lines)

write(lines)

class astropy.io.ascii.latex.LatexData

Bases: astropy.io.ascii.core.BaseData

data_end = '\\end{tabular}'

data_start = None

end_line(lines)

start_line(lines)

write(lines)

class astropy.io.ascii.latex.LatexSplitter

Bases: astropy.io.ascii.core.BaseSplitter

Split LaTeX table date. Default delimiter is &.

delimiter = '&'

join(vals)

Join values together and add a few extra spaces for readability

process_line(line)

Remove whitespace at the beginning or end of line. Also remove at end of line

process_val(val)

Remove whitespace and {} at the beginning or end of value.

class astropy.io.ascii.latex.AASTexHeader

Bases: astropy.io.ascii.latex.LatexHeader

In a deluxetable some header keywords differ from standard LaTeX.

This header is modified to take that into account.

header_start = '\\tablehead'

start_line(lines)

write(lines)

class astropy.io.ascii.latex.AASTexData

Bases: astropy.io.ascii.latex.LatexData

In a deluxetable the data is enclosed in startdata and enddata

data_end = '\\enddata'

data_start = '\\startdata'

start_line(lines)

write(lines)

class astropy.io.ascii.latex.AASTexHeaderSplitter

Bases: astropy.io.ascii.latex.LatexSplitter

extract column names from a deluxetable

This splitter expects the following LaTeX code in a single line:

ablehead{colhead{col1} & ... & colhead{coln}}

join(vals)

process_line(line)

extract column names from tablehead