o h\@sddlmZddlmZmZddlmZddlZddlmZm Z m Z m Z m Z m Z mZmZddlZddlZddlmZmZddlmZddlmZmZmZmZmZmZmZm 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-m.Z.dd l/m0Z0dd l1m2Z2dd l3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCddlDmEZFddlGmHZHmIZImJZJddlKmLZLmMZMmNZNddlOmPZPddlQmRZRddlSmTZTmUZUmVZVmWZWmXZXmYZYddlZm[Z[m\Z\m]Z]m^Z^m_Z_ddl`maZambZbddlcmdZdmeZeddlfmgZgmhZhmiZimjZjddlkmlZlmmZmmnZnddlompZpddlqmrZrddlsmtZtmuZuddlvmwZwddlxmyZyddlzm{Z{ddl|m}m~ZddlmZmZmZdd lmZmZdd!lmZdd"lmZmZdd#lmZerdd$lmZmZdd%lmZdd&lmZmZmZe e6efZdSd)d*ZdTd.d/ZGd0d1d1eretZGd2d3d3eZd4Zd5Zd6Zd7ZGd8d9d9eZdUd>d?ZedVdBdCZedWdFdCZdXdIdCZdYdMdNZdZdQdRZdS)[) annotations)datetime timedelta)wrapsN) TYPE_CHECKINGAnyCallableLiteralUnioncastfinaloverload)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)rdrb)rmoprqQ/var/www/html/env/lib/python3.10/site-packages/pandas/core/arrays/datetimelike.py_make_unpacked_invalid_ops rsmethr,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) isinstancedtyperJviewrr _box_func_value_from_backing_data)selfargskwargsarrresultres_i8rtrqrrnew_meths      z"_period_dispatch..new_meth)rr r,)rtrrqrrr_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 | NonefreqruboolcCsdS)NTrqr~rqrqrr _can_hold_naz#DatetimeLikeArrayMixin._can_hold_naNFry Dtype | NonecopyNonecCt|ror8)r~dataryrrrqrqrr__init__szDatetimeLikeArrayMixin.__init__type[DatetimeLikeScalar]cCr)z The scalar associated with this datelike * PeriodArray : Period * DatetimeArray : Timestamp * TimedeltaArray : Timedelta rrrqrqrr _scalar_types z#DatetimeLikeArrayMixin._scalar_typevaluern 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. rr~rrqrqrr_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') rrrqrqrr _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 rr~rrqrqrr_check_compatible_withrz-DatetimeLikeArrayMixin._check_compatible_withcCr)zI box function to get object from internal representation r)r~xrqrqrrr{-z DatetimeLikeArrayMixin._box_funccCstj||jddS)z1 apply box func to passed values F)convert)r map_inferr{)r~valuesrqrqrr _box_values3sz"DatetimeLikeArrayMixin._box_valuesrfcs8jdkrfddttDSfddjDS)Nc3s|]}|VqdSrorq).0nrrqrr ;sz2DatetimeLikeArrayMixin.__iter__..c3s|]}|VqdSro)r{)rvrrqrrr=s)ndimrangelenasi8rrqrrr__iter__9s zDatetimeLikeArrayMixin.__iter__npt.NDArray[np.int64]cCs |jdS)z Integer representation of the values. Returns ------- ndarray An ndarray with int64 dtype. rw)rrzrrqrqrrr?s 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)r~rrrqrqrr_format_native_typesOs z+DatetimeLikeArrayMixin._format_native_typesboxedcCsdjS)Nz'{}')format)r~rrqrqrr _formatter[sz!DatetimeLikeArrayMixin._formatterNpDtype | None bool | NonecCs t|r tjt|tdS|jS)Nry)rCnpr]listobjectr)r~ryrrqrqrr __array__bsz DatetimeLikeArrayMixin.__array__itemr1cCdSrorqr~rrqrqrr __getitem__jrz"DatetimeLikeArrayMixin.__getitem__(SequenceIndexer | PositionalIndexerTupler2cCrrorqrrqrqrrrnskeyr/Self | 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_scalarr2_get_getitem_freq_freq)r~rr __class__rqrrrus    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)rxryrJrrr`slicestepEllipsiscomis_bool_indexerrmaybe_booleans_to_slicerzruint8r)r~r is_periodrnew_keyrqrqrrrs.          z(DatetimeLikeArrayMixin._get_getitem_freq,int | Sequence[int] | Sequence[bool] | sliceNaTType | Any | Sequence[Any]cs.t|||}t|||rdS|dSro)rar __setitem___maybe_clear_freq)r~rrno_oprrqrrrs  z"DatetimeLikeArrayMixin.__setitem__cCrrorqrrqrqrrrsz(DatetimeLikeArrayMixin._maybe_clear_freqTcs,t|}|tkr;|jjdkr"td|}|j}t||jd|jd}|S|jjdkr/t |j ddS| |j  |jSt|trHtj||dSt|rP|S|jd vrq|j}|tjkritd |jd |d |ro|}|S|jd vr{|j|ks|jdkrdt|jd|}t|tj||dS)NMrj timestamp)tzboxresomT)rriuzConverting from z to z? is not supported. Do obj.astype('int64').astype(dtype) insteadmMfz Cannot cast z to dtype r)rErrykindr rrr_cresorrrravelreshapeshaperxrIrastyperDrrint64 TypeErrorrtype__name__asarray)r~ryri8data convertedrmsgrrqrrrs@      zDatetimeLikeArrayMixin.astypecCrrorqrrqrqrrrzrzDatetimeLikeArrayMixin.viewLiteral['M8[ns]']rjcCrrorqr~ryrqrqrrrzrLiteral['m8[ns]']rlcCrrorqrrqrqrrrzr.r'cCrrorqrrqrqrrrzrcs t|Sro)rrzrrrqrrrzs 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_objectry)rxrnr ValueErrorrr9rrrrrrBr_validate_listlikerCgetattr)r~rerrrqrqrr_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) rxrrnrr_validation_error_messagerrMryrrNrr)r~rrrrrrqrqrr_validate_scalar0s,          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 ryrrz array'zvalue should be a 'z!', 'NaT', or array of those. Got z instead.z' or 'NaT'. Got )hasattrrryrrr)r~rrmsg_gotrrqrqrrrms  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_okrrryT extract_numpy)rxrryras_unitunitrr_from_sequencerrr infer_dtyperrrrr_pd_arrayr@rG categories_internal_get_valuesrCr)r~rrrrqrqrrrsJ       z)DatetimeLikeArrayMixin._validate_listlikecCs,t|r ||}n|j|ddS||S)NT)r)rBrr_unboxrrqrqrr_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. )rrrrrrrqrqrrrs   zDatetimeLikeArrayMixin._unboxcCs:ddlm}t|||d}||}t|tr|S|jS)Nrrh) na_action)pandasrirTrxrLto_numpyr])r~mapperrrirrqrqrrmaps  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. stacklevelrDatetimeArray | TimedeltaArray)ryrrzerosrrr^rxrrrmaybe_convert_objectsrSrrrrwarningswarn FutureWarningr>r r rrrr)r~r inferableinferredrqrqrrrSsN        zDatetimeLikeArrayMixin.isincC|jSro)_isnanrrqrqrrrNAszDatetimeLikeArrayMixin.isnacCs |jtkS)z- return if each value is nan )rrrrqrqrrr3D zDatetimeLikeArrayMixin._isnancCst|jS)zJ return if I have any nans; enables various perf speedups )rr3anyrrqrqrr_hasnaKszDatetimeLikeArrayMixin._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)r6rrnanputmaskr3)r~r fill_valuerrqrqrr_maybe_mask_resultsRs 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)rfreqstrrrqrqrrr<ps 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)rre infer_freqrrrqrqrr inferred_freqs   z$DatetimeLikeArrayMixin.inferred_freqResolution | NonecCs4|j}|dur dSzt|WStyYdSwro)r<rget_reso_from_freqstrKeyError)r~r<rqrqrr_resolution_objs  z&DatetimeLikeArrayMixin._resolution_objcCs|jjS)zO Returns day, hour, minute, second, millisecond or microsecond )rBattrnamerrqrqrr resolutionsz!DatetimeLikeArrayMixin.resolutioncCtj|jdddS)NTtimelikerr is_monotonicrrrqrqrr_is_monotonic_increasingz/DatetimeLikeArrayMixin._is_monotonic_increasingcCrE)NTrFrrHrrqrqrr_is_monotonic_decreasingrKz/DatetimeLikeArrayMixin._is_monotonic_decreasingcCstt|jd|jkS)NK)rrUrrsizerrqrqrr _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)NrrryrFr rw))rrrrrrr9rcrCrRcomp_method_OBJECT_ARRAYrrrrroperatorneonesrr+rxryrJr TimelikeOpsrrr rrr]asm8r$rrrzrNr3r5r8) r~rrpryr other_arr other_valso_maskmask nat_resultrqrqrr _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)rxrordinalrrr|r3r)r~ri8valuesrYrqrqrr_get_i8_values_and_masks 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)rxryrJrrrrrrqrqrr_get_arithmetic_result_freq*s   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 rlrrj) tz_to_dtypezM8[]rrwrrryr)r is_np_dtyperyrrrr pandas.core.arraysrjpandas.core.arrays.datetimesrprrNr to_datetime64rr _simple_newr_ensure_matching_resosrkrrrrrzrrl) r~rrjrprother_i8rX res_valuesrynew_freqrqrqrr_add_datetimelike_scalar:s*      z/DatetimeLikeArrayMixin._add_datetimelike_scalarcCs6t|jdstdt|jdt|j||S)Nrrmrn)rrtryrrrrrqrqrr_add_datetime_arraylike\s z.DatetimeLikeArrayMixin._add_datetime_arraylikedatetime | np.datetime64cCsZ|jjdkrtdt|jtd|}t|r|tSt|}| |\}}| |S)Nr"cannot subtract a datelike from a rj) ryrrrrr rNrrry_sub_datetimelike)r~rtsrqrqrr_sub_datetimelike_scalarfs   z/DatetimeLikeArrayMixin._sub_datetimelike_scalarcCsZ|jjdkrtdt|jt|t|krtdtd|}||\}}| |S)Nrr$cannot add indices of unequal lengthrj) ryrrrrrrr ryrrrqrqrr_sub_datetime_arraylikeys   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) Nrjrrlcomparesubtractrwr timedelta64[rqz Tick | Noners)r rurl_assert_tzawareness_compatrrnreplacerrkrrrrrzrrlrxry) r~rrlr new_messagerzrXr{res_m8r|rqrqrrrs    z(DatetimeLikeArrayMixin._sub_datetimelikerrkcCs\t|jdstdt|jddlm}t |j |j }t |j }|||d}||S)Nrzcannot add Period to a r)rkr)rrtryrrrpandas.core.arrays.periodrkr broadcast_torirrJr)r~rrki8valsryparrrqrqrr _add_periods   z"DatetimeLikeArrayMixin._add_periodcCrror)r~offsetrqrqrr _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 rwrr*)rNremptyrrzrryfillrrrxr rry_add_timedeltalike)r~r new_valuesrqrqrr_add_timedeltalike_scalars   z0DatetimeLikeArrayMixin._add_timedeltalike_scalarcCs:t|t|kr tdtd|}||\}}||S)zl Add a delta of a TimedeltaIndex Returns ------- Same type as self rr*)rrr ryrrrqrqrr_add_timedelta_arraylikes    z/DatetimeLikeArrayMixin._add_timedelta_arraylikeTimedelta | TimedeltaArraycCs\td|}||\}}t|jtj|dd}||jj}| |}t |j ||j|dS)Nr*rwrrs) r rkrrrrrzrryrlrrx)r~rrzrXrr{r|rqrqrrrs  z)DatetimeLikeArrayMixin._add_timedeltalikecCsvt|jtrtdt|jdttjtd|}tj |j tj d}| t ||jj}t|j||jddS)z$ Add pd.NaT to self z Cannot add rnzTimedeltaArray | DatetimeArrayrNrs)rxryrJrrrrr rrrrrrrzrrxr~rrqrqrr_add_nats   zDatetimeLikeArrayMixin._add_natcCsPtj|jtjd}|t|jjdvr#td|}| d|j dS| dS)z+ Subtract pd.NaT from self rrzDatetimeArray| TimedeltaArrayrrqztimedelta64[ns]) rrrrrrryrr rzrrrqrqrr_sub_nats     zDatetimeLikeArrayMixin._sub_natPeriod | PeriodArraycstjtstdt|jdtjtd||\}}t j t j | dd}t fdd|D}|durGj}nj|B}t||<|S)Ncannot subtract  from rkrwrcsg|]}jj|qSrq)rbaserrrrqrr z:DatetimeLikeArrayMixin._sub_periodlike..)rxryrJrrrr rrkrrrrr]r3r)r~rrzrX new_i8_datanew_datarYrqrrr_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.r(O)rQaddsubrrr-r.rrr:r>rrrr)r~rrpr{rqrqrr_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)rrrrVrrxry)r~rr%rrprrqrqrr _accumulateIs  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)Nryrrkrrr)'rr^rrrxrrrrrrrrrr}rrrtryr is_integerrJr&r _addsub_int_array_or_scalar_nrQrrrCrrHr~rANotImplementedndarrayrurlrr~r other_dtyperobjrlrqrqrrrRsF                 zDatetimeLikeArrayMixin.__add__cCs ||Sro)rrrqrqrr__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)Nryrkrrrr)'rr^rrrxrrrrrrrrrrrrryrJr&r rrrQrrrrtrrCrrHrrArrrurlrrrqrqrrrsJ                 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) Nryrrrrorrrl)rrrtrxrHryrrrrurjrrrrrrrJr )r~rr other_is_dt64rjrqrqrr__rsub__s*         zDatetimeLikeArrayMixin.__rsub__cCs4||}|dd|dd<t|jts|j|_|SrorxryrJrrr~rrrqrqrr__iadd__  zDatetimeLikeArrayMixin.__iadd__cCs4||}|dd|dd<t|jts|j|_|Srorrrqrqrr__isub__rzDatetimeLikeArrayMixin.__isub__qsnpt.NDArray[np.float64] interpolationcstj||dS)N)rr)r _quantile)r~rrrrqrrrsz 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. rqr)nv validate_minvalidate_minmax_axisrrQnanminr_wrap_reduction_resultr~rr%rrrqrqrrmin  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. rqr)r validate_maxrrrQnanmaxrrrrqrqrrmaxrzDatetimeLikeArrayMixin.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%rY) rxryrJrrrrQnanmeanrrNr)r~r%rrrqrqrrmean)s , zDatetimeLikeArrayMixin.meancKsHtd||durt||jkrtdtj|j||d}|||S)Nrqz abs(axis) must be less than ndimr) rvalidate_medianabsrrrQ nanmedianrrrrqrqrrmedianbs  zDatetimeLikeArrayMixin.mediandropnacCsHd}|r|}tj|d|d}||jj}ttj|}| |S)Nrw)rY) rNrOmoderzrryr rrr})r~rrYi8modesnpmodesrqrqrr_models  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)r5allrzh' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).z () instead.r(zPeriod 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 rvr)WrappedCythonOp)rrr)rrcomp_idsrY)stdsemrz-'std' and 'sem' are not valid for PeriodDtyper*zm8[rqr)ryrrr-r.r/r>rxrJrrzpandas.core.groupby.opsrget_kind_from_how_cython_op_ndim_compatrcast_blocklistrurlr rrxr})r~rrrrrrrynpvaluesrrrpr{rl new_dtyperqrqrr _groupby_opysl           z"DatetimeLikeArrayMixin._groupby_oprur)NNF)ryrrrrur)rur)rrnrur)rrrur)rrrurrur)rurf)rur)rrrur)F)rr)NN)ryrrrrur)rr1rur)rrrur2)rr/rur)rur)rrrrrurrurT)rrrur2)ryrrurj)ryrrurl).)ryrrur'ro)rrrr)rrrurn)rr)rur)rr'rur)rur)rrrur)rur;)rur?rurn)rurh)rurj)rrjrurj)rrrurl)rrjrurl)rrrurl)rrrurk)rrl)rr)rrrur)rr)rrnr%rrur2)rrrrnrur2)rrr%r)r%rrr)rr) rrnrrrrrrrr)`r __module__ __qualname____doc____annotations__r=rrpropertyrrrrr{rrrrrrr rrrrrrzrrrrrr rrYrrSrNr3r6rr:r<r>rBrDrJrLrOr[rsr\r]r^r_r`rarbrcrdrerfrgrkrlr}r~rrrrrrrrrrrrrrbrrrrrrrrrrrrrr __classcell__rqrqrrrrs             3 (=: 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)URLrrnrurcCs|j|tjd}|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') )rrFr)rrr7rr)r~rrrqrqrrstrftimes1zDatelikeOps.strftimeN)rrnrur)rrrrr<r rqrqrqrrrs 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)|rTzK Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex. znp.dtype_default_dtypeNFrrrurc 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.r(Tr rna_valuerdtype=z does not match data dtype MmrwzUnexpected 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[rqinferz#Frequency inference not allowed in z$.__init__. Use 'pd.array()' instead.r(TimedeltaArray/Index freq must be a Tick)rry)&r-r.rrr/r>rEr_rxr\rrrr no_defaultrr!_validate_inferred_freqryrrrrrr rzrrrtrHr_validate_dtyperrrrr_validate_frequency) r~rryrrr> explicit_nonerrrqrqrrrs               zTimelikeOps.__init__cCrror)clsrryrqrqrrrszTimelikeOps._validate_dtypecCr2)zK Return the frequency object if it is set, otherwise None. rrrqrqrrrszTimelikeOps.freqcCsV|dur&t|}||||jjdkrt|tstd|jdkr&td||_ dS)NrrrzCannot set freq with ndim > 1) r!rryrrxrrrrrrrqrqrrrs    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)r~rrrqrqrr_maybe_pin_freqs     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 rq) r>rNr<_generate_rangerrr array_equalrrrn)rindexrrr1on_freqrrqrqrrr0s8 zTimelikeOps._validate_frequencyr  int | Noner2cOrror)rrrr rrrrqrqrrr#\rzTimelikeOps._generate_rangercCs t|jjSro)rrryrrqrqrrrds zTimelikeOps._cresorncCs t|jSro) dtype_to_unitryrrqrqrrrhr4zTimelikeOps.unitTrr cCs~|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'rrqr rjrrrs) rrryrrrrxr rrHrrxr)r~rr ryrrrrqrqrrr os  zTimelikeOps.as_unitcCs@|j|jkr|j|jkr||j}||fS||j}||fSro)rr rrrqrqrrrys    z"TimelikeOps._ensure_matching_resosufuncnp.ufuncmethodcs`|tjtjtjfvr"t|dkr"|d|ur"t|||jfi|Stj||g|Ri|S)Nrr) risnanisinfisfiniterrrr__array_ufunc__)r~r-r/inputsrrrqrrr3s   zTimelikeOps.__array_ufunc__c Cst|jtr!td|}|d}|||||}|j|j||dS|d}ttj |}t ||j }|dkr:| St |||} |j| td}||jj}|j||jdS)Nrj) ambiguous nonexistentrwrr9r)rxryrHr tz_localize_roundrrzrrr%rrr#r:rrrx) r~rrr5r6naiverrnanos result_i8rqrqrrr9s       zTimelikeOps._roundround)rpraiser5r4r6r5cC||tj||Sro)r9r"NEAREST_HALF_EVENr~rr5r6rqrqrrr=zTimelikeOps.roundfloorcCr?ro)r9r" MINUS_INFTYrArqrqrrrCrBzTimelikeOps.floorceilcCr?ro)r9r" PLUS_INFTYrArqrqrrrErBzTimelikeOps.ceilrrrr%cCtj|j|||dSNr)rQnananyrrNr~rr%rqrqrrr5szTimelikeOps.anycCrGrH)rQnanallrrNrJrqrqrrrszTimelikeOps.allcCs d|_dSrorrrqrqrrrs 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) rrxrryrrrr!r>rzr)r~rrrqrqrr _with_freqs   zTimelikeOps._with_freqrcst|jtjr |jStSro)rxryrrr_values_for_jsonrrrqrrrMs 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.)rN) rrarangerintprrNotImplementedErrorrrr factorize)r~rNrOcodesuniquesrrqrrrT s zTimelikeOps.factorizer to_concatSequence[Self]r(cst||}|d|dkrDdd|D}jdurDtfdd|DrDt|dd|dd}tfdd|DrDj}||_|S) NrcSsg|]}t|r|qSrq)rrrqrqrrr( rz1TimelikeOps._concat_same_type..c3s|] }|jjkVqdSrorrrrqrrr* sz0TimelikeOps._concat_same_type..rPrc3s.|]}|ddj|ddkVqdS)rrPrNrY)rpairrZrqrrr, s,)r_concat_same_typerrzipr)rrWrnew_objpairsr|rrZrrr\ s zTimelikeOps._concat_same_typeCordercstj|d}|j|_|S)N)ra)rrrr)r~rar^rrqrrr1 szTimelikeOps.copyr-r%ric Ks^|dkrt|s |j} n|j} tj| f||||||d||s%|St|j| |jdS)z2 See NDFrame.interpolate.__doc__. linear)r/rr%limitlimit_direction limit_arear)rSrrrPinterpolate_2d_inplacerrxry) r~r/rr%rcrdrerrout_datarqrqrr interpolate6 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) rrtryrrrr r logical_andr)r~ values_intconsider_valuesrppd even_daysrqrqrr_is_dates_only_ s  zTimelikeOps._is_dates_only)rrrurr)rr)rr)r r'rur2)rurrr)rrnr rrur2)r-r.r/rn)r>r>)r5r4r6r5rur2)rrr%rrurrr)TF)rNrrOr)r)rWrXrr(rur2)r`)rarnrur2) r/r-rrr%rirrrur2r),rrrrrrrr classmethodrrrsetterr rrr#r=rrr ryr3r9r; _round_doc_round_examplerr=_floor_examplerC _ceil_examplerEr5rrrLrMrTr\rrhrnrrqrqrrrrTsj  \     *           )rTrrcls_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) NryrFzCannot create a z from a MultiIndex.Tr rrr r7)rrxrtuplerrr?rLrr_r\rZryrrr_maybe_convert_datelike_arrayrr[rrKrtakerUr_values)rrrurqrqrr!ensure_arraylike_for_datetimelikey s6         r{r rcCrrorqr rqrqrrvalidate_periods rr} int | floatrcCrrorqr|rqrqrrr} 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.r(zperiods must be a number, got ) ris_floatr-r.r/r>rrrr|rqrqrrr} 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 Nr!r")rr<)rr>rqrqrrr srry'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) rxrHrrFrr pyarrow_dtyper datetime_datarrqrqrrr( s   r()rmrn)rtr,rur,)rrrurnrurv)r rrur)r r~rur)r rrur')rrr>rrur)ryrrurn) __future__rrr functoolsrrQtypingrrrr r r r r r-numpyr pandas._libsrrpandas._libs.arraysrpandas._libs.tslibsrrrrrrrrrrrrrrrr 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.r/r0r1r2r3r4r5r6pandas.compat.numpyr7r pandas.errorsr8r9r:pandas.util._decoratorsr;r<r=pandas.util._exceptionsr>pandas.core.dtypes.castr?pandas.core.dtypes.commonr@rArBrCrDrEpandas.core.dtypes.dtypesrFrGrHrIrJpandas.core.dtypes.genericrKrLpandas.core.dtypes.missingrMrN pandas.corerOrPrQrRpandas.core.algorithmsrSrTrUpandas.core.array_algosrVpandas.core.arraylikerWpandas.core.arrays._mixinsrXrYpandas.core.arrays.arrow.arrayrZpandas.core.arrays.baser[pandas.core.arrays.integerr\pandas.core.commoncorecommonrpandas.core.constructionr]rr^r_pandas.core.indexersr`rapandas.core.ops.commonrbpandas.core.ops.invalidrcrdpandas.tseriesrecollections.abcrfrgrrirurjrkrlrrsrrrrqrrrsrtrTr{r}rr(rqrqrqrrs  (  L   H                :? h'    "