o ҷhI@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(dd l)m*Z*m+Z+dd l,m-Z-dd l.m/Z/dd l0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@dd lAmBZCddlDmEZEmFZFmGZGddlHmIZImJZJmKZKddlLmMZMddlNmOZOmPZPmQZQmRZRmSZSmTZTddlUmVZVmWZWmXZXmYZYddlZm[Z[m\Z\ddl]m^Z^m_Z_ddl`maZambZbmcZcmdZdddlemfZfmgZgmhZhmiZiddljmkZkddllmmZmddlnmoZompZpddlqmrZrddlsmtZtddlumvZvddlwmxmyZzddl{m|Z}m~Z~mZddlmZmZddlmZdd lmZmZdd!lmZerrdd"lmZmZdd#lmZdd$lmZmZmZe e3efZdPd'd(ZdQd,d-ZGd.d/d/emeoZGd0d1d1eZd2Zd3Zd4Zd5ZGd6d7d7eZdRd;d<ZedSd?d@ZedTdCd@ZdUdFd@ZdVdHdIZdJdKZdWdNdOZdS)X) annotations)datetime timedelta)wrapsN) TYPE_CHECKINGAnyCallableLiteralUnioncastfinaloverload)algoslib) NDArrayBacked) BaseOffsetIncompatibleFrequencyNaTNaTTypePeriod ResolutionTick Timedelta Timestampastype_overflowsafedelta_to_nanosecondsget_unit_from_dtypeiNaTints_to_pydatetimeints_to_pytimedelta to_offset)RoundTo round_nsint64)compare_mismatched_resolutions)integer_op_not_supported) ArrayLikeAxisIntDatetimeLikeScalarDtypeDtypeObjFInterpolateOptionsNpDtypePositionalIndexer2DPositionalIndexerTuple ScalarIndexerSelfSequenceIndexer TimeAmbiguousTimeNonexistentnpt)function)AbstractMethodErrorInvalidComparisonPerformanceWarning)Appender Substitutioncache_readonly)find_stack_level)is_all_stringsis_integer_dtype is_list_likeis_object_dtypeis_string_dtype pandas_dtype)CategoricalDtypeDatetimeTZDtypeExtensionDtype PeriodDtype)ABCCategorical ABCMultiIndex)is_valid_na_for_dtypeisna) algorithmsmissingnanopsops)checked_add_with_arrisin 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)rar_)rjoprnR/var/www/html/venv/lib/python3.10/site-packages/pandas/core/arrays/datetimelike.py_make_unpacked_invalid_ops rpmethr*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) isinstancedtyperFviewrr _box_func_value_from_backing_data)selfargskwargsarrresultres_i8rqrnronew_meths      z"_period_dispatch..new_meth)rr r*)rqrrnrro_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/Zd0dd1dd5d6Zddd8d9Zddd;d<Zedd?d@ZeddCd@ZdfdGd@ ZddHdIZdfdLdM ZddNdOZd d fdQdR Zed dSdTZed dWdTZed dZdTZeddd]dTZddfd^dT Zd_d`ZddPdaddddeZdddfdgZdddidjZdkdlZe ddndoZ!e"ddpdqZ#ddsdtZ$ddudvZ%eddwdxZ&eddydzZ'e(dfdd|d}Z)edddZ*edddZ+edddZ,edddZ-edddZ.edddZ/edddZ0ddZ1e2dZ3e2dZ4e2dZ5e2dZ6e2dZ7e2dZ8e2dZ9e2dZ:e2dZ;e2dZe dddZ?e dddZ@e dddZAe dddZBe dddZCe dddZDe dddZEe dddZFddZGddZHd ddZIe d!ddZJe ddZKe ddZLe d"ddZMe d#dd„ZNdPdÜd$ddDŽZOePdȃddʄZQdd̄ZRePd̓ddτZSddфZTd ddӄZUd ddՄZVeWd%fddڄ ZXeWddPdۜd&dd߄ZYeWddPdۜd&ddZZdPddd'ddZ[eWddPdۜ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 | NonefreqrrboolcCsdS)NTrnr{rnrnro _can_hold_naz#DatetimeLikeArrayMixin._can_hold_naNFrv Dtype | NonecopyNonecCt|rlr6)r{datarvrrrnrnro__init__szDatetimeLikeArrayMixin.__init__type[DatetimeLikeScalar]cCr)z The scalar associated with this datelike * PeriodArray : Period * DatetimeArray : Timestamp * TimedeltaArray : Timedelta rrrnrnro _scalar_types z#DatetimeLikeArrayMixin._scalar_typevaluerk 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{rrnrnro_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.arrays.DatetimeArray(np.array(['1970-01-01'], 'datetime64[ns]')) >>> arr._unbox_scalar(arr[0]) numpy.datetime64('1970-01-01T00:00:00.000000000') rrrnrnro _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{rrnrnro_check_compatible_withrz-DatetimeLikeArrayMixin._check_compatible_withcCr)zI box function to get object from internal representation r)r{xrnrnrorx*sz DatetimeLikeArrayMixin._box_funccCstj||jddS)z1 apply box func to passed values F)convert)r map_inferrx)r{valuesrnrnro _box_values0sz"DatetimeLikeArrayMixin._box_valuesrccs8jdkrfddttDSfddjDS)Nc3s|]}|VqdSrlrn).0nrrnro 8sz2DatetimeLikeArrayMixin.__iter__..c3s|]}|VqdSrl)rx)rvrrnror:s)ndimrangelenasi8rrnrro__iter__6s zDatetimeLikeArrayMixin.__iter__npt.NDArray[np.int64]cCs |jdS)z Integer representation of the values. Returns ------- ndarray An ndarray with int64 dtype. rt)rrwrrnrnror<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{rrrnrnro_format_native_typesLs z+DatetimeLikeArrayMixin._format_native_typesboxedcCsdjS)Nz'{}')format)r{rrnrnro _formatterXsz!DatetimeLikeArrayMixin._formatterNpDtype | NonecCs t|r tjt|tdS|jS)Nrv)r@nprZlistobjectrr{rvrnrnro __array___sz DatetimeLikeArrayMixin.__array__itemr/cCdSrlrnr{rrnrnro __getitem__erz"DatetimeLikeArrayMixin.__getitem__(SequenceIndexer | PositionalIndexerTupler0cCrrlrnrrnrnroriskeyr-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_scalarr0_get_getitem_freq_freq)r{rr __class__rnrorps    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)rurvrFrrr]slicestepEllipsiscomis_bool_indexerrmaybe_booleans_to_slicerwruint8r)r{r is_periodrnew_keyrnrnrors.          z(DatetimeLikeArrayMixin._get_getitem_freq,int | Sequence[int] | Sequence[bool] | sliceNaTType | Any | Sequence[Any]cs.t|||}t|||rdS|dSrl)r^r __setitem___maybe_clear_freq)r{rrno_oprrnrors  z"DatetimeLikeArrayMixin.__setitem__cCrrlrnrrnrnrorsz(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)NMrg timestamp)tzboxresomT)rriuzConverting from z to z? is not supported. Do obj.astype('int64').astype(dtype) insteadmMfz Cannot cast z to dtype r)rBrrvkindr rrr_cresorrrravelreshapeshaperurErastyperArrint64 TypeErrorrtype__name__asarray)r{rvri8data convertedrmsgrrnrors@      zDatetimeLikeArrayMixin.astypecCrrlrnrrnrnrorwrzDatetimeLikeArrayMixin.viewLiteral['M8[ns]']rgcCrrlrnrrnrnrorwrLiteral['m8[ns]']ricCrrlrnrrnrnrorwr.r%cCrrlrnrrnrnrorwrcs t|Srl)rrwrrrnrorws 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_objectrv)rurkr ValueErrorrr7rrrrrr?r_validate_listliker@getattr)r{rerrrnrnro_validate_comparison_values>       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) rurrkrr_validation_error_messagerrIrvrrJrr)r{rrrrrrnrnro_validate_scalar+s,          z'DatetimeLikeArrayMixin._validate_scalarcCsD|rd|jjdt|jd}|Sd|jjdt|jd}|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 zvalue should be a 'z"', 'NaT', or array of those. Got 'z ' instead.z' or 'NaT'. Got ')rrr)r{rrrrnrnrorfs  z0DatetimeLikeArrayMixin._validation_error_messagerc Csdt|t|r |St|trt|dkrt|jg|jdSt|drS|jtkrSt ||j vrSz t||}Wnt t fyR|rH|YS| |d}t |wt|dd}t|}t|dd}t|r}z t|j||jd}Wn t y|Ynwt|jtr|jj|jkr|}t|dd}|rt|jr |St||js| |d}t ||S)NrrrvT extract_numpy)rurrr_from_sequencervhasattrrr infer_dtyperrrrr\pd_arrayr=rC categories_internal_get_valuesr@r)r{rrrrnrnrorsD       z)DatetimeLikeArrayMixin._validate_listlikecCs,t|r ||}n|j|ddS||S)NT)r)r?rr_unboxrrnrnro_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. )rrrrrrrnrnror s   zDatetimeLikeArrayMixin._unboxcCs:ddlm}t|||d}||}t|tr|S|jS)Nrre) na_action)pandasrfrQrurHto_numpyrZ)r{mapperr rfrrnrnromaps  zDatetimeLikeArrayMixin.mapnpt.NDArray[np.bool_]c Cs4t|ds t|}|jjdvrtj|jtdSt|t |sggd}|jt krLt j |dd}||vrL|dkr8nd|vrDt |t |Stj|jtdSz t ||}Wntyft |t |YSw|jjd vrxtd |}||j}z||Wnttfytj|jtdYSwt |j|jS) z Compute boolean array of whether each value is found in the passed set of values. Parameters ---------- values : set or sequence of values Returns ------- ndarray[bool] rvfiucr)r timedelta64r datetime64dateperiodFskipnastringmixedrDatetimeArray | TimedeltaArray)rrrrvrzerosrrrurrrrrPrrrr as_unitunitrrr)r{r inferableinferredrnrnrorPs8       zDatetimeLikeArrayMixin.isincC|jSrl)_isnanrrnrnrorJszDatetimeLikeArrayMixin.isnacCs |jtkS)z- return if each value is nan )rrrrnrnror" zDatetimeLikeArrayMixin._isnancCst|jS)zJ return if I have any nans; enables various perf speedups )rr"anyrrnrnro_hasna!szDatetimeLikeArrayMixin._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")r{r fill_valuerrnrnro_maybe_mask_results(s 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)rfreqstrrrnrnror+Fs 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)rrb infer_freqrrrnrnro inferred_freqds   z$DatetimeLikeArrayMixin.inferred_freqResolution | NonecCs4|j}|dur dSzt|WStyYdSwrl)r+rget_reso_from_freqstrKeyError)r{r+rnrnro_resolution_objs  z&DatetimeLikeArrayMixin._resolution_objcCs|jjS)zO Returns day, hour, minute, second, millisecond or microsecond )r1attrnamerrnrnro resolutionsz!DatetimeLikeArrayMixin.resolutioncCtj|jdddS)NTtimelikerr is_monotonicrrrnrnro_is_monotonic_increasingz/DatetimeLikeArrayMixin._is_monotonic_increasingcCr4)NTr5rr7rrnrnro_is_monotonic_decreasingr:z/DatetimeLikeArrayMixin._is_monotonic_decreasingcCstt|jd|jkS)NK)rrRrrsizerrnrnro _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)NrrrvrFround_okrt))rrrrrrr7r`r@rNcomp_method_OBJECT_ARRAYrrrrroperatorneonesrrrurvrFr TimelikeOpsrrrrrrZasm8r#rr rwrJr"r$r') r{rrmrvr other_arr other_valso_maskmask nat_resultrnrnro _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)zR Get the int64 values and b_mask to pass to checked_add_with_arr. N)rurordinalrrryr"r)r{ri8valuesrJrnrnro_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)rurvrFrrrrrrnrnro_get_arithmetic_result_freqs   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|j||j|d }|d|jd }||j|jd }|d|jd }||} |j||| d S)Nr cannot add  and rirrg) tz_to_dtypezM8[]rarr_maskb_maskrrrvr)r is_np_dtypervrrrr pandas.core.arraysrgpandas.core.arrays.datetimesrarrJr to_datetime64rr _simple_newr_ensure_matching_resosr\rOrr"rwrr]) r{rrgrarother_i8rI res_valuesrvnew_freqrnrnro_add_datetimelike_scalars.       z/DatetimeLikeArrayMixin._add_datetimelike_scalarcCs6t|jdstdt|jdt|j||S)Nrr^r_)rrhrvrrrrrnrnro_add_datetime_arraylike4s z.DatetimeLikeArrayMixin._add_datetime_arraylikedatetime | np.datetime64cCsZ|jjdkrtdt|jtd|}t|r|tSt|}| |\}}| |S)Nr"cannot subtract a datelike from a rg) rvrrrrr rJrrrm_sub_datetimelike)r{rtsrnrnro_sub_datetimelike_scalar>s   z/DatetimeLikeArrayMixin._sub_datetimelike_scalarcCsZ|jjdkrtdt|jt|t|krtdtd|}||\}}| |S)Nrrt$cannot add indices of unequal lengthrg) rvrrrrrrr rmrurrnrnro_sub_datetime_arraylikeQs   z.DatetimeLikeArrayMixin._sub_datetime_arraylikeTimestamp | DatetimeArrayc Cstd|}ddlm}z||Wnty-}zt|dd}t|||d}~ww||\}}t |j | |j |d}| d|j d}||} td | } |j||j| d S) Nrgrricomparesubtractrc timedelta64[rbz Tick | Nonerg)r riri_assert_tzawareness_compatrrkreplacerr\rOrr"rwrr]rlrv) r{rrir new_messagernrIrores_m8rprnrnroru^s"    z(DatetimeLikeArrayMixin._sub_datetimelikerrhcCs\t|jdstdt|jddlm}t |j |j }t |j }|||d}||S)Nrzcannot add Period to a r)rhr)rrhrvrrrpandas.core.arrays.periodrhr broadcast_torZrrFr)r{rrhi8valsrvparrrnrnro _add_periodts   z"DatetimeLikeArrayMixin._add_periodcCrrlr)r{offsetrnrnro _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 rtrr)rJremptyrrwrrvfillrrrlr rrm_add_timedeltalike)r{r new_valuesrnrnro_add_timedeltalike_scalars   z0DatetimeLikeArrayMixin._add_timedeltalike_scalarcCs:t|t|kr tdtd|}||\}}||S)zl Add a delta of a TimedeltaIndex Returns ------- Same type as self rxr)rrr rmrrrnrnro_add_timedelta_arraylikes    z/DatetimeLikeArrayMixin._add_timedelta_arraylikeTimedelta | TimedeltaArraycCsZtd|}||\}}t|j||j|d}||jj}||}t |j ||j|dS)Nrrcrg) r r\rOrr"rwrrvr]rrl)r{rrnrIrrorprnrnrors   z)DatetimeLikeArrayMixin._add_timedeltalikecCsvt|jtrtdt|jdttjtd|}tj |j tj d}| t ||jj}t|j||jddS)z$ Add pd.NaT to self z Cannot add r_zTimedeltaArray | DatetimeArrayrNrg)rurvrFrrrrr rrrrrrrwrrlr{rrnrnro_add_nats   zDatetimeLikeArrayMixin._add_natcCsPtj|jtjd}|t|jjdvr#td|}| d|j dS| dS)z+ Subtract pd.NaT from self rrzDatetimeArray| TimedeltaArrayr~rbztimedelta64[ns]) rrrrrrrvrr rwrrrnrnro_sub_nats     zDatetimeLikeArrayMixin._sub_natPeriod | PeriodArraycstjtstdt|jdtjtd||\}}t j | j |d}t fdd|D}|durFj }nj |B}t||<|S)Ncannot subtract  from rhrccsg|]}jj|qSrn)rbaserrrrnro z:DatetimeLikeArrayMixin._sub_periodlike..)rurvrFrrrr rr\rOrr"rrZr)r{rrnrI new_i8_datanew_datarJrnrro_sub_periodlikes    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. stacklevelO)rBaddsubrrwarningswarnrrr8r<rrrr)r{rrmrornrnro_addsub_object_arraysz+DatetimeLikeArrayMixin._addsub_object_arrayrnamercKsV|dvrtd|dt|tt|}||fd|i|}t|j||jdS)N>cummaxcumminz Accumulation z not supported for rr)rrrrSrrlrv)r{rrr}rmrrnrnro _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)Nrvrrhrrr{)&rr[rrrurrrrrrrrrrqrrrhrvr is_integerrFr$r _addsub_int_array_or_scalar_nrBrrr@rrDrrr>NotImplementedndarrayririr{r other_dtyperobjrirnrnror0sF                zDatetimeLikeArrayMixin.__add__cCs ||Srl)rrrnrnro__radd__hs 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)Nrvrhrrrr{)&rr[rrrurrrrrrrrrrwrrrvrFr$r rrrBrrrrhrr@rrDryr>rrririrrnrnrorlsJ                zDatetimeLikeArrayMixin.__sub__cCs t|dd}t|dpt|t}|r8t|jdr8t|r%t||St|ts4ddl m }||}||S|jj dkrUt |drU|sUt dt|jdt|jt|jtrot|drot dt|jd|jt|jdrtd|}| |S|| S) Nrvrrrr`rrri)rrrhrurDrvrrrrirgrrrrrrFr )r{rr other_is_dt64rgrnrnro__rsub__s*        zDatetimeLikeArrayMixin.__rsub__cCs4||}|dd|dd<t|jts|j|_|SrlrurvrFrrr{rrrnrnro__iadd__  zDatetimeLikeArrayMixin.__iadd__cCs4||}|dd|dd<t|jts|j|_|Srlrrrnrnro__isub__rzDatetimeLikeArrayMixin.__isub__qsnpt.NDArray[np.float64] interpolationcstj||dS)N)rr)r _quantile)r{rrrrnrorsz 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. rnr)nv validate_minvalidate_minmax_axisrrMnanminr_wrap_reduction_resultr{rrr}rrnrnromin  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. rnr)r validate_maxrrrMnanmaxrrrrnrnromaxrzDatetimeLikeArrayMixin.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()rrrJ) rurvrFrrrrMnanmeanrrJr)r{rrrrnrnromeans , zDatetimeLikeArrayMixin.meancKsHtd||durt||jkrtdtj|j||d}|||S)Nrnz abs(axis) must be less than ndimr) rvalidate_medianabsrrrM nanmedianrrrrnrnromedian@s  zDatetimeLikeArrayMixin.mediandropnacCsHd}|r|}tj|d|d}||jj}ttj|}| |S)Nrt)rJ) rJrKmoderwrrvr rrrz)r{rrJi8modesnpmodesrnrnro_modeJs  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}| |} | | S| |j j} || S)Nr)sumprodcumsumcumprodvarskewz!datetime64 type does not support z operations)r$all'zh' 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 rsr)WrappedCythonOp)rrr)rrcomp_idsrJ)stdsemr{z-'std' and 'sem' are not valid for PeriodDtyperzm8[rb)rvrrrr FutureWarningr<rurFrrwpandas.core.groupby.opsrget_kind_from_how_cython_op_ndim_compatrcast_blocklistririr rrz)r{rrrrrr}rvnpvaluesrrrmrori new_dtypernrnro _groupby_opWsl           z"DatetimeLikeArrayMixin._groupby_op)rrr)NNF)rvrrrrrr)rrr)rrkrrr)rrrrr)rrrrrrrr)rrrc)rrr)rrrrr)F)rrrl)rvrrrr)rr/rrr)rrrrr0)rr-rrr)rrr)rrrrrrrrrr)T)rrrrr0)rvrrrrg)rvrrrri).)rvrrrr%)rrrr)rrrrrk)rr)rrr )rrr)rrrrr)rrr*)rrr.rrrk)rrrY)rrrg)rrgrrrg)rrsrrri)rrgrrri)rrzrrri)rrrrrh)rri)rr)rrrrr)rr)rrkrrrrr0)rrrrkrrr0)rrrr)rrrr)rr) rrkrrrrrrrr)`r __module__ __qualname____doc____annotations__r;rrpropertyrrrrrxrrrrrrr rrrrrrwrrrrr r r rVrrPrJr"r%rr)r+r-r1r3r9r;r>rLrprMrNrOrPrQrRrSrTrUrVrWrXr\r]rqrrrwryrurrrrrrrrrrr_rrrrrrrrrrrrrr __classcell__rnrnrrors             3 (;4 <     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)URLrrkrrrcCs|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)rrr&rr)r{rrrnrnrostrftimes1zDatelikeOps.strftimeN)rrkrrr)rrrrr:rrnrnrnrors raM 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='T') 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<dejdfdZd d Zed d Z e ddZ e j d[ddZ eddZ ed\ddZed]ddZed^ddZd_ddZdd Zd`fd$d% Zd&d'Zeeejd(d) * *dadbd/d0Zeeejd1d) * *dadbd2d3Zeeejd4d) * *dadbd5d6Zdd7d8dcdd?Z d[d@dAZ!d\dBdCZ"ddfdEdF Z# 7 dedffdIdJ Z$e KdgdhfdOdP Z%didjfdSdT Z&dkdXdYZ'Z(S)lrEzK Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex. znp.dtype_default_dtypeNFrrrrrcCst|dd}t|tr|jdtd}t|dd}|du}|tjur#|nd}t|t|rh|r/n|dur7|j }n|rI|j rIt |}t ||j d\}}|durat |}||j kratd|d|j |j }|j}n|durt|tjr||j jd vr||j }n|j}t|tjstd t|jd t|jd |jd vrtd|j dkr||j}|||}|dkrtdt|jd|r|}|rt |}|j jdkrt|tstdtj|||d||_|dur|durt|||dSdSdS)NTrrna_valuerFzdtype=z does not match data dtype MmzUnexpected type 'z'. 'values' must be a z6, ndarray, or Series or Index containing one of those.)rz.Only 1-dimensional input arrays are supported.rtinferz#Frequency inference not allowed in z$.__init__. Use 'pd.array()' instead.r(TimedeltaArray/Index freq must be a Tick)rrv)r\rurYrrrr no_defaultrrr validate_inferred_freqrBrvrrrrrrrrrrw_validate_dtyperrrrr_validate_frequency)r{rrvrrr- explicit_none_rnrnrorysh          zTimelikeOps.__init__cCrrlr)clsrrvrnrnror zTimelikeOps._validate_dtypecCr!)zK Return the frequency object if it is set, otherwise None. rrrnrnrorszTimelikeOps.freqcCsV|dur&t|}||||jjdkrt|tstd|jdkr&td||_ dS)Nrr rzCannot set freq with ndim > 1) r r rvrrurrrrrrrnrnrors   c 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 rn) r-r=r+_generate_rangerrr array_equalrrrk)rindexrr}r on_freqrrnrnror s8  zTimelikeOps._validate_frequencyr0cOrrlr)rrrrrr|r}rnrnrorrzTimelikeOps._generate_rangercCs t|jjSrl)rrrvrrnrnror s zTimelikeOps._cresorkcCs t|jSrl) dtype_to_unitrvrrnrnrorr#zTimelikeOps.unitrcCs~|dvrtdt|jjd|d}t|j|dd}t|jtjr(|j}n td|j}t ||d}t |j |||j d S) N)smsusnsz)Supported units are 's', 'ms', 'us', 'ns'z8[rbTr?rgrfrg) rrrvrrrrur rrDrrlr)r{rrvrrrrnrnrors  zTimelikeOps.as_unitcCs@|j|jkr|j|jkr||j}||fS||j}||fSrl)rrrrrnrnrorm,s    z"TimelikeOps._ensure_matching_resosufuncnp.ufuncmethodcs`|tjtjtjfvr"t|dkr"|d|ur"t|||jfi|Stj||g|Ri|S)Nrr) risnanisinfisfiniterrrr__array_ufunc__)r{r!r#inputsr}rrnror'7s   zTimelikeOps.__array_ufunc__c Cst|jtr!td|}|d}|||||}|j|j||dS|d}ttj |}t |}|j t ||j } | dkrA|St||| } |j| td}||jj}|j||jdS)Nrg) ambiguous nonexistentrtrr(r)rurvrDr tz_localize_roundrrwrrr nanosrrrr"r)rrrl) r{rrr)r*naiverrrr. result_i8rnrnror-Bs$       zTimelikeOps._roundround)rmraiser)r2r*r3cC||tj||Srl)r-r!NEAREST_HALF_EVENr{rr)r*rnrnror1ZzTimelikeOps.roundfloorcCr3rl)r-r! MINUS_INFTYr5rnrnror7cr6zTimelikeOps.floorceilcCr3rl)r-r! PLUS_INFTYr5rnrnror9lr6zTimelikeOps.ceilTrrrrcCtj|j|||dSNr)rMnananyrrJr{rrrnrnror$xszTimelikeOps.anycCr;r<)rMnanallrrJr>rnrnror|szTimelikeOps.allcCs d|_dSrlrrrnrnrors 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 Nrrr r) rrurrvrrrr r-rwr)r{rr~rnrnro _with_freqs   zTimelikeOps._with_freqrcst|jtjr |jStSrl)rurvrrr_values_for_jsonrrrnrorAs 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.)rB) rrarangerintprrNotImplementedErrorrrr factorize)r{rBrCcodesuniquesrrnrorHs zTimelikeOps.factorizer to_concatSequence[Self]r&cst||}|d|dkrDdd|D}jdurDtfdd|DrDt|dd|dd}tfdd|DrDj}||_|S) NrcSsg|]}t|r|qSrn)rrrnrnrorrz1TimelikeOps._concat_same_type..c3s|] }|jjkVqdSrlrrrrnrorsz0TimelikeOps._concat_same_type..rDrc3s.|]}|ddj|ddkVqdS)rrDrNrM)rpairrNrnrors,)r_concat_same_typerrzipr)rrKrnew_objpairsrprrNrorPs zTimelikeOps._concat_same_typeCordercstj|d}|j|_|S)N)rU)rrrr)r{rUrRrrnrorszTimelikeOps.copyr+rrfc Ks^|dkrt|s |j} n|j} tj| f||||||d||s%|St|j| |jdS)z2 See NDFrame.interpolate.__doc__. linear)r#rrlimitlimit_direction limit_arear)rGrrrLinterpolate_2d_inplacerrlrv) r{r#rrrWrXrYrr}out_datarnrnro interpolates(  zTimelikeOps.interpolate)rrrrrrr)rrrr)rrkrrr0)r!r"r#rk)r2r2)r)r2r*r3rrr0)rrrrrrrr)TF)rBrrCr)r)rKrLrr&rrr0)rT)rUrkrrr0) r#r+rrrrfrrrrr0))rrrrrrr r classmethodr rrsetterr rr;rrrrmr'r-r9 _round_doc_round_examplerr1_floor_exampler7 _ceil_exampler9r$rrr@rArHrPrr\rrnrnrrorErs`  J    *          rErrcls_namecCst|dst|ttfst|dkrt|}t|}d}nt|tr,td|dt |dd}t|t sBt|t rO|j j dvrO|jd td }d}||fSt|t rb|}|}d}||fSt|tjtfsst|}||fSt|tr|jj|jtd j}d}||fS) NrvrFzCannot create a z from a MultiIndex.Trrrrr+)rrurtuplerrrrHrr\rYrWrvrrr_maybe_convert_datelike_arrayrrXrGrtakerIr_values)rrrcrnrnro!ensure_arraylike_for_datetimelike s6          rhrrcCrrlrnrrnrnrovalidate_periods0 rrj int | floatrcCrrlrnrirnrnrorj5 rint | float | None int | NonecCs:|durt|rt|}|St|std||S)a9 If a `periods` argument is passed to the Datetime/Timedelta Array/Index constructor, cast it to an integer. Parameters ---------- periods : None, float, int Returns ------- periods : None or int Raises ------ TypeError if periods is None, float, or int Nzperiods must be a number, got )ris_floatrrrrirnrnrorj: s  tuple[BaseOffset | None, bool]cCsF|dur|dur||krtd|d|j|dur|}d}||fS)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 freq_infer : bool Returns ------- freq : DateOffset or None freq_infer : bool Notes ----- We assume at this point that `maybe_infer_freq` has been called, so `freq` is either a DateOffset object or None. NrrF)rr+)rr- freq_inferrnrnror T sr cCs6d}t|ts|dkrt|}||fSd}d}||fS)a Comparing a DateOffset to the string "infer" raises, so we need to be careful about comparisons. Make a dummy variable `freq_infer` to signify the case where the given freq is "infer" and set freq to None to avoid comparison trouble later on. Parameters ---------- freq : {DateOffset, None, str} Returns ------- freq : {DateOffset, None} freq_infer : bool Whether we should inherit the freq of passed data. FrTN)rurr )rrprnrnromaybe_infer_freqy s rqrvDatetimeTZDtype | np.dtypecCst|tr|jSt|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 r)rurDrr datetime_datarrnrnror s r)rjrk)rqr*rrr*)rrrcrk)rrrrr)rrkrrr)rrlrrrm)rrro)rvrrrrrk) __future__rrr functoolsrrBtypingrrrr r r r r rnumpyr pandas._libsrrpandas._libs.arraysrpandas._libs.tslibsrrrrrrrrrrrrrrrr pandas._libs.tslibs.fieldsr!r"pandas._libs.tslibs.np_datetimer#pandas._libs.tslibs.timestampsr$pandas._typingr%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4pandas.compat.numpyr5r pandas.errorsr6r7r8pandas.util._decoratorsr9r:r;pandas.util._exceptionsr<pandas.core.dtypes.commonr=r>r?r@rArBpandas.core.dtypes.dtypesrCrDrErFpandas.core.dtypes.genericrGrHpandas.core.dtypes.missingrIrJ pandas.corerKrLrMrNpandas.core.algorithmsrOrPrQrRpandas.core.array_algosrSpandas.core.arraylikerTpandas.core.arrays._mixinsrUrVpandas.core.arrays.arrow.arrayrWpandas.core.arrays.baserXpandas.core.arrays.integerrYpandas.core.commoncorecommonrpandas.core.constructionrZrr[r\pandas.core.indexersr]r^pandas.core.ops.commonr_pandas.core.ops.invalidr`rapandas.tseriesrbcollections.abcrcrdr rfrirgrhrirrprrrr_r`rarbrErhrjr rqrrnrnrnros  (  H  H               q:? $    %