iaddlmZddlmZmZddlmZddlZddlmZm Z m Z m Z m Z m Z mZmZddlZddlZddlmZddlmZmZddlmZdd lmZmZmZmZmZm Z m!Z!m"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/m0Z0dd l1m2Z2dd l3m4Z4ddl5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEddlFmGZHddlImJZJmKZKmLZLddlMmNZNmOZOmPZPddlQmRZRddlSmTZTddlUmVZVmWZWmXZXmYZYmZZZm[Z[ddl\m]Z]m^Z^m_Z_m`Z`maZaddlbmcZcmdZdddlemfZfmgZgddlhmiZimjZjmkZkmlZlddlmmnZnmoZompZpddlqmrZrddlsmtZtddlumvZvmwZwddlxmyZyddlzm{Z{ddl|m}Z}ddl~mcmZdd lmZmZmZdd!lmZmZdd"lmZdd#lmZmZdd$lmZerdd%lmZmZdd&lmZdd'lmZmZmZe e8efZdNd*ZdOd.ZGd/d0etevZGd1d2eZd3Zd4Zd5Zd6ZGd7d8eZdPd=ZedQd@ZedRdCZdSdFZdTdJZdUdMZdS)V) annotations)datetime timedelta)wrapsN) TYPE_CHECKINGAnyCallableLiteralUnioncastfinaloverload)using_string_dtype)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 PeriodArrayTimedeltaArrayop_namestrcPt|}t||SN)rfrd)roops W/srv/django_bis/venv311/lib/python3.11/site-packages/pandas/core/arrays/datetimelike.py_make_unpacked_invalid_oprus(  ! !B , #G , ,R 0 00methr.returncbtfd}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. cdt|jts |g|Ri|S|d}|g|Ri|}|turtSt|t r||jS|d}||S)NM8[ns]i8) isinstancedtyperLviewrr _box_func_value_from_backing_data)selfargskwargsarrresultres_i8rws rtnew_methz"_period_dispatch..new_meths$*k22 /4.t...v.. .ii!!c+D+++F++ S==J  * * 1>>&-00 0T""&&v...rv)rr r.)rwrs` rt_period_dispatchrs@ 4[[ / / / /[ / 8  rvceZdZUdZded<ded<ded<ded <d ed <eddZ dddZeddZ ddZ ddZ ddZ d Z dd!Zdd#Zedd%Zd&dd'dd+Zddd-Z ddd0Zedd3Zedd6Zdˆfd: Zdd;ZdĈfd> Zdd?ZddLjfdA ZeddBZeddEZeddHZedddKZdd̈fdL ZdMZdd@dNddQZdddRZdddTZdUZe ddWZ!e"ddXZ#dd[Z$dd\Z%edd]Z&edd^Z'e(dfdd`Z)eddbZ*eddcZ+eddeZ,eddfZ-eddgZ.eddhZ/eddiZ0djZ1e2dkZ3e2dlZ4e2dmZ5e2dnZ6e2doZ7e2dpZ8e2dqZ9e2drZ:e2dsZ;e2dtZ<e2duZ=e2dvZ>e ddxZ?e ddyZ@e ddzZAe dd{ZBe dd}ZCe dd~ZDe ddZEe ddZFdZGdZHddZIe ddZJe dZKe dZLe ddZMe ddZNd@dddZOePddZQdZRePddZSdZTddZUddZVeWdfd ZXeWdd@dddZYeWdd@dddZZd@ddddZ[eWdd@dddZ\dddZ]ddZ^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 | NonefreqrxboolcdS)NTrs rt _can_hold_naz#DatetimeLikeArrayMixin._can_hold_nastrvNFr~ Dtype | NonecopyNonec t|rrr:)rdatar~rrs rt__init__zDatetimeLikeArrayMixin.__init__s"$'''rvtype[DatetimeLikeScalar]c t|)z The scalar associated with this datelike * PeriodArray : Period * DatetimeArray : Timestamp * TimedeltaArray : Timedelta rrs rt _scalar_typez#DatetimeLikeArrayMixin._scalar_types"$'''rvvaluerp DTScalarOrNaTc t|)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. rrrs rt_scalar_from_stringz*DatetimeLikeArrayMixin._scalar_from_string$"$'''rv)np.int64 | np.datetime64 | np.timedelta64c t|)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 rt _unbox_scalarz$DatetimeLikeArrayMixin._unbox_scalars*"$'''rvotherc t|)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 rrrs rt_check_compatible_withz-DatetimeLikeArrayMixin._check_compatible_withrrvc t|)zI box function to get object from internal representation r)rxs rtrz DatetimeLikeArrayMixin._box_func/s"$'''rvc:tj||jdS)z1 apply box func to passed values F)convert)r map_inferr)rvaluess rt _box_valuesz"DatetimeLikeArrayMixin._box_values5s}VT^UCCCCrvrhcjdkr(fdttDSfdjDS)Nc3(K|] }|V dSrrr).0nrs rt z2DatetimeLikeArrayMixin.__iter__..=s'66DG666666rvc3BK|]}|VdSrr)r)rvrs rtrz2DatetimeLikeArrayMixin.__iter__..?s/99!DNN1%%999999rv)ndimrangelenasi8rs`rt__iter__zDatetimeLikeArrayMixin.__iter__;sR 9q==6666U3t99%5%5666 69999ty999 9rvnpt.NDArray[np.int64]c6|jdS)z Integer representation of the values. Returns ------- ndarray An ndarray with int64 dtype. r|)rrrs rtrzDatetimeLikeArrayMixin.asi8As}!!$'''rvr)na_rep date_formatr str | floatnpt.NDArray[np.object_]c t|)z| Helper method for astype when converting to strings. Returns ------- ndarray[str] r)rrrs rt_format_native_typesz+DatetimeLikeArrayMixin._format_native_typesQs"$'''rvboxedcdjS)Nz'{}')format)rrs rt _formatterz!DatetimeLikeArrayMixin._formatter]s }rvNpDtype | None bool | Nonect|rT|dur(tjdtt t jt|tS|durt j|j |S|j S)NFaSStarting with NumPy 2.0, the behavior of the 'copy' keyword has changed and passing 'copy=False' raises an error when returning a zero-copy NumPy array is not possible. pandas will follow this behavior starting with pandas 3.0. This conversion to NumPy requires a copy, but 'copy=False' was passed. Consider using 'np.asarray(..)' instead. stacklevelr~T) rEwarningswarn FutureWarningr@npr_listobjectr)rr~rs rt __array__z DatetimeLikeArrayMixin.__array__ds 5 ! ! 6u}} 0 "/11    8DJJf555 5 4<<8DM777 7}rvitemr3cdSrrrrrs rt __getitem__z"DatetimeLikeArrayMixin.__getitem__{ rv(SequenceIndexer | PositionalIndexerTupler4cdSrrrrs rtrz"DatetimeLikeArrayMixin.__getitem__s rvkeyr1Self | DTScalarOrNaTctdt|}tj|r|Stt |}|||_|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_scalarr4_get_getitem_freq_freq)rrr __class__s rtrz"DatetimeLikeArrayMixin.__getitem__si2EGG4G4G4L4LMM =  (M$''F--c22  rvct|jt}|r|j}n|jdkrd}nt ||}d}t|t r&|j|j|j|jz}n|j}n|tur|j}notj |r[tj | tj}t|t r||S|S)z\ Find the `freq` attribute to assign to the result of a __getitem__ lookup. rN)r}r~rLrrrbslicestepEllipsiscomis_bool_indexerrmaybe_booleans_to_slicerruint8r)rr is_periodrnew_keys rtrz(DatetimeLikeArrayMixin._get_getitem_freqstz;77  ;9DD Y!^^DD%dC00CD#u%% ;9(SX-A8di/DD9DDy$S)) ;5chhrx6H6HIIgu--;11'::: rv,int | Sequence[int] | Sequence[bool] | sliceNaTType | Any | Sequence[Any]ct|||}t|||rdS|dSrr)rcr __setitem___maybe_clear_freq)rrrno_oprs rtrz"DatetimeLikeArrayMixin.__setitem__sW&c5$77 C'''   F      rvcdSrrrrs rtrz(DatetimeLikeArrayMixin._maybe_clear_freqs  rvTcht|}|tkr|jjdkr6t d|}|j}t ||jd|j}|S|jjdkrt|j dS| |j  |jSt|rpt!|t"rG||j}|}|||d S|St!|t"r#t-|| S|jd vrJ|j}|t0jkrt5d |jd|d|r|}|S|jdvr |j|ks |jdkr)dt9|jd|}t5|t1j||S)NMrl timestamp)tzboxresomT)r)rF)r~rriuzConverting from z to z? is not supported. Do obj.astype('int64').astype(dtype) insteadmMfz Cannot cast z to dtype r)rGrr~kindr rr r_cresor!rrravelreshapeshaperFr}rKrna_valueconstruct_array_type_from_sequencerastyperint64 TypeErrorrtype__name__asarray) rr~ri8data converted arr_objectclsrmsgrs rtrzDatetimeLikeArrayMixin.astypesH U## F??z#%%OT22.w#  ! C''*4=dCCCC##DIOO$5$566>>tzJJ J U # # 1%00 3!66en6MM 0022))*E)NNN00222 ~ . . 177>>%d>33 3 Z4  YF  CtzCCuCCC  'MjD  TZ5%8%8UZ3=N=NHd!4GGGGCC.. :d%000 0rvcdSrrrrs rtrzDatetimeLikeArrayMixin.view rrvLiteral['M8[ns]']rlcdSrrrrr~s rtrzDatetimeLikeArrayMixin.view rrvLiteral['m8[ns]']rncdSrrrrs rtrzDatetimeLikeArrayMixin.viewrrv.r)cdSrrrrs rtrzDatetimeLikeArrayMixin.viewrrvcFt|Srr)rr)rr~rs rtrzDatetimeLikeArrayMixin.viewsww||E"""rvct|tr; ||}n$#ttf$rt |wxYwt||js |turU||} | |n#ttf$r}t ||d}~wwxYwt|st |t|t|krtd | |d}| |nM#ttf$r9}tt|ddrnt ||Yd}~nd}~wwxYw|S)NzLengths must matchT) allow_objectr~)r}rpr ValueErrorrr;rrrrrrDr_validate_listlikerEgetattr)rrerrs rt_validate_comparison_valuez1DatetimeLikeArrayMixin._validate_comparison_value#s eS ! ! / /0077 56 / / /'... / eT5 6 6 <%3,,%%e,,E 8++E222245 8 8 8'..C7 8e$$ <#E** * ZZ3t99 $ $122 2 <//D/II++E222245 < < <"75'4#@#@AA<+E22;DDDD < s9-!ABC,B<<C,D??F /FF )allow_listlikeunboxr*r+clt||jrnt|trO ||}n#t$r+}|||}t ||d}~wwxYwt||jrt}nt|r%|||}t |t||j r||}n%|||}t ||s|S| |S)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) r}rrprr%_validation_error_messagerrOr~rrPrr)rrr*r+r(rs rt_validate_scalarz'DatetimeLikeArrayMixin._validate_scalarGsJ0 eT. / / !  s # # ! .0077 . . .44UNKKnn#- .#5$* 5 5 !EE %[[ !00GGCC.. t7 8 8 !%%e,,EE00GGCC..  L!!%(((sA A9&A44A9ct|dr t|dddkr |jd}ndt|jd}|rd|jjd|d}nd|jjd |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 r~rrz array'zvalue should be a 'z!', 'NaT', or array of those. Got z instead.z' or 'NaT'. Got )hasattrr'r~rrr)rrr*msg_gotrs rtr-z0DatetimeLikeArrayMixin._validation_error_messages 5' " " 2wufa'@'@1'D'D,,,GG1$u++.111G  =d&7&@==*1=== C *d&7&@*****  rvr$c8t|t|r.|jjdvr|s||jd}|St|t 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 rtrhzDatetimeLikeArrayMixin.freqstrs4 9 4y  rvch|jdkrdS tj|S#t$rYdSwxYw)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)rrg infer_freqr%rs rt inferred_freqz$DatetimeLikeArrayMixin.inferred_freqsL0 9>>4 )$// /   44 s # 11Resolution | Nonecd|j}|dS tj|S#t$rYdSwxYwrr)rhrget_reso_from_freqstrKeyError)rrhs rt_resolution_objz&DatetimeLikeArrayMixin._resolution_objsK, ?4 3G<< <   44 s ! //c|jjS)zO Returns day, hour, minute, second, millisecond or microsecond )rpattrnamers rt resolutionz!DatetimeLikeArrayMixin.resolutions #,,rvcDtj|jddS)NTtimelikerr is_monotonicrrs rt_is_monotonic_increasingz/DatetimeLikeArrayMixin._is_monotonic_increasing!$)d;;;A>>rvcDtj|jddS)NTrurrwrs rt_is_monotonic_decreasingz/DatetimeLikeArrayMixin._is_monotonic_decreasingrzrvc|tt|jd|jkS)NK)rrWrr sizers rt _is_uniquez!DatetimeLikeArrayMixin._is_uniques-8DIOOC001122di??rvc|jdkrbt|dd|jkrH||||jS ||}n!#t $rt|||cYSwxYwt|dd}t|rBtj |tj | t|}|S|turQ|t jur!tj|jt&}n tj|jt&}|St+|jt.st1t2|}|j|jkrt+|t7|s] ||jd}n\#t<$r2tj|j }tC|j"||cYSwxYw|j"}tC|j"||S|#|}||j"$d|$d}tK|}|j&|z}|'r$|t ju} tj(||| |S)Nrr r~rFr4r|))rr'r r r r)r;rerErTcomp_method_OBJECT_ARRAYrrrrroperatorneonesrrWr}r~rLr TimelikeOpsr rr8r9r%r_asm8r&rr?rrPr\r_rc) rrrsr~r other_arr other_valso_maskmask nat_results rt _cmp_methodz"DatetimeLikeArrayMixin._cmp_methods 9q==WUGT::djHH2djjllEKKMM22::4:FF F 733E::EE  7 7 7%dE266 6 6 6 7w-- 5 ! ! 1BJt{{62233UFM C<<X[  4888$*D999M$*k22 X T**D{el**!%d44 X % di% H H%$&HUZ$8$8 = M9b   !&I9$-TVWWW[['' DM&&t,,jood.C.CDDe{V# 88:: 1x{*J JvtZ 0 0 0 s$/BB#"B#?G9HH__pow____rpow____mul____rmul__ __truediv__ __rtruediv__ __floordiv__ __rfloordiv____mod____rmod__ __divmod__ __rdivmod__@tuple[int | npt.NDArray[np.int64], None | npt.NDArray[np.bool_]]ct|tr |j}d}n4t|ttfr |j}d}n|j}|j}||fS)zN Get the int64 values and b_mask to pass to add_overflowsafe. N)r}rordinalrrrr\r)rri8valuesrs rt_get_i8_values_and_maskz.DatetimeLikeArrayMixin._get_i8_values_and_mask.sc eV $ $ "}HDD  95 6 6 "|HDD>&!$)RZ-M-M-MNN[[!3ty!3!3!344  uxdi888[[!3ty!3!3!344 33E::(}(5xPPPPrvctj|jds9tdt |jdt |j||zS)Nrrr)rrr~rrrrs rt_add_datetime_arraylikez.DatetimeLikeArrayMixin._add_datetime_arraylikess[tz3// Nd4jj1NNU 8LNN  t|rvdatetime | np.datetime64c4|jjdkr$tdt|jt d|}t |r |tz St|}| |\}}| |S)Nr"cannot subtract a datelike from a rl) r~rrrrr rPrrr_sub_datetimelike)rrtss rt_sub_datetimelike_scalarz/DatetimeLikeArrayMixin._sub_datetimelike_scalar}s :?c ! !VdATVVWW WOT** ;; #:  u  ..r22b%%b)))rvcB|jjdkr$tdt|jt |t |krt dtd|}||\}}| |S)Nrr$cannot add indices of unequal lengthrl) r~rrrrrr%r rrrs rt_sub_datetime_arraylikez.DatetimeLikeArrayMixin._sub_datetime_arraylikes :?c ! !VdATVVWW W t99E " "CDD DOT**11%88 e%%e,,,rvTimestamp | DatetimeArrayc2td|}ddlm} ||nN#t$rA}t |dd}t|||d}~wwxYw||\}}t|j tj | d}| d|jd }||} td | } |j||j| S) Nrlrrncomparesubtractr|r timedelta64[rz Tick | Noner)r rrn_assert_tzawareness_compatrrpreplacerrrrrrrr9rrr~) rrrnr( new_messagerrrres_m8rs rtrz(DatetimeLikeArrayMixin._sub_datetimelikes*OT**555555 2  + +E 2 2 2 2 2 2 2c((**9jAAK$s))K((c 1 2 77>>&%diXIT1R1R1RSS !< !>t}?RSSJ OOD ! ! !::))*DJ)GG G4d;;%  11%88 e&&u---rvct|t|krtdtd|}||\}}||S)zl Add a delta of a TimedeltaIndex Returns ------- Same type as self rrV)rr%r rrrs rt_add_timedelta_arraylikez/DatetimeLikeArrayMixin._add_timedelta_arraylikese t99E " "CDD D4d;;11%88 e&&u---rvTimedelta | TimedeltaArrayc`td|}||\}}t|jt j|d}||jj}| |}t| ||j|S)NrVr|rr) r rrrrrrrr~rrr)rrrrrrrs rtrz)DatetimeLikeArrayMixin._add_timedeltalikes4d;;77>>&%diHD1Q1Q1QRR __T]%899 33E:: Dzz%% djx&   rvct|jtr>tdt |jdt t jtd|}tj |j tj }| t||jj}t |||jdS)z$ Add pd.NaT to self z Cannot add rzTimedeltaArray | DatetimeArrayrNr)r}r~rLrrrrr rrr rrrrrrrrs rt_add_natzDatetimeLikeArrayMixin._add_nats dj+ . . Ld4jj1LLS 8JLL 4d;;$*BH555 DT]011Dzz%% $*4&   rvc"tj|jtj}|t |jjdvr.td|}| d|j dS| dS)z+ Subtract pd.NaT from self rrzDatetimeArray| TimedeltaArrayrrztimedelta64[ns]) rrr rrrr~rr rr9rs rt_sub_natzDatetimeLikeArrayMixin._sub_nats$*BH555 D :?d " "7>>D;;:di:::;; ;;;011 1rvPeriod | PeriodArrayctjts9tdt |jdt jt d||\}}tj tj | d}tj fd|D}|j}n j|z}t||<|S)Ncannot subtract  from rmr|rc.g|]}jj|zSr)rbase)rrrs rt z:DatetimeLikeArrayMixin._sub_periodlike..1s"EEEATY^a/EEErv)r}r~rLrrrr rrrrrrr_r\r)rrrr new_i8_datanew_datars` rt_sub_periodlikez&DatetimeLikeArrayMixin._sub_periodlike#s$*k22 T4;;#7TTtDzz?RTT M4(( ##E***77>>&&ty"*hYd2S2S2STT 8EEEEEEEFF >;DD;'Drvc|tjtjfvsJt|dkr|jdkr|||dSt jdt|jdtt|j |j ksJ|j |j f|| dtj|}|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.rO)raddsubrrrrrrr<r@r rrr)rrrsrs rt_addsub_object_arrayz+DatetimeLikeArrayMixin._addsub_object_array<s hlHL11111 u::??tyA~~2dE!H%% %  5Dzz" 5 5 5 '))     zU[(((4:u{*C(((R C(("*U*;*;<< rvrRnamerSc |dvr"td|dt|tt|}||fd|i|}t|||jS)N>cummaxcumminz Accumulation z not supported for rSr)rrr'rXrrr~)rrrSrrsrs rt _accumulatez"DatetimeLikeArrayMixin._accumulate`s + + +QDQQT$ZZQQRR R / 6 6DIIKK999&99Dzz%%fDJ%???rv__add__ct|dd}t|}|tur|}n{t |t t tjfr| |}n=t |tr| |}nt |ttj fr||}nt |tr1t!j|jdr||}nt!j|rht |jt*st-|t/d|}|||jjzt4j}nt!j|dr||}nt;|r!||t4j}nt!j|dst |t>r| |StC|rgt |jt*st-|t/d|}|||jjzt4j}ntDSt |tj#r0t!j|jdrddl$m%}|j&|S|S)Nr~rrmrrr)'r'r`rrr}rrrrLrrrrrMrrrrr~r is_integerrLr(r _addsub_int_array_or_scalar_nrrrrErrJrrCNotImplementedndarrayrrnrrr other_dtyperobjrns rtrzDatetimeLikeArrayMixin.__add__iseWd33 .u55 C<<]]__FF i@ A A( "33E::FF z * *& "%%e,,FF "-8 9 9# "22599FF v & &! "3?4:s+K+K! "%%e,,FF ^E " " "dj+66 5.t444}d++C44USY\5I8<XXFF_[# . . "22599FF [ ) ) "..uhlCCFF _[# . . "* 3 3  "//66 6 k * * "dj+66 5.t444}d++C44USY\5I8<XXFF" ! fbj ) ) 9coflC.P.P 9 9 9 9 9 9 90>088 8 rvc,||Srr)rrs rt__radd__zDatetimeLikeArrayMixin.__radd__s||E"""rv__sub__c:t|dd}t|}|tur|}nt |t t tjfr| | }nRt |tr| | }n%t |ttj fr||}ntj|rht |jt$st'|t)d|}|||jjzt.j}nqt |t2r||}nEtj|dr|| }nt;|r!||t.j}ntj|dst |t>r| |}nt |t$r||}n}tC|rgt |jt$st'|t)d|}|||jjzt.j}ntDSt |tj#r0tj|jdrddl$m%}|j&|S|S)Nr~rmrrrr)'r'r`rrr}rrrrLrrrrrMrrrr~rLr(r rrrrrrrrrErrJrrCrrrrnrrs rtrzDatetimeLikeArrayMixin.__sub__seWd33 .u55 C<<]]__FF i@ A A( "33UF;;FF z * *& "%%uf--FF "-8 9 9# "22599FF ^E " "! "dj+66 5.t444}d++C44USY\5I8<XXFF v & & "))%00FF_[# . . "22E6::FF [ ) ) "..uhlCCFF _[# . . "* 3 3  "11%88FF  [ 1 1 "))%00FF k * * "dj+66 5.t444}d++C44USY\5I8<XXFF" ! fbj ) ) 9coflC.P.P 9 9 9 9 9 9 90>088 8 rvc4t|dd}tj|dpt|t}|rptj|jdrVtj|rt||z St|tsddl m }|j |}||z S|jj dkrKt|dr;|s9tdt|jdt|jt|jt"rAtj|dr,tdt|jd|jtj|jdrt%d|}| |zS||z S) Nr~rrrrrrrn)r'rrr}rJr~rrrrrlrrr1rrrrLr )rrr other_is_dt64rls rt__rsub__zDatetimeLikeArrayMixin.__rsub__seWd33  S99 Z > >   #S_TZ== #}U## / ''$..e%;<< <<<<<<<4 4U;;4<  Z_ # #w(?(? # #T4::#6TTd5kk>RTT  K 0 0 #S_[RU5V5V #WtDzz/BWW%+WWXX X _TZ - - #($//DEU? "rvcz||z}|dd|dd<t|jts |j|_|Srrr}r~rLrrrrrs rt__iadd__zDatetimeLikeArrayMixin.__iadd__B)QQQ$*k22 %DJ rvcz||z }|dd|dd<t|jts |j|_|Srrrrs rt__isub__zDatetimeLikeArrayMixin.__isub__r rvqsnpt.NDArray[np.float64] interpolationcJt||S)N)r r)r _quantile)rr rrs rtrz DatetimeLikeArrayMixin._quantiles" ww  Bm DDDrvaxisrSrAxisInt | Nonec tjd|tj||jt 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_axisrrSnanminr_wrap_reduction_resultrrrSrrs rtminzDatetimeLikeArrayMixin.minY F### di000t}4GGG**4888rvc tjd|tj||jt 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_maxrrrSnanmaxrrrs rtmaxzDatetimeLikeArrayMixin.max.rrvr)rSrc t|jtr%tdt |jdt 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()rrSr) r}r~rLrrrrSnanmeanrrPr)rrSrrs rtmeanzDatetimeLikeArrayMixin.mean@sX dj+ . . 7tDzz/B777   MV$))++   **4888rvc tjd||'t||jkrt dt j|j||}|||S)Nrz abs(axis) must be less than ndimr) rvalidate_medianabsrr%rS nanmedianrrrs rtmedianzDatetimeLikeArrayMixin.medianysk 2v&&&  D TY 6 6?@@ @!$-d6JJJ**4888rvdropnac d}|r|}tj|d|}||jj}t tj|}| |S)Nr|)r) rPrQmoderrr~r rrr)rr*ri8modesnpmodess rt_modezDatetimeLikeArrayMixin._modesu  99;;D/$))D//===,,t}233rz7++&&w///rvhowhas_dropped_na min_countintngroupsidsnpt.NDArray[np.intp]c |j}|jdkrK|dvrtd|d|dvr/tjd|d|dt t nwt|trK|dvrtd |d|dvr/tjd|d |dt t n|d vrtd |d|j d}ddl m } | |} | || |} | j|f|||dd|} | j| jvr| S| jdksJ|dvrvddlm} t|jtrtdt'd|}d|jd}| |} | j| | jS| |j j} || S)Nr)sumprodcumsumcumprodvarskewz!datetime64 type does not support z operations)r_allr0zh' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).z () instead.rzPeriod type does not support ze' with PeriodDtype is deprecated and will raise in a future version. Use (obj != pd.Period(0, freq)).)r9r;r=r<z"timedelta64 type does not support r{r)WrappedCythonOp)r0rr1)r2r4comp_idsr)stdsemrz-'std' and 'sem' are not valid for PeriodDtyperVzm8[rr)r~rrrrrr@r}rLrrpandas.core.groupby.opsr?get_kind_from_how_cython_op_ndim_compatr0cast_blocklistrrnr r9rr)rr0r1r2r4r5rr~npvaluesr?rrsrrn new_dtypes rt _groupby_opz"DatetimeLikeArrayMixin._groupby_ops  :  III TC T T TUUUn$$ UUUDGUUU!/11 { + + WIII P P P PQQQn$$ XXXGJXXX!/11 888 US U U UVVV=%%h//;;;;;;0055 _4 O O O.R.         6R& & & 8++++ . 9 9 9 9 9 9$*k22 Q OPPP8$??D*di***I#33J->-j @PQQQ Q__T]%899 &&z222rvrxr)NNF)r~rrrrxr)rxr)rrprxr)rrrxr)rrrxrrxr)rxrh)rxr)rrrxr)F)rr)NN)r~rrrrxr)rr3rxr)rrrxr4)rr1rxr)rxr)rrrrrxrrxrT)rrrxr4)r~rrxrl)r~rrxrn).)r~rrxr)rr)r*rr+r)r*rrxrp)r$r)rxrA)rr)rxrI)rxrI)rrrxr)rxrf)rxrlrxrp)rxr)rxrl)rrlrxrl)rrrxrn)rrlrxrn)rrrxrn)rrrxrm)rrn)rr)rrrxr)rr)rrprSrrxr4)r r rrprxr4)rrrSr)rSrrr)r*r) r0rpr1rr2r3r4r3r5r6)`r __module__ __qualname____doc____annotations__r?rrpropertyrrrrrrrrrrrrrrrrrrr)r.r-r&r@r r?r[rHrUrPr\r`rrerhrkrprsryr|rrrurrrrrrrrrrrrrrrrrrrrrrrrrrrrrrdrrrrrr rrrr r$r)r/rI __classcell__rs@rtrrs $###4444))))^IN((((( (((X((((((((((.((((,((( DDDD ::::  ( ( (X ( (-$ ( ( ( ( ( (AE.   X    X "<!!!!!!,    71717171717171r   X    X    X     X #######"""P % ;);););););)z>88888t"""     U "    \  P,P,P,P,j!!!X! '''X'.24<!!!X!:X<X---X-???X????X?@@@X@ 555r(' 22G((44H'' 22G((44H++M::K,,^<>M'' 22G((44H**<88J++M::K  U$     U  QQQ UQB  U *** U*$  - - - U - UUU UU&     U (((...(....$     U     U , 22 U2&  U0 !!! U!F8<@@@@@@i((55)(5n###i((55)(5n   DEEEEEE,0999999",0999999"&*!797979797979r/3D99999900000M3M3M3M3M3M3M3M3rvrc>eZdZdZedd dZd S) DatelikeOpszK Common ops for DatetimeIndex/PeriodIndex, but not TimedeltaIndex. zNhttps://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior)URLrrprxrc||tj}tr+ddlm}t ||tjS|tdS)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') )rrr) StringDtyper rFr) rrrbrrEr[r;rr)rrrr[s rtstrftimezDatelikeOps.strftimesxb**{26*RR    H * * * * * *F++rv*F*F*FGGG G}}V%}000rvN)rrprxr)rrPrQrRr>r]rrvrtrXrXsW\ *212121 212121rvrXaO 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<dejdfdLd Zed Z e d Z e j dMd Z e dNdZe edOdZedPdZedQdZedRdZdSdTdZd ZdUfd$ Zd%Zeeezd&' dVdWd-Zeeezd.' dVdWd/Zeeezd0' dVdWd1Z ddd2dXd6Z!ddd2dXd7Z"dMd8Z#dYd9Z$dZfd; Z% d[d\fd> Z&e d]d^fdC Z'd_d`fdF Z(dadJZ)e dbdKZ*xZ+S)crzK Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex. znp.dtype_default_dtypeNFrrrxrcPtjt|jdtt |t |}t|d}t|tr| dt}t|dd}|du}|tjur|nd}t|t|rp|rn7||j}n-|r+|jr$t!|}t#||j}|%||jkrt'd|d |j|j}|j}ns|qt|t*jr|jjd vr|j}nA|j}t|t*jr |jd kr||}t|t*js:t5d t|jd t|jd|jdvrt5d|jd kr|"|j}||j}nntj|dr||}nCt|t:r.|jj}|d|jd}||}|||}|dkr%t5dt|jd|r| }|rCt!|}|jjdkr$t|tBst'dtEj#|||||_$|'|'t|%||dSdSdS)NzV.__init__ is deprecated and will be removed in a future version. Use pd.array instead.rTr6rr\rdtype=z does not match data dtype Mmr|zUnexpected 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)rr~)&rrrrrr@rGrar}r^rFrr'r no_defaultrr#_validate_inferred_freqr~rrrrrr_rr%rrrJr9_validate_dtyperrrrr_validate_frequency) rrr~rrrk explicit_nonerrHs rtrzTimelikeOps.__init__s  Dzz" A A A '))        ''EvT::: fl + + =__Wt_<11ttt fd4jj ) ) 0 B{ B&+ B .tV[AA Ufl%:%:MUMMv|MMLE_FF ]&"*-- 0&,2Ct2K2K +fbj110fld6J6J#[[//F&"*-- +DLL$9++::&+++  ;f $ $MNN N <4  }+T%899-- 0U++E?33 0*/#44uz444 Y//$$VU33 7??,d4jj6I,,,   #[[]]F  LT??D| C'' 40F0F' JKKKtF%@@@@  T%5 JJ * *4 6 6 6 6 6 ! %5%5rvc t|rrr)rrr~s rtrizTimelikeOps._validate_dtypes!#&&&rvc|jS)zK Return the frequency object if it is set, otherwise None. rrs rtrzTimelikeOps.freqs zrvc|st|}||||jjdkr$t |t st d|jdkrtd||_ dS)NrrfrzCannot set freq with ndim > 1) r#rjr~rr}rrrr%rrs rtrzTimelikeOps.freqs}  e$$E  $ $T5 1 1 1z#%%j.E.E% JKKKy1}} !@AAA rv validate_kwdsdictcN| d|_dS|dkr$|jt|j|_dSdS|tjurdS|j4t|}t |j||fi|||_dSt|}t||jdS)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. Nre)rr#rkrrgrrjrh)rrrps rt_maybe_pin_freqzTimelikeOps._maybe_pin_freq*s <DJJJ W__z!'t'9:: "!S^ # # D Z T??D *DJJ *4 G G G G GDJJJT??D #D$* 5 5 5 5 5rvrrc h|j}|jdks ||jkrdS |jd|ddt |||jd|}t j|j|jstdS#t$r3}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)startendperiodsrr9z non-fixedInferred frequency 9 from passed values does not conform to passed frequency r) rkrrh_generate_rangerr9r array_equalrr%rp)rindexrrrZon_freqr(s rtrjzTimelikeOps._validate_frequencyKs& :??h$,664 )c)AhE Z   G>%*gl;; !   ! !   c#hh&& GhGG8< GG  sAA44 B1>.B,,B1rw int | Noner4c t|rrr)rrurvrwrrrs rtrzzTimelikeOps._generate_rangews"#&&&rvr3c4t|jjSrr)rrr~rs rtr zTimelikeOps._cresos"4=#6777rvrpc*t|jSrr) dtype_to_unitr~rs rtr9zTimelikeOps.units TZ(((rvTr9r5c|dvrtdtj|jjd|d}t |j||}t |jtjr|j}n&td|j}t||}t| |||j S) N)smsusnsz)Supported units are 's', 'ms', 'us', 'ns'rdrr4rlrr) r%rr~rrrr}r rrJrrr)rr9r5r~rrHrs rtr8zTimelikeOps.as_units . . .HII IDJO66t66677(QQQ dj"( + + :"(IIot,,/B'2D999IDzz%% idi&   rvc|j|jkrE|j|jkr||j}n||j}||fSrr)r r8r9rs rtrz"TimelikeOps._ensure_matching_resossR ;%, & &{U\))||EJ// di00U{rvufuncnp.ufuncmethodc|tjtjtjfvr9t |dkr&|d|urt |||jfi|Stj||g|Ri|S)Nrr) risnanisinfisfiniterr'rr__array_ufunc__)rrrinputsrrs rtrzTimelikeOps.__array_ufunc__s bh"+6 6 6F q  q T!!*75&))$-BB6BB B&uww&ufHvHHHHHHrvcvt|jtrZtd|}|d}|||||}||j||S|d}ttj |}t||j }|dkr| St|||} || t}||jj}|||jS)Nrl) ambiguous nonexistentr|rrdr)r}r~rJr tz_localize_roundrrrrr'r rr%rerrr) rrr,rrnaiverrnanos result_i8s rtrzTimelikeOps._rounds dj/ 2 2 ..D$$T**E\\$iEEF%%9+& 4bj&))"455 A::99;; !&$66 ))))EET]011dj999rvround)rsraiserr6rr7cF||tj||Srr)rr$NEAREST_HALF_EVENrrrrs rtrzTimelikeOps.rounds{{4!:I{SSSrvfloorcF||tj||Srr)rr$ MINUS_INFTYrs rtrzTimelikeOps.floors{{4!4iMMMrvceilcF||tj||Srr)rr$ PLUS_INFTYrs rtrzTimelikeOps.ceils{{4!3Y LLLrvrrrrSc`tj|j|||SNr")rSnananyrrPrrrSs rtr_zTimelikeOps.anys%}T]f499;;WWWWrvc`tj|j|||Sr)rSnanallrrPrs rtr>zTimelikeOps.alls'}T]f499;;WWWWrvcd|_dSrrrnrs rtrzTimelikeOps._maybe_clear_freqs  rvc4|nyt|dkrJt|tr5|jjdkr$t|t st dn|dksJt|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 Nrrrfre) rr}rr~rrrr#rkrr)rrrs rt _with_freqzTimelikeOps._with_freqs <  YY!^^ 4 < <^z#%%jt.D.D% JKKK7????T/00Diikk  rvrct|jtjr|jSt Srr)r}r~rrr_values_for_json)rrs rtrzTimelikeOps._values_for_json s7 dj"( + + != ww'')))rvuse_na_sentinelsortc~|jmtjt|tj}|}|r&|jjdkr|ddd}|ddd}||fS|r%tdt|j dt |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.)r) rrarangerintprrNotImplementedErrorrrr factorize)rrrcodesuniquesrs rtrzTimelikeOps.factorize s 9 Ic$iirw777EiikkG ( addd !$$B$-'> !  &=d)<===  ww   AAArvr to_concatSequence[Self]r*cXt||}|d|dkrwd|D}jdtfd|DrIt |dd|dd}tfd|Drj}||_|S)Nrc0g|]}t||Sr)r)rrs rtrz1TimelikeOps._concat_same_type..C s#888qQ8888rvc38K|]}|jjkVdSrrr)rrrs rtrz0TimelikeOps._concat_same_type..E s,+R+R1AFch,>+R+R+R+R+R+Rrvrrc3dK|]*}|ddjz|ddkV+dS)rrrNr)rpairrs rtrz0TimelikeOps._concat_same_type..G s?NNtAwr{SX-a;NNNNNNrv)r_concat_same_typerr>zipr)rrrnew_objpairsrrrs @rtrzTimelikeOps._concat_same_type6 s ''++It<<l 19998I888Ix#+R+R+R+R +R+R+R(R(R#IcrcNIabbM::NNNNNNNNN-"xH$,GMrvCordercdt|}|j|_|S)N)r)rrrr)rrrrs rtrzTimelikeOps.copyL s('',,U,++  rvr/r|rkc |dkrt|s|j} n|j} tj| f||||||d||s|St || |jS)z2 See NDFrame.interpolate.__doc__. linear)rrr|limitlimit_direction limit_arear)rrrrRinterpolate_2d_inplacerrr~) rrrr|rrrrrout_datas rt interpolatezTimelikeOps.interpolateQ s X  % % ,}HH}))++H&  +!   KDzz%%hdj%AAArvc tj|jsdS|j}|tk}t |j}t |}tj|||zdk dk}|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) rrr~rrrr"r logical_andr8)r values_intconsider_valuesrppd even_dayss rt_is_dates_onlyzTimelikeOps._is_dates_onlyz stz** 5Y $,"4:..d##N?J4D4IJJNNPPTUU rv)rrrxrrL)rprq)rr)rwr~rxr4)rxr3rOrM)r9rpr5rrxr4)rrrrp)rr)rr6rr7rxr4)rrrSrrxrrNrK)TF)rrrr)r)rrrr*rxr4)r)rrprxr4) rr/rr3r|rkrrrxr4rJ),rrPrQrRrSrrgr classmethodrirTrsetterr rsrjrzr?r r9r8rrrr= _round_doc_round_examplerr_floor_exampler _ceil_examplerr_r>rrrrrrrrrUrVs@rtrrs!s~EZ7Z7Z7Z7Z7x''['X  [   [  666 U6@ ((([ U(T'''['888^8)))^)      * I I I I I I:::,XzN*22g2>>??$+'. TTTT@?TXzN*22g2>>??$+'. NNNN@?NXzM)11V1<<==$+'. MMMM>=M-1XXXXXX-1XXXXXX@******!%BBBBBBB0[* $B$B$B$BRXrvrrrcls_nametuple[ArrayLike, bool]cdt|dsUt|ttfs't j|dkrt|}t |}d}n9t|trtd|dt|d}t|ts#t|tr-|j j dvr|d t }d}nt|tr+|}|}d}nxt|tjt$fst j|}nBt|t(r-|j|jt0 j}d}||fS) Nr~rFzCannot create a z from a MultiIndex.Tr6rrr\r)r1r}rtuplerrrArNrrar^r\r~rrFr_maybe_convert_datelike_arrayrr]rrMr<takerr_values)rrrs rt!ensure_arraylike_for_datetimeliker s 4 ! ! 7$u .. 274==A3E3E::D6t<< D- ( (7H8HHHIIIT666$ %%4,--26*/T2I2I}}Wt}44 D- . . 1133}} rz>: ; ; z$ D. ) )##DJ3#??G :rvrwrcdSrrrrws rtvalidate_periodsr Crv int | floatr3cdSrrrrs rtrr rrvint | float | Noner~c|rtj|r8tjdtt t |}n&tj|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 NzNon-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.rzperiods must be a number, got ) ris_floatrrrr@r3rrrs rtrr s$ < H M2+--     'llGG(( HFWFFGG G NrvrrrkcV|&| ||krtd|d|j||}|S)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 Returns ------- freq : DateOffset or None Nrxry)r%rh)rrks rtrhrh s]    5 5"m""<""  < D Krvr~'DatetimeTZDtype | np.dtype | ArrowDtypect|tr|jSt|tr(|jdvrt d|d|jjStj|dS)z Return the unit str corresponding to the dtype's resolution. Parameters ---------- dtype : DatetimeTZDtype or np.dtype If np.dtype, we assume it is a datetime64 dtype. Returns ------- str rraz does not have a resolution.r) r}rJr9rHrr% pyarrow_dtyper datetime_datars rtrr sy%))(z E: & &( :T ! !DDDDEE E"'' E " "1 %%rv)rorp)rwr.rxr.)rrrrprxr)rwrrxr)rwrrxr3)rwrrxr~)rrrkrrxr)r~rrxrp) __future__rrr functoolsrrtypingrrr r r r r rrnumpyrpandas._configr pandas._libsrrpandas._libs.arraysrpandas._libs.tslibsrrrrrrrrrrrrrr r!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/r0r1r2r3r4r5r6r7r8pandas.compat.numpyr9r pandas.errorsr:r;r<pandas.util._decoratorsr=r>r?pandas.util._exceptionsr@pandas.core.dtypes.castrApandas.core.dtypes.commonrBrCrDrErFrGpandas.core.dtypes.dtypesrHrIrJrKrLpandas.core.dtypes.genericrMrNpandas.core.dtypes.missingrOrP pandas.corerQrRrSrTpandas.core.algorithmsrUrVrWpandas.core.array_algosrXpandas.core.arraylikerYpandas.core.arrays._mixinsrZr[pandas.core.arrays.arrow.arrayr\pandas.core.arrays.baser]pandas.core.arrays.integerr^pandas.core.commoncorecommonrpandas.core.constructionr_r;r`rapandas.core.indexersrbrcpandas.core.ops.commonrdpandas.core.ops.invalidrerfpandas.tseriesrgcollections.abcrhrirErkrrlrmrnrrurrrXrrrrrrrrhrrrvrtrs5""""""                    ------.-----&KJJJJJ======CCCCCC$/.....  544444KKKKKK   ?>>>>>******?>>>>>222222333333  <;;;;; '&&&&&   ('12 1111 6W3W3W3W3W3 )W3W3W3t0;1;1;1;1;1(;1;1;1|= ~66 8^^^^^(^^^J$$$$N    D:&&&&&&rv