o $ja@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)rnoprr`/var/www/html/Deteccion_Ine/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)selfargskwargsarrresultZres_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)rZ 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)ryrzrKrrraslicestepEllipsiscomZis_bool_indexerrZmaybe_booleans_to_slicer{rZuint8r)rrZ is_periodrZnew_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)rrrZno_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_valueZconstruct_array_type_from_sequencerastyperint64 TypeErrorrtype__name__asarray) rrzrZi8dataZ convertedZ 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_listlikeunboxrrc 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)rrrrrrrrrrrs_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 )hasattrrrzrrr)rrrZmsg_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_okrrrzTZ extract_numpy)ryrrzras_unitunitrrrrrr infer_dtyperrrrr`pd_arrayrArH categoriesZ_internal_get_valuesrDr)rrrrrrrrrsrsJ       z)DatetimeLikeArrayMixin._validate_listlikecCs,t|r ||}n|j|ddS||S)NT)r)rCrr_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^)rZmapperrrjrrrrrrsmaps  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] Zfiucr)r timedelta64r datetime64dateZperiodT)Zconvert_non_numericZdtype_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_ryrrrZmaybe_convert_objectsrTr rrrrrrr?r r r rrr)rrZ inferableinferredrrrrrsrTsN        zDatetimeLikeArrayMixin.isincC|jSrp)_isnanrrrrrrsrOXszDatetimeLikeArrayMixin.isnacCs |jtkS)z- return if each value is nan )rrrrrrrrsr"[ zDatetimeLikeArrayMixin._isnancCst|jS)zJ return if I have any nans; enables various perf speedups )rr"anyrrrrrrs_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%rrnanputmaskr")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)rfreqstrrrrrrrsr+s 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)rrfZ infer_freqrrrrrrrs inferred_freqs   z$DatetimeLikeArrayMixin.inferred_freqResolution | NonecCs4|j}|dur dSzt|WStyYdSwrp)r+rZget_reso_from_freqstrKeyError)rr+rrrrrs_resolution_objs  z&DatetimeLikeArrayMixin._resolution_objcCs|jjS)zO Returns day, hour, minute, second, millisecond or microsecond )r/attrnamerrrrrrs resolutionsz!DatetimeLikeArrayMixin.resolutioncCtj|jdddS)NTZtimelikerrZ is_monotonicrrrrrrrs_is_monotonic_increasingz/DatetimeLikeArrayMixin._is_monotonic_increasingcCr2)NTr3rr4rrrrrrs_is_monotonic_decreasingr6z/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))rrrrrrr:rdrDrSZcomp_method_OBJECT_ARRAYrrrrroperatorneZonesrrryrzrKr TimelikeOpsrrr r rr^Zasm8r%rrr{rOr"r$r') rrrqrzrZ other_arrZ other_valso_maskmaskZ 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}r"r)rrZi8valuesr?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[]rrxrr rzr)r is_np_dtyperzrrrr pandas.core.arraysrkZpandas.core.arrays.datetimesrTrrOrZ to_datetime64rr  _simple_newr_ensure_matching_resosrOrrrrr{rrP) rrrkrTrother_i8r> res_valuesrznew_freqrrrrrs_add_datetimelike_scalarQs*      z/DatetimeLikeArrayMixin._add_datetimelike_scalarcCs6t|jdstdt|jdt|j||S)NrrQrR)rrXrzrrrrrrrrrs_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)Nrrb$cannot add indices of unequal lengthrk) rzrrrrrrr r[rcrrrrrrs_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[rUz Tick | NonerW)r rYrmZ_assert_tzawareness_compatrroreplacerrOrrrrr{r rPrZrz) rrrmrZ new_messager\r>r]Zres_m8r^rrrrrsrcs    z(DatetimeLikeArrayMixin._sub_datetimelikerrlcCs\t|jdstdt|jddlm}t |j |j }t |j }|||d}||S)Nrzcannot add Period to a r)rlr)rrXrzrrrZpandas.core.arrays.periodrlrZ broadcast_torNrrKr)rrrlZi8valsrzZparrrrrrrs _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 rxrr)rOremptyrr{rrzfillrrrZr 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 rfr)rrr r[rsrrrrrrs_add_timedelta_arraylikes    z/DatetimeLikeArrayMixin._add_timedelta_arraylikeTimedelta | TimedeltaArraycCs\td|}||\}}t|jtj|dd}||jj}| |}t |j ||j|dS)NrrxrrW) r rOrrrrr{rrzrPrrZ)rrr\r>rtr]r^rrrrrsrss  z)DatetimeLikeArrayMixin._add_timedeltalikecCsvt|jtrtdt|jdttjtd|}tj |j tj d}| t ||jj}t|j||jddS)z$ Add pd.NaT to self z Cannot add rRzTimedeltaArray | DatetimeArrayrNrW)ryrzrKrrrrr rrqrrrrrr{rrZrrrrrrrs_add_nats   zDatetimeLikeArrayMixin._add_natcCsPtj|jtjd}|t|jjdvr#td|}| d|j dS| dS)z+ Subtract pd.NaT from self rrzDatetimeArray| TimedeltaArrayrlrUztimedelta64[ns]) rrqrrrrrrzrr r{r rxrrrrrs_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 rrOrrrrr^r"r)rrr\r>Z new_i8_dataZnew_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)r;addsubrrrrrrr;r?rrrr)rrrqr]rrrrrs_addsub_object_array<sz+DatetimeLikeArrayMixin._addsub_object_arrayrnamercKsV|dvrtd|dt|tt|}||fd|i|}t|j||jdS)N>ZcummaxZcumminz Accumulation z not supported for rr)rrrrWrrZrz)rrrrrqrrrrrrs _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)Nrzrrlrrri)'rr_rryryrrrrrurrprrr_rrrXrzrn is_integerrKr'r _addsub_int_array_or_scalar_nr;rrvrDrrIr`rBNotImplementedndarrayrYrmrrr 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)Nrzrlrrrri)'rr_rrzryrrrrrurrprrrerrrzrKr'r rrr;rrrrXrvrDrrIrgrBrrrYrmrrrrrrrsrsJ                 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) NrzrrrrSr|r}rm)rrrXryrIrzrrrrYrkrrrrrrrKr )rrrZ 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._quantileaxisrrAxisInt | 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)nvZ validate_minvalidate_minmax_axisrrRZnanminr_wrap_reduction_resultrrrrrrrrrrsmin  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)rZ validate_maxrrrRZnanmaxrrrrrrrrsmax.rzDatetimeLikeArrayMixin.maxr)rrcCsFt|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()rrr?) ryrzrKrrrrRZnanmeanrrOr)rrrrrrrrrsmean@s , zDatetimeLikeArrayMixin.meancKsHtd||durt||jkrtdtj|j||d}|||S)Nrrz abs(axis) must be less than ndimr) rZvalidate_medianabsrrrRZ nanmedianrrrrrrrrsmedianys  zDatetimeLikeArrayMixin.mediandropnacCsHd}|r|}tj|d|d}||jj}ttj|}| |S)Nrx)r?) rOrPmoder{rrzr rrr~)rrr?Zi8modesZnpmodesrrrrrs_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)sumprodZcumsumcumprodvarskewz!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)rrZcomp_idsr?)ZstdZsemriz-'std' and 'sem' are not valid for PeriodDtyperzm8[rUr)rzrrrrrr?ryrKrr{Zpandas.core.groupby.opsrZget_kind_from_howZ_cython_op_ndim_compatrZcast_blocklistrYrmr r rZr~)rrrrrrrrzZnpvaluesrrrqr]rm 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)rrrr)rrrvro)rr)rvr)rr(rvr)rvr)rrrvr)rvr*)rvr-rvro)rvrM)rvrk)rrkrvrk)rrarvrm)rrkrvrm)rrhrvrm)rrrvrl)rrm)rrw)rr{rvr)rr)rrorrrvr3)rrrrorvr3)rrrr)rrrr)rr) rrorrrrrrrr)`r __module__ __qualname____doc____annotations__r>rrpropertyrrrrr|rrrrrrr rrrrrr{rrrrrr rrZrrTrOr"r%rr)r+r,r/r1r5r7r:r@rtrArBrCrDrErFrGrHrIrJrKrLrOrPr_r`rergrcrnrprurvrsryrzrrrrcrrrrrrrrrrrrrr __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&rrrr rr)rrrrrrrrrsstrftimes 1 zDatelikeOps.strftimeN)rrorvr)rrrrr=rrrrrrrrsrs raO 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)|r=zK 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.rTr rrrdtype=z does not match data dtype ZMmrxzUnexpected 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[rUinferz#Frequency inference not allowed in z$.__init__. Use 'pd.array()' instead.r(TimedeltaArray/Index freq must be a Tick)rrz)&rrrrrr?rFr`ryr]rrrr no_defaultrr"_validate_inferred_freqrzrrrrrrr{rrrXrIr _validate_dtyperrrrr_validate_frequency) rrrzrrr,Z explicit_nonerrrrrrrsrs               zTimelikeOps.__init__cCrrpr)rrrzrrrrrsrszTimelikeOps._validate_dtypecCr!)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"r,rrrrr)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)startendperiodsrr z non-fixedInferred frequency 9 from passed values does not conform to passed frequency rr) r,r9r+_generate_rangerr rZ array_equalrrro)rindexrrr Zon_freqrrrrrrsrKs8 zTimelikeOps._validate_frequencyr int | Noner3cOrrpr)rrrrrrrrrrrrsrwrzTimelikeOps._generate_rangercCs t|jjSrp)rrrzrrrrrrsrs zTimelikeOps._cresorocCs t|jSrp) dtype_to_unitrzrrrrrrsr r#zTimelikeOps.unitTr rcCs~|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'rrUrrkrVrW) rrrzrrrryr rrIrrZr)rr rrzrtrrrrrrrsr s  zTimelikeOps.as_unitcCs@|j|jkr|j|jkr||j}||fS||j}||fSrp)rr r rrrrrrsr[s    z"TimelikeOps._ensure_matching_resosufuncnp.ufuncmethodcs`|tjtjtjfvr"t|dkr"|d|ur"t|||jfi|Stj||g|Ri|S)Nrr) risnanisinfisfiniterrrr__array_ufunc__)rrrZinputsrrrrrsrs   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 Z tz_localize_roundrr{rrr&rrr$r)rrrZ) rrrrrZnaiverrZnanosZ result_i8rrrrrsrs       zTimelikeOps._roundround)rqraiserr5rr6cC||tj||Srp)rr#ZNEAREST_HALF_EVENrrrrrrrrrsrzTimelikeOps.roundfloorcCrrp)rr#Z MINUS_INFTYrrrrrrsrrzTimelikeOps.floorceilcCrrp)rr#Z PLUS_INFTYrrrrrrsrrzTimelikeOps.ceilrrrrcCtj|j|||dSNr)rRZnananyrrOrrrrrrrrsr$szTimelikeOps.anycCrr)rRZnanallrrOrrrrrrsrszTimelikeOps.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"r,r{r)rrrrrrrrs _with_freqs   zTimelikeOps._with_freqrcst|jtjr |jStSrp)ryrzrrr_values_for_jsonrrrrrsr 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.)r) rrZarangerZintprrNotImplementedErrorrrr factorize)rrrcodesZuniquesrrrrsr 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..rrc3s.|]}|ddj|ddkVqdS)rrrNr )rpairr rrrsrG s,)r_concat_same_typerrzipr)rr rnew_objpairsr^rr rsr6 s zTimelikeOps._concat_same_typeCordercstj|d}|j|_|S)N)r)rrrr)rrrrrrrsrL szTimelikeOps.copyr.rrjc Ks^|dkrt|s |j} n|j} tj| f||||||d||s%|St|j| |jdS)z2 See NDFrame.interpolate.__doc__. Zlinear)rrrlimitlimit_direction limit_arear)rrrrQZinterpolate_2d_inplacerrZrz) rrrrrrrrrZout_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) rrXrzrrrr!r logical_andr)rZ values_intZconsider_valuesrZppdZ even_daysrrrrrs_is_dates_onlyz s  zTimelikeOps._is_dates_only)rrrvrr)rr)rr)rrrvr3)rvrrr)r rorrrvr3)rrrro)rr)rr5rr6rvr3)rrrrrvrrr)TF)rrrr)r)r r rr)rvr3)r)rrorvr3) rr.rrrrjrrrvr3r),rrrrrrrr classmethodrrrsetterr rrrr>rr r r[rrr< _round_doc_round_examplerr_floor_exampler _ceil_examplerr$rrrrrrrrrrrrrrrrsr=sj  \     *           )r=rrcls_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.Tr rrrr)rryrtuplerrr@rMrr`r]r[rzrrrZ_maybe_convert_datelike_arrayrr\rrLrZtakerr_values)rrr rrrrrs!ensure_arraylike_for_datetimelike s6         r$rrcCrrprrrrrrrrsvalidate_periods rr& int | floatrcCrrprrr%rrrrrsr& rint | float | NonercCsL|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 ) rZis_floatrrrr?rrrr%rrrrrsr& s  rrr,cCs>|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 Nrr)rr+)rr,rrrrrsr 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) ryrIr rGrrZ pyarrow_dtyperZ datetime_datarrrrrrsr s   r)rnro)rur-rvr-)rrr rorvr!)rrrvr)rr'rvr)rr(rvr)rrr,rrvr)rzr)rvro) __future__rrr functoolsrr;typingrrrr r r r r rnumpyrZpandas._configrZ pandas._libsrrZpandas._libs.arraysrZpandas._libs.tslibsrrrrrrrrrrrrrrr r!r"Zpandas._libs.tslibs.fieldsr#r$Zpandas._libs.tslibs.np_datetimer%Zpandas._libs.tslibs.timedeltasr&Zpandas._libs.tslibs.timestampsr'Zpandas._typingr(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7Zpandas.compat.numpyr8rZ pandas.errorsr9r:r;Zpandas.util._decoratorsr<r=r>Zpandas.util._exceptionsr?Zpandas.core.dtypes.castr@Zpandas.core.dtypes.commonrArBrCrDrErFZpandas.core.dtypes.dtypesrGrHrIrJrKZpandas.core.dtypes.genericrLrMZpandas.core.dtypes.missingrNrOZ pandas.corerPrQrRrSZpandas.core.algorithmsrTrUrVZpandas.core.array_algosrWZpandas.core.arraylikerXZpandas.core.arrays._mixinsrYrZZpandas.core.arrays.arrow.arrayr[Zpandas.core.arrays.baser\Zpandas.core.arrays.integerr]Zpandas.core.commoncorecommonrZpandas.core.constructionr^r r_r`Zpandas.core.indexersrarbZpandas.core.ops.commonrcZpandas.core.ops.invalidrdreZpandas.tseriesrfcollections.abcrgrhrrjrYrkrlrmrrtrrrrrrrr=r$r&rrrrrrrrrss  (   L   H                &>? h'    "