a GGbF@sddlmZddlmZmZddlZddlmZmZmZm Z m Z m Z m Z m Z mZmZddlZddlZddlmZmZddlmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"ddl#m$Z$m%Z%ddl&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2dd l3m4Z5dd l6m7Z7m8Z8m9Z9dd l:m;Z;mm?Z?ddl@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPddlQmRZRddlSmTZTmUZUddlVmWZWmXZXddlYmZZZm[Z[m\Z\m]Z]ddl^m_Z_ddl`maZambZbddlcmdmeZfddlgmhZimjZjddlkmlZlmmZmddlnmoZoddlpmqZqmrZrddlsmtZterPddlumvZvmwZwe e*efZxe dddZyGdddezZ{Gd dde_eaZ|Gd!d"d"e|Z}d#Z~d$Zd%Zd&Ze d'd(dZGd)d(d(e|Zd*d+Zd,d-Zd.d/ZdS)0) annotations)datetime timedeltaN) TYPE_CHECKINGAnyCallableLiteralSequenceTypeVarUnioncastfinaloverload)algoslib) BaseOffsetIncompatibleFrequencyNaTNaTTypePeriod ResolutionTick Timestampdelta_to_nanosecondsiNaTints_to_pydatetime to_offset)RoundTo round_nsint64)integer_op_not_supported) ArrayLikeDatetimeLikeScalarDtypeDtypeObjNpDtypePositionalIndexer2DPositionalIndexerTuple ScalarIndexerSequenceIndexernpt)function)AbstractMethodErrorNullFrequencyErrorPerformanceWarning)Appender Substitutioncache_readonly)find_stack_level)is_all_stringsis_categorical_dtypeis_datetime64_any_dtypeis_datetime64_dtypeis_datetime64tz_dtypeis_datetime_or_timedelta_dtypeis_dtype_equalis_float_dtypeis_integer_dtype is_list_likeis_object_dtypeis_period_dtypeis_string_dtypeis_timedelta64_dtypeis_unsigned_integer_dtype pandas_dtype)ExtensionDtype)is_valid_na_for_dtypeisna)nanopsops)checked_add_with_arrisinmodeunique1d)OpsMixin)NDArrayBackedExtensionArray ravel_compat)array extract_array)check_array_indexercheck_setitem_lengths)unpack_zerodim_and_defer)invalid_comparisonmake_invalid_op) frequencies) DatetimeArrayTimedeltaArrayDatetimeLikeArrayTDatetimeLikeArrayMixin)boundc@seZdZdZdS)InvalidComparisonzm Raised by _validate_comparison_value to indicate to caller it should return invalid_comparison. N)__name__ __module__ __qualname____doc__r`r`>lib/python3.9/site-packages/pandas/core/arrays/datetimelike.pyr[sr[cszeZdZUdZded<ded<ded<ded <ed d d d ZdddddZedd ddZ dddddZ ddd ddddZ ddd d d!d"d#Z edd d$d%Z d&d'Zdd d(d)Zd*d+Zed,d d-d.Zd/dd0d1d2Zdd d3d4d5Zdd6dd7d8d9Zed:dd;dd?d>d@dAd=Zd>dBdCdDfdEd= ZdFd dGdHZdIdJd dKfdLdM ZdNdOZdd dQfdRdS Zed>d>dTdUdVZedWdXd7dYdVZedZd[d7d\dVZeddd^d7d_dVZddd^d7fd`dV Zeddbdcddd>defdfdg Zdd>d>dTfdidj ZdkdlZedbd>d>dmdndoZ dpdqZ!drdsZ"ddPdPdtd d d dtdudvZ#dd ddwdxdyZ$dd dzd{d|Z%d}d~Z&ddZ'dd ddddZ(e)ddZ*dd ddZ+dd ddZ,edd ddZ-ed d ddZ.e/dfdddddZ0eddZ1e1j2ddZ1edd ddZ3edd ddZ4edd ddZ5edd ddZ6eddZ7edbd>dddZ8ed d ddZ9ed d ddZ:ed d ddZ;ddZe=dZ?e=dZ@e=dZAe=dZBe=dZCe=dZDe=dZEe=dZFe=dZGe=dZHe=dZIddZJeJZKddZLeLZMddZNdddd„ZOddĄZPddƄZQddȄZReSddʄZTeSdd̄ZUdd΄ZVddddЄZWdd>ddd>dќddӄZXeYdԃddքZZdd؄Z[eYdكddۄZ\dd݄Z]dd߄Z^ddZ_ddPddd dddZ`ddPddd dddZadPdadd ddddZbddPddd dddZcdd dddZdZeS)rYz Shared Base/Mixin class for DatetimeArray, TimedeltaArray, PeriodArray Assumes that __new__/__init__ defines: _data _freq and that the inheriting class has methods: _generate_range ztuple[str, ...]_infer_matcheszCallable[[DtypeObj], bool]_is_recognized_dtypeztuple[type, ...]_recognized_scalarsz np.ndarray_ndarrayboolreturncCsdS)NTr`selfr`r`ra _can_hold_nasz#DatetimeLikeArrayMixin._can_hold_naNFz Dtype | NonedtypecCs t|dSNr+)rjdatarmfreqcopyr`r`ra__init__szDatetimeLikeArrayMixin.__init__ztype[DatetimeLikeScalar]cCs t|dS)z The scalar associated with this datelike * PeriodArray : Period * DatetimeArray : Timestamp * TimedeltaArray : Timedelta Nrorir`r`ra _scalar_types z#DatetimeLikeArrayMixin._scalar_typestr DTScalarOrNaT)valuerhcCs t|dS)ay Construct a scalar type from a string. Parameters ---------- value : str Returns ------- Period, Timestamp, or Timedelta, or NaT Whatever the type of ``self._scalar_type`` is. Notes ----- This should call ``self._check_compatible_with`` before unboxing the result. Nrorjrwr`r`ra_scalar_from_stringsz*DatetimeLikeArrayMixin._scalar_from_stringz)np.int64 | np.datetime64 | np.timedelta64)rwsetitemrhcCs t|dS)a Unbox the integer value of a scalar `value`. Parameters ---------- value : Period, Timestamp, Timedelta, or NaT Depending on subclass. setitem : bool, default False Whether to check compatibility with setitem strictness. Returns ------- int Examples -------- >>> self._unbox_scalar(Timedelta("10s")) # doctest: +SKIP 10000000000 Nro)rjrwrzr`r`ra _unbox_scalarsz$DatetimeLikeArrayMixin._unbox_scalarNone)otherrzrhcCs t|dS)a Verify that `self` and `other` are compatible. * DatetimeArray verifies that the timezones (if any) match * PeriodArray verifies that the freq matches * Timedelta has no verification In each case, NaT is considered compatible. Parameters ---------- other setitem : bool, default False For __setitem__ we may have stricter compatibility restrictions than for comparisons. Raises ------ Exception Nrorjr}rzr`r`ra_check_compatible_withsz-DatetimeLikeArrayMixin._check_compatible_withcCs|jSrn)rerir`r`ra_dataszDatetimeLikeArrayMixin._datacCs t|dS)zI box function to get object from internal representation Nro)rjxr`r`ra _box_funcsz DatetimeLikeArrayMixin._box_funccCstj||jddS)z1 apply box func to passed values F)convert)rZ map_inferr)rjvaluesr`r`ra _box_values sz"DatetimeLikeArrayMixin._box_valuescs<jdkr$fddttDSfddjDSdS)Nc3s|]}|VqdSrnr`).0nrir`ra z2DatetimeLikeArrayMixin.__iter__..c3s|]}|VqdSrn)r)rvrir`rarr)ndimrangelenasi8rir`rira__iter__s zDatetimeLikeArrayMixin.__iter__znpt.NDArray[np.int64]cCs |jdS)z Integer representation of the values. Returns ------- ndarray An ndarray with int64 dtype. i8)reviewrir`r`rars zDatetimeLikeArrayMixin.asi8r)na_rep date_formatcCs t|dS)z| Helper method for astype when converting to strings. Returns ------- ndarray[str] Nro)rjrrr`r`ra_format_native_types(sz+DatetimeLikeArrayMixin._format_native_types)boxedcCsdjS)Nz'{}')format)rjrr`r`ra _formatter2sz!DatetimeLikeArrayMixin._formatterzNpDtype | None)rmrhcCs t|rtjt|tdS|jSNrl)r<nprNlistobjectrerjrmr`r`ra __array__9sz DatetimeLikeArrayMixin.__array__r')itemrhcCsdSrnr`rjrr`r`ra __getitem__?sz"DatetimeLikeArrayMixin.__getitem__rXz(SequenceIndexer | PositionalIndexerTuple)rjrrhcCsdSrnr`rr`r`rarCsr%z"DatetimeLikeArrayT | DTScalarOrNaT)rjkeyrhcs:tdt|}t|r |Stt|}|||_|S)z This getitem defers to the underlying array, which by-definition can only handle list-likes, slices, and integer scalars z(Union[DatetimeLikeArrayT, DTScalarOrNaT])r superrr is_scalarrX_get_getitem_freq_freq)rjrresult __class__r`rarJs     zBaseOffset | NonecCst|j}|r|j}n|jdkr&d}nt||}d}t|trh|jdur`|jdur`|j|j}q|j}n@|turx|j}n0t |rt | tj}t|tr||S|S)z\ Find the `freq` attribute to assign to the result of a __getitem__ lookup. rN)r=rmrqrrP isinstanceslicestepEllipsiscomZis_bool_indexerrZmaybe_booleans_to_slicerrZuint8r)rjrZ is_periodrqZnew_keyr`r`rar_s$       z(DatetimeLikeArrayMixin._get_getitem_freqz,int | Sequence[int] | Sequence[bool] | slicezNaTType | Any | Sequence[Any])rrwrhcs.t|||}|rdSt|||dSrn)rQr __setitem___maybe_clear_freq)rjrrwZno_oprr`rar}s z"DatetimeLikeArrayMixin.__setitem__cCsdSrnr`rir`r`rarsz(DatetimeLikeArrayMixin._maybe_clear_freqTrrcst|}t|r^|jjdkrF|j}t||j|jdd}| |j S| |j |j St |t rxtj||dSt|r|St|r|j}t|r|d}|r|}|St|rt|j|rt|rdt|jd|}t|ntj||dSdS) NMZ timestamp)tzrqZboxrZuint64z Cannot cast z to dtype rl)rAr<rmkindrravelrrrqreshapeshaperrrBrastyper>rr:r@rrrr7r8r9typer\ TypeErrorrasarray)rjrmrrZi8dataZ convertedrmsgrr`rars@       zDatetimeLikeArrayMixin.astype)rjrhcCsdSrnr`rir`r`rarszDatetimeLikeArrayMixin.viewzLiteral['M8[ns]']rVcCsdSrnr`rr`r`rarszLiteral['m8[ns]']rWcCsdSrnr`rr`r`rars.r cCsdSrnr`rr`r`rarscs t|Srn)rrrrr`rarsrztype[DatetimeLikeArrayT]zSequence[DatetimeLikeArrayT]int)cls to_concataxisrhcst||}|dj}d}t|r0j}nl|dkrdd|D}jdurtfdd|Drt|dd|dd}tfdd|Drj}||_|S) NrcSsg|]}t|r|qSr`)rrrr`r`ra rz.c3s|]}|jjkVqdSrnrqrobjr`rarrz;DatetimeLikeArrayMixin._concat_same_type..rc3s,|]$}|ddj|ddkVqdS)rrrNr)rZpairrr`rarr)r_concat_same_typermr=rqallzipr)rrrnew_objrmnew_freqZpairsrrrars z(DatetimeLikeArrayMixin._concat_same_typeCcstj|d}|j|_|S)N)order)rrrrqr)rjrrrr`rarrszDatetimeLikeArrayMixin.copycCs|jttfSrn)rerint64rrir`r`ra_values_for_factorizesz,DatetimeLikeArrayMixin._values_for_factorize)roriginalrhcCs|||jdSrrl)rrrr`r`ra_from_factorizedsz'DatetimeLikeArrayMixin._from_factorizedc Cs0t|tr8z||}Wnttfy6t|Yn0t||jsL|tur||}z| |Wn2t tfy}zt||WYd}~n d}~00nt |st|nt |t |krtdnfz|j |dd}| |WnHt tfy*}z*tt|ddr n t||WYd}~n d}~00|S)NzLengths must matchT allow_objectrm)rrury ValueErrorrr[rdrrtrrr;r_validate_listliker<getattr)rjr}errr`r`ra_validate_comparison_value s.  "   z1DatetimeLikeArrayMixin._validate_comparison_valuecCst||jrt}ntt||jr*||}n\|jturPt|rPtj ||j d}n ||}t j dt |d|jjdttd|}|j|ddS)NrzPassing zA to shift is deprecated and will raise in a future version, pass z instead.) stacklevelTrz)rCrmrrrdrtrr is_integerZ _from_ordinalrqwarningswarnrr\ FutureWarningr1_unbox)rj fill_valueZnew_fillr`r`ra_validate_shift_value0s       z,DatetimeLikeArrayMixin._validate_shift_value)allow_listlikerzunboxc Cst||jrnt|trdz||}Wqty`}z"|||}t||WYd}~qd}~00n\t||jrvt }nJt |r|||}t|n,t||j r||}n|||}t||s|S|j ||dS)av Validate that the input value can be cast to our scalar_type. Parameters ---------- value : object allow_listlike: bool, default False When raising an exception, whether the message should say listlike inputs are allowed. setitem : bool, default True Whether to check compatibility with setitem strictness. unbox : bool, default True Whether to unbox the result before returning. Note: unbox=False skips the setitem compatibility check. Returns ------- self._scalar_type or NaT Nr) rrtruryr_validation_error_messagerrCrmrrDrdr{)rjrwrrzrrrr`r`ra_validate_scalarOs(   "      z'DatetimeLikeArrayMixin._validate_scalar)rrhcCsB|r"d|jjdt|jd}nd|jjdt|jd}|S)a+ Construct an exception message on validation error. Some methods allow only scalar inputs, while others allow either scalar or listlike. Parameters ---------- allow_listlike: bool, default False Returns ------- str zvalue should be a 'z"', 'NaT', or array of those. Got 'z ' instead.z' or 'NaT'. Got ')rtr\r)rjrwrrr`r`rars  z0DatetimeLikeArrayMixin._validation_error_messagerc Csnt|t|r|St|tr       z)DatetimeLikeArrayMixin._validate_listlikecCs,t|s|j|dddS||}||S)NTF)rrz)r;rrrrxr`r`ra_validate_searchsorted_values z3DatetimeLikeArrayMixin._validate_searchsorted_valuecCs0t|r||}n|j|ddS|j|ddS)NT)rr)r;rrrrxr`r`ra_validate_setitem_values z.DatetimeLikeArrayMixin._validate_setitem_valuez6np.int64 | np.datetime64 | np.timedelta64 | np.ndarray)rzrhcCs2t|r|j||d}n|j||d|j}|S)zZ Unbox either a scalar with _unbox_scalar or an instance of our own type. r)rrr{rrer~r`r`rars  zDatetimeLikeArrayMixin._unboxcCsddlm}|||jS)Nr)Index)ZpandasrmaprN)rjZmapperrr`r`rars zDatetimeLikeArrayMixin.mapznpt.NDArray[np.bool_]c Cst|dst|}|jjdvr0tj|jtdSt|t |sgd}|jt krt j |dd}||vr|dkrpn(d|vrt |t |Stj|jtdSzt ||}Wn"tyt |t |YS0z||Wn(ttfytj|jtdYS0t |j|jS) z Compute boolean array of whether each value is found in the passed set of values. Parameters ---------- values : set or sequence of values Returns ------- ndarray[bool] rm)fiucrl)r timedelta64r datetime64dateZperiodF)skipnastringZmixed)rrrrmrZzerosrrfrrrrrrHrrrrrr)rjrZ inferableinferredr`r`rarH s.     zDatetimeLikeArrayMixin.isincCs|jSrn)_isnanrir`r`rarDAszDatetimeLikeArrayMixin.isnacCs |jtkS)z- return if each value is nan )rrrir`r`rarDszDatetimeLikeArrayMixin._isnancCst|jS)zJ return if I have any nans; enables various perf speedups )rfranyrir`r`ra_hasnaKszDatetimeLikeArrayMixin._hasna)rrhcCs6|jr2|r||}|dur"tj}t||j||S)az Parameters ---------- result : np.ndarray fill_value : object, default iNaT convert : str, dtype or None Returns ------- result : ndarray with values replace by the fill_value mask the result if needed, convert to the provided dtype if its not None This is an internal routine. N)rrrnanputmaskr)rjrrrr`r`ra_maybe_mask_resultsRs z*DatetimeLikeArrayMixin._maybe_mask_resultscCs|jS)zK Return the frequency object if it is set, otherwise None. rrir`r`rarqpszDatetimeLikeArrayMixin.freqcCs8|dur.t|}||||jdkr.td||_dS)NrzCannot set freq with ndim > 1)r_validate_frequencyrrrrxr`r`rarqws   z str | NonecCs|jdurdS|jjS)zU Return the frequency object as a string if its set, otherwise None. N)rqfreqstrrir`r`rars zDatetimeLikeArrayMixin.freqstrcCs4|jdkrdSz t|WSty.YdS0dS)z Tries to return a string representing a frequency guess, generated by infer_freq. Returns None if it can't autodetect the frequency. rN)rrUZ infer_freqrrir`r`ra inferred_freqs    z$DatetimeLikeArrayMixin.inferred_freqzResolution | NonecCs8|j}|durdSz t|WSty2YdS0dSrn)rrZget_reso_from_freqKeyError)rjrr`r`ra_resolution_objs  z&DatetimeLikeArrayMixin._resolution_objcCs|jjS)zO Returns day, hour, minute, second, millisecond or microsecond )rattrnamerir`r`ra resolutionsz!DatetimeLikeArrayMixin.resolutionc Ks|j}|jdks||jkrdSz:|jf|ddt||d|}t|j|jsVtWnLty}z4dt |vrx|td|d|j|WYd}~n d}~00dS)am Validate that a frequency is compatible with the values of a given Datetime Array/Index or Timedelta Array/Index Parameters ---------- index : DatetimeIndex or TimedeltaIndex The index on which to determine if the given frequency is valid freq : DateOffset The frequency to validate rNstartendperiodsrqz non-fixedInferred frequency 9 from passed values does not conform to passed frequency ) rsizer_generate_rangerrZ array_equalrrru)rindexrqkwargsrZon_freqer`r`rars* z*DatetimeLikeArrayMixin._validate_frequency)rrhcOs t|dSrnro)rrr r rqargsrr`r`rarsz&DatetimeLikeArrayMixin._generate_rangecCstj|jdddS)NTZtimelikerrZ is_monotonicrrir`r`ra_is_monotonic_increasingsz/DatetimeLikeArrayMixin._is_monotonic_increasingcCstj|jdddS)NTrrrrir`r`ra_is_monotonic_decreasingsz/DatetimeLikeArrayMixin._is_monotonic_decreasingcCstt|jd|jkS)NK)rrJrrr rir`r`ra _is_uniquesz!DatetimeLikeArrayMixin._is_uniquec Cs|jdkr6t|dd|jkr6||||jSz||}Wntybt|||YS0t|dd}t|rt j dd*t |t |t|}Wdn1s0Y|S||}||jd|d}t|}|j|B}|r|tju}t ||||S)Nrrrmignore)rr)rrrrrrr[rSr<rZerrstaterFZcomp_method_OBJECT_ARRAYrrrrrerrDrroperatorner) rjr}oprmrZ other_valsZo_maskmaskZ nat_resultr`r`ra _cmp_methods*  "    z"DatetimeLikeArrayMixin._cmp_method__pow____rpow____mul____rmul__ __truediv__ __rtruediv__ __floordiv__ __rfloordiv____mod____rmod__ __divmod__ __rdivmod__cCs$tdt|jdt|jdS)Nz cannot add  and rrr\rjr}r`r`ra_add_datetimelike_scalarsz/DatetimeLikeArrayMixin._add_datetimelike_scalarcCs$|tus Jtdt|jdS)Nz"cannot subtract a datelike from a )rrrr\r-r`r`ra_sub_datetimelike_scalar s z/DatetimeLikeArrayMixin._sub_datetimelike_scalarcCstdt|jdS)Nzcannot subtract Period from a r,r-r`r`ra _sub_period'sz"DatetimeLikeArrayMixin._sub_periodr)r}cCstdt|jdS)Nzcannot add Period to a r,r-r`r`ra _add_period+sz"DatetimeLikeArrayMixin._add_periodcCs t|dSrnro)rjoffsetr`r`ra _add_offset/sz"DatetimeLikeArrayMixin._add_offsetcCst|r4tj|jdd}|tt|||jdSt|}t |j ||j d}| d}| |}| |jj}d}t|jtst|jr|j}t|j||j|dS)zk Add a delta of a timedeltalike Returns ------- Same type as self rrl)arr_maskNrmrq)rDremptyrfillrrrmrrGrrrrrerrqrr= _simple_new)rjr} new_valuesZincrr`r`ra_add_timedeltalike_scalar2s   z0DatetimeLikeArrayMixin._add_timedeltalike_scalarcCst|t|krtdt|tjr:ddlm}||}|j}|j}t |||j |j d}|j sf|j r|j |j B}t ||t t|||jdS)zl Add a delta of a TimedeltaIndex Returns ------- Same type as self z$cannot add indices of unequal lengthrrW)r4Zb_maskrl)rrrrndarraypandas.core.arraysrWrrrGrrrrrrm)rjr}rWZself_i8Zother_i8r9rr`r`ra_add_timedelta_arraylikePs       z/DatetimeLikeArrayMixin._add_timedelta_arraylikecCsZt|jr*tdt|jdttjtj|jtj d}| t t|||jddS)z$ Add pd.NaT to self z Cannot add r+rlNr5) r=rmrrr\rrr6rrr7rrjrr`r`ra_add_natns  zDatetimeLikeArrayMixin._add_natcCs&tj|jtjd}|t|dS)z+ Subtract pd.NaT from self rlztimedelta64[ns])rr6rrr7rrr?r`r`ra_sub_nat~s  zDatetimeLikeArrayMixin._sub_natcCs td|jdt|jdS)Ncannot subtract z -dtype from )rrmrr\r-r`r`ra_sub_period_arraysz(DatetimeLikeArrayMixin._sub_period_arraycCs|tjtjfvsJt|dkr8|jdkr8|||dStdt|jdt |j |j ksnJ|j |j ft 4tj dt d||dt|}Wdn1s0Yt|}t|d d |j }|S) z Add or subtract array-like of DateOffset objects Parameters ---------- other : np.ndarray[object] op : {operator.add, operator.sub} Returns ------- result : same class as self rrz)Adding/subtracting object-dtype array to z not vectorized.r)categoryONTr)raddsubrrrrrr\r-rcatch_warningsfilterwarningsrrrrrrrOr)rjr}rZ res_valuesrr`r`ra_addsub_object_arrays(  4 z+DatetimeLikeArrayMixin._addsub_object_array)rjr rhcCs|dur4||jkr4t|tr$t|}||}||S|dksHt|dkrP|S|jdurbtd|d||j}|d||j}|j||d|jdS)a Shift each value by `periods`. Note this is different from ExtensionArray.shift, which shifts the *position* of each element, padding the end with missing values. Parameters ---------- periods : int Number of periods to shift by. freq : pandas.DateOffset, pandas.Timedelta, or str Frequency increment to shift by. NrzCannot shift with no freqrr)rqrrurrrrr,r)rjr rqr2rr r`r`ra _time_shifts  z"DatetimeLikeArrayMixin._time_shift__add__cCsdt|dd}|tur |}nt|tttjfr>||}nt|t rT| |}nt|t tj frp| |}nt|trt|jr||}nt|rt|jst|||}nzt|r||}nft|r||tj}nNt|st|r||St|r.t|jst|| |tj}nt!St|tj"r`t|jr`ddl#m$}||S|SNrmrr;)%rrr@rrrrrr:rr3rrr.rr?rmr1rrr=rrKr>r<rJrrFr5r6_add_datetime_arrayliker:_addsub_int_arrayNotImplementedr<r=rWrjr} other_dtyperrWr`r`rarLs<               zDatetimeLikeArrayMixin.__add__cCs ||Srn)rLr-r`r`ra__radd__szDatetimeLikeArrayMixin.__radd____sub__cCs|t|dd}|tur |}n*t|tttjfrB|| }nt|t rZ| | }nt|t tj frv| |}nt|rt|jst||| }nt|tr||}nt|r|| }n~t|r||tj}nft|st|r||}nHt|r||}n2t |rFt|js6t||!|tj}nt"St|tj#rxt|jrxddl$m%}||S|SrM)&rrrArrrrrr:rr3rrr/rrr=rmrrKrr0r?r>r<rJrrGr5r6_sub_datetime_arraylikerCr:rOrPr<r=rWrQr`r`rarTs@              zDatetimeLikeArrayMixin.__sub__cCst|dd}t|rZt|jrZt|r4t||St|tsRddl m }||}||St|jrt |drt|jst dt |jdt |jnNt|jrt|rt dt |jd|jnt|jrtd|}| |S|| S)Nrmr)rVrBz from rW)rr4r?rmrrrrrYr=rVrrrr\r=r )rjr}rRrVr`r`ra__rsub__Ns.        zDatetimeLikeArrayMixin.__rsub__cCs2||}|dd|dd<t|js.|j|_|Srnr=rmrqrrjr}rr`r`ra__iadd__qs  zDatetimeLikeArrayMixin.__iadd__cCs2||}|dd|dd<t|js.|j|_|SrnrWrXr`r`ra__isub__zs  zDatetimeLikeArrayMixin.__isub__rr int | NonecKstd|t||jt|jrxtj|j d||d}|t urHt S| d}|dusd|jdkrn| |S| |Stj|j||d}| ||S)a  Return the minimum value of the Array or minimum along an axis. See Also -------- numpy.ndarray.min Index.min : Return the minimum value in an Index. Series.min : Return the minimum value in a Series. r`M8[ns]r[rNr)nvZ validate_minvalidate_minmax_axisrr=rmrEZnanminrerrr_from_backing_data_wrap_reduction_resultrjrrrrr`r`ramins     zDatetimeLikeArrayMixin.mincKstd|t||jt|jrxtj|j d||d}|t urH|S| d}|dusd|jdkrn| |S| |Stj|j||d}| ||S)a  Return the maximum value of the Array or maximum along an axis. See Also -------- numpy.ndarray.max Index.max : Return the maximum value in an Index. Series.max : Return the maximum value in a Series. r`r]r[rNr)r^Z validate_maxr_rr=rmrEZnanmaxrerrrr`rarbr`r`ramaxs     zDatetimeLikeArrayMixin.max)rrcCsDt|jr tdt|jdtj|j|||d}| ||S)an Return the mean value of the Array. .. versionadded:: 0.25.0 Parameters ---------- skipna : bool, default True Whether to ignore any NaT elements. axis : int, optional, default 0 Returns ------- scalar Timestamp or Timedelta. See Also -------- numpy.ndarray.mean : Returns the average of array elements along a given axis. Series.mean : Return the mean value in a Series. Notes ----- mean is only defined for Datetime and Timedelta dtypes, not for Period. zmean is not implemented for zX since the meaning is ambiguous. An alternative is obj.to_timestamp(how='start').mean()rrr) r=rmrrr\rEZnanmeanrerDra)rjrrrr`r`rameans zDatetimeLikeArrayMixin.meancKstd||dur*t||jkr*tdt|jr|tj|j d||d}| d}|dush|jdkrr| |S| |Stj|j ||d}| ||S)Nr`z abs(axis) must be less than ndimr]r[rr)r^Zvalidate_medianabsrrr=rmrEZ nanmedianrerrr`rarbr`r`ramedians     zDatetimeLikeArrayMixin.median)dropnacCsL|}|r|}||}t|d}||jj}ttj|}||S)Nr) rDrIrrermr rr<r`)rjrirrZi8modesZnpmodesr`r`ra_modes  zDatetimeLikeArrayMixin._mode)NNF)F)F)F)N)T).)N)r)r)F)F)F)N)T)fr\r]r^r___annotations__r0rkrspropertyrtryr{rrrrrrrrrrrrrrrr classmethodrrrrrrrrrrrrrrMrrHrDrrrrrqsetterrrrrrrrrrrrTrr r!r"r#r$r%r&r'r(r)r*r.rNr/rUr0r1r3r:r>r r@rArCrJrKrRrLrSrTrVrYrZrcrdrfrhrj __classcell__r`r`rrarYs    2 $#>3  8     &#  +& 2 3#  'c@s*eZdZdZedddddddZd S) DatelikeOpszK Common ops for DatetimeIndex/PeriodIndex, but not TimedeltaIndex. zNhttps://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior)ZURLruznpt.NDArray[np.object_])rrhcCs|j|tjd}|jtddS)a Convert to Index using specified date_format. Return an Index of formatted strings specified by date_format, which supports the same string format as the python standard library. Details of the string format can be found in `python string format doc <%(URL)s>`__. Parameters ---------- date_format : str Date format string (e.g. "%%Y-%%m-%%d"). Returns ------- ndarray[object] NumPy ndarray of formatted strings. See Also -------- to_datetime : Convert the given argument to datetime. DatetimeIndex.normalize : Return DatetimeIndex with times to midnight. DatetimeIndex.round : Round the DatetimeIndex to the specified freq. DatetimeIndex.floor : Floor the DatetimeIndex to the specified freq. Examples -------- >>> rng = pd.date_range(pd.Timestamp("2018-03-10 09:00"), ... periods=3, freq='s') >>> rng.strftime('%%B %%d, %%Y, %%r') Index(['March 10, 2018, 09:00:00 AM', 'March 10, 2018, 09:00:01 AM', 'March 10, 2018, 09:00:02 AM'], dtype='object') )rrFr)rrrrr)rjrrr`r`rastrftime s'zDatelikeOps.strftimeN)r\r]r^r_r/rqr`r`r`rarps rpaM Perform {op} operation on the data to the specified `freq`. Parameters ---------- freq : str or Offset The frequency level to {op} the index to. Must be a fixed frequency like 'S' (second) not 'ME' (month end). See :ref:`frequency aliases ` for a list of possible `freq` values. ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise' Only relevant for DatetimeIndex: - 'infer' will attempt to infer fall dst-transition hours based on order - bool-ndarray where True signifies a DST time, False designates a non-DST time (note that this flag is only applicable for ambiguous times) - 'NaT' will return NaT where there are ambiguous times - 'raise' will raise an AmbiguousTimeError if there are ambiguous times. nonexistent : 'shift_forward', 'shift_backward', 'NaT', timedelta, default 'raise' A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST. - 'shift_forward' will shift the nonexistent time forward to the closest existing time - 'shift_backward' will shift the nonexistent time backward to the closest existing time - 'NaT' will return NaT where there are nonexistent times - timedelta objects will shift nonexistent times by the timedelta - 'raise' will raise an NonExistentTimeError if there are nonexistent times. Returns ------- DatetimeIndex, TimedeltaIndex, or Series Index of the same type for a DatetimeIndex or TimedeltaIndex, or a Series with the same index for a Series. Raises ------ ValueError if the `freq` cannot be converted. Notes ----- If the timestamps have a timezone, {op}ing will take place relative to the local ("wall") time and re-localized to the same timezone. When {op}ing near daylight savings time, use ``nonexistent`` and ``ambiguous`` to control the re-localization behavior. Examples -------- **DatetimeIndex** >>> rng = pd.date_range('1/1/2018 11:59:00', periods=3, freq='min') >>> rng DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00', '2018-01-01 12:01:00'], dtype='datetime64[ns]', freq='T') a>>> rng.round('H') DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00', '2018-01-01 12:00:00'], dtype='datetime64[ns]', freq=None) **Series** >>> pd.Series(rng).dt.round("H") 0 2018-01-01 12:00:00 1 2018-01-01 12:00:00 2 2018-01-01 12:00:00 dtype: datetime64[ns] When rounding near a daylight savings time transition, use ``ambiguous`` or ``nonexistent`` to control how the timestamp should be re-localized. >>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam") >>> rng_tz.floor("2H", ambiguous=False) DatetimeIndex(['2021-10-31 02:00:00+01:00'], dtype='datetime64[ns, Europe/Amsterdam]', freq=None) >>> rng_tz.floor("2H", ambiguous=True) DatetimeIndex(['2021-10-31 02:00:00+02:00'], dtype='datetime64[ns, Europe/Amsterdam]', freq=None) a>>> rng.floor('H') DatetimeIndex(['2018-01-01 11:00:00', '2018-01-01 12:00:00', '2018-01-01 12:00:00'], dtype='datetime64[ns]', freq=None) **Series** >>> pd.Series(rng).dt.floor("H") 0 2018-01-01 11:00:00 1 2018-01-01 12:00:00 2 2018-01-01 12:00:00 dtype: datetime64[ns] When rounding near a daylight savings time transition, use ``ambiguous`` or ``nonexistent`` to control how the timestamp should be re-localized. >>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam") >>> rng_tz.floor("2H", ambiguous=False) DatetimeIndex(['2021-10-31 02:00:00+01:00'], dtype='datetime64[ns, Europe/Amsterdam]', freq=None) >>> rng_tz.floor("2H", ambiguous=True) DatetimeIndex(['2021-10-31 02:00:00+02:00'], dtype='datetime64[ns, Europe/Amsterdam]', freq=None) a>>> rng.ceil('H') DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00', '2018-01-01 13:00:00'], dtype='datetime64[ns]', freq=None) **Series** >>> pd.Series(rng).dt.ceil("H") 0 2018-01-01 12:00:00 1 2018-01-01 12:00:00 2 2018-01-01 13:00:00 dtype: datetime64[ns] When rounding near a daylight savings time transition, use ``ambiguous`` or ``nonexistent`` to control how the timestamp should be re-localized. >>> rng_tz = pd.DatetimeIndex(["2021-10-31 01:30:00"], tz="Europe/Amsterdam") >>> rng_tz.ceil("H", ambiguous=False) DatetimeIndex(['2021-10-31 02:00:00+01:00'], dtype='datetime64[ns, Europe/Amsterdam]', freq=None) >>> rng_tz.ceil("H", ambiguous=True) DatetimeIndex(['2021-10-31 02:00:00+02:00'], dtype='datetime64[ns, Europe/Amsterdam]', freq=None) TimelikeOpsT TimelikeOpscseZdZdZdddfdd ZddZeeej d d d(d d Z eee j dd d)ddZ eee j dd d*ddZddddddddZddddddddZdddd Zd!d"Zd+dd%fd&d' ZZS),rszK Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex. znp.ufuncru)ufuncmethodcs`|tjtjtjfvrDt|dkrD|d|urDt|||jfi|Stj||g|Ri|S)Nrr) rZisnanZisinfZisfiniterrrer__array_ufunc__)rjrtruZinputsrrr`rarvs  zTimelikeOps.__array_ufunc__c Cst|jr@td|}|d}|||||}|j|j||dS|d}ttj|}t |j }t |||} |j | t d}||jj}|j||jdS)NrV) ambiguous nonexistentr)rrl)r6rmr Z tz_localize_roundrrrr<rnanosrrrrer8) rjrqrIrwrxZnaiverrrzZ result_i8r`r`rarys       zTimelikeOps._roundround)rraisecCs||tj||Srn)ryrZNEAREST_HALF_EVENrjrqrwrxr`r`rar{szTimelikeOps.roundfloorcCs||tj||Srn)ryrZ MINUS_INFTYr}r`r`rar~szTimelikeOps.floorceilcCs||tj||Srn)ryrZ PLUS_INFTYr}r`r`rarszTimelikeOps.ceilNTr[r\rfcCstj|j|||dSNre)rEZnananyrerDrjrrr`r`rarszTimelikeOps.anycCstj|j|||dSr)rEZnanallrerDrr`r`rarszTimelikeOps.allr|rgcCs d|_dSrnrrir`r`rarszTimelikeOps._maybe_clear_freqcCsJ|dur n.t|dkr"t|tr"n|dks.Jt|j}|}||_|S)z Helper to get a view on the same data, with a new freq. Parameters ---------- freq : DateOffset, None, or "infer" Returns ------- Same type as self Nrinfer)rrrrrrr)rjrqZarrr`r`ra _with_freq s   zTimelikeOps._with_freqrF)sortcsh|jdurZtjt|tjd}|}|rR|jjdkrR|ddd}|ddd}||fStj|dS)Nrlrr) na_sentinel) rqrZarangerZintprrrr factorize)rjrrZcodesZuniquesrr`rar)s zTimelikeOps.factorize)r|r|)r|r|)r|r|)rF)r\r]r^r_rvryr. _round_doc_round_examplerr{_floor_exampler~ _ceil_examplerrrrrrror`r`rrarss    cCs8|dur4t|rt|}nt|s4td||S)a9 If a `periods` argument is passed to the Datetime/Timedelta Array/Index constructor, cast it to an integer. Parameters ---------- periods : None, float, int Returns ------- periods : None or int Raises ------ TypeError if periods is None, float, or int Nzperiods must be a number, got )rZis_floatrrr)r r`r`ravalidate_periods:s    rcCsH|dur@|dur0||kr0td|d|jn |dur<|}d}||fS)a If the user passes a freq and another freq is inferred from passed data, require that they match. Parameters ---------- freq : DateOffset or None inferred_freq : DateOffset or None freq_infer : bool Returns ------- freq : DateOffset or None freq_infer : bool Notes ----- We assume at this point that `maybe_infer_freq` has been called, so `freq` is either a DateOffset object or None. Nr r F)rr)rqr freq_inferr`r`ravalidate_inferred_freqTsrcCs0d}t|ts(|dkr t|}nd}d}||fS)a Comparing a DateOffset to the string "infer" raises, so we need to be careful about comparisons. Make a dummy variable `freq_infer` to signify the case where the given freq is "infer" and set freq to None to avoid comparison trouble later on. Parameters ---------- freq : {DateOffset, None, str} Returns ------- freq : {DateOffset, None} freq_infer : bool Whether we should inherit the freq of passed data. FrTN)rrr)rqrr`r`ramaybe_infer_freqws  r)Z __future__rrrrtypingrrrrr r r r r rrZnumpyrZ pandas._libsrrZpandas._libs.tslibsrrrrrrrrrrrrZpandas._libs.tslibs.fieldsrrZpandas._libs.tslibs.timestampsrZpandas._typingr r!r"r#r$r%r&r'r(r)Zpandas.compat.numpyr*r^Z pandas.errorsr+r,r-Zpandas.util._decoratorsr.r/r0Zpandas.util._exceptionsr1Zpandas.core.dtypes.commonr2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rAZpandas.core.dtypes.dtypesrBZpandas.core.dtypes.missingrCrDZ pandas.corerErFZpandas.core.algorithmsrGrHrIrJZpandas.core.arraylikerKZpandas.core.arrays._mixinsrLrMZpandas.core.commoncorecommonrZpandas.core.constructionrNrrOZpandas.core.indexersrPrQZpandas.core.ops.commonrRZpandas.core.ops.invalidrSrTZpandas.tseriesrUr=rVrWrvrX Exceptionr[rYrprrrrrrrsrrrr`r`r`rasj 0 8 0  H       |0? p#