j>ddlmZddlmZddlZddlmZmZmZddl Z ddl m Z m Z ddlmZmZmZmZmZmZmZmZmZmZmZddlmZddlmZmZdd lm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z'dd l(m)Z)dd l*m+Z+dd l,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7ddl8m9Z9ddl:m;Z;mZ>ddl?m@ZAddlBmCZCddlDmEcmFZGddlHmIZIerddlJmKZKmLZLddlMmNZNmOZOmPZPmQZQmRZRmSZSddlTmUZUddlVZVd1dZWe)dGddeAjXZY d2d3d(ZZd4d5d,Z[ d6d7d.Z\d8d0Z]dS)9) annotations) timedeltaN) TYPE_CHECKINGSelfcast)libtslibs) DayNaTNaTTypeTick Timedeltaastype_overflowsafeget_supported_dtypeiNaTis_supported_dtypeperiods_per_second to_offset)cast_from_unit_vectorized)get_timedelta_daysget_timedelta_field)array_to_timedelta64floordiv_object_arrayints_to_pytimedeltaparse_timedelta_unittruediv_object_array)function) set_module)validate_endpoints) TD64NS_DTYPEis_float_dtypeis_integer_dtypeis_object_dtype is_scalaris_string_dtype pandas_dtype) ArrowDtypeBaseMaskedDtypeExtensionDtype)isna)nanops roperator)datetimelike_accumulations) datetimelike)generate_regular_range)unpack_zerodim_and_defer)CallableIterator)AxisIntDateTimeErrorChoicesDtypeObjNpDtypenptTimeUnit DataFramenamestralias docstringcRdfd }||_d|d|_t|S)Nreturn np.ndarrayc|j}dkrt||j}nt||j}|jr||dd}|S)Ndaysresofloat64) fill_valueconvert)asi8r_cresor_hasna_maybe_mask_results)selfvaluesresultr=s KC:\Projects\DSCons\.venv\Lib\site-packages\pandas\core\arrays\timedeltas.pyfz_field_accessor..fZss F??'T[AAAFF )T[IIIF ; --4.F  )r@rA)__name____doc__property)r;r=r>rQs ` rP_field_accessorrWYsH AJ"Y"""AI A;;rRz pandas.arraysceZdZUdZdZeejefZ dZ de d<dZ e dwd Ze dxd Zd ZgZd e d<gZd e d<gdZd e d<eezddgzZd e d<gdZd e d<dydZe dzdZdZde d<edZedefd{fd$ Zedd%d&d|d)Zedd%ejdd*d|d+Z e d}d~d-Z!dwd.Z"dd/Z#dd1Z$ddd3Z%dd5Z&dddd%dd2d6d7dd?Z'dddd@d%d2dAddCZ(d2dDdfdGZ)dddIZ*dJddKddOZ+dPZ,e-dQddRZ.e.Z/dSZ0dTZ1ddVZ2e-dWdXZ3e-dYdZZ4e-d[d\Z5e-d]d^Z6e-d_d`Z7e-dadbZ8e-dcddZ9e-dedfZ:ddgZ;ddhZddlZ?e@jAdmZBeCdndneBZDe@jAdoZEeCdpdpeEZFe@jAdqZGeCdrdreGZHe@jAdsZIeCdtdteIZJe ddvZKxZLS)TimedeltaArrayaa 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 ---------- data : array-like The timedelta data. dtype : numpy.dtype Currently, only ``numpy.dtype("timedelta64[ns]")`` is accepted. freq : Offset, optional Frequency of the data. copy : bool, default False Whether to copy the underlying array of data. Attributes ---------- None Methods ------- None See Also -------- Timedelta : Represents a duration, the difference between two dates or times. TimedeltaIndex : Immutable Index of timedelta64 data. to_timedelta : Convert argument to timedelta. Examples -------- >>> pd.arrays.TimedeltaArray._from_sequence(pd.TimedeltaIndex(["1h", "2h"])) ['0 days 01:00:00', '0 days 02:00:00'] Length: 2, dtype: timedelta64[us] timedeltaarrayc,tj|dS)Nm)r is_np_dtypexs rPzTimedeltaArray.sQRTWAXAXrRzCallable[[DtypeObj], bool]_is_recognized_dtype)r timedelta64r@np.timedelta64c6tjd|jS)Nr )nprbunitrMs rP_internal_fill_valuez#TimedeltaArray._internal_fill_values~eTY///rRtype[Timedelta]ctSNrrgs rP _scalar_typezTimedeltaArray._scalar_typesrRiz list[str] _other_ops _bool_ops)rCseconds microseconds nanoseconds _field_opsrffreq_datetimelike_ops)to_pytimedelta total_secondsroundfloorceilas_unit_datetimelike_methodsr_Timedelta | NaTTypec|d}|tjkrtStj||jS)Ni8rD)viewr _valuer_from_value_and_resorJ)rMr_ys rP _box_funczTimedeltaArray._box_funcs9 FF4LL  ??J-adkBBBBrRnp.dtype[np.timedelta64]c|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 )_ndarraydtypergs rPrzTimedeltaArray.dtypes"}""rRNTick | Day | None_freqct|}t|j||jkrtd|S)Nz'Values resolution does not match dtype.)_validate_td64_dtyper ValueError)clsrNrs rP_validate_dtypezTimedeltaArray._validate_dtypesB%U++V\*** FL FGG G rRrNnpt.NDArray[np.timedelta64]rrcrtj|dsJtj|rJt |t jsJt|||jksJ|t |ttfsJt ||}||_ |S)Nr\)rNr)rr]r is_unitless isinstancerendarraytyperr r super _simple_newr)rrNrtrrO __class__s rPrzTimedeltaArray._simple_newsuc*****%e,,,,,&"*--;;tF||;;- $$$$|z$s <<||<$$F%$@@  rRFrcopyrboolcd}|rAt|}tj|dkrtj|d}t |||\}}|t ||d}|||j|S)NintegerrrrfFrrrt) rr infer_dtypere datetime_datasequence_to_td64nsrrr)rdatarrrfrts rP_from_sequencezTimedeltaArray._from_sequences  2(//Et$$ 11'..q1'4dCCC d  &t5uEEEDt4:DAAArR)rrrtrfcT|rCt|}|2tj|dkrtj|d}|dvsJt |||\}}|t ||d}|||j|}| |i|S) zo _from_sequence_not_strict but without responsibility for finding the result's `freq`. NrrYrMrFrr) rrrrerrrrr_maybe_pin_freq)rrrrrtrf inferred_freqrOs rP_from_sequence_not_strictz(TimedeltaArray._from_sequence_not_stricts  2(//E| 5 5 B B'..q1?****0DtLLLm  &t5uEEEDTZmLLtR((( rRr8cNtj|}|+td|||fDrtdt j||||dkrtd|"t |d}|"t |d}|dvrtd||||d }||||d }t|\}}|t||||| } n3tj |j |j | d } |s | d d} |s | dd } | d|d} || | j|S)Nc3K|]}|duV dSrk.0r_s rP z1TimedeltaArray._generate_range..(s&IIaT IIIIIIrRz1Must provide freq argument if no data is suppliedzVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedns)smsusrz+'unit' must be one of 's', 'ms', 'us', 'ns'Fround_okrfrzm8[]r)dtlvalidate_periodsanyrcomcount_not_nonerr{rr/relinspacerastyperrr) rstartendperiodsrtclosedrf left_closed right_closedindex td64valuess rP_generate_rangezTimedeltaArray._generate_range#s&w// $>! \  *5#w4PPPEEK cj'BBII$OOE !""IE #2#JEZZ d .. z1AMMMrRct||js|turtd|||turt j|j|jS| |jdj S)Nz'value' should be a Timedelta.Fr) rrmr r_check_compatible_withrerbrrfr{asm8rMvalues rP _unbox_scalarzTimedeltaArray._unbox_scalarQs~%!233 ?S8H8H=>> > ##E*** C<<>%, :: :==U=;;@ @rRc t|Srkrlrs rP_scalar_from_stringz"TimedeltaArray._scalar_from_stringZsrRNonecdSrkrrMothers rPrz%TimedeltaArray._check_compatible_with]s rRTct|}tj|dr||jkr|r|S|St |rFt |j|d}t| ||j|j Std|jd|dtj |||S)Nr\FrrzCannot convert from z to z1. Supported resolutions are 's', 'ms', 'us', 'ns')r&rr]rrrrrrrrtrrDatetimeLikeArrayMixinr)rMrr res_valuess rPrzTimedeltaArray.astypeds U## ?5# & &  ""'99;;& !%(( 0ERRR Dzz--j&6TY.!F4:FF5FFF )00u40HHHrRr2c#RK|jdkr+tt|D] }||V dS|j}t|}d}||zdz}t|D]>}||z}t |dz|z|}t |||d}|Ed{V?dS)Nri'Tbox)ndimrangelenrminr) rMirlength chunksizechunksstart_iend_i converteds rP__iter__zTimedeltaArray.__iter__s 9q==3t99%%  1g   =DYYFI )Q.F6]] % %i-QUi/88/WU]0CNNN $$$$$$$$$  % %rRr)axisroutkeepdimsinitialskipna min_countrAxisInt | NoneNpDtype | Nonerrrintctjd||||dtj|j|||}|||S)Nr)rrrr)rrr)nv validate_sumr+nansumr_wrap_reduction_result) rMrrrrrrrrOs rPsumzTimedeltaArray.sumsd  %gVV    MVy   **4888rRr)rrrddofrrrctjd|||ddtj|j|||}| |jdkr||S||S)Nr)rrrstd)fname)rrrr)rvalidate_stat_ddof_funcr+nanstdrrr_from_backing_data)rMrrrrrrrOs rPrzTimedeltaArray.stds " %BB%    t}4TRRR <49>>>>&)) )&&v...rR)rr;r<c 4|dkratt|}||jfd|i|}t ||d|jS|dkrtdtj |fd|i|S)Ncumsumr)rtrcumprodz$cumprod not supported for Timedelta.) getattrr-rrrrr TypeErrorr _accumulate)rMr;rkwargsoprOrs rPrzTimedeltaArray._accumulates 8  3T::BR **,,FFVFvFFF::))&t4:)NN N Y  BCC C'577&tEEFEfEE ErRboxedc(ddlm}||dS)Nrget_format_timedelta64Tr)pandas.io.formats.formatr )rMr r s rP _formatterzTimedeltaArray._formatters*CCCCCC%%d5555rRr )na_rep date_formatr str | floatnpt.NDArray[np.object_]c nddlm}|||}tj|dd|jS)Nrr r)rr re frompyfuncr)rMrrrr  formatters rP_format_native_typesz#TimedeltaArray._format_native_typessM DCCCCC+*488 .r}Y1--dm<<z*TimedeltaArray.__mul__..s&BBBAc!fuQx'BBBrRr)r$ris_boolrrrkindrrTrtr*rrhasattrrearrayrr'r(NotImplementedrr]rr#r)rMrrOrtrs ` @rPrzTimedeltaArray.__mul__st U   Q{5!! ' ''' ]U*F| C'' NU 8L N NOOODy$T%[[$y5(6Q;;D::))& 4)PP Pug&& $HUOOE ; s " "#DJ###  ekJ#@ A A "! ! u::T " "3?5;+L+L "CDD D 5; ' ' F-CBBBBBs4yy1A1ABBBFXf%%F::))& )EE E& <  # #JDKK4HJJKK KDzz%%fFL%AAArRct||jr}t|}td|turFt j|jt j}| t j |S||j |S|tj tjfvr9tdt!|jdt!|j||j |}d}|jt|jt&r[|jj|zdkrt'|jj|z}n5t+t|jj|z }n |j|z }|jdkr|jjdkrd}t!|||j|S) zv Shared logic for __truediv__, __rtruediv__, __floordiv__, __rfloordiv__ with scalar 'other'. r}r!zCannot divide z by Nr)rCr)r_recognized_scalarsrrr reemptyshaperFfillnanrr,rtruediv rfloordivrrrTrtr rrnanosrr)rMrr resrOrts rP_scalar_divlike_opz!TimedeltaArray._scalar_divlike_op s eT5 6 6( Qe$$E)511S88htz<<<    2dmU++ + i()*=>>>TT%[[%9TTtDzz?RTTR u--FDy$di---y{U*a//"49;%#788( )D)D)DEEM9u,D:??ty!';'; D::))& 4)PP PrRct|dstj|}t|t|krt d|S)Nrz*Cannot divide vectors with unequal lengths)r$rer%rrrs rP_cast_divlike_opzTimedeltaArray._cast_divlike_opOsLug&& $HUOOE u::T " "IJJ J rRnp.ndarray | SelfcD||jtj|}t|jst |jrC|t jt jfvr)t| ||jS|t jtj fvrw| t|z}|r?|tj}tj||tj|S)z Shared logic for __truediv__, __floordiv__, and their reversed versions with timedelta64-dtype ndarray other. r!)rreasarrayr"rr!operatortruedivfloordivrrr,r.r*rrrFputmaskr,)rMrr rOmasks rP_vector_divlike_opz!TimedeltaArray._vector_divlike_opXs DM2:e#4#455 U[ ) ) F^EK-H-H Fb    U O O ::))& )EE E (#Y%89 9 999;;e,Dxxzz 1rz22 64000 rR __truediv__c^tj}t|r|||S||}t j|jds(t|jst|jr| ||St|jrutj |}|jdkr?dt||dD}d|D}tj|d}nt#|j|}|St&S) Nr\rcg|] \}}||z  Srrrleftrights rPr z.TimedeltaArray.__truediv__..s-%0T5D5LrRTstrictc:g|]}|ddSrrreshapers rPr z.TimedeltaArray.__truediv__..&@@@!QYYq"--@@@rRrr)r7r8r$r1r3rr]rr"r!r<r#rer6rzip concatenaterrr&rMrr res_cols res_cols2rOs rPr=zTimedeltaArray.__truediv__ns<  U   6**5"55 5%%e,, OEK - - 6 ,, 6ek** 6 **5"55 5 5; ' ' "Ju%%Ey1}}47eD4Q4Q4QA@x@@@  :::-dmUCCM" !rR __rtruediv__ctj}tr|St jjdr|Stjr=fdttD}tj |StS)Nr\c2g|]}||z SrrrrrrMs rPr z/TimedeltaArray.__rtruediv__..s&HHH!58d1g-HHHrR)r,r-r$r1r3rr]rr<r#rrrer%r&)rMrr  result_lists`` rPrPzTimedeltaArray.__rtruediv__s  U   6**5"55 5%%e,, ?5; , , "**5"55 5 U[ ) ) "IHHHHuSYY7G7GHHHK8K(( (" !rR __floordiv__ctj}t|r|||S||}t j|jds(t|jst|jr| ||St|jrtj |}|jdkr?dt||dD}d|D}tj|d}nt#|j|}|jt&ksJ|St(S) Nr\rcg|] \}}||z Srrr@s rPr z/TimedeltaArray.__floordiv__..s-&1dEDEMrRTrCc:g|]}|ddSrFrGrs rPr z/TimedeltaArray.__floordiv__..rIrRrrJ)r7r9r$r1r3rr]rr"r!r<r#rer6rrKrLrrobjectr&rMs rPrUzTimedeltaArray.__floordiv__sM   U   6**5"55 5%%e,, OEK - - " ,, "ek** " **5"55 5 U[ ) ) "Ju%%Ey1}}58uT5R5R5RA@x@@@  :::.t}eDD<6))))M" !rR __rfloordiv__ctj}tr|St jjdr|Stjr?fdttD}tj |}|StS)Nr\c2g|]}||zSrrrSs rPr z0TimedeltaArray.__rfloordiv__..s&III158tAw.IIIrR)r,r.r$r1r3rr]rr<r#rrrer%r&)rMrr rTrOs`` rPrZzTimedeltaArray.__rfloordiv__s   U   6**5"55 5%%e,, ?5; , , "**5"55 5 U[ ) ) "IIIIIc$ii8H8HIIIKXk**FM" !rR__mod__c`t||jrt|}|||z|zz Srkrr(rrs rPr]zTimedeltaArray.__mod__s: eT5 6 6 %e$$Etu}---rR__rmod__c`t||jrt|}|||z|zz Srkr_rs rPr`zTimedeltaArray.__rmod__s: eT5 6 6 %e$$E ---rR __divmod__clt||jrt|}||z}|||zz }||fSrkr_rMrres1res2s rPrbzTimedeltaArray.__divmod__sG eT5 6 6 %e$$Eu}dUl"TzrR __rdivmod__clt||jrt|}||z}|||zz }||fSrkr_rds rPrgzTimedeltaArray.__rdivmod__sG eT5 6 6 %e$$E}td{"TzrRcd}|j|j }t||j |j|SNr)rtrrrr)rMrts rP__neg__zTimedeltaArray.__neg__s? 9 I:DDzz%%t}nDJT%RRRrRct||j|j|jSrj)rrrrrrtrgs rP__pos__zTimedeltaArray.__pos__s>Dzz%% M    &   rRct|tj|j|jS)Nr!)rrreabsrrrgs rP__abs__zTimedeltaArray.__abs__s/Dzz%%bfT]&;&;4:%NNNrRnpt.NDArray[np.float64]cht|j}||j|z dS)ay 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[s] >>> 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[s]', freq=None) >>> idx.total_seconds() Index([0.0, 86400.0, 172800.0, 259200.0, 345600.0], dtype='float64') N)rG)rrJrLrI)rMppss rPrwzTimedeltaArray.total_secondss3l!--'' CD'IIIrRc*t|jS)a; Return an ndarray of datetime.timedelta objects. Returns ------- numpy.ndarray A NumPy ``timedelta64`` object representing the same duration as the original pandas ``Timedelta`` object. The precision of the resulting object is in nanoseconds, which is the default time resolution used by pandas for ``Timedelta`` objects, ensuring high precision for time-based calculations. See Also -------- to_timedelta : Convert argument to timedelta format. Timedelta : Represents a duration between two dates or times. DatetimeIndex: Index of datetime64 data. Timedelta.components : Return a components namedtuple-like of a single timedelta. Examples -------- >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit="D") >>> tdelta_idx TimedeltaIndex(['1 days', '2 days', '3 days'], dtype='timedelta64[s]', freq=None) >>> tdelta_idx.to_pytimedelta() array([datetime.timedelta(days=1), datetime.timedelta(days=2), datetime.timedelta(days=3)], dtype=object) >>> tidx = pd.TimedeltaIndex(data=["1 days 02:30:45", "3 days 04:15:10"]) >>> tidx TimedeltaIndex(['1 days 02:30:45', '3 days 04:15:10'], dtype='timedelta64[us]', freq=None) >>> tidx.to_pytimedelta() array([datetime.timedelta(days=1, seconds=9045), datetime.timedelta(days=3, seconds=15310)], dtype=object) )rrrgs rPrvzTimedeltaArray.to_pytimedelta@sN#4=111rRa8Number of days for each element. See Also -------- Series.dt.seconds : Return number of seconds for each element. Series.dt.microseconds : Return number of microseconds for each element. Series.dt.nanoseconds : Return number of nanoseconds 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[s] >>> 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[us]', freq=None) >>> tdelta_idx.days Index([0, 10, 20], dtype='int64')rCa2Number of seconds (>= 0 and less than 1 day) for each element. See Also -------- Series.dt.seconds : Return number of seconds for each element. Series.dt.nanoseconds : Return number of nanoseconds 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[s] >>> 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[s]', freq=None) >>> tdelta_idx.seconds Index([1, 2, 3], dtype='int32')rpaNumber of microseconds (>= 0 and less than 1 second) for each element. See Also -------- pd.Timedelta.microseconds : Number of microseconds (>= 0 and less than 1 second). pd.Timedelta.to_pytimedelta.microseconds : Number of microseconds (>= 0 and less than 1 second) of a datetime.timedelta. 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[us] >>> 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[us]', freq=None) >>> tdelta_idx.microseconds Index([1, 2, 3], dtype='int32')rqaNumber of nanoseconds (>= 0 and less than 1 microsecond) for each element. See Also -------- Series.dt.seconds : Return number of seconds for each element. Series.dt.microseconds : Return number of nanoseconds 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')rrr:cddlm}gd|j}|rfdnd|fd|D}|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 See Also -------- TimedeltaIndex.total_seconds : Return total duration expressed in seconds. Timedelta.components : Return a components namedtuple-like of a single timedelta. 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 rr9)rChoursminutesrp millisecondsrqrrcjt|rtjgtzS|jSrk)r*rer,r components)r_columnss rPrQz$TimedeltaArray.components..f/s.773F8c'll22|#rRc|jSrk)rzr^s rPrQz$TimedeltaArray.components..f6s |#rRc&g|] }|Srr)rr_rQs rPr z-TimedeltaArray.components..9s!///QAAaDD///rR)r{int64)pandasr:rKr)rMr:hasnansrOr{rQs @@rPrzzTimedeltaArray.componentss8 %$$$$$   +  $ $ $ $ $ $ $ $ $ $////$///AAA ,]]7++F rR)r@rc)r@ri)r_rcr@r})r@r)rNrrtrrrr@r)rrr@rrk)rfr8r@r)r@r})r@r)T)rr)r@r2) rrrrrrrrrr) rrrrrrrrrr)r;r<rr)F)r r)rrr@r)r@r)r@r4)r@rY)r@rq)r@r)r@r:)MrT __module__ __qualname__rU_typrrerbr r(ra__annotations___infer_matchesrVrhrm__array_priority__rnrorsrur|rrr classmethodrr rrr no_defaultrrrrrrrrrrrrrr0r__rmul__r1r3r<r=rPrUrZr]r`rbrgrkrmrprwrvtextwrapdedentdays_docstringrWrCseconds_docstringrpmicroseconds_docstringrqnanoseconds_docstringrrrz __classcell__)rs@rPrYrYos))V D$bnd;7X7XXXXX1N 000X0XJINNNJNNNN#- #9VV : :D' '  BoG -X_ '""F#?L ,HO '!!D"/K 666X66666rRrYFraiserrerrorsr4r@$tuple[np.ndarray, Tick | Day | None]c&|dvsJd}|t|}tj||d\}}t|tr|j}|jtkst|jrt|||}d}nt|jrt||\}}|o| }nt|jrt|jtr|j}|j}nt!j|}||dkrt!jd 5|t j}dddn #1swxYwY|||kz}|r$t-|d|| \} } t.| |<| |fSt1||pd}t.||<|d }d}not5j|jd r=t9|js(t;|j} t=|| d}d}nt?d|jd|st!j |}nt!j!||}|jj"d 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, Day, 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. rNrY)cls_namerfrFrrignore)invalid)rrfrzm8[ns]r\rzdtype z' cannot be converted to timedelta64[ns]rm8)#rr!ensure_arraylike_for_datetimelikerrYrtrrYr%_objects_to_td64nsr"_ints_to_td64nsr!r)_mask_datareisnanerrstaterr~allrrrrrr]rrrrr6r%r#) rrrfrr copy_mader;int_data all_roundrO_ new_dtypes rPrrCs H  & & & &M #D))6 d-JD$$''"  zVtz::!$T&AAA $* % %)V)$T:::i%I   # #$V dj. 1 1 ":D:DD8D>>D   X... 1 1;;rx00 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1!127799I -.5tF  $t },,(t|t<<T yy"" S ) ) V!$*-- +DJ77I&t95IIIDDTTTTUUU )z$x4((( :?c ! ! ! ! :      s( EEErrftuple[np.ndarray, bool]cXd}||nd}|jtjkr!|tj}d}|dkrNd|d}||}t |j}||jkrt ||}d}n|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 FNrTz timedelta64[rr!ztimedelta64[ns])rrer~rrrr)rrfr dtype_strrs rPrrs I#44D zRX{{28$$  t||*4*** yy##' 33  " "&t9===DIyy*++ ?rRrAcjtj|tj}t|||}|S)aR Convert an object-dtyped or string-dtyped array into a 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. r!r)rer6object_r)rrfrrNrOs rPrrs4@ZBJ / / /F !&tF C C CF MrRr5ct|}|tjdkrd}t|t j|dstd|dt |std|S)NrzhPassing in 'timedelta' dtype with no precision is not allowed. Please pass in 'timedelta64[ns]' instead.r\zdtype 'z,' is invalid, should be np.timedelta64 dtypez;Supported timedelta64 resolutions are 's', 'ms', 'us', 'ns')r&rerrrr]r)rmsgs rPrrs   E  8 oo ?5# & &XV5VVVWWW  & &XVWWW LrR)r;r<r=r<r>r<)FNr)rrrr4r@r)r)rfr<r@r)Nr)rr4r@rA)r@r5)^ __future__rdatetimerr7typingrrrnumpyre pandas._libsrr pandas._libs.tslibsr r r r rrrrrrrpandas._libs.tslibs.conversionrpandas._libs.tslibs.fieldsrrpandas._libs.tslibs.timedeltasrrrrrpandas.compat.numpyrrpandas.util._decoratorsrpandas.util._validatorsrpandas.core.dtypes.commonr r!r"r#r$r%r&pandas.core.dtypes.dtypesr'r(r)pandas.core.dtypes.missingr* pandas.corer+r,pandas.core.array_algosr-pandas.core.arraysr.rpandas.core.arrays._rangesr/pandas.core.commoncorecommonrpandas.core.ops.commonr0collections.abcr1r2pandas._typingr3r4r5r6r7r8rr:rrW TimelikeOpsrYrrrrrrRrPrsr""""""                           EDDDDD/...........666666 ,+++++?>>>>>222222====== ;;;;;; !22222222!     , OLLLLLS_LLLj #* jjjjjZ'''''V5<#####LrR