What’s New in Astropy 1.0?


Astropy 1.0 is a major release that adds significant new functionality since the 0.4.x series of releases.

In particular, coordinate conversions to/from Altitude/Azimuth are now supported (see Support for Alt/Az coordinates), a new package to help with data visualization has been added (see New data visualization subpackage), and a new package for common analytic functions is now also included (see New analytic functions subpackage).

The ASCII Tables (astropy.io.ascii) sub-package now includes fast C-based readers/writers for common formats, and also supports a new ASCII format that better preserves meta-data (see New ASCII features), the modeling package has been significantly improved and now supports composite models (see New modeling features), and the Table class can now include SkyCoord and Time objects containing arrays (see New Table features).

In addition to these major changes, Astropy 1.0 includes a large number of smaller improvements and bug fixes, which are described in the Full Changelog. By the numbers:

  • 681 issues have been closed since v0.4
  • 419 pull requests have been merged since v0.4
  • 122 distinct people have contributed code

About Long-term support

Astropy v1.0 is a long-term support (LTS) release. This means v1.0 will be supported with bug fixes for 2 years from its release, rather than 6 months like the non-LTS releases. More details about this, including a wider rationale for Astropy’s version numbering scheme, can be found in Astropy Proposal for Enhancement 2.

Note that different sub-packages in Astropy have different stability levels. See the Current status of sub-packages page for an overview of the status of major components. LTS can be expected for anything with green or blue (stable or mature) status on that page. For yellow (in development) subpackages, LTS may be provided, but major changes may prevent backporting of complex changes, particularly if they are connected to new features.

Support for Alt/Az coordinates

The coordinates package now supports conversion to/from AltAz coordinates. This means coordinates can now be used for planning observations. For example:

>>> from astropy import units as u
>>> from astropy.time import Time
>>> from astropy.coordinates import SkyCoord, EarthLocation, AltAz
>>> greenwich = EarthLocation(lat=51.477*u.deg,lon=0*u.deg)
>>> albireo = SkyCoord('19h30m43.2805s +27d57m34.8483s')
>>> altaz = albireo.transform_to(AltAz(location=greenwich, obstime=Time('2014-6-21 0:00')))
>>> print altaz.alt, altaz.az
60d32m28.4576s 133d45m36.4967s

For a more detailed outline of this new functionality, see the Determining and plotting the altitude/azimuth of a celestial object and the AltAz documentation.

To enable this functionality, coordinates now also contains the full IAU-sanctioned coordinate transformation stack from ICRS to AltAz. To view the full set of coordinate frames now available, see the coordinates Reference/API.

New Galactocentric coordinate frame

Added a new, customizable Galactocentric coordinate frame. The other coordinate frames (e.g., ICRS, Galactic) are all Heliocentric (or barycentric). The center of this new coordinate frame is at the center of the Galaxy, with customizable parameters allowing the user to specify the distance to the Galactic center (galcen_distance), the ICRS position of the Galactic center (galcen_ra, galcen_dec), the height of the Sun above the Galactic midplane (z_sun), and a final roll angle that allows for specifying the orientation of the z axis (roll):

>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord, Galactocentric
>>> c = SkyCoord(ra=152.718 * u.degree,
...              dec=-11.214 * u.degree,
...              distance=21.5 * u.kpc)
>>> c.transform_to(Galactocentric)
<SkyCoord (Galactocentric: galcen_distance=8.3 kpc, galcen_ra=266d24m18.36s, galcen_dec=-28d56m10.23s, z_sun=27.0 pc, roll=0.0 deg): (x, y, z) in kpc
    (-13.6512648452, -16.6847348677, 12.4862582821)>
>>> c.transform_to(Galactocentric(galcen_distance=8*u.kpc, z_sun=15*u.pc))
<SkyCoord (Galactocentric: galcen_distance=8.0 kpc, galcen_ra=266d24m18.36s, galcen_dec=-28d56m10.23s, z_sun=15.0 pc, roll=0.0 deg): (x, y, z) in kpc
    (-13.368458678, -16.6847348677, 12.466872262)>

New data visualization subpackage

The new Data Visualization package is intended to collect functionality that can be helpful when visualizing data. At the moment, the main functionality is image normalizing (including both scaling and stretching) but this will be expanded in future. Included in the image normalization functionality is the ability to compute interval limits on data, (such as percentile limits), stretching with non-linear functions (such as square root or arcsinh functions), and the ability to use custom stretches in Matplotlib that are correctly reflected in the colorbar:

import numpy as np
import matplotlib.pyplot as plt

from astropy.visualization import SqrtStretch
from astropy.visualization.mpl_normalize import ImageNormalize

# Generate test image
image = np.arange(65536).reshape((256, 256))

# Create normalizer object
norm = ImageNormalize(vmin=0., vmax=65536, stretch=SqrtStretch())

fig = plt.figure(figsize=(6,3))
ax = fig.add_subplot(1,1,1)
im = ax.imshow(image, norm=norm, origin='lower', aspect='auto')

(png, svg, pdf)


New analytic functions subpackage

This subpackage provides analytic functions that are commonly used in astronomy. These already understand Quantity, i.e., they can handle units of input and output parameters. For instance, to calculate the blackbody flux for 10000K at 6000 Angstrom:

>>> from astropy import units as u
>>> from astropy.analytic_functions import blackbody_lambda, blackbody_nu
>>> blackbody_lambda(6000 * u.AA, 10000 * u.K)
<Quantity 15315791.836941158 erg / (Angstrom cm2 s sr)>
>>> blackbody_nu(6000 * u.AA, 10000 * u.K)
<Quantity 0.00018391673686797075 erg / (cm2 Hz s sr)

See Analytic Functions (astropy.analytic_functions) for more details.

In future versions of Astropy, the functions in this module might also be accessible as Model classes.

New ASCII features

Fast readers/writers for ASCII files

The astropy.io.ascii module now includes a significantly faster Cython/C engine for reading and writing ASCII files. This is available for the following formats: basic, commented_header, csv, no_header, rdb, and tab. On average the new engine is about 4 to 5 times faster than the corresponding pure-Python implementation, and is often comparable to the speed of the pandas ASCII file interface (read_csv and to_csv). The fast reader has parallel processing option that allows harnessing multiple cores for input parsing to achieve even greater speed gains.

By default, read() and write() will attempt to use the fast C engine when dealing with compatible formats. Certain features of the full read / write interface are not available in the fast version, in which case the pure-Python version will automatically be used.

For full details including extensive performance testing, see Fast ASCII I/O.

Enhanced CSV format

One of the problems when storing a table in an ASCII format is preserving table meta-data such as comments, keywords and column data types, units, and descriptions. Using the newly defined Enhanced Character Separated Values format it is now possible to write a table to an ASCII-format file and read it back with no loss of information. The ECSV format has been designed to be both human-readable and compatible with most simple CSV readers.

In the example below we show writing a table that has float32 and bool types. This illustrates the simple look of the format which has a few header lines (starting with #) in YAML format and then the data values in CSV format.

>>> t = Table()
>>> t['x'] = Column([1.0, 2.0], unit='m', dtype='float32')
>>> t['y'] = Column([False, True], dtype='bool')

>>> from astropy.extern.six.moves import StringIO
>>> fh = StringIO()
>>> t.write(fh, format='ascii.ecsv')  
>>> table_string = fh.getvalue()      
>>> print(table_string)               
# %ECSV 0.9
# ---
# columns:
# - {name: x, unit: m, type: float32}
# - {name: y, type: bool}
x y
1.0 False
2.0 True

Without the header this table would get read back with different types (float64 and string respectively) and no unit values. Instead with the automatically-detected ECSV we get:

>>> Table.read(table_string, format='ascii')  
<Table masked=False length=2>
   x      y
float32  bool
------- -----
    1.0 False
    2.0  True

Note that using the ECSV reader requires the PyYAML package to be installed.

New modeling features

New subclasses of Model are now a bit easier to define, requiring less boilerplate code in general. Now all that is necessary to define a new model class is an evaluate method that computes the model. Optionally one can define fittable parameters, a fit_deriv, and/or an inverse. The new, improved custom_model decorator reduces the boilerplate needed for many models even more. See Defining New Model Classes for more details.

Array broadcasting has also been improved, enabling a broader range of possibilities for the values of model parameters and inputs. Support has also been improved for Model Sets (previously referred to as parameter sets) which can be thought of like an array of models of the same class, each with different sets of parameters, which can be fitted simultaneously either to the same data, or to different data sets per model. See Instantiating and Evaluating Models for more details.

It is now possible to create compound models by combining existing models using the standard arithmetic operators such as + and *, as well as functional composition using the | operator. This provides a powerful and flexible new way to create more complex models without having to define any special classes or functions. For example:

>>> from astropy.modeling.models import Gaussian1D
>>> gaussian1 = Gaussian1D(1, 0, 0.2)
>>> gaussian2 = Gaussian1D(2.5, 0.5, 0.1)
>>> sum_of_gaussians = gaussian1 + gaussian2

The resulting model works like any other model, and also works with the fitting framework. See the introduction to compound models and full compound models documentation for more examples.

New Table features

Refactor of table infrastructure

The underlying data container for the Astropy Table object has been changed in Astropy v1.0. Previously, tables were stored internally as a Numpy structured array object, with column access being a memory view of the corresponding Numpy array field. Starting with this release the fundamental data container is an ordered dictionary of individual column objects and each Column object is the sole owner of its data.

The biggest impact to users is that operations such as adding or removing table columns is now significantly faster because there is no structured array to rebuild each time.

For details please see Table implementation change in 1.0.

Support for ‘mixin’ columns

Version v1.0 of Astropy introduces a new concept of the “Mixin Column” in tables which allows integration of appropriate non-Column based class objects within a Table object. These mixin column objects are not converted in any way but are used natively.

The available built-in mixin column classes are Quantity, SkyCoord, and Time. User classes for array-like objects that support the Mixin protocol can also be used in tables as mixin columns.


While the Astropy developers are excited about this new capability and intend to improve it, the interface for using mixin columns is not stable at this point and it is not recommended for use in production code.

As an example we can create a table and add a time column:

>>> from astropy.table import Table
>>> from astropy.time import Time
>>> t = Table()
>>> t['index'] = [1, 2]
>>> t['time'] = Time(['2001-01-02T12:34:56', '2001-02-03T00:01:02'])
>>> print(t)
index           time
----- -----------------------
    1 2001-01-02T12:34:56.000
    2 2001-02-03T00:01:02.000

The important point here is that the time column is a bona fide Time object:

>>> t['time']
<Time object: scale='utc' format='isot' value=['2001-01-02T12:34:56.000' '2001-02-03T00:01:02.000']>
>>> t['time'].mjd
array([ 51911.52425926,  51943.00071759])

For all the details, including a new QTable class, please see Mixin columns.

Integration with WCSAxes

The WCS class can now be used as a Matplotlib projection to make plots of images with WCS coordinates overlaid, making use of the WCSAxes affiliated package behind the scenes. More information on using this functionality can be found in the WCSAxes documentation.

Deprecation and backward-incompatible changes

Astropy is now no longer supported on Python 3.1 and 3.2. Python 3.x users should use Python 3.3 or 3.4. In addition, support for Numpy 1.5 has been dropped, and users should make sure they are using Numpy 1.6 or later.

Full change log

To see a detailed list of all changes in version v1.0, including changes in API, please see the Full Changelog.