|ochaddlmZddlmZmZddlmZddlZddlmZm 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 e8efZd:d(Zd;d)ZGd*d+etevZGd,d-eZd.Zd/Zd0Zd1ZGd2d3eZ dd6Zd?d7Z d@d8ZdAd9Zy)B) 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 PeriodArrayTimedeltaArrayc:t|}t||SN)rfrd)op_nameops n/mnt/ACDE16A4DE16673C/PROJECTS/MIS_PORTAL/venv/lib/python3.12/site-packages/pandas/core/arrays/datetimelike.py_make_unpacked_invalid_oprts  !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) isinstancedtyperLviewrr _box_func_value_from_backing_data)selfargskwargsarrresultres_i8meths rsnew_methz"_period_dispatch..new_meths$**k2.t.v. .ii!c+D+F+ S=J  *>>&--0 0T"&&v..ru)rr r.)rrs` rs_period_dispatchrs* 4[ / / 8 ruceZdZUdZded<ded<ded<ded <d ed <edod Z dp dqdZedrdZ dsdZ dtdZ dudZ dZ dvdZdwdZedxdZdd d dydZdzd{dZ d| d}dZed~dZe ddZdfd Zdd Z dfd! Zdd"Zddfd$ Zedd%Zedd&Zedd'Zeddd(Zddfd) Zd*Zdd#d+ dd,Zdzdd-Zdzdd.Zd/Ze dd0Z!e"dd1Z#dd2Z$dd3Z%edd4Z&edod5Z'e(d f dd6Z)edd7Z*edd8Z+edd9Z,edd:Z-edod;Z.edod<Z/edod=Z0d>Z1e2d?Z3e2d@Z4e2dAZ5e2dBZ6e2dCZ7e2dDZ8e2dEZ9e2dFZ:e2dGZ;e2dHZ<e2dIZ=e2dJZ>e ddKZ?e ddLZ@e ddMZAe ddNZBe ddOZCe ddPZDe ddQZEe ddRZFdSZGdTZHddUZIe ddVZJe dWZKe dXZLe ddYZMe ddZZNd#d[dd\ZOePd]d^ZQd_ZRePd`daZSdbZTddcZUdddZVeW dfde ZXeWd d#dfddgZYeWd d#dfddhZZd#didjddkZ[eWd d#dfddlZ\dddmZ] ddnZ^xZ_S)DatetimeLikeArrayMixinz Shared Base/Mixin class for DatetimeArray, TimedeltaArray, PeriodArray Assumes that __new__/__init__ defines: _ndarray and that inheriting subclass implements: freq ztuple[str, ...]_infer_matcheszCallable[[DtypeObj], bool]_is_recognized_dtypeztuple[type, ...]_recognized_scalars np.ndarray_ndarrayBaseOffset | Nonefreqcy)NTrs rs _can_hold_naz#DatetimeLikeArrayMixin._can_hold_nasruNFct|rpr:)rdatar{rcopys rs__init__zDatetimeLikeArrayMixin.__init__s"$''ruct|)z The scalar associated with this datelike * PeriodArray : Period * DatetimeArray : Timestamp * TimedeltaArray : Timedelta rrs rs _scalar_typez#DatetimeLikeArrayMixin._scalar_types"$''ruct|)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 rs_scalar_from_stringz*DatetimeLikeArrayMixin._scalar_from_string$"$''ruct|)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 rs _unbox_scalarz$DatetimeLikeArrayMixin._unbox_scalars*"$''ruct|)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 rs_check_compatible_withz-DatetimeLikeArrayMixin._check_compatible_withrruct|)zI box function to get object from internal representation r)rxs rsr}z DatetimeLikeArrayMixin._box_func/s"$''rucFtj||jdS)z1 apply box func to passed values F)convert)r map_inferr})rvaluess rs _box_valuesz"DatetimeLikeArrayMixin._box_values5s}}VT^^UCCrucjdkDrfdttDSfdjDS)Nc3(K|] }| ywrpr).0nrs rs z2DatetimeLikeArrayMixin.__iter__..=s6DG6sc3@K|]}j|ywrp)r})rvrs rsrz2DatetimeLikeArrayMixin.__iter__..?s9!DNN1%9s)ndimrangelenasi8rs`rs__iter__zDatetimeLikeArrayMixin.__iter__;s1 99q=6U3t9%56 69tyy9 9ruc8|jjdS)z Integer representation of the values. Returns ------- ndarray An ndarray with int64 dtype. ry)rr|rs rsrzDatetimeLikeArrayMixin.asi8As}}!!$''rur)na_rep date_formatct|)z| Helper method for astype when converting to strings. Returns ------- ndarray[str] r)rrrs rs_format_native_typesz+DatetimeLikeArrayMixin._format_native_typesQs"$''rucdjS)Nz'{}')format)rboxeds rs _formatterz!DatetimeLikeArrayMixin._formatter]s }}ruct|rL|dur$tjdtt t j t|tS|dur!t j |j|S|jS)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 rs __array__z DatetimeLikeArrayMixin.__array__dsl 5 !u} 0 "/1 88DJf5 5 4<88DMM7 7}}rucyrprritems rs __getitem__z"DatetimeLikeArrayMixin.__getitem__{ rucyrprrs rsrz"DatetimeLikeArrayMixin.__getitem__s ructdt| |}tj|r|Stt |}|j ||_|S)z This getitem defers to the underlying array, which by-definition can only handle list-likes, slices, and integer scalars zUnion[Self, DTScalarOrNaT])r superrr is_scalarr4_get_getitem_freq_freq)rkeyr __class__s rsrz"DatetimeLikeArrayMixin.__getitem__sR2EG4G4LM == M$'F--c2  ruc: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)rzr{rLrrrbslicestepEllipsiscomis_bool_indexerrmaybe_booleans_to_slicer|ruint8r)rr is_periodrnew_keys rsrz(DatetimeLikeArrayMixin._get_getitem_freqstzz;7 99D& %YY!^D" &dC0CD#u%99(SXX-A88dii/D  99D yy  $$S)55chhrxx6HIgu-11':: rucft|||}t| |||ry|jyrp)rcr __setitem___maybe_clear_freq)rrrno_oprs rsrz"DatetimeLikeArrayMixin.__setitem__s6&c5$7 C'    rucyrprrs rsrz(DatetimeLikeArrayMixin._maybe_clear_freqs ruTc`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)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!rrravelreshapeshaperFrzrKrna_valueconstruct_array_type_from_sequencerastyperint64 TypeErrorrtype__name__asarray) rr{ri8data converted arr_objectclsrmsgrs rsrzDatetimeLikeArrayMixin.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 0rucyrprrs rsr|zDatetimeLikeArrayMixin.view rrucyrprrr{s rsr|zDatetimeLikeArrayMixin.view rrucyrprr s rsr|zDatetimeLikeArrayMixin.viewrrucyrprr s rsr|zDatetimeLikeArrayMixin.viewrruc"t||Srp)rr|)rr{rs rsr|zDatetimeLikeArrayMixin.viewsw|E""ruct|tr |j|}t||j s|tur%|j|} |j||St|s t |t|t|k7r td |j|d}|j||S#ttf$r t |wxYw#ttf$r}t ||d}~wwxYw#ttf$r.}tt|ddrn t ||Yd}~|Sd}~wwxYw)NzLengths must matchT) allow_objectr{)rzstrr ValueErrorrr;rrrrrrDr_validate_listlikerEgetattr)rrerrs rs_validate_comparison_valuez1DatetimeLikeArrayMixin._validate_comparison_value#sM eS ! /007 eT55 6%3,%%e,E 8++E2, #e$#E* * Z3t9 $12 2 <//D/I++E2 ; 56 /'.. /45 8'.C7 845 <"75'4#@A+E2;  >DE#D>>E)allow_listlikeunboxct||jrnt|tr |j|}nt||jrt}nmt|r|j ||}t |t||jr|j|}n|j ||}t ||s|S|j|S#t$r#}|j ||}t ||d}~wwxYw)a  Validate that the input value can be cast to our scalar_type. Parameters ---------- value : object allow_listlike: bool, default False When raising an exception, whether the message should say listlike inputs are allowed. unbox : bool, default True Whether to unbox the result before returning. Note: unbox=False skips the setitem compatibility check. Returns ------- self._scalar_type or NaT N) rzrrrr_validation_error_messagerrOr{rrPrr)rrrrrr s rs_validate_scalarz'DatetimeLikeArrayMixin._validate_scalarGs0 eT.. /  s # .007 #5$** 5E %[00GCC. t77 8%%e,E00GCC. L!!%((9 .44UNKn#- .sC D#DDc t|dr t|dddkDr|jd}ndt|jd}|rd|j jd|d}|Sd|j jd |d}|S) a+ Construct an exception message on validation error. Some methods allow only scalar inputs, while others allow either scalar or listlike. Parameters ---------- allow_listlike: bool, default False Returns ------- str r{rrz array'zvalue should be a 'z!', 'NaT', or array of those. Got z instead.z' or 'NaT'. Got )hasattrrr{rrr)rrrmsg_gotr s rsrz0DatetimeLikeArrayMixin._validation_error_messages 5' "wufa'@1'D V,G$u+../q1G %d&7&7&@&@%AB**1)=  &d&7&7&@&@%ABiy*  ruct|t|r9|jjdvr|s|j |j d}|St|t r4t|dk(r&t|jg|jSt|drO|jtk(r>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00"], freq="D") >>> idx.freqstr 'D' The frequency can be inferred if there are more than 2 points: >>> idx = pd.DatetimeIndex(["2018-01-01", "2018-01-03", "2018-01-05"], ... freq="infer") >>> idx.freqstr '2D' For PeriodIndex: >>> idx = pd.PeriodIndex(["2023-1", "2023-2", "2023-3"], freq="M") >>> idx.freqstr 'M' N)rfreqstrrs rsrTzDatetimeLikeArrayMixin.freqstrs!4 99 yy   rucl|jdk7ry tj|S#t$rYywxYw)ax Tries to return a string representing a frequency generated by infer_freq. Returns None if it can't autodetect the frequency. Examples -------- For DatetimeIndex: >>> idx = pd.DatetimeIndex(["2018-01-01", "2018-01-03", "2018-01-05"]) >>> idx.inferred_freq '2D' For TimedeltaIndex: >>> tdelta_idx = pd.to_timedelta(["0 days", "10 days", "20 days"]) >>> tdelta_idx TimedeltaIndex(['0 days', '10 days', '20 days'], dtype='timedelta64[ns]', freq=None) >>> tdelta_idx.inferred_freq '10D' rN)rrg infer_freqrrs rs inferred_freqz$DatetimeLikeArrayMixin.inferred_freqs:0 99> ))$/ /  s ' 33cj|j}|y tj|S#t$rYywxYwrp)rTrget_reso_from_freqstrKeyError)rrTs rs_resolution_objz&DatetimeLikeArrayMixin._resolution_objs;,, ? 33G< <  s & 22c.|jjS)zO Returns day, hour, minute, second, millisecond or microsecond )r[attrnamers rs resolutionz!DatetimeLikeArrayMixin.resolutions ##,,,rucJtj|jddS)NTtimelikerr is_monotonicrrs rs_is_monotonic_increasingz/DatetimeLikeArrayMixin._is_monotonic_increasing!!$))d;A>>rucJtj|jddS)NTr`rrbrs rs_is_monotonic_decreasingz/DatetimeLikeArrayMixin._is_monotonic_decreasingrerucvtt|jjd|jk(S)NK)rrWrrsizers rs _is_uniquez!DatetimeLikeArrayMixin._is_uniques(8DIIOOC012dii??ruc|jdkDrXt|dd|jk(r>||j|jj |jS |j |}t|dd}t|r?tj|tj|jt|}|S|tur`|t j"ur'tj$|jt&}|Stj(|jt&}|St+|j,t.st1t2|}|j4|j4k7rWt+|t7|s |j9|j:d}n#|jD}tC|jD||S|jG|}||jDjId|jId}tK|}|jL|z}|jOr)|t j"u} tjP||| |S#t $rt|||cYSwxYw#t<$r9tj>|j@}tC|jD||cYSwxYw)Nrrr{rFr"ry))rrrrrrr;rerErTcomp_method_OBJECT_ARRAYrrrrroperatorneonesrDrCrzr{rLr TimelikeOpsrrr&r'rr_asm8r&rr-r|rPrIrLrP) rrrrr{r other_arr other_valso_maskmask nat_results rs _cmp_methodz"DatetimeLikeArrayMixin._cmp_methods3 99q=WUGT:djjHdjjlEKKM2::4::F F 733E:Ew- 5 !11BJJt{{623UFM C<X[[ 48M$**D9M$**k2 T*D{{ell*!%d4 % dii% H!&I9$--TVWW[[' DMM&&t,jood.CDe{{V# 88:x{{*J JJvtZ 0 ]! 7%dE26 6 76&$&HHUZZ$8 = MM9b s$)I*J*JJ?KK__pow____rpow____mul____rmul__ __truediv__ __rtruediv__ __floordiv__ __rfloordiv____mod____rmod__ __divmod__ __rdivmod__ct|tr|j}d}||fSt|ttfr|j }d}||fS|j }|j}||fS)zN Get the int64 values and b_mask to pass to add_overflowsafe. N)rzrordinalrrr~rIr)rri8valuesrvs rs_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:(}((5xPPructj|jds7tdt |j dt |j ||zS)Nrrr)rrr{rrrrs rs_add_datetime_arraylikez.DatetimeLikeArrayMixin._add_datetime_arraylikessStzz3/d4j112%U 8L8L7MN  t|ruc|jjdk7r!tdt|jt d|}t |r |tz St|}|j|\}}|j|S)Nr"cannot subtract a datelike from a rl) r{rrrrr rPrrr_sub_datetimelike)rrtss rs_sub_datetimelike_scalarz/DatetimeLikeArrayMixin._sub_datetimelike_scalar}s ::??c !@dATAT@UVW WOT* ;#:  u ..r2b%%b))ruc|jjdk7r!tdt|jt |t |k7r t dtd|}|j|\}}|j|S)Nrr$cannot add indices of unequal lengthrl) r{rrrrrrr rrrs rs_sub_datetime_arraylikez.DatetimeLikeArrayMixin._sub_datetime_arraylikes} ::??c !@dATAT@UVW W t9E "CD DOT*11%8 e%%e,,ructd|}ddlm} |j||j|\}}t|jtj| d}|jd|jd }|j|} td | } |j ||j"| S#t$r2}t |j dd}t|||d}~wwxYw) Nrlrrncomparesubtractryr timedelta64[rz Tick | Noner)r rrn_assert_tzawareness_compatrrreplacerrrrrrr|r'rrr{) rrrnr new_messagerrurres_m8rs rsrz(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)rmr)rrr{rrrpandas.core.arrays.periodrmr broadcast_torrrLr)rrrmi8valsr{parrs rs _add_periodz"DatetimeLikeArrayMixin._add_periodsstzz3/5d4j6I6I5JKL L : ;EJJ'6/d{ruct|rpr)roffsets rs _add_offsetz"DatetimeLikeArrayMixin._add_offsets !$''ruct|rtj|jdj |j j }|jtt|j||j Std|}t|}|j|\}}|j|S)zk Add a delta of a timedeltalike Returns ------- Same type as self ryrrB)rPremptyrr|rr{fillrrrr rr_add_timedeltalike)rr new_valuess rs_add_timedeltalike_scalarz0DatetimeLikeArrayMixin._add_timedeltalike_scalars ;$**D9>>t}}?R?RSJ OOD !:))*DJJ)G G4d;% 11%8 e&&u--ruct|t|k7r tdtd|}|j|\}}|j |S)zl Add a delta of a TimedeltaIndex Returns ------- Same type as self rrB)rrr rrrs rs_add_timedelta_arraylikez/DatetimeLikeArrayMixin._add_timedelta_arraylikesR t9E "CD D4d;11%8 e&&u--rucRtd|}|j|\}}t|jt j |d}|j |jj}|j|}t|j||j|S)NrBryrr) r rrrrrr|rr{rrr)rrrrurrrs rsrz)DatetimeLikeArrayMixin._add_timedeltalikes4d;77>&%diiHD1QR __T]]%8%89 33E: Dz%% djjx&  ruct|jtr;tdt |j dt t j td|}tj|jtj}|jt|j|jj}t |j!||jdS)z$ Add pd.NaT to self z Cannot add rzTimedeltaArray | DatetimeArrayrNr)rzr{rLrrrrr rrrrrrr|rrrrs rs_add_natzDatetimeLikeArrayMixin._add_nats djj+ .d4j112%S 8J8J7KL 4d;$**BHH5 DT]]001Dz%% $**4&  ruc2tj|jtj}|j t |j jdvr+td|}|jd|jdS|jdS)z+ Subtract pd.NaT from self rrzDatetimeArray| TimedeltaArrayrrztimedelta64[ns]) rrrrrrr{rr r|r'rs rs_sub_natzDatetimeLikeArrayMixin._sub_natsq$**BHH5 D ::??d "7>D;;dii[:; ;;;01 1ruc.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 rmryr)rzr{rLrrrr rrrrrrr_rbaserIr)rrrru new_i8_datarnew_datarvs rs_sub_periodlikez&DatetimeLikeArrayMixin._sub_periodlike#s$**k2"4;#7#7"8tDz?R?R>ST M4( ##E*77>&&tyy"**hYd2ST 88EATYY^^a/EF >;;D;;'DFs Dc|tjtjfvsJt|dk(r|jdk(r |||dSt j dt|jdtt|j|jk(sJ|j|jf||jdtj|}|S)aZ Add or subtract array-like of DateOffset objects Parameters ---------- other : np.ndarray[object] op : {operator.add, operator.sub} Returns ------- np.ndarray[object] Except in fastpath case with length 1 where we operate on the contained scalar. rrz)Adding/subtracting object-dtype array to z not vectorized.rO)rnaddsubrrrrrrr<r@rrrr)rrrrrs rs_addsub_object_arrayz+DatetimeLikeArrayMixin._addsub_object_array<s hllHLL1111 u:?tyyA~dE!H% % 7Dz""##3 5 ')  zzU[[(C4::u{{*CC( C("**U*;< rur>c |dvrtd|dt|tt|}||j fd|i|}t|j ||j S)N>cummaxcumminz Accumulation z not supported for r?r)rrrrXrrr{)rnamer?rrrrs rs _accumulatez"DatetimeLikeArrayMixin._accumulate`sm + +mD61DT$ZLQR R / 6DIIK99&9Dz%%fDJJ%??ru__add__ct|dd}t|}|tur|j}nUt |t t tjfr|j|}nt |tr|j|}nt |ttjfr|j|}nt |tr3t!j"|j$dr|j'|}nt!j(|rjt |j$t*s t-|t/d|}|j1||j$j2zt4j6}nt!j"|dr|j9|}nt;|r!|j=|t4j6}nt!j"|dst |t>r|jA|StC|rit |j$t*s t-|t/d|}|j1||j$j2zt4j6}ntDSt |tjFr8t!j"|j$drddl$m%}|jL|S|S)Nr{rrmrrr)'rr`rrrzrrrr8rrrrr9rrrrr{r is_integerrLr(r _addsub_int_array_or_scalar_nrnrrrErrJrrCNotImplementedndarrayrrnrrr other_dtyperobjrns rsrzDatetimeLikeArrayMixin.__add__iseWd3 .u5 C<]]_F i@ A33E:F z *%%e,F "--8 92259F v &3??4::s+K%%e,F ^^E "djj+6.t44}d+C44USYY\\5I8<<XF__[# .2259F [ )..uhllCF __[# .* 3 //6 6 k *djj+6.t44}d+C44USYY\\5I8<<XF" ! fbjj )coofllC.P 90>008 8 ruc$|j|Srp)rrs rs__radd__zDatetimeLikeArrayMixin.__radd__s||E""ru__sub__ct|dd}t|}|tur|j}n\t |t t tjfr|j| }n#t |tr|j| }nt |ttjfr|j|}ntj |rjt |j"t$s t'|t)d|}|j+||j"j,zt.j0}nMt |t2r|j5|}n*tj6|dr|j9| }nt;|r!|j=|t.j0}ntj6|dst |t>r|jA|}nt |t$r|j5|}nztC|rit |j"t$s t'|t)d|}|j+||j"j,zt.j0}ntDSt |tjFr8tj6|j"drddl$m%}|jL|S|S)Nr{rmrrrr)'rr`rrrzrrrr8rrrrr9rrrr{rLr(r rrrnrrrrrrErrJrrCrrrrnrrs rsrzDatetimeLikeArrayMixin.__sub__seWd3 .u5 C<]]_F i@ A33UF;F z *%%uf-F "--8 92259F ^^E "djj+6.t44}d+C44USYY\\5I8<<XF v &))%0F__[# .22E6:F [ )..uhllCF __[# .* 3 11%8F  [ 1))%0F k *djj+6.t44}d+C44USYY\\5I8<<XF" ! fbjj )coofllC.P 90>008 8 ruc8t|dd}tj|dxst|t}|rptj|j drPtj |rt||z St|tsddl m }|j|}||z S|j jdk(rEt|dr9|s7tdt|j dt|j t|j t"rDtj|dr.tdt|j d|j tj|j drt%d|}| |zS||z S) Nr{rrrrrrrn)rrrrzrJr{rrrrrlrrrrrrrLr )rrr other_is_dt64rls rs__rsub__zDatetimeLikeArrayMixin.__rsub__s^eWd3  S9 Z >  S__TZZ=}}U# '$..e%;<<4 44U;4<  ZZ__ #w(? "4:#6#6"7vd5k>R>R=ST  K 0S__[RU5V.tDz/B/B.C6%++WX X __TZZ -($/DEU? "rucv||z}|dd|ddt|jts|j|_|Srprzr{rLrrrrrs rs__iadd__zDatetimeLikeArrayMixin.__iadd__6)Q$**k2DJ rucv||z }|dd|ddt|jts|j|_|Srprrs rs__isub__zDatetimeLikeArrayMixin.__isub__rruc&t|||S)N)qs interpolation)r _quantile)rrrrs rsrz DatetimeLikeArrayMixin._quantiles w Bm DDruaxisr?c 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_axisrrSnanminr_wrap_reduction_resultrrr?rrs rsminzDatetimeLikeArrayMixin.minO F# dii0t}}4G**488ruc 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_maxrrrSnanmaxrrrs rsmaxzDatetimeLikeArrayMixin.max.rrur)r?rct|jtr"tdt |j dt j|j|||j}|j||S)a Return the mean value of the Array. Parameters ---------- skipna : bool, default True Whether to ignore any NaT elements. axis : int, optional, default 0 Returns ------- scalar Timestamp or Timedelta. See Also -------- numpy.ndarray.mean : Returns the average of array elements along a given axis. Series.mean : Return the mean value in a Series. Notes ----- mean is only defined for Datetime and Timedelta dtypes, not for Period. Examples -------- For :class:`pandas.DatetimeIndex`: >>> idx = pd.date_range('2001-01-01 00:00', periods=3) >>> idx DatetimeIndex(['2001-01-01', '2001-01-02', '2001-01-03'], dtype='datetime64[ns]', freq='D') >>> idx.mean() Timestamp('2001-01-02 00:00:00') For :class:`pandas.TimedeltaIndex`: >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='D') >>> tdelta_idx TimedeltaIndex(['1 days', '2 days', '3 days'], dtype='timedelta64[ns]', freq=None) >>> tdelta_idx.mean() Timedelta('2 days 00:00:00') zmean is not implemented for zX since the meaning is ambiguous. An alternative is obj.to_timestamp(how='start').mean()rr?rv) rzr{rLrrrrSnanmeanrrPr)rr?rrs rsmeanzDatetimeLikeArrayMixin.mean@suX djj+ ..tDz/B/B.CD77   MMV$))+ **488ruc tjd||#t||jk\r t dt j |j||}|j||S)Nrz abs(axis) must be less than ndimr) rvalidate_medianabsrrrS nanmedianrrrs rsmedianzDatetimeLikeArrayMixin.medianys^ 2v&  D TYY 6?@ @!!$--d6J**488rucd}|r|j}tj|jd|}|j|jj }t tj|}|j|S)Nry)rv) rPrQmoder|rr{r rrr)rdropnarvi8modesnpmodess rs_modezDatetimeLikeArrayMixin._modesf 99;D//$))D/=,,t}}223rzz7+&&w//ruc |j}|jdk(rC|dvrtd|d|dvrtjd|d|dt t nft|trC|dvrtd |d|dvr?tjd|d |dt t n|d vrtd |d|jjd}ddl m } | j|} | || |} | j|f|||dd|} | j| j vr| S| jdk(sJ|dvrvddlm} t|jtr tdt'd|}d|j(d}| j|} | j*| | jS| j|jj} |j-| S)Nr)sumprodcumsumcumprodvarskewz!datetime64 type does not support z operations)rLallrzh' 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)).)rrrrz"timedelta64 type does not support rxr)WrappedCythonOp)howrhas_dropped_na) min_countngroupscomp_idsrv)stdsemrz-'std' and 'sem' are not valid for PeriodDtyperBzm8[rr)r{rrrrrr@rzrLrr|pandas.core.groupby.opsrget_kind_from_how_cython_op_ndim_compatrcast_blocklistrrnr r'rr)rrrrridsrr{npvaluesrrrrrrn new_dtypes rs _groupby_opz"DatetimeLikeArrayMixin._groupby_ops  :: II"CC5 TUUn$ uDDG5 U!/1 { +II"?uK PQQn$ uGGJe;X!/1 88"DSE UVV==%%h/;005 4 O.R..       66R&& & 8+++ . 9$**k2 OPP8$?Ddii[*I#3J->--j @P@PQ Q__T]]%8%89 &&z22rureturnrD)NNF)r{ Dtype | NonerrDr+None)r+ztype[DatetimeLikeScalar])rrr+ DTScalarOrNaT)rr.r+z)np.int64 | np.datetime64 | np.timedelta64)rr.r+r-r+r)r+rh)r+znpt.NDArray[np.int64])rz str | floatr+npt.NDArray[np.object_])F)rrD)NN)r{zNpDtype | Nonerz bool | Noner+r)rr3r+r.)rz(SequenceIndexer | PositionalIndexerTupler+r4)rr1r+zSelf | DTScalarOrNaT)r+r)rz,int | Sequence[int] | Sequence[bool] | slicerzNaTType | Any | Sequence[Any]r+r-r+r-T)rrDr+r4)r{zLiteral['M8[ns]']r+rl)r{zLiteral['m8[ns]']r+rn).)r{r,r+r)rp)rrDrrD)rrDr+r)rrD)r+z6np.int64 | np.datetime64 | np.timedelta64 | np.ndarray)rr)r+npt.NDArray[np.bool_])r+r4)rrr+r)r+z str | None)r+zResolution | Noner+r)r+z@tuple[int | npt.NDArray[np.int64], None | npt.NDArray[np.bool_]])r+rl)rrlr+rl)rzdatetime | np.datetime64r+rn)rrlr+rn)rzTimestamp | DatetimeArrayr+rn)rrr+rm)rrn)rzTimedelta | TimedeltaArray)rzPeriod | PeriodArrayr+r0)rr0)rrr?rDr+r4)rznpt.NDArray[np.float64]rrr+r4)rAxisInt | Noner?rD)r?rDrr6)rrD) rrrrDrintrr7r&znpt.NDArray[np.intp])`r __module__ __qualname____doc____annotations__r?rrpropertyrrrrr}rrrrrrrrrrrrr|rrrrr.r r-r[r5rUrPrIrMrrRrTrWr[r^rdrgrkrxrtryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrdrrrrrrrrrrrr rr) __classcell__rs@rsrrs$#44)) IN('(AE( ( ((((("( 2(.(,( D :  ( ( (-$ ($ (  (AE#2= .   6    "<! 9!-!  !, 71r        #"P % ;) ;)  ;)z>8t"    "    P,j!! ''.24  <!!:<--????@@ 5r( 2G(4H' 2G(4H+M:K,^M' 2G(4H*<8J+M:K  I $     Q QB   *-* * *$  -  - U U&    (.(.$        , 2 2&  0 ! !F8<@i(5)5n#i(5)5n DE #EE  EE,099",099"&*!79r/3D990M3M3 M3  M3  M3"M3rurc0eZdZdZedddZy) DatelikeOpszK Common ops for DatetimeIndex/PeriodIndex, but not TimedeltaIndex. zNhttps://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior)URLc|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 <%(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) StringDtyperrFr) rrrOrr2rCr)rr)rrrrCs rsstrftimezDatelikeOps.strftimesPb**{266*R   *F+rvv*FG G}}V%}00ruN)rrr+r0)rr8r9r:r>rErrursr@r@s% *21 21rur@aO Perform {op} operation on the data to the specified `freq`. Parameters ---------- freq : str or Offset The frequency level to {op} the index to. Must be a fixed frequency like 'S' (second) not 'ME' (month end). See :ref:`frequency aliases ` for a list of possible `freq` values. ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise' Only relevant for DatetimeIndex: - 'infer' will attempt to infer fall dst-transition hours based on order - bool-ndarray where True signifies a DST time, False designates a non-DST time (note that this flag is only applicable for ambiguous times) - 'NaT' will return NaT where there are ambiguous times - 'raise' will raise an AmbiguousTimeError if there are ambiguous times. nonexistent : 'shift_forward', 'shift_backward', 'NaT', timedelta, default 'raise' A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST. - 'shift_forward' will shift the nonexistent time forward to the closest existing time - 'shift_backward' will shift the nonexistent time backward to the closest existing time - 'NaT' will return NaT where there are nonexistent times - timedelta objects will shift nonexistent times by the timedelta - 'raise' will raise an NonExistentTimeError if there are nonexistent times. Returns ------- DatetimeIndex, TimedeltaIndex, or Series Index of the same type for a DatetimeIndex or TimedeltaIndex, or a Series with the same index for a Series. Raises ------ ValueError if the `freq` cannot be converted. Notes ----- If the timestamps have a timezone, {op}ing will take place relative to the local ("wall") time and re-localized to the same timezone. When {op}ing near daylight savings time, use ``nonexistent`` and ``ambiguous`` to control the re-localization behavior. Examples -------- **DatetimeIndex** >>> rng = pd.date_range('1/1/2018 11:59:00', periods=3, freq='min') >>> rng DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00', '2018-01-01 12:01:00'], dtype='datetime64[ns]', freq='min') a>>> rng.round('h') DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00', '2018-01-01 12:00:00'], dtype='datetime64[ns]', freq=None) **Series** >>> pd.Series(rng).dt.round("h") 0 2018-01-01 12:00:00 1 2018-01-01 12:00:00 2 2018-01-01 12:00:00 dtype: datetime64[ns] When rounding near a daylight savings time transition, use ``ambiguous`` or ``nonexistent`` to control how the timestamp should be re-localized. >>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam") >>> rng_tz.floor("2h", ambiguous=False) DatetimeIndex(['2021-10-31 02:00:00+01:00'], dtype='datetime64[ns, Europe/Amsterdam]', freq=None) >>> rng_tz.floor("2h", ambiguous=True) DatetimeIndex(['2021-10-31 02:00:00+02:00'], dtype='datetime64[ns, Europe/Amsterdam]', freq=None) a>>> rng.floor('h') DatetimeIndex(['2018-01-01 11:00:00', '2018-01-01 12:00:00', '2018-01-01 12:00:00'], dtype='datetime64[ns]', freq=None) **Series** >>> pd.Series(rng).dt.floor("h") 0 2018-01-01 11:00:00 1 2018-01-01 12:00:00 2 2018-01-01 12:00:00 dtype: datetime64[ns] When rounding near a daylight savings time transition, use ``ambiguous`` or ``nonexistent`` to control how the timestamp should be re-localized. >>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam") >>> rng_tz.floor("2h", ambiguous=False) DatetimeIndex(['2021-10-31 02:00:00+01:00'], dtype='datetime64[ns, Europe/Amsterdam]', freq=None) >>> rng_tz.floor("2h", ambiguous=True) DatetimeIndex(['2021-10-31 02:00:00+02:00'], dtype='datetime64[ns, Europe/Amsterdam]', freq=None) a>>> rng.ceil('h') DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00', '2018-01-01 13:00:00'], dtype='datetime64[ns]', freq=None) **Series** >>> pd.Series(rng).dt.ceil("h") 0 2018-01-01 12:00:00 1 2018-01-01 12:00:00 2 2018-01-01 13:00:00 dtype: datetime64[ns] When rounding near a daylight savings time transition, use ``ambiguous`` or ``nonexistent`` to control how the timestamp should be re-localized. >>> rng_tz = pd.DatetimeIndex(["2021-10-31 01:30:00"], tz="Europe/Amsterdam") >>> rng_tz.ceil("h", ambiguous=False) DatetimeIndex(['2021-10-31 02:00:00+01:00'], dtype='datetime64[ns, Europe/Amsterdam]', freq=None) >>> rng_tz.ceil("h", ambiguous=True) DatetimeIndex(['2021-10-31 02:00:00+02:00'], dtype='datetime64[ns, Europe/Amsterdam]', freq=None) ceZdZUdZded<dej df d&dZedZ e dZ e jd'd Z e d(d Ze ed)d Ze d*d Zed+d Zed,dZd-d.dZdZd/fd ZdZeeezj7d d0 d1dZeeezj7d d0 d1dZeeezj7d d0 d1dZ dddd2dZ!dddd2dZ"d'dZ#d3dZ$d4fd Z% d5 d6fd! Z&e d7 d8fd" Z'd9d:fd# Z( d;d$Z)e d| |j}n/|r-|jr!t!|}t#||j}|*||j$k7rt'd|d |j$|j$}|j(}n|t|t*j,r%|j$j.d vr |j$}nF|j0}t|t*j,r |j$d k(r|j3|}t|t*j,s8t5d t|jd t|jd|j6dvr t5d|j$d k(r|(|j0}|j3|j0}nqtj8|dr|j3|}nIt|t:r9|j0j.}|d|j<d}|j3|}|j?||}|dk(r"t5dt|jd|r|jA}|r?t!|}|j$j.dk(rt|tBs t'dtEjF|||||_$||t|jK||yyy)NzV.__init__ is deprecated and will be removed in a future version. Use pd.array instead.rTr$rrDrdtype=z does not match data dtype MmryzUnexpected 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@rGrarzr^r3rrr no_defaultrr#_validate_inferred_freqr{rrrrrrGr|rrrrJr'_validate_dtyperrrrr_validate_frequency) rrr{rrrW explicit_nonerr(s rsrzTimelikeOps.__init__s9  Dz""#$A A ')     'EvT: fl +__Wt_>1tt fd4j ){{&++ .tV[[A Ufll%:UG#>v||nMLLE__F ]&"**-&,,2C2Ct2K ++fbjj1flld6J#[[/F&"**-#DL$9$9#::P:&&'(++  ;;f $MN N <<4 }++T%8%89-U+E?3**//#fBuzzl!4 Y/$$VU3 7?5d4j6I6I5JK,,  [[]F T?D||  C' 40F JKKtF%@  T%5 J * *4 6&6 ruct|rpr)rrr{s rsrQzTimelikeOps._validate_dtypes !#&&ruc|jS)zK Return the frequency object if it is set, otherwise None. rrs rsrzTimelikeOps.freqs zzruc|kt|}|j|||jjdk(rt |t s t d|jdkDr td||_ y)NrrNrzCannot set freq with ndim > 1) r#rRr{rrzrrrrrrs rsrzTimelikeOps.freqse  e$E  $ $T5 1zz#%j.E JKKyy1} !@AA rucR|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. NrM)rr#rWrrOrrRrP)rr validate_kwdss rs_maybe_pin_freqzTimelikeOps._maybe_pin_freq*s <DJ W_zz!'t'9'9: "S^^ #  ZZ T?D *DJ * *4 G GDJT?D #D$** 5ruc |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) rWrjrT_generate_rangerr'r array_equalrrr)rindexrrrGon_freqrs rsrRzTimelikeOps._validate_frequencyKs&& ::?h$,,6 )c))AhE ZZ   G>>%**gll;  < c#h& %hZ088< ~G  sAB C+CCct|rpr)rr\r]r^rrrs rsrazTimelikeOps._generate_rangews"#&&ruc@t|jjSrp)rrr{rs rsrzTimelikeOps._cresos"4==#6#677ruc,t|jSrp) dtype_to_unitr{rs rsr'zTimelikeOps.units TZZ((ruTc|dvr tdtj|jjd|d}t |j ||}t |jtjr |j}n#td|j}t||}t|j|||jS) N)smsusnsz)Supported units are 's', 'ms', 'us', 'ns'rLrr"rlrr) rrr{rrrrzr rrJrrr)rr'r#r{rr(rs rsr&zTimelikeOps.as_units . .HI IDJJOO,BtfA67(Q djj"(( +"((Iot,//B'2D9IDz%% idii&  ruc|j|jk7rS|j|jkr|j|j}||fS|j|j}||fSrp)rr&r'rs rsrz"TimelikeOps._ensure_matching_resoss^ ;;%,, &{{U\\)||EJJ/U{ dii0U{ruc|tjtjtjfvr2t |dk(r$|d|urt |||j fi|St| ||g|i|S)Nrr) risnanisinfisfiniterrrr__array_ufunc__)rufuncmethodinputsrrs rsrszTimelikeOps.__array_ufunc__sq bhh"++6 6F q q T!*75&)$--B6B Bw&ufHvHHHrucLt|jtrOtd|}|j d}|j ||||}|j |j ||S|jd}ttj|}t||j}|dk(r|jSt|||} |j| t}|j|j j}|j#||jS)Nrl) ambiguous nonexistentryrrQr)rzr{rJr tz_localize_roundrr|rrr'rrr%rRrrr) rrr rxrynaiverrnanos result_i8s rsr|zTimelikeOps._rounds djj/ 2.D$$T*E\\$iEF%%9+& 4bjj&)"45 A:99; !&$6 ))))ET]]001djj99ruround)rrcF|j|tj||Srp)r|r$NEAREST_HALF_EVENrrrxrys rsrzTimelikeOps.rounds{{4!:!:I{SSrufloorcF|j|tj||Srp)r|r$ MINUS_INFTYrs rsrzTimelikeOps.floors{{4!4!4iMMruceilcF|j|tj||Srp)r|r$ PLUS_INFTYrs rsrzTimelikeOps.ceils{{4!3!3Y LLrurcdtj|j|||jSNr)rSnananyrrPrrr?s rsrLzTimelikeOps.anys!}}T]]f499;WWrucdtj|j|||jSr)rSnanallrrPrs rsrzTimelikeOps.alls#}}T]]f499;WWrucd|_yrprVrs rsrzTimelikeOps._maybe_clear_freqs  ruc|nnt|dk(rDt|tr4|jjdk(r7t|t s't d|dk(sJt|j}|j}||_ |S)z Helper to get a view on the same data, with a new freq. Parameters ---------- freq : DateOffset, None, or "infer" Returns ------- Same type as self rrrNrM) rrzrr{rrrr#rWr|r)rrrs rs _with_freqzTimelikeOps._with_freqsz <  Y!^ 4 <zz#%jt.D JKK7? "?T//0Diik  ruct|jtjr |jSt|Srp)rzr{rrr_values_for_json)rrs rsrzTimelikeOps._values_for_json s- djj"(( +== w'))ruc^|jmtjt|tj}|j }|r)|jj dkr|ddd}|ddd}||fS|r"tdt|jdt|-|S)NrrzThe 'sort' keyword in zu.factorize is ignored unless arr.freq is not None. To factorize with sort, call pd.factorize(obj, sort=True) instead.)use_na_sentinel) rrarangerintprrNotImplementedErrorrrr factorize)rrsortcodesuniquesrs rsrzTimelikeOps.factorize s 99 IIc$irww7EiikG add !$B$-'> ! &(d)<)<(=>==  w  AAruc0t|||}|d|dk(rt|Dcgc]}t|s|}}jMt fd|Dr9t |dd|dd}t fd|Drj}||_|Scc}w)Nrc3PK|]}|jjk(ywrpr)rrrs rsrz0TimelikeOps._concat_same_type..E s+R1AFFchh,>+Rs#&rrc3ZK|]"}|ddjz|ddk($yw)rrrNr)rpairrs rsrz0TimelikeOps._concat_same_type..G s/NtAwr{SXX-a;Ns(+)r_concat_same_typerrrzipr) r to_concatrnew_objrpairsrrrs @rsrzTimelikeOps._concat_same_type6 s '+It<l 19%.8qQ8I8xx#+R +R(RIcrNIabM:NNN"xxH$,GM9s BBcJt||}|j|_|S)N)order)rrrr)rrrrs rsrzTimelikeOps.copyL s#',U,+  ruc |dk7rt|s |j} n|jj} tj| f||||||d||s|St |j | |jS)z2 See NDFrame.interpolate.__doc__. linear)rurrclimitlimit_direction limit_arear)rrrrRinterpolate_2d_inplacerrr{) rrurrcrrrrrout_datas rs interpolatezTimelikeOps.interpolateQ s X % %}}H}}))+H&&  +!  KDz%%hdjj%AAruc 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) rrr{rrrr"r logical_andr)r values_intconsider_valuesrppd even_dayss rs_is_dates_onlyzTimelikeOps._is_dates_onlyz sstzz*YY $,"4::.d#NN?J4D4IJNNPTUU ru)rrDr+r-r1)rYdict)rr)r^ int | Noner+r4)r+r7r5r2)r'rr#rDr+r4)rtznp.ufuncrur)raiser)rxr6ryr7r+r4)rr6r?rDr+rDr3r/)TF)rrDrrD)r)rzSequence[Self]rr*r+r4)C)rrr+r4) rur/rr7rcrkrrDr+r4r*),rr8r9r:r;rrOr classmethodrQr<rsetterr rZrRrar?rr'r&rrsr|r= _round_doc_round_examplerr_floor_exampler _ceil_examplerrLrrrrrrrrrr=r>s@rsrqrqs!s~~EZ7=AZ7 Z7x''  [[   6 6@ ( (T'",' ''88))  * I:,zN*22g2>?$+'. T!T% T  T@TzN*22g2>?$+'. N!N% N  N@NzM)11V1<=$+'. M!M% M  M>M-1X-1X@*!%BBB0!  * $B#$B $B  $B$B $BRrurqct|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) Nr{rFzCannot create a z from a MultiIndex.Tr$rrrDrz)rrzrtuplerrrArNrrar^r\r{rr3r_maybe_convert_datelike_arrayrr]rrMr*takerr_values)rrcls_names rs!ensure_arraylike_for_datetimeliker s\ 4 !$u .2774=A3E:D6t< D- (*8*4GHIIT6$ %4,-$**//T2I}}Wt}4 : D- .113}} :rzz>: ;zz$ : D. )##DJJ3#?GG :rucyrprr^s rsvalidate_periodsr rucyrprrs rsrr rruc|itj|r1tjdtt t |}|Stj|std||S)a9 If a `periods` argument is passed to the Datetime/Timedelta Array/Index constructor, cast it to an integer. Parameters ---------- periods : None, float, int Returns ------- periods : None or int Raises ------ TypeError if periods is None, float, or int zNon-integer 'periods' in pd.date_range, pd.timedelta_range, pd.period_range, and pd.interval_range are deprecated and will raise in a future version.rzperiods must be a number, got ) ris_floatrrrr@r7rrrs rsrr sj$ << MM2+-  'lG N(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.abcrhrir2rkrrlrmrnr.rtrrr@rrrrrqrrrPrhrrursrs"   -.&K=C$/  5K   ?*?23  < '  ('12 1 6W3 )W3t0;1(;1|= ~66 8^(^J$$ #$$N    D ,=:&ru