o Tja@sddlmZddlmZmZddlmZddlZddlmZm 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~mmZdd lmZmZmZdd!lmZmZdd"lmZdd#lmZmZdd$lmZerdd%lmZmZdd&lmZdd'lmZmZmZe e8efZdTd*d+ZdUd/d0ZGd1d2d2etevZGd3d4d4eZd5Zd6Zd7Zd8ZGd9d:d:eZdVd?d@ZedWdCdDZedXdGdDZdYdJdDZdZdNdOZd[dRdSZdS)\) annotations)datetime timedelta)wrapsN) TYPE_CHECKINGAnyCallableLiteralUnioncastfinaloverload)using_string_dtype)algoslib) NDArrayBacked) BaseOffsetIncompatibleFrequencyNaTNaTTypePeriod ResolutionTick Timedelta Timestampadd_overflowsafeastype_overflowsafeget_unit_from_dtypeiNaTints_to_pydatetimeints_to_pytimedeltaperiods_per_day to_offset)RoundTo round_nsint64)compare_mismatched_resolutions)get_unit_for_round)integer_op_not_supported) ArrayLikeAxisIntDatetimeLikeScalarDtypeDtypeObjFInterpolateOptionsNpDtypePositionalIndexer2DPositionalIndexerTuple ScalarIndexerSelfSequenceIndexer TimeAmbiguousTimeNonexistentnpt)function)AbstractMethodErrorInvalidComparisonPerformanceWarning)Appender Substitutioncache_readonly)find_stack_level)'construct_1d_object_array_from_listlike)is_all_stringsis_integer_dtype is_list_likeis_object_dtypeis_string_dtype pandas_dtype) ArrowDtypeCategoricalDtypeDatetimeTZDtypeExtensionDtype PeriodDtype)ABCCategorical ABCMultiIndex)is_valid_na_for_dtypeisna) algorithmsmissingnanopsops)isin map_arrayunique1d)datetimelike_accumulations)OpsMixin)NDArrayBackedExtensionArray ravel_compat)ArrowExtensionArray)ExtensionArray) IntegerArray)arrayensure_wrapped_if_datetimelike extract_array)check_array_indexercheck_setitem_lengths)unpack_zerodim_and_defer)invalid_comparisonmake_invalid_op) frequencies)IteratorSequenceIndex) DatetimeArray PeriodArrayTimedeltaArrayop_namestrcCst|}t||SN)rerc)rnoprrb/home/dinkstrade/pdmp-scanner/venv/lib/python3.10/site-packages/pandas/core/arrays/datetimelike.py_make_unpacked_invalid_ops rtmethr-returncstfdd}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. csxt|jts|g|Ri|S|d}|g|Ri|}|tur'tSt|tr2||jS|d}||S)NM8[ns]i8) isinstancedtyperKviewrr _box_func_value_from_backing_data)selfargskwargsarrresultres_i8rurrrsnew_meths      z"_period_dispatch..new_meth)rr r-)rurrrrrs_period_dispatchs rcseZdZUdZded<ded<ded<ded <d ed <edddZ ddddZedddZ dddZ dd!d"Z dd$d%Z d&d'Z dd(d)Zdd+d,Zedd.d/Zd0dd1dd5d6Zddd8d9Z ddde dddZ?e dddZ@e dddZAe dddZBe d ddZCe d!ddZDe d"ddZEe d#ddZFddZGddZHd$ddZIe d%ddZJe ddZKe ddZLe d&dd„ZMe d'ddĄZNdQdŜd(ddɄZOePdʃdd̄ZQdd΄ZRePdσddфZSddӄZTd ddՄZUd ddׄZVeWd)fdd܄ ZXeWddQdݜd*ddZYeWddQdݜd*ddZZdQddd+ddZ[eWddQdݜd*ddZ\d d,ddZ]d-ddZ^Z_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 | NonefreqrvboolcCsdS)NTrrrrrrrrs _can_hold_naz#DatetimeLikeArrayMixin._can_hold_naNFrz Dtype | NonecopyNonecCt|rpr9)rdatarzrrrrrrrs__init__szDatetimeLikeArrayMixin.__init__type[DatetimeLikeScalar]cCr)z The scalar associated with this datelike * PeriodArray : Period * DatetimeArray : Timestamp * TimedeltaArray : Timedelta rrrrrrrs _scalar_types z#DatetimeLikeArrayMixin._scalar_typevaluero DTScalarOrNaTcCr)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. rrrrrrrrs_scalar_from_stringz*DatetimeLikeArrayMixin._scalar_from_string)np.int64 | np.datetime64 | np.timedelta64cCr)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') rrrrrrrs _unbox_scalarsz$DatetimeLikeArrayMixin._unbox_scalarothercCr)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 rrrrrrrrs_check_compatible_withrz-DatetimeLikeArrayMixin._check_compatible_withcCr)zI box function to get object from internal representation r)rxrrrrrsr|/z DatetimeLikeArrayMixin._box_funccCstj||jddS)z1 apply box func to passed values F)convert)r map_inferr|)rvaluesrrrrrs _box_values5sz"DatetimeLikeArrayMixin._box_valuesrgcs8jdkrfddttDSfddjDS)Nc3s|]}|VqdSrprr).0nrrrrs =sz2DatetimeLikeArrayMixin.__iter__..c3s|]}|VqdSrp)r|)rvrrrrsr?s)ndimrangelenasi8rrrrrs__iter__;s zDatetimeLikeArrayMixin.__iter__npt.NDArray[np.int64]cCs |jdS)z Integer representation of the values. Returns ------- ndarray An ndarray with int64 dtype. rx)rr{rrrrrrsrAs zDatetimeLikeArrayMixin.asi8r)na_rep date_formatr str | floatnpt.NDArray[np.object_]cCr)z| Helper method for astype when converting to strings. Returns ------- ndarray[str] r)rrrrrrrrs_format_native_typesQs z+DatetimeLikeArrayMixin._format_native_typesboxedcCsdjS)Nz'{}')format)rrrrrrrs _formatter]sz!DatetimeLikeArrayMixin._formatterNpDtype | None bool | NonecCsRt|r|durtjdttdtjt|tdS|dur&tj|j |dS|j S)NFaSStarting with NumPy 2.0, the behavior of the 'copy' keyword has changed and passing 'copy=False' raises an error when returning a zero-copy NumPy array is not possible. pandas will follow this behavior starting with pandas 3.0. This conversion to NumPy requires a copy, but 'copy=False' was passed. Consider using 'np.asarray(..)' instead. stacklevelrzT) rDwarningswarn FutureWarningr?npr^listobjectr)rrzrrrrrrs __array__ds z DatetimeLikeArrayMixin.__array__itemr2cCdSrprrrrrrrrrs __getitem__{rz"DatetimeLikeArrayMixin.__getitem__(SequenceIndexer | PositionalIndexerTupler3cCrrprrrrrrrrsrskeyr0Self | DTScalarOrNaTcs:tdt|}t|r|Stt|}|||_|S)z This getitem defers to the underlying array, which by-definition can only handle list-likes, slices, and integer scalars zUnion[Self, DTScalarOrNaT])r superrr is_scalarr3_get_getitem_freq_freq)rrr __class__rrrsrs    cCst|jt}|r |j}|S|jdkrd}|St||}d}t|tr9|jdur4|jdur4|j|j}|S|j}|S|turB|j}|St |rZt | tj}t|trZ||S|S)z\ Find the `freq` attribute to assign to the result of a __getitem__ lookup. rN)ryrzrKrrraslicestepEllipsiscomis_bool_indexerrmaybe_booleans_to_slicer{ruint8r)rr is_periodrnew_keyrrrrrsrs.          z(DatetimeLikeArrayMixin._get_getitem_freq,int | Sequence[int] | Sequence[bool] | sliceNaTType | Any | Sequence[Any]cs.t|||}t|||rdS|dSrp)rbr __setitem___maybe_clear_freq)rrrno_oprrrrsrs  z"DatetimeLikeArrayMixin.__setitem__cCrrprrrrrrrrsrsz(DatetimeLikeArrayMixin._maybe_clear_freqTc s\t|}|tkr;|jjdkr"td|}|j}t||jd|jd}|S|jjdkr/t |j ddS| |j  |jSt|r[t|trW|j|jd}|}|j||d d S|St|trhtj||d S|jd vr|j}|tjkrtd |jd|d|r|}|S|jdvr|j|ks|jdkrdt|jd|}t|tj||dS)NMrk timestamp)tzboxresomT)r)rF)rzrriuzConverting from z to z? is not supported. Do obj.astype('int64').astype(dtype) insteadmMfz Cannot cast z to dtype r)rFrrzkindr rrr_cresor rrravelreshapeshaperEryrJrna_valueconstruct_array_type_from_sequencerastyperint64 TypeErrorrtype__name__asarray) rrzri8data converted arr_objectclsrmsgrrrrsrsH       zDatetimeLikeArrayMixin.astypecCrrprrrrrrrrsr{ rzDatetimeLikeArrayMixin.viewLiteral['M8[ns]']rkcCrrprrrrzrrrrrsr{ rLiteral['m8[ns]']rmcCrrprrrrrrrrsr{r.r(cCrrprrrrrrrrsr{rcs t|Srp)rr{rrrrrsr{s c Cst|trz||}Wn ttfyt|wt||js$|turE||}z| |W|St tfyD}zt||d}~wwt |sMt|t |t |krYtdz|j |dd}| |W|St tfy}ztt|ddr{nt||WYd}~|Sd}~ww)NzLengths must matchT) allow_objectrz)ryror ValueErrorrr:rrrrrrCr_validate_listlikerDgetattr)rrerrrrrrrs_validate_comparison_value#s>       z1DatetimeLikeArrayMixin._validate_comparison_value)allow_listlikeunboxr rc Cst||jrnQt|tr+z||}WnDty*}z |||}t||d}~wwt||jr4t }n$t |rB|||}t|t||j rN||}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) ryrrorr_validation_error_messagerrNrzrrOrr)rrr rr rrrrrrs_validate_scalarGs,          z'DatetimeLikeArrayMixin._validate_scalarcCsrt|drt|dddkr|jd}n dt|jd}|r,d|jjd|d}|Sd|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 rzrrz array'zvalue should be a 'z!', 'NaT', or array of those. Got z instead.z' or 'NaT'. Got )hasattrr rzrrr)rrr msg_gotrrrrrrsrs  z0DatetimeLikeArrayMixin._validation_error_messagerc Cst|t|r|jjdvr|s|j|jdd}|St|tr.t|dkr.t|jg|jdSt |drc|jt krct ||j vrcz t||}Wnttfyb|rX|YS||d}t|wt|dd}t|}t|dd}t|rz t|j||jd}Wn tyYnwt|jtr|jj|jkr|}t|dd}|rt|jrnt||js||d}t||jjdvr|s|j|jdd}|S) NrFround_okrrrzT extract_numpy)ryrrzras_unitunitrrrrrr infer_dtyperrrrr`pd_arrayrArH categories_internal_get_valuesrDr)rrrrrrrrrsr sJ       z)DatetimeLikeArrayMixin._validate_listlikecCs,t|r ||}n|j|ddS||S)NT)r )rCr r_unboxrrrrrrs_validate_setitem_values  z.DatetimeLikeArrayMixin._validate_setitem_value6np.int64 | np.datetime64 | np.timedelta64 | np.ndarraycCs,t|r ||}|S|||j}|S)zZ Unbox either a scalar with _unbox_scalar or an instance of our own type. )rrrrrrrrrrrsrs   zDatetimeLikeArrayMixin._unboxcCs:ddlm}t|||d}||}t|tr|S|jS)Nrri) na_action)pandasrjrUryrMto_numpyr^)rmapperr!rjrrrrrrsmaps  zDatetimeLikeArrayMixin.maprnpt.NDArray[np.bool_]c Csj|jjdvrtj|jtdSt|}t|t|sgd}|jt krYt j |d|jd}|jt kr5| |St j |dd}||vrY|dkrEnd |vrQt |t |Stj|jtdSz t||}Wntyst |t |YSwtjd |jd ttd |jjd vrtd|}||j}z||Wnttfytj|jtdYSwt |j|jS)z Compute boolean array of whether each value is found in the passed set of values. Parameters ---------- values : np.ndarray or ExtensionArray Returns ------- ndarray[bool] fiucr)r timedelta64r datetime64dateperiodT)convert_non_numericdtype_if_all_natFskipnastringmixedz"The behavior of 'isin' with dtype=z and castable values (e.g. strings) is deprecated. In a future version, these will not be considered matching by isin. Explicitly cast to the appropriate dtype before calling isin instead.rrDatetimeArray | TimedeltaArray)rzrrzerosrrr_ryrrrmaybe_convert_objectsrTrrrrrrrr?r rrrrr)rr inferableinferredrrrrrsrTsN        zDatetimeLikeArrayMixin.isincC|jSrp)_isnanrrrrrrsrOXszDatetimeLikeArrayMixin.isnacCs |jtkS)z- return if each value is nan )rrrrrrrrsr8[ zDatetimeLikeArrayMixin._isnancCst|jS)zJ return if I have any nans; enables various perf speedups )rr8anyrrrrrrs_hasnabszDatetimeLikeArrayMixin._hasnarcCs6|jr|r ||}|durtj}t||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. N)r;rrnanputmaskr8)rr fill_valuerrrrrrs_maybe_mask_resultsis z*DatetimeLikeArrayMixin._maybe_mask_results str | NonecCs|jdurdS|jjS)a{ Return the frequency object as a string if it's set, otherwise None. 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)rfreqstrrrrrrrsrAs zDatetimeLikeArrayMixin.freqstrcCs0|jdkrdSzt|WStyYdSw)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)rrf infer_freqrrrrrrrs inferred_freqs   z$DatetimeLikeArrayMixin.inferred_freqResolution | NonecCs4|j}|dur dSzt|WStyYdSwrp)rArget_reso_from_freqstrKeyError)rrArrrrrs_resolution_objs  z&DatetimeLikeArrayMixin._resolution_objcCs|jjS)zO Returns day, hour, minute, second, millisecond or microsecond )rGattrnamerrrrrrs resolutionsz!DatetimeLikeArrayMixin.resolutioncCtj|jdddS)NTtimelikerr is_monotonicrrrrrrrs_is_monotonic_increasingz/DatetimeLikeArrayMixin._is_monotonic_increasingcCrJ)NTrKrrMrrrrrrs_is_monotonic_decreasingrPz/DatetimeLikeArrayMixin._is_monotonic_decreasingcCstt|jd|jkS)NK)rrVrrsizerrrrrrs _is_uniquesz!DatetimeLikeArrayMixin._is_uniquec Cs|jdkrt|dd|jkr||||jSz||}Wnty1t|||YSwt|dd}t|rKt |t | t|}|S|turh|tjur^t j|jtd}|St j|jtd}|St|jtstt|}|j|jkrt|t|sz |j|jdd}Wn tyt |j }t!|j"||YSw|j"}t!|j"||S|#|}||j"$d|$d}t%|}|j&|B}|'r|tju} t (||| |S)NrrrzrFrrx))rr rrrr r:rdrDrScomp_method_OBJECT_ARRAYrrrrroperatorneonesrr3ryrzrKr TimelikeOpsrrrrrr^asm8r%rrr{rOr8r:r=) rrrqrzr other_arr other_valso_maskmask nat_resultrrrrrs _cmp_methodsR           z"DatetimeLikeArrayMixin._cmp_method__pow____rpow____mul____rmul__ __truediv__ __rtruediv__ __floordiv__ __rfloordiv____mod____rmod__ __divmod__ __rdivmod__@tuple[int | npt.NDArray[np.int64], None | npt.NDArray[np.bool_]]cCsPt|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)ryrordinalrrr}r8r)rri8valuesr^rrrrrs_get_i8_values_and_mask.s z.DatetimeLikeArrayMixin._get_i8_values_and_maskcCs6t|jtr |jSt|sdSt|jtr|jSdS)zP Check if we can preserve self.freq in addition or subtraction. N)ryrzrKrrrrrrrrrrs_get_arithmetic_result_freqAs   z2DatetimeLikeArrayMixin._get_arithmetic_result_freqc Cs(t|jdstdt|jdt|jtd|}ddlm}ddl m }|t us.Jt |rI|j t d|jd }|j||jd St|}||\}}td|}||\}}t|jtj|d d }|d|jd }||j|jd }|d|jd }||} |j||| d S)Nr cannot add  and rmrrk) tz_to_dtypezM8[]rrxrrrzr)r is_np_dtyperzrrrr pandas.core.arraysrkpandas.core.arrays.datetimesrurrOr to_datetime64rr _simple_newr_ensure_matching_resosrprrrrr{rrq) rrrkrurother_i8r] res_valuesrznew_freqrrrrrs_add_datetimelike_scalarQs*      z/DatetimeLikeArrayMixin._add_datetimelike_scalarcCs6t|jdstdt|jdt|j||S)Nrrrrs)rryrzrrrrrrrrrs_add_datetime_arraylikess z.DatetimeLikeArrayMixin._add_datetime_arraylikedatetime | np.datetime64cCsZ|jjdkrtdt|jtd|}t|r|tSt|}| |\}}| |S)Nr"cannot subtract a datelike from a rk) rzrrrrr rOrrr~_sub_datetimelike)rrtsrrrrrs_sub_datetimelike_scalar}s   z/DatetimeLikeArrayMixin._sub_datetimelike_scalarcCsZ|jjdkrtdt|jt|t|krtdtd|}||\}}| |S)Nrr$cannot add indices of unequal lengthrk) rzrrrrrrr r~rrrrrrrs_sub_datetime_arraylikes   z.DatetimeLikeArrayMixin._sub_datetime_arraylikeTimestamp | DatetimeArrayc Cstd|}ddlm}z||Wnty-}zt|dd}t|||d}~ww||\}}t |j t j | dd}| d|jd }||} td | } |j||j| d S) Nrkrrmcomparesubtractrxr timedelta64[rvz Tick | Nonerx)r rzrm_assert_tzawareness_compatrroreplacerrprrrrr{rrqr}rz) rrrmr  new_messagerr]rres_m8rrrrrrsrs    z(DatetimeLikeArrayMixin._sub_datetimelikerrlcCs\t|jdstdt|jddlm}t |j |j }t |j }|||d}||S)Nrzcannot add Period to a r)rlr)rryrzrrrpandas.core.arrays.periodrlr broadcast_tornrrKr)rrrli8valsrzparrrrrrrs _add_periods   z"DatetimeLikeArrayMixin._add_periodcCrrpr)roffsetrrrrrs _add_offsetsz"DatetimeLikeArrayMixin._add_offsetcCsjt|r tj|jdd|jj}|tt |j ||jdSt d|}t |}| |\}}||S)zk Add a delta of a timedeltalike Returns ------- Same type as self rxrr2)rOremptyrr{rrzfillrrr}r rr~_add_timedeltalike)rr new_valuesrrrrrs_add_timedeltalike_scalars   z0DatetimeLikeArrayMixin._add_timedeltalike_scalarcCs:t|t|kr tdtd|}||\}}||S)zl Add a delta of a TimedeltaIndex Returns ------- Same type as self rr2)rrr r~rrrrrrrs_add_timedelta_arraylikes    z/DatetimeLikeArrayMixin._add_timedelta_arraylikeTimedelta | TimedeltaArraycCs\td|}||\}}t|jtj|dd}||jj}| |}t |j ||j|dS)Nr2rxrrx) r rprrrrr{rrzrqrr})rrrr]rrrrrrrrsrs  z)DatetimeLikeArrayMixin._add_timedeltalikecCsvt|jtrtdt|jdttjtd|}tj |j tj d}| t ||jj}t|j||jddS)z$ Add pd.NaT to self z Cannot add rszTimedeltaArray | DatetimeArrayrNrx)ryrzrKrrrrr rrrrrrr{rr}rrrrrrrs_add_nats   zDatetimeLikeArrayMixin._add_natcCsPtj|jtjd}|t|jjdvr#td|}| d|j dS| dS)z+ Subtract pd.NaT from self rrzDatetimeArray| TimedeltaArrayrrvztimedelta64[ns]) rrrrrrrzrr r{rrrrrrrs_sub_nats     zDatetimeLikeArrayMixin._sub_natPeriod | PeriodArraycstjtstdt|jdtjtd||\}}t j t j | dd}t fdd|D}|durGj}nj|B}t||<|S)Ncannot subtract  from rlrxrcsg|]}jj|qSrr)rbaserrrrrrs 1z:DatetimeLikeArrayMixin._sub_periodlike..)ryrzrKrrrr rrprrrrr^r8r)rrrr] new_i8_datanew_datar^rrrrs_sub_periodlike#s    z&DatetimeLikeArrayMixin._sub_periodlikecCs|tjtjfvs Jt|dkr|jdkr|||dStjdt|jdt t d|j |j ks:J|j |j f|| dt |}|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)rVaddsubrrrrrrr;r?rrrr)rrrqrrrrrrs_addsub_object_array<sz+DatetimeLikeArrayMixin._addsub_object_arrayr.namer/cKsV|dvrtd|dt|tt|}||fd|i|}t|j||jdS)N>cummaxcumminz Accumulation z not supported for r/r)rrr rWrr}rz)rrr/rrqrrrrrrs _accumulate`s  z"DatetimeLikeArrayMixin._accumulate__add__cCst|dd}t|}|tur|}nt|tttjfr"| |}nt|t r-| |}nt|t tj fr;||}n{t|trMt|jdrM||}nit|rmt|jts\t|td|}|||jjtj}nIt|dry||}n=t|r||tj}n1t|dst|tr| |St!|rt|jtst|td|}|||jjtj}nt"St|tj#rt|jdrddl$m%}|&|S|S)Nrzrrlrrr)'r r_rrryrrrr(rrrrr)rrrryrzr is_integerrKr'r _addsub_int_array_or_scalar_nrVrrrDrrIrrBNotImplementedndarrayrzrmrrr other_dtyperobjrmrrrrrsrisF                 zDatetimeLikeArrayMixin.__add__cCs ||Srp)rrrrrrrs__radd__s zDatetimeLikeArrayMixin.__radd____sub__cCst|dd}t|}|tur|}nt|tttjfr#| | }nt|t r/| | }nt|t tj fr=||}nt|r]t|jtsLt|td|}|||jjtj}nat|trh||}nVt|dru|| }nIt|r||tj}n=t|dst|tr| |}n,t|tr||}n!t!|rt|jtst|td|}|||jjtj}nt"St|tj#rt|jdrddl$m%}|&|S|S)Nrzrlrrrr)'r r_rrryrrrr(rrrrr)rrrrzrKr'r rrrVrrrryrrDrrIrrBrrrzrmrrrrrrrsrsJ                 zDatetimeLikeArrayMixin.__sub__cCs t|dd}t|dpt|t}|r9t|jdr9t|r%t||St|ts5ddl m }| |}||S|jj dkrVt |drV|sVtdt|jdt|jt|jtrpt|drptdt|jd|jt|jdrtd|}| |S|| S) Nrzrrrrtrrrm)r rryryrIrzrrrrzrkrrrrrrrKr )rrr other_is_dt64rkrrrrrs__rsub__s*         zDatetimeLikeArrayMixin.__rsub__cCs4||}|dd|dd<t|jts|j|_|SrpryrzrKrrrrrrrrrrs__iadd__  zDatetimeLikeArrayMixin.__iadd__cCs4||}|dd|dd<t|jts|j|_|Srprrrrrrrs__isub__rzDatetimeLikeArrayMixin.__isub__qsnpt.NDArray[np.float64] interpolationcstj||dS)N)rr)r _quantile)rrrrrrrsrsz DatetimeLikeArrayMixin._quantileaxisr/rAxisInt | NonecK8td|t||jtj|j||d}|||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. rrr)nv validate_minvalidate_minmax_axisrrRnanminr_wrap_reduction_resultrrr/rrrrrrrsmin  zDatetimeLikeArrayMixin.mincKr)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. rrr)r validate_maxrrrRnanmaxrrrrrrrrsmax.rzDatetimeLikeArrayMixin.maxr)r/rcCsFt|jtrtdt|jdtj|j||| d}| ||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/r^) ryrzrKrrrrRnanmeanrrOr)rr/rrrrrrrsmean@s , zDatetimeLikeArrayMixin.meancKsHtd||durt||jkrtdtj|j||d}|||S)Nrrz abs(axis) must be less than ndimr) rvalidate_medianabsrrrR nanmedianrrrrrrrrsmedianys  zDatetimeLikeArrayMixin.mediandropnacCsHd}|r|}tj|d|d}||jj}ttj|}| |S)Nrx)r^) rOrPmoder{rrzr rrr~)rrr^i8modesnpmodesrrrrrs_modes  zDatetimeLikeArrayMixin._modehowhas_dropped_na min_countintngroupsidsnpt.NDArray[np.intp]cKs|j}|jdkr)|dvrtd|d|dvr(tjd|d|dttd n2t|trO|dvr:td |d|dvrNtjd|d |dttd n |d vr[td |d|j d}ddl m } | |} | || |d} | j|f|||dd|} | j| jvr| S| jdksJ|dvrddlm} t|jtrtdtd|}d|jd}| |} | j| | jdS| |j j} || S)Nr)sumprodcumsumcumprodvarskewz!datetime64 type does not support z operations)r:allrzh' 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 rwr)WrappedCythonOp)rrr)rrcomp_idsr^)stdsemrz-'std' and 'sem' are not valid for PeriodDtyper2zm8[rvr)rzrrrrrr?ryrKrr{pandas.core.groupby.opsrget_kind_from_how_cython_op_ndim_compatrcast_blocklistrzrmr rr}r~)rrrrrrrrznpvaluesrrrqrrm new_dtyperrrrrs _groupby_opsl           z"DatetimeLikeArrayMixin._groupby_oprvr)NNF)rzrrrrvr)rvr)rrorvr)rrrvr)rrrvrrvr)rvrg)rvr)rrrvr)F)rr)NN)rzrrrrvr)rr2rvr)rrrvr3)rr0rvr)rvr)rrrrrvrrvrT)rrrvr3)rzrrvrk)rzrrvrm).)rzrrvr(rp)r rrr)r rrvro)rr)rvr )rr(rvr&)rvr&)rrrvr)rvr@)rvrDrvro)rvrm)rvrk)rrkrvrk)rrrvrm)rrkrvrm)rrrvrm)rrrvrl)rrm)rr)rrrvr)rr)rror/rrvr3)rrrrorvr3)rrr/r)r/rrr)rr) rrorrrrrrrr)`r __module__ __qualname____doc____annotations__r>rrpropertyrrrrr|rrrrrrr rrrrrr{r rrr rr rrZr%rTrOr8r;rr?rArCrGrIrOrQrTr`rtrarbrcrdrerfrgrhrirjrkrlrprqrrrrrrrrrrrrrrrrcrrrrrrrrrrrrrr __classcell__rrrrrrsrs             9 (=: U     9!      # 7 7 "  9  rc@s$eZdZdZeddd dd Zd S) DatelikeOpszK Common ops for DatetimeIndex/PeriodIndex, but not TimedeltaIndex. zNhttps://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior)URLrrorvrcCsD|j|tjd}trddlm}t||tjddS|jtddS)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) rrr<rr"rrrr)rrrrrrrrrsstrftimes 1 zDatelikeOps.strftimeN)rrorvr)rrrr r=rrrrrrrrsr s r 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) cseZdZUdZded<dejdfded d Zed d Z e ddZ e j dfddZ e dgddZe edhddZediddZedjdd Zedkd"d#Zdldmd'd(Zd)d*Zdnfd.d/ Zd0d1Zeeejd2d3 4 4dodpd9d:Zeeejd;d3 4 4dodpdd3 4 4dodpd?d@Z dd$dAdqdEdFZ!dd$dAdqdGdHZ"dfdIdJZ#drdKdLZ$dsfdNdO Z% $ dtdufdRdS Z&e TdvdwfdXdY Z'dxdyfd\d] Z(dzdadbZ)e d{dcddZ*Z+S)|rYzK Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex. znp.dtype_default_dtypeNFrrrvrc Cstjt|jdttd|durt|}t|dd}t|t r)|j dt d}t |dd}|du}|t jur:|nd}t|t|rx|rFn|durN|j}n|r]|jr]t|}t||j}|durq||jkrqtd|d |j|j}|j}n'|durt|tjr|jjd vr|j}n|j}t|tjr|jd kr||}t|tjstd t|jd t|jd|jdvrtd|jd kr|dur|j}||j}n#t |dr||}nt|tr|jj}|d|jd}||}|||}|dkr tdt|jd|r| }|r*t|}|jjdkr*t|t!s*tdt"j#|||d||_$|durI|durKt|%||dSdSdS)NzV.__init__ is deprecated and will be removed in a future version. Use pd.array instead.rTrrrrdtype=z does not match data dtype MmrxzUnexpected 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[rvinferz#Frequency inference not allowed in z$.__init__. Use 'pd.array()' instead.r(TimedeltaArray/Index freq must be a Tick)rrz)&rrrrrr?rFr`ryr]r#rr r no_defaultrr"_validate_inferred_freqrzrrrrrrr{rrryrIr_validate_dtyperrrrr_validate_frequency) rrrzrrrC explicit_nonerrrrrrrsrs               zTimelikeOps.__init__cCrrpr)rrrzrrrrrsrszTimelikeOps._validate_dtypecCr7)zK Return the frequency object if it is set, otherwise None. rrrrrrrsrszTimelikeOps.freqcCsV|dur&t|}||||jjdkrt|tstd|jdkr&td||_ dS)NrrrzCannot set freq with ndim > 1) r"rrzrryrrrrrrrrrrrsrs    validate_kwdsdictcCs|dur d|_dS|dkr|jdurt|j|_dSdS|tjur#dS|jdur=t|}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. Nr)rr"rCrrrrr)rrrrrrrrs_maybe_pin_freq*s     zTimelikeOps._maybe_pin_freqrrc Ks|j}|jdks ||jkrdSz |jd|ddt|||jd|}t|j|js-t WdSt yO}zdt |vr?|t d|d|j|d}~ww)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)startendperiodsrrz non-fixedInferred frequency 9 from passed values does not conform to passed frequency rr) rCrSrA_generate_rangerrr array_equalrrro)rindexrrr6on_freqr rrrrrsrKs8 zTimelikeOps._validate_frequencyr$ int | Noner3cOrrpr)rr"r#r$rrrrrrrrsr'wrzTimelikeOps._generate_rangercCs t|jjSrp)rrrzrrrrrrsrs zTimelikeOps._cresorocCs t|jSrp) dtype_to_unitrzrrrrrrsrr9zTimelikeOps.unitTrrcCs~|dvrtdt|jjd|d}t|j||d}t|jtjr(|j}n td|j}t ||d}t |j |||j dS) N)smsusnsz)Supported units are 's', 'ms', 'us', 'ns'rrvrrkrwrx) rrrzrrrryr rrIrr}r)rrrrzrrrrrrrrsrs  zTimelikeOps.as_unitcCs@|j|jkr|j|jkr||j}||fS||j}||fSrp)rrrrrrrrrsr~s    z"TimelikeOps._ensure_matching_resosufuncnp.ufuncmethodcs`|tjtjtjfvr"t|dkr"|d|ur"t|||jfi|Stj||g|Ri|S)Nrr) risnanisinfisfiniterr rr__array_ufunc__)rr1r3inputsrrrrrsr7s   zTimelikeOps.__array_ufunc__c Cst|jtr!td|}|d}|||||}|j|j||dS|d}ttj |}t ||j }|dkr:| St |||} |j| td}||jj}|j||jdS)Nrk) ambiguous nonexistentrxrr>r)ryrzrIr tz_localize_roundrr{rrr&rrr$r?rrr}) rrrr9r:naiverrnanos result_i8rrrrrsr=s       zTimelikeOps._roundround)rqraiser9r5r:r6cC||tj||Srp)r=r#NEAREST_HALF_EVENrrr9r:rrrrrsrAzTimelikeOps.roundfloorcCrCrp)r=r# MINUS_INFTYrErrrrrsrGrFzTimelikeOps.floorceilcCrCrp)r=r# PLUS_INFTYrErrrrrsrIrFzTimelikeOps.ceilrrrr/cCtj|j|||dSNr)rRnananyrrOrrr/rrrrrsr:szTimelikeOps.anycCrKrL)rRnanallrrOrNrrrrrsrszTimelikeOps.allcCs d|_dSrprrrrrrrsrs zTimelikeOps._maybe_clear_freqcCsh|durn&t|dkr t|tr |jjdkrt|tstdn |dks&Jt|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 Nrrrr) rryrrzrrrr"rCr{r)rrrrrrrrs _with_freqs   zTimelikeOps._with_freqrcst|jtjr |jStSrp)ryrzrrr_values_for_jsonrrrrrsrQ s zTimelikeOps._values_for_jsonuse_na_sentinelsortcs|jdur-tjt|tjd}|}|r)|jjdkr)|ddd}|ddd}||fS|r:tdt|j dt j |dS)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.)rR) rrarangerintprrNotImplementedErrorrrr factorize)rrRrScodesuniquesrrrrsrX s zTimelikeOps.factorizer to_concatSequence[Self]r)cst||}|d|dkrDdd|D}jdurDtfdd|DrDt|dd|dd}tfdd|DrDj}||_|S) NrcSsg|]}t|r|qSrr)rrrrrrrsrC rz1TimelikeOps._concat_same_type..c3s|] }|jjkVqdSrprrrrrrsrE sz0TimelikeOps._concat_same_type..rTrc3s.|]}|ddj|ddkVqdS)rrTrNr])rpairr^rrrsrG s,)r_concat_same_typerrzipr)rr[rnew_objpairsrrr^rsr`6 s zTimelikeOps._concat_same_typeCordercstj|d}|j|_|S)N)re)rrrr)rrerbrrrrsrL szTimelikeOps.copyr.r)rjc Ks^|dkrt|s |j} n|j} tj| f||||||d||s%|St|j| |jdS)z2 See NDFrame.interpolate.__doc__. linear)r3rr)limitlimit_direction limit_arear)rWrrrQinterpolate_2d_inplacerr}rz) rr3rr)rgrhrirrout_datarrrrrs interpolateQ s(  zTimelikeOps.interpolatecCsPt|jsdS|j}|tk}t|j}t|}t|||dk 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) rryrzrrrr!r logical_andr)r values_intconsider_valuesrppd even_daysrrrrrs_is_dates_onlyz s  zTimelikeOps._is_dates_only)rrrvrr)rr )rr)r$r+rvr3)rvrrr)rrorrrvr3)r1r2r3ro)rBrB)r9r5r:r6rvr3)rrr/rrvrrr)TF)rRrrSr)r)r[r\rr)rvr3)rd)rerorvr3) r3r.rrr)rjrrrvr3r),rrrr r rrr classmethodrr rsetterr r!rr'r>rrrr~r7r=r< _round_doc_round_examplerrA_floor_examplerG _ceil_examplerIr:rrrPrQrXr`rrlrrr rrrrrrsrYsj  \     *           )rYrrcls_nametuple[ArrayLike, bool]cCst|dst|ttfst|dkrt|}t|}d}nt|tr+td|dt |dd}t|t sAt|t rN|j j dvrN|jd td }d}||fSt|t ra|}|}d}||fSt|tjtfsrt|}||fSt|tr|jj|jtd j}d}||fS) NrzrFzCannot create a z from a MultiIndex.Trrrrr;)rryrtuplerrr@rMrr`r]r[rzrr#r_maybe_convert_datelike_arrayrr\rrLrtakerYr_values)rrryrrrrrs!ensure_arraylike_for_datetimelike s6         rr$rcCrrprrr$rrrrrsvalidate_periods rr int | floatrcCrrprrrrrrrrsr rint | float | Noner+cCsL|dur$t|rtjdttdt|}|St|s$td||S)a9 If a `periods` argument is passed to the Datetime/Timedelta Array/Index constructor, cast it to an integer. Parameters ---------- periods : None, float, int Returns ------- periods : None or int Raises ------ TypeError if periods is None, float, or int NzNon-integer 'periods' in pd.date_range, pd.timedelta_range, pd.period_range, and pd.interval_range are deprecated and will raise in a future version.rzperiods must be a number, got ) ris_floatrrrr?rrrrrrrrrsr s  rrrCcCs>|dur|dur||krtd|d|j|dur|}|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&)rrA)rrCrrrrrsr srrz'DatetimeTZDtype | np.dtype | ArrowDtypecCsJt|tr|jSt|tr|jdvrtd|d|jjSt|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 rrz does not have a resolution.r) ryrIrrGrr pyarrow_dtyper datetime_datarrrrrrsr, s   r,)rnro)rur-rvr-)rrryrorvrz)r$rrvr)r$rrvr)r$rrvr+)rrrCrrvr)rzrrvro) __future__rrr functoolsrrVtypingrrrr r r r r rnumpyrpandas._configr pandas._libsrrpandas._libs.arraysrpandas._libs.tslibsrrrrrrrrrrrrrrr r!r"pandas._libs.tslibs.fieldsr#r$pandas._libs.tslibs.np_datetimer%pandas._libs.tslibs.timedeltasr&pandas._libs.tslibs.timestampsr'pandas._typingr(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7pandas.compat.numpyr8r pandas.errorsr9r:r;pandas.util._decoratorsr<r=r>pandas.util._exceptionsr?pandas.core.dtypes.castr@pandas.core.dtypes.commonrArBrCrDrErFpandas.core.dtypes.dtypesrGrHrIrJrKpandas.core.dtypes.genericrLrMpandas.core.dtypes.missingrNrO pandas.corerPrQrRrSpandas.core.algorithmsrTrUrVpandas.core.array_algosrWpandas.core.arraylikerXpandas.core.arrays._mixinsrYrZpandas.core.arrays.arrow.arrayr[pandas.core.arrays.baser\pandas.core.arrays.integerr]pandas.core.commoncorecommonrpandas.core.constructionr^rr_r`pandas.core.indexersrarbpandas.core.ops.commonrcpandas.core.ops.invalidrdrepandas.tseriesrfcollections.abcrgrhr"rjrzrkrlrmrrtrrr rurvrwrxrYrrrr,rrrrrrrss  (   L   H                &>? h'    "