jwUddlmZddlmZmZddlmZddlZddlmZm 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*<dKd-ZdLd1ZGd2d3euewZGd4d5eZGd6d7eZdMd<ZedNd?ZedOdAZdPdCZdQdGZdRdJZdS)S) 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 DTScalarOrNaTop_namestrcPt|}t||SN)rgre)rsops MC:\Projects\DSCons\.venv\Lib\site-packages\pandas\core\arrays\datetimelike.py_make_unpacked_invalid_oprys(  ! !B , #G , ,R 0 00methr1returncbtfd}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) isinstancedtyperMviewrr _box_func_value_from_backing_data)selfargskwargsarrresultres_i8r{s rxnew_methz"_period_dispatch..new_meths$*k22 /4.t...v.. .ii!!c+D+++F++ S==J  * * 1>>&-00 0T""&&v...rz)rr r1)r{rs` rx_period_dispatchrs@ 4[[ / / / /[ / 8  rzceZdZUdZded<ded<ded<ded <d ed <eddZ dddZeddZ ddZ ddZ ddZ d Z dd!Zdd#Zedd%Zd&dd'dd+Zddd.Z ddd1Zedd4Zedd7Zdƈfd: Zdd;ZdȈfd> Zdd?ZddˈfdA ZeddBZeddEZeddHZedddKZddЈfdL Zd҈fdO ZdPZdd@dQddTZdddUZdddWZdXZ e!ddZZ"e#ddd]Z$dd_Z%dd`Z&eddaZ'eddbZ(e)dfdddZ*eddfZ+eddgZ,eddiZ-eddjZ.eddkZ/eddlZ0eddmZ1dnZ2e3doZ4e3dpZ5e3dqZ6e3drZ7e3dsZ8e3dtZ9e3duZ:e3dvZ;e3dwZ<e3dxZ=e3dyZ>e3dzZ?e!dd|Z@e!dd}ZAe!dd~ZBe!ddZCe!ddZDe!ddZEe!ddZFe!ddZGdZHdZIddZJe!ddZKe!ddZLe!ddZMe!ddZNe!ddZOd@dddZPeQddZRdZSeQddZTdZUddZVddZWeXdfd ZYeXdd@dddZZeXdd@dddZ[d@ddddZ\eXdd@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 | Nonefreqr|boolcdS)NTrs rx _can_hold_naz#DatetimeLikeArrayMixin._can_hold_nastrzNFr Dtype | NonecopyNonec t|rvr=)rdatarrrs rx__init__zDatetimeLikeArrayMixin.__init__s"$'''rztype[DatetimeLikeScalar]c t|)z The scalar associated with this datelike * PeriodArray : Period * DatetimeArray : Timestamp * TimedeltaArray : Timedelta rrs rx _scalar_typez#DatetimeLikeArrayMixin._scalar_types"$'''rzvaluertrrc 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 rx_scalar_from_stringz*DatetimeLikeArrayMixin._scalar_from_string$"$'''rz)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]) np.datetime64('1970-01-01T00:00:00.000000000') rrs rx _unbox_scalarz$DatetimeLikeArrayMixin._unbox_scalars*"$'''rzotherc 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 rx_check_compatible_withz-DatetimeLikeArrayMixin._check_compatible_withrrzc t|)zI box function to get object from internal representation r)rxs rxrz DatetimeLikeArrayMixin._box_func/s"$'''rzc:tj||jdS)z1 apply box func to passed values F)convert)r map_inferrrvaluess rx _box_valuesz"DatetimeLikeArrayMixin._box_values5s}VT^UCCCCrzrjcjdkr(fdttDSfdjDS)Nc3(K|] }|V dSrvr).0nrs rx z2DatetimeLikeArrayMixin.__iter__..=s'66DG666666rzc3BK|]}|VdSrv)r)rvrs rxrz2DatetimeLikeArrayMixin.__iter__..?s/99!DNN1%%999999rz)ndimrangelenasi8rs`rx__iter__zDatetimeLikeArrayMixin.__iter__;sR 9q==6666U3t99%5%5666 69999ty999 9rznpt.NDArray[np.int64]c6|jdS)z Integer representation of the values. Returns ------- ndarray An ndarray with int64 dtype. r)rrrs rxrzDatetimeLikeArrayMixin.asi8As}!!$'''rzr)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 rx_format_native_typesz+DatetimeLikeArrayMixin._format_native_typesQs"$'''rzboxedCallable[[object], str]cdjS)Nz'{}')format)rrs rx _formatterz!DatetimeLikeArrayMixin._formatter]s }rzNpDtype | None bool | Nonec4t|r;|durtdtjt |t S|durtj|j|S|j}|jr |}d|j _ |S)NFz:Unable to avoid copy while creating an array as requested.rT) rF ValueErrornpr`listobjectr _readonlyrflags writeable)rrrrs rx __array__z DatetimeLikeArrayMixin.__array__ds 5 ! ! 6u}} P8DJJf555 5 4<<8DM777 7 > +[[]]F%*FL " rzkeyr6cdSrvrrrs rx __getitem__z"DatetimeLikeArrayMixin.__getitem__x@Crz(SequenceIndexer | PositionalIndexerTupler cdSrvrrs rxrz"DatetimeLikeArrayMixin.__getitem__{s srzr4Self | DTScalarOrNaTcttttft |}t j|r|Stt|}|||_ |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 rxrz"DatetimeLikeArrayMixin.__getitem__steD-/0%''2E2Ec2J2JKK =  (M$''F--c22  rzct|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)rrrMrrrcslicestepEllipsiscomis_bool_indexerrmaybe_booleans_to_slicerruint8r)rr is_periodrnew_keys rxrz(DatetimeLikeArrayMixin._get_getitem_freqstz;77  ;9DD Y!^^DD%dC00CD#u%% ;9(SX-A8di/DD9DDy$S)) ;5chhrx6H6HIIgu--;11'::: rz,int | Sequence[int] | Sequence[bool] | sliceNaTType | Any | Sequence[Any]ct|||}t|||rdS|dSrv)rdr __setitem___maybe_clear_freq)rrrno_oprs rxrz"DatetimeLikeArrayMixin.__setitem__sW&c5$77 C'''   F      rzcdSrvrrs rxrz(DatetimeLikeArrayMixin._maybe_clear_freqs  rzTcht|}|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)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#rrravelreshapeshaperGrrLrna_valueconstruct_array_type_from_sequencerastyperint64 TypeErrorrtype__name__asarray) rrri8data converted arr_objectclsrmsgrs rxrzDatetimeLikeArrayMixin.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 0rzcdSrvrrs rxrzDatetimeLikeArrayMixin.viewsCrzLiteral['M8[ns]']rocdSrvrrrs rxrzDatetimeLikeArrayMixin.view s?BsrzLiteral['m8[ns]']rqcdSrvrr!s rxrzDatetimeLikeArrayMixin.view rrz.r,cdSrvrr!s rxrzDatetimeLikeArrayMixin.viewsrrrrrrEr_validate_listlikerFgetattr)rrerrs rx_validate_comparison_valuez1DatetimeLikeArrayMixin._validate_comparison_values eS ! ! 8 80077 56 8 8 8'..C7 8 eT5 6 6 <%3,,%%e,,E 8++E2222 8 8 8'..C7 8e$$ <#E** * ZZ3t99 $ $122 2 <//D/II++E2222 < < <"75'4#@#@AA<+E22;DDDD < sD-AAA B B?*B::B?,D== F/E;;F)allow_listlikeunboxr0r1clt||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) rrrtrr_validation_error_messagerrPrrrQrr)rrr0r1r.rs rx_validate_scalarz'DatetimeLikeArrayMixin._validate_scalarCsJ0 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 rrrz array'zvalue should be a 'z!', 'NaT', or array of those. Got z instead.z' or 'NaT'. Got )hasattrr-rrrr)rrr0msg_gotrs rxr3z0DatetimeLikeArrayMixin._validation_error_messages 5' " " 2wufa'@'@1'D'D,,,GG1$u++.111G  =d&7&@==*1=== C *d&7&@*****  rzr+c<t|t|r>|jjdvr.|s,|j|jkr||jd}|St|t rs {rzc"|jtkS)z- return if each value is nan )rr!rs rxrZzDatetimeLikeArrayMixin._isnanAs yD  rzcNt|jS)zJ return if I have any nans; enables various perf speedups )rrZanyrs rx_hasnazDatetimeLikeArrayMixin._hasnaHs DKOO%%&&&rzrc|jr@|r||}| 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. )r^rrnanputmaskrZ)rr fill_valuers rx_maybe_mask_resultsz*DatetimeLikeArrayMixin._maybe_mask_resultsOsO& ; 8 0w//!V Jvt{J 7 7 7 rz str | Nonec,|jdS|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 rxrfzDatetimeLikeArrayMixin.freqstrms@ 9 4y  rzch|jdkrdS tj|S#t$rYdSwxYw)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 rx inferred_freqz$DatetimeLikeArrayMixin.inferred_freqsL: 9>>4 )$// /   44 s # 11Resolution | Nonecd|j}|dS tj|S#t$rYdSwxYwrv)rfrget_reso_from_freqstrKeyError)rrfs rx_resolution_objz&DatetimeLikeArrayMixin._resolution_objsK, ?4 3G<< <   44 s ! //c|jjS)zO Returns day, hour, minute, second, millisecond or microsecond )rnattrnamers rx resolutionz!DatetimeLikeArrayMixin.resolutions #,,rzcDtj|jddS)NTtimelikerr is_monotonicrrs rx_is_monotonic_increasingz/DatetimeLikeArrayMixin._is_monotonic_increasing!$)d;;;A>>rzcDtj|jddS)NTrsrrurs rx_is_monotonic_decreasingz/DatetimeLikeArrayMixin._is_monotonic_decreasingrxrzc|tt|jd|jkS)NK)rrXrr sizers rx _is_uniquez!DatetimeLikeArrayMixin._is_uniques-8DIOOC001122di??rzc|jdkrbt|dd|jkrH||||jS ||}nT#t $rGt|dr#t|j tr tcYSt|||cYSwxYwt|dd}t|rBtj|t!j|t&|}|S|t(urQ|t*jur!t!j|jt0}n t!j|jt0}|St|j t4st7t8|}|j|jkrt|t=|s] ||j d}n\#tB$r2t!j"|j#}tI|j%||cYSwxYw|j%}tI|j%||S|&|}||j%'d|'d}tQ|}|j)|z}|*r$|t*ju} t!j+||| |S)NrrrrFr:r),rr-rr rr/r>r7rrrINotImplementedrfrFrUcomp_method_OBJECT_ARRAYrrrrroperatorneonesrrXrMr TimelikeOpsr rrBrArr`asm8r)rrJrrQrZr]ra) rrrwrr other_arr other_valso_maskr& nat_results rx _cmp_methodz"DatetimeLikeArrayMixin._cmp_methods 9q==WUGT::djHH2djjllEKKMM22::4:FF F 733E::EE  7 7 7ug&& &:ek:+N+N &%%%%%dE266 6 6 6 7 w-- 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*/B;CCC2H9I  I __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)rrordinalrrrrZr)rri8valuesr&s rx_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::(}(5xPPPPrzctj|jds9tdt |jdt |j||zS)Nrrr)rrrrrrrs rx_add_datetime_arraylikez.DatetimeLikeArrayMixin._add_datetime_arraylikes[tz3// Nd4jj1NNU 8LNN  t|rzdatetime | np.datetime64c4|jjdkr$tdt|jt d|}t |r |tz St|}| |\}}| |S)Nr"cannot subtract a datelike from a ro) rr rrrr rQrrr_sub_datetimelike)rrtss rx_sub_datetimelike_scalarz/DatetimeLikeArrayMixin._sub_datetimelike_scalars :?c ! !VdATVVWW WOT** ;; #:  u  ..r22b%%b)))rzcB|jjdkr$tdt|jt |t |krt dtd|}||\}}| |S)Nrr$cannot add indices of unequal lengthro) rr rrrrrr rrrs rx_sub_datetime_arraylikez.DatetimeLikeArrayMixin._sub_datetime_arraylikes :?c ! !VdATVVWW W t99E " "CDD DOT**11%88 e%%e,,,rzTimestamp | DatetimeArrayc2td|}ddlm} ||nN#t$rA}t |dd}t|||d}~wwxYw||\}}t|j tj | d}| d|jd }||} td | } |j||j| S) Nrorrqcomparesubtractrr timedelta64[rz Tick | Noner)r rrq_assert_tzawareness_compatrrtreplacerrrrrrrrArrr) rrrqr. new_messagerrrres_m8rs rxrz(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---rzct|t|krtdtd||\}}||S)zl Add a delta of a TimedeltaIndex Returns ------- Same type as self rrW)rrr rrrs rx_add_timedelta_arraylikez/DatetimeLikeArrayMixin._add_timedelta_arraylikesi t99E " "CDD D ,d   ' ' e&&u---rzTimedelta | TimedeltaArrayc@||\}}t|jtj|d}||jj}||}t| ||j|S)Nrrr) rrrrrrrrrrr)rrrrrrrs rxrz)DatetimeLikeArrayMixin._add_timedeltalikes77>>&%diHD1Q1Q1QRR __T]%899 33E::Dzz%% *&   rzct|jtr>tdt |jdt t jtj|j tj }| t| |jj}t |||jdS)z$ Add pd.NaT to self z Cannot add rrNr)rrrMrrrrrrrrrr!rrrrrs rx_add_natzDatetimeLikeArrayMixin._add_nats dj+ . . Ld4jj1LLS 8JLL  $*BH555 DT]011Dzz%% *&   rzc"tj|jtj}|t |jjdvr.td|}| d|j dS| dS)z+ Subtract pd.NaT from self rr zDatetimeArray| TimedeltaArrayrrztimedelta64[ns]) rrrrrr!rr r rrArs rx_sub_natzDatetimeLikeArrayMixin._sub_nats$*BH555 D :?d " "7>>D;;:di:::;; ;;;011 1rzPeriod | PeriodArrayctjts9tdt |jdt jt d||\}}tj tj | d}tj fd|D}|j}n j|z}t||<|S)Ncannot subtract  from rprrc.g|]}jj|zSr)rbase)rrrs rx z:DatetimeLikeArrayMixin._sub_periodlike..;s"EEEATY^a/EEErz)rrrMrrrr rrrrrrr`rZr)rrrr new_i8_datanew_datar&s` rx_sub_periodlikez&DatetimeLikeArrayMixin._sub_periodlike-s$*k22 T4;;#7TTtDzz?RTT M4(( ##E***77>>&&ty"*hYd2S2S2STT 8EEEEEEEFF >;DD;'Drzc|tjtjfvsJt|dkr|jdkr|||dSt dr>t jdt|j dtt|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. rrperformance_warningsz)Adding/subtracting object-dtype array to z not vectorized.) stacklevelO)raddsubrrrwarningswarnrrr?rArrrr)rrrwrs rx_addsub_object_arrayz+DatetimeLikeArrayMixin._addsub_object_arrayFs hlHL11111 u::??tyA~~2dE!H%% % , - -  M9::&999"+--     zU[(((4:u{*C(((R C(("*U*;*;<< rz)skipnanamerc |dvr"td|dt|tt|}||fd|i|}t|||jS)N>cummaxcumminz Accumulation z not supported for rr)rrr-rYrrr)rrrrrwrs rx _accumulatez"DatetimeLikeArrayMixin._accumulateks + + +QDQQT$ZZQQRR R / 6 6DIIKK999&99Dzz%%fDJ%???rz__add__ct|dd}t|}|tur|}nt |t t tjfr| |}nt |trYtj |j dr?t|jd}| |}n=t |t"r||}nt |t&tjfr||}nt |t,r1tj |j dr||}ntj|rht |j t2st5|t7d|}|||j jzt<j}ntj |dr| |}ntC|r!|"|t<j}ntj |dst |tFr|$|StK|rgt |j t2st5|t7d|}|||j jzt<j}ntLSt |tj'r7tj |j drdd l(m)}|j*||j S|S) NrMmdayssrrprrrr)+r-rarrrrrr timedelta64rrrrrrrrBrrr datetime64rrr is_integerrMr+r _addsub_int_array_or_scalar_nrrrrFrrKrrDrrDrrqrrr other_dtypertdobjrqs rxrzDatetimeLikeArrayMixin.__add__tseWd33 .u55 C<<:>--//FF i@ A A, "33E::FF s # #* " D(I(I* "(((0055B33B77FF 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 ) ) McoflC.P.P M 9 9 9 9 9 90>0v|LLL L rzc,||Srv)rrs rx__radd__zDatetimeLikeArrayMixin.__radd__s||E"""rz__sub__c&t|dd}t|}|tur|}nt |t t tjfr| | }nt |trZtj |j dr@t|jd}| | }nRt |t"r|| }n%t |t&tjfr||}ntj|rht |j t.st1|t3d|}|||j jzt8j}nqt |t<r||}nEtj |dr| | }ntC|r!|"|t8j}ntj |dst |tFr|$|}nt |t.r||}n}tK|rgt |j t.st1|t3d|}|||j jzt8j}ntLSt |tj'r7tj |j drdd l(m)}|j*||j S|S) Nrrrrrprrrrr)+r-rarrrrrrrrrrrrrrrBrrrrrrrMr+r rrrrrrrrFrrKrrDrrDrrqrrs rxr zDatetimeLikeArrayMixin.__sub__s4eWd33 .u55 C<<:>--//FF i@ A A, "33UF;;FF s # #* " D(I(I* "(((0055B33RC88FF 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 ) ) McoflC.P.P M 9 9 9 9 9 90>0v|LLL L rzc t|dd}tj|dpt|t}|rwtj|jdr]tj|rt||z St|tsddl m }|j ||j}||z S|jj dkrTt|drD|sBtdt|jdt|jd |jd t|jt"rAtj|dr,tdt|jd|jtj|jdrt%d |}| |zS||z }|jj dkr9tdt|jdt|j| S) Nrrrrrrrr[rrq)r-rrrrKrrrrrrorr r7rrrrMr )rrr other_is_dt64roflippeds rx__rsub__zDatetimeLikeArrayMixin.__rsub__s#eWd33  S99 Z > >   #S_TZ== #}U## / ''$..e%;<< O<<<<<<4 4U%+NNN4<  Z_ # #w(?(? # #94::#699;;'99*/+999  K 0 0 #S_[RU5V5V #WtDzz/BWW%+WWXX X _TZ - - #($//DEU? ", =  $ $T4::#6TTd5kk>RTT xrzcz||z}|dd|dd<t|jts |j|_|SrvrrrMrrrrrs rx__iadd__zDatetimeLikeArrayMixin.__iadd__B)QQQ$*k22 %DJ rzcz||z }|dd|dd<t|jts |j|_|Srvrrs rx__isub__zDatetimeLikeArrayMixin.__isub__"rrzqsnpt.NDArray[np.float64] interpolationcJt||S)N)rr)r _quantile)rrrrs rxrz DatetimeLikeArrayMixin._quantile.s" ww  Bm DDDrzaxisrrAxisInt | 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_axisrrTnanminr_wrap_reduction_resultrrrrrs rxminzDatetimeLikeArrayMixin.min6Y F### di000t}4GGG**4888rzc 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_maxr"rrTnanmaxrr$r%s rxmaxzDatetimeLikeArrayMixin.maxHr'rzr)rrc 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 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&) rrrMrrrrTnanmeanrrQr$)rrrrs rxmeanzDatetimeLikeArrayMixin.meanZsZ dj+ . . 7tDzz/B777   MV$))++   **4888rzc tjd||'t||jkrt dt j|j||}|||S)Nrz abs(axis) must be less than ndimr) r validate_medianabsrrrT nanmedianrr$r%s rxmedianzDatetimeLikeArrayMixin.mediansk 2v&&&  D TY 6 6?@@ @!$-d6JJJ**4888rzdropnac&d}|r|}tj|d|\}}||jj}t tj|}| |S)Nr)r&) rQrRmoderrrr rrDr)rr5r&i8modes_npmodess rx_modezDatetimeLikeArrayMixin._modesy  99;;D_TYYt__4@@@ ,,t}233rz7++&&w///rzhowhas_dropped_na min_countintngroupsidsnpt.NDArray[np.intp]c |j}|jdkr2|dvrtd|d|dvrtd|d|dn^t|tr2|dvrtd|d |dvrtd|d |dn|d vrtd |d |jd }ddlm} | |} | || |} | j |f|||dd|} | j | j vr| S| jd ksJ|dvrvddl m} t|jtrtdtd|}d|jd}| |} | j| | jS| |jj} || S)Nr)sumprodcumsumcumprodvarskewkurtz,datetime64 type does not support operation 'r6)r]allzN' 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)).)rErGrIrJrHz"timedelta64 type does not support rr)WrappedCythonOp)r<r r=)r>r@comp_idsr&)stdsemrz-'std' and 'sem' are not valid for PeriodDtyperWzm8[rr)rr rrrMrrpandas.core.groupby.opsrLget_kind_from_how_cython_op_ndim_compatr<cast_blocklistrrqr rArr)rr<r=r>r@rArrnpvaluesrLr rwrrq new_dtypes rx _groupby_opz"DatetimeLikeArrayMixin._groupby_ops  :  QQQ Us U U UVVVn$$EEE47EEE%{ + + SQQQ P P P PQQQn$$HHH7:HHH%> > >QQQQRR R=%%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 &&z222rzr|r)NNF)rrrrr|r)r|r)rrtr|rr)rrrr|r)rrrr|rr|r)r|rj)r|r)rrr|r)F)rrr|r)NN)rrrrr|r)rr6r|rr)rrr|r )rr4r|r)r|r)rrrrr|rr|rT)rrr|r )rrr|ro)rr"r|rq).)rrr|r,rv)r&r'r|r)r0rr1r)r0rr|rt)r+r)r|rL)rNrO)rr,r|r')r|r')rrr|r)r|rd)r|rj)r|rt)r|r)r|ro)rror|ro)rrr|rq)rror|rq)rrr|rq)rrr|rp)rrqr|r )rrr|r )rrr|r)rrr|r)rrtrrr|r )rrrrtr|r )rrrr)rrrr)r5r) r<rtr=rr>r?r@r?rArB)ar __module__ __qualname____doc____annotations__r@rrpropertyrrrrrrrrrrrrrrrrrrr)r/r4r3r,rKrrJr\rTrVrQrZr^r!rcrfrirnrqrwrzr~rryrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrerrr rrrrrr&r+r/r4r;rV __classcell__rs@rxrrs $###4444))))^IN((((( (((X((((((((((.((((,((( DDDD ::::  ( ( (X ( (-$ ( ( ( ( ( (AE(CCCXC X &<!!!!!!,    71717171717171rX BBBXB CCCXC ????X?####### """P % ;);););););)z>@@@@@D"""     U "     \  2,2,2,2,n!!!X! '''X'.24<!!!!!!X!!F!!!X!FX---X-???X????X?@@@X@ 777v(' 22G((44H'' 22G((44H++M::K,,^<>M'' 22G((44H**<88J++M::K  U$ ''' U'R QQQ UQB  U *** U*$  - - - U - UUU UU&     U (((...(....$      U       U * 222 U2&  U0 """ U"H8<@@@@@@i((99)(9v###i((99)(9v'''REEEEEE,0999999",0999999"&*!898989898989t/3D99999900000H3H3H3H3H3H3H3H3rzrceZdZdZddZdS) DatelikeOpszK Common ops for DatetimeIndex/PeriodIndex, but not TimedeltaIndex. rrtr|rc||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 `__. 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) rrr`rrQrfrFrr)rrrrfs rxstrftimezDatelikeOps.strftimesxZ**{26*RR    H * * * * * *F++rv*F*F*FGGG G}}V%}000rzN)rrtr|r)rr\r]r^rhrrzrxrdrds2212121212121rzrdceZdZdZedZedZejdMdZe dNd Z e edOd Z edPdZ e dQdZe dRdZdSdTdZdZdUfd Zd Z dVdWd&Z dVdWd'Z dVdWd(Zd)dd*dXd.Zd)dd*dXd/ZdMd0ZdYd1ZdZfd3 Z d[d\fd7 Ze d]d^fd< Zd_d`fd? ZdadDZd4d)d8dEdbfdKZ edcdLZ!xZ"S)drzK Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex. c t|rvr)rrrs rx_validate_dtypezTimelikeOps._validate_dtype5s!#&&&rzc|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 rxrzTimelikeOps.freq9s 8zrzr|rc |zt|}||||jjdkr+t |t t fstd|jdkrtd||_ dS)Nr(TimedeltaArray/Index freq must be a TickrzCannot set freq with ndim > 1) r&_validate_frequencyrr rrrrrrrrs rxrzTimelikeOps.freqWs  e$$E  $ $T5 1 1 1z#%%js .L.L% JKKKy1}} !@AAA rz 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. Ninfer)rr&rir no_defaultrrp_validate_inferred_freq)rrrqs rx_maybe_pin_freqzTimelikeOps._maybe_pin_freqds <DJJJ W__z!'t'9:: "!S^ # # D Z T??D *DJJ *4 G G G G GDJJJT??D #D$* 5 5 5 5 5rzrrc 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)startendperiodsrrAz non-fixedInferred frequency 9 from passed values does not conform to passed frequency r) rir}rf_generate_rangerrAr array_equalrrrt)rindexrrinferredon_freqr.s rxrpzTimelikeOps._validate_frequencys& :??h$,664 )c)AhE Z   G>%*gl;; !   ! !   c#hh&& GhGG8< GG  sAA44 B1>.B,,B1r{ int | Noner c t|rvr)rryrzr{rrrs rxr~zTimelikeOps._generate_ranges"#&&&rzr?c4t|jjSrv)r rrrs rxr zTimelikeOps._cresos"4=#6777rzrlc*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 rxrAzTimelikeOps.units6TZ(((rzTrAr;rc|dvrtdtj|jjd|d}t |j||}t |jtjr|j}n&td|j}t||}t| |||j S) 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) rrrr rrrr rrKrrr)rrAr;rrrUrs rxrBzTimelikeOps.as_unitsT . . .HII IDJO66t66677(QQQ dj"( + + :"(IIot,,/B'2D999IDzz%% &   rzc|j|jkrE|j|jkr||j}n||j}||fSrv)r rBrArs rxrz"TimelikeOps._ensure_matching_resossR ;%, & &{U\))||EJ// di00U{rzufuncnp.ufuncmethodrtc|tjtjtjfvr9t |dkr&|d|urt |||jfi|Stj||g|Ri|S)Nrr) risnanisinfisfiniterr-rr__array_ufunc__)rrrinputsrrs rxrzTimelikeOps.__array_ufunc__%s bh"+6 6 6F q  q T!!*75&))$-BB6BB B&uww&ufHvHHHHHHrzcvt|jtrZtd|}|d}|||||}||j||S|d}ttj |}t||j }|dkr| St|||} || t}||jj}|||jS)Nro) ambiguous nonexistentrrrbr)rrrKr tz_localize_roundrrrrDr*r rr(rcr!rr) rrr7rrnaiverrnanos result_i8s rxrzTimelikeOps._round0s dj/ 2 2 ..D$$T**E\\$iEEF%%9+& 4bj&))"455 A::99;; !&$66 ))))EET]011dj999rzraiserr9rr:cF||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) )rr'NEAREST_HALF_EVENrrrrs rxroundzTimelikeOps.roundFs L{{4!:I{SSSrzcF||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) )rr' MINUS_INFTYrs rxfloorzTimelikeOps.floors L{{4!4iMMMrzcF||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) )rr' PLUS_INFTYrs rxceilzTimelikeOps.ceil s L{{4!3Y LLLrzNrrrrc`tj|j|||SNr-)rTnananyrrQrrrs rxr]zTimelikeOps.any s%}T]f499;;WWWWrzc`tj|j|||Sr)rTnanallrrQrs rxrKzTimelikeOps.all s'}T]f499;;WWWWrzcd|_dSrvrmrs rxrzTimelikeOps._maybe_clear_freq s  rzcB|nt|dkrQt|tr<|jjdkr+t|t t fstdn|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 Nrrrort) rrrrr rrrr&rirr)rrrs rx _with_freqzTimelikeOps._with_freq s <  YY!^^ 4 < <^z#%%jc{.K.K% JKKK7????T/00Diikk  rzrct|jtjr|jSt Srv)rrrrr_values_for_json)rrs rxrzTimelikeOps._values_for_json s7 dj"( + + != ww'')))rzFuse_na_sentinelsortc|j|rN|jjdkr>tjt |dz ddtj}|ddd}nAtjt |tj}|}||fS|r%tdt|j dt |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.)r) rrrarangerintprNotImplementedErrorrrr factorize)rrrcodesuniquesrs rxrzTimelikeOps.factorize s 9  & a #d))a-RrwGGGttt* #d))27;;;))++'> !  &=d)<===  ww   AAArzr to_concatSequence[Self]r-c\t||}|d|dkryd|D}jftfd|DrKt |dd|ddd}tfd|Drj}||_|S) Nrc0g|]}t||Sr)r)rrs rxrz1TimelikeOps._concat_same_type.. s#888qQ8888rzc38K|]}|jjkVdSrvr)rrrs rxrz0TimelikeOps._concat_same_type.. s,+R+R1AFch,>+R+R+R+R+R+RrzrrT)strictc3dK|]*}|ddjz|ddkV+dS)rrrNr)rpairrs rxrz0TimelikeOps._concat_same_type.. s?NNtAwr{SX-a;NNNNNNrz)r_concat_same_typerrKzipr)rrrnew_objpairsrrrs @rxrzTimelikeOps._concat_same_type s ''++It<<l 19998I888Ix#+R+R+R+R +R+R+R(R(R#IcrcNIabbM$GGGNNNNNNNNN-"xH$,GMrzCordercdt|}|j|_|S)N)r)rrrr)rrrrs rxrzTimelikeOps.copy s('',,U,++  rzr2rrnrc |dkrt|s|j} n|j} tj| f||||||d||s|St || |jS)z2 See NDFrame.interpolate.__doc__. linear)rrrlimitlimit_direction limit_arear)rrrrSinterpolate_2d_inplacerrr) rrrrrrrrrout_datas rx interpolatezTimelikeOps.interpolate s X  % % ,}HH}))++H&  +!   KDzz%%hdj%AAArz) allow_fillrbrindicesr8rrbrc8t||||}tj|tj}t j|t|}t|tr| |}||_ |S)N)rrrbrr) rtakerrrrmaybe_indices_to_slicerrrrr) rrrrbrr maybe_slicerrs rxrzTimelikeOps.take s zPT  *WBG4440#d))DD k5 ) ) ))+66DFL rzc 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) rrrrr!r r$r logical_andrD)r values_intconsider_valuesrppd even_dayss rx_is_dates_onlyzTimelikeOps._is_dates_only( stz** 5Y $,"4:..d##N?J4D4IJJNNPPTUU rzrY)rqrrr|r)rrr|r)r{rr|r )r|r?)r|rlrZ)rArlr;rr|r )rrrrt)rr)rr9rr:r|r )rrrrr|rr[rX)TF)rrrr)r)rrrr-r|r )r)rrtr|r ) rr2rr?rrnrrr|r ) rr8rrrbrrr-r|r rW)#rr\r]r^ classmethodrkr`rsetterrrwrpr~r@r rArBrrrrrrr]rKrrrrrrrrrrarbs@rxrr0s''['X: [   [  666 U6@ ((([ U(T'''['888^8)))^)8< < < < < @ I I I I I I:::2$+'. fTfTfTfTfTV$+'. fNfNfNfNfNV$+'. fMfMfMfMfMV-1XXXXXX-1XXXXXX@******!%BBBBBBB2[* $B$B$B$BT! 0Xrzrrrcls_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) NrrFzCannot create a z from a MultiIndex.Tr?rrrgr)r7rrtuplerrrBrOrrbr_r]rr rRr!_maybe_convert_datelike_arrayrDr^rrNrGrrr_values)rrrs rx!ensure_arraylike_for_datetimelikerB s 4 ! ! 7$u .. 274==A3E3E::D6t<< D- ( (7H8HHHIIIT666$ %%4,--26*/T2I2I}}Wt}44 D- . . 1133}} rz>: ; ; z$ D. ) )##DJ3#??G :rzr{rcdSrvrr{s rxvalidate_periodsri s-0Srzr?cdSrvrrs rxrrm s+.3rzrcV|&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 Nz periods must be an integer, got )rrrrs rxrrq s7$3>'#:#:D7DDEEE NrzrrricV|&| ||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 Nr|r})rrf)rris rxrvrv s]    5 5"m""<""  < D Krzr'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 r zdtype=z does not have a resolution.r) rrKrArIr r pyarrow_dtyper datetime_datars rxrr sy%))(z E: & &( :T ! !DDDDEE E"'' E " "1 %%rz)rsrt)r{r1r|r1)rrrrtr|r)r{rr|r)r{r?r|r?)r{rr|r)rrrirr|r)rrr|rt) __future__rrr functoolsrrtypingrrr 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`rFrarbpandas.core.indexersrcrdpandas.core.ops.commonrepandas.core.ops.invalidrfrgpandas.tseriesrhcollections.abcrirjrkrlrQrnrrorprqrrr_ryrrrdrrrrvrrrzrxrs3"""""""                      ------,,,,,,*KJJJJJ======CCCCCC$/..... 544444KKKKKK   ?>>>>>******?>>>>>222222333333  <;;;;; '&&&&& (''''' .7 77771111 2k3k3k3k3k3X'Bk3k3k3\17171717171(717171tK K K K K (K K K d$$$$N 000 0 ... .2:&&&&&&rz