Owg\ddlmZddlmZmZddlmZddlZddlmZm Z m Z m Z m Z m Z mZmZddlZddlZddlmZmZddlmZddlmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)dd l*m+Z+m,Z,dd l-m.Z.dd l/m0Z0dd l1m2Z2dd l3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCddlDmEZFddlGmHZHmIZImJZJddlKmLZLmMZMmNZNddlOmPZPddlQmRZRddlSmTZTmUZUmVZVmWZWmXZXmYZYddlZm[Z[m\Z\m]Z]m^Z^m_Z_ddl`maZambZbddlcmdZdmeZeddlfmgZgmhZhmiZimjZjddlkmlZlmmZmmnZnddlompZpddlqmrZrddlsmtZtmuZuddlvmwZwddlxmyZyddlzm{Z{ddl|m}cm~ZddlmZmZmZdd lmZmZdd!lmZdd"lmZmZdd#lmZerdd$lmZmZdd%lmZdd&lmZmZmZe e6efZd9d'Zd:d(ZGd)d*eretZGd+d,eZd-Zd.Zd/Zd0ZGd1d2eZ d;d3Zedd6Z d?d7Zd@d8Zy)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:t|}t||SN)rerc)op_nameops V/var/www/horilla/myenv/lib/python3.12/site-packages/pandas/core/arrays/datetimelike.py_make_unpacked_invalid_oprss  !B , #G ,R 00cJtfd}tt|S)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. c@t|jts |g|i|S|jd}|g|i|}|turtSt|t r|j |jS|jd}|j|S)NM8[ns]i8) isinstancedtyperKviewrr _box_func_value_from_backing_data)selfargskwargsarrresultres_i8meths rrnew_methz"_period_dispatch..new_meths$**k2.t.v. .ii!c+D+F+ S=J  *>>&--0 0T"&&v..rt)rr r-)rrs` rr_period_dispatchrs* 4[ / / 8 rtceZdZUdZded<ded<ded<ded <d ed <edod Z dp dqdZedrdZ dsdZ dtdZ dudZ dZ dvdZdwdZedxdZdd d dydZdzd{dZ d| d}dZed~dZe ddZdfd Zdd Z dfd! Zdd"Zddfd$ Zedd%Zedd&Zedd'Zeddd(Zddfd) Zd*Zdd#d+ dd,Zdzdd-Zdzdd.Zd/Ze dd0Z!e"dd1Z#dd2Z$dd3Z%edd4Z&edod5Z'e(d f dd6Z)edd7Z*edd8Z+edd9Z,edd:Z-edod;Z.edod<Z/edod=Z0d>Z1e2d?Z3e2d@Z4e2dAZ5e2dBZ6e2dCZ7e2dDZ8e2dEZ9e2dFZ:e2dGZ;e2dHZ<e2dIZ=e2dJZ>e ddKZ?e ddLZ@e ddMZAe ddNZBe ddOZCe ddPZDe ddQZEe ddRZFdSZGdTZHddUZIe ddVZJe dWZKe dXZLe ddYZMe ddZZNd#d[dd\ZOePd]d^ZQd_ZRePd`daZSdbZTddcZUdddZVeW dfde ZXeWd d#dfddgZYeWd d#dfddhZZd#didjddkZ[eWd d#dfddlZ\dddmZ] ddnZ^xZ_S)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 | Nonefreqcy)NTrs rr _can_hold_naz#DatetimeLikeArrayMixin._can_hold_nasrtNFct|ror9)rdatarzrcopys rr__init__zDatetimeLikeArrayMixin.__init__s"$''rtct|)z The scalar associated with this datelike * PeriodArray : Period * DatetimeArray : Timestamp * TimedeltaArray : Timedelta rrs rr _scalar_typez#DatetimeLikeArrayMixin._scalar_types"$''rtct|)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. rrvalues rr_scalar_from_stringz*DatetimeLikeArrayMixin._scalar_from_string$"$''rtct|)a 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_scalarz$DatetimeLikeArrayMixin._unbox_scalars*"$''rtct|)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_withz-DatetimeLikeArrayMixin._check_compatible_withrrtct|)zI box function to get object from internal representation r)rxs rrr|z DatetimeLikeArrayMixin._box_func-s"$''rtcFtj||jdS)z1 apply box func to passed values F)convert)r map_inferr|)rvaluess rr _box_valuesz"DatetimeLikeArrayMixin._box_values3s}}VT^^UCCrtcjdkDrfdttDSfdjDS)Nc3(K|] }| ywror).0nrs rr z2DatetimeLikeArrayMixin.__iter__..;s6DG6sc3@K|]}j|ywro)r|)rvrs rrrz2DatetimeLikeArrayMixin.__iter__..=s9!DNN1%9s)ndimrangelenasi8rs`rr__iter__zDatetimeLikeArrayMixin.__iter__9s1 99q=6U3t9%56 69tyy9 9rtc8|jjdS)z Integer representation of the values. Returns ------- ndarray An ndarray with int64 dtype. rx)rr{rs rrrzDatetimeLikeArrayMixin.asi8?s}}!!$''rtr)na_rep date_formatct|)z| Helper method for astype when converting to strings. Returns ------- ndarray[str] r)rrrs rr_format_native_typesz+DatetimeLikeArrayMixin._format_native_typesOs"$''rtcdjS)Nz'{}')format)rboxeds rr _formatterz!DatetimeLikeArrayMixin._formatter[s }}rtcxt|r$tjt|tS|j S)Nrz)rDnpr^listobjectr)rrzrs rr __array__z DatetimeLikeArrayMixin.__array__bs+ 5 !88DJf5 5}}rtcyrorritems rr __getitem__z"DatetimeLikeArrayMixin.__getitem__j rtcyrorrs rrrz"DatetimeLikeArrayMixin.__getitem__ns rtctdt| |}tj|r|Stt |}|j ||_|S)z 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 rrrz"DatetimeLikeArrayMixin.__getitem__usR2EG4G4LM == M$'F--c2  rtc:t|jt}|r|j}|S|jdk7rd}|St ||}d}t|t rA|j'|j|j|jz}|S|j}|S|tur|j}|Stj|rStj|jtj}t|t r|j!|S|S)z\ 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 rrrz(DatetimeLikeArrayMixin._get_getitem_freqstzz;7 99D& %YY!^D" &dC0CD#u%99(SXX-A88dii/D  99D yy  $$S)55chhrxx6HIgu-11':: rtcft|||}t| |||ry|jyro)rbr __setitem___maybe_clear_freq)rrrno_oprs rrrz"DatetimeLikeArrayMixin.__setitem__s6&c5$7 C'    rtcyrorrs rrrz(DatetimeLikeArrayMixin._maybe_clear_freqs rtTct|}|tk(r|jjdk(r=t d|}|j }t ||jd|j}|S|jjdk(rt|jdS|j|j jj|jSt|t rt"|I||St'|r|j)S|jd vrO|j }|t*j,k7rt/d |jd |d |r|j1}|S|jd vr|j|k7s|jdk(r&dt3|j4d|}t/|t+j6||S)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 rrrzDatetimeLikeArrayMixin.astypes U# F?zz#%OT2.ww#  ! C'*4==dCC##DIIOO$56>>tzzJ J ~ .7>%d>3 3 U #,,. . ZZ4 YYF &tzzl$ug>CC MjjD TZZ5%8UZZ3=N!d!4!4 5ZwGCC. ::d%0 0rtcyrorrs rrr{zDatetimeLikeArrayMixin.viewrrtcyrorrrzs rrr{zDatetimeLikeArrayMixin.viewrrtcyrorrs rrr{zDatetimeLikeArrayMixin.viewrrtcyrorrs rrr{zDatetimeLikeArrayMixin.viewrrtc"t||Sro)rr{)rrzrs rrr{zDatetimeLikeArrayMixin.viewsw|E""rtct|tr |j|}t||j s|tur%|j|} |j||St|s t |t|t|k7r td |j|d}|j||S#ttf$r t |wxYw#ttf$r}t ||d}~wwxYw#ttf$r.}tt|ddrn t ||Yd}~|Sd}~wwxYw)NzLengths must matchT) allow_objectrz)rystrr ValueErrorrr:rrrrrrCr_validate_listlikerDgetattr)rrerrs rr_validate_comparison_valuez1DatetimeLikeArrayMixin._validate_comparison_value sM eS ! /007 eT55 6%3,%%e,E 8++E2, #e$#E* * Z3t9 $12 2 <//D/I++E2 ; 56 /'.. /45 8'.C7 845 <"75'4#@A+E2;  >DE#D>>E)allow_listlikeunboxct||jrnt|tr |j|}nt||jrt}nmt|r|j ||}t |t||jr|j|}n|j ||}t ||s|S|j|S#t$r#}|j ||}t ||d}~wwxYw)a  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. 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 N) ryrrrr_validation_error_messagerrNrzrrOrr)rrr rr rs rr_validate_scalarz'DatetimeLikeArrayMixin._validate_scalar0s0 eT.. /  s # .007 #5$** 5E %[00GCC. t77 8%%e,E00GCC. L!!%((9 .44UNKn#- .sC D#DDc t|dr t|dddkDr|jd}ndt|jd}|rd|j jd|d}|Sd|j jd |d}|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 rzrrz array'zvalue should be a 'z!', 'NaT', or array of those. Got z instead.z' or 'NaT'. Got )hasattrr rzrrr)rrr msg_gotrs rrrz0DatetimeLikeArrayMixin._validation_error_messagems 5' "wufa'@1'D V,G$u+../q1G %d&7&7&@&@%AB**1)=  &d&7&7&@&@%ABiy*  rtct|t|r9|jjdvr|s|j |j d}|St|t r4t|dk(r&t|jg|jSt|drO|jtk(r>> 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 rrrOzDatetimeLikeArrayMixin.freqstrps!4 99 yy   rtcl|jdk7ry tj|S#t$rYywxYw)ax 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_freqz$DatetimeLikeArrayMixin.inferred_freqs:0 99> ))$/ /  s ' 33cj|j}|y tj|S#t$rYywxYwro)rOrget_reso_from_freqstrKeyError)rrOs rr_resolution_objz&DatetimeLikeArrayMixin._resolution_objs;,, ? 33G< <  s & 22c.|jjS)zO Returns day, hour, minute, second, millisecond or microsecond )rVattrnamers rr resolutionz!DatetimeLikeArrayMixin.resolutions ##,,,rtcJtj|jddS)NTtimelikerr is_monotonicrrs rr_is_monotonic_increasingz/DatetimeLikeArrayMixin._is_monotonic_increasing!!$))d;A>>rtcJtj|jddS)NTr[rr]rs rr_is_monotonic_decreasingz/DatetimeLikeArrayMixin._is_monotonic_decreasingr`rtcvtt|jjd|jk(S)NK)rrVrrsizers rr _is_uniquez!DatetimeLikeArrayMixin._is_uniques(8DIIOOC012dii??rtc|jdkDrXt|dd|jk(r>||j|jj |jS |j |}t|dd}t|r?tj|tj|jt|}|S|tur`|t j"ur'tj$|jt&}|Stj(|jt&}|St+|j,t.st1t2|}|j4|j4k7rWt+|t7|s |j9|j:d}n#|jD}tC|jD||S|jG|}||jDjId|jId}tK|}|jL|z}|jOr)|t j"u} tjP||| |S#t $rt|||cYSwxYw#t<$r9tj>|j@}tC|jD||cYSwxYw)NrrrzrFrrx))rr rrrr r:rdrDrScomp_method_OBJECT_ARRAYrrrrroperatorneonesr<r;ryrzrKr TimelikeOpsrrrrrr^asm8r%rr#r{rOrDrGrK) rrrqrzr other_arr other_valso_maskmask nat_results rr _cmp_methodz"DatetimeLikeArrayMixin._cmp_methods3 99q=WUGT:djjHdjjlEKKM2::4::F F 733E:Ew- 5 !11BJJt{{623UFM C<X[[ 48M$**D9M$**k2 T*D{{ell*!%d4 % dii% H!&I9$--TVWW[[' DMM&&t,jood.CDe{{V# 88:x{{*J JJvtZ 0 ]! 7%dE26 6 76&$&HHUZZ$8 = MM9b s$)I*J*JJ?KK__pow____rpow____mul____rmul__ __truediv__ __rtruediv__ __floordiv__ __rfloordiv____mod____rmod__ __divmod__ __rdivmod__ct|tr|j}d}||fSt|ttfr|j }d}||fS|j }|j}||fS)zN Get the int64 values and b_mask to pass to add_overflowsafe. N)ryrordinalrrr}rDr)rri8valuesrqs rr_get_i8_values_and_maskz.DatetimeLikeArrayMixin._get_i8_values_and_masksq eV $}}HD~ 95 6||HD ~<&!$))RZZ-MN[[3tyyk!34 uxxdii8[[3tyyk!34 33E:(}((5xPPrtctj|jds7tdt |j dt |j ||zS)Nrrr)rrrzrrrrs rr_add_datetime_arraylikez.DatetimeLikeArrayMixin._add_datetime_arraylike\sStzz3/d4j112%U 8L8L7MN  t|rtc|jjdk7r!tdt|jt d|}t |r |tz St|}|j|\}}|j|S)Nr"cannot subtract a datelike from a rk) rzrrrrr rOrrr_sub_datetimelike)rrtss rr_sub_datetimelike_scalarz/DatetimeLikeArrayMixin._sub_datetimelike_scalarfs ::??c !@dATAT@UVW WOT* ;#:  u ..r2b%%b))rtc|jjdk7r!tdt|jt |t |k7r t dtd|}|j|\}}|j|S)Nrr$cannot add indices of unequal lengthrk) rzrrrrrrr rrrs rr_sub_datetime_arraylikez.DatetimeLikeArrayMixin._sub_datetime_arraylikeys} ::??c !@dATAT@UVW W t9E "CD DOT*11%8 e%%e,,rtctd|}ddlm} |j||j|\}}t|jtj| d}|jd|jd }|j|} td | } |j ||j"| S#t$r2}t |j dd}t|||d}~wwxYw) Nrkrrmcomparesubtractrxr timedelta64[rz Tick | Noner)r rrm_assert_tzawareness_compatrrreplacerrrrrrr{rrrrz) rrrmr  new_messagerrprres_m8rs rrrz(DatetimeLikeArrayMixin._sub_datetimelikesOT*5 2  + +E 2  77>&%diiXIT1RS < {!!<=33E: x0)~))& 8TT 2c(**9jAK$s)K(c 1 2sC C; -C66C;c,tj|jds!tdt |j ddlm}tj|j|j}t|j}|||}||zS)Nrzcannot add Period to a r)rlr)rrrzrrrpandas.core.arrays.periodrlr broadcast_torrrKr)rrrli8valsrzparrs rr _add_periodz"DatetimeLikeArrayMixin._add_periodsstzz3/5d4j6I6I5JKL L : ;EJJ'6/d{rtct|ror)roffsets rr _add_offsetz"DatetimeLikeArrayMixin._add_offsets !$''rtct|rtj|jdj |j j }|jtt|j||j Std|}t|}|j|\}}|j|S)zk Add a delta of a timedeltalike Returns ------- Same type as self rxrr:)rOremptyrr{rrzfillrrrr rr_add_timedeltalike)rr new_valuess rr_add_timedeltalike_scalarz0DatetimeLikeArrayMixin._add_timedeltalike_scalars ;$**D9>>t}}?R?RSJ OOD !:))*DJJ)G G4d;% 11%8 e&&u--rtct|t|k7r tdtd|}|j|\}}|j |S)zl Add a delta of a TimedeltaIndex Returns ------- Same type as self rr:)rrr rrrs rr_add_timedelta_arraylikez/DatetimeLikeArrayMixin._add_timedelta_arraylikesR t9E "CD D4d;11%8 e&&u--rtcRtd|}|j|\}}t|jt j |d}|j |jj}|j|}t|j||j|S)Nr:rxrr) r rrrrrr{rrzrrr)rrrrprrrs rrrz)DatetimeLikeArrayMixin._add_timedeltalikes4d;77>&%diiHD1QR __T]]%8%89 33E: Dz%% djjx&  rtct|jtr;tdt |j dt t j td|}tj|jtj}|jt|j|jj}t |j!||jdS)z$ Add pd.NaT to self z Cannot add rzTimedeltaArray | DatetimeArrayrNr)ryrzrKrrrrr rrrrrrr{rrrrs rr_add_natzDatetimeLikeArrayMixin._add_nats djj+ .d4j112%S 8J8J7KL 4d;$**BHH5 DT]]001Dz%% $**4&  rtc2tj|jtj}|j t |j jdvr+td|}|jd|jdS|jdS)z+ Subtract pd.NaT from self rrzDatetimeArray| TimedeltaArrayrrztimedelta64[ns]) rrrrrrrzrr r{rrs rr_sub_natzDatetimeLikeArrayMixin._sub_natsq$**BHH5 D ::??d "7>D;;dii[:; ;;;01 1rtc.t|jts7tdt |j dt |j t d|}|j||j|\}}t|jtj| d}tj|Dcgc]}|jj|zc}}| |j }n|j |z}t"||<|Scc}w)Ncannot subtract  from rlrxr)ryrzrKrrrr rrrrrrr^rbaserDr)rrrrp new_i8_datarnew_datarqs rr_sub_periodlikez&DatetimeLikeArrayMixin._sub_periodlike s$**k2"4;#7#7"8tDz?R?R>ST M4( ##E*77>&&tyy"**hYd2ST 88EATYY^^a/EF >;;D;;'DFs Dc|tjtjfvsJt|dk(r|jdk(r |||dSt j dt|jdtt|j|jk(sJ|j|jf||jdtj|}|S)aZ 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.r8O)riaddsubrrr>r?rrr;r?rrrr)rrrqrs rr_addsub_object_arrayz+DatetimeLikeArrayMixin._addsub_object_array%s hllHLL1111 u:?tyyA~dE!H% % 7Dz""##3 5 ')  zzU[[(C4::u{{*CC( C("**U*;< rtr4c |dvrtd|dt|tt|}||j fd|i|}t|j ||j S)N>cummaxcumminz Accumulation z not supported for r5r)rrr rWrrrz)rnamer5rrqrs rr _accumulatez"DatetimeLikeArrayMixin._accumulateIsm + +mD61DT$ZLQR R / 6DIIK99&9Dz%%fDJJ%??rt__add__ct|dd}t|}|tur|j}nUt |t t tjfr|j|}nt |tr|j|}nt |ttjfr|j|}nt |tr3t!j"|j$dr|j'|}nt!j(|rjt |j$t*s t-|t/d|}|j1||j$j2zt4j6}nt!j"|dr|j9|}nt;|r!|j=|t4j6}nt!j"|dst |t>r|jA|StC|rit |j$t*s t-|t/d|}|j1||j$j2zt4j6}ntDSt |tjFr8t!j"|j$drddl$m%}|jL|S|S)Nrzrrlrrr)'r r_rrryrrrr.rrrrr/rrrrrzr is_integerrKr'r _addsub_int_array_or_scalar_nrirrrDrrIrrBNotImplementedndarrayrrmrrr other_dtyperobjrms rrrzDatetimeLikeArrayMixin.__add__RseWd3 .u5 C<]]_F i@ A33E:F z *%%e,F "--8 92259F v &3??4::s+K%%e,F ^^E "djj+6.t44}d+C44USYY\\5I8<<XF__[# .2259F [ )..uhllCF __[# .* 3 //6 6 k *djj+6.t44}d+C44USYY\\5I8<<XF" ! fbjj )coofllC.P 90>008 8 rtc$|j|Sro)rrs rr__radd__zDatetimeLikeArrayMixin.__radd__s||E""rt__sub__ct|dd}t|}|tur|j}n\t |t t tjfr|j| }n#t |tr|j| }nt |ttjfr|j|}ntj |rjt |j"t$s t'|t)d|}|j+||j"j,zt.j0}nMt |t2r|j5|}n*tj6|dr|j9| }nt;|r!|j=|t.j0}ntj6|dst |t>r|jA|}nt |t$r|j5|}nztC|rit |j"t$s t'|t)d|}|j+||j"j,zt.j0}ntDSt |tjFr8tj6|j"drddl$m%}|jL|S|S)Nrzrlrrrr)'r r_rrryrrrr.rrrrr/rrrrzrKr'r rrrirrrrrrDrrIrrBrrrrmrrs rrrzDatetimeLikeArrayMixin.__sub__seWd3 .u5 C<]]_F i@ A33UF;F z *%%uf-F "--8 92259F ^^E "djj+6.t44}d+C44USYY\\5I8<<XF v &))%0F__[# .22E6:F [ )..uhllCF __[# .* 3 11%8F  [ 1))%0F k *djj+6.t44}d+C44USYY\\5I8<<XF" ! fbjj )coofllC.P 90>008 8 rtc8t|dd}tj|dxst|t}|rptj|j drPtj |rt||z St|tsddl m }|j|}||z S|j jdk(rEt|dr9|s7tdt|j dt|j t|j t"rDtj|dr.tdt|j d|j tj|j drt%d|}| |zS||z S) Nrzrrrrrrrm)r rrryrIrzrrrrrkrrrrrrrKr )rrr other_is_dt64rks rr__rsub__zDatetimeLikeArrayMixin.__rsub__s^eWd3  S9 Z >  S__TZZ=}}U# '$..e%;<<4 44U;4<  ZZ__ #w(? "4:#6#6"7vd5k>R>R=ST  K 0S__[RU5V.tDz/B/B.C6%++WX X __TZZ -($/DEU? "rtcv||z}|dd|ddt|jts|j|_|SroryrzrKrrrrrs rr__iadd__zDatetimeLikeArrayMixin.__iadd__6)Q$**k2DJ rtcv||z }|dd|ddt|jts|j|_|Srorrs rr__isub__zDatetimeLikeArrayMixin.__isub__rrtc&t|||S)N)qs interpolation)r _quantile)rrrrs rrrz DatetimeLikeArrayMixin._quantiles w Bm DDrtaxisr5c tjd|tj||jt j |j ||}|j||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. rr)nv validate_minvalidate_minmax_axisrrRnanminr_wrap_reduction_resultrrr5rrs rrminzDatetimeLikeArrayMixin.minO F# dii0t}}4G**488rtc tjd|tj||jt j |j ||}|j||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. rr)r validate_maxrrrRnanmaxrrrs rrmaxzDatetimeLikeArrayMixin.maxrrtr)r5rct|jtr"tdt |j dt j|j|||j}|j||S)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()rr5rq) ryrzrKrrrrRnanmeanrrOr)rr5rrs rrmeanzDatetimeLikeArrayMixin.mean)suX djj+ ..tDz/B/B.CD77   MMV$))+ **488rtc tjd||#t||jk\r t dt j |j||}|j||S)Nrz abs(axis) must be less than ndimr) rvalidate_medianabsrrrR nanmedianrrrs rrmedianzDatetimeLikeArrayMixin.medianbs^ 2v&  D TYY 6?@ @!!$--d6J**488rtcd}|r|j}tj|jd|}|j|jj }t tj|}|j|S)Nrx)rq) rOrPmoder{rrzr rrr~)rdropnarqi8modesnpmodess rr_modezDatetimeLikeArrayMixin._modelsf 99;D//$))D/=,,t}}223rzz7+&&w//rtc |j}|jdk(rC|dvrtd|d|dvrtjd|d|dt t nft|trC|dvrtd |d|dvr?tjd|d |dt t n|d vrtd |d|jjd}ddl m } | j|} | || |} | j|f|||dd|} | j| j vr| S| jdk(sJ|dvrvddlm} t|jtr tdt'd|}d|j(d}| j|} | j*| | jS| j|jj} |j-| S)Nr)sumprodcumsumcumprodvarskewz!datetime64 type does not support z operations)rGallrzh' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).z () instead.r8zPeriod type does not support ze' with PeriodDtype is deprecated and will raise in a future version. Use (obj != pd.Period(0, freq)).)rrrrz"timedelta64 type does not support rwr)WrappedCythonOp)howrhas_dropped_na) min_countngroupscomp_idsrq)stdsemrz-'std' and 'sem' are not valid for PeriodDtyper:zm8[rr)rzrrr>r?r@r?ryrKrr{pandas.core.groupby.opsrget_kind_from_how_cython_op_ndim_compatrcast_blocklistrrmr rrr~)rrrrridsrrznpvaluesrrrqrrm new_dtypes rr _groupby_opz"DatetimeLikeArrayMixin._groupby_opys  :: II"CC5 TUUn$ uDDG5 U!/1 { +II"?uK PQQn$ uGGJe;X!/1 88"DSE UVV==%%h/;005 4 O.R..       66R&& & 8+++ . 9$**k2 OPP8$?Ddii[*I#3J->--j @P@PQ Q__T]]%8%89 &&z22rtreturnr<)NNF)rz Dtype | Nonerr<r&None)r&ztype[DatetimeLikeScalar])rrr& DTScalarOrNaT)rr)r&z)np.int64 | np.datetime64 | np.timedelta64)rr)r&r(r&r)r&rg)r&znpt.NDArray[np.int64])rz str | floatr&npt.NDArray[np.object_])F)rr<)NN)rzzNpDtype | Nonerz bool | Noner&r)rr2r&r))rz(SequenceIndexer | PositionalIndexerTupler&r3)rr0r&zSelf | DTScalarOrNaT)r&r)rz,int | Sequence[int] | Sequence[bool] | slicerzNaTType | Any | Sequence[Any]r&r(r&r(T)rr<r&r3)rzzLiteral['M8[ns]']r&rk)rzzLiteral['m8[ns]']r&rm).)rzr'r&r(ro)r r<rr<)r r<r&r)rr<)r&z6np.int64 | np.datetime64 | np.timedelta64 | np.ndarray)rr(r&npt.NDArray[np.bool_])r&r/)rrr&r)r&z str | None)r&zResolution | Noner&r)r&z@tuple[int | npt.NDArray[np.int64], None | npt.NDArray[np.bool_]])r&rk)rrkr&rk)rzdatetime | np.datetime64r&rm)rrkr&rm)rzTimestamp | DatetimeArrayr&rm)rrr&rl)rrm)rzTimedelta | TimedeltaArray)rzPeriod | PeriodArrayr&r+)rr+)rrr5r<r&r3)rznpt.NDArray[np.float64]rrr&r3)rAxisInt | Noner5r<)r5r<rr1)r r<) rrrr<rintrr2r!znpt.NDArray[np.intp])`r __module__ __qualname____doc____annotations__r>rrpropertyrrrrr|rrrrrrrrrrrrr{r rrr r$r r#rZr+rTrOrDrHrrMrOrRrVrYr_rbrfrsrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrcrrrrrrrrrrrrr r$ __classcell__rs@rrrrs$#44)) IN('(AE( ( ((((("( 2(.(,( D :  ( ( (-$ ($ (  (AE#2=    6    "<! 9!-!  !, 11f        #"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"M3rtrc0eZdZdZedddZy) DatelikeOpszK Common ops for DatetimeIndex/PeriodIndex, but not TimedeltaIndex. zNhttps://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior)URLcr|j|tj}|jtdS)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)rrrJrr)rrrs rrstrftimezDatelikeOps.strftimes1b**{266*R}}V%}00rtN)rrr&r+)rr3r4r5r=r>rrtrrr;r;s% *.1 .1rtr;aO 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) ceZdZUdZded<dej df d&dZedZ e dZ e jd'd Z e d(d Ze ed)d Ze d*d Zed+d Zed,dZd-d.dZdZd/fd ZdZeeezj7d d0 d1dZeeezj7d d0 d1dZeeezj7d d0 d1dZ dddd2dZ!dddd2dZ"d'dZ#d3dZ$d4fd Z% d5 d6fd! Z&e d7 d8fd" Z'd9d:fd# Z( d;d$Z)e d| |j}n/|r-|jr!t!|}t#||j}|*||j$k7rt'd|d |j$|j$}|j(}n|t|t*j,r%|j$j.d vr |j$}nF|j0}t|t*j,r |j$d k(r|j3|}t|t*j,s8t5d t|jd t|jd|j6dvr t5d|j$d k(r|(|j0}|j3|j0}nqtj8|dr|j3|}nIt|t:r9|j0j.}|d|j<d}|j3|}|j?||}|dk(r"t5dt|jd|r|jA}|r?t!|}|j$j.dk(rt|tBs t'dtEjF|||||_$||t|jK||yyy)NzV.__init__ is deprecated and will be removed in a future version. Use pd.array instead.r8Trrna_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?rrr@r?rFr`ryr]r)rr r no_defaultrr"_validate_inferred_freqrzrrrrrr@r{rrrrIr_validate_dtyperrrrr_validate_frequency) rrrzrrrR explicit_nonerr#s rrrzTimelikeOps.__init__s9  Dz""#$A A ')     'EvT: fl +__Wt_>1tt fd4j ){{&++ .tV[[A Ufll%:UG#>v||nMLLE__F ]&"**-&,,2C2Ct2K ++fbjj1flld6J#[[/F&"**-#DL$9$9#::P:&&'(++  ;;f $MN N <<4 }++T%8%89-U+E?3**//#fBuzzl!4 Y/$$VU3 7?5d4j6I6I5JK,,  [[]F T?D||  C' 40F JKKtF%@  T%5 J * *4 6&6 rtct|ror)clsrrzs rrrLzTimelikeOps._validate_dtypes !#&&rtc|jS)zK Return the frequency object if it is set, otherwise None. rrs rrrzTimelikeOps.freqs zzrtc|kt|}|j|||jjdk(rt |t s t d|jdkDr td||_ y)NrrIrzCannot set freq with ndim > 1) r"rMrzrryrrrrrrs rrrzTimelikeOps.freqse  e$E  $ $T5 1zz#%j.E JKKyy1} !@AA rtcR|d|_y|dk(r(|jt|j|_yy|tjury|j0t|}t |j ||fi|||_yt|}t||jy)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. NrH)rr"rRrrJrrMrK)rr validate_kwdss rr_maybe_pin_freqzTimelikeOps._maybe_pin_freqs <DJ W_zz!'t'9'9: "S^^ #  ZZ T?D *DJ * *4 G GDJT?D #D$** 5rtc |j}|jdk(s||jk(ry |jd|ddt |||j d|}t j|j|jsty#t$r0}dt|vr|td|d|j|d}~wwxYw)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 rN)startendperiodsrrz non-fixedInferred frequency 9 from passed values does not conform to passed frequency r) rRrerO_generate_rangerrr array_equalrrr)rPindexrrrBon_freqr s rrrMzTimelikeOps._validate_frequency0s&& ::?h$,,6 )c))AhE ZZ   G>>%**gll;  < c#h& %hZ088< ~G  sAB C+CCct|ror)rPrXrYrZrrrs rrr]zTimelikeOps._generate_range\s"#&&rtc@t|jjSro)rrrzrs rrrzTimelikeOps._cresods"4==#6#677rtc,t|jSro) dtype_to_unitrzrs rrrzTimelikeOps.uniths TZZ((rtTc|dvr tdtj|jjd|d}t |j ||}t |jtjr |j}n#td|j}t||}t|j|||jS) N)smsusnsz)Supported units are 's', 'ms', 'us', 'ns'rGrrrkrr) rrrzrrrryr rrIrrr)rrrrzrr#rs rrrzTimelikeOps.as_unitos . .HI IDJJOO,BtfA67(Q djj"(( +"((Iot,//B'2D9IDz%% idii&  rtc|j|jk7rS|j|jkr|j|j}||fS|j|j}||fSro)rrrrs rrrz"TimelikeOps._ensure_matching_resoss^ ;;%,, &{{U\\)||EJJ/U{ dii0U{rtc|tjtjtjfvr2t |dk(r$|d|urt |||j fi|St| ||g|i|S)Nrr) risnanisinfisfiniterr rr__array_ufunc__)rufuncmethodinputsrrs rrrozTimelikeOps.__array_ufunc__sq bhh"++6 6F q q T!*75&)$--B6B Bw&ufHvHHHrtcLt|jtrOtd|}|j d}|j ||||}|j |j ||S|jd}ttj|}t||j}|dk(r|jSt|||} |j| t}|j|j j}|j#||jS)Nrk) ambiguous nonexistentrxrrLr)ryrzrIr tz_localize_roundrr{rrr&rrr$rMrrr) rrrrtrunaiverrnanos result_i8s rrrxzTimelikeOps._rounds djj/ 2.D$$T*E\\$iEF%%9+& 4bjj&)"45 A:99; !&$6 ))))ET]]001djj99rtround)rqcF|j|tj||Sro)rxr#NEAREST_HALF_EVENrrrtrus rrr|zTimelikeOps.rounds{{4!:!:I{SSrtfloorcF|j|tj||Sro)rxr# MINUS_INFTYrs rrrzTimelikeOps.floors{{4!4!4iMMrtceilcF|j|tj||Sro)rxr# PLUS_INFTYrs rrrzTimelikeOps.ceils{{4!3!3Y LLrtrcdtj|j|||jSNr)rRnananyrrOrrr5s rrrGzTimelikeOps.anys!}}T]]f499;WWrtcdtj|j|||jSr)rRnanallrrOrs rrrzTimelikeOps.alls#}}T]]f499;WWrtcd|_yrorRrs rrrzTimelikeOps._maybe_clear_freqs  rtc|nnt|dk(rDt|tr4|jjdk(r7t|t s't d|dk(sJt|j}|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 rrrIrH) rryrrzrrrr"rRr{r)rrrs rr _with_freqzTimelikeOps._with_freqsz <  Y!^ 4 <zz#%jt.D JKK7? "?T//0Diik  rtct|jtjr |jSt|Sro)ryrzrrr_values_for_json)rrs rrrzTimelikeOps._values_for_jsons- djj"(( +== w'))rtc^|jmtjt|tj}|j }|r)|jj dkr|ddd}|ddd}||fS|r"tdt|jdt|-|S)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) rrarangerintprrNotImplementedErrorrrr factorize)rrsortcodesuniquesrs rrrzTimelikeOps.factorize s 99 IIc$irww7EiikG add !$B$-'> ! &(d)<)<(=>==  w  AArtc0t|||}|d|dk(rt|Dcgc]}t|s|}}jMt fd|Dr9t |dd|dd}t fd|Drj}||_|Scc}w)Nrc3PK|]}|jjk(ywror)rrrs rrrz0TimelikeOps._concat_same_type..* s+R1AFFchh,>+Rs#&rrc3ZK|]"}|ddjz|ddk($yw)rrrNr)rpairrs rrrz0TimelikeOps._concat_same_type.., s/NtAwr{SXX-a;Ns(+)r_concat_same_typerrrzipr) rP to_concatrnew_objrpairsrrrs @rrrzTimelikeOps._concat_same_type s '+It<l 19%.8qQ8I8xx#+R +R(RIcrNIabM:NNN"xxH$,GM9s BBcJt||}|j|_|S)N)order)rrrr)rrrrs rrrzTimelikeOps.copy1 s#',U,+  rtc |dk7rt|s |j} n|jj} tj| f||||||d||s|St |j | |jS)z2 See NDFrame.interpolate.__doc__. linear)rqrr_limitlimit_direction limit_arear)rrrrQinterpolate_2d_inplacerrrz) rrqrr_rrrrrout_datas rr interpolatezTimelikeOps.interpolate6 s X % %}}H}}))+H&&  +!  KDz%%hdjj%AArtc tj|jsy|j}|tk7}t |j}t |}tj|||zdk7jdk(}|S)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_andr)r values_intconsider_valuesrppd even_dayss rr_is_dates_onlyzTimelikeOps._is_dates_only_ sstzz*YY $,"4::.d#NN?J4D4IJNNPTUU rt)rr<r&r(r,)rUdict)rr)rZ int | Noner&r3)r&r2r0r-)rrrr<r&r3)rpznp.ufuncrqr)raiser)rtr5rur6r&r3)rr1r5r<r&r<r.r*)TF)rr<rr<)r)rzSequence[Self]rr)r&r3)C)rrr&r3) rqr.rr2r_rjrr<r&r3r%),rr3r4r5r6rrJr classmethodrLr7rsetterr rVrMr]r>rrrrrorxr< _round_doc_round_examplerr|_floor_exampler _ceil_examplerrGrrrrrrrrrr8r9s@rrrlrls!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@*!%BBB0!  * $B#$B $B  $B$B $BRrtrlct|dsGt|ttfs#t j |dk(r t|}t |}d}n,t|trtd|dt|d}t|ts(t|tr5|jjdvr|jd t }d}||fSt|tr&|j!}|j}d}||fSt|tj"t$fst j&|}||fSt|t(r7|j*j-|j.t0 j2}d}||fS) NrzrFzCannot create a z from a MultiIndex.TrrrrBrv)rryrtuplerrr@rMrr`r]r[rzrr)r_maybe_convert_datelike_arrayrr\rrLr takerr_values)rrcls_names rr!ensure_arraylike_for_datetimelikery s\ 4 !$u .2774=A3E:D6t< D- (*8*4GHIIT6$ %4,-$**//T2I}}Wt}4 : D- .113}} :rzz>: ;zz$ : D. )##DJJ3#?GG :rtcyrorrZs rrvalidate_periodsr rtcyrorrs rrrr rrtc|itj|r1tjdtt t |}|Stj|std||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 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.r8zperiods must be a number, got ) ris_floatr>r?r@r?r2rrrs rrrr sj$ << MM2+-  'lG N(numpyr pandas._libsrrpandas._libs.arraysrpandas._libs.tslibsrrrrrrrrrrrrrrr r!r"pandas._libs.tslibs.fieldsr#r$pandas._libs.tslibs.np_datetimer%pandas._libs.tslibs.timedeltasr&pandas._libs.tslibs.timestampsr'pandas._typingr(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7pandas.compat.numpyr8r pandas.errorsr9r:r;pandas.util._decoratorsr<r=r>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^rr_r`pandas.core.indexersrarbpandas.core.ops.commonrcpandas.core.ops.invalidrdrepandas.tseriesrfcollections.abcrgrhr(rjrrkrlrmr)rsrrr;rrrrrlrrrKrdrrtrrrs"   .&K=C$/  5K   ?*?23  < '  ('12 1 6B3 )B3J071(71t= ~66 8^(^J$$ #$$N    D ,=:&rt