a ߙfb@sdZddlZddlZddlZddlZddlZddlmZmZmZddl m Z ddl m Z ddl ZddlZddlmZmZddlmZddlmZdd lmZdd lmZmZdd lmZd d l m!Z!d dl"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(d dl"m)Z)ddl*m+Z+gdZ,dZ-dZ.e/dde-e.fDZ0e-e.Z1ddddddddddddddd d!Z2d"Z3d#Z4d$Z5e/d%de3e4e5e.fDZ6e3e4e5e.Z7ddej8 ej8d&ej8ej8 ej8d&ej8ej9 ej9d&ej9d'Z:ej;d(d)ejd(d)ej?d(d)ej@d$d)ejAd$d*d+d-d.ZBGd/d0d0ejCZDeDjEaFeGZHGd1d2d2eZIGd3d4d4eIZJGd5d6d6eZKGd7d8d8eKZLGd9d:d:eKZMGd;d<dZPd?d@ZQGdAdBdBeRZSdCdDZTdHdEdFZUdS)Iz The astropy.time package provides functionality for manipulating times and dates. Specific emphasis is placed on supporting time scales (e.g. UTC, TAI, UT1) and time representations (e.g. JD, MJD, ISO 8601) that are used in astronomy. N)datetimedate timedelta)strftime)warn)units constants)UnitConversionError)ShapedLikeNDArray)override__dir__) MixinInfodata_info_factory)AstropyWarning)day_frac) TIME_FORMATSTIME_DELTA_FORMATSTimeJD TimeUniqueTimeAstropyTime TimeDatetime) TimeFromEpoch) _strptime) TimeBaseTime TimeDeltaTimeInfoupdate_leap_seconds TIME_SCALESSTANDARD_TIME_SCALESTIME_DELTA_SCALESScaleValueErrorOperandTypeError)taitcbtcgtdbttut1utc)localccs |]}|D]}||fVq qdSN.0scalesscaler,r,0lib/python3.9/site-packages/astropy/time/core.py ,sr2r'r&r')r))r&r')r&)r&r'r#r))r&r'r#)r'r#r)r'r#)r#r))r#))r#r$r#r%)r#r()r#r&)r$r%)r$r')r$r()r$r))r%r&)r%r()r%r))r&r()r&r))r'r()r'r))r#r'r%r$r&r(ccs |]}|D]}||fVq qdSr+r,r-r,r,r1r2Bsg?)r5)r#r')r%r')r'r%)r%r#r6r7)r&r$)r(r')functionr/F)r9r/ include_tio)ZIAU2006ZIAU2000ZIAU1982)ZIAU2006AZIAU2000AZIAU2000BZIAU1994)meanapparentc@seZdZdZdZdZdS)_LeapSecondsCheckrrN)__name__ __module__ __qualname__ NOT_STARTEDRUNNINGDONEr,r,r,r1r=gsr=cseZdZdZejdhBZdZdZdZe j j Z e ddZdfd d Zd d Ze d dZeeejddejDdZddZddZdddZZS)rz Container for meta information like name, description, format. This is required when the object is used as a mixin column within a table, but can be used as a general way to store meta information. serialize_methodT)formatr0 precision in_subfmt out_subfmtlocation_delta_ut1_utc _delta_tdb_ttvaluecCs:|j|j}|dkrd}n|dkr(d}ntd||jS)Nformatted_value)rMjd1_jd2)jd1jd2z7serialize method must be 'formatted_value' or 'jd1_jd2')rEZ_serialize_context ValueError_represent_as_dict_extra_attrs)selfmethodoutr,r,r1_represent_as_dict_attrss z!TimeInfo._represent_as_dict_attrsFcs(t||r$ddddddd|_dS)NrOrN)ZfitsZecsvZhdf5ZyamlZparquetN)super__init__rE)rTbound __class__r,r1rYs zTimeInfo.__init__cCs(|j}|j}||j|ddj}||gS)z Return a list of arrays which can be lexically sorted to represent the order of the parent column. Returns ------- arrays : list of ndarray jdrF)Z_parentr]r\)rTparentZ jd_approxZ jd_remainderr,r,r1get_sortable_arrayss zTimeInfo.get_sortable_arrayscCsdSr+r,rTr,r,r1unitsz TimeInfo.unitcCsg|]}tt|qSr,)getattrnp)r.statr,r,r1 zTimeInfo.)namesZfuncscCsd|vrpd|vrp|d}|dd}d|d<|d|d<|d|d<|jfi|}||_|dur||_n|d|d<|jfi|}|S) NrPrQrFrIr]valval2rM)pop _parent_clsrFrI)rTmaprFrIrVr,r,r1_construct_from_dict_bases  z"TimeInfo._construct_from_dict_basecCsB|dd}|dd}||}|dur0||_|dur>||_|S)NrKrL)rkrnrKrL)rTrm delta_ut1_utc delta_tdb_ttrVr,r,r1_construct_from_dicts   zTimeInfo._construct_from_dictrNc s||||d}|d|d|ddD]4}ztd|Wq.ty`tdYq.0q.|f|d}d}tj||d d } tj|d d } fd d d D} |j| | fddi| } j | _ | D]\} }t | j | |q| S)a Return a new Time instance which is consistent with the input Time objects ``cols`` and has ``length`` rows. This is intended for creating an empty Time instance whose elements can be set in-place for table operations like join or vstack. It checks that the input locations and attributes are consistent. This is used when a Time object is used as a mixin column in an astropy Table. Parameters ---------- cols : list List of input columns (Time objects) length : int Length of the output column object metadata_conflicts : str ('warn'|'error'|'silent') How to handle metadata conflicts name : str Output column name Returns ------- col : Time (or subclass) Empty instance of this class consistent with ``cols`` metaZ descriptiondtyperrNz)input columns have inconsistent locationsshape@,BAf8rtcsi|]}|t|qSr,)rc)r.attrcol0r,r1 sz%TimeInfo.new_like..)r0rJrGrHrIrFr]) merge_cols_attributesrk_make_value_equivalentslicerRrdZfullzerosrlrFitemssetattrinfo)rTcolslengthmetadata_conflictsnameattrscolruZjd2000rPrQZtm_attrsrVryrMr,rzr1new_likes,    zTimeInfo.new_like)F)rN)r?r@rA__doc__r Z attr_namesZ_supports_indexingrSZ_represent_as_dict_primary_datardmamaskedZmask_valpropertyrWrYr`rb staticmethodr Z_statsZinfo_summary_statsrnrqr __classcell__r,r,r[r1rqs(    rc@s"eZdZdZddZdddZdS) TimeDeltaInforFr0cCs ||Sr+)rn)rTrmr,r,r1rqsz"TimeDeltaInfo._construct_from_dictrNc Cs||||d}|d|d}|f|d}tj|dd}tj|dd} |j|| d|jd} |j| _|D]\} } t| j | | qr| S) a Return a new TimeDelta instance which is consistent with the input Time objects ``cols`` and has ``length`` rows. This is intended for creating an empty Time instance whose elements can be set in-place for table operations like join or vstack. It checks that the input locations and attributes are consistent. This is used when a Time object is used as a mixin column in an astropy Table. Parameters ---------- cols : list List of input columns (Time objects) length : int Length of the output column object metadata_conflicts : str ('warn'|'error'|'silent') How to handle metadata conflicts name : str Output column name Returns ------- col : Time (or subclass) Empty instance of this class consistent with ``cols`` rrrtrrurwrxr]r) r}rkrdrrlr0rFrrr) rTrrrrrr{rurPrQrVryrMr,r,r1rs  zTimeDeltaInfo.new_like)rN)r?r@rArSrqrr,r,r,r1rsrcs^eZdZdZdZdZddZdpddZdd Ze d d Z e j d d Z e d dZ e j ddZ ddZ ddZddZe ddZddZe ddZej ddZe ddZej ddZe d d!Zej d"d!Ze d#d$Zej d%d$Zd&d'Ze d(d)Ze d*d+Zdqd-d.Ze d/d0Ze d1d2Ze d3d4Zdrd6d7Zd8d9Zdsd:d;Zdtd.Z astropy_timez5No time format was given, and the input is not uniquez0Format {!r} is not one of the allowed formats {}rz,Input values did not match the format class :: zTInput values did not match any of the formats where the format keyword is optional: r)rtkindrhFORMATSrappendrrrrrRrFrr TypeErrorlenoslinesepr\r?) rTrirjrFr0rGrHrIformatsZproblemsrrerrr,r,r1rsR         zTimeBase._get_time_fmtcCs|jjjj|jjjj@Sr+rrPflags writeablerQrar,r,r1rszTimeBase.writeablecCs||jjj_||jjj_dSr+rrTrMr,r,r1rs cCs|jS)ao Get or set time format. The format defines the way times are represented when accessed via the ``.value`` attribute. By default it is the same as the format used for initializing the `Time` instance, but it can be set to any other value that could be used for initialization. These can be listed with:: >>> list(Time.FORMATS) ['jd', 'mjd', 'decimalyear', 'unix', 'unix_tai', 'cxcsec', 'gps', 'plot_date', 'stardate', 'datetime', 'ymdhms', 'iso', 'isot', 'yday', 'datetime64', 'fits', 'byear', 'jyear', 'byear_str', 'jyear_str'] )rrar,r,r1rFszTimeBase.formatc Csh||jvrtdt|j|j|}||jj|jj|jj|j||j ||j dd|_||_ dS)zSet time formatformat must be one of T)rHrIfrom_jdN) rrRlistrrPrQ_scalerG_get_allowed_subfmtrHrIr)rTrFZ format_clsr,r,r1rFs      cCs d|jj|j|jt||jS)Nz,<{} object: scale='{}' format='{}' value={}>)rFr\r?r0rcrar,r,r1__repr__s zTimeBase.__repr__cCstt||jSr+)rrcrFrar,r,r1__str__szTimeBase.__str__cCszTt|dd}|dur>|jtj|jtj|jtjf}t|j|j |j |fWSt y|j dkrrd}n|j r~d}nt d|jjd|Yn0dS)NrJrz(must be scalar)z(value is masked)zunhashable type: 'z' )rcxto_valueumyzhashrPrQr0rndimrr\r?)rTZlocreasonr,r,r1__hash__s (  zTimeBase.__hash__cCs|jjS)z Time scale)rr0rar,r,r1r0szTimeBase.scalec Cs||jkrdS||jvr.td|t|j|dks@|jdkrFt|j|f}tt|}t|d}|dd||dd}||krtt |}|j j |j j }}t |dd|ddD]\}} ||g} || f| |ffD]H} dj| } zt|| } WntyYq0| | ||q.qtt|| }|| \}}qt||\}}|jrltj||j<|j|j||||j|j|jdd |_ dS) This is the key routine that actually does time scale conversions. This is not public and not connected to the read-only scale property. Nrr)r,rz_get_delta_{}_{}Tr)r0rrRrFr_check_leapsectuple MULTI_HOPSgetreversedrrP jd2_filledziprcAttributeErrorrerfarrrdrrrrGrHrI)rTr0ZxformZ xform_sortZmultiZxformsrPrQZsys1Zsys2argsZsys12Z dt_methodZget_dtZ conv_funcr,r,r1 _set_scalesD       "  zTimeBase._set_scalecCs|jjS)z| Decimal precision when outputting seconds as floating point (int value between 0 and 9 inclusive). )rrGrar,r,r1rGVszTimeBase.precisioncCs2|`t|tr|dks|dkr&td||j_dS)Nr z2precision attribute must be an int between 0 and 9)cacherintrRrrGrTrir,r,r1rG^scCs|jjS)zd Unix wildcard pattern to select subformats for parsing string input times. )rrHrar,r,r1rHfszTimeBase.in_subfmtcCs||j_|`dSr+)rrHrrr,r,r1rHnscCs|jjS)zR Unix wildcard pattern to select subformats for outputting times. )rrIrar,r,r1rIsszTimeBase.out_subfmtcCs||j_|`dSr+)rrIrrr,r,r1rIzscCs |jjjS)a_The shape of the time instances. Like `~numpy.ndarray.shape`, can be set to a new shape by assigning a tuple. Note that if different instances share some but not all underlying data, setting the shape of one instance can make the other instance unusable. Hence, it is strongly recommended to get new, reshaped instances with the ``reshape`` method. Raises ------ ValueError If the new shape has the wrong total number of elements. AttributeError If the shape of the ``jd1``, ``jd2``, ``location``, ``delta_ut1_utc``, or ``delta_tdb_tt`` attributes cannot be changed without the arrays being copied. For these cases, use the `Time.reshape` method (which copies any arrays that cannot be reshaped in-place). )rrPrurar,r,r1ruszTimeBase.shapec Cs|`g}|j}|jdf|jdf|df|df|dffD]`\}}t||d}|dur4|jdkr4z ||_Wn$ty|D] }||_qvYq40||q4dS)NrPrQrKrLrJr)rrurrcsize Exceptionr)rTruZreshapedZoldshapeobjryrirjr,r,r1rus$    cCs|jjjr6t|tjr|Std|jjd|dnPt|tjr|jstj|s|j j dkrh|dS|j j rx|dS| Sn|SdS)NzJD is an array (z) but value is not ()rr,) rrPrurrdZndarrayrrZ is_maskedrtrfieldsitemrr,r,r1_shaped_like_inputs&       zTimeBase._shaped_like_inputcCs|j|jj}||S)zU First of the two doubles that internally store time value(s) in JD. )rmask_if_neededrPr)rTrPr,r,r1rPsz TimeBase.jd1cCs|j|jj}||S)zV Second of the two doubles that internally store time value(s) in JD. )rrrQr)rTrQr,r,r1rQsz TimeBase.jd2rc Cs||jvrtdt|j|jd}|dur4|n||f}||vr||jkrT|}n |j|d}i}|dur~||jkr~||d<z|jjfd|i|}WnRt y}z:|j |dt |vrtd|d dnWYd}~n d}~00| |}|||<||S) aJGet time values expressed in specified output format. This method allows representing the ``Time`` object in the desired output ``format`` and optional sub-format ``subfmt``. Available built-in formats include ``jd``, ``mjd``, ``iso``, and so forth. Each format can have its own sub-formats For built-in numerical formats like ``jd`` or ``unix``, ``subfmt`` can be one of 'float', 'long', 'decimal', 'str', or 'bytes'. Here, 'long' uses ``numpy.longdouble`` for somewhat enhanced precision (with the enhancement depending on platform), and 'decimal' :class:`decimal.Decimal` for full precision. For 'str' and 'bytes', the number of digits is also chosen such that time values are represented accurately. For built-in date-like string formats, one of 'date_hms', 'date_hm', or 'date' (or 'longdate_hms', etc., for 5-digit years in `~astropy.time.TimeFITS`). For sub-formats including seconds, the number of digits used for the fractional seconds is as set by `~astropy.time.Time.precision`. Parameters ---------- format : str The format in which one wants the time values. Default: the current format. subfmt : str or None, optional Value or wildcard pattern to select the sub-format in which the values should be given. The default of '*' picks the first available for a given format, i.e., 'float' or 'date_hms'. If `None`, use the instance's ``out_subfmt``. rrFNr^rIr_z(unexpected keyword argument 'out_subfmt'zto_value() method for format z- does not support passing a 'subfmt' argument) rrRrrrF replicaterIrrrZ_select_subfmtsrr) rTrFsubfmtrkeytmkwargsrMexcr,r,r1rs2$        zTimeBase.to_valuecCs||jdS)zTime value(s) in current formatN)rrFrar,r,r1rM.szTimeBase.valuecCs|jjSr+)rrrar,r,r1r3szTimeBase.maskedcCs|jjSr+)rrrar,r,r1r7sz TimeBase.maskrcCs`zt|}Wnty(tdYn0|dkr:td|jsRtd|jjt|t |krvt d|t ||dkrt ||}t ||jst |}|jrt |nd}|jjj|gt |||jjd}|jjd||jjd|<|jjd||jjd|<|||||<|jj|d|jj||d<|jj|d|jj||d<|S) a Insert values before the given indices in the column and return a new `~astropy.time.Time` or `~astropy.time.TimeDelta` object. The values to be inserted must conform to the rules for in-place setting of ``Time`` objects (see ``Get and set values`` in the ``Time`` documentation). The API signature matches the ``np.insert`` API, but is more limited. The specification of insert index ``obj`` must be a single integer, and the ``axis`` must be ``0`` for simple row insertion before the index. Parameters ---------- obj : int Integer index before which ``values`` is inserted. values : array-like Value(s) to insert. If the type of ``values`` is different from that of quantity, ``values`` is converted to the matching type. axis : int, optional Axis along which to insert ``values``. Default is 0, which is the only allowed value and will insert a row. Returns ------- out : `~astropy.time.Time` subclass New time object with inserted value(s) zobj arg must be an integerrzaxis must be 0z#cannot insert into scalar {} objectz1index {} is out of bounds for axis 0 with size {}r)rN)operatorindexrrRrurFr\r?absr IndexErrorrrdasarrayrrrrrPrQ)rTrvaluesaxisZidx0Zn_valuesrVr,r,r1insert;s4!    "  zTimeBase.insertcCs|js2|jr td|jjntd|jj|`dD]}t||r:t||q:|t j j usj|t j ur|t j |j j|<dS|||}|jdurt||j}|j j|j j|<|j j|j j|<dS)NzK{} object is read-only. Make a copy() or set "writeable" attribute to True.zscalar {} object is read-only.)rLrK)rrurRrFr\r?rrdelattrrdrrrrrQr~r0rcrP)rTrrMryr,r,r1 __setitem__s(     zTimeBase.__setitem__c Cs|durdttjtj}t|tjtfsBt d|j j dz||}t |}||k}Wn<t y}z$t d|j j d|WYd}~n d}~00|S)aXReturns a boolean or boolean array where two Time objects are element-wise equal within a time tolerance. This evaluates the expression below:: abs(self - other) <= atol Parameters ---------- other : `~astropy.time.Time` Time object for comparison. atol : `~astropy.units.Quantity` or `~astropy.time.TimeDelta` Absolute tolerance for equality with units of time (e.g. ``u.s`` or ``u.day``). Default is two bits in the 128-bit JD time representation, equivalent to about 40 picosecs. Nr>>'atol' argument must be a Quantity or TimeDelta instance, got  insteadze'other' argument must support subtraction with Time and return a value that supports comparison with r)rdfinfofloatepsrdayrQuantityrrr\r?rr)rTotheratoldtrVrr,r,r1iscloses"  zTimeBase.isclosecCs|jd|dS)a Return a fully independent copy the Time object, optionally changing the format. If ``format`` is supplied then the time format of the returned Time object will be set accordingly, otherwise it will be unchanged from the original. In this method a full copy of the internal time arrays will be made. The internal time arrays are normally not changeable by the user so in most cases the ``replicate()`` method should be used. Parameters ---------- format : str, optional Time format of the copy. Returns ------- tm : Time object Copy of this object rr^_apply)rTrFr,r,r1rsz TimeBase.copyFcCs|j|r dnd||dS)a  Return a replica of the Time object, optionally changing the format. If ``format`` is supplied then the time format of the returned Time object will be set accordingly, otherwise it will be unchanged from the original. If ``copy`` is set to `True` then a full copy of the internal time arrays will be made. By default the replica will use a reference to the original arrays when possible to save memory. The internal time arrays are normally not changeable by the user so in most cases it should not be necessary to set ``copy`` to `True`. The convenience method copy() is available in which ``copy`` is `True` by default. Parameters ---------- format : str, optional Time format of the replica. copy : bool, optional Return a true copy instead of using references where possible. Returns ------- tm : Time object Replica of this object rrrFrr)rTrFrrr,r,r1rszTimeBase.replicaterc s|dur|jn|}tr,fdd}n&dkr:d}ntjgRi}|jj|jj}} |rx||}|| } t|p|j } t || |j ddddd| _d D]p} zt || } Wnt yYqYn0|r t | d d r|| } nd ksd kr t| } t| | | qd|jvr.|j| _|| jvrNtdt| j| j|} | | jj| jj| jj|j| |j| |jdd| _|| _|j| _| S)a-Create a new time object, possibly applying a method to the arrays. Parameters ---------- method : str or callable If string, can be 'replicate' or the name of a relevant `~numpy.ndarray` method. In the former case, a new time instance with unchanged internal data is created, while in the latter the method is applied to the internal ``jd1`` and ``jd2`` arrays, as well as to possible ``location``, ``_delta_ut1_utc``, and ``_delta_tdb_tt`` arrays. If a callable, it is directly applied to the above arrays. Examples: 'copy', '__getitem__', 'reshape', `~numpy.broadcast_to`. args : tuple Any positional arguments for ``method``. kwargs : dict Any keyword arguments for ``method``. If the ``format`` keyword argument is present, this will be used as the Time format of the replica. Examples -------- Some ways this is used internally:: copy : ``_apply('copy')`` replicate : ``_apply('replicate')`` reshape : ``_apply('reshape', new_shape)`` index or slice : ``_apply('__getitem__', item)`` broadcast : ``_apply(np.broadcast, shape=new_shape)`` Ncs|gRiSr+r,)arrayrrrUr,r1$rgz!TimeBase._apply..rrrT)rGrHrIr)rKrLrJrur,rZflattenrr)rFcallabler methodcallerrrPrQrX__new__r\rr0rcrrr__dict__rrrRrrrGrrHrIrr)rTrUrFrrrZ new_formatZ apply_methodrPrQrryriZ NewFormatr[rr1rsR            zTimeBase._applycCs|S)z Overrides the default behavior of the `copy.copy` function in the python stdlib to behave like `Time.copy`. Does *not* make a copy of the JD arrays - only copies by reference. )rrar,r,r1__copy__fszTimeBase.__copy__cCs|S)z Overrides the default behavior of the `copy.deepcopy` function in the python stdlib to behave like `Time.copy`. Does make a copy of the JD arrays. r)rTmemor,r,r1 __deepcopy__nszTimeBase.__deepcopy__csndurt|jS|jdkr,rHj|jkrHtfddt|jD}t|S)aTurn argmin, argmax output into an advanced index. Argmin, argmax output contains indices along a given axis in an array shaped like the other dimensions. To use this to get values at the correct location, a list is constructed in which the other axes are indexed sequentially. For ``keepdims`` is ``True``, the net result is the same as constructing an index grid with ``np.ogrid`` and then replacing the ``axis`` item with ``indices`` with its shaped expanded at ``axis``. For ``keepdims`` is ``False``, the result is the same but with the ``axis`` dimension removed from all list entries. For ``axis`` is ``None``, this calls :func:`~numpy.unravel_index`. Parameters ---------- indices : array Output of argmin or argmax. axis : int or None axis along which argmin or argmax was used. keepdims : bool Whether to construct indices that keep or remove the axis along which argmin or argmax was used. Default: ``False``. Returns ------- advanced_index : list of arrays Suitable for use as an advanced index. Nrc sjg|]b\}}|krnLt|ds0|kr4|n|d|fd|sV|krZdndqS))rrr>)rdZarangereshape)r.isrindiceskeepdimsrr,r1rfs z,TimeBase._advanced_index..)rdZ unravel_indexrurZ expand_dims enumerater)rTrrrrr,rr1_advanced_indexvs  zTimeBase._advanced_indexcCs:|j|j}}tj|||dd}|||}|||S)a)Return indices of the minimum values along the given axis. This is similar to :meth:`~numpy.ndarray.argmin`, but adapted to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is used. See :func:`~numpy.argmin` for detailed documentation. Tr)rPrQrdminargminrTrrVrPrQapproxrr,r,r1rs zTimeBase.argmincCs:|j|j}}tj|||dd}|||}|||S)a)Return indices of the maximum values along the given axis. This is similar to :meth:`~numpy.ndarray.argmax`, but adapted to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is used. See :func:`~numpy.argmax` for detailed documentation. Tr)rPrQrdmaxargmaxrr,r,r1rs zTimeBase.argmaxrcCsV|j|j}}||}|||}|dur@t||fStj||f|dSdS)awReturns the indices that would sort the time array. This is similar to :meth:`~numpy.ndarray.argsort`, but adapted to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is used, and that corresponding attributes are copied. Internally, it uses :func:`~numpy.lexsort`, and hence no sort method can be chosen. N)keysr)rPrQrdZlexsortZravel)rTrrPrQrZ remainderr,r,r1argsorts  zTimeBase.argsortcCs(|durtd||||||S)aMinimum along a given axis. This is similar to :meth:`~numpy.ndarray.min`, but adapted to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is used, and that corresponding attributes are copied. Note that the ``out`` argument is present only for compatibility with ``np.min``; since `Time` instances are immutable, it is not possible to have an actual ``out`` to store the result in. NUSince `Time` instances are immutable, ``out`` cannot be set to anything but ``None``.)rRrrrTrrVrr,r,r1rs z TimeBase.mincCs(|durtd||||||S)aMaximum along a given axis. This is similar to :meth:`~numpy.ndarray.max`, but adapted to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is used, and that corresponding attributes are copied. Note that the ``out`` argument is present only for compatibility with ``np.max``; since `Time` instances are immutable, it is not possible to have an actual ``out`` to store the result in. Nr")rRrrr#r,r,r1rs z TimeBase.maxcCs,|durtd|j||d|j||dS)aPeak to peak (maximum - minimum) along a given axis. This is similar to :meth:`~numpy.ndarray.ptp`, but adapted to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is used. Note that the ``out`` argument is present only for compatibility with `~numpy.ptp`; since `Time` instances are immutable, it is not possible to have an actual ``out`` to store the result in. Nr"r)rRrrr#r,r,r1ptps   z TimeBase.ptpcCs||j|||ddS)a"Return a copy sorted along the specified axis. This is similar to :meth:`~numpy.ndarray.sort`, but internally uses indexing with :func:`~numpy.lexsort` to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is kept, and that corresponding attributes are properly sorted and copied as well. Parameters ---------- axis : int or None Axis to be sorted. If ``None``, the flattened array is sorted. By default, sort over the last axis. Tr)rr!)rTrr,r,r1sortsz TimeBase.sortcCs|jjS)zA Return the cache associated with this instance. rrrar,r,r1r"szTimeBase.cachecCs |j`dSr+r&rar,r,r1r)scCs||jvrd|jdurd|jd}||vr\||jkr6|}n|}|||jrTd|_|||<||S||jvr||j|ddS|t vr|jdurt dqt d |j j |j|n ||SdS)zU Get dynamic attributes to output format or do timescale conversion. Nr0F)rzCCannot convert TimeDelta with undefined scale to any defined scale.z/Cannot convert {} with scale '{}' to scale '{}')rr0rrrrurrrrr!rFr\r?__getattribute__)rTryrrr,r,r1 __getattr__-s*      zTimeBase.__getattr__cCst|j}||j|Sr+)setrupdater)rTresultr,r,r1__dir__Ps  zTimeBase.__dir__cCsXt|dd}|jdkrT|j|jkrTztj||jdd}WntyRtdYn0|S)z Ensure that `val` is matched to length of self. If val has length 1 then broadcast, otherwise cast to double and make sure shape matches. TrrsubokzAttribute shape must match or be broadcastable to that of Time object. Typically, give either a single value or one for each time.)rrrurdrrrRrr,r,r1 _match_shapeVs  zTimeBase._match_shapecCs|j|jur8z|j||jd}Wnty6tYS0|jdurN|j|jvsd|jdur~|j|jvr~td|jj|j|j|jdur|jdurt||j}||j |j |j |j dS)zvIf other is of same class as self, compare difference in self.scale. Otherwise, return NotImplemented r0Nz5Cannot compare {} instances with scales '{}' and '{}') r\r0rNotImplementedrrrFr?rcrPrQ)rTropr,r,r1_time_comparisonhs"     zTimeBase._time_comparisoncCs||tjSr+)r4rltrTrr,r,r1__lt__szTimeBase.__lt__cCs||tjSr+)r4rler6r,r,r1__le__szTimeBase.__le__cCs||tjS)z If other is an incompatible object for comparison, return `False`. Otherwise, return `True` if the time difference between self and other is zero. )r4reqr6r,r,r1__eq__szTimeBase.__eq__cCs||tjS)z If other is an incompatible object for comparison, return `True`. Otherwise, return `False` if the time difference between self and other is zero. )r4rner6r,r,r1__ne__szTimeBase.__ne__cCs||tjSr+)r4rgtr6r,r,r1__gt__szTimeBase.__gt__cCs||tjSr+)r4rger6r,r,r1__ge__szTimeBase.__ge__)NNN)r)r)N)N)NFN)NF)NN)NN)r)NNF)NNF)NNF)r);r?r@rArZ__array_priority__Z_astropy_column_attrsrrrrrsetterrFrrrr0rrGrHrIrurrPrQrrMrrrrrrrrr rrrrr!rrr$r%rdeleterr(r r,r/r4r7r9r;r=r?rArr,r,r[r1rLs 9;     ;           P    J '  d 2         # rcs8eZdZdZeZeZd0fdd Zd1ddZ dd Z e d d Z e Ze d d ZddZd2ddZd3ddZd4ddZeejerejdeeddeede_d5ddZddZd6ddZd7d d!Zd"d#ZeeeZ d8d$d%Z!d&d'Z"ee!e"Z#d(d)Z$d*d+Z%d,d-Z&d9d.d/Z'e(j)je'_Z*S):ra Represent and manipulate times and dates for astronomy. A `Time` object is initialized with one or more times in the ``val`` argument. The input times in ``val`` must conform to the specified ``format`` and must correspond to the specified time ``scale``. The optional ``val2`` time input should be supplied only for numeric input formats (e.g. JD) where very high precision (better than 64-bit precision) is required. The allowed values for ``format`` can be listed with:: >>> list(Time.FORMATS) ['jd', 'mjd', 'decimalyear', 'unix', 'unix_tai', 'cxcsec', 'gps', 'plot_date', 'stardate', 'datetime', 'ymdhms', 'iso', 'isot', 'yday', 'datetime64', 'fits', 'byear', 'jyear', 'byear_str', 'jyear_str'] See also: http://docs.astropy.org/en/stable/time/ Parameters ---------- val : sequence, ndarray, number, str, bytes, or `~astropy.time.Time` object Value(s) to initialize the time or times. Bytes are decoded as ascii. val2 : sequence, ndarray, or number; optional Value(s) to initialize the time or times. Only used for numerical input, to help preserve precision. format : str, optional Format of input value(s) scale : str, optional Time scale of input value(s), must be one of the following: ('tai', 'tcb', 'tcg', 'tdb', 'tt', 'ut1', 'utc') precision : int, optional Digits of precision in string representation of time in_subfmt : str, optional Unix glob to select subformats for parsing input times out_subfmt : str, optional Unix glob to select subformat for outputting times location : `~astropy.coordinates.EarthLocation` or tuple, optional If given as an tuple, it should be able to initialize an an EarthLocation instance, i.e., either contain 3 items with units of length for geocentric coordinates, or contain a longitude, latitude, and an optional height for geodetic coordinates. Can be a single location, or one for each input time. If not given, assumed to be the center of the Earth for time scale transformations to and from the solar-system barycenter. copy : bool, optional Make a copy of the input values NFc s,t|tr|j|| |d} n t|} | SN)rFrr)rrrrXr  rrirjrFr0rGrHrIrJrrTr[r,r1r s  z Time.__new__c Cs`|durJddlm} t|| r&||_n | ||_|jjdkrZ|j|_nt|dsZd|_t|tr|durt||j_ |dur||j_ |dur||j_ t |j |_|dur||n$|||||| |||t |j |_|jdur\|jjdkr\|jj|jkr\ztj|j|jdd|_Wn>tyZ} z$td|jj|j| WYd} ~ n d} ~ 00dS)Nr) EarthLocationrrJTr-zThe location with shape {} cannot be broadcast against time with shape {}. Typically, either give a single location or one for each time.)astropy.coordinatesrFrrJrZsqueezerrrrGrHrI TIME_TYPESr0rrrrurdrrrRrF) rTrirjrFr0rGrHrIrJrrFrr,r,r1rYsH             z Time.__init__c Cs&|jdur,|jjr,tj|j|jdd|}n|j}t|tr|durT|jdurTd}n:|durf|jdusx|dur~|jdur~d}nt||jk}|std||jn|z|j ||j |d}Wndt y z|j ||j |j|d}Wn4t y}ztd|WYd}~n d}~00Yn0|S) z3Coerce setitem value into an equivalent Time objectNTr-FzTcannot set to Time with different location: expected location={} and got location={})r0rJ)r0rFrJz4cannot convert value to a compatible Time object: {}) rJrurdrrrallrRrFr\r0r)rTrrMZ self_locationmatchrr,r,r1r~ s:  "zTime._make_value_equivalentcCst}||dddS)aF Creates a new object corresponding to the instant in time this method is called. .. note:: "Now" is determined using the `~datetime.datetime.utcnow` function, so its accuracy and precision is determined by that function. Generally that means it is set by the accuracy of your system clock. Returns ------- nowtime : :class:`~astropy.time.Time` A new `Time` object (or a subclass of `Time` if this is called from such a subclass) at the current time. rr))rirFr0)rZutcnow)rZdtnowr,r,r1now1szTime.nowcKst|}|jjdvr,d|jj}t||jjdkr>> Time.strptime('2012-Jun-30 23:59:60', '%Y-%b-%d %H:%M:%S')