uj2dZddlmZddlmZddlmZddlZddlm Z m Z m Z m Z m Z mZddlZddlZddlmZmZddlmZmZmZmZmZmZmZmZmZmZdd l m!Z!dd l"m#Z#m$Z$dd l%m&Z'dd l(m)Z)m*Z*m+Z+m,Z,m-Z-dd l.m/Z/ddl0m1Z1ddl2m3Z3m4Z4ddl5m6Z6ddl7m8Z8m9Z9m:Z:ddl;mm?Z?m@Z@mAZAmBZBddlCmDcmEZFddlGmHZHddlImJZJddlKmLZLddlMmNZNddlOmPZPddlQmRZRddlSmTZTe r ddlUmVZVmWZWddlXmXZXddlYmZZZm[Z[m\Z\m]Z]ddl^m_Z_Gdd eNeZ`Gd!d"e`eZay)#z; Base and utility classes for tseries type pandas objects. ) annotations)ABC)pairwiseN) TYPE_CHECKINGAnyLiteralSelfcastfinal)NaTlib) BaseOffsetDay ResolutionTick Timedelta Timestampget_resolutionparsing timezones to_offset)abbrev_to_npy_unit)RelativeDeltaOffsetWeek)function)InvalidIndexErrorNullFrequencyErrorOutOfBoundsDatetimeOutOfBoundsTimedeltaPandas4Warning)cache_readonly)find_stack_level) is_integer is_list_like) concat_compat)CategoricalDtypeDatetimeTZDtype PeriodDtype) algorithms roperator) DatetimeArrayExtensionArray PeriodArrayTimedeltaArray)ensure_wrapped_if_datetimelike)check_array_indexer)Index)NDArrayBackedExtensionIndex) RangeIndex) to_timedelta) frequencies)HashableSequence)datetime)AxisJoinHowTimeUnitnpt)CategoricalIndexcleZdZUdZdZded<dZded<ddd d#d Zed$d Z ed%d Z ed&d Z e d'dZ e d&dZe d(dZd)dZd*dZfdZdZdd d+dZd&dZfdZd,d&fd Zed-dZd.dZd/dZd0dZe d1dZd2d Zd3d4d!Zd"Z xZ!S)5DatetimeIndexOpsMixinzM Common ops mixin to support a unified interface datetimelike Index. Fz,DatetimeArray | TimedeltaArray | PeriodArray_dataTbool _warn_quarterrskipnaaxisc<|jj||S)a Return the mean value of the Array. This method computes the arithmetic mean of the datetime or timedelta values in the index, optionally skipping NaT values. 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[us]', freq=None) >>> tdelta_idx.mean() Timedelta('2 days 00:00:00') rC)r@mean)selfrDrEs k/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/core/indexes/datetimelike.pyrGzDatetimeIndexOpsMixin.meanus`zzf488c.|jjSac 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 )r@freqrHs rIrMzDatetimeIndexOpsMixin.freqs<zzrJc.|jjS)a  Return Integer representation of the values. For :class:`DatetimeIndex` and :class:`TimedeltaIndex`, the values are the number of time units (determined by the index resolution) since the epoch. For :class:`PeriodIndex`, the values are ordinals. Returns ------- numpy.ndarray An ndarray with int64 dtype. See Also -------- Index.values : Return an array representing the data in the Index, using native types (datetime64, timedelta64) rather than int64. Index.to_numpy : Return a NumPy ndarray of the index values. Examples -------- For :class:`DatetimeIndex` with default microsecond resolution: >>> idx = pd.DatetimeIndex(["2023-01-01", "2023-01-02"], dtype="datetime64[us]") >>> idx.asi8 array([1672531200000000, 1672617600000000]) For :class:`TimedeltaIndex` with millisecond resolution: >>> idx = pd.TimedeltaIndex(["1 day", "2 days"], dtype="timedelta64[ms]") >>> idx.asi8 array([ 86400000, 172800000]) For :class:`PeriodIndex`: >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M") >>> idx.asi8 array([636, 637, 638]) )r@asi8rNs rIrPzDatetimeIndexOpsMixin.asi8sRzzrJc|j}||St|jtrt |j S|j S)a Return the frequency object as a string if it's set, otherwise None. This property returns a string representation of the frequency (e.g., ``'D'`` for daily, ``'h'`` for hourly) when one has been set on the index, either explicitly or via inference. 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' )rM isinstancer@r-r(_freqstrfreqstr)rHrMs rIrTzDatetimeIndexOpsMixin.freqstrsAHyy <K djj+ .t$-- -||rJcXt|jtr|jjS|jjdk(r6t |j |j|jjSt |j d|jjS)NM)reso)tzrW) rRdtyper(_resolution_objkindrrPrXr@_cresorNs rIrZz%DatetimeIndexOpsMixin._resolution_objsn djj+ .::-- - ZZ__ #!$))TWW4::;L;LM M!$))4::;L;LM MrJc.|jjS)zO Returns day, hour, minute, second, millisecond or microsecond )rZattrnamerNs rI resolutionz DatetimeIndexOpsMixin.resolution&s ##,,,rJc.|jjSN)r@_hasnarNs rIhasnanszDatetimeIndexOpsMixin.hasnans/szz   rJc<|j|ryt|tsy|jjdvryt|t |sd|jt k(r|j}|jjdk(rd}n|jjdk(rd}nd}||vrytjtj|d }t|}t|t |jrt |j|}n|jjdk(r{|d k(rutj d t"t%  t ||}n=t|jt,r"t/d |}tj|j0}|jt k(r#tj|d }t|}n t|}t|t |jr t ||}n|jjdk(rk|jt k(rXtj2|j0d k(r6tj d t"t%  t ||}t |t |k7ry|j|jk(r*tj4|j6|j6S|jjdk(r|j8|j8k(s|jjdk(r] |jj;|j\}}tj4|j=d|j=dSy#t&t(t*f$rYywxYw#t&t(t*f$rYywxYw#t&t(t*f$rYywxYw#t>t@f$rYywxYw)zL Determines if two Index objects contain the same elements. TFiufcrV)r8 datetime64datem) timedelta timedelta64)period)convert_non_numericrgzInferring datetime64 from data containing datetime.date objects is deprecated. In a future version, these will be left as object dtype. Use pd.to_datetime to explicitly convert to datetime64. stacklevelr=i8)!is_rRr1rYr[typeobject inferred_typer maybe_convert_objectsnpasarrayr/r@ _simple_newwarningswarnr r" ValueError TypeError OverflowErrorr&r categories infer_dtypearray_equivalent_bytesrPrX_ensure_matching_resosviewrr)rHotherinferred compatible convertedcat_valsleftrights rIequalszDatetimeIndexOpsMixin.equals3sI 88E?%' [[   'E4:.{{f$ ..::??c)!CJZZ__+!=J!,J:- 55JJu%4 ;9E idjj)9: J229=EZZ__+F0BMMN'#3#5 % *T 5 1EKK)9:/7::e&6&67>>V+ # 9 9 d!I!?y II >x HIidjj)9:% *T 5 1JJOOs* &0(8(89VCMM1 '#3#5% *T 5 1 :e $ ZZ5;; &--diiD Djjoo$EHH)<TWAW U"jj?? L e11$))D/5::dCSTTe' =A%$%' =A%$%&' =A%$%()=>  sH'N;!O&O/(P ;OOO,+O,/PP PPc|t| |j|y#tttt f$rYywxYw)a Return a boolean indicating whether the provided key is in the index. Parameters ---------- key : label The key to check if it is present in the index. Returns ------- bool Whether the key search is in the index. Raises ------ TypeError If the key is not hashable. See Also -------- Index.isin : Returns an ndarray of boolean dtype indicating whether the list-like key is in the index. Examples -------- >>> idx = pd.Index([1, 2, 3, 4]) >>> idx Index([1, 2, 3, 4], dtype='int64') >>> 2 in idx True >>> 6 in idx False FT)hashget_locKeyErrorr{rzr)rHkeys rI __contains__z"DatetimeIndexOpsMixin.__contains__s@D S   LL )Z1BC  s ;;c|tjt|j}t|||Sra)rurvr4to_numpysuper_convert_tolerance)rH tolerancetarget __class__s rIrz(DatetimeIndexOpsMixin._convert_tolerances1JJ|I6??AB w))V<Eu% %  ) )4yd1g"tAw,BbMb4PR8m!2JMIE$11%)&1IH%225972KI*EH,<= =uRy(HuRy(Hx'00215 5rJcBt|tr3 |j|\}}|j \}}|dk(r|S|St||j js|j d||S#t$r}|j d||Yd}~sd}~wwxYw)aL If label is a string, cast it to scalar type according to resolution. Parameters ---------- label : object side : {'left', 'right'} Returns ------- label : object Notes ----- Value of `side` parameter should be validated in caller. rNr)rRrrrz_raise_invalid_indexerrr@_recognized_scalars)rHrrrrWrloweruppers rI_maybe_cast_slice_boundz-DatetimeIndexOpsMixin._maybe_cast_slice_boundWs" eS ! A#44U;  88vFLE5 FN5 5 5E4::#A#AB  ' ' 7  A++GUC@@  AsA88 BBBct)ae Shift index by desired number of time frequency increments. This method is for shifting the values of datetime-like indexes by a specified time increment a given number of times. Parameters ---------- periods : int, default 1 Number of periods (or increments) to shift by, can be positive or negative. freq : pandas.DateOffset, pandas.Timedelta or string, optional Frequency increment to shift by. If None, the index is shifted by its own `freq` attribute. Offset aliases are valid strings, e.g., 'D', 'W', 'M' etc. Returns ------- pandas.DatetimeIndex Shifted index. See Also -------- Index.shift : Shift values of Index. PeriodIndex.shift : Shift values of PeriodIndex. r)rHperiodsrMs rIshiftzDatetimeIndexOpsMixin.shift{s 6"!rJc |jj|d}t||jS#ttf$r+t |t st j|}n|}YPwxYw)zT Analogue to maybe_cast_indexer for get_indexer instead of get_loc. T) allow_objectrY) r@_validate_listlikerzr{rRr,comasarray_tuplesafer1rY)rHkeyarrress rI_maybe_cast_listlike_indexerz2DatetimeIndexOpsMixin._maybe_cast_listlike_indexersk **//T/JCS **I& fn5++F3  s67A0/A0)rDrArEz int | NonereturnBaseOffset | None)rznpt.NDArray[np.int64])rr)rrrrA)rrrrA)rrrrA)r list[str]rrr str | Nonerrra)rWrrrA)rWr)rrrztuple[datetime, Resolution])rrrslice | npt.NDArray[np.intp])rWrrr8rr)rrNrintrr )"__name__ __module__ __qualname____doc___can_hold_strings__annotations__rBrGpropertyrMrPrTr!rZr_rcrrr_default_na_reprrrrr rrrrrrrr __classcell__rs@rIr?r?ls_ 77M4%)a09d>((T((TNN--!!\|'R= OLP " ,/ >H  , , + + "2) 767676 & 76 76rH"> +rJr?ceZdZUdZded<ddgZddgZdZded<ejZ ejZ ejZed4d Zej"d5d Zd6d7fd Zd8fd Zd9fd Zd:d;fd Zd5dZd4dZfdZ d< d=fd Zed>dZd?dZdZed@dZdAdBdZedCdZ edDdZ!edEdZ"dFdZ#d9dZ$d9dZ%d9dZ&dGdHdZ'd Z(dId!Z)dId"Z*dJd#Z+fd$Z,d%Z- dKfd& Z.d@d'Z/dLd(Z0dMdNfd) Z1dOfd* Z2fd+Z3d4d,Z4dPfd- Z5dQd.Z6dRd/Z7d9fd0 Z8dRfd1 Z9d2e:jve:jvf dSd3Z<xZ=S)TDatetimeTimedeltaMixinze Mixin class for methods shared by DatetimeIndex and TimedeltaIndex, but not PeriodIndex zDatetimeArray | TimedeltaArrayr@rrMNr_freqc|jSrL)rrNs rIrMzDatetimeTimedeltaMixin.freqs8zzrJc|j}|qt|}|j|||jjdk(r!t |t tfs td|jdkDr td||_ y)Nrh(TimedeltaArray/Index freq must be a TickrzCannot set freq with ndim > 1) r@r_validate_frequencyrYr[rRrrr{ndimrzr)rHvaluearrs rIrMzDatetimeTimedeltaMixin.freqsrjj  e$E  # #C /yy~~$Zc{-K JKKxx!| !@AA rJcvt|||}t|t|r|j|_|S)N)copy)rastyperRrqr)rHrYr rrs rIr zDatetimeTimedeltaMixin.astypes3D1 fd4j )::FL rJc`t|||}t|t|rd|_|Sra)rputmaskrRrqr)rHmaskrrrs rIrzDatetimeTimedeltaMixin.putmasks-u- fd4j )FL rJcFt|}|j|_|Sra)r_viewr)rHrrs rIrzDatetimeTimedeltaMixin._viewszz  rJcLt|||}|j|_|S)N)rdeep)rr r)rHrrrrs rIr zDatetimeTimedeltaMixin.copys%4d3zz  rJcP|j}|d|_y|dk(r%|||_yt|j|_y|tj ur||_y|.t|}t |j||||_yt|}||k7rt|dk(r/|j|dstd|d|jt|trt|dkDrt|}|j|j }||k7s:t#j$|j&|j(k(j+sDtd|d|jt|dkDrt |j||||_y)a Constructor helper to pin the appropriate ``freq`` attribute on self. ``inferred`` is the frequency inferred from the input data (or ``None`` if no freq could be inferred), as determined by the caller before wrapping the array in this Index. NinferrrzInferred frequency z9 from passed values does not conform to passed frequency )r@rr_inferred_freq_strr no_defaultrqrr is_on_offsetrzrTrRrras_unitunitrudiffrP_valueall)rHrMrr deltasteps rI _pin_freqz DatetimeTimedeltaMixin._pin_freqsjj <DJ W_#% 't'>'>? S^^ #"DJ  T?D I ) )$ 5DJT?Dxt9>,,T!W5(1(H# 6;Q(R' (yH'  rJcZ|j|rU|jjdkrtjt |tj }|j }d|_||fSt |dkDr`|js |jrHtj|jj|j|\}}||}d|_||fSt|=||S)Nrrrr)sortuse_na_sentinel)rMnruarangerintpr _namerrr)factorize_monotonic_codesr@rr factorize)rHr2r3codesuniquesuniques_indexerrs rIr9z DatetimeTimedeltaMixin.factorizezs 99  a #d)a-RrwwGtt* #d)277;))+ GM'> ! t9q=  ( (D,H,H&0%I%I ##T%A%A4& "E??+G GM'> !w dO LLrJc.|jjS)a The precision unit of the datetime data. Returns the precision unit for the dtype of the index. This is the smallest time frame that can be stored within this dtype. Returns ------- str Unit string representation (e.g. ``"ns"``). See Also -------- DatetimeIndex.as_unit : Convert to the given unit. TimedeltaIndex.as_unit : Convert to the given unit. Examples -------- For a DatetimeIndex: >>> idx = pd.DatetimeIndex(["2020-01-02 01:02:03.004005006"]) >>> idx.unit 'ns' >>> idx_s = pd.DatetimeIndex(["2020-01-02 01:02:03"], dtype="datetime64[s]") >>> idx_s.unit 's' For a TimedeltaIndex: >>> tdidx = pd.TimedeltaIndex(["1 day 3 min 2 us 42 ns"]) >>> tdidx.unit 'ns' >>> tdidx_s = pd.TimedeltaIndex(["1 day 3 min"], dtype="timedelta64[s]") >>> tdidx_s.unit 's' )r@rrNs rIrzDatetimeTimedeltaMixin.unitsPzzrJc|jj|}t|j||j}|j |_|S)a Convert to a dtype with the given unit resolution. This method is for converting the dtype of a ``DatetimeIndex`` or ``TimedeltaIndex`` to a new dtype with the given unit resolution/precision. Parameters ---------- unit : {'s', 'ms', 'us', 'ns'} Returns ------- same type as self Converted to the specified unit. See Also -------- Timestamp.as_unit : Convert to the given unit. Timedelta.as_unit : Convert to the given unit. DatetimeIndex.as_unit : Convert to the given unit. TimedeltaIndex.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) r)r@rrqrwrrMr)rHrr rs rIrzDatetimeTimedeltaMixin.as_unitsFXjj  &d''$))'<yy  rJc|nst|tr:|jjdk(rJt|tt fs4t d|dk(rt|j}ntd||jj}t|j||j}||_|S)NrhrrzInvalid frequency: r)rRrrYr[rrr{rrrzr@rrqrwr7r)rHrMr rs rI _with_freqz!DatetimeTimedeltaMixin._with_freqs <  j )zz#%jc{.K JKK W_T445D24(;< <jjood''$**'=  rJct|jtrtjdt d|j j}|j}d|j_ |S)NaDatetimeIndex.values returning an ndarray that drops timezone information is deprecated. In a future version, this will return the underlying DatetimeArray instead. Use 'DatetimeIndex.tz_convert(None).to_numpy()' to get a NumPy array of UTC values, or 'DatetimeIndex.array' to get the ExtensionArray. See https://pandas.pydata.org/docs/dev/whatsnew/v3.1.0.html#whatsnew-310-deprecations-values for more details.rrmF) rRrYr'rxryr r@rrflags writeable)rHdatas rIvalueszDatetimeTimedeltaMixin.valuessX djj/ 2 MM% zz""yy{$  rJc|4||jk7r%t|tr t|}||z}||zS|dk(st |dk(r|j S|j t d|d||jzz}|d||jzz}|jj||d|j|j}t|j||j}|j|_ |S)ad Shift index by desired number of time frequency increments. This method is for shifting the values of datetime-like indexes by a specified time increment a given number of times. Parameters ---------- periods : int, default 1 Number of periods (or increments) to shift by, can be positive or negative. freq : pandas.DateOffset, pandas.Timedelta or string, optional Frequency increment to shift by. If None, the index is shifted by its own `freq` attribute. Offset aliases are valid strings, e.g., 'D', 'W', 'M' etc. Returns ------- pandas.DatetimeIndex Shifted index. See Also -------- Index.shift : Shift values of Index. PeriodIndex.shift : Shift values of PeriodIndex. NrzCannot shift with no freqr)startendrrMrr)rMrRrrrr rr@_generate_rangerrqrwrr)rHrrMoffsetrGrHr rs rIrzDatetimeTimedeltaMixin.shifts4   1$$ t^F&= a<3t9>99;  99 $%@A AQ'DII--2h499,, jj((S$TYYTYY) d''$))'<yy  rJc.|jjS)zP Internal version of inferred_freq without deprecation warning. )r@rrNs rIrz)DatetimeTimedeltaMixin._inferred_freq_strJs zz,,,rJcBtj|jdS)a6 Return the inferred frequency of the index. .. deprecated:: 3.1.0 A future version of pandas will return a :class:`BaseOffset` instead of a string. Use ``pd.set_option('future.infer_freq_returns_offset', True)`` to opt in to the future behavior. Attempts to determine the frequency of the index by analyzing the differences between consecutive values using ``infer_freq``. Returns ------- str or None A string representing a frequency generated by ``infer_freq``. Returns ``None`` if the frequency cannot be inferred. 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 # doctest: +SKIP '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 # doctest: +SKIP '10D' inferred_freq)r5maybe_convert_inferred_freqrrNs rIrMz$DatetimeTimedeltaMixin.inferred_freqQs#T66  # #_  rJctd|j}t|j|jj }t |dj |dj |z|}t|S)Nrrr)r rMrrrrranger3)rHrMtickrngs rI_as_range_indexz&DatetimeTimedeltaMixin._as_range_indexs_FDII&&&tyy188DGNNDHOOd$:DA#rJcnt|jtxrt|jtSra)rRrMrr%s rI_can_range_setopz'DatetimeTimedeltaMixin._can_range_setops#$))T*Kz%**d/KKrJcd}t|s |j}nSt|trCt t |j |jj|j}|jj|jjj}t|jj||j}t!d|j#||}||_|S)Nrrr )rrMrRr3rrrrrrErr@rrYrqrwr _wrap_setop_resultr)rHrres_i8r0 res_valuesr rs rI_wrap_range_setopz(DatetimeTimedeltaMixin._wrap_range_setops6{yyH  + &++DII6>>tyyIH]]'' (;(;(A(AB 4::** ** + fd55eSAB  rJc||j}|j}|j||}|j||SNr2)rS intersectionr[rHrr2rrrYs rI_range_intersectz'DatetimeTimedeltaMixin._range_intersects@##%%""5t"4%%eV44rJc||j}|j}|j||}|j||Sr])rSunionr[r`s rI _range_unionz#DatetimeTimedeltaMixin._range_unions=##%%E-%%eV44rJc<td|}|j|r|j||S|j|sJt j |||}|j ||}|jdjdS|j||S)z_ intersection specialized to the case with matching dtypes and both non-empty. rr^Nr) r rUra_can_fast_intersectr1 _intersectionrXr@_fast_intersect)rHrr2rs rIrgz$DatetimeTimedeltaMixin._intersections-u5   '((T(: :''.((u4@F ,,UF;F$$T*55g> >''t4 4rJc,|d|dkr||}}n||}}t|d|d}|d}||kr|ddSt|j||}|j|}t |j ||j } |j| _| S)Nrrr) minr slice_locs_valuesrqrwrrMr) rHrr2rrrHrGlslicer rs rIrhz&DatetimeTimedeltaMixin._fast_intersects 7eAh %D%D$r(E"I&a ;8Os34ll6"d''$))'<yy  rJc|jy|j|jk7ry|jsy|j}t|try|jdk7ry|d}|d}t|t r:|j |jf|j |jfk7ryt|tr4|j(|j|jz dzdk7ryy)NFrrT) rMrrRrr4rtime nanosecondrweekday toordinal)rHrrM left_start right_starts rIrfz*DatetimeTimedeltaMixin._can_fast_intersects 99  ZZ499 $--yy d/ 0 66Q;!W Ah j) ,!:#8#89  "&&> dD !dll&:$$&)>)>)@@AEJrJc|j}|||jk7ry|jsyt|dk(st|dk(ry|d|dkr||}}n||}}|d}|d}|||zk(xs||vS)NFrTr)rMrr)rHrrMrrruleft_ends rI_can_fast_unionz&DatetimeTimedeltaMixin._can_fast_unionsyy <45::-++ t9>SZ1_ 7eAh %D%DAh 8x$.F;$3FFrJcZ|d|dkr||}}n||}}|d}|d}||kr|j|d}|j|d}t|j|g}t|t |j sJt |j |} |j| _| S|S)Nrrrr) rrlr%rRrqr@rwrMr) rHrrrrw right_endloc right_chunkdatesrs rI _fast_unionz"DatetimeTimedeltaMixin._fast_union4s 7eAh %D%D8"I  i $$XG$EeT$**%56 66$Z++E2F99FLMKrJctt|t|sJ|j|jk(sJ|j|r|j ||S|j |r |dus |d|dkr|j |S|j|t|%||}|jdS)Nr^Frr) rRrqrYrUrdrxr~rXr_unionr@)rHrr2rrs rIrzDatetimeTimedeltaMixin._unionOs%d,,,zzU[[(((   '$$U$6 6    &D,=aERSHAT ##E* *,,UEGN5$4OPF$$W- -rJcDd}|j|r |j}|S)zK Get the freq to attach to the result of a join operation. N)rxrM)rHrrMs rI_get_join_freqz%DatetimeTimedeltaMixin._get_join_freqes%    &99D rJc|j|jk(sJ|j|jft| |||||\}}}|j||_|||fSra)rYr_wrap_join_resultrr)rHjoinedrlidxridxhow join_indexrs rIrz(DatetimeTimedeltaMixin._wrap_join_resultnsp{{djj(C5;; *CC(!&!: E4s"  D$ ..u5 4%%rJcL|jjjdS)Nro)r@rrrNs rI_get_engine_targetz)DatetimeTimedeltaMixin._get_engine_target}szz""''--rJc|j|jjj}|jj |Sra)rr@rrY_from_backing_data)rHrs rI_from_join_targetz(DatetimeTimedeltaMixin._from_join_targets5TZZ00667zz,,V44rJch|jrt|ttfrt |j t |j kDrU|dk(r|j |j }n4|j|j j |j }t|%||S)Nr) rrRrrrrrceilr_searchsorted_monotonic)rHrrrs rIrz.DatetimeTimedeltaMixin._searchsorted_monotonics  ( (59i"89"5::.1CDII1NNw dii0 499-55dii@w.ud;;rJcRt||}|j||_|Sra)r_getitem_slice_get_getitem_freqr)rHslobjrrs rIrz%DatetimeTimedeltaMixin._getitem_slices)'.--e4  rJc|t||}t|t|r|j ||_|Sra)r __getitem__rRrqrr)rHrrrs rIrz"DatetimeTimedeltaMixin.__getitem__s7$S) fd4j )11#6FL rJct|j|}d}t|trA|j'|j |j |jz}|S|j}|S|t ur|j}|Stj|rStj|jtj}t|tr|j|S|S)z\ Find the `freq` attribute to assign to the result of a __getitem__ lookup. N)r0r@rRrrMrEllipsisris_bool_indexerr maybe_booleans_to_slicerruuint8r)rHrrMnew_keys rIrz(DatetimeTimedeltaMixin._get_getitem_freqs"$**c2 c5 !yy$)=xx$))+ yy H_99D    %11#((2882DEG'5)--g66 rJc  t ||}td|d td|Dcgc]}t|s|c}}t |t r j t fd|Dr j tjdd}t ts|t trtfd|Dr~t jjj |Dcgc]'}|j j"j%d)}}t fdt'|D}nt fd t'|D}|r |_|Scc}wcc}w) Nrrzlist[DatetimeTimedeltaMixin]c3PK|]}|jjk(ywra)rM).0idxobjs rI z1DatetimeTimedeltaMixin._concat..sGSCHH(G#&rXc3PK|]}|jjk(ywrarW)rrrHs rIrz1DatetimeTimedeltaMixin._concat..sJchh$))+Jrroc3@K|]\}}|dz|dk(yw)rrN)rabrs rIrz1DatetimeTimedeltaMixin._concat..s&#STQAbEDLAaD$8#Ssc3FK|]}|ddz|ddk(yw)rrrNr)rpairrMs rIrz1DatetimeTimedeltaMixin._concat..s3$GBK$&$q'!*4$s!)r_concatr rrRrqrMrgetattrrYrrrrrrr@rrrr) rH to_concatrrrto_concat_nonemptyrXi8s evenly_spacedrMrrrs ` @@@rIrzDatetimeTimedeltaMixin._concatsGD1+Yq\:! *% 2SSS 2  vtDz *$G4FGG88DT40B4&2:*T3:OJ7IJJ!..tyy9@@@RSsyy))..t4SS ##SXc]#S S #$ (); <$! #  5 3 TsF F ,Fcd}|jt|r,|dt| dt|dz fvr |j}|St|rBt j t j|t jt|}t|trA|jdvr3|jdvs|jt|dfvr |j}|S)z7 Find the `freq` for self.delete(loc). Nrrrrr)rN)rMr#rr$r maybe_indices_to_slicerurvr6rRrrrGstop)rHr{rMs rI_get_delete_freqz'DatetimeTimedeltaMixin._get_delete_freqs 99 #1s4yj"c$i!m<<99D  $44 3bgg6D Cc5)chh).CyyI-c$i=N1N#yy rJc"|jj|}|jj|}d}|j|jro|t ur |S|dt | fvr#||jz|dk(r|j}|S|t |k(r!||jz |dk(r |j}|St|jtr|j}|S|jj|r |j}|S)z= Find the `freq` for self.insert(loc, item). Nrr) r@_validate_scalar _box_funcrMsizer rrRrr)rHr{itemrrMs rI_get_insert_freqz'DatetimeTimedeltaMixin._get_insert_freqs ++D1zz##E* 99 yy3; QT O+tyy0@DG0K99D SY&D499,<R,H99D DIIt,yy ''-yy rJcRt||}|j||_|S)a Make new Index with passed location(-s) deleted. Parameters ---------- loc : int or list of int Location of item(-s) which will be deleted. Use a list of locations to delete more than one value at the same time. Returns ------- Index Will be same type as self, except for RangeIndex. See Also -------- numpy.delete : Delete any rows and column from NumPy array (ndarray). Examples -------- >>> idx = pd.Index(["a", "b", "c"]) >>> idx.delete(1) Index(['a', 'c'], dtype='str') >>> idx = pd.Index(["a", "b", "c"]) >>> idx.delete([0, 2]) Index(['b'], dtype='str') )rdeleterr)rHr{rrs rIrzDatetimeTimedeltaMixin.delete s*8$,,S1  rJct|||}t|t|r|j |||_|S)a Make new Index inserting new item at location. Follows Python numpy.insert semantics for negative values. Parameters ---------- loc : int The integer location where the new item will be inserted. item : object The new item to be inserted into the Index. Returns ------- Index Returns a new Index object resulting from inserting the specified item at the specified location within the original Index. See Also -------- Index.append : Append a collection of Indexes together. Examples -------- >>> idx = pd.Index(["a", "b", "c"]) >>> idx.insert(1, "x") Index(['a', 'x', 'b', 'c'], dtype='str') )rinsertrRrqrr)rHr{rrrs rIrzDatetimeTimedeltaMixin.insert-s<8T* fd4j )00d;FL rJrc >tjd|tj|tj}t j |||||fi|}tj|t|}t|tr|j|}||_ |S)ar Return a new Index of the values selected by the indices. For internal compatibility with numpy arrays. Parameters ---------- indices : array-like Indices to be taken. axis : {0 or 'index'}, optional The axis over which to select values, always 0 or 'index'. allow_fill : bool, optional How to handle negative values in `indices`. * False: negative values in `indices` indicate positional indices from the right, matching :func:`numpy.take`. * True: negative values in `indices` indicate missing values. ``-1`` entries are set to ``fill_value`` (defaulting to ``NaT`` if not supplied). Any other negative values raise a ``ValueError``. * Not supplied: defaults to ``allow_fill=False`` unless ``fill_value`` is explicitly provided, in which case fill semantics apply (``allow_fill=True``). fill_value : scalar, optional If fill semantics apply (see ``allow_fill``), indices specified by ``-1`` are filled with ``fill_value``. Passing ``fill_value=None`` is equivalent to passing ``self._na_value`` (``NaT``). **kwargs Required for compatibility with numpy. Returns ------- Index An index formed of elements at the given indices. Will be the same type as self, except for RangeIndex. See Also -------- numpy.ndarray.take: Return an array formed from the elements of a at the given indices. Examples -------- >>> idx = pd.date_range("2024-01-01", periods=3) >>> idx.take([2, 1, 0]) DatetimeIndex(['2024-01-03', '2024-01-02', '2024-01-01'], dtype='datetime64[us]', freq='-1D') rr)nv validate_takerurvr6r2taker rrrRrrr) rHindicesrE allow_fill fill_valuekwargsr maybe_slicerMs rIrzDatetimeTimedeltaMixin.takeRsn V$**WBGG4,11 '4Z ;A 00#d)D k5 )))+6DFL rJr)rNone)T)r rA)rr1)rr )NF)rzHashable | NonerrArr )FT)r2rAr3rA)rr;)rr;rr )r np.ndarrayrr)rr)rzstr | BaseOffset | None)rr3r)F)rr1r2rArr1)rr rrA)rr rr )rnpt.NDArray[np.intp] | Nonerrrr:rzEtuple[Self, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None])rr)r)rzLiteral['left', 'right'])rrrr )rz list[Index]rr6rr1)r{zint | slice | Sequence[int])r{r)rEr9rzbool | lib.NoDefaultrr )>rrrrr _comparablesrrr1r_is_monotonic_increasingr_is_monotonic_decreasing is_unique _is_uniquerrMsetterr rrr r r&r(r9rrr@rErr!rrMrSrUr[rardrgrhrfrxr~rrrrrrrrrrrrrrr rrrrs@rIrrs *)F#L6"K#E # %<<$<<J : [[    @D,\  $MMM6''R/b"(2h-- + + `L6555.*1fG<6., &* & * &  & O &.5 <&  *"H,4@ P+.>>>> BB) B BrJr)br __future__rabcr itertoolsrr*typingrrrr r r rxnumpyru pandas._libsr r pandas._libs.tslibsrrrrrrrrrrpandas._libs.tslibs.dtypesrpandas._libs.tslibs.offsetsrrpandas.compat.numpyrr pandas.errorsrrrrr pandas.util._decoratorsr!pandas.util._exceptionsr"pandas.core.dtypes.commonr#r$pandas.core.dtypes.concatr%pandas.core.dtypes.dtypesr&r'r( pandas.corer)r*pandas.core.arraysr+r,r-r.pandas.core.commoncorecommonrpandas.core.constructionr/pandas.core.indexersr0pandas.core.indexes.baser1pandas.core.indexes.extensionr2pandas.core.indexes.ranger3pandas.core.tools.timedeltasr4pandas.tseriesr5collections.abcr6r7r8pandas._typingr9r:r;r<pandasr=r?rrrJrIrs#   :/54  ! C4F05&"({+7{+|j2CjrJ