Mh\SSKJr SSKJrJr SSKJr SSKrSSKJrJ r J r J r J r J r JrJr SSKrSSKrSSKJrJr SSKJr SSKJrJrJrJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r) SS K*J+r+J,r, SS K-J.r. SS K/J0r0 SS K1J2r2 SS K3J4r4J5r5J6r6J7r7J8r8J9r9J:r:J;r;Jr>J?r?J@r@JArAJBrBJCrC SSKDJErF SSKGJHrHJIrIJJrJ SSKKJLrLJMrMJNrN SSKOJPrP SSKQJRrR SSKSJTrTJUrUJVrVJWrWJXrXJYrY SSKZJ[r[J\r\J]r]J^r^J_r_ SSK`JaraJbrb SSKcJdrdJere SSKfJgrgJhrhJiriJjrj SSKkJlrlJmrmJnrn SSKoJprp SSKqJrrr SSKsJtrtJuru SSKvJwrw SSKxJyry SSKzJ{r{ SSK|J}s J~r SSKJrJrJr SS KJrJr SS!KJr SS"KJrJr SS#KJr \(aSS$KJrJr SS%KJr SS&KJrJrJr \ \6\4rS9S'jrS:S(jr"S)S*\r\t5r"S+S,\5rS-rS.rS/rS0r"S1S2\5rS;S3jr\SS6jrS?S7jrS@S8jrg)A) annotations)datetime timedelta)wrapsN) TYPE_CHECKINGAnyCallableLiteralUnioncastfinaloverload)algoslib) NDArrayBacked) BaseOffsetIncompatibleFrequencyNaTNaTTypePeriod ResolutionTick Timedelta Timestampadd_overflowsafeastype_overflowsafeget_unit_from_dtypeiNaTints_to_pydatetimeints_to_pytimedeltaperiods_per_day to_offset)RoundTo round_nsint64)compare_mismatched_resolutions)get_unit_for_round)integer_op_not_supported) ArrayLikeAxisIntDatetimeLikeScalarDtypeDtypeObjFInterpolateOptionsNpDtypePositionalIndexer2DPositionalIndexerTuple ScalarIndexerSelfSequenceIndexer TimeAmbiguousTimeNonexistentnpt)function)AbstractMethodErrorInvalidComparisonPerformanceWarning)Appender Substitutioncache_readonly)find_stack_level)'construct_1d_object_array_from_listlike)is_all_stringsis_integer_dtype is_list_likeis_object_dtypeis_string_dtype pandas_dtype) ArrowDtypeCategoricalDtypeDatetimeTZDtypeExtensionDtype PeriodDtype)ABCCategorical ABCMultiIndex)is_valid_na_for_dtypeisna) algorithmsmissingnanopsops)isin map_arrayunique1d)datetimelike_accumulations)OpsMixin)NDArrayBackedExtensionArray ravel_compat)ArrowExtensionArray)ExtensionArray) IntegerArray)arrayensure_wrapped_if_datetimelike extract_array)check_array_indexercheck_setitem_lengths)unpack_zerodim_and_defer)invalid_comparisonmake_invalid_op) frequencies)IteratorSequenceIndex) DatetimeArray PeriodArrayTimedeltaArrayc:[U5n[U5"U5$N)rerc)op_nameops Q/var/www/html/env/lib/python3.13/site-packages/pandas/core/arrays/datetimelike.py_make_unpacked_invalid_oprss  !B #G ,R 00cL^[T5U4Sj5n[[U5$)z For PeriodArray methods, dispatch to DatetimeArray and re-wrap the results in PeriodArray. We cannot use ._ndarray directly for the affected methods because the i8 data has different semantics on NaT values. cV>[UR[5(d T"U/UQ70UD6$URS5nT"U/UQ70UD6nU[La[$[U[ 5(aUR UR5$URS5nURU5$)NM8[ns]i8) isinstancedtyperKviewrr _box_func_value_from_backing_data)selfargskwargsarrresultres_i8meths rrnew_meth"_period_dispatch..new_meths$**k22.t.v. .ii!c+D+F+ S=J  * *>>&--0 0T"&&v..rt)rr r-)rrs` rr_period_dispatchrs* 4[ / / 8 rtcp^\rSrSr%SrS\S'S\S'S\S'S \S 'S \S '\SqS j5rSrSsSjjr\ StSj5r SuSjr SvSjr SwSjr SrSxSjrSySjr\ SzSj5rSSS.S{SjjrS|S}SjjrS~SSjjr\SSj5r\SSj5rSU4S jjrSS!jrSU4S"jjrSS#jrSSU4S%jjjr\SS&j5r\SS'j5r\SS(j5r\SSS)jj5rSSU4S*jjjrS+rSS$S,.SS-jjrS|SS.jjrS|SS/jjrS0r \!SS1j5r"\#SS2j5r$SS3jr%SS4jr&\ SS5j5r'\ SqS6j5r(\)S4SS7jjr*\ SS8j5r+\ SS9j5r,\ SS:j5r-\ SS;j5r.\ SqS<j5r/\ SqS=j5r0\ SqS>j5r1S?r2\3"S@5r4\3"SA5r5\3"SB5r6\3"SC5r7\3"SD5r8\3"SE5r9\3"SF5r:\3"SG5r;\3"SH5r<\3"SI5r=\3"SJ5r>\3"SK5r?\!SSLj5r@\!SSMj5rA\!SSNj5rB\!SSOj5rC\!SSPj5rD\!SSQj5rE\!SSRj5rF\!SSSj5rGSTrHSUrISSVjrJ\!SSWj5rK\!SX5rL\!SY5rM\!SSZj5rN\!SS[j5rOS$S\.SS]jjrP\Q"S^5S_5rRS`rS\Q"Sa5Sb5rTScrUSSdjrVSSejrW\XSU4Sfjj5rY\XSS$Sg.SShjj5rZ\XSS$Sg.SSijj5r[S$SjSk.SSljjr\\XSS$Sg.SSmjj5r]SSSnjjr^SSojr_Spr`U=ra$)DatetimeLikeArrayMixinz Shared Base/Mixin class for DatetimeArray, TimedeltaArray, PeriodArray Assumes that __new__/__init__ defines: _ndarray and that inheriting subclass implements: freq ztuple[str, ...]_infer_matcheszCallable[[DtypeObj], bool]_is_recognized_dtypeztuple[type, ...]_recognized_scalars np.ndarray_ndarrayBaseOffset | Nonefreqcg)NTrs rr _can_hold_na#DatetimeLikeArrayMixin._can_hold_nasrtNFc[U5eror9)rdatarzrcopys rr__init__DatetimeLikeArrayMixin.__init__s"$''rtc[U5e)z{ The scalar associated with this datelike * PeriodArray : Period * DatetimeArray : Timestamp * TimedeltaArray : Timedelta rrs rr _scalar_type#DatetimeLikeArrayMixin._scalar_types"$''rtc[U5e)a 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. rrvalues rr_scalar_from_string*DatetimeLikeArrayMixin._scalar_from_string$"$''rtc[U5e)aD Unbox the integer value of a scalar `value`. Parameters ---------- value : Period, Timestamp, Timedelta, or NaT Depending on subclass. Returns ------- int Examples -------- >>> arr = pd.array(np.array(['1970-01-01'], 'datetime64[ns]')) >>> arr._unbox_scalar(arr[0]) numpy.datetime64('1970-01-01T00:00:00.000000000') rrs rr _unbox_scalar$DatetimeLikeArrayMixin._unbox_scalars*"$''rtc[U5e)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 Raises ------ Exception rrothers rr_check_compatible_with-DatetimeLikeArrayMixin._check_compatible_withrrtc[U5e)z9 box function to get object from internal representation r)rxs rrr| DatetimeLikeArrayMixin._box_func-s"$''rtc@[R"XRSS9$)z! apply box func to passed values F)convert)r map_inferr|)rvaluess rr _box_values"DatetimeLikeArrayMixin._box_values3s}}V^^UCCrtc^TRS:aU4Sj[[T555$U4SjTR5$)Nc3.># UH nTUv M g7fror).0nrs rr 2DatetimeLikeArrayMixin.__iter__..;s6%5DG%5sc3F># UHnTRU5v M g7fro)r|)rvrs rrrr=s9y!DNN1%%ys!)ndimrangelenasi8rs`rr__iter__DatetimeLikeArrayMixin.__iter__9s1 99q=6U3t9%56 69tyy9 9rtc8URRS5$)za Integer representation of the values. Returns ------- ndarray An ndarray with int64 dtype. rx)rr{rs rrrDatetimeLikeArrayMixin.asi8?s}}!!$''rtr)na_rep date_formatc[U5e)zT Helper method for astype when converting to strings. Returns ------- ndarray[str] r)rrrs rr_format_native_types+DatetimeLikeArrayMixin._format_native_typesOs"$''rtcSR$)Nz'{}')format)rboxeds rr _formatter!DatetimeLikeArrayMixin._formatter[s }}rtc~[U5(a"[R"[U5[S9$UR $)Nrz)rDnpr^listobjectr)rrzrs rr __array__ DatetimeLikeArrayMixin.__array__bs. 5 ! !88DJf5 5}}rtcgrorritems rr __getitem__"DatetimeLikeArrayMixin.__getitem__j rtcgrorrs rrrrns rtc>[S[TU] U55n[R"U5(aU$[[ U5nUR U5UlU$)zz This getitem defers to the underlying array, which by-definition can only handle list-likes, slices, and integer scalars zUnion[Self, DTScalarOrNaT])r superrr is_scalarr3_get_getitem_freq_freq)rkeyr __class__s rrrrusU2EG4G4LM == M$'F--c2  rtcn[UR[5nU(aURnU$URS:waSnU$[ X5nSn[U[ 5(aDURb(URbURUR-nU$URnU$U[LaURnU$[R"U5(aY[R"UR[R55n[U[ 5(aUR!U5$U$)zL Find the `freq` attribute to assign to the result of a __getitem__ lookup. rN)ryrzrKrrraslicestepEllipsiscomis_bool_indexerrmaybe_booleans_to_slicer{ruint8r)rr is_periodrnew_keys rrr(DatetimeLikeArrayMixin._get_getitem_freqs tzz;7 99D& %YY!^D" &d0CD#u%%99(SXX-A88dii/D  99D yy  $$S))55chhrxx6HIgu--11':: rtcl>[XU5n[TU] X5 U(agUR5 gro)rbr __setitem___maybe_clear_freq)rrrno_oprs rrr"DatetimeLikeArrayMixin.__setitem__s2&c$7 C'    rtcgrorrs rrr(DatetimeLikeArrayMixin._maybe_clear_freqs rtTc>[U5nU[:XaURRS:Xa:[ SU5nUR n[ UURSURS9nU$URRS:Xa[URSS9$URUR R55RUR5$[U[ 5(a ["TU]IXS9$['U5(aUR)5$URS ;aUUR nU[*R,:wa[/S URS US 35eU(aUR15nU$URS ;aURU:wdURS:Xa&S[3U5R4SU3n[/U5e[*R6"XS9$)NMrk timestamp)tzboxresomT)rriuzConverting from z to z? is not supported. Do obj.astype('int64').astype(dtype) insteadmMfz Cannot cast z to dtype r)rFrrzkindr rrr_cresor rrravelreshapeshaperyrJrastyperErrint64 TypeErrorrtype__name__asarray)rrzri8data convertedrmsgrs rrr DatetimeLikeArrayMixin.astypes U# F?zz#%OT2.ww#  ! C'*4==dCC##DIIOO$56>>tzzJ J ~ . .7>%>3 3 U # #,,. . ZZ4 YYF &tzzl$ug>CC MjjD TZZ5%8UZZ3=N!d!4!4 5ZwGCC. ::d0 0rtcgrorrs rrr{DatetimeLikeArrayMixin.viewrrtcgrorrrzs rrr{rrrtcgrorrs rrr{rrrtcgrorrs rrr{rrrtc">[TU]U5$ro)rr{)rrzrs rrr{rsw|E""rtc[U[5(aURU5n[XR 5(d U[La%URU5nURU5 U$[U5(d [ U5e[U5[U5:wa [S5eURUSS9nURU5 U$![[4a [ U5ef=f![[4an[ U5UeSnAff=f![[4a2n[[USS55(aSnAU$[ U5UeSnAff=f)NzLengths must matchT) allow_objectrz)rystrr ValueErrorrr:rrrrr rCr_validate_listlikerDgetattr)rrerrs rr_validate_comparison_value1DatetimeLikeArrayMixin._validate_comparison_value sT eS ! ! /007 e55 6 6%3,%%e,E 8++E2, #e$$#E* * Z3t9 $12 2 <//D/I++E2 ; 56 /'.. /45 8'.C7 845 <"75'4#@AA ,E2;  UR*RUR:XaUR-5n[#USS9nU(a[/UR5(aOF[U5R1UR5(dUR!US5n[U5eURRS;a!U(dUR UR SS9nU$![[4a) U(aUs$UR!US5n[U5ef=f![a GNKf=f) NrFround_okrrrzT extract_numpy)ryr rzras_unitunitrr_from_sequencer,rr infer_dtyperrr r'r`pd_arrayrArH categories_internal_get_valuesrDr)rrrrs rrr)DatetimeLikeArrayMixin._validate_listlikes eT$Z ( (zz$&| dii% @L eT " "s5zQ:,,Rtzz,B B 5' " "u{{f'<u%)<)<<) J55e 49=v fm , ,??$ $<< rtcURRS;a#[R"UR[ S9$[ U5n[U[U55(Gd/SQnUR[:Xa[R"USURS9nUR[:waURU5$[R"USS9nX2;aOUS:XaOHS U;a[UR[5U5$[R"UR[ S9$[U5RU5n[ R""S URS 3[$['5S 9 URRS ;a'[+SU5nUR-UR.5nUR1U5 [UR4UR45$![(a" [UR[5U5s$f=f![2[(4a& [R"UR[ S9s$f=f)z Compute boolean array of whether each value is found in the passed set of values. Parameters ---------- values : np.ndarray or ExtensionArray Returns ------- ndarray[bool] fiucr)r timedelta64r datetime64dateperiodT)convert_non_numericdtype_if_all_natFskipnastringmixedz"The behavior of 'isin' with dtype=z and castable values (e.g. strings) is deprecated. In a future version, these will not be considered matching by isin. Explicitly cast to the appropriate dtype before calling isin instead. stacklevelrDatetimeArray | TimedeltaArray)rzrrzerosr boolr_ryr rrmaybe_convert_objectsrTr7r r6warningswarn FutureWarningr?rr r4r5rr r)rr inferableinferreds rrrTDatetimeLikeArrayMixin.isins <<   &88DJJd3 3/7&$t*--I||v%22(,%)ZZ <<6)99V,,??6%@,8+ H,#DKK$7@@!xx $?? d226: 8 E,, "/1  ::??d "8$?D^^DII.F 4  ' ' /DIIv{{++? 9DKK/88 92:& 488DJJd3 3 4s$+G(7H()HH3I  I cUR$ro)_isnanrs rrrODatetimeLikeArrayMixin.isnaAs {{rtc(UR[:H$)z return if each value is nan )rrrs rrrbDatetimeLikeArrayMixin._isnanDs yyD  rtcH[URR55$)z: return if I have any nans; enables various perf speedups )rYrbanyrs rr_hasnaDatetimeLikeArrayMixin._hasnaKs DKKOO%&&rtcUR(aLU(aURU5nUc[Rn[R"XR U5 U$)a 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. )rhr rnanputmaskrb)rr fill_valuers rr_maybe_mask_results*DatetimeLikeArrayMixin._maybe_mask_resultsRsB& ;;w/!VV JJv{{J 7 rtcJURcgURR$)a Return the frequency object as a string if it's set, otherwise None. Examples -------- For DatetimeIndex: >>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00"], freq="D") >>> idx.freqstr 'D' The frequency can be inferred if there are more than 2 points: >>> idx = pd.DatetimeIndex(["2018-01-01", "2018-01-03", "2018-01-05"], ... freq="infer") >>> idx.freqstr '2D' For PeriodIndex: >>> idx = pd.PeriodIndex(["2023-1", "2023-2", "2023-3"], freq="M") >>> idx.freqstr 'M' N)rfreqstrrs rrrqDatetimeLikeArrayMixin.freqstrps!4 99 yy   rtcrURS:wag[R"U5$![a gf=f)a Tries to return a string representing a frequency generated by infer_freq. Returns None if it can't autodetect the frequency. Examples -------- For DatetimeIndex: >>> idx = pd.DatetimeIndex(["2018-01-01", "2018-01-03", "2018-01-05"]) >>> idx.inferred_freq '2D' For TimedeltaIndex: >>> tdelta_idx = pd.to_timedelta(["0 days", "10 days", "20 days"]) >>> tdelta_idx TimedeltaIndex(['0 days', '10 days', '20 days'], dtype='timedelta64[ns]', freq=None) >>> tdelta_idx.inferred_freq '10D' rN)rrf infer_freqrrs rr inferred_freq$DatetimeLikeArrayMixin.inferred_freqs:0 99> ))$/ /  s ) 66cpURnUcg[R"U5$![a gf=fro)rqrget_reso_from_freqstrKeyError)rrqs rr_resolution_obj&DatetimeLikeArrayMixin._resolution_objs;,, ? 33G< <  s ( 55c.URR$)z? Returns day, hour, minute, second, millisecond or microsecond )rzattrnamers rr resolution!DatetimeLikeArrayMixin.resolutions ##,,,rtcF[R"URSS9S$)NTtimelikerr is_monotonicrrs rr_is_monotonic_increasing/DatetimeLikeArrayMixin._is_monotonic_increasing!!$))d;A>>rtcF[R"URSS9S$)NTrrrrs rr_is_monotonic_decreasing/DatetimeLikeArrayMixin._is_monotonic_decreasingrrtcv[[URRS555UR:H$)NK)rrVrrsizers rr _is_unique!DatetimeLikeArrayMixin._is_uniques(8DIIOOC012dii??rtcURS:aY[USS5UR:Xa>U"UR5UR55R UR5$UR U5n[USS5n[U5(aA[R"U[R"UR[55U5nU$U[La]U[ R"La%[R$"UR[&S9nU$[R("UR[&S9nU$[+UR,[.5(d[1[2U5nUR4UR4:waX[+U[7U55(dUR9UR:SS9nO"URDn[CURDXR5$URGU5nU"URDRIS5URIS55n[KU5nURLU-nURO5(a)U[ R"Ln [RP"XHU 5 U$![ a [XU5s$f=f![<a9 [R>"UR@5n[CURDXR5s$f=f)Nrr rzrFr0rx))rr r rrr"r:rdrDrScomp_method_OBJECT_ARRAYrrr rroperatorneonesrYrXryrzrKr TimelikeOpsrr r4r5rr^asm8r%rr=r{rOrbrgrl) rrrqrzr other_arr other_valso_maskmask nat_results rr _cmp_method"DatetimeLikeArrayMixin._cmp_methods5 99q=WUGT:djjHdjjlEKKM2::4::F F 733E:Ew- 5 ! !11BJJt{{623UFM C<X[[ 48M$**D9M$**k22 T*D{{ell*!%d44 % dii% H!&I9$--WW[[' DMM&&t,jood.CDe{{V# 88::x{{*J JJvZ 0 ]! 7%d26 6 76&$&HHUZZ$8 = MM9 s%+I=$J=JJAKK__pow____rpow____mul____rmul__ __truediv__ __rtruediv__ __floordiv__ __rfloordiv____mod____rmod__ __divmod__ __rdivmod__c[U[5(aURnSnX#4$[U[[45(aUR nSnX#4$UR nURnX#4$)z> Get the int64 values and b_mask to pass to add_overflowsafe. N)ryrordinalrrr}rbr)rri8valuesrs rr_get_i8_values_and_mask.DatetimeLikeArrayMixin._get_i8_values_and_masksq eV $ $}}HD~ 95 6 6||HD ~<!$))RZZ-MN[[3tyyk!34 uxxdii8[[3tyyk!34 33E:((xPPrtc[R"URS5(d7[S[ U5R S[ U5R 35eX-$)Nrrr)rrrzr r rrs rr_add_datetime_arraylike.DatetimeLikeArrayMixin._add_datetime_arraylike\sTtzz3//d4j112%U 8L8L7MN  |rtc URRS:wa![S[U5R35e[ SU5n[ U5(a U[- $[U5nURU5upURU5$)Nr"cannot subtract a datelike from a rk) rzrr r rr rOrrr_sub_datetimelike)rrtss rr_sub_datetimelike_scalar/DatetimeLikeArrayMixin._sub_datetimelike_scalarfs ::??c !@dATAT@UVW WOT* ;;#:  u ..r2%%b))rtcURRS:wa![S[U5R35e[ U5[ U5:wa [ S5e[SU5nURU5upURU5$)Nrr$cannot add indices of unequal lengthrk) rzrr r rrrr rrrs rr_sub_datetime_arraylike.DatetimeLikeArrayMixin._sub_datetime_arraylikeys{ ::??c !@dATAT@UVW W t9E "CD DOT*11%8 %%e,,rtc[SU5nSSKJn URU5 URU5upV[UR[R"U*SS95nURSURS 35nURU5n [S U 5n UR "XR"U S 9$![a2n[ U5R SS5n[U5"U5UeSnAff=f) Nrkrrmcomparesubtractrxr timedelta64[rz Tick | Noner)r rrm_assert_tzawareness_compatr rreplacer rrrrrr{r5rrrz) rrrmr! new_messagerrrres_m8rs rrr(DatetimeLikeArrayMixin._sub_datetimelikesOT*5 2  + +E 2  77>%diiXIT1RS < {!!<=33E: x0))& 8TT 2c(**9jAKs)K(c 1 2sB99 C5-C00C5c0[R"URS5(d![S[ U5R 35eSSKJn [R"URUR5n[UR5nU"X4S9nXP-$)Nrzcannot add Period to a r)rlr)rrrzr r rpandas.core.arrays.periodrlr broadcast_torr rKr)rrrli8valsrzparrs rr _add_period"DatetimeLikeArrayMixin._add_periodsrtzz3//5d4j6I6I5JKL L : ;EJJ'6/{rtc[U5eror)roffsets rr _add_offset"DatetimeLikeArrayMixin._add_offsets !$''rtc[U5(ay[R"URSS9R UR R 5nUR[5 [U5RX R S9$[SU5n[U5nURU5upURU5$)zC Add a delta of a timedeltalike Returns ------- Same type as self rxrrW)rOremptyr r{rrzfillrr rr rr_add_timedeltalike)rr new_valuess rr_add_timedeltalike_scalar0DatetimeLikeArrayMixin._add_timedeltalike_scalars ;;$**D9>>t}}?R?RSJ OOD !:))*JJ)G G4d;% 11%8 &&u--rtc[U5[U5:wa [S5e[SU5nURU5upUR U5$)zD Add a delta of a TimedeltaIndex Returns ------- Same type as self rrW)rrr rrrs rr_add_timedelta_arraylike/DatetimeLikeArrayMixin._add_timedelta_arraylikesP t9E "CD D4d;11%8 &&u--rtcD[SU5nURU5up#[UR[R "USS95nUR URR5nURU5n[U5RXPRUS9$)NrWrxrr) r rrrrrr{rrzrr r)rrrrrrrs rrr)DatetimeLikeArrayMixin._add_timedeltalikes4d;77>%diiHD1QR __T]]%8%89 33E: Dz%% jjx&  rtc[UR[5(a;[S[ U5R S[ [ 5R 35e[SU5n[R"UR[RS9nUR[5 URURR5n[ U5R!XRSS9$)z Add pd.NaT to self z Cannot add rzTimedeltaArray | DatetimeArrayrNr)ryrzrKr r rrr rrr r rrr{rrrrs rr_add_natDatetimeLikeArrayMixin._add_nats djj+ . .d4j112%S 8J8J7KL 4d;$**BHH5 DT]]001Dz%% **4&  rtc2[R"UR[RS9nUR [ 5 UR RS;a+[SU5nURSURS35$URS5$)z Subtract pd.NaT from self rrzDatetimeArray| TimedeltaArrayrrztimedelta64[ns]) rrr r rrrzrr r{r5rs rr_sub_natDatetimeLikeArrayMixin._sub_natsq$**BHH5 D ::??d "7>D;;dii[:; ;;;01 1rtc8[UR[5(d7[S[ U5R S[ U5R 35e[ SU5nURU5 URU5up#[UR[R"U*SS95n[R"UVs/sHoPRRU-PM sn5nUc UR nOUR U-n["Xg'U$s snf)Ncannot subtract  from rlrxr)ryrzrKr r rr rrrrrrr^rbaserbr)rrrr new_i8_datarnew_datars rr_sub_periodlike&DatetimeLikeArrayMixin._sub_periodlike s$**k22"4;#7#7"8tDz?R?R>ST M4( ##E*77>&tyy"**hYd2ST 88EAYY^^a/EF >;;D;;'DFs"DcU[R[R4;de[U5S:XaURS:Xa U"XS5$[ R "S[U5RS3[[5S9 URUR:XdURUR45eU"URS5[R"U55nU$)a Add or subtract array-like of DateOffset objects Parameters ---------- other : np.ndarray[object] op : {operator.add, operator.sub} Returns ------- np.ndarray[object] Except in fastpath case with length 1 where we operate on the contained scalar. rrz)Adding/subtracting object-dtype array to z not vectorized.rUO)raddsubrrr[r\r rr;r?r r rr)rrrqrs rr_addsub_object_array+DatetimeLikeArrayMixin._addsub_object_array%s hllHLL1111 u:?tyyA~d!H% % 7Dz""##3 5 ')  zzU[[(C4::u{{*CC( C("**U*;< rtrQc US;a[SUS[U535e[[U5nU"UR 54SU0UD6n[U5R XPR S9$)N>cummaxcumminz Accumulation z not supported for rRr)r r r rWrrrz)rnamerRrrqrs rr _accumulate"DatetimeLikeArrayMixin._accumulateIsk + +mD61DT$ZLQR R / 6DIIK99&9Dz%%fJJ%??rt__add__cV[USS5n[U5nU[LaUR5nGO[ U[ [ [R45(aURU5nGO[[ U[5(aURU5nGO3[ U[[R45(aURU5nGO[ U[5(a9[ R""UR$S5(aUR'U5nGO[ R("U5(an[ UR$[*5(d [-U5e[/SU5nUR1XR$R2-[4R65nGO$[ R""US5(aUR9U5nO[;U5(a!UR=U[4R65nO[ R""US5(d[ U[>5(aURAU5$[CU5(am[ UR$[*5(d [-U5e[/SU5nUR1XR$R2-[4R65nO[D$[ U[RF5(a>[ R""UR$S5(aSSK$J%n URL"U5$U$)Nrzrrlrrr)'r r_rrryrrrrKrrrrrLrrrrrzr is_integerrKr'r _addsub_int_array_or_scalar_nrrrrDrrIrrBNotImplementedndarrayrrmr6rr other_dtyperobjrms rrrDatetimeLikeArrayMixin.__add__Rs7eWd3 .u5 C<]]_F i@ A A33E:F z * *%%e,F "--8 9 92259F v & &3??4::s+K+K%%e,F ^^E " "djj+66.t44}d+C44UYY\\5I8<<XF__[# . .2259F [ ) )..uhllCF __[# . .* 3 3 //6 6 k * *djj+66.t44}d+C44UYY\\5I8<<XF" ! fbjj ) )coofllC.P.P 9!008 8 rtc$URU5$ro)rrs rr__radd__DatetimeLikeArrayMixin.__radd__s||E""rt__sub__cb[USS5n[U5nU[LaUR5nGO[ U[ [ [R45(aURU*5nGO`[ U[5(aURU*5nGO7[ U[[R45(aURU5nGO[R "U5(an[ UR"[$5(d ['U5e[)SU5nUR+XR"R,-[.R05nGOv[ U[25(aUR5U5nGON[R6"US5(aUR9U*5nGO[;U5(a!UR=U[.R05nO[R6"US5(d[ U[>5(aURAU5nO[ U[$5(aUR5U5nO[CU5(am[ UR"[$5(d ['U5e[)SU5nUR+XR"R,-[.R05nO[D$[ U[RF5(a>[R6"UR"S5(aSSK$J%n URL"U5$U$)Nrzrlrrrr)'r r_rrryrrrrKrrrrrLrrrrzrKr'r rrrrrrrrrDrrIrrBrrrrmr6rs rrrDatetimeLikeArrayMixin.__sub__sEeWd3 .u5 C<]]_F i@ A A33UF;F z * *%%uf-F "--8 9 92259F ^^E " "djj+66.t44}d+C44UYY\\5I8<<XF v & &))%0F__[# . .22E6:F [ ) )..uhllCF __[# . .* 3 3 11%8F  [ 1 1))%0F k * *djj+66.t44}d+C44UYY\\5I8<<XF" ! fbjj ) )coofllC.P.P 9!008 8 rtc[USS5n[R"US5=(d [U[5nU(a[R"UR S5(aZ[R "U5(a[U5U- $[U[5(dSSK J n UR"U5nX- $UR RS:XaO[US5(a>U(d7[S[U5R S[U5R 35e[UR ["5(aJ[R"US5(a.[S[U5R SUR 35e[R"UR S5(a[%SU5nU*U-$X- *$) Nrzrrrrrrrm)r rrryrIrzrrrrrkr6rr,r r rrKr )rrr other_is_dt64rks rr__rsub__DatetimeLikeArrayMixin.__rsub__smeWd3  S9 Z >  S__TZZ==}}U## '$..e%;<<<%44U;<  ZZ__ #w(?(? "4:#6#6"7vd5k>R>R=ST  K 0 0S__[RU5V5V.tDz/B/B.C6%++WX X __TZZ - -($/DEU? "rtc~X-nUSSUSS&[UR[5(dURUlU$roryrzrKrrrrrs rr__iadd__DatetimeLikeArrayMixin.__iadd__7)Q$**k22DJ rtc~X- nUSSUSS&[UR[5(dURUlU$ror$r%s rr__isub__DatetimeLikeArrayMixin.__isub__r(rtc>[TU]XS9$)N)qs interpolation)r _quantile)rr-r.rs rrr/ DatetimeLikeArrayMixin._quantiles w B DDrtaxisrRc [R"SU5 [R"XR5 [R "UR XS9nURX5$)z 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. rr1)nv validate_minvalidate_minmax_axisrrRnanminr_wrap_reduction_resultrr2rRrrs rrminDatetimeLikeArrayMixin.minI F# ii0t}}4G**488rtc [R"SU5 [R"XR5 [R "UR XS9nURX5$)z 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. rr1)r4 validate_maxr6rrRnanmaxrr8r9s rrmaxDatetimeLikeArrayMixin.maxr<rtr)rRr2c[UR[5(a"[S[ U5R S35e[ R"URX!UR5S9nURX#5$)a Return the mean value of the Array. 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. Examples -------- For :class:`pandas.DatetimeIndex`: >>> idx = pd.date_range('2001-01-01 00:00', periods=3) >>> idx DatetimeIndex(['2001-01-01', '2001-01-02', '2001-01-03'], dtype='datetime64[ns]', freq='D') >>> idx.mean() Timestamp('2001-01-02 00:00:00') For :class:`pandas.TimedeltaIndex`: >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='D') >>> tdelta_idx TimedeltaIndex(['1 days', '2 days', '3 days'], dtype='timedelta64[ns]', freq=None) >>> tdelta_idx.mean() Timedelta('2 days 00:00:00') zmean is not implemented for zX since the meaning is ambiguous. An alternative is obj.to_timestamp(how='start').mean()r2rRr) ryrzrKr r rrRnanmeanrrOr8)rrRr2rs rrmeanDatetimeLikeArrayMixin.mean)stX djj+ . ..tDz/B/B.CD77   MM$))+ **488rtc [R"SU5 Ub$[U5UR:a [ S5e[ R "URXS9nURX5$)Nrz abs(axis) must be less than ndimr1) r4validate_medianabsrrrR nanmedianrr8r9s rrmedianDatetimeLikeArrayMixin.medianbsZ 2v&  D TYY 6?@ @!!$--dJ**488rtcSnU(aUR5n[R"URS5US9nURURR 5n[ [RU5nURU5$)Nrx)r) rOrPmoder{rrzr rrr~)rdropnari8modesnpmodess rr_modeDatetimeLikeArrayMixin._modelsf 99;D//$))D/=,,t}}223rzz7+&&w//rtc URnURS:XaEUS;a[SUS35eUS;a)[R"SUSUS3[ [ 5S 9 Oo[U[5(aEUS;a[S US35eUS;a)[R"SUS US3[ [ 5S 9 OUS ;a[S US35eURRS5nSSK J n U RU5n U "XUS9n U R"U4UUUSS.UD6n U RU R ;aU $U RS:XdeUS;awSSKJn [UR[5(a [S5e['SU5nSUR(S3nU RU5n U R*"XRS9$U RURR5n UR-U 5$)Nr)sumprodcumsumcumprodvarskewz!datetime64 type does not support z operations)rgallr+zh' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).z () instead.rUzPeriod type does not support ze' with PeriodDtype is deprecated and will raise in a future version. Use (obj != pd.Period(0, freq)).)rVrXrZrYz"timedelta64 type does not support rwr)WrappedCythonOp)howrhas_dropped_na) min_countngroupscomp_idsr)stdsemrz-'std' and 'sem' are not valid for PeriodDtyperWzm8[rr)rzrr r[r\r]r?ryrKrr{pandas.core.groupby.opsr\get_kind_from_how_cython_op_ndim_compatr]cast_blocklistrrmr r5rr~)rr]r^r_r`idsrrznpvaluesr\rrqrrm new_dtypes rr _groupby_op"DatetimeLikeArrayMixin._groupby_opys  :: II"CC5 TUUn$ uDDG5 U!/1 { + +II"?uK PQQn$ uGGJe;X!/1 88"DSE UVV==%%h/;005  O..       66R&& & 8+++ . 9$**k22 OPP8$?Ddii[*I#3J!--j@P@PQ Q__T]]%8%89 &&z22rtrreturnrY)NNF)rz Dtype | NonerrYroNone)roztype[DatetimeLikeScalar])rrro DTScalarOrNaT)rrrroz)np.int64 | np.datetime64 | np.timedelta64)rrrrorqror)rorg)roznpt.NDArray[np.int64])rz str | floatronpt.NDArray[np.object_])F)rrY)NN)rzzNpDtype | Nonerz bool | Noneror)rr2rorr)rz(SequenceIndexer | PositionalIndexerTupleror3)rr0rozSelf | DTScalarOrNaT)ror)rz,int | Sequence[int] | Sequence[bool] | slicerzNaTType | Any | Sequence[Any]rorqrorqT)rrYror3)rzzLiteral['M8[ns]']rork)rzzLiteral['m8[ns]']rorm).)rzrpror(ro)r$rYr%rY)r$rYror)rrY)roz6np.int64 | np.datetime64 | np.timedelta64 | np.ndarray)rr(ronpt.NDArray[np.bool_])rorx)rrror)roz str | None)rozResolution | Noneror)roz@tuple[int | npt.NDArray[np.int64], None | npt.NDArray[np.bool_]])rork)rrkrork)rzdatetime | np.datetime64rorm)rrkrorm)rzTimestamp | DatetimeArrayrorm)rrrorl)rrm)rzTimedelta | TimedeltaArray)rzPeriod | PeriodArrayrort)rrt)r rrRrYror3)r-znpt.NDArray[np.float64]r.rror3)r2AxisInt | NonerRrY)rRrYr2rz)rOrY) r]rr^rYr_intr`r{rhznpt.NDArray[np.intp])br __module__ __qualname____firstlineno____doc____annotations__r>rrpropertyrrrrr|rrrrrrrrrrrr r{r"r(r'rr>r r=rZrGrTrOrbrhrrnrqrurzr~rrrrrsrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rcrrrr!r&r*rr/r:r@rErKrRrk__static_attributes__ __classcell__rs@rrrrs$#44)) IN('(AE( ( ((((("( 2(.(,( D :  ( ( (-$ ($ (  (AE#2=    6    "<! 9!-!  !, 1111f        ##"P % ;) ;)  ;)z>8t"    "    P,j!! ''.24  <!!:<--????@@ 5r( 2G(4H' 2G(4H+M:K,^M' 2G(4H*<8J+M:K  I $     Q QB   *-* * *$  -  - U U&    (.(.$        , 2 2&  0 ! !F8<@i(5)5n#i(5)5n DE #EE  EE,099",099"&*!79r/3D990M3M3 M3  M3  M3"M3M3rtrc4\rSrSrSr\"SS9SSj5rSrg) DatelikeOpsizC Common ops for DatetimeIndex/PeriodIndex, but not TimedeltaIndex. zNhttps://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior)URLcfURU[RS9nUR[SS9$)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>`__. Formats supported by the C `strftime` API but not by the python string format doc (such as `"%%R"`, `"%%r"`) are not officially supported and should be preferably replaced with their supported equivalents (such as `"%%H:%%M"`, `"%%I:%%M:%%S %%p"`). Note that `PeriodIndex` support additional directives, detailed in `Period.strftime`. 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. Timestamp.strftime : Format a single Timestamp. Period.strftime : Format a single Period. 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)rrrkr r)rrrs rrstrftimeDatelikeOps.strftimes1b**{266*R}}V%}00rtrN)rrrort)rr|r}r~rr=rrrrtrrrrs% *.1 .1rtraO 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='min') 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) c^\rSrSr%SrS\S'S\RS4S(Sjjr\ S5r \ S 5r \ RS)S j5r \S*S j5r\\ S+S j55r\ S,S j5r\S-Sj5r\S.Sj5rS/S0SjjrSrS1U4SjjrSr\"\\-R9SS95S2S3Sjj5r\"\\-R9SS95S2S3Sjj5r\"\\ -R9SS95S2S3Sjj5r!SSS.S4Sjjr"SSS.S4Sjjr#S)Sjr$S5S jr%S6U4S!jjr&S7S8U4S"jjjr'\ S9S:U4S#jjj5r(S;SS&j5r+S'r,U=r-$)?rizC Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex. znp.dtype_default_dtypeNFc[R"[U5RS3[[ 5S9 Ub [ U5n[USS9n[U[5(aURS[S9n[USS5nUSLnU[RLaUOSn[U[U55(aU(aOHUc URnO8U(a1UR(a [!U5n[#X1R5nUb*X!R$:wa['SUS UR$35eUR$nUR(nOUc[U[*R,5(a'UR$R.S ;a UR$nOLUR0n[U[*R,5(a!UR$S :XaUR3U5n[U[*R,5(d8[5S [U5RS [U5RS35eUR6S;a [5S5eUR$S :XaUc(UR0nUR3UR05nO|[R8"US5(aUR3U5nON[U[:5(a9UR0R.nUSUR<S3nUR3U5nUR?X5nUS:Xa"[5S[U5RS35eU(aURA5nU(aE[!U5nUR$R.S:Xa [U[B5(d ['S5e[DRF"XUS9 X0l$UcUb[U5RKX5 ggg)NzV.__init__ is deprecated and will be removed in a future version. Use pd.array instead.rUTr2r na_valuerdtype=z does not match data dtype MmrxzUnexpected type 'z'. 'values' must be a z6, ndarray, or Series or Index containing one of those.)rz.Only 1-dimensional input arrays are supported.r8[rinferz#Frequency inference not allowed in z$.__init__. Use 'pd.array()' instead.r(TimedeltaArray/Index freq must be a Tick)rrz)&r[r\r rr]r?rFr`ryr]rErr r no_defaultrr"_validate_inferred_freqrzr rrrrrr{rrrrIr5_validate_dtyperrrrr_validate_frequency) rrrzrrru explicit_nonerrjs rrrTimelikeOps.__init__sE  Dz""#$A A ')     'EvT: fl + +__Wt_>1tt fd4j ) ){{&++ .t[[A Ull%:UG#>v||nMLLE__F ]&"**--&,,2C2Ct2K ++fbjj11flld6J#[[/F&"**--#DL$9$9#::P:&&'(++  ;;f $MN N <<4 }++T%8%89--U+E?33**//#fBuzzl!4 Y/$$V3 7?5d4j6I6I5JK,,  [[]F T?D||  C' 40F0F JKKt%@  T%5 J * *4 6&6 rtc[U5eror)clsrrzs rrrTimelikeOps._validate_dtypes !#&&rtcUR$)z; Return the frequency object if it is set, otherwise None. rmrs rrrTimelikeOps.freqs zzrtcUbq[U5nURX5 URRS:Xa [ U[ 5(d [ S5eURS:a [S5eXl g)NrrrzCannot set freq with ndim > 1) r"rrzrryrr rrrrs rrrrsd  e$E  $ $T 1zz#%j.E.E JKKyy1} !@AA rtcVUcSUlgUS:Xa)URc[UR5UlggU[RLagURc.[U5n[ U5R "X40UD6 Xlg[U5n[XR5 g)z Constructor helper to pin the appropriate `freq` attribute. Assumes that self._freq is currently set to any freq inferred in _from_sequence_not_strict. Nr)rr"rurrr rr)rr validate_kwdss rr_maybe_pin_freqTimelikeOps._maybe_pin_freqs <DJ W_zz!'t'9'9: "S^^ #  ZZ T?D J * *4 G GJT?D #D** 5rtc URnURS:XdXBR:XagUR"SUSS[ U5UUR S.UD6n[ R"URUR5(d[eg![a2nS[U5;aUe[SUSUR35UeSnAff=f)a% 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 rN)startendperiodsrr5z non-fixedInferred frequency 9 from passed values does not conform to passed frequency r) rurrq_generate_rangerr5r array_equalrrr)rindexrrr_on_freqr!s rrrTimelikeOps._validate_frequency0s&& ::?h,,6 ))AhE ZZ   G>>%**gll;;  < c#h& %hZ088< ~G  sA$B C-C  Cc[U5eror)rrrrrrrs rrrTimelikeOps._generate_range\s"#&&rtc@[URR5$ro)rrrzrs rrrTimelikeOps._cresods"4==#6#677rtc,[UR5$ro) dtype_to_unitrzrs rrr5TimelikeOps.uniths TZZ((rtTcUS;a [S5e[R"URRSUS35n[ UR X2S9n[ UR[R5(a URnO[SU5Rn[XaS9n[U5RXEURS9$) N)smsusnsz)Supported units are 's', 'ms', 'us', 'ns'rrr0rkrr) rrrzrrrryr rrIr rr)rr5r1rzrrjrs rrr4TimelikeOps.as_unitos . .HI IDJJOO,BtfA67(Q djj"(( + +"((Iot,//B'29IDz%% dii&  rtcURUR:waSURUR:aURUR5nX4$URUR5nX4$ro)rr4r5rs rrr"TimelikeOps._ensure_matching_resossZ ;;%,, &{{U\\)||EJJ/{ dii0{rtc>U[R[R[R4;a3[ U5S:Xa$USULa[ X5"UR 40UD6$[TU] "X/UQ70UD6$)Nrr) risnanisinfisfiniterr rr__array_ufunc__)rufuncmethodinputsrrs rrrTimelikeOps.__array_ufunc__sk bhh"++6 6F q q T!5)$--B6B Bw&uHvHHHrtc:[UR[5(aI[SU5nUR S5nUR XX45nUR UR X4S9$URS5n[[RU5n[XR5nUS:XaUR5$[XrU5n URU [S9nURUR R5nUR#X`RS9$)Nrk) ambiguous nonexistentrxrrmr)ryrzrIr tz_localize_roundrr{rrr&rrr$rnrrr) rrrNrrnaiverrnanos result_i8s rrrTimelikeOps._rounds djj/ 2 2.D$$T*E\\$iEF%%9& 4bjj&)"45 A:99; !&6 ))))ET]]001jj99rtround)rqcDURU[RX#5$ro)rr#NEAREST_HALF_EVENrrrrs rrrTimelikeOps.rounds{{4!:!:ISSrtfloorcDURU[RX#5$ro)rr# MINUS_INFTYrs rrrTimelikeOps.floors{{4!4!4iMMrtceilcDURU[RX#5$ro)rr# PLUS_INFTYrs rrrTimelikeOps.ceils{{4!3!3YLLrtr1c^[R"URXUR5S9$NrC)rRnananyrrOrr2rRs rrrgTimelikeOps.anys}}T]]499;WWrtc^[R"URXUR5S9$r)rRnanallrrOrs rrr[TimelikeOps.alls!}}T]]499;WWrtcSUlgrormrs rrrTimelikeOps._maybe_clear_freqs  rtc2UcO|[U5S:XaP[U[5(a;URRS:Xa [U[ 5(d [ S5eOUS:Xde[UR5nUR5nXl U$)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 rrrr) rryrrzrrr r"rur{r)rrrs rr _with_freqTimelikeOps._with_freqs <  Y!^ 4 < <zz#%jt.D.D JKK7? "?T//0Diik  rtc>[UR[R5(a UR$[TU]5$ro)ryrzrrr_values_for_json)rrs rrrTimelikeOps._values_for_jsons0 djj"(( + +== w'))rtcj>URbp[R"[U5[RS9nUR 5nU(a*URR S:aUSSS2nUSSS2nX44$U(a"[S[U5RS35e[TU]-US9$)NrrzThe 'sort' keyword in zu.factorize is ignored unless arr.freq is not None. To factorize with sort, call pd.factorize(obj, sort=True) instead.)use_na_sentinel) rrarangerintprrNotImplementedErrorr rr factorize)rrsortcodesuniquesrs rrrTimelikeOps.factorize s 99 IIc$irww7EiikG add !$B$-> ! &(d)<)<(=>==  w  AArtcZ>^[TU]X5nUSmUS:XaUVs/sHn[U5(dMUPM nnTRbX[ U4SjU55(a>[ USSUSS5n[ U4SjU55(aTRnXclU$s snf)Nrc3T># UHoRTR:Hv M g7fror)rrrs rrr0TimelikeOps._concat_same_type..* s+R 1FFchh,> s%(rrc3^># UH"oSSTR-USS:Hv M$ g7f)rrrNr)rpairrs rrrr, s-NAwr{SXX-a;s*-)r_concat_same_typerrr[zipr) r to_concatr2new_objrpairsrrrs @rrrTimelikeOps._concat_same_type s '+I<l 19%.8IqQII8xx#+R +R(R(RIcrNIabM:NNNN"xxH$,M9s B(B(cD>[TU]US9nURUlU$)N)order)rrrr)rrrrs rrrTimelikeOps.copy1 s#',U,+  rtc US:wa[eU(d URn OURR5n [R"U 4UUUUUUS.UD6 U(dU$[ U5R XRS9$)z" See NDFrame.interpolate.__doc__. linear)rr2rlimitlimit_direction limit_arear)rrrrQinterpolate_2d_inplacer rrz) rrr2rr r rrrout_datas rr interpolateTimelikeOps.interpolate6 s X % %}}H}}))+H&&  +!  KDz%%hjj%AArtc[R"UR5(dgURnU[:gn[ UR5n[ U5n[R"X!U-S:g5R5S:HnU$)z Check if we are round times at midnight (and no timezone), which will be given a more compact __repr__ than other cases. For TimedeltaArray we are checking for multiples of 24H. Fr) rrrzrrrr!r logical_andrU)r values_intconsider_valuesrppd even_dayss rr_is_dates_onlyTimelikeOps._is_dates_only_ sttzz**YY $,"4::.d#NN?4D4IJNNPTUU rtrm)rrYrorqru)rdict)rr)r int | Noneror3)ror{ryrv)r5rr1rYror3)rznp.ufuncrr)raiser)rr5rr6ror3)r2rzrRrYrorYrwrs)TF)rrYrrY)r)rzSequence[Self]r2r)ror3)C)rrror3) rr.r2r{rrjrrYror3rn).rr|r}r~rrrrr classmethodrrrsetterr rrrr>rr5r4rrrr< _round_doc_round_examplerr_floor_exampler _ceil_examplerrgr[rrrrrrrrrrrs@rrrrs!s~~EZ7=AZ7 Z7x''  [[   6 6@ ( (T'",' ''88))  * I:,zN*22g2>?$+'. T!T% T  T@TzN*22g2>?$+'. N!N% N  N@NzM)11V1<=$+'. M!M% M  M>M-1X-1X@*!%BBBB0!  * $B#$B $B  $B$B $BRrtrc^[US5(dN[U[[45(d%[R "U5S:Xa [U5n[ U5nSnO.[U[5(a[SUS35e[USS9n[U[5(d/[U[5(a3URRS;aURS [S 9nSnX4$[U[5(a%UR!5nUR5nSnX4$[U[R"[$45(d[R&"U5nX4$[U[(5(a4UR*R-UR.[0S 9R2nSnX4$) NrzrFzCannot create a z from a MultiIndex.Tr2rr rr)r,ryrtuplerrr@rMr r`r]r[rzrrEr_maybe_convert_datelike_arrayrr\rrLr9takerr_values)rrcls_names rr!ensure_arraylike_for_datetimeliker+y sl 4 ! !$u ..2774=A3E:D6t< D- ( (*8*4GHIIT6$ %%4,--$**//T2I}}Wt}4 : D- . .113}} :rzz>: ; ;zz$ : D. ) )##DJJ3#?GG :rtcgrorrs rrvalidate_periodsr. rtcgrorr-s rrr.r. r/rtcUbs[R"U5(a/[R"S[[ 5S9 [ U5nU$[R"U5(d[SU35eU$)a 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 zNon-integer 'periods' in pd.date_range, pd.timedelta_range, pd.period_range, and pd.interval_range are deprecated and will raise in a future version.rUzperiods must be a number, got ) ris_floatr[r\r]r?r{rr r-s rrr.r. sp$ << MM2+-  'lG N((pandas.util._exceptionsr?pandas.core.dtypes.castr@pandas.core.dtypes.commonrArBrCrDrErFpandas.core.dtypes.dtypesrGrHrIrJrKpandas.core.dtypes.genericrLrMpandas.core.dtypes.missingrNrO pandas.corerPrQrRrSpandas.core.algorithmsrTrUrVpandas.core.array_algosrWpandas.core.arraylikerXpandas.core.arrays._mixinsrYrZpandas.core.arrays.arrow.arrayr[pandas.core.arrays.baser\pandas.core.arrays.integerr]pandas.core.commoncorecommonrpandas.core.constructionr^r8r_r`pandas.core.indexersrarbpandas.core.ops.commonrcpandas.core.ops.invalidrdrepandas.tseriesrfcollections.abcrgrhrDrjrrkrlrmrrrsrrrr!r"r#r$rr+r.rrrrtrrr]s"   .&K=C$/  5K   ?*?23  < '  ('12 1 6B3 )B3J071(71t= ~66 8^(^J$$ #$$N    D ,=:&rt