i|UddlmZddlmZmZddlmZddlZddlmZm Z m Z m Z m Z m Z mZmZmZddlZddlZddlmZddlmZddlmZmZdd lmZmZmZmZm Z m!Z!m"Z"m#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/m0Z0m1Z1dd l2m3Z3dd l4m5Z5dd l6m7Z7ddl8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHddlImJZKddlLmMZMmNZNmOZOddlPmQZQddlRmSZSddlTmUZUddlVmWZWmXZXmYZYmZZZm[Z[m\Z\ddl]m^Z^m_Z_m`Z`maZambZbddlcmdZdmeZeddlfmgZgmhZhddlimjZjmkZkmlZlmmZmddlnmoZompZpmqZqddlrmsZsddltmuZuddlvmwZwmxZxddlymzZzddl{m|Z|ddl}m~Z~ddlmcmZdd lmZmZmZdd!lmZmZdd"lmZdd#lmZmZdd$lmZer dd%lmZmZmZdd&l8mZdd'lmZdd(lmZmZmZe;e zZd)ed*<d9d+Zd:d,ZGd-d.euewZGd/d0eZGd1d2eZ d;d3Zedd6Z d?d7Zd@d8Zy)A) annotations)datetime timedelta)wrapsN) TYPE_CHECKINGAnyLiteralSelf TypeAliasUnioncastfinaloverload)using_string_dtype) get_option)algoslib) BaseOffsetDayIncompatibleFrequencyNaTNaTTypePeriod ResolutionTick Timedelta Timestampadd_overflowsafeastype_overflowsafeget_unit_from_dtypeiNaTints_to_pydatetimeints_to_pytimedeltaperiods_per_day timezones to_offset)RoundTo round_nsint64)compare_mismatched_resolutions)get_unit_for_round)integer_op_not_supported) ArrayLikeAxisIntDatetimeLikeScalarDtypeDtypeObjFInterpolateOptionsNpDtypePositionalIndexer2DPositionalIndexerTuple ScalarIndexerSequenceIndexer TakeIndexer TimeAmbiguousTimeNonexistentnpt)function)AbstractMethodErrorInvalidComparisonPerformanceWarning)cache_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)CallableIteratorSequence)TimeUnitIndex) DatetimeArray PeriodArrayTimedeltaArrayr DTScalarOrNaTc:t|}t||SN)rgre)op_nameops \/app/cer_product_mecsu/.venv/lib/python3.12/site-packages/pandas/core/arrays/datetimelike.py_make_unpacked_invalid_oprxs  !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) isinstancedtyperMviewrr _box_func_value_from_backing_data)selfargskwargsarrresultres_i8meths rwnew_methz"_period_dispatch..new_meths$**k2.t.v. .ii!c+D+F+ S=J  *>>&--0 0T"&&v..ry)rr r1)rrs` rw_period_dispatchrs* 4[ / / 8 ryceZdZUdZded<ded<ded<ded <d ed <edpd Z dq drdZedsdZ dtdZ dudZ dvdZ dZ dwdZdxdZedydZdd d dzdZd{d|dZ d} d~dZeddZe ddZdfd Zdd Z dfd! Zdd"Zddfd$ Zedd%Zedd&Zedd'Zeddd(Zddfd) Zdfd* Zd+Zdd#d, dd-Zd{dd.Zd{dd/Zd0Z e!dd1Z"e#ddd2Z$dd3Z%dd4Z&edd5Z'edpd6Z(e)d f dd7Z*edd8Z+edd9Z,edd:Z-edd;Z.edpd<Z/edpd=Z0edpd>Z1d?Z2e3d@Z4e3dAZ5e3dBZ6e3dCZ7e3dDZ8e3dEZ9e3dFZ:e3dGZ;e3dHZ<e3dIZ=e3dJZ>e3dKZ?e! ddLZ@e!ddMZAe!ddNZBe!ddOZCe! ddPZDe!ddQZEe!ddRZFe!ddSZGdTZHdUZIddVZJe!ddWZKe!ddXZLe!dwdYZMe!ddZZNe!dd[ZOd#d\dd]ZPeQd^d_ZRd`ZSeQdadbZTdcZUdddZVddeZWeX dfdf ZYeXd d#dgddhZZeXd d#dgddiZ[d#djdkddlZ\eXd d#dgddmZ]dddnZ^ ddoZ_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 rw _can_hold_naz#DatetimeLikeArrayMixin._can_hold_nasryNFct|rtr=)rdatarrcopys rw__init__zDatetimeLikeArrayMixin.__init__s"$''ryct|)z The scalar associated with this datelike * PeriodArray : Period * DatetimeArray : Timestamp * TimedeltaArray : Timedelta rrs rw _scalar_typez#DatetimeLikeArrayMixin._scalar_types"$''ryct|)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 rw_scalar_from_stringz*DatetimeLikeArrayMixin._scalar_from_string$"$''ryct|)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]) np.datetime64('1970-01-01T00:00:00.000000000') rrs rw _unbox_scalarz$DatetimeLikeArrayMixin._unbox_scalars*"$''ryct|)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 rw_check_compatible_withz-DatetimeLikeArrayMixin._check_compatible_withrryct|)zI box function to get object from internal representation r)rxs rwrz DatetimeLikeArrayMixin._box_func/s"$''rycFtj||jdS)z1 apply box func to passed values F)convert)r map_inferrrvaluess rw _box_valuesz"DatetimeLikeArrayMixin._box_values5s}}VT^^UCCrycjdkDrfdttDSfdjDS)Nc3(K|] }| ywrtr).0nrs rw z2DatetimeLikeArrayMixin.__iter__..=s6DG6sc3@K|]}j|ywrt)r)rvrs rwrz2DatetimeLikeArrayMixin.__iter__..?s9!DNN1%9s)ndimrangelenasi8rs`rw__iter__zDatetimeLikeArrayMixin.__iter__;s1 99q=6U3t9%56 69tyy9 9ryc8|jjdS)z Integer representation of the values. Returns ------- ndarray An ndarray with int64 dtype. r})rrrs rwrzDatetimeLikeArrayMixin.asi8As}}!!$''ryr)na_rep date_formatct|)z| Helper method for astype when converting to strings. Returns ------- ndarray[str] r)rrrs rw_format_native_typesz+DatetimeLikeArrayMixin._format_native_typesQs"$''rycdjS)Nz'{}')format)rboxeds rw _formatterz!DatetimeLikeArrayMixin._formatter]s }}ryc>t|r3|dur tdtjt |t S|dur!tj|j |S|j }|jr!|j}d|j_ |S)NFz:Unable to avoid copy while creating an array as requested.rT) rF ValueErrornpr`listobjectr _readonlyrflags writeable)rrrrs rw __array__z DatetimeLikeArrayMixin.__array__ds 5 !u} P88DJf5 5 4<88DMM7 7 >>[[]F%*FLL " rycyrtrrkeys rw __getitem__z"DatetimeLikeArrayMixin.__getitem__x@Crycyrtrrs rwrz"DatetimeLikeArrayMixin.__getitem__{srycttttft||}t j|r|Stt|}|j||_ |S)z This getitem defers to the underlying array, which by-definition can only handle list-likes, slices, and integer scalars ) r r r rrsuperrr is_scalar_get_getitem_freq_freq)rrr __class__s rwrz"DatetimeLikeArrayMixin.__getitem__s]eD-/0%'2Ec2JK == M$'F--c2  ryc: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)r~rrMrrrcslicestepEllipsiscomis_bool_indexerrmaybe_booleans_to_slicerruint8r)rr is_periodrnew_keys rwrz(DatetimeLikeArrayMixin._get_getitem_freqstzz;7 99D& %YY!^D" &dC0CD#u%99(SXX-A88dii/D  99D yy  $$S)55chhrxx6HIgu-11':: rycft|||}t| |||ry|jyrt)rdr __setitem___maybe_clear_freq)rrrno_oprs rwrz"DatetimeLikeArrayMixin.__setitem__s6&c5$7 C'    rycyrtrrs rwrz(DatetimeLikeArrayMixin._maybe_clear_freqs ryTc`t|}|tk(r|jjdk(r=t d|}|j }t ||jd|j}|S|jjdk(rt|jdS|j|j jj|jSt|r`t!|t"r@|j%|j&}|j)}|j+||d S|j%St!|t"rt, |]|| S|jd vrO|j }|t0j2k7rt5d |jd|d|r|j7}|S|jdvr|j|k7s|jdk(r&dt9|j:d|}t5|t1j<||S)NMro timestamp)tzboxresomT)r)rF)rrriuzConverting from z to z? is not supported. Do obj.astype('int64').astype(dtype) insteadmMfz Cannot cast z to dtype r)rHrrkindr rr"r_cresor#rrravelreshapeshaperGr~rLrna_valueconstruct_array_type_from_sequencerastyperint64 TypeErrorrtype__name__asarray) rrri8data converted arr_objectclsrmsgrs rwrzDatetimeLikeArrayMixin.astypes U# F?zz#%OT2.ww#  ! C'*4==dCC##DIIOO$56>>tzzJ J U #%0!66enn6M 002))*E)NN0022 ~ .7>%d>3 3 ZZ4 YYF &tzzl$ug>CC MjjD TZZ5%8UZZ3=N!d!4!4 5ZwGCC. ::d%0 0rycyrtrrs rwrzDatetimeLikeArrayMixin.viewsrycyrtrrrs rwrzDatetimeLikeArrayMixin.view s?Brycyrtrrs rwrzDatetimeLikeArrayMixin.view rrycyrtrrs rwrzDatetimeLikeArrayMixin.viewsrrrrrrEr_validate_listlikerFgetattr)rrerrs rw_validate_comparison_valuez1DatetimeLikeArrayMixin._validate_comparison_valuesD eS ! 8007 eT55 6%3,%%e,E 8++E2, #e$#E* * Z3t9 $12 2 <//D/I++E2 ; 56 8'.C7 8 8'.C7 8 <"75'4#@A+E2;  K?ct|r|j|}n|j|dS|j|S)NT)r)rErr!_unboxrs rw_validate_setitem_valuez.DatetimeLikeArrayMixin._validate_setitem_values?  ++E2E((t(D D{{5!!ryctj|r|j|}|S|j||j}|S)zZ Unbox either a scalar with _unbox_scalar or an instance of our own type. )rrrrrrs rwr7zDatetimeLikeArrayMixin._unboxsE == &&u-E    ' ' .NNE rycddlm}t|||}||}t|tr|j S|j S)Nrrm) na_action)pandasrnrWr~rOto_numpyr`)rmapperr;rnrs rwmapzDatetimeLikeArrayMixin.maps= 49=v fm ,??$ $<< rycL|jjdvr%tj|jt St |}t|t|s|jtk(retj|d|j}|jtk7r|j|St|jt|Stj|jt S|jjdvr'td|}|j|j } |j#|t|j(|j(S#t$t&f$r(tj|jt cYSwxYw)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] fiucrTr)rDatetimeArray | TimedeltaArray)rrrzerosrboolrar~rrrr2rVrr r/r.rrrrrs rwrVzDatetimeLikeArrayMixin.isins< <<   &88DJJd3 3/7&$t*-||v%22(,%)ZZ <<6)99V,,  F 3V<<88DJJd3 3 ::??d "8$?D^^DII.F 4  ' ' /DIIv{{++ :& 488DJJd3 3 4s;E,,4F#"F#c|jSrt)_isnanrs rwrQzDatetimeLikeArrayMixin.isna>s {{ryc(|jtk(S)z- return if each value is nan )rr!rs rwrFzDatetimeLikeArrayMixin._isnanAs yyD  rycHt|jjS)zJ return if I have any nans; enables various perf speedups )rDrFanyrs rw_hasnazDatetimeLikeArrayMixin._hasnaHs DKKOO%&&ryc|jrF|r|j|}|tj}tj||j ||S)az Parameters ---------- result : np.ndarray fill_value : object, default iNaT convert : str, dtype or None Returns ------- result : ndarray with values replace by the fill_value mask the result if needed, convert to the provided dtype if its not None This is an internal routine. )rJrrnanputmaskrF)rr fill_valuers rw_maybe_mask_resultsz*DatetimeLikeArrayMixin._maybe_mask_resultsOsD& ;;w/!VV JJvt{{J 7 rycH|jy|jjS)a Return the frequency object as a string if it's set, otherwise None. See Also -------- DatetimeIndex.inferred_freq : Returns a string representing a frequency generated by infer_freq. 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 rwrQzDatetimeLikeArrayMixin.freqstrms"@ 99 yy   rycl|jdk7ry tj|S#t$rYywxYw)a  Tries to return a string representing a frequency generated by infer_freq. Returns None if it can't autodetect the frequency. See Also -------- DatetimeIndex.freqstr : Return the frequency object as a string if it's set, otherwise None. 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[us]', freq=None) >>> tdelta_idx.inferred_freq '10D' rN)rrh infer_freqrrs rw inferred_freqz$DatetimeLikeArrayMixin.inferred_freqs:: 99> ))$/ /  s ' 33cj|j}|y tj|S#t$rYywxYwrt)rQrget_reso_from_freqstrKeyError)rrQs rw_resolution_objz&DatetimeLikeArrayMixin._resolution_objs;,, ? 33G< <  s & 22c.|jjS)zO Returns day, hour, minute, second, millisecond or microsecond )rXattrnamers rw resolutionz!DatetimeLikeArrayMixin.resolutions ##,,,rycJtj|jddS)NTtimelikerr is_monotonicrrs rw_is_monotonic_increasingz/DatetimeLikeArrayMixin._is_monotonic_increasing!!$))d;A>>rycJtj|jddS)NTr]rr_rs rw_is_monotonic_decreasingz/DatetimeLikeArrayMixin._is_monotonic_decreasingrbrycvtt|jjd|jk(S)NK)rrXrrsizers rw _is_uniquez!DatetimeLikeArrayMixin._is_uniques(8DIIOOC012dii??ryc|jdkDrXt|dd|jk(r>||j|jj |jS |j |}t|dd}t|r?tj|t!j"|j%t&|}|S|t(ur`|t*j,ur't!j.|jt0}|St!j2|jt0}|St|jt4st7t8|}|j:|j:k7rWt|t=|s |j?|j@d}n#|jJ}tI|jJ||S|jM|}||jJjOd|jOd}tQ|}|jR|z}|jUr)|t*j,u} t!jV||| |S#t $r>t|dr"t|jtrtcYSt|||cYSwxYw#tB$r9t!jD|jF}tI|jJ||cYSwxYw)NrrrrFr'r}),rrrrrrr>r$r~rrINotImplementedrfrFrUcomp_method_OBJECT_ARRAYrrrrroperatorneonesrDrCrMr TimelikeOpsrrr/r.rr`asm8r)rr7rrQrFrIrM) rrrvrr other_arr other_valso_maskr nat_results rw _cmp_methodz"DatetimeLikeArrayMixin._cmp_methodsP 99q=WUGT:djjHdjjlEKKM2::4::F F 733E:E w- 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 a! 7ug&:ekk:+N%%%dE26 6 7:&$&HHUZZ$8 = MM9b s*)I*J4*5J1! J10J14?K65K6__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)r~rordinalrrrrFr)rri8valuesrs rw_get_i8_values_and_maskz.DatetimeLikeArrayMixin._get_i8_values_and_mask!sq eV $}}HD~ 95 6||HD ~<&!$))RZZ-MN[[3tyyk!34 uxxdii8[[3tyyk!34 33E:(}((5xPPryctj|jds7tdt |j dt |j ||zS)Nrrr)rrrrrrrs rw_add_datetime_arraylikez.DatetimeLikeArrayMixin._add_datetime_arraylikesStzz3/d4j112%U 8L8L7MN  t|ryc|jjdk7r!tdt|jt d|}t |r |tz St|}|j|\}}|j|S)Nr"cannot subtract a datelike from a ro) rrrrrr rQrrr_sub_datetimelike)rrtss rw_sub_datetimelike_scalarz/DatetimeLikeArrayMixin._sub_datetimelike_scalars ::??c !@dATAT@UVW WOT* ;#:  u ..r2b%%b))ryc|jjdk7r!tdt|jt |t |k7r t dtd|}|j|\}}|j|S)Nrr$cannot add indices of unequal lengthro) rrrrrrrr rrrs rw_sub_datetime_arraylikez.DatetimeLikeArrayMixin._sub_datetime_arraylikes} ::??c !@dATAT@UVW W t9E "CD DOT*11%8 e%%e,,ryctd|}ddlm} |j||j|\}}t|jtj| d}|jd|jd }|j|} td | } |j ||j"| S#t$r2}t |j dd}t|||d}~wwxYw) Nrorrqcomparesubtractr}r timedelta64[rz Tick | Noner)r rrq_assert_tzawareness_compatrrreplacerrrrrrrr.rrr) rrrqr new_messagerrsrres_m8rs rwrz(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)rpr)rrrrrrpandas.core.arrays.periodrpr broadcast_torrrMr)rrrpi8valsrparrs rw _add_periodz"DatetimeLikeArrayMixin._add_periodsstzz3/5d4j6I6I5JKL L : ;EJJ'6/d{ryct|rtr)roffsets rw _add_offsetz"DatetimeLikeArrayMixin._add_offsets !$''ryct|rtj|jdj |j j }|jtt|j||j Std|}t|}|j|\}}|j|S)zk Add a delta of a timedeltalike Returns ------- Same type as self r}rrB)rQremptyrrrrfillr!rrr rr_add_timedeltalike)rr new_valuess rw_add_timedeltalike_scalarz0DatetimeLikeArrayMixin._add_timedeltalike_scalars ;$**D9>>t}}?R?RSJ OOD !:))*DJJ)G G4d;% 11%8 e&&u--ryct|t|k7r tdtd|j|\}}|j |S)zl Add a delta of a TimedeltaIndex Returns ------- Same type as self rrB)rrr rrrs rw_add_timedelta_arraylikez/DatetimeLikeArrayMixin._add_timedelta_arraylikesT t9E "CD D ,d  ' e&&u--ryc:|j|\}}t|jtj|d}|j |j j}|j|}t|j||j|S)Nr}rr) rrrrrrrrrrr)rrrrsrrrs rwrz)DatetimeLikeArrayMixin._add_timedeltalikes77>&%diiHD1QR __T]]%8%89 33E:Dz%% **&  ryct|jtr;tdt |j dt t j tj|jtj}|jt|j|jj}t |j||jdS)z$ Add pd.NaT to self z Cannot add rrNr)r~rrMrrrrrrrrrr!rrrrrs rw_add_natzDatetimeLikeArrayMixin._add_nats djj+ .d4j112%S 8J8J7KL  $**BHH5 DT]]001Dz%% **&  ryc2tj|jtj}|j t |j jdvr+td|}|jd|jdS|jdS)z+ Subtract pd.NaT from self rrzDatetimeArray| TimedeltaArrayrrztimedelta64[ns]) rrrrrr!rrr rr.rs rw_sub_natzDatetimeLikeArrayMixin._sub_natsq$**BHH5 D ::??d "7>D;;dii[:; ;;;01 1ryc.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 rpr}r)r~rrMrrrr rrrrrrr`rbaserFr)rrrrs new_i8_datarnew_datars rw_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 dr;t jdt|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. rrperformance_warningsz)Adding/subtracting object-dtype array to z not vectorized.) stacklevelO)rladdsubrrrwarningswarnrrr?rArrrr)rrrvrs rw_addsub_object_arrayz+DatetimeLikeArrayMixin._addsub_object_arrayFs hllHLL1111 u:?tyyA~dE!H% % , - MM;:&&''79"+-  zzU[[(C4::u{{*CC( C("**U*;< ry)skipnac |dvrtd|dt|tt|}||j fd|i|}t|j ||j S)N>cummaxcumminz Accumulation z not supported for rr)rrrrYrrr)rnamerrrvrs rw _accumulatez"DatetimeLikeArrayMixin._accumulateksm + +mD61DT$ZLQR R / 6DIIK99&9Dz%%fDJJ%??ry__add__ct|dd}t|}|tur|j}nt |t t tjfr|j|}nt |trXtj|jdr8t|jj!d}|j|}nt |t"r|j%|}nt |t&tj(fr|j+|}nt |t,r3tj|jdr|j/|}ntj0|rjt |jt2s t5|t7d|}|j9||jj:zt<j>}ntj|dr|jA|}ntC|r!|jE|t<j>}ntj|dst |tFr|jI|StK|rit |jt2s t5|t7d|}|j9||jj:zt<j>}ntLSt |tjNrDtj|jdr$dd l(m)}|jT||j S|S) NrMmdayssrrprrrr)+rrarrr~rrr timedelta64rrrrrrrr/rrr datetime64rrr is_integerrMr+r _addsub_int_array_or_scalar_nrlrrrFrrKrrDrjr1rrqrrr other_dtypertdobjrqs rwrzDatetimeLikeArrayMixin.__add__tsXeWd3 .u5 C<:>--/F i@ A33E:F s # D(I(005B33B7F 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>00v||L L ryc$|j|Srt)rrs rw__radd__zDatetimeLikeArrayMixin.__radd__s||E""ry__sub__ct|dd}t|}|tur|j}nt |t t tjfr|j| }nt |trYtj|jdr9t|jj!d}|j| }n#t |t"r|j%| }nt |t&tj(fr|j+|}ntj,|rjt |jt.s t1|t3d|}|j5||jj6zt8j:}nMt |t<r|j?|}n*tj|dr|jA| }ntC|r!|jE|t8j:}ntj|dst |tFr|jI|}nt |t.r|j?|}nztK|rit |jt.s t1|t3d|}|j5||jj6zt8j:}ntLSt |tjNrDtj|jdr$dd l(m)}|jT||j S|S) Nrrrrrprrrrr)+rrarrr~rrrrrrrrrrrr/rrrrrrrMr+r rrrlrrrrrFrrKrrDrjr1rrqrrs rwrzDatetimeLikeArrayMixin.__sub__sheWd3 .u5 C<:>--/F i@ A33UF;F s # D(I(005B33RC8F 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>00v||L L ryc t|dd}tj|dxst|t}|r|tj|j dr\tj |rt||z St|ts$ddl m }|j||j }||z S|j jdk(rSt|drG|sEtdt|j dt|j d |j d t|j t"rDtj|dr.tdt|j d|j tj|j drt%d |}| |zS||z }|j jdk(r7tdt|j dt|j | S) Nrrrrrrrr[rrq)rrrr~rKrrrrrrorrr$rrrrMr )rrr other_is_dt64roflippeds rw__rsub__zDatetimeLikeArrayMixin.__rsub__seWd3  S9 Z >  S__TZZ=}}U# '$..e%;<<4 44U%++N4<  ZZ__ #w(? "4:#6#6"7v;''(%++a9  K 0S__[RU5V.tDz/B/B.C6%++WX X __TZZ -($/DEU? ", ==   $"4:#6#6"7vd5k>R>R=ST xrycv||z}|dd|ddt|jts|j|_|Srtr~rrMrrrrrs rw__iadd__zDatetimeLikeArrayMixin.__iadd__6)Q$**k2DJ rycv||z }|dd|ddt|jts|j|_|Srtrrs rw__isub__zDatetimeLikeArrayMixin.__isub__"rryc&t|||S)N)qs interpolation)r _quantile)rrrrs rwrz DatetimeLikeArrayMixin._quantile.s w Bm DDryaxisrc 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_axisrrTnanminr_wrap_reduction_resultrrrrrs rwminzDatetimeLikeArrayMixin.min6O F# dii0t}}4G**488ryc 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_maxrrrTnanmaxrrrs rwmaxzDatetimeLikeArrayMixin.maxHrryr)rrct|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 Axis for the function to be applied on. 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[us]', 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[s]', 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()rrr) r~rrMrrrrTnanmeanrrQr)rrrrs rwmeanzDatetimeLikeArrayMixin.meanZsuZ djj+ ..tDz/B/B.CD77   MMV$))+ **488ryc tjd||#t||jk\r t dt j |j||}|j||S)Nrz abs(axis) must be less than ndimr) rvalidate_medianabsrrrT nanmedianrrrs rwmedianzDatetimeLikeArrayMixin.medians^ 2v&  D TYY 6?@ @!!$--d6J**488rycd}|r|j}tj|jd|\}}|j|jj }t tj|}|j|S)Nr})r) rQrRmoderrrr rr1r)rdropnari8modes_npmodess rw_modezDatetimeLikeArrayMixin._modesj 99;D__TYYt_4@ ,,t}}223rzz7+&&w//ryc |j}|jdk(r)|dvrtd|d|dvr^td|d|dt|tr)|dvrtd|d |dvr%td|d |d|d vrtd |d |j j d }ddlm} | j|} | || |} | j|f|||dd|} | j| jvr| S| jd k(sJ|dvrvddl m} t|jtr tdtd|}d|j d}| j |} | j"| | jS| j |j j} |j%| S)Nr)sumprodcumsumcumprodvarskewkurtz,datetime64 type does not support operation 'r#)rIallzN' with datetime64 dtypes is no longer supported. Use (obj != pd.Timestamp(0)).z () instead.zPeriod type does not support z operationszK' with PeriodDtype is no longer supported. Use (obj != pd.Period(0, freq)).)rr!r#r$r"z"timedelta64 type does not support r|r)WrappedCythonOp)howrhas_dropped_na) min_countngroupscomp_idsr)stdsemrz-'std' and 'sem' are not valid for PeriodDtyperBzm8[rr)rrrr~rMrrpandas.core.groupby.opsr&get_kind_from_how_cython_op_ndim_compatr'cast_blocklistrrqr r.rr)rr'r(r)r*idsrrnpvaluesr&rrvrrq new_dtypes rw _groupby_opz"DatetimeLikeArrayMixin._groupby_ops   :: QQ"NseST UVVn$u4475 E { +QQ"?uK PQQn$u77:e;H > >@[QR R==%%h/;005 4 O.R..       66R&& & 8+++ . 9$**k2 OPP8$?Ddii[*I#3J->--j @P@PQ Q__T]]%8%89 &&z22ryreturnrD)NNF)r Dtype | NonerrDr7None)r7ztype[DatetimeLikeScalar])rrr7rr)rrrr7z)np.int64 | np.datetime64 | np.timedelta64)rrrr7r9r7r)r7rj)r7znpt.NDArray[np.int64])rz str | floatr7npt.NDArray[np.object_])F)rrDr7zCallable[[object], str])NN)rzNpDtype | Nonerz bool | Noner7r)rr6r7rr)rz(SequenceIndexer | PositionalIndexerTupler7r )rr4r7zSelf | DTScalarOrNaT)r7r)rz,int | Sequence[int] | Sequence[bool] | slicerzNaTType | Any | Sequence[Any]r7r9r7r9T)rrDr7r )rzLiteral['M8[ns]']r7ro)rzLiteral['m8[ns]']r7rq).)rr8r7r,rt)rnpt.NDArray[np.bool_]r7r9)rrDrrD)rrDr7r)rrD)r7z6np.int64 | np.datetime64 | np.timedelta64 | np.ndarray)r;zLiteral['ignore'] | None)rr,r7r?)r7r?)rrr7r)r7z str | None)r7zResolution | None)r7r)r7z@tuple[int | npt.NDArray[np.int64], None | npt.NDArray[np.bool_]])r7ro)rror7ro)rzdatetime | np.datetime64r7rq)rror7rq)rzTimestamp | DatetimeArrayr7rq)rrr7rp)rrqr7r )rzTimedelta | TimedeltaArrayr7r )rzPeriod | PeriodArrayr7r;)rr;r7r)rrrrDr7r )rznpt.NDArray[np.float64]rrr7r )rAxisInt | NonerrD)rrDrr@)rrD) r'rr(rDr)intr*rAr2znpt.NDArray[np.intp])ar __module__ __qualname____doc____annotations__r@rrpropertyrrrrrrrrrrrrrrrrrrrrr!r rr8rr7r\r?rVrQrFrJr!rOrQrTrXr[rardrhrurxrvrwrxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrerrrrrrrrrr rrrr5 __classcell__rs@rwrrs$#44)) IN('(AE( ( ((((("( 2(.(,( D :  ( ( (-$ ($ (  (AE#2= (CC  5  &<! 9!-!  !, 71r BB CC ??# "P % ;) ;)  ;)z>@D"    "    2,n!! ''.24  <!!!!F!!F--????@@ 7v( 2G(4H' 2G(4H+M:K,^M' 2G(4H*<8J+M:K  I $ ' 'R Q QB   *-* * *$  -  - U U&    (.(.$          * 2 2&  0 " "H8<@i(9)9v#i(9)9v'RE #EE  EE,099",099"&*!89t/3D990H3H3 H3  H3  H3"H3ryrceZdZdZddZy) DatelikeOpszK Common ops for DatetimeIndex/PeriodIndex, but not TimedeltaIndex. c|j|tj}tr(ddlm}t ||tjS|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 `__. 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='str') )rrr) StringDtyperrFr) rrrLrr<rLr3rr)rrrrLs rwstrftimezDatelikeOps.strftimesPZ**{266*R   *F+rvv*FG G}}V%}00ryN)rrr7r;)rrBrCrDrNrryrwrJrJs 21ryrJceZdZdZedZedZejd"dZe d#dZ e ed$dZ e d%dZ e d&dZe d'd Zd(d)d Zd Zd*fd ZdZ d+ d,dZ d+ d,dZ d+ d,dZdd dd-dZdd dd-dZd"dZd.dZd/fd Z d0 d1fd Ze d2 d3fd Zd4d5fd Z d6dZdddd d7fd Z ed8d!Z!xZ"S)9rozK Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex. ct|rtr)r rrs rw_validate_dtypezTimelikeOps._validate_dtype5s !#&&ryc|jS)ac Return the frequency object if it is set, otherwise None. To learn more about the frequency strings, please see :ref:`this link`. See Also -------- DatetimeIndex.freq : Return the frequency object if it is set, otherwise None. PeriodIndex.freq : Return the frequency object if it is set, otherwise None. Examples -------- >>> datetimeindex = pd.date_range( ... "2022-02-22 02:22:22", periods=10, tz="America/Chicago", freq="h" ... ) >>> datetimeindex DatetimeIndex(['2022-02-22 02:22:22-06:00', '2022-02-22 03:22:22-06:00', '2022-02-22 04:22:22-06:00', '2022-02-22 05:22:22-06:00', '2022-02-22 06:22:22-06:00', '2022-02-22 07:22:22-06:00', '2022-02-22 08:22:22-06:00', '2022-02-22 09:22:22-06:00', '2022-02-22 10:22:22-06:00', '2022-02-22 11:22:22-06:00'], dtype='datetime64[us, America/Chicago]', freq='h') >>> datetimeindex.freq rrs rwrzTimelikeOps.freq9s8zzryc|qt|}|j|||jjdk(r!t |t t fs td|jdkDr td||_ y)Nr(TimedeltaArray/Index freq must be a TickrzCannot set freq with ndim > 1) r&_validate_frequencyrrr~rrrrrrrs rwrzTimelikeOps.freqWsi  e$E  $ $T5 1zz#%js .L JKKyy1} !@AA rycR|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. Ninfer)rr&rTr no_defaultrrV_validate_inferred_freq)rr validate_kwdss rw_maybe_pin_freqzTimelikeOps._maybe_pin_freqds <DJ W_zz!'t'9'9: "S^^ #  ZZ T?D *DJ * *4 G GDJT?D #D$** 5ryc |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)startendperiodsrr.z non-fixedInferred frequency 9 from passed values does not conform to passed frequency r) rTrgrQ_generate_rangerr.r array_equalrrr)r indexrrinferredon_freqrs rwrVzTimelikeOps._validate_frequencys&& ::?h$,,6 )c))AhE ZZ   G>>%**gll;  < c#h& %hZ088< ~G  sAB C+CCct|rtr)r r^r_r`rrrs rwrczTimelikeOps._generate_ranges"#&&ryc@t|jjSrt)r rrrs rwrzTimelikeOps._cresos"4==#6#677ryc,t|jS)a4 The precision unit of the datetime data. Returns the precision unit for the dtype. It means the smallest time frame that can be stored within this dtype. Returns ------- str Unit string representation (e.g. "ns"). See Also -------- TimelikeOps.as_unit : Converts to a specific unit. Examples -------- >>> idx = pd.DatetimeIndex(["2020-01-02 01:02:03.004005006"]) >>> idx.unit 'ns' >>> idx.as_unit("s").unit 's' ) dtype_to_unitrrs rwr.zTimelikeOps.units6TZZ((ryTc|dvr tdtj|jjd|d}t |j ||}t |jtjr |j}n#td|j}t||}t|j|||jS) aZ Convert to a dtype with the given unit resolution. The limits of timestamp representation depend on the chosen resolution. Different resolutions can be converted to each other through as_unit. Parameters ---------- unit : {'s', 'ms', 'us', 'ns'} round_ok : bool, default True If False and the conversion requires rounding, raise ValueError. Returns ------- same type as self Converted to the specified unit. See Also -------- Timestamp.as_unit : Convert to the given unit. Examples -------- For :class:`pandas.DatetimeIndex`: >>> idx = pd.DatetimeIndex(["2020-01-02 01:02:03.004005006"]) >>> idx DatetimeIndex(['2020-01-02 01:02:03.004005006'], dtype='datetime64[ns]', freq=None) >>> idx.as_unit("s") DatetimeIndex(['2020-01-02 01:02:03'], dtype='datetime64[s]', freq=None) For :class:`pandas.TimedeltaIndex`: >>> tdelta_idx = pd.to_timedelta(["1 day 3 min 2 us 42 ns"]) >>> tdelta_idx TimedeltaIndex(['1 days 00:03:00.000002042'], dtype='timedelta64[ns]', freq=None) >>> tdelta_idx.as_unit("s") TimedeltaIndex(['1 days 00:03:00'], dtype='timedelta64[s]', freq=None) )rmsusnsz)Supported units are 's', 'ms', 'us', 'ns'z8[rr'rorr) rrrrrrr~r rrKrrr)rr.r(rrr4rs rwr/zTimelikeOps.as_unitsT . .HI IDJJOO,BtfA67(Q djj"(( +"((Iot,//B'2D9IDz%% &  ryc|j|jk7rS|j|jkr|j|j}||fS|j|j}||fSrt)rr/r.rs rwrz"TimelikeOps._ensure_matching_resoss^ ;;%,, &{{U\\)||EJJ/U{ dii0U{ryc|tjtjtjfvr2t |dk(r$|d|urt |||j fi|St| ||g|i|S)Nrr) risnanisinfisfiniterrrr__array_ufunc__)rufuncmethodinputsrrs rwruzTimelikeOps.__array_ufunc__%sq bhh"++6 6F q q T!*75&)$--B6B Bw&ufHvHHHrycLt|jtrOtd|}|j d}|j ||||}|j |j ||S|jd}ttj|}t||j}|dk(r|jSt|||} |j| t}|j|j j}|j#||jS)Nro) ambiguous nonexistentr}rrNr)r~rrKr tz_localize_roundrrrr1r*rrr(rOr!rr) rrrrzr{naiverrnanos result_i8s rwr~zTimelikeOps._round0s djj/ 2.D$$T*E\\$iEF%%9+& 4bjj&)"45 A:99; !&$6 ))))ET]]001djj99rycF|j|tj||S)a Perform round operation on the data to the specified `freq`. Parameters ---------- freq : str or Offset The frequency level to round 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 a ValueError 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 a ValueError 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. See Also -------- DatetimeIndex.floor : Perform floor operation on the data to the specified `freq`. DatetimeIndex.snap : Snap time stamps to nearest occurring frequency. Notes ----- If the timestamps have a timezone, rounding will take place relative to the local ("wall") time and re-localized to the same timezone. When rounding 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[us]', freq='min') >>> rng.round('h') DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00', '2018-01-01 12:00:00'], dtype='datetime64[us]', 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[us] 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[us, Europe/Amsterdam]', freq=None) >>> rng_tz.floor("2h", ambiguous=True) DatetimeIndex(['2021-10-31 02:00:00+02:00'], dtype='datetime64[us, Europe/Amsterdam]', freq=None) )r~r'NEAREST_HALF_EVENrrrzr{s rwroundzTimelikeOps.roundFs L{{4!:!:I{SSrycF|j|tj||S)a Perform floor operation on the data to the specified `freq`. Parameters ---------- freq : str or Offset The frequency level to floor 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 a ValueError 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 a ValueError 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. See Also -------- DatetimeIndex.floor : Perform floor operation on the data to the specified `freq`. DatetimeIndex.snap : Snap time stamps to nearest occurring frequency. Notes ----- If the timestamps have a timezone, flooring will take place relative to the local ("wall") time and re-localized to the same timezone. When flooring 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[us]', freq='min') >>> rng.floor('h') DatetimeIndex(['2018-01-01 11:00:00', '2018-01-01 12:00:00', '2018-01-01 12:00:00'], dtype='datetime64[us]', 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[us] 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[us, Europe/Amsterdam]', freq=None) >>> rng_tz.floor("2h", ambiguous=True) DatetimeIndex(['2021-10-31 02:00:00+02:00'], dtype='datetime64[us, Europe/Amsterdam]', freq=None) )r~r' MINUS_INFTYrs rwfloorzTimelikeOps.floors L{{4!4!4iMMrycF|j|tj||S)a Perform ceil operation on the data to the specified `freq`. Parameters ---------- freq : str or Offset The frequency level to ceil 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 a ValueError 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 a ValueError 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. See Also -------- DatetimeIndex.floor : Perform floor operation on the data to the specified `freq`. DatetimeIndex.snap : Snap time stamps to nearest occurring frequency. Notes ----- If the timestamps have a timezone, ceiling will take place relative to the local ("wall") time and re-localized to the same timezone. When ceiling 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[us]', freq='min') >>> rng.ceil('h') DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00', '2018-01-01 13:00:00'], dtype='datetime64[us]', 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[us] 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[us, Europe/Amsterdam]', freq=None) >>> rng_tz.ceil("h", ambiguous=True) DatetimeIndex(['2021-10-31 02:00:00+02:00'], dtype='datetime64[us, Europe/Amsterdam]', freq=None) )r~r' PLUS_INFTYrs rwceilzTimelikeOps.ceil s L{{4!3!3Y LLryNrcdtj|j|||jSNr)rTnananyrrQrrrs rwrIzTimelikeOps.any s!}}T]]f499;WWrycdtj|j|||jSr)rTnanallrrQrs rwr%zTimelikeOps.all s#}}T]]f499;WWrycd|_yrtrSrs rwrzTimelikeOps._maybe_clear_freq s  ryc"|ntt|dk(rJt|tr:|jjdk(r=t|t t fs'td|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 rrrUrX) rr~rrrrrrr&rTrr)rrrs rw _with_freqzTimelikeOps._with_freq s~ <  Y!^ 4 <zz#%jc{.K JKK7? "?T//0Diik  ryct|jtjr |jSt|Srt)r~rrrr_values_for_json)rrs rwrzTimelikeOps._values_for_json s- djj"(( +== w'))ryFc|j|rX|jjdkr?tjt |dz ddtj }|ddd}||fStjt |tj }|j }||fS|r"tdt|jdt|-|S)NrrrzThe '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) rrrarangerintprNotImplementedErrorrrr factorize)rrsortcodesuniquesrs rwrzTimelikeOps.factorize s 99  a #d)a-RrwwGtt*'> ! #d)277;))+'> ! &(d)<)<(=>==  w  AAryrc4t|||}|d|dk(rv|Dcgc]}t|s|}}jOt fd|Dr;t |dd|ddd}t fd|Drj}||_|Scc}w)Nrc3PK|]}|jjk(ywrtr)rrrs rwrz0TimelikeOps._concat_same_type.. s+R1AFFchh,>+Rs#&rrT)strictc3ZK|]"}|ddjz|ddk($yw)rrrNr)rpairrs rwrz0TimelikeOps._concat_same_type.. s/NtAwr{SXX-a;Ns(+)r_concat_same_typerrr%zipr) r  to_concatrnew_objrpairsrrrs @rwrzTimelikeOps._concat_same_type s '+It<l 19%.8qQ8I8xx#+R +R(RIcrNIabM$GNNN"xxH$,GM9s BBcJt||}|j|_|S)N)order)rrrr)rrrrs rwrzTimelikeOps.copy s#',U,+  ryc |dk7rt|s |j} n|jj} tj| f||||||d||s|St |j | |jS)z2 See NDFrame.interpolate.__doc__. linear)rwrrelimitlimit_direction limit_arear)rrrrSinterpolate_2d_inplacerrr) rrwrrerrrrrout_datas rw interpolatezTimelikeOps.interpolate s X % %}}H}}))+H&&  +!  KDz%%hdjj%AAry) allow_fillrNrct|||||}tj|tj}t j |t|}t|tr|j|}||_ |S)N)indicesrrNrr) rtakerrrrmaybe_indices_to_slicerr~rrr) rrrrNrr maybe_slicerrs rwrzTimelikeOps.take st zPT **WBGG400#d)D k5 )))+6DFL ryc 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) rrrrr!r r$r logical_andr)r values_intconsider_valuesrppd even_dayss rw_is_dates_onlyzTimelikeOps._is_dates_only( sstzz*YY $,"4::.d#NN?J4D4IJNNPTUU ryr<)r[dictr7r9)rrr7r9)r` int | Noner7r )r7rA)r7rlr=)r.rlr(rDr7r )rvznp.ufuncrwr)raiser)rzr9r{r:r7r )rr@rrDr7rDr>r:)TF)rrDrrD)r)rzSequence[Self]rr-r7r )C)rrr7r ) rwr2rrArernrrDr7r ) rr8rrDrNrrr-r7r r6)#rrBrCrD classmethodrQrFrsetterrr\rVrcr@rr.r/rrur~rrrrIr%rrrrrrrrrrGrHs@rwroro0s'': [[   6 6@ ( (T'",' ''88))8< @ I:2$+'. fT!fT% fT  fTV$+'. fN!fN% fN  fNV$+'. fM!fM% fM  fMV-1X-1X@*!%BBB2!  * $B#$B $B  $B$B $BT!       0ryroct|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) NrrFzCannot create a z from a MultiIndex.Tr,rrrMr|)r$r~rtuplerrrBrOrrbr_r]rrr=r!_maybe_convert_datelike_arrayr1r^rrNr4rrr_values)rrcls_names rw!ensure_arraylike_for_datetimelikerB s\ 4 !$u .2774=A3E:D6t< D- (*8*4GHIIT6$ %4,-$**//T2I}}Wt}4 : D- .113}} :rzz>: ;zz$ : D. )##DJJ3#?GG :rycyrtrr`s rwvalidate_periodsri s-0rycyrtrrs rwrrm s+.rycP|#tj|std||S)a. If a `periods` argument is passed to the Datetime/Timedelta Array/Index constructor, cast it to an integer. Parameters ---------- periods : None, int Returns ------- periods : None or int Raises ------ TypeError if periods is not None or int z periods must be an integer, got )rrrrs rwrrq s/$3>>'#::7)DEE NrycV|&| ||k7rtd|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 rarb)rrQ)rrTs rwrZrZ sO    5%m_5?<<."  < D Kryct|tr |jSt|tr3|jdvrt d|d|j jStj|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 rzdtype=z does not have a resolution.r) r~rKr.rIrr pyarrow_dtyper datetime_datars rwrkrk sk%)zz E: & ::T !x'CDE E""'''  E "1 %%ry)rur)rr1r7r1)rrDrrr7ztuple[ArrayLike, bool])r`r9r7r9)r`rAr7rA)r`rr7r)rrrTrr7r)rz'DatetimeTZDtype | np.dtype | ArrowDtyper7r) __future__rrr functoolsrrltypingrrr r r r r rrrnumpyrpandas._configrpandas._config.configr pandas._libsrrpandas._libs.tslibsrrrrrrrrrrrrr r!r"r#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/r0r1r2r3r4r5r6r7r8r9r:r;pandas.compat.numpyr<r pandas.errorsr=r>r?pandas.util._decoratorsr@pandas.util._exceptionsrApandas.core.dtypes.castrBpandas.core.dtypes.commonrCrDrErFrGrHpandas.core.dtypes.dtypesrIrJrKrLrMpandas.core.dtypes.genericrNrOpandas.core.dtypes.missingrPrQ pandas.corerRrSrTrUpandas.core.algorithmsrVrWrXpandas.core.array_algosrYpandas.core.arraylikerZpandas.core.arrays._mixinsr[r\pandas.core.arrays.arrow.arrayr]pandas.core.arrays.baser^pandas.core.arrays.integerr_pandas.core.commoncorecommonrpandas.core.constructionr`r3rarbpandas.core.indexersrcrdpandas.core.ops.commonrepandas.core.ops.invalidrfrgpandas.tseriesrhcollections.abcrirjrkrlr<rnrrorprqrrrErxrrrJrorrrZrkrryrwrs"   -,*K=C$/ 5K   ?*?23  < ' ( .7 y71 2k3X'Bk3\171(71tK (K d$$ #$$N 0 0 . .2 ,=:&ry