sunpy · Cadair · Dec 14, 2018 · May 1, 2018 · May 1, 2018 · May 2, 2018
diff --git a/.gitignore b/.gitignore
@@ -209,3 +209,5 @@ docs/generated
 docs/api/
 # This is incase you run the figure tests
 figure_test_images*
+
+tags
diff --git a/.travis.yml b/.travis.yml
@@ -80,7 +80,7 @@ matrix:
            env: PYTHON_VERSION=3.6
 
          - python: 3.6
-           stage: Cron tests
+           stage: Comprehensive tests
            env: ASTROPY_VERSION='dev'
 
          - python: 3.6

diff --git a/changelog/2611.breaking.rst b/changelog/2611.breaking.rst
@@ -0,0 +1 @@
+Make ``sunpy.time.parse_time`` return ``astropy.time.Time`` instead of ``datetime.datetime``.
diff --git a/changelog/2638.breaking.rst b/changelog/2638.breaking.rst
@@ -0,0 +1 @@
+The properties and methods of ``sunpy.time.TimeRange`` returns ``astropy.time.Time`` and ``astropy.time.TimeDelta`` instead of ``datetime.datetime`` and ``datetime.timedelta`` respectively.
diff --git a/changelog/2676.breaking.rst b/changelog/2676.breaking.rst
@@ -0,0 +1 @@
+`obstime` keyword param of ``sunpy.instr.goes._goes_lx`` takes a non-scalar ``astropy.time.Time`` object instead of ``np.array``. The precision of times contained in sunpy `timeseries` has been increased to 9 from 6.
diff --git a/changelog/2679.bugfix.rst b/changelog/2679.bugfix.rst
@@ -0,0 +1 @@
+``sunpy.instr.fermi.met_to_utc`` now returns the correct utc time which takes into account the leap seconds that have passed.
diff --git a/changelog/2694.breaking.rst b/changelog/2694.breaking.rst
@@ -0,0 +1 @@
+Removed ``sunpy.net.jsoc.attrs.Time`` because it served the same purpose as ``sunpy.net.attrs.Time`` after the switch to ``astropy.time.Time``.
diff --git a/docs/code_ref/coordinates.rst b/docs/code_ref/coordinates.rst
@@ -127,11 +127,10 @@ coordinates is::
 
    >>> c = SkyCoord(0*u.arcsec, 0*u.arcsec, frame=frames.Helioprojective, obstime="2017-07-26")
    >>> c
-   <SkyCoord (Helioprojective: obstime=2017-07-26 00:00:00, rsun=695508.0 km, observer=<HeliographicStonyhurst Coordinate (obstime=2017-07-26 00:00:00): (lon, lat, radius) in (deg, deg, AU)
-       (0., 5.31701821, 1.01567428)>): (Tx, Ty) in arcsec
+   <SkyCoord (Helioprojective: obstime=2017-07-26T00:00:00.000, rsun=695508.0 km, observer=<HeliographicStonyhurst Coordinate for 'earth'>): (Tx, Ty) in arcsec
        (0., 0.)>
    >>> c.transform_to(frames.HeliographicCarrington)
-   <SkyCoord (HeliographicCarrington: obstime=2017-07-26 00:00:00): (lon, lat, radius) in (deg, deg, km)
+   <SkyCoord (HeliographicCarrington: obstime=2017-07-26T00:00:00.000): (lon, lat, radius) in (deg, deg, km)
       (283.99298362, 5.31701821, 695508.00000058)>
 
 It is also possible to transform to any coordinate system implemented in Astropy. This can be used to find the position of the solar limb in AltAz equatorial coordinates::
@@ -258,14 +257,14 @@ If you want to obtain a un-realized coordinate frame corresponding to a
   >>> from sunpy.data.sample import AIA_171_IMAGE  # doctest: +REMOTE_DATA
   >>> amap = sunpy.map.Map(AIA_171_IMAGE)  # doctest: +REMOTE_DATA
   >>> amap.observer_coordinate  # doctest: +REMOTE_DATA
-    <SkyCoord (HeliographicStonyhurst: obstime=2011-06-07 06:33:02.770000): (lon, lat, radius) in (deg, deg, m)
+    <SkyCoord (HeliographicStonyhurst: obstime=2011-06-07T06:33:02.770000): (lon, lat, radius) in (deg, deg, m)
         (0., 0.048591, 1.51846026e+11)>
 
 which is equivalent to::
 
   >>> from astropy.wcs.utils import wcs_to_celestial_frame # doctest: +REMOTE_DATA
   >>> wcs_to_celestial_frame(amap.wcs)  # doctest: +REMOTE_DATA
-    <Helioprojective Frame (obstime=2011-06-07 06:33:02.770000, rsun=696000000.0 m, observer=<HeliographicStonyhurst Coordinate (obstime=2011-06-07 06:33:02.770000): (lon, lat, radius) in (deg, deg, m)
+    <Helioprojective Frame (obstime=2011-06-07T06:33:02.770000, rsun=696000000.0 m, observer=<HeliographicStonyhurst Coordinate (obstime=2011-06-07 06:33:02.770000): (lon, lat, radius) in (deg, deg, m)
         (0., 0.048591, 1.51846026e+11)>)>
 
 

diff --git a/docs/code_ref/time.rst b/docs/code_ref/time.rst
@@ -2,7 +2,7 @@ SunPy time
 ==========
 
 The time submodule contains helpers for converting strings to Python
-`datetime.datetime` objects and handling common operations on these objects. As
+`astropy.time.Time` objects and handling common operations on these objects. As
 well as this a `~sunpy.time.TimeRange` object is provided for representing a
 period of time and performing operations on that range.
 

diff --git a/docs/dev_guide/documentation.rst b/docs/dev_guide/documentation.rst
@@ -224,7 +224,7 @@ Example (:class:`sunpy.map.Map`) ::
     ----------
     header : dict
         A dictionary representation of the image header
-    date : datetime
+    date : `astropy.time.Time`
         Image observation time
     det : str
         Detector name

diff --git a/docs/guide/acquiring_data/hek.rst b/docs/guide/acquiring_data/hek.rst
@@ -336,7 +336,7 @@ HEK results and create the corresponding VSO query attributes.
 
     >>> vso_query = hek2vso.translate_results_to_query(result[10:11])  # doctest: +REMOTE_DATA
     >>> vso_query[0]  # doctest: +REMOTE_DATA
-    [<Time(datetime.datetime(2011, 8, 9, 7, 22, 44), datetime.datetime(2011, 8, 9, 7, 28, 56), None)>, <Source('SDO')>, <Instrument('AIA')>, <Wavelength(193.0, 193.0, 'Angstrom')>]
+    [<Time(<Time object: scale='utc' format='isot' value=2011-08-09T07:22:44.000>, <Time object: scale='utc' format='isot' value=2011-08-09T07:28:56.000>, None)>, <Source('SDO')>, <Instrument('AIA')>, <Wavelength(193.0, 193.0, 'Angstrom')>]
 
 This function allows users finer-grained control of VSO queries
 generated from HEK results.

diff --git a/docs/guide/roi.rst b/docs/guide/roi.rst
@@ -19,9 +19,9 @@ This creates an roi called result for the specific time range. Querying the newl
     >>> result
     SunPy Region-of-interest (ROI) object
     -------------------------------------
-    Source:         LYRA LYTAF
-    Start time:     2011-02-15T04:34:09
-    End time:       2011-02-15T04:48:21
-    Event description:  UV occult.
+    Source:            LYRA LYTAF
+    Start time:        2011-02-15 04:34:09.000
+    End time:          2011-02-15 04:48:21.000
+    Event description: UV occult.
 
 Check out the code reference for the time range object for more information.
diff --git a/docs/guide/time.rst b/docs/guide/time.rst
@@ -16,29 +16,36 @@ SunPy builds upon its functionality.
 
 Solar data is associated with a number of different time formats. SunPy provides a simple
 parsing function which can deal with most every format that a user may encounter. Called
-`sunpy.time.parse_time()`, this function takes a string as input and returns a datetime object.
+`sunpy.time.parse_time()`, this function takes a string as input and returns a `~astropy.time.Time` object.
+
 Here are few examples of formats which `sunpy.time.parse_time()` accepts::
 
     >>> from sunpy.time import parse_time
     >>> parse_time('2007-05-04T21:08:12')
-    datetime.datetime(2007, 5, 4, 21, 8, 12)
+    <Time object: scale='utc' format='isot' value=2007-05-04T21:08:12.000>
     >>> parse_time('2007/05/04T21:08:12')
-    datetime.datetime(2007, 5, 4, 21, 8, 12)
+    <Time object: scale='utc' format='isot' value=2007-05-04T21:08:12.000>
     >>> parse_time('20070504T210812')
-    datetime.datetime(2007, 5, 4, 21, 8, 12)
+    <Time object: scale='utc' format='isot' value=2007-05-04T21:08:12.000>
     >>> parse_time('2007-May-04 21:08:12')
-    datetime.datetime(2007, 5, 4, 21, 8, 12)
+    <Time object: scale='utc' format='isot' value=2007-05-04T21:08:12.000>
     >>> parse_time('20070504_210812')
-    datetime.datetime(2007, 5, 4, 21, 8, 12)
+    <Time object: scale='utc' format='isot' value=2007-05-04T21:08:12.000>
 
-Each of the above returns the same datetime object ``datetime.datetime(2007,
-5, 4, 21, 8, 12)``. One of the most standard time formats used in solar
-physics is the number of seconds since 1979 January 01. The parse_time
+Each of the above returns the same `~astropy.time.Time` object ``<Time object: scale='utc' format='isot' value=2007-05-04T21:08:12.000>``. One of the most standard time formats used in solar
+physics is the number of seconds since 1979 January 01 called ``utime``. The parse_time
 function also accepts this as input, e.g.::
 
-    >>> parse_time(894316092.00000000)
-    datetime.datetime(2007, 5, 4, 21, 8, 12)
+    >>> parse_time(894316092.00000000, format='utime')
+    <Time object: scale='utc' format='utime' value=894316092.0>
+
+`sunpy.time.parse_time` is a wrapper around `astropy.time.Time`. It supports a few more formats
+than `~astropy.time.Time`, but the API is mostly the same. You can specify the format, scale, precision, 
+location and other arguments just as you would do with `~astropy.time.Time`. An example::
 
+    >>> times = ['1999-01-01T00:00:00.123456789', '2010-01-01T00:00:00']
+    >>> parse_time(times, format='isot', scale='tai')
+    <Time object: scale='tai' format='isot' value=['1999-01-01T00:00:00.123' '2010-01-01T00:00:00.000']> 
 
 All SunPy functions which require
 time as an input sanitize the input using parse_time.
@@ -60,13 +67,19 @@ You can also pass the start and end times as a tuple: ::
 
 This object makes use of parse_time() so it can accept a wide variety of time formats.
 A time range object can also be created by providing a start time and a duration.
-The duration must be provided as a `datetime.timedelta` object or
-time-equivalent `astropy.units.Quantity`
+The duration must be provided as a `~astropy.time.TimeDelta` or
+time-equivalent `astropy.units.Quantity` or `datetime.timedelta` object
 example: ::
 
     >>> import astropy.units as u
     >>> time_range = TimeRange('2010/03/04 00:10', 400 * u.second)
 
+or: ::
+
+    >>> import astropy.units as u
+    >>> from astropy.time import TimeDelta
+    >>> time_range = TimeRange('2010/03/04 00:10', TimeDelta(400 * u.second))
+
 or: ::
 
     >>> from datetime import timedelta
@@ -77,7 +90,7 @@ get the time at the center of your interval or the length of your interval in mi
 or days or seconds: ::
 
     >>> time_range.center
-    datetime.datetime(2010, 3, 4, 0, 13, 20)
+    <Time object: scale='utc' format='isot' value=2010-03-04T00:13:20.000>
     >>> time_range.minutes
     <Quantity 6.66666667 min>
     >>> time_range.days

diff --git a/docs/guide/tour.rst b/docs/guide/tour.rst
@@ -264,9 +264,9 @@ and times. Here is a short example: ::
 
     # parsing a standard time strings
     >>> sunpy.time.parse_time('2004/02/05 12:00')
-    datetime.datetime(2004, 2, 5, 12, 0)
+    <Time object: scale='utc' format='isot' value=2004-02-05T12:00:00.000>
 
-    # This returns a datetime object. All SunPy functions which require
+    # This returns a astropy.time.Time object. All SunPy functions which require
     # time as an input sanitize the input using parse_time.
     >>> sunpy.time.day_of_year('2004-Jul-05 12:00:02')
     187.50002314814816
@@ -278,7 +278,7 @@ and times. Here is a short example: ::
     # TimeRange objects are useful for representing ranges of time
     >>> time_range = sunpy.time.TimeRange('2010/03/04 00:10', '2010/03/04 00:20')
     >>> time_range.center
-    datetime.datetime(2010, 3, 4, 0, 15)
+    <Time object: scale='utc' format='isot' value=2010-03-04T00:15:00.000>
 
 For more information about working with time in SunPy checkout the :doc:`time guide <time>`.
 

diff --git a/docs/guide/units-coordinates.rst b/docs/guide/units-coordinates.rst
@@ -149,15 +149,14 @@ A SkyCoord object to represent a point on the Sun can then be created::
   >>> c = SkyCoord(70*u.deg, -30*u.deg, obstime="2017-08-01",
   ...              frame=frames.HeliographicStonyhurst)
   >>> c
-  <SkyCoord (HeliographicStonyhurst: obstime=2017-08-01 00:00:00): (lon, lat, radius) in (deg, deg, km)
+  <SkyCoord (HeliographicStonyhurst: obstime=2017-08-01T00:00:00.000): (lon, lat, radius) in (deg, deg, km)
       (70., -30., 695508.)>
 
 This `~astropy.coordinates.SkyCoord` object can then be transformed to any
 other coordinate frame defined either in Astropy or SunPy, for example::
 
   >>> c.transform_to(frames.Helioprojective)
-  <SkyCoord (Helioprojective: obstime=2017-08-01 00:00:00, rsun=695508.0 km, observer=<HeliographicStonyhurst Coordinate (obstime=2017-08-01 00:00:00): (lon, lat, radius) in (deg, deg, AU)
-      (0., 5.78339799, 1.01496923)>): (Tx, Ty, distance) in (arcsec, arcsec, km)
+  <SkyCoord (Helioprojective: obstime=2017-08-01T00:00:00.000, rsun=695508.0 km, observer=<HeliographicStonyhurst Coordinate for 'earth'>): (Tx, Ty, distance) in (arcsec, arcsec, km)
       (769.74997696, -498.75932128, 1.51668819e+08)>
 
 
@@ -191,8 +190,7 @@ one observer to a coordinate seen by another::
 
   >>> hpc1.transform_to(frames.Helioprojective(observer="venus",
   ...                                          obstime="2017-07-26"))
-  <SkyCoord (Helioprojective: obstime=2017-07-26 00:00:00, rsun=695508.0 km, observer=<HeliographicStonyhurst Coordinate (obstime=2017-07-26 00:00:00): (lon, lat, radius) in (deg, deg, AU)
-    (77.03547231, 3.17032536, 0.72510629)>): (Tx, Ty, distance) in (arcsec, arcsec, km)
+  <SkyCoord (Helioprojective: obstime=2017-07-26T00:00:00.000, rsun=695508.0 km, observer=<HeliographicStonyhurst Coordinate for 'venus'>): (Tx, Ty, distance) in (arcsec, arcsec, km)
     (-1285.11970265, 106.17983302, 1.08317783e+08)>
 
 
@@ -208,15 +206,14 @@ constructed from the header information. This can be accessed using
   >>> from sunpy.data.sample import AIA_171_IMAGE  # doctest: +REMOTE_DATA
   >>> m = sunpy.map.Map(AIA_171_IMAGE) # doctest: +REMOTE_DATA
   >>> m.coordinate_frame  # doctest: +REMOTE_DATA
-    <Helioprojective Frame (obstime=2011-06-07 06:33:02.770000, rsun=696000000.0 m, observer=<HeliographicStonyhurst Coordinate (obstime=2011-06-07 06:33:02.770000): (lon, lat, radius) in (deg, deg, m)
+    <Helioprojective Frame (obstime=2011-06-07T06:33:02.000.770000, rsun=696000000.0 m, observer=<HeliographicStonyhurst Coordinate (obstime=2011-06-07T06:33:02.770000): (lon, lat, radius) in (deg, deg, m)
         (0., 0.048591, 1.51846026e+11)>)>
 
 This can be used when creating a `~astropy.coordinates.SkyCoord` object to set
 the coordinate system to that image::
 
   >>> SkyCoord(100 * u.arcsec, 10*u.arcsec, frame=m.coordinate_frame) # doctest: +REMOTE_DATA
-  <SkyCoord (Helioprojective: obstime=2011-06-07 06:33:02.770000, rsun=696000000.0 m, observer=<HeliographicStonyhurst Coordinate (obstime=2011-06-07 06:33:02.770000): (lon, lat, radius) in (deg, deg, m)
-      (0., 0.048591, 1.51846026e+11)>): (Tx, Ty) in arcsec
+  <SkyCoord (Helioprojective: obstime=2011-06-07T06:33:02.770000, rsun=696000000.0 m, observer=<HeliographicStonyhurst Coordinate for 'earth'>): (Tx, Ty) in arcsec
       (100., 10.)>
 
 This `~astropy.coordinates.SkyCoord` object could then be used to plot a point

diff --git a/examples/parse_time.py b/examples/parse_time.py
@@ -0,0 +1,95 @@
+"""
+========================================
+Parsing times with sunpy.time.parse_time
+========================================
+
+This is an example to show some possible usage of ``parse_time``.
+``parse_time`` is a function that can be useful to create `~astropy.time.Time`
+objects from various other time objects and strings.
+"""
+##############################################################################
+# Import the required modules.
+from datetime import datetime, date
+import time
+
+import numpy as np
+import pandas
+
+from sunpy.time import parse_time
+
+
+##############################################################################
+# Suppose you want to parse some strings, ``parse_time`` can do that.
+t1 = parse_time('1995-12-31 23:59:60')
+
+##############################################################################
+# Of course you could do the same with `~astropy.time.Time`.
+# But SunPy ``parse_time`` can parse even more formats of time strings.
+# And as you see from the examples, thanks to `~astropy.time.Time`, ``parse_time``
+# can handle leap seconds too.
+t2 = parse_time('1995-Dec-31 23:59:60')
+
+
+##############################################################################
+# You can mention the scale of the time as a keyword parameter if you need.
+# Similar to scale you can pass in any astropy Time compatible keywords to
+# ``parse_time``. See all arguments
+# `here: <http://docs.astropy.org/en/stable/time/#creating-a-time-object>`__
+t3 = parse_time('2012:124:21:08:12', scale='tai')
+
+
+##############################################################################
+# Now that you are done with strings, let's see other type ``parse_time`` handles,
+# tuples. `~astropy.time.Time` doesnot handle tuples but ``parse_time`` does.
+t4 = parse_time((1998, 11, 14))
+t5 = parse_time((2001, 1, 1, 12, 12, 12, 8899))
+
+##############################################################################
+# This also means that you can parse a ``time.struct_time``.
+t6 = parse_time(time.localtime())
+
+##############################################################################
+# ``parse_time`` also parses ``datetime`` and ``date`` objects.
+t7 = parse_time(datetime.now())
+t8 = parse_time(date.today())
+
+
+##############################################################################
+# ``parse_time`` can return ``Time`` objects for ``pandas.Timestamp``, ``pandas.Series``
+# and ``pandas.DatetimeIndex``.
+t9 = parse_time(pandas.Timestamp(datetime(1966, 2, 3)))
+
+t10 = parse_time(
+    pandas.Series([[datetime(2012, 1, 1, 0, 0),
+                    datetime(2012, 1, 2, 0, 0)],
+                   [datetime(2012, 1, 3, 0, 0),
+                    datetime(2012, 1, 4, 0, 0)]]))
+
+t11 = parse_time(
+    pandas.DatetimeIndex([
+        datetime(2012, 1, 1, 0, 0),
+        datetime(2012, 1, 2, 0, 0),
+        datetime(2012, 1, 3, 0, 0),
+        datetime(2012, 1, 4, 0, 0)
+    ]))
+
+
+##############################################################################
+# ``parse_time`` can parse ``numpy.datetime64`` objects.
+t12 = parse_time(np.datetime64('2014-02-07T16:47:51.008288123-0500'))
+t13 = parse_time(
+    np.array(
+        ['2014-02-07T16:47:51.008288123', '2014-02-07T18:47:51.008288123'],
+        dtype='datetime64'))
+
+##############################################################################
+# Parse time returns `~astropy.time.Time object for every parsable input that
+# you give to it.
+# ``parse_time`` can handle all formats that `~astropy.time.Time` can handle.
+# That is,
+# ['jd', 'mjd', 'decimalyear', 'unix', 'cxcsec', 'gps', 'plot_date', 'datetime',
+# 'iso', 'isot', 'yday', 'fits', 'byear', 'jyear', 'byear_str', 'jyear_str']
+# at the time of writing. This can be used by passing format keyword argument
+# to ``parse_time``.
+parse_time(1234.0, format='jd')
+parse_time('B1950.0', format='byear_str')
diff --git a/examples/plotting/finegrained_plot.py b/examples/plotting/finegrained_plot.py
@@ -27,7 +27,7 @@
 top_right = SkyCoord(800*u.arcsec, 700*u.arcsec, frame=aiamap.coordinate_frame)
 aiamap_sub = aiamap.submap(bottom_left, top_right)
 
-title_obsdate = '{:%Y-%b-%d %H:%M:%S}'.format(aiamap_sub.date)
+title_obsdate = aiamap_sub.date.strftime('%Y-%b-%d %H:%M:%S')
 
 ###############################################################################
 # The SunPy map peek method shows a helioprojective  grid by default.

diff --git a/examples/plotting/overplot_hek_polygon.py b/examples/plotting/overplot_hek_polygon.py
@@ -11,13 +11,13 @@
 
 from __future__ import print_function, division
 
-from datetime import timedelta
 import numpy as np
 
 import matplotlib.pyplot as plt
 
 import astropy.units as u
 from astropy.coordinates import SkyCoord
+from astropy.time import TimeDelta
 
 import sunpy.map
 import sunpy.data.sample
@@ -40,8 +40,8 @@
 ##############################################################################
 # Look for coronal holes detected using the SPoCA feature recognition method:
 
-start_time = aia_map.date - timedelta(hours=2)
-end_time = aia_map.date + timedelta(hours=2)
+start_time = aia_map.date - TimeDelta(2*u.hour)
+end_time = aia_map.date + TimeDelta(2*u.hour)
 responses = hek_client.search(hek.attrs.Time(start_time, end_time),
                               hek.attrs.CH, hek.attrs.FRM.Name == 'SPoCA')