B q\@sddlZddlZddlZddlZddlZddlmZmZddlZ ddl m Z ddl m Z ddlmZddlmZddlmZmZmZmZd d d d d ddddddddddddddddddd d!d"d#d$d%d&gZdgZeZeZd'd'd(d(d)d*Zd+d,ZGd-d.d.eZGd/d d ed0Z Gd1d d e Z!Gd2d d e Z"Gd3dde Z#Gd4d d e Z$Gd5d d e$Z%Gd6dde$Z&Gd7dde$Z'Gd8dde$Z(Gd9dde Z)Gd:d;d;e)Z*Gddde)Z.Gd?dde.Z/Gd@dde/Z0GdAdde/Z1GdBd&d&e0Z2GdCdde.Z3GdDdde Z4GdEdde4Z5GdFdde4Z6GdGdde.Z7GdHd d e7Z8GdId!d!e7Z9GdJdKdKeZ:GdLdde e:d0Z;GdMdde;ZddPl?m@Z@mAZAmBZBmCZCdS)QN) OrderedDict defaultdict) lazyproperty)AstropyDeprecationWarning)units)_erfa)day_fracquantity_day_fractwo_sum two_product TimeFormatTimeJDTimeMJD TimeFromEpochTimeUnix TimeCxcSecTimeGPSTimeDecimalYear TimePlotDate TimeUnique TimeDatetime TimeStringTimeISOTimeISOTTimeFITSTimeYearDayTime TimeEpochDateTimeBesselianEpochTimeJulianEpochTimeDeltaFormat TimeDeltaSec TimeDeltaJDTimeEpochDateStringTimeBesselianEpochStringTimeJulianEpochString TIME_FORMATSTIME_DELTA_FORMATS TimezoneInfoTimeDeltaDatetimeTimeDatetime64ttutctai)ZTDTZETZGMTZUTZIATcCsng}x`|D]X}|d}xdD]\}}|||}qWd|krX|dt|d|df}||q Wt|S)a Iterate through each of the sub-formats and try substituting simple regular expressions for the strptime codes for year, month, day-of-month, hour, minute, second. If no % characters remain then turn the final string into a compiled regex. This assumes time formats do not have a % in them. This is done both to speed up parsing of strings and to allow mixed formats where strptime does not quite work well enough. r))z%Yz(?P\d\d\d\d))z%mz(?P\d{1,2}))z%dz(?P\d{1,2}))z%Hz(?P\d{1,2}))z%Mz(?P\d{1,2}))z%Sz(?P\d{1,2})%r$)replacerecompileappendtuple)subfmtsZ new_subfmtsZ subfmt_tupleZ subfmt_inZ strptime_coderegexr83lib/python3.7/site-packages/astropy/time/formats.py_regexify_subfmts,s    r:cs$eZdZdZeZfddZZS)TimeFormatMetaz Metaclass that adds `TimeFormat` and `TimeDeltaFormat` to the `TIME_FORMATS` and `TIME_DELTA_FORMATS` registries, respectively. csJt||||}d|kr0|jdkr0||j|j<d|krFt|d|_|S)Nname astropy_timer6)super__new__r< _registryr:r6)mclsr<basesmemberscls) __class__r8r9r?Rs  zTimeFormatMeta.__new__)__name__ __module__ __qualname____doc__r&r@r? __classcell__r8r8)rEr9r;Jsr;c@seZdZdZdddZddZeddZejd dZd d Z ed d Z eddZ eddZ e ddZddZddZddZd ddZeddZdS)!r a Base class for time representations. Parameters ---------- val1 : numpy ndarray, list, number, str, or bytes Values to initialize the time or times. Bytes are decoded as ascii. val2 : numpy ndarray, list, or number; optional Value(s) to initialize the time or times. Only used for numerical input, to help preserve precision. scale : str Time scale of input value(s) precision : int Precision for seconds as floating point in_subfmt : str Select subformat for inputting string times out_subfmt : str Select subformat for outputting string times from_jd : bool If true then val1, val2 are jd1, jd2 FcCsJ||_||_||_||_|r*||_||_n|||\}}|||dS)N)scale precision in_subfmt out_subfmtjd1jd2_check_val_typeset_jds)selfval1val2rKrLrMrNfrom_jdr8r8r9__init__xszTimeFormat.__init__cCs t|jS)N)lenrO)rSr8r8r9__len__szTimeFormat.__len__cCs||j|_|jS)z Time scale) _check_scale_scale)rSr8r8r9rKszTimeFormat.scalecCs ||_dS)N)r[)rSvalr8r8r9rKscCs|jrtjj||jdd}|S)NF)maskcopy)maskednpZmaarrayr])rSvaluer8r8r9mask_if_neededszTimeFormat.mask_if_neededcCs@d|jkr6t|j|jd<|jdjr6d|jdj_|jdS)Nr]F)cacher`ZisnanrPshapeflagsZ writeable)rSr8r8r9r]s   zTimeFormat.maskcCs*d|jkr tt|j|jd<|jdS)Nr_)rdboolr`anyr])rSr8r8r9r_s zTimeFormat.maskedcCs|jrt|jS|jS)N)r_r`Z nan_to_numrP)rSr8r8r9 jd2_filledszTimeFormat.jd2_filledcCsttS)zA Return the cache associated with this instance. )rdict)rSr8r8r9rdszTimeFormat.cachecCsN|jtjkott|}|dkp@|jtjko@tt| }|rJ|sZtd|j t |dddk rt j |dd}|dk rt j |dd}yt ||\}}Wn t jk rt dYnXdt |dd}|dkr"t||\}}|||7}t||\}}nt |dddk r"td|dkr6t|}d d }||||fS) z?Input value validation, typically overridden by derived classesNz1Input values for {0} class must be finite doublesunitF)r^zJonly quantities with time units can be used to instantiate Time instances.g?z$Cannot mix float and Quantity inputscSst|tjrt|S|S)z Remove ndarray subclasses since for jd1/jd2 we want a pure ndarray or a Python or numpy scalar. ) isinstancer`ZndarrayZasarray)r\r8r8r9asarray_or_scalarsz5TimeFormat._check_val_type..asarray_or_scalar)dtyper`doubleallZisfiniterhZisinf TypeErrorformatr<getattruZQuantityr Z UnitsErrorZUnitConversionErrorr r zeros_like)rSrTrUZok1Zok2ZfactorZcarryrmr8r8r9rQs2&      zTimeFormat._check_val_typecCsDt|jdr|dkr|jj}|dkr(d}|tkr@td|t|S)a Return a validated scale value. If there is a class attribute 'scale' then that defines the default / required time scale for this format. In this case if a scale value was provided that needs to match the class default, otherwise return the class default. Otherwise just make sure that scale is in the allowed list of scales. Provide a different error message if `None` (no value) was supplied. epoch_scaleNr,z+Scale value '{0}' not in allowed values {1})hasattrrErv TIME_SCALESScaleValueErrorrr)rSrKr8r8r9rZs  zTimeFormat._check_scalecCstdS)zl Set internal jd1 and jd2 from val1 and val2. Must be provided by derived classes. N)NotImplementedError)rSrTrUr8r8r9rRszTimeFormat.set_jdsNcCs ||jS)aV Return time representation from internal jd1 and jd2. This is the base method that ignores ``parent`` and requires that subclasses implement the ``value`` property. Subclasses that require ``parent`` or have other optional args for ``to_value`` should compute and return the value directly. )rcrb)rSparentr8r8r9to_valueszTimeFormat.to_valuecCstdS)N)rz)rSr8r8r9rbszTimeFormat.value)F)N)rFrGrHrIrWrYpropertyrKsetterrcr]r_rirrdrQrZrRr|rbr8r8r8r9r as      2 ) metaclassc@s(eZdZdZdZddZeddZdS)rz Julian Date time format. This represents the number of days since the beginning of the Julian Period. For example, 2451544.5 in JD is midnight on January 1, 2000. jdcCs"||jt||\|_|_dS)N)rZr[r rOrP)rSrTrUr8r8r9rRs zTimeJD.set_jdscCs |j|jS)N)rOrP)rSr8r8r9rb sz TimeJD.valueN)rFrGrHrIr<rRr}rbr8r8r8r9rsc@s(eZdZdZdZddZeddZdS)rz Modified Julian Date time format. This represents the number of days since midnight on November 17, 1858. For example, 51544.0 in MJD is midnight on January 1, 2000. ZmjdcCs:||jt||\}}|tj7}t||\|_|_dS)N)rZr[r erfaDJM0rOrP)rSrTrUrOrPr8r8r9rR-s  zTimeMJD.set_jdscCs|jtj|jS)N)rOrrrP)rSr8r8r9rb7sz TimeMJD.valueN)rFrGrHrIr<rRr}rbr8r8r8r9r%s c@s(eZdZdZdZddZeddZdS)rz Time as a decimal year, with integer values corresponding to midnight of the first day of each year. For example 2000.5 corresponds to the ISO time '2000-07-02 00:00:00'. decimalyearc Cs.||jt||\}}t|t}t|| \}}|||7}||tj}t|t}t|} t|} t |} t |} t |} |j d}t ||| | | | | \}}t ||d| | | | | \}}t|||j dd}t|||j dd}||||}t|j|j\|_|_dS)Nasciirr)rKrr)rZr[r r`Ztruncastypeintro ones_likerurKupperencoderdtf2dTimer rOrP)rSrTrUZsum12Zerr12iy_startZextraZy_fracr\imonidayihriminisecrK jd1_start jd2_startjd1_endjd2_endZt_startZt_endZt_fracr8r8r9rRDs*        zTimeDecimalYear.set_jdsc Cs|jd}t|d|j|j\}}}}t|}t|}t |}t |} t |j} |jd}t |||||| | \} } t ||d|||| | \} }|j| |j | }| | || }|||}|S)Nrrr) rKrrrd2dtfrOrir`rrurrP)rSrKrimsidsihmsfsrrrrrrrrrdtZdt_endrr8r8r9rbcs"       zTimeDecimalYear.valueN)rFrGrHrIr<rRr}rbr8r8r8r9r<scs<eZdZdZd fdd ZddZd dd ZeeZZ S) rz Base class for times that represent the interval from a particular epoch as a floating point multiple of a unit time interval (e.g. seconds or days). Fc s@||_t|j|j|j|jd}||_t|||||||dS)N)rKrr) rKr epoch_val epoch_val2rv epoch_formatepochr>rW) rSrTrUrKrLrMrNrVr)rEr8r9rWs  zTimeFromEpoch.__init__c Cst||d|jd\}}|jj|}|jj|}ytt|||jdd|j}Wn<t k r}zt d |j |j|j|Wdd}~XYnXt|j j|j j\|_|_dS)z Initialize the internal jd1 and jd2 attributes given val1 and val2. For an TimeFromEpoch subclass like TimeUnix these will be floats giving the effective seconds since an epoch time (e.g. 1970-01-01 00:00:00). g?)divisorr)rKrrzSCannot convert from '{0}' epoch scale '{1}'to specified scale '{2}', got error: {3}N)r rkrrOrPrsrrvrK Exceptionryrrr<_time) rSrTrUdayZfracrOrPtmerrr8r8r9rRs   zTimeFromEpoch.set_jdsNc Cs|j|jkr~|dkrtdyt||j}Wn<tk rh}ztd|j|j|j|Wdd}~XYnX|jj |jj }}n|j |j }}||j j ||j j |j }| |S)Nz/cannot compute value without parent Time objectzSCannot convert from '{0}' epoch scale '{1}'to specified scale '{2}', got error: {3})rKrv ValueErrorrsrryrrr<rrOrPrrkrc)rSr{rrrOrPZtime_from_epochr8r8r9r|s  zTimeFromEpoch.to_value)F)N) rFrGrHrIrWrRr|r}rbrJr8r8)rEr9r}s  ' c@s.eZdZdZdZdejZdZdZ dZ dZ dS)ra Unix time: seconds from 1970-01-01 00:00:00 UTC. For example, 946684800.0 in Unix time is midnight on January 1, 2000. NOTE: this quantity is not exactly unix time and differs from the strict POSIX definition by up to 1 second on days with a leap second. POSIX unix time actually jumps backward by 1 second at midnight on leap second days while this class value is monotonically increasing at 86400 seconds per UTC day. Zunixg?z1970-01-01 00:00:00Nr,iso) rFrGrHrIr<rDAYSECrkrrrvrr8r8r8r9rs  c@s.eZdZdZdZdejZdZdZ dZ dZ dS)rz Chandra X-ray Center seconds from 1998-01-01 00:00:00 TT. For example, 63072064.184 is midnight on January 1, 2000. Zcxcsecg?z1998-01-01 00:00:00Nr+r) rFrGrHrIr<rrrkrrrvrr8r8r8r9rs c@s.eZdZdZdZdejZdZdZ dZ dZ dS)raGPS time: seconds from 1980-01-06 00:00:00 UTC For example, 630720013.0 is midnight on January 1, 2000. Notes ===== This implementation is strictly a representation of the number of seconds (including leap seconds) since midnight UTC on 1980-01-06. GPS can also be considered as a time scale which is ahead of TAI by a fixed offset (to within about 100 nanoseconds). For details, see http://tycho.usno.navy.mil/gpstt.html Zgpsg?z1980-01-06 00:00:19Nr-r) rFrGrHrIr<rrrkrrrvrr8r8r8r9rs  c@s(eZdZdZdZdZdZdZdZdZ dS)ra' Matplotlib `~matplotlib.pyplot.plot_date` input: 1 + number of days from 0001-01-01 00:00:00 UTC This can be used directly in the matplotlib `~matplotlib.pyplot.plot_date` function:: >>> import matplotlib.pyplot as plt >>> jyear = np.linspace(2000, 2001, 20) >>> t = Time(jyear, format='jyear', scale='utc') >>> plt.plot_date(t.plot_date, jyear) >>> plt.gcf().autofmt_xdate() # orient date labels at a slant >>> plt.draw() For example, 730120.0003703703 is midnight on January 1, 2000. Z plot_dateg?gPD:ANr,r) rFrGrHrIr<rkrrrvrr8r8r8r9rsc@seZdZdZdS)rz Base class for time formats that can uniquely create a time object without requiring an explicit format specifier. This class does nothing but provide inheritance to identify a class as unique. N)rFrGrHrIr8r8r8r9r"sc@seZdZdZdZdddZdS)TimeAstropyTimez Instantiate date from an Astropy Time object (or list thereof). This is purely for instantiating from a Time object. The output format is the same as the first time instance. r=Fc s|jdttr,tfdd|jDs:sz*TimeAstropyTime.__new__..z>Input values for {0} class must all be same astropy Time type.Ncsg|]}t|jqSr8)rsr)rr\)rKr8r9 Bsz+TimeAstropyTime.__new__..cSsg|]}t|jqSr8)r` atleast_1drO)rr\r8r8r9rCscSsg|]}t|jqSr8)r`rrP)rr\r8r8r9rDsT)rV)flatrlrrprqrrr<rKrer`Z concatenatersrrOrPrE)rDrTrUrKrLrMrNrVvalsrOrPr\Z OutTimeFormatrSr8)rKrr9r?3s"    zTimeAstropyTime.__new__N)F)rFrGrHrIr<r?r8r8r8r9r*src@s6eZdZdZdZddZddZd dd ZeeZ dS) ram Represent date as Python standard library `~datetime.datetime` object Example:: >>> from astropy.time import Time >>> from datetime import datetime >>> t = Time(datetime(2000, 1, 2, 12, 0, 0), scale='utc') >>> t.iso '2000-01-02 12:00:00.000' >>> t.tt.datetime datetime.datetime(2000, 1, 2, 12, 1, 4, 184000) datetimecCs,tdd|jDs$td|j|dfS)Ncss|]}t|tjVqdS)N)rlr)rr\r8r8r9rbsz/TimeDatetime._check_val_type..z3Input values for {0} class must be datetime objects)rprrqrrr<)rSrTrUr8r8r9rQ`s zTimeDatetime._check_val_typecCstj|ddddddgdgtgdtjgtjgd}x|D]~\}}}}}} } |} | jdk rt| | jdd} | j |d<| j |d<| j |d<| j |d<| j | d<| j| jd| d<q>> from datetime import datetime >>> from astropy.time import TimezoneInfo # Specifies a timezone >>> import astropy.units as u >>> utc = TimezoneInfo() # Defaults to UTC >>> utc_plus_one_hour = TimezoneInfo(utc_offset=1*u.hour) # UTC+1 >>> dt_aware = datetime(2000, 1, 1, 0, 0, 0, tzinfo=utc_plus_one_hour) >>> print(dt_aware) 2000-01-01 00:00:00+01:00 >>> print(dt_aware.astimezone(utc)) 1999-12-31 23:00:00+00:00 rNZUTC)r timedeltar|rtr _utcoffset_tzname_dst)rSrrtznamer8r8r9rWs zTimezoneInfo.__init__cCs|jS)N)r)rSrr8r8r9rszTimezoneInfo.utcoffsetcCs t|jS)N)strr)rSrr8r8r9rszTimezoneInfo.tznamecCs|jS)N)r)rSrr8r8r9rszTimezoneInfo.dst) rFrGrHrIrtZquantity_inputrrWrrrr8r8r8r9r(s c@sLeZdZdZddZddZddZdd Zd d Ze d d Z ddZ dS)rz Base class for string-like time representations. This class assumes that anything following the last decimal point to the right is a fraction of a second. This is a reference implementation can be made much faster with effort. cCs$|jjdkrtd|j|dfS)N)SUz*Input values for {0} class must be strings)rnkindrqrrr<)rSrTrUr8r8r9rQs  zTimeString._check_val_typec s d}d}y|d}Wntk r.d}Yn$X|d|||d}}t|}x|D]\}}}t|tryt||Wntk rwXYqXfdd|D} n6t ||dkrqX fddt ||D} | d || d <| SWtd ||j dS) z@Read time from a single string, using a set of possible formats.)rmonmdayrminsec)Nrrrrr.gNcsg|]}td|qS)Ztm_)rs)r component)rr8r9r sz+TimeString.parse_string..cs g|]\}}t||qSr8)rget)rrdefault)rr8r9rsrz"Time {0} does not match {1} format)rindexrfloatrlrtimeZstrptimerr2match groupdictziprrr<) rStimestrr6Z componentsdefaultsZidotfracsec_Zstrptime_fmt_or_regexrr8)rr9 parse_strings4      zTimeString.parse_stringc Cs||j}|jjdkrtndd}tj|ddddddg|jgdtjgtjgd}xR|D]J\}}}} } } } ||}| ||\|d<|d<| d<| d<| d<| d<q^Wt j |j df|jd d\} }t| |\|_|_dS) z9Parse the time strings contained in val1 and set jd1, jd2rcSst|ddS)Nr)encoding)rr)xr8r8r9&sz$TimeString.set_jds..Nr)r.rr)_select_subfmtsrMrnrrr`rrrorrrrKrrrr rOrP)rSrTrUr6 to_stringrr\rrrrrrrOrPr8r8r9rRs  4zTimeString.set_jdsc cs|jdf}t||j|j|j\}}}}||j d\}}}d|krTd}nd}d} |d} |d} |d } |d } xzt |||| | | | gD]^\}}}}}}}|rt ||| j} t|t|t|t|t|t|t|| d VqWdS) z Generator that yields a dict of values corresponding to the calendar date and time for the internal JD values. rrz{yday:TFNrrrr)rrrrrrryday)rKrrrrrLrOrirrNr`rrZ timetupleZtm_ydayr)rSrKrrrrrstr_fmtZhas_ydayrrrrrrrrrrrrr8r8r9 str_kwargs2s& &zTimeString.str_kwargscKs |jf|S)zWrite time to a string using a given format. By default, just interprets str_fmt as a format string, but subclasses can add to this. )rr)rSrkwargsr8r8r9 format_stringQszTimeString.format_stringcCs||j}|d\}}}|jdkrD|drD|dt|jd7}g}x(|D]}|t|j|f|qRWt | |j j S)Nrz {sec:02d}z .{fracsec:0zd}) rrNrLendswithrrr4rr`rareshaperOre)rSr6rroutsrr8r8r9rbYs zTimeString.valuecs:tjfdd|jD}t|dkr6td|S)zc Return a list of subformats where name matches ``pattern`` using fnmatch. csg|]}|dr|qS)rr8)rr) fnmatchcasepatternr8r9rssz.TimeString._select_subfmts..rzNo subformats match {0})fnmatchrr6rXrrr)rSrr6r8)rrr9rls  zTimeString._select_subfmtsN) rFrGrHrIrQrrRrrr}rbrr8r8r8r9rs) cs(eZdZdZdZdZfddZZS)ra7 ISO 8601 compliant date-time format "YYYY-MM-DD HH:MM:SS.sss...". For example, 2000-01-01 00:00:00.000 is midnight on January 1, 2000. The allowed subformats are: - 'date_hms': date + hours, mins, secs (and optional fractional secs) - 'date_hm': date + hours, mins - 'date': date r))date_hmsz%Y-%m-%d %H:%M:%Sz;{year:d}-{mon:02d}-{day:02d} {hour:02d}:{min:02d}:{sec:02d})date_hmz%Y-%m-%d %H:%Mz1{year:d}-{mon:02d}-{day:02d} {hour:02d}:{min:02d})datez%Y-%m-%dz{year:d}-{mon:02d}-{day:02d}cs6|dr(|jdkrtd|dd}t||S)NZr,z3Time input terminating in 'Z' must have scale='UTC'r)rrKrr>r)rSrr6)rEr8r9rs    zTimeISO.parse_string)rFrGrHrIr<r6rrJr8r8)rEr9rys  c@seZdZdZdZdZdS)ra ISO 8601 compliant date-time format "YYYY-MM-DDTHH:MM:SS.sss...". This is the same as TimeISO except for a "T" instead of space between the date and time. For example, 2000-01-01T00:00:00.000 is midnight on January 1, 2000. The allowed subformats are: - 'date_hms': date + hours, mins, secs (and optional fractional secs) - 'date_hm': date + hours, mins - 'date': date Zisot))rz%Y-%m-%dT%H:%M:%Sz;{year:d}-{mon:02d}-{day:02d}T{hour:02d}:{min:02d}:{sec:02d})rz%Y-%m-%dT%H:%Mz1{year:d}-{mon:02d}-{day:02d}T{hour:02d}:{min:02d})rz%Y-%m-%dz{year:d}-{mon:02d}-{day:02d}N)rFrGrHrIr<r6r8r8r8r9rs c@seZdZdZdZdZdS)raq Year, day-of-year and time as "YYYY:DOY:HH:MM:SS.sss...". The day-of-year (DOY) goes from 001 to 365 (366 in leap years). For example, 2000:001:00:00:00.000 is midnight on January 1, 2000. The allowed subformats are: - 'date_hms': date + hours, mins, secs (and optional fractional secs) - 'date_hm': date + hours, mins - 'date': date r))rz%Y:%j:%H:%M:%Sz2{year:d}:{yday:03d}:{hour:02d}:{min:02d}:{sec:02d})rz %Y:%j:%H:%Mz({year:d}:{yday:03d}:{hour:02d}:{min:02d})rz%Y:%jz{year:d}:{yday:03d}N)rFrGrHrIr<r6r8r8r8r9rs cs8eZdZdZddZfddZefddZZS)r* datetime64cCs$|jjdkstd|j|dfS)NMz5Input values for {0} class must be datetime64 objects)rnrrqrrr<)rSrTrUr8r8r9rQs  zTimeDatetime64._check_val_typecs2|jjdkr|d}|d}t||dS)N)z datetime64[M]z datetime64[Y]z datetime64[D]r)rnr<rr>rR)rSrTrU)rEr8r9rRs   zTimeDatetime64.set_jdscs$|j}d|_tj}||_|dS)N r)rLr>rbr)rSrLZret)rEr8r9rbs zTimeDatetime64.value) rFrGrHr<rQrRr}rbrJr8r8)rEr9r*s csFeZdZdZdZdZeddeDZddZefdd Z Z S) ru FITS format: "[±Y]YYYY-MM-DD[THH:MM:SS[.sss]]". ISOT but can give signed five-digit year (mostly for negative years); The allowed subformats are: - 'date_hms': date + hours, mins, secs (and optional fractional secs) - 'date': date - 'longdate_hms': as 'date_hms', but with signed 5-digit year - 'longdate': as 'date', but with signed 5-digit year See Rots et al., 2015, A&A 574:A36 (arXiv:1409.7583). Zfits))rz_(?P\d{4})-(?P\d\d)-(?P\d\d)T(?P\d\d):(?P\d\d):(?P\d\d(\.\d*)?)z={year:04d}-{mon:02d}-{day:02d}T{hour:02d}:{min:02d}:{sec:02d})rz,(?P\d{4})-(?P\d\d)-(?P\d\d)z{year:04d}-{mon:02d}-{day:02d})Z longdate_hmszc(?P[+-]\d{5})-(?P\d\d)-(?P\d\d)T(?P\d\d):(?P\d\d):(?P\d\d(\.\d*)?)z>{year:+06d}-{mon:02d}-{day:02d}T{hour:02d}:{min:02d}:{sec:02d})Zlongdatez0(?P[+-]\d{5})-(?P\d\d)-(?P\d\d)z{year:+06d}-{mon:02d}-{day:02d}ccs(|] }|d|dd|dfVqdS)rrz0(\((?P\w+)(\((?P\w+)\))?\))?r0Nr8)rZsubfmtr8r8r9r szTimeFITS.c Csx6|D]\}}}t||}|rPqWtd||j|}|ddk rtdt|d }t || }|t krtd|tt |jdkr||_||jkrtd|jt|dt|dt|d t| d d t| d d t| d dgS)z)Read time and deprecated scale if presentz"Time {0} does not match {1} formatrKNzrb)rSr)rEr8r9rb5s    zTimeFITS.value) rFrGrHrIr<r6r5rr}rbrJr8r8)rEr9rs %c@s$eZdZdZddZeddZdS)rzP Base class for support floating point Besselian and Julian epoch dates cCs>||jtt|j}|||\}}t||\|_|_dS)N)rZr[rsr epoch_to_jdr rOrP)rSrTrUrrOrPr8r8r9rRFs  zTimeEpochDate.set_jdscCstt|j}||j|jS)N)rsr jd_to_epochrOrP)rSrr8r8r9rbLs zTimeEpochDate.valueN)rFrGrHrIrRr}rbr8r8r8r9rAscs,eZdZdZdZdZdZfddZZS)rz;Besselian Epoch year as floating point value(s) like 1950.0Zbyearepb2jdepbcs*t|drt|drtdt||S)z?Input value validation, typically overridden by derived classestorkz{Cannot use Quantities for 'byear' format, as the interpretation would be ambiguous. Use float with Besselian year instead. )rwrr>rQ)rSrTrU)rEr8r9rQXsz"TimeBesselianEpoch._check_val_type) rFrGrHrIr<rrrQrJr8r8)rEr9rRs c@s"eZdZdZdZejZdZdZ dS)rz8Julian Epoch year as floating point value(s) like 2000.0Zjyearepj2jdepjN) rFrGrHrIr<rZDJYrkrrr8r8r8r9rbs c@s$eZdZdZddZeddZdS)r#zx Base class to support string Besselian and Julian epoch dates such as 'B1950.0' or 'J2000.0' respectively. c Cs|j}|jjdkrtndd}tj|dg|jtjgd}x|D]x\}}y:||}|d|dd} } t| } | |kr~t Wn,t t t fk rt d ||j Yq>X| |d<q>W||jtt|j} | |jd \} }t| |\|_|_dS) NrcSst|ddS)Nr)r)rr)rr8r8r9rtsz-TimeEpochDateString.set_jds..)rrrz"Time {0} does not match {1} format.r) epoch_prefixrnrrr`rrorrr IndexErrorUnicodeEncodeErrorrrr<rZr[rsrrrr rOrP)rSrTrUrrrr\yearsZtime_strZ epoch_typeZyear_strrrrOrPr8r8r9rRps&    zTimeEpochDateString.set_jdscsZtt|j}||j|j}|jdt|jdfdd|jD}t | |jj S)Nz%.rcsg|] }|qSr8r8)rr)rr8r9rsz-TimeEpochDateString.value..) rsrrrOrPrrrLrr`rarre)rSrrrr8)rr9rbs  zTimeEpochDateString.valueN)rFrGrHrIrRr}rbr8r8r8r9r#jsc@s eZdZdZdZdZdZdZdS)r$z6Besselian Epoch year as string value(s) like 'B1950.0'Z byear_strrrBN)rFrGrHrIr<rrrr8r8r8r9r$s c@s eZdZdZdZdZdZdZdS)r%z3Julian Epoch year as string value(s) like 'J2000.0'Z jyear_strrrJN)rFrGrHrIr<rrrr8r8r8r9r%s c@seZdZeZdS)TimeDeltaFormatMetaN)rFrGrHr'r@r8r8r8r9rsrc@s,eZdZdZddZddZeddZdS) r z)Base class for time delta representationscCs$|dk r |tkr td|t|S)zU Check that the scale is in the allowed list of scales, or is `None` Nz+Scale value '{0}' not in allowed values {1})TIME_DELTA_SCALESryrr)rSrKr8r8r9rZs zTimeDeltaFormat._check_scalecCs,||jt||d|jd\|_|_dS)Ng?)r)rZr[r rkrOrP)rSrTrUr8r8r9rRs zTimeDeltaFormat.set_jdscCs|j|j|jS)N)rOrPrk)rSr8r8r9rbszTimeDeltaFormat.valueN)rFrGrHrIrZrRr}rbr8r8r8r9r s c@seZdZdZdZdejZdS)r!zTime delta in SI secondsrg?N)rFrGrHrIr<rrrkr8r8r8r9r!sc@seZdZdZdZdZdS)r"z,Time delta in Julian days (86400 SI seconds)rg?N)rFrGrHrIr<rkr8r8r8r9r"sc@s0eZdZdZdZddZddZeddZd S) r)z Time delta in datetime.timedeltarcCs,tdd|jDs$td|j|dfS)Ncss|]}t|tjVqdS)N)rlrr)rr\r8r8r9rsz4TimeDeltaDatetime._check_val_type..z=Input values for {0} class must be datetime.timedelta objects)rprrqrrr<)rSrTrUr8r8r9rQs z!TimeDeltaDatetime._check_val_typecCsp||jtj|dgdgtgtjgd}x |D]\}}||d<q2Wt|j ddt j d\|_ |_ dS)Nr)rfr.rg)r)rZr[r`rrrorZ total_secondsr rrrrOrP)rSrTrUrr\rr8r8r9rRs   zTimeDeltaDatetime.set_jdscCs`tj|j|jdgdg|jjgtgd}x$|D]\}}tj|d|d<q0W| |j dS)Nr)rfr)Zdays.r) r`rrOrPrnrrrrrcr)rSrrrr8r8r9rbs zTimeDeltaDatetime.valueN) rFrGrHrIr<rQrRr}rbr8r8r8r9r)s  )rrxrry)Drrr2rr collectionsrrZnumpyr`Zastropy.utils.decoratorsrZastropy.utils.exceptionsrZastropyrrtrrZutilsr r r r __all__Z__doctest_skip__r&r'r r:rr;r rrrrrrrrrrrrr(rrrrr*rrrrr#r$r%rr r!r"r)Zcorerrxrryr8r8r8r9sx       3AT &a3"X(#