o hƓ@sddlmZddlmZddlZddlmZmZddlZ ddl m Z m Z ddl mZmZmZmZmZmZmZmZmZddlmZddlmZmZdd lmZmZmZm Z m!Z!dd l"m#Z$dd l%m&Z&dd l'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.dd l/m0Z0ddl1m2Z2ddl3m4Z4m5Z5ddl6m7Z7ddl8m9Z:ddl;mm?Z@ddlAmBZBerddlCmDZDddlEmFZFmGZGmHZHmIZImJZJmKZKddlLmMZMddlNZNd2ddZOGddde:jPZQ   d3d4d'd(ZRd5d6d+d,ZSd7d8d-d.ZTd9d0d1ZUdS):) annotations) timedeltaN) TYPE_CHECKINGcast)libtslibs) NaTNaTTypeTick Timedeltaastype_overflowsafeget_supported_dtypeiNaTis_supported_dtypeperiods_per_second)cast_from_unit_vectorized)get_timedelta_daysget_timedelta_field)array_to_timedelta64floordiv_object_arrayints_to_pytimedeltaparse_timedelta_unittruediv_object_array)function)validate_endpoints) TD64NS_DTYPEis_float_dtypeis_integer_dtypeis_object_dtype is_scalaris_string_dtype pandas_dtype)ExtensionDtype)isna)nanops roperator)datetimelike_accumulations) datetimelike)generate_regular_range)unpack_zerodim_and_defer)Iterator)AxisIntDateTimeErrorChoicesDtypeObjNpDtypeSelfnpt DataFramenamestralias docstringcs*dfdd }||_d|d|_t|S)Nreturn np.ndarraycsH|j}dkrt||jd}nt||jd}|jr"|j|ddd}|S)Ndaysresofloat64) fill_valueconvert)asi8r_cresor_hasna_maybe_mask_results)selfvaluesresultr5O/var/www/html/env/lib/python3.10/site-packages/pandas/core/arrays/timedeltas.pyfRsz_field_accessor..f )r7r8)__name____doc__property)r3r5r6rIrGrFrH_field_accessorQsrNcs*eZdZUdZdZeddZeeje fZ ddZ dZ e dd d Zd ZgZd ed<gZd ed<dgZd ed<gdZd ed<eeedgZd ed<gdZd ed<dddZe dddZd ZeZed!d"Zed efdfd(d) Zed d*d+dd.d/Zed d*e j!d d0dd1d2Z"e dd d3dd5d6Z#dd7d8Z$dd9d:Z%dddDdEddMdNZ)d d d dOd*d>dPddRdSZ*d>dTdfdWdXZ+dddZd[Z,dd d\dd`daZ-dbdcZ.e/ddddedfZ0e0Z1dgdhZ2didjZ3ddldmZ4e/dndodpZ5e/dqdrdsZ6e/dtdudvZ7e/dwdxdyZ8e/dzd{d|Z9e/d}d~dZ:e/dddZ;e/dddZdddZ?dddZ@dddZAeBCdZDeEddeDZFeBCdZGeEddeGZHeBCdZIeEddeIZJeBCdZKeEddeKZLe dddZMZNS)TimedeltaArrayal Pandas ExtensionArray for timedelta data. .. warning:: TimedeltaArray is currently experimental, and its API may change without warning. In particular, :attr:`TimedeltaArray.dtype` is expected to change to be an instance of an ``ExtensionDtype`` subclass. Parameters ---------- values : array-like The timedelta data. dtype : numpy.dtype Currently, only ``numpy.dtype("timedelta64[ns]")`` is accepted. freq : Offset, optional copy : bool, default False Whether to copy the underlying array of data. Attributes ---------- None Methods ------- None Examples -------- >>> pd.arrays.TimedeltaArray._from_sequence(pd.TimedeltaIndex(['1h', '2h'])) ['0 days 01:00:00', '0 days 02:00:00'] Length: 2, dtype: timedelta64[ns] timedeltaarrayrnscCs t|dS)Nm)r is_np_dtypexrGrGrHs zTimedeltaArray.)r timedelta64r7type[Timedelta]cCstSNr rCrGrGrH _scalar_typezTimedeltaArray._scalar_typeiz list[str] _other_ops _bool_opsfreq _object_ops)r9seconds microseconds nanoseconds _field_opsunit_datetimelike_ops)to_pytimedelta total_secondsroundfloorceilas_unit_datetimelike_methodsrUnp.timedelta64Timedelta | NaTTypecCs(|d}|tjkr tStj||jdS)Ni8r:)viewr_valuer _from_value_and_resor@)rCrUyrGrGrH _box_funcs  zTimedeltaArray._box_funcnp.dtype[np.timedelta64]cCs|jjS)a3 The dtype for the TimedeltaArray. .. warning:: A future version of pandas will change dtype to be an instance of a :class:`pandas.api.extensions.ExtensionDtype` subclass, not a ``numpy.dtype``. Returns ------- numpy.dtype )_ndarraydtyper[rGrGrHryszTimedeltaArray.dtypeNcCs(t|}t|j||jkrtd|S)Nz'Values resolution does not match dtype.)_validate_td64_dtypery ValueError)clsrDryrGrGrH_validate_dtypes   zTimedeltaArray._validate_dtyperDnpt.NDArray[np.timedelta64] Tick | Noneryr/cstt|dsJt|rJt|tjsJt|||jks"J|dus-t|t s-Jt j ||d}||_ |S)NrR)rDry) rrSr is_unitless isinstancenpndarraytyperyr super _simple_new_freq)r|rDr`ryrE __class__rGrHrszTimedeltaArray._simple_newFrycopyrboolcCsF|rt|}t||dd\}}|durt||dd}|j||j|dS)NrrfFrryr`)rzsequence_to_td64nsr rry)r|dataryrr`rGrGrH_from_sequences zTimedeltaArray._from_sequence)ryrr`rfcCsb|rt|}|dvs Jt|||d\}}|dur t||dd}|j||j|d}||i|S)zo _from_sequence_not_strict but without responsibility for finding the result's `freq`. YruMrNFrr)rzrr rry_maybe_pin_freq)r|rryrr`rf inferred_freqrErGrGrH_from_sequence_not_stricts  z(TimedeltaArray._from_sequence_not_strictrf str | Nonec CsXt|}|durtdd|||fDrtdt||||dkr'td|dur2t|d}|dur=t|d}|durJ|dvrItdnd}|dur[|dur[|j|d d }|durj|durj|j|d d }t|\}}|dur~t |||||d } n t |j |j | d } |s| d d} |s| dd} | d|d} |j| | j|dS)Ncss|]}|duVqdSrYrG.0rUrGrGrH sz1TimedeltaArray._generate_range..z1Must provide freq argument if no data is suppliedzVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedrQ)smsusrQz+'unit' must be one of 's', 'ms', 'us', 'ns'F)round_okrrqzm8[]r)dtlvalidate_periodsanyr{comcount_not_noner rmrr(rlinspacersastyperrrry) r|startendperiodsr`closedrf left_closed right_closedindex td64valuesrGrGrH_generate_ranges<     zTimedeltaArray._generate_rangecCsLt||js|turtd|||turt|j|jS| |jj S)Nz'value' should be a Timedelta.) rr\rr{_check_compatible_withrrWrsrfrmasm8rCvaluerGrGrH _unbox_scalar?s  zTimedeltaArray._unbox_scalarcCst|SrYrZrrGrGrH_scalar_from_stringHsz"TimedeltaArray._scalar_from_stringNonecCsdSrYrGrCotherrGrGrHrKr]z%TimedeltaArray._check_compatible_withTcCst|}t|dr;||jkr|r|S|St|r/t|j|dd}t|j ||j|j dSt d|jd|dt j j|||dS)NrRFrrzCannot convert from z to z1. Supported resolutions are 's', 'ms', 'us', 'ns')r!rrSryrrr rxrrr`r{rDatetimeLikeArrayMixinr)rCryr res_valuesrGrGrHrRs   zTimedeltaArray.astyper*c cs|jdkrtt|D]}||Vq dS|j}t|}d}||d}t|D]}||}t|d||}t|||dd}|EdHq)dS)Nri'Tbox)ndimrangelenrxminr) rCirlength chunksizechunksstart_iend_i convertedrGrGrH__iter__ms     zTimedeltaArray.__iter__r)axisryoutkeepdimsinitialskipna min_countrAxisInt | NoneNpDtype | Nonerrrintc Cs6td||||dtj|j|||d}|||S)NrG)ryrrr)rrr)nv validate_sumr$nansumrx_wrap_reduction_result) rCrryrrrrrrErGrGrHsums   zTimedeltaArray.sumr)rryrddofrrrcCsRtjd|||dddtj|j|||d}|dus|jdkr$||S||S)NrG)ryrrstd)fname)rrrr)rvalidate_stat_ddof_funcr$nanstdrxrrv_from_backing_data)rCrryrrrrrErGrGrHrs   zTimedeltaArray.std)rr3r4c sj|dkr!tt|}||jfd|i|}t|j|d|jdS|dkr)tdtj |fd|i|S)Ncumsumr)r`rycumprodz$cumprod not supported for Timedelta.) getattrr&rxrrrry TypeErrorr _accumulate)rCr3rkwargsoprErrGrHrs zTimedeltaArray._accumulateboxedcCsddlm}||ddS)Nrget_format_timedelta64Tr)pandas.io.formats.formatr)rCrrrGrGrH _formatters  zTimedeltaArray._formatter)na_rep date_formatr str | floatnpt.NDArray[np.object_]cKs*ddlm}|||}t|dd|jS)Nrrr)rrr frompyfuncrx)rCrrrr formatterrGrGrH_format_native_typess  z#TimedeltaArray._format_native_typescCs.t|trJtdt|jdt|j)Nzcannot add the type z to a )rr rrrKrrGrGrH _add_offsetszTimedeltaArray._add_offset__mul__cs8tr;|j}|jjdkrtdtjd}|jdur0ts0|j}|j dkr0d}t|j ||j|dSt dsEt tt|krXtjdsXtdtjr}|jfddtt|D}t |}t|j ||jd S|j}|jjdkrtdtjt|j ||jd S) NrRzCannot multiply with rrryz$Cannot multiply with unequal lengthscsg|] }||qSrGrGrnarrrrGrH z*TimedeltaArray.__mul__..ry)rrxrykindrrrKr`r#rrhasattrrarrayrrrSr{rr)rCrrEr`rGrrHrs.          zTimedeltaArray.__mul__cCst||jr(t|}td|tur"tj|jtjd}| tj |S||j |S|t j t jfvr@tdt|jdt|j||j |}d}|jdur_|j|}|jdkr_|jjdkr_d}t|j||j|dS)zv Shared logic for __truediv__, __rtruediv__, __floordiv__, __rfloordiv__ with scalar 'other'. rprzCannot divide z by Nrr)r_recognized_scalarsr rrremptyshaper<fillnanrxr%rtruediv rfloordivrrrKr`nanosrry)rCrrresrEr`rGrGrH_scalar_divlike_ops$      z!TimedeltaArray._scalar_divlike_opcCs0t|ds t|}t|t|krtd|S)Nryz*Cannot divide vectors with unequal lengths)rrrrr{rrGrGrH_cast_divlike_op's  zTimedeltaArray._cast_divlike_opnp.ndarray | SelfcCs||jt|}t|jst|jr%|tjtjfvr%t |j ||jdS|tjt j fvrG| t |B}|rG|tj}t||tj|S)z Shared logic for __truediv__, __floordiv__, and their reversed versions with timedelta64-dtype ndarray other. r)rxrasarrayrryroperatortruedivfloordivrrr%rr#rrr<putmaskr)rCrrrEmaskrGrGrH_vector_divlike_op0s z!TimedeltaArray._vector_divlike_op __truediv__cCstj}t|r |||S||}t|jds#t|js#t |jr)| ||St |jrZt |}|jdkrRddt||D}dd|D}t j|dd}|St|j|}|StS)NrRrcSsg|]\}}||qSrGrGrleftrightrGrGrHrXz.TimedeltaArray.__truediv__..cSg|]}|ddqSrrreshaperrGrGrHrYrrr)rrrr r rrSryrrrrrrrzip concatenaterrxNotImplementedrCrrres_cols res_cols2rErGrGrHrFs*        zTimedeltaArray.__truediv__ __rtruediv__csrtj}tr |Stjdr|St jr7fddt t D}t |StS)NrRcsg|] }||qSrGrGrrrCrGrHrrrz/TimedeltaArray.__rtruediv__..)r%rrr r rrSryrrrrrrr!)rCrr result_listrGr&rHr%cs     zTimedeltaArray.__rtruediv__ __floordiv__cCstj}t|r |||S||}t|jds#t|js#t |jr)| ||St |jr`t |}|jdkrQddt||D}dd|D}t j|dd}nt|j|}|jtks^J|StS)NrRrcSsg|]\}}||qSrGrGrrGrGrHrrz/TimedeltaArray.__floordiv__..cSrrrrrGrGrHrrrr)rrrr r rrSryrrrrrrrrr rrxobjectr!r"rGrGrHr(xs*        zTimedeltaArray.__floordiv__ __rfloordiv__csvtj}tr |Stjdr|St jr9fddt t D}t |}|StS)NrRcsg|] }||qSrGrGrr&rGrHrrz0TimedeltaArray.__rfloordiv__..)r%rrr r rrSryrrrrrrr!)rCrrr'rErGr&rHr*s     zTimedeltaArray.__rfloordiv____mod__cCs$t||jr t|}||||SrYrrr rrGrGrHr+ zTimedeltaArray.__mod____rmod__cCs$t||jr t|}||||SrYr,rrGrGrHr.r-zTimedeltaArray.__rmod__ __divmod__cCs0t||jr t|}||}|||}||fSrYr,rCrres1res2rGrGrHr/  zTimedeltaArray.__divmod__ __rdivmod__cCs0t||jr t|}||}|||}||fSrYr,r0rGrGrHr4r3zTimedeltaArray.__rdivmod__cCs0d}|jdur |j }t|j|j |j|dSNr)r`rrrxry)rCr`rGrGrH__neg__s zTimedeltaArray.__neg__cCst|j|j|j|jdSr5)rrrxrryr`r[rGrGrH__pos__szTimedeltaArray.__pos__cCst|jt|j|jdS)Nr)rrrabsrxryr[rGrGrH__abs__szTimedeltaArray.__abs__npt.NDArray[np.float64]cCst|j}|j|j|ddS)a{ Return total duration of each element expressed in seconds. This method is available directly on TimedeltaArray, TimedeltaIndex and on Series containing timedelta values under the ``.dt`` namespace. Returns ------- ndarray, Index or Series When the calling object is a TimedeltaArray, the return type is ndarray. When the calling object is a TimedeltaIndex, the return type is an Index with a float64 dtype. When the calling object is a Series, the return type is Series of type `float64` whose index is the same as the original. See Also -------- datetime.timedelta.total_seconds : Standard library version of this method. TimedeltaIndex.components : Return a DataFrame with components of each Timedelta. Examples -------- **Series** >>> s = pd.Series(pd.to_timedelta(np.arange(5), unit='d')) >>> s 0 0 days 1 1 days 2 2 days 3 3 days 4 4 days dtype: timedelta64[ns] >>> s.dt.total_seconds() 0 0.0 1 86400.0 2 172800.0 3 259200.0 4 345600.0 dtype: float64 **TimedeltaIndex** >>> idx = pd.to_timedelta(np.arange(5), unit='d') >>> idx TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[ns]', freq=None) >>> idx.total_seconds() Index([0.0, 86400.0, 172800.0, 259200.0, 345600.0], dtype='float64') N)r=)rr@rBr?)rCppsrGrGrHris 6zTimedeltaArray.total_secondscCs t|jS)a  Return an ndarray of datetime.timedelta objects. Returns ------- numpy.ndarray Examples -------- >>> 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.to_pytimedelta() array([datetime.timedelta(days=1), datetime.timedelta(days=2), datetime.timedelta(days=3)], dtype=object) )rrxr[rGrGrHrhs zTimedeltaArray.to_pytimedeltaaCNumber of days for each element. Examples -------- For Series: >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='d')) >>> ser 0 1 days 1 2 days 2 3 days dtype: timedelta64[ns] >>> ser.dt.days 0 1 1 2 2 3 dtype: int64 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.days Index([0, 10, 20], dtype='int64')r9aNumber of seconds (>= 0 and less than 1 day) for each element. Examples -------- For Series: >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='s')) >>> ser 0 0 days 00:00:01 1 0 days 00:00:02 2 0 days 00:00:03 dtype: timedelta64[ns] >>> ser.dt.seconds 0 1 1 2 2 3 dtype: int32 For TimedeltaIndex: >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='s') >>> tdelta_idx TimedeltaIndex(['0 days 00:00:01', '0 days 00:00:02', '0 days 00:00:03'], dtype='timedelta64[ns]', freq=None) >>> tdelta_idx.seconds Index([1, 2, 3], dtype='int32')rbaNumber of microseconds (>= 0 and less than 1 second) for each element. Examples -------- For Series: >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='us')) >>> ser 0 0 days 00:00:00.000001 1 0 days 00:00:00.000002 2 0 days 00:00:00.000003 dtype: timedelta64[ns] >>> ser.dt.microseconds 0 1 1 2 2 3 dtype: int32 For TimedeltaIndex: >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='us') >>> tdelta_idx TimedeltaIndex(['0 days 00:00:00.000001', '0 days 00:00:00.000002', '0 days 00:00:00.000003'], dtype='timedelta64[ns]', freq=None) >>> tdelta_idx.microseconds Index([1, 2, 3], dtype='int32')rcaNumber of nanoseconds (>= 0 and less than 1 microsecond) for each element. Examples -------- For Series: >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='ns')) >>> ser 0 0 days 00:00:00.000000001 1 0 days 00:00:00.000000002 2 0 days 00:00:00.000000003 dtype: timedelta64[ns] >>> ser.dt.nanoseconds 0 1 1 2 2 3 dtype: int32 For TimedeltaIndex: >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='ns') >>> tdelta_idx TimedeltaIndex(['0 days 00:00:00.000000001', '0 days 00:00:00.000000002', '0 days 00:00:00.000000003'], dtype='timedelta64[ns]', freq=None) >>> tdelta_idx.nanoseconds Index([1, 2, 3], dtype='int32')rdr2cs`ddlm}gd|j}|rfddndd|fdd|Dd }|s.|d }|S) a Return a DataFrame of the individual resolution components of the Timedeltas. The components (days, hours, minutes seconds, milliseconds, microseconds, nanoseconds) are returned as columns in a DataFrame. Returns ------- DataFrame Examples -------- >>> tdelta_idx = pd.to_timedelta(['1 day 3 min 2 us 42 ns']) >>> tdelta_idx TimedeltaIndex(['1 days 00:03:00.000002042'], dtype='timedelta64[ns]', freq=None) >>> tdelta_idx.components days hours minutes seconds milliseconds microseconds nanoseconds 0 1 0 3 0 0 2 42 rr1)r9hoursminutesrb millisecondsrcrdcst|r tjgtS|jSrY)r#rrr componentsrTcolumnsrGrHrIsz$TimedeltaArray.components..fcSs|jSrY)r?rTrGrGrHrIscsg|]}|qSrGrGr)rIrGrHrsz-TimedeltaArray.components..r@int64)pandasr2rAr)rCr2hasnansrErG)rArIrHr?s   zTimedeltaArray.components)r7rX)rUror7rp)r7rw)rDr~r`rryrwr7r/)rrr7r/rY)rfrr7r/)r7ro)r7rp)r7r)T)rr)r7r*) rrryrrrrrrr) rrryrrrrrrr)r3r4rr)F)rr)rrr7r)r7r/)r7r )r7rO)r7r:)r7r)r7r2)OrK __module__ __qualname__rL_typrrW_internal_fill_valuerr r_is_recognized_dtype_infer_matchesrMr\__array_priority__r^__annotations__r_rarergrnrvryrr_default_dtype classmethodr}rrr no_defaultrrrrrrrrrrrrrr)r__rmul__r r rrr%r(r*r+r.r/r4r6r7r9rirhtextwrapdedentdays_docstringrNr9seconds_docstringrbmicroseconds_docstringrcnanoseconds_docstringrdr? __classcell__rGrGrrHrOgs %           0     ))             9 rOFraiserrerrorsr,r7tuple[np.ndarray, Tick | None]cCsr|dvsJd}|durt|}tj||dd\}}t|tr"|j}|jtks,t|jr6t |||d}d}nat |jrIt ||d\}}|oG| }nNt |jrst|jt r[|j}|j}nt|}t||ped}t||<|d }d}n$t|jd rt|jst|j}t||dd }d}n td |jd |st|}ntj||d}|jjd ksJ|jdksJ||fS)a Parameters ---------- data : list-like copy : bool, default False unit : str, optional The timedelta unit to treat integers as multiples of. For numeric data this defaults to ``'ns'``. Must be un-specified if the data contains a str and ``errors=="raise"``. errors : {"raise", "coerce", "ignore"}, default "raise" How to handle elements that cannot be converted to timedelta64[ns]. See ``pandas.to_timedelta`` for details. Returns ------- converted : numpy.ndarray The sequence converted to a numpy array with dtype ``timedelta64[ns]``. inferred_freq : Tick or None The inferred frequency of the sequence. Raises ------ ValueError : Data cannot be converted to timedelta64[ns]. Notes ----- Unlike `pandas.to_timedelta`, if setting ``errors=ignore`` will not cause errors to be ignored; they are caught and subsequently ignored at a higher level. rNrO)cls_namerfrYFrrQzm8[ns]rRrzdtype z' cannot be converted to timedelta64[ns]rm8)rr!ensure_arraylike_for_datetimelikerrOr`ryr)r _objects_to_td64nsr_ints_to_td64nsrr"_mask_datarisnanrrrrrrSrr r rrrr)rrrfrYr copy_mader new_dtyperGrGrHrsJ $          rrQrfcCsxd}|dur|nd}|jtjkr|tj}d}|dkr3d|d}||}t|td}d}||fS|d}||fS) a Convert an ndarray with integer-dtype to timedelta64[ns] dtype, treating the integers as multiples of the given timedelta unit. Parameters ---------- data : numpy.ndarray with integer-dtype unit : str, default "ns" The timedelta unit to treat integers as multiples of. Returns ------- numpy.ndarray : timedelta64[ns] array converted from data bool : whether a copy was made FNrQTz timedelta64[rrtimedelta64[ns])ryrrBrrrr r)rrfrd dtype_strrGrGrHr`Fs      r`cCs(tj|tjd}t|||d}|dS)aR Convert a object-dtyped or string-dtyped array into an timedelta64[ns]-dtyped array. Parameters ---------- data : ndarray or Index unit : str, default "ns" The timedelta unit to treat integers as multiples of. Must not be specified if the data contains a str. errors : {"raise", "coerce", "ignore"}, default "raise" How to handle elements that cannot be converted to timedelta64[ns]. See ``pandas.to_timedelta`` for details. Returns ------- numpy.ndarray : timedelta64[ns] array converted from data Raises ------ ValueError : Data cannot be converted to timedelta64[ns]. Notes ----- Unlike `pandas.to_timedelta`, if setting `errors=ignore` will not cause errors to be ignored; they are caught and subsequently ignored at a higher level. rr\rf)rrobject_rrr)rrfrYrDrErGrGrHr_ns r_r-cCsRt|}|tdkrd}t|t|dstd|dt|s'td|S)Nr]zhPassing in 'timedelta' dtype with no precision is not allowed. Please pass in 'timedelta64[ns]' instead.rRzdtype 'z,' is invalid, should be np.timedelta64 dtypez;Supported timedelta64 resolutions are 's', 'ms', 'us', 'ns')r!rryr{rrSr)rymsgrGrGrHrzs rz)r3r4r5r4r6r4)FNrX)rrrYr,r7rZ)rQ)rfr4)NrX)rYr,)r7r-)V __future__rdatetimerrtypingrrnumpyr pandas._libsrrpandas._libs.tslibsrr r r r r rrrpandas._libs.tslibs.conversionrpandas._libs.tslibs.fieldsrrpandas._libs.tslibs.timedeltasrrrrrpandas.compat.numpyrrpandas.util._validatorsrpandas.core.dtypes.commonrrrrrr r!pandas.core.dtypes.dtypesr"pandas.core.dtypes.missingr# pandas.corer$r%pandas.core.array_algosr&pandas.core.arraysr'rpandas.core.arrays._rangesr(pandas.core.commoncorecommonrpandas.core.ops.commonr)collections.abcr*pandas._typingr+r,r-r.r/r0rCr2rQrN TimelikeOpsrOrr`r_rzrGrGrGrHsT ,   $          ` ($