IR-ez1ddlZddlZddlZddlZddlZddlmZmZddlm Z ddl Z ddl Z ddl mZddlmZmZddlmZmZddlmZmZmZddlmZmZmZmZgd Zd gZeZ eZ!d d d d d dZ"GddeZ#dZ$GddZ%Gdde%Z&Gdde&Z'Gdde&Z(dZ)Gdde&Z*Gdde&Z+Gdd e+Z,Gd!d"e,Z-Gd#d$e+Z.Gd%d&e+Z/Gd'd e+Z0Gd(d)e+Z1Gd*d+e%Z2Gd,d-e2Z3Gd.d/e2Z4Gd0d1e2Z5Gd2d3ej6Z7Gd4d5e2Z8Gd6d7e8Z9Gd8d9e9Z:Gd:d;e9Z;Gd<d=e:Z<Gd>d?e8Z=Gd@dAe&Z>GdBdCe>Z?GdDdEe>Z@GdFdGe8ZAGdHdIeAZBGdJdKeAZCGdLdMe%ZDGdNdOeDe&ZEGdPdQeEZFGdRdSeEZGGdTdUeDe2ZHdVZIdWZJddXlKmLZLmMZMmNZNmOZOdS)YN) OrderedDict defaultdict)Decimal) classproperty lazyproperty)AstropyDeprecationWarningAstropyUserWarning) _parse_timesconfutils)day_fracquantity_day_frac two_producttwo_sum)# AstropyDatetimeLeapSecondWarning TimeFormatTimeJDTimeMJD TimeFromEpochTimeUnix TimeUnixTai TimeCxcSecTimeGPSTimeDecimalYear TimePlotDate TimeUnique TimeDatetime TimeStringTimeISOTimeISOTTimeFITSTimeYearDayTime TimeEpochDateTimeBesselianEpochTimeJulianEpochTimeDeltaFormat TimeDeltaSec TimeDeltaJDTimeEpochDateStringTimeBesselianEpochStringTimeJulianEpochString TIME_FORMATSTIME_DELTA_FORMATS TimezoneInfoTimeDeltaDatetimeTimeDatetime64 TimeYMDHMS TimeNumericTimeDeltaNumericrttutctai)TDTETGMTUTIATceZdZdZdS)rzDWarning for leap second when converting to datetime.datetime object.N__name__ __module__ __qualname____doc__4lib/python3.11/site-packages/astropy/time/formats.pyrrMsNNNNrDrc"g}|D]|}|d}t|trHdD]\}}|||}d|vr&|dtj|dz|df}||}t |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}))%Sz(?P\d{1,2})%r$) isinstancestrreplacerecompileappendtuple)subfmts new_subfmts subfmt_tuple subfmt_in strptime_coderegexs rE_regexify_subfmtsrXQsK))  O i % % ) D D$ u&--mUCC )## OJy3// O  <((((   rDc<eZdZdZdZdZeZ d!dZfdZ e dZ e dZ e jd Z e d Zejd Ze d Zejd Ze dZejdZdZe dZejdZdZe dZe dZe dZe dZejdZedZdZdZdZd"dZe dZe d Z xZ!S)#ra1 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. Quantities with time units are allowed for formats where the interpretation is unambiguous. 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 r6rCFc||_||_||_||_d\|_|_|r||_||_dS|||\}}| ||dS)NNN) scale precision in_subfmt out_subfmt_jd1_jd2jd1jd2_check_val_typeset_jds)selfval1val2r\r]r^r_from_jds rE__init__zTimeFormat.__init__s{ ""$) 49  %DHDHHH--dD99JD$ LLt $ $ $ $ $rDc d|jvrG|jdkr||||_dSr)r{rrfr|s rEr^zTimeFormat.in_subfmts# V$$$ rDc|jSr) _out_subfmtrs rEr_zTimeFormat.out_subfmt rDc>||||_dSr)r{rrs rEr_zTimeFormat.out_subfmts& V$$$!rDc|jSr)r`rs rErbzTimeFormat.jd1 yrDct||_|j)t|j|j\|_|_dSdSr)_validate_jd_for_storager`ra_broadcast_writeable)rfrbs rErbzTimeFormat.jd1A,S11 9 #7 49#M#M DItyyy ! rDc|jSr)rars rErczTimeFormat.jd2rrDct||_|j)t|j|j\|_|_dSdSr)rrar`r)rfrcs rErczTimeFormat.jd2rrDc*t|jSr)lenrbrs rE__len__zTimeFormat.__len__s48}}rDcN||j|_|jS)z Time scale.) _check_scale_scalers rEr\zTimeFormat.scales#'' 44 {rDc||_dSr)rrfvals rEr\zTimeFormat.scales  rDcb|jr'tj||jd}|S)NF)maskcopy)maskednpmaarrayr)rfrns rEmask_if_neededzTimeFormat.mask_if_neededs- ; CEKKDIEKBBE rDcd|jvrJtj|j|jd<|jdjrd|jdj_|jdS)NrF)cacherisnanrcshapeflags writeablers rErzTimeFormat.masksX  # #!#$(!3!3DJv z&!' ;5: 6"(2z&!!rDcd|jvr.ttj|j|jd<|jdS)Nr)rboolranyrrs rErzTimeFormat.maskeds< 4: % %#'ty(9(9#:#:DJx z(##rDcP|jrtj|jn|jSr)rr nan_to_numrcrs rE jd2_filledzTimeFormat.jd2_filled s"*.+Cr}TX&&&48CrDc|jSr) _precisionrs rEr]zTimeFormat.precisionrrDctt|tr |dks|dkrtd||_dS)Nr z2precision attribute must be an int between 0 and 9)rKintrrrrs rEr]zTimeFormat.precisionsA#s## SsQww#''QRR RrDc*ttS)zA Return the cache associated with this instance. )rdictrs rErzTimeFormat.caches 4   rDctj|}|jdkr|}n |jdkrd}|jjdkr|jjdkr|p |jdk}|dupQ|jjdko6|jjdko&tjtj| p |jdk}|r|std|j dt|d dtj |d }|tj |d } t||\}}n'#tj$rtjd wxYwd t|d d z }|d kr.t#||\}}|||zz }t%||\}}n t|d dtd |tjd|j}d}||||fS)@Input value validation, typically overridden by derived classes.r rFfNInput values for z class must be finite doublesunit)rzJonly quantities with time units can be used to instantiate Time instances.?z$Cannot mix float and Quantity inputsdtypecbt|tjrtj|n|S)z Remove ndarray subclasses since for jd1/jd2 we want a pure ndarray or a Python or numpy scalar. )rKrndarrayasarray)rs rEasarray_or_scalarz5TimeFormat._check_val_type..asarray_or_scalarbs' '1bj&A&AJ2:c???s JrD)risfinitesizeallrkinditemsizerisinf TypeErrorrlgetattruQuantityr UnitsErrorUnitConversionErrorrrr) rfrgrh isfinite1ok1ok2factorcarryrs rErdzTimeFormat._check_val_type#skK%% 9q==  IY!^^I JOs "  #q(  yA~  DL  3&/J'1,/rx~~...   yA~   LDILLL  4 & & 2 :d///Dz$U333 .tT:: dd<   +: 74555F}})$77 e&$T511 d T64 ( ( 4BCC C <8ATZ000D K K K! &&(9(9$(?(???s !D55$Ec^||j}|tvrtd|dt|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. N Scale value '' not in allowed values )_default_scale TIME_SCALESScaleValueErrorrfr\s rErzTimeFormat._check_scaleksH ='E  # #!LLL{LL  rDct)zl Set internal jd1 and jd2 from val1 and val2. Must be provided by derived classes. NotImplementedErrorrfrgrhs rErezTimeFormat.set_jdss "!rDNc|*|j} ||_|j}||_n#||_wxYw|j}||S)a Return time representation from internal jd1 and jd2 in specified ``out_subfmt``. This is the base method that ignores ``parent`` and uses the ``value`` property to compute the output. This is done by temporarily setting ``self.out_subfmt`` and calling ``self.value``. This is required for legacy Format subclasses prior to astropy 4.0 New code should instead implement the value functionality in ``to_value()`` and then make the ``value`` property be a simple call to ``self.to_value()``. Parameters ---------- parent : object Parent `~astropy.time.Time` object associated with this `~astropy.time.TimeFormat` object out_subfmt : str or None Output subformt (use existing self.out_subfmt if `None`) Returns ------- value : numpy.array, numpy.ma.array Array or masked array of formatted time representation values )r_rnr)rfparentr_out_subfmt_origrns rEto_valuezTimeFormat.to_values[4  !"oO 2", "1/1111JE""5)))s! *ctrrrs rErnzTimeFormat.values!!rDcpttstddkr|jSfd|jD}t |dkr]t |jdkrtd|jd|jD}tdd|d |j|S) am Return a list of subformats where name matches ``pattern`` using fnmatch. If no subformat matches pattern then a ValueError is raised. A special case is a format with no allowed subformats, i.e. subfmts=(), and pattern='*'. This is OK and happens when this method is used for validation of an out_subfmt. z!subfmt attribute must be a stringrzcJg|]}tj|d| Sr)fnmatch fnmatchcase).0xpatterns rE z.TimeFormat._select_subfmts..s/PPPW-@1w-O-OP1PPPrDrz!subformat not allowed for format cg|] }|d SrrC)rrs rErz.TimeFormat._select_subfmts..s:::!:::rDz subformat z must match one of z for format )rKrLrrrRrrl)rvrrR subfmt_namess ` rEr{zTimeFormat._select_subfmtss'3'' @AA A ^^; PPPPckPPP w<<1  3;1$$ !OSX!O!OPPP::ck:::  <<<#<<14<< rDFr[)"r?r@rArBrrRr-rsrjru classmethodr}propertyr^setterr_rbrcrr\rrrrr]rrrdrrerrnr{ __classcell__rxs@rErrts0NGILQ%%%%"33333*  [ X!!!   X """ X ZNNZN X ZNNZN X  \\ ""X"$$X$ DDXDX !!\! F@F@F@P."""$*$*$*$*L""X"[rDrceZdZdejdejfdejejej fdej ej ej fdej ej ejfdejejejffZfdZd dZeeZxZS) r3floatNlongdecimalrLbytesc|du}|jjdkr&t||\}}nV|r<|jjdvsF|jjdkrt d|jDst d|jd|r|jntj |j|j}| |j }|D]\}}}} tj ||rntd|7 |||\}}n&#t$rt d|jd wxYw||fS) rNrUSOc3@K|]}t|tVdSr)rKr)rvs rE z.TimeNumeric._check_val_type..s,BB1 1g..BBBBBBrDfor zd class, input should be doubles, string, or Decimal, and second values are only allowed for doubles.z*input type not among selected sub-formats.zr class, input should be (long) doubles, string, or Decimal, and second values are only allowed for (long) doubles.)rrrtrdrflatrrlr result_typer{r^ issubdtyperr Exception) rfrgrhorig_val2_is_none val_dtyperRr|rconvert_rxs rErdzTimeNumeric._check_val_types !DL :?c ! !00t<  $DN,C C C:  ;(C ;(C  J%%j11!4 !9( ( (4++D$%1D*D!E!EFFGGF)MMMF5Mq #s--f--""5)))rD)NNNN)r?r@rArfloat64add longdoubler longdouble_to_twovaltwoval_to_longdoubleobject_decimal_to_twovaltwoval_to_decimalstr_twoval_to_stringbytes_bytes_to_twovaltwoval_to_bytesrRrdrrrnrrs@rEr3r3s "*dBF+  :Ercrtrr)rfrwr\rBimsidsihmsfsrErFrGrHrIrJrKrLrMdtdt_endr.rxs rErzTimeDecimalYear.to_valuesi   ""))'22%)Z 1dh& & "#sF|H%%|H%%mH%%}X&&}TX&&   ""))'22#z%4sDRVWW 9:eX\4sDRVWWh"tx)'; <I%'I*=>f, uwwOKRZ__OOOOOrD) r?r@rArBrlrdrerrrnrrs@rErrVs{   D33333 >>>:PPPPP. HX  EEEEErDrceZdZdZeddZedZdZd fd Z ee Z ed Z xZ S) rz Base class for times that represent the interval from a particular epoch as a numerical multiple of a unit time interval (e.g. seconds or days). T)lazycPt|j|j|j|jS)Nr5)r? epoch_val epoch_val2 epoch_scale epoch_format)rvs rE_epochzTimeFromEpoch._epochs0  M N/#     rDc|jS)>Reference epoch time from which the time interval is measured.)r`rs rEepochzTimeFromEpoch.epochs {rDc t||d|jz \}}|jj|z}|jj|z}|jj|jkrW|jrtj|n t| }||z }||z}||c|_|_dS tt|||j d|j}n=#t$r0} td|jd|j d|jd | | d} ~ wwxYwt|jj|jj\|_|_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). rdivisorNrr5Cannot convert from '' epoch scale '' to specified scale '', got error: )rrrcrbrcr\rrrounditemrr?r^rrrl_time) rfrgrhdayfracrbrc jd1_extratmerrs rErezTimeFromEpoch.set_jdssy"T4tyAAA Tjns"jnt# : tz ) )),I chhjj8I8II 9 C 9 C!$c DHdh F S#T%5dCCCTZBB   !H HH$BRHH'+zHHBEHH   &bhlBHLAA$(((s)+C D+D  DNc |j|jkr~|td t||j}n=#t$r0}t d|jd|jd|jd||d}~wwxYw|jj|jj }}n|j|j }}d|j z }||j jz |z}||j j z |z} tj d|| d|S) Nz/cannot compute value without parent Time objectrgrhrirjrr(rC)r\r^rrrrrrlrmrbrcrrcrtr) rfrrwrqrrrbrcrtime_from_epoch1time_from_epoch2rxs rErzTimeFromEpoch.to_values4 :) ) )~ !RSSS VT%566   %)DI))())@D ))#&))  x|RX\CCxCty$*.0F:$*.0F:uwwU$4:JUUfUUUs: A4+A//A4c|jSr)r^rs rErzTimeFromEpoch._default_scale rrDr) r?r@rArBrr`rrcrerrnrrrs@rErrs ]     X3B3B3BjVVVVVV6 HX  E   X     rDrc:eZdZdZdZdejz ZdZdZ dZ dZ dS)ra Unix time (UTC): seconds from 1970-01-01 00:00:00 UTC, ignoring leap seconds. 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. unixr1970-01-01 00:00:00Nr6iso r?r@rArBrlr$DAYSECrr\r]r^r_rCrDrErrs?   D  D%IJKLLLrDrceZdZdZdZdZdZdS)raq Unix time (TAI): SI seconds elapsed since 1970-01-01 00:00:00 TAI (see caveats). This will generally differ from standard (UTC) Unix time by the cumulative integral number of leap seconds introduced into UTC since 1972-01-01 UTC plus the initial offset of 10 seconds at that date. This convention matches the definition of linux CLOCK_TAI (https://www.cl.cam.ac.uk/~mgk25/posix-clocks.html), and the Precision Time Protocol (https://en.wikipedia.org/wiki/Precision_Time_Protocol), which is also used by the White Rabbit protocol in High Energy Physics: https://white-rabbit.web.cern.ch. Caveats: - Before 1972, fractional adjustments to UTC were made, so the difference between ``unix`` and ``unix_tai`` time is no longer an integer. - Because of the fractional adjustments, to be very precise, ``unix_tai`` is the number of seconds since ``1970-01-01 00:00:00 TAI`` or equivalently ``1969-12-31 23:59:51.999918 UTC``. The difference between TAI and UTC at that epoch was 8.000082 sec. - On the day of a positive leap second the difference between ``unix`` and ``unix_tai`` times increases linearly through the day by 1.0. See also the documentation for the `~astropy.time.TimeUnix` class. - Negative leap seconds are possible, though none have been needed to date. Examples -------- >>> # get the current offset between TAI and UTC >>> from astropy.time import Time >>> t = Time('2020-01-01', scale='utc') >>> t.unix_tai - t.unix 37.0 >>> # Before 1972, the offset between TAI and UTC was not integer >>> t = Time('1970-01-01', scale='utc') >>> t.unix_tai - t.unix # doctest: +FLOAT_CMP 8.000082 >>> # Initial offset of 10 seconds in 1972 >>> t = Time('1972-01-01', scale='utc') >>> t.unix_tai - t.unix 10.0 unix_tairyr7N)r?r@rArBrlr\r^rCrDrErr$s*,,\ D%IKKKrDrc:eZdZdZdZdejz ZdZdZ 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. cxcsecrz1998-01-01 00:00:00Nr5rzr{rCrDrErrXs? D  D%IJKLLLrDrc:eZdZdZdZdejz ZdZdZ 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 https://www.usno.navy.mil/USNO/time/gps/usno-gps-time-transfer gpsrz1980-01-06 00:00:19Nr7rzr{rCrDrErrfs?   D  D%IJKLLLrDrc@eZdZdZdZdZdZdZdZdZ e dZ 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. plot_datergPD:ANr6rc ddlm}|}ddlm}t j5t jd|t|dd}d d d n #1swxYwYd |_n#t$r |j }YnwxYw|S) rbr) get_epoch) ErfaWarningignore)categoryr6isotr5Nr) matplotlib.datesrr$rwarningscatch_warningsfilterwarningsr?r6 ImportErrorr`)rfr epoch_utcrr`s rErczTimePlotDate.epochs ! 2 2 2 2 2 2 " I ( ( ( ( ( ((** E E';GGGGiuVDDD E E E E E E E E E E E E E E E!FMM ! ! ![FFF ! s"A3)A  A$'A$3BB) r?r@rArBrlrr\r]r^r_rrcrCrDrErr}sW& D DIJKL\rDc*eZdZdZdZdZdZdZdZdZ dS) TimeStardatez Stardate: date units from 2318-07-05 12:00:00 UTC. For example, stardate 41153.7 is 00:52 on April 30, 2363. See http://trekguide.com/Stardates.htm#TNG for calculations and reference points. stardateg|u?z2318-07-05 11:00:00Nr7rz) r?r@rArBrlrr\r]r^r_rCrDrErrs8 D D%IJKLLLrDrceZdZdZdS)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. Nr>rCrDrErrsrDrc eZdZdZdZ ddZdS)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. rmFc t|jdttr tfd|jDst d|jdj|jrfd|D}tj d|D} tj d|D} td |Drtd |Drtd g} |D]T} tj | j | jjjd } | tj| Utj | } n-d} n*t%j}|j|j} } j } jj}|| | |||d }| |_|S)z Use __new__ instead of __init__ to output a class instance that is the same as the class of the first Time object in the list. rc3TK|]"}t|tuV#dSr)type)rrval1_0s rErz*TimeAstropyTime.__new__..s4CC#DIIf-CCCCCCrDrz. class must all be the same astropy Time type.Nc:g|]}t|jSrC)rrm)rrr\s rErz+TimeAstropyTime.__new__..s&>>>#GC''->>>rDc@g|]}tj|jSrC)r atleast_1drbrrs rErz+TimeAstropyTime.__new__..$!I!I!IS"-"8"8!I!I!IrDc@g|]}tj|jSrC)rrrcrs rErz+TimeAstropyTime.__new__..rrDc3(K|] }|jduVdSrlocationrrqs rErz*TimeAstropyTime.__new__..s)::r2;d*::::::rDc3(K|] }|jduVdSrrrs rErz*TimeAstropyTime.__new__..s)::rr{d*::::::rDzMcannot concatenate times unless all locations are set or no locations are setT)subok)ri)rrKr?rrrlr\rr concatenaterrr broadcast_torrmrbrPrrrcrx _location)rvrgrhr\r]r^r_rivalsrbrc locationsrqrr OutTimeFormatrfrs ` @rE__new__zTimeAstropyTime.__new__s1 vt $ $ CCCCCCCCC %CH%%%  =LE : '>>>>>>>D.!I!ID!I!I!IJJC.!I!ID!I!I!IJJC::T::::: ::T:::::$: >>B! RX\%7t   H$$R]8%<%<====>)44 &%((.CwCH . } eY :t    " rDNr)r?r@rArBrlrrCrDrErrs@ DKP999999rDrcBeZdZdZdZdZdZ ddZeeZ dS) ran 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) datetimectd|jDstd|jd|t |jd||dfS)Nc3JK|]}t|tjVdSr)rKrrs rErz/TimeDatetime._check_val_type..s/KK#:c8#455KKKKKKrDrz class must be datetime objects/ objects do not accept a val2 but you provided rrrrlrrrs rErdzTimeDatetime._check_val_types~KKKKKKK NDINNN   9SSTSS TzrDc tj|ddddddgddgdgdtjgzztjgz}|D]\}}}}}} } |} | j+| | z d} | j|d<| j |d<| j |d<| j |d<| j | d<| j | jdz z| d<tj|jd g|jd dR\} } t+| | \|_|_dS) z6Convert datetime object contained in val1 to jd1, jd2.Nrefs_ok zerosize_okr op_dtypestzinfo..Ar4r )rnditerintcr9rlr utcoffsetrMyearmonthrnhourminutesecond microsecondr$r>r\r<r=operandsrrbrc)rfrgrhiteratorriyimidrGrHdsecrWrbrcs rErezTimeDatetime.set_jds(sb9 4tT4 6m,fqBG9}, {:    19 9 9 ,CRS$By$2<<>>)22$2??gBsGhBsGfBsGwCH DI BNS$88DII: J     % %g . . 191B1221F   S&c3//$(((rDNraisec ||||#|jdkrtd|jd|jd}t j|d|j|j \}}}} | d} | d} | d } | d } tj |||| | | | dgd d gd dgztgz}|D]\}}}}}}}}|dkr|dz }d}nd}|>> from astropy.time import Time >>> t = Time("2015-06-30 23:59:60.500") >>> print(t.to_datetime(leap_second_strict='silent')) 2015-07-01 00:00:00.500000 Parameters ---------- timezone : {`~datetime.tzinfo`, None}, optional If not `None`, return timezone-aware datetime. leap_second_strict : str, optional If ``raise`` (default), raise an exception if the time is within a leap second. If ``warn`` then issue a warning. If ``silent`` then silently handle the leap second. Returns ------- `~datetime.datetime` If ``timezone`` is not ``None``, output will be timezone-aware. Nr6z scale is z*, must be 'utc' when timezone is supplied.r4hmsrrrr<r TFr)secondsTime z is within a leap second but `datetime` does not support leap seconds. Use the `leap_second_strict` argument of the `Time.to_datetime()` method with value of 'raise', 'warn', or 'silent' to control how leap seconds are handled.rwarnsilentz>leap_second_strict must be 'raise', 'warn', or 'silent', not ''.)r{rrr\r<r=r$rSrbrrrobjectrr/ astimezone timedeltarrrrrrr)rftimezoneleap_second_strictrr_r\iysrTrUrVihrsiminsisecsifracsrrrrrGrHrIifracsecoutin_leap_secondrWmsgs rErzTimeDatetime.to_valueBs>  !   , , ,  {e##%W WWW    ""))'22 $ 1dh! ! S#vc{s s 9 #sD% =m,4&jF8+    ;C   6BBT43rzzax!%!&#&BT4,..*X&&&r2r3dHMM h(3333KBKKK &00$S//)'611M#'GHHHH'833$6 2666 CHH""8#4R#8999rD)NrNN) r?r@rArBrlrdrerrrnrCrDrErr sn   D   0006RV\:\:\:\:| HX  EEErDrc8eZdZdZdZdZdZedZdS)r2aB ymdhms: A Time format to represent Time as year, month, day, hour, minute, second (thus the name ymdhms). Acceptable inputs must have keys or column names in the "YMDHMS" set of ``year``, ``month``, ``day`` ``hour``, ``minute``, ``second``: - Dict with keys in the YMDHMS set - NumPy structured array, record array or astropy Table, or single row of those types, with column names in the YMDHMS set One can supply a subset of the YMDHMS values, for instance only 'year', 'month', and 'day'. Inputs have the following defaults:: 'month': 1, 'day': 1, 'hour': 0, 'minute': 0, 'second': 0 When the input is supplied as a ``dict`` then each value can be either a scalar value or an array. The values will be broadcast to a common shape. Example:: >>> from astropy.time import Time >>> t = Time({'year': 2015, 'month': 2, 'day': 3, ... 'hour': 12, 'minute': 13, 'second': 14.567}, ... scale='utc') >>> t.iso '2015-02-03 12:13:14.567' >>> t.ymdhms.year 2015 ymdhmsc|tdgd}jjrfdjjD}nщjdkrdSjjdkrjdkrt trs} }d t|tj |D}ntd |}|dt|}d }t|t|z } | rt|| d t|t|kr+td t|d||||fS)aM This checks inputs for the YMDHMS format. It is bit more complex than most format checkers because of the flexible input that is allowed. Also, it actually coerces ``val1`` into an appropriate dict of ndarrays that can be used easily by ``set_jds()``. This is useful because it makes it easy to get default values in that routine. Parameters ---------- val1 : ndarray or None val2 : ndarray or None Returns ------- val1_as_dict, val2 : val1 as dict or None, val2 is always None Nz#val2 must be None for ymdhms format)rrrnrrrc"i|] }|| SrCrC)rrlrgs rE z.TimeYMDHMS._check_val_type..sJJJD$t*JJJrDrr[rrCci|]\}}|| SrCrC)rrlrns rErz.TimeYMDHMS._check_val_type..s+ +eerDz input must be dict or table-likec@dd|DS)Nz, c34K|]}t|VdSr)reprrs rErzATimeYMDHMS._check_val_type..comma_repr..s(773T#YY777777rD)join)rs rE comma_reprz.TimeYMDHMS._check_val_type..comma_reprs#9977$77777 7rDz" not allowed as YMDHMS key name(s)rz! input key names you must supply )rrrnamesrrrKrlrkeysvaluesziprbroadcast_arraysrset) rfrgrhr val1_as_dictrrrequired_namesr bad_namess ` rErdzTimeYMDHMS._check_val_types&  BCC CEEE :  AJJJJ9IJJJLL Z4  : JOs " " b  499;;--!IIKK$$&&EYY[[''))F/25":Mv:V/W/WLL ?@@ @!!## #e** - 8 8 8JJV,  :i((LLL  u::^,, , ,@s5zz@@#-:n#=#=@@  T!!rDc (|Atjgtj}tjgtj}ntj|jd|d|dd|dd|dd|d d|d d\}}t||\|_ |_ dS) Nrr4rrr rnrrrr) rrrr$r>r\r<r=getrrbrcr&s rErezTimeYMDHMS.set_jds s <(2RZ000C(2RZ000CCz   ""))'22V !$$""##1%%1%%HC&c3//$(((rDc|jd}tj|d|j|j\}}}}tj|jj gd}||d<||d<||d<|d|d <|d |d <|d |d dzz|d<| tj }| |S)Nr4r))ri4)rr)rnr)rr)rr)rf8rrrrnrrrrrrg& .>r) r\r<r=r$rSrbrremptyrviewrecarrayr)rfr\rrTrUrVrs rErnzTimeYMDHMS.value s   ""))'22 $ 5!TXt O OS#vh HN    F G E SkF s H s fSkJ&>>H hhr{##""3'''rDN r?r@rArBrlrdrerrnrCrDrEr2r2sb> DF"F"F"P000&((X(((rDr2ceZdZdZejejejdejzdejzdfdZdZdZ dZ dS) r/a) Subclass of the `~datetime.tzinfo` object, used in the to_datetime method to specify timezones. It may be safer in most cases to use a timezone database package like pytz rather than defining your own timezones - this class is mainly a workaround for users without pytz. ) utc_offsetdstrNc |dkr |dkr|d}tj|tj|_||_tj|tj|_dS)a Parameters ---------- utc_offset : `~astropy.units.Quantity`, optional Offset from UTC in days. Defaults to zero. dst : `~astropy.units.Quantity`, optional Daylight Savings Time offset in days. Defaults to zero (no daylight savings). tzname : str or None, optional Name of timezone Examples -------- >>> 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 rNUTC)rrrrrn _utcoffset_tzname_dst)rfrrtznames rErjzTimezoneInfo.__init__Esk4 ??saxxFNF",Z-@-@-G-GHH &s||AE':':;; rDc|jSr)r rfrWs rErzTimezoneInfo.utcoffsetes rDc*t|jSr)rLr rs rEr zTimezoneInfo.tznamehs4<   rDc|jSr)r rs rErzTimezoneInfo.dstks yrD) r?r@rArBrquantity_inputrnrjrr rrCrDrEr/r/;sQAE222"#ae)QU4<<<32<>!!!rDr/cbeZdZdZfdZdZdZdZdZdZ dZ d Z e d Z xZS) ra 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. **Fast C-based parser** Time format classes can take advantage of a fast C-based parser if the times are represented as fixed-format strings with year, month, day-of-month, hour, minute, second, OR year, day-of-year, hour, minute, second. This can be a factor of 20 or more faster than the pure Python parser. Fixed format means that the components always have the same number of characters. The Python parser will accept ``2001-9-2`` as a date, but the C parser would require ``2001-09-02``. A subclass in this case must define a class attribute ``fast_parser_pars`` which is a `dict` with all of the keys below. An inherited attribute is not checked, only an attribute in the class ``__dict__``. - ``delims`` (tuple of int): ASCII code for character at corresponding ``starts`` position (0 => no character) - ``starts`` (tuple of int): position where component starts (including delimiter if present). Use -1 for the month component for format that use day of year. - ``stops`` (tuple of int): position where component ends. Use -1 to continue to end of string, or for the month component for formats that use day of year. - ``break_allowed`` (tuple of int): if true (1) then the time string can legally end just before the corresponding component (e.g. "2000-01-01" is a valid time but "2000-01-01 12" is not). - ``has_day_of_year`` (int): 0 if dates have year, month, day; 1 if year, day-of-year c d|jvr|j}tjt t t t|d|d|d|dtj }|jdrdx|dd <|d d <tj ||_ tj d i|dS) Nfast_parser_parsdelimsstartsstops break_allowedhas_day_of_yearrstartr stoprC)rprrrlistrmapchrr dt_pars create_parser _fast_parserrtru)rvrwfpprxs rEruzTimeString.__init_subclass__s  - -&C(CX//H G O, $  C#$56 6355G Q#f+a.+9#>>C !!++F+++++rDc|jjdvr|jrtd|jd|t |jd||dfS)N)SUrz class must be stringsr)rrrrrlrrrs rErdzTimeString._check_val_typesk :?* , , ,Q QQQRR R  9SSTSS TzrDcR d}d} |d}|d|||d}}t|}d}n#t$rd}YnwxYw|D]\}} }t| tr9d| v} t j||  fd|D} n\#t$rYPwxYwtj | | l fd t||D} d v} |r| r| d |z| d <n| cStd |d |j d)z@Read time from a single string, using a set of possible formats.)rmonmdayrminsec)Nr r rrrr NTFrGc6g|]}td|zS)tm_)r)r componentrqs rErz+TimeString.parse_string..s(WWWyGB (9::WWWrDc\g|](\}}t||)SrC)rr)rr.defaultrqs rErz+TimeString.parse_string..sC* 7y'2233rDr+rr does not match  format) rindexrrrKrLtimestrptimerrrNmatch groupdictrrl) rftimestrrR componentsdefaultsidotfracsectimestr_has_fractional_digitsrstrptime_fmt_or_regexsubfmt_has_secrrqs @rE parse_stringzTimeString.parse_stringsC ( 1>>#&&D 'uu~wtuu~WGGnnG,0 ) )  2 2 2,1 ) ) ) 2,3! R! R 'A$a/55 -!%)>!>Xw0EFFBXWWWJWWWDD"H X3W==:\\^^.1*h.G.G"'" - !#Bx'1DHHKKKPWPPdiPPPQQ Qs#A AA6B B'&B'cR|jdksd|jjvstjdkr|||\}}nU |||\}}n:#t$r-tjdkr|||\}}YnwxYw||_||_ dS)z:Parse the time strings contained in val1 and set jd1, jd2.rzr"FalseforceN) r^rxrpr use_fast_parserget_jds_python get_jds_fastrrbrcr&s rErezTimeString.set_jdss Nc ! !T^%<<<#w..**466HC ?,,T488SS ? ? ?'722#224>>HC  ?sA4BBc <||j}|jjdkrtnd}t j|ddddddgdgdgdt jgzzt jgz}|D]D\}}}} } } } ||}| ||\|d<|d<| d<| d<| d<| d<Etj |j dg|jd dR\} }t!| |\} }| |fS) z:Parse the time strings contained in val1 and get jd1, jd2.r&cHt|dSNr4)encodingrLrlrs rEz+TimeString.get_jds_python.. QVVXXPW9X9X9XrDNrrr.r4r )r{r^rrrLrrrr9r@r$r>r\r<r=rr)rfrgrhrR to_stringrrrrrrGrHrrbrcs rErEzTimeString.get_jds_pythonsc&&t~66 :?c))CC/X/X 9 4tT4 6 /fqBG9}, {:    19 0 0 ,CRS$)C..C!!#w// 333CS S : J     % %g . . 191B1221F   SC%%SCxrDc |jjdkru|tj|jjdzf}tj|dkrtd|tj }n+|tj |jjf}| |}tj |jd|d|d|d|d |d |d \}}t#||S) zAUse fast C parser to parse time strings in val1 and get jd1, jd2.r&zinput is not pure ASCIIr4rrrnrrr)rrrruint32rrrrr8r dt_u1r"r$r>r\r<r=r)rfrgrh val1_uint32chars time_structrbrcs rErFzTimeString.get_jds_fast#s" :?c ! !))RY 0Cq0H$IJJKvkC'(( < !:;;; &&|'9::EEII|14:3FGHHE''.. : J     % %g . .         !  !  SS!!!rDc #K|jdf}tj||j|j|j\}}}}||j d\}}}d}d|v} |d} |d} |d} |d} tj |||| | | | gd g D]\}}}}}}}| r-tj ||| j}t|t|t|t|t|t|t||d VdS) z Generator that yields a dict of values corresponding to the calendar date and time for the internal JD values. r4rNz{yday:rrrrr)r)rr(rnrr*r+r<yday)r\r<r=r$rSr]rbrr{r_rrr timetupletm_ydayr)rfr\rrTrUrVrstr_fmtrYhas_ydayrrrrrrrrGrHrIrs rE str_kwargszTimeString.str_kwargsDs !!##**7335 $ 4>48T_! ! S#v ,,T_==a@ 1gw&c{s s 57Y #sD% 7 6 6 6    1BBT4 I(R44>>@@HB2ww2wwC4yy4yyx==         rDc |jdi|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. rC)r6)rfr\rws rE format_stringzTimeString.format_stringis w~'''''rDc ||j}|d\}}}|jdkr2|dr|dt |jzdzz }g}|D]0}|t |j|fi|1tj | |j j S)Nrz {sec:02d}z .{fracsec:0zd}) r{r_r]endswithrLr^rPr`rrreshaperbr)rfrRrr\outsrws rErnzTimeString.valueqs&&t77 1g >A  '"2"2;"?"?  }s4>':'::TA AGoo'' D DF KK.D.wAA&AABB C C C Cx~~%%dhn555rD)r?r@rArBrurdr@rerErFr^r`rrnrrs@rErros&&P,,,,,(2R2R2Rh2B"""B###J(((66X66666rDrc eZdZdZdZdZedededededededfd d d d Zfd Z xZ S)r a7 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 rz))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}r- :r rrQr r rr rrrrr rr r rrrrrc|dr$|jdkrtd|dd}t||S)NZr6z3Time input terminating in 'Z' must have scale='UTC'r)rbr\rrrtr@)rfr8rRrxs rEr@zTimeISO.parse_strings\   C  #zU"" !VWWWcrclGww##GW555rD) r?r@rArBrlrRrordrr@rrs@rEr r s   D G.t33s88SSXXss3xxS33s88SSXXN(',666666666rDr c eZdZdZdZdZedededededededfd d d d Zd S)r!a 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 r))rfz%Y-%m-%dT%H:%M:%Sz;{year:d}-{mon:02d}-{day:02d}T{hour:02d}:{min:02d}:{sec:02d})rgz%Y-%m-%dT%H:%Mz1{year:d}-{mon:02d}-{day:02d}T{hour:02d}:{min:02d}rhrrjTrlr rmrrrvrwN r?r@rArBrlrRrrzrrCrDrEr!r!s   D Gt33s88SSXXss3xxS33s88SSXXN(',rDr!c eZdZdZdZdZeddedededededfddd d Zd S) r#aq 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 rY))rfz%Y:%j:%H:%M:%Sz2{year:d}:{yday:03d}:{hour:02d}:{min:02d}:{sec:02d})rgz %Y:%j:%H:%Mz({year:d}:{yday:03d}:{hour:02d}:{min:02d})riz%Y:%jz{year:d}:{yday:03d}rrlr )rrrQr )r rrrnrorprrvr rwNr}rCrDrEr#r#s   DG.t1cc#hhC##c((CCHHcc#hhG((,rDr#cBeZdZdZdZfdZefdZxZS)r1 datetime64c|jjdks8|jdkrtd|jdt jgd}|t|jd||dfS)NMrrz! class must be datetime64 objects datetime64[D]r)rrrrrlrrrrrs rErdzTimeDatetime64._check_val_typesz#%%y1}}T TTTxO44  9SSTSS TzrDcrtj|}tj|}|r|}d||<|jjdvr|d}|d}t|||rtj |j |<dSdS)N2000)z datetime64[M]z datetime64[Y]rr%) risnatrrrrlr8rtrenanrc)rfrgrhrrrxs rErezTimeDatetime64.set_jds's x~~  99;;DDJ :?@ @ @;;//D{{3 d###  $VDHTNNN $ $rDc~|j}d|_tj}||_|dS)Nrr)r]rtrnr8)rfr]retrxs rErnzTimeDatetime64.value>s5N ggm"zz,'''rD) r?r@rArlrdrerrnrrs@rEr1r1sq D   $$$$$.((((X(((((rDr1cjeZdZdZdZdZedeDZdZefdZ xZ S)r"u 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). fits))rfz_(?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})riz,(?P\d{4})-(?P\d\d)-(?P\d\d)z{year:04d}-{mon:02d}-{day:02d}) 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})longdatez0(?P[+-]\d{5})-(?P\d\d)-(?P\d\d)z{year:+06d}-{mon:02d}-{day:02d}c#JK|]}|d|ddz|dfVdS)rr z0(\((?P\w+)(\((?P\w+)\))?\))?rJNrC)rr|s rErzTimeFITS.wsU  1I 1IK K 1I rDc |D]\}}}tj||}|rn td|d|jd|}|dt jdt|d}t || }|tvr'td|dtt|j||_||jkrtd |jd t!|d t!|d t!|d t!| ddt!| ddt#| ddgS)z*Read time and deprecated scale if present.rr1r2r\Nze  G, , , \XrDr"cBeZdZdZdZdZfdZeeZxZ S)r$zE Base class for support of Besselian and Julian epoch dates. r5c||jtt|j}|||z\}}t ||\|_|_dSr)rrrr$ epoch_to_jdrrbrc)rfrgrhrrbrcs rErezTimeEpochDate.set_jdss] $+&&&dD$455 ;td{++S%c3//$(((rDc tt|j}||j|j}t jd|tjdd|S)NrRr(rC) rr$ jd_to_epochrbrcrtrrr)rfrwrrnrxs rErzTimeEpochDate.to_valuesVdD$455  DHdh//uwwIErz#II&IIIrD) r?r@rArBrrerrrnrrs@rEr$r$sbN000 JJJJJ HX  EEEEErDr$c.eZdZdZdZdZdZfdZxZS)r%zBesselian Epoch year as value(s) like 1950.0. Since for this format the length of the year varies, input needs to be floating point; it is not possible to use Quantity input, for which a year always equals 365.25 days. byearepb2jdepbctt|j||t||Srr0r1s rErdz"TimeBesselianEpoch._check_val_typer2rD) r?r@rArBrlrrrdrrs@rEr%r%sS DKK333333333rDr%c,eZdZdZdZejZdZdZ dS)r&z*Julian Epoch year as value(s) like 2000.0.jyearepj2jdepjN) r?r@rArBrlr$DJYrrrrCrDrEr&r&s*44 D 8DKKKKrDr&c2eZdZdZdZdZedZdS)r*zx Base class to support string Besselian and Julian epoch dates such as 'B1950.0' or 'J2000.0' respectively. r5c |j}|jjdkrtnd}t j|dg|jtjgdg}|D]\}} ||}|d|dd} } t| } | |krt | |d<X#tttf$rtd|d |j d wxYw| |jtt |j} | |jd \} }t'| |\|_|_dS) Nr&cHt|dSrIrKrLs rErMz-TimeEpochDateString.set_jds..rNrDr)rrrr .rr1r2r) epoch_prefixrrrLrrr9rr<rr IndexErrorUnicodeEncodeErrorrlrrrr$rrrrbrc)rfrgrhrrOrryearstime_str epoch_typeyear_strrrrbrcs rErezTimeEpochDateString.set_jdss|( :?c))CC/X/X 9 4LTZ$;M?   # " "JC "$9S>>'/{HQRRLH X##%%55$$6 "c  ,>? R R R !P!P!Pdi!P!P!PQQQ R $+&&&dD$455 ;x0455S%c3//$(((s A B''3Cc0tt|j}||j|j}|jdzt |jzdzfd|jD}tj | |jj S)Nz%.rcg|]}|zSrCrC)rrr\s rErz-TimeEpochDateString.value..s6664$666rD) rr$rrbrcrrLr]rrrrcr)rfrrrdr\s @rErnzTimeEpochDateString.value sdD$455  DHdh//#d*S-@-@@3F66665:666x~~%%dhn555rDN)r?r@rArBrrerrnrCrDrEr*r*sO N000466X666rDr*c"eZdZdZdZdZdZdZdS)r+z7Besselian Epoch year as string value(s) like 'B1950.0'. byear_strrrBNr?r@rArBrlrrrrCrDrEr+r+s(AA DKKLLLrDr+c"eZdZdZdZdZdZdZdS)r,z4Julian Epoch year as string value(s) like 'J2000.0'. jyear_strrrJNrrCrDrEr,r,s(>> DKKLLLrDr,ceZdZdZeZdZdS)r'z*Base class for time delta representations.cP|#|tvrtd|dt|S)zV Check that the scale is in the allowed list of scales, or is `None`. Nrr)TIME_DELTA_SCALESrrs rErzTimeDeltaFormat._check_scale-sB  .?!?!?!RRR?PRR  rDN)r?r@rArBr.rsrrCrDrEr'r'(s.44"I     rDr'c:eZdZdZfdZeeZxZS)r4c||jt||d|jz \|_|_dS)Nrre)rrrrrbrcrs rErezTimeDeltaNumeric.set_jds:s? $+&&&%dD# /JJJ$(((rDc xd|jz }|j|z}|j|z}tjd||d|S)Nrr(rC)rrbrcrtr)rfrwrrbrcrxs rErzTimeDeltaNumeric.to_value>sLtyhhuww;CS;;F;;;rD)r?r@rArerrrnrrs@rEr4r49sOKKK<<<<< HX  EEEEErDr4c*eZdZdZdZdejz ZdS)r(zTime delta in SI seconds.r+rN)r?r@rArBrlr$r|rrCrDrEr(r(Is%## D  DDDrDr(ceZdZdZdZdZdS)r)z-Time delta in Julian days (86400 SI seconds).rrN)r?r@rArBrlrrCrDrEr)r)Ps77 D DDDrDr)c8eZdZdZdZdZdZedZdS)r0z!Time delta in datetime.timedelta.rctd|jDstd|jd|t |jd||dfS)Nc3JK|]}t|tjVdSr)rKrrrs rErz4TimeDeltaDatetime._check_val_type..]s/LL3:c8#566LLLLLLrDrz) class must be datetime.timedelta objectsrrrs rErdz!TimeDeltaDatetime._check_val_type\s~LL$)LLLLL XDIXXX   9SSTSS TzrDc||jtj|ddgddgdtjtjg}t jd}|D]6\}}}t||\|d<}||z |d<7t|j d|j d\|_ |_ dS) Nrrrr )days.r) rrrrr9rrdivmodrlrrrbrc) rfrgrhrrnrrbrcothers rErezTimeDeltaDatetime.set_jdsgs $+&&&9 4 m,RY 2     a(((% # #MCc$SXXZZ55OCHes{CHH%h&7&;X=Nr=RSS$(((rDctj|j|jdgddgddtg}|D]8\}}}t ||\}}t j||dzdz|d<9||j dS) NrrriQr)r microseconds.r) rrrbrcrrrrrr)rfrrbrcrjd1_jd2_s rErnzTimeDeltaDatetime.valuevs9 Xtx &m,T6*    & V VMCc!#s++JD$)t$,QTBTUUUCHH""8#4R#8999rDNrrCrDrEr0r0Ws[++ D    T T T : :X : : :rDr0ct|ttfr tj|tjSt|tjrN|jjdkr|jj dks|jjdvr tj|tjSt|tj r"|jjdkr|jj dkr|Std|dt|)NrrriuzJJD values must be arrays (possibly zero-dimensional) of floats but we got z of type ) rKrrrrfloat_genericrrrrrr)rs rErrs"ucl##-x"),,,,"bj!!    !2a!7!728=D;P;Px"),,,, B # #  (<(<ARVWAWAW  >$& > >3788 > >   rDcJ|j|jkr||fStj||j}|j|kr|}n+tjtj||ddg}|j|kr|}n+tjtj||ddg}||fS)NCW) requirements)rr broadcastrequirer)rbrcrs_jd1s_jd2s rErrs yCICx Lc " " (E yE 2?366c3ZPPP yE 2?366c3ZPPP %<rD)rrrr?)PrrrNr4r collectionsrrrrr$numpyr astropy.unitsunitsrastropy.utils.decoratorsrrastropy.utils.exceptionsrr r r r rrrr__all____doctest_skip__r-r.rrrXrr3rrr,rrrrrrrrrrrr2rr/rr r!r#r1r"r$r%r&r*r+r,r'r4r(r)r0rrcorerrrr?rCrDrErs 00000000 @@@@@@@@RRRRRRRR''''''''''DDDDDDDDDDDD$ $ $ L## {}}  []]      OOOOO'9OOO   FZZZZZZZZz OOOOO*OOOd 2 2 2 2 2[ 2 2 2 k0   GGGGGkGGGTl l l l l Kl l l ^}*11111(111h        m./////=///d     =   CCCCCjCCCLTTTTT:TTTnU(U(U(U(U(U(U(U(p111118?111hS6S6S6S6S6S6S6S6l4646464646j464646n&&&&&w&&&R-----g---`/(/(/(/(/(X/(/(/(dpppppzpppfK*33333333$m)6)6)6)6)6*)6)6)6X2/j"         #"+:+:+:+:+:+:+:+:\    *HGGGGGGGGGGGGGrD