`Vg3ddlmZddlmZddlmZmZddlZddl m Z m Z ddl m Z mZmZmZmZmZmZmZmZddlmZddlmZdd lmZmZmZdd lmZm Z m!Z!dd l"m#Z$dd l%m&Z&dd l'm(Z(ddl)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z9ddl:m;Z;ddlZ?ddl@mAZAerddlBmCZCddZDGdde9jZF d ddZGddZHd dZId!dZJy)") annotations) timedelta) TYPE_CHECKINGcastN)libtslibs) BaseOffsetNaTNaTTypeTick Timedeltaastype_overflowsafeiNaTperiods_per_second to_offset)precision_from_unit)get_timedelta_field)array_to_timedelta64ints_to_pytimedeltaparse_timedelta_unit)DtypeObjNpDtypenpt)function)validate_endpoints)astype_td64_unit_conversion) TD64NS_DTYPEis_dtype_equalis_float_dtypeis_integer_dtypeis_object_dtype is_scalaris_string_dtypeis_timedelta64_dtype pandas_dtype)isna)nanops) datetimelike)generate_regular_range)unpack_zerodim_and_defer DataFramecJdfd }||_d|d|_t|S)Nc|j}t||j}|jr|j |dd}|S)Nresofloat64) fill_valueconvert)asi8r_reso_hasna_maybe_mask_results)selfvaluesresultaliass ^/var/www/html/hubwallet-dev/venv/lib/python3.12/site-packages/pandas/core/arrays/timedeltas.pyfz_field_accessor..fBsH$VUD ;;--4.F  )return np.ndarray)__name____doc__property)namer; docstringr=s ` r<_field_accessorrGAs+AJYKr"AI A;r>ceZdZUdZdZej ddZeej e fZ e Z dZ edLdZdZgZded <gZded <d gZded <gd Zded<eezezZded<gdZded<dMdZedNdZdZeZedZedef dOfd Zeedd dPdZ eede!jDdf dPdZ#edQdZ$dRdSdZ%dTdZ&dRdUdZ'dVdWd Z(d!Z)ddddddd"d# dXd$Z*dddd%ddd& dYd'Z+dRdZd(Z,ddd) d[d*Z-d+Z.e/d,d\d-Z0e0Z1e/d.d/Z2e/d0d1Z3e/d2d3Z4e/d4d5Z5e/d6d7Z6e/d8d9Z7e/d:d;Z8e/d<d=Z9d\d>Z:d\d?Z;d\d@Ze?dCdCdDZ@e?dEdEdFZAe?dGdGdHZBe?dIdIdJZCed^dKZDxZES)_TimedeltaArraya 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 timedeltaarrayr ns)r timedelta64ctSNr r8s r< _scalar_typezTimedeltaArray._scalar_typevsr>iz list[str] _other_ops _bool_opsfreq _object_ops)daysseconds microseconds nanoseconds _field_ops_datetimelike_ops)to_pytimedelta total_secondsroundfloorceil_datetimelike_methodsc|jd}|tjk(rtStj||j S)Ni8r/)viewr valuer _from_value_and_resor5)r8xys r< _box_funczTimedeltaArray._box_funcs6 FF4L  >J--adjjAAr>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 )_ndarraydtyperPs r<rlzTimedeltaArray.dtypes"}}"""r>NcFt|jt|}|SrN)_validate_td64_dtyperl)clsr9rls r<_validate_dtypezTimedeltaArray._validate_dtypes V\\*$U+ r>c2t|tjr|jdk(sJt j |rJt|tj sJt|||jk(sJt|%||}||_ |S)Nm)r9rl) isinstancenprlkindr is_unitlessndarraytypesuper _simple_new_freq)ror9rTrlr: __class__s r<rzzTimedeltaArray._simple_news %*uzzS/@@@%%e,,,&"**-;tF|;- $$$$F%$@  r>Frlcopyc|r t|t||d\}}tjd|d\}}|j ||j |S)Nr~unitFrlrT)rnsequence_to_td64nsdtlvalidate_inferred_freqrzrl)rodatarlr~ inferred_freqrT_s r<_from_sequencezTimedeltaArray._from_sequencesS   '0DtLm,,T=%Hat4::DAAr>c|r t||dvsJ|du}|tjur|nd}tj|\}}t |||\}}tj |||\}}|rd}|j||j|} |||j| || S|rt| j| _ | S)NYrhMrr) rnr no_defaultrmaybe_infer_freqrrrzrl_validate_frequencyrrr{) rorrlr~rTr explicit_none freq_inferrr:s r<_from_sequence_not_strictz(TimedeltaArray._from_sequence_not_stricts   '?*** 3>>1tt//5j0DtLm55dM:Vj DTZZdC  T%5  # #FD 1 %V%9%9:FL r>ctj|}| td|||fDr tdt j ||||dk7r td| t |}| t |}t|\}}|t||||}n:tj|j|j|jd}|s|dd}|s|dd}|jd} |j| | j| S) Nc3$K|]}|du ywrN).0rgs r< z1TimedeltaArray._generate_range..sIaT Isz1Must provide freq argument if no data is suppliedzVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedrcm8[ns]r)rvalidate_periodsany ValueErrorcomcount_not_noner rr)rtlinspacereastyperdrzrl) rostartendperiodsrTclosed left_closed right_closedindex td64valuess r<_generate_rangezTimedeltaArray._generate_ranges&&w/ ! \  *5#wEEKK SYY@GGME!"IE#2JEZZ) z1A1AMMr>ct||js|tur td|j ||t j |jdS)Nz'value' should be a Timedelta.)setitemrK)rsrQr r_check_compatible_withrtrLre)r8rers r< _unbox_scalarzTimedeltaArray._unbox_scalarsM%!2!23S8H=> > ##E7#;~~ekk400r>ct|SrNrO)r8res r<_scalar_from_stringz"TimedeltaArray._scalar_from_strings r>cyrNr)r8otherrs r<rz%TimedeltaArray._check_compatible_with s r>Tct|}|jdk(rt|j||Stj j |||S)Nrrr~)r%rurrkrDatetimeLikeArrayMixinr)r8rlr~s r<rzTimedeltaArray.astype'sK U# :: .t}}e$O O))00u40HHr>c#4K|jdkDr!tt|D] }|| y|j}t|}d}||zdz}t|D]3}||z}t |dz|z|}t |||d}|Ed{5y7w)Nri'Tbox)ndimrangelenrkminr) r8irlength chunksizechunksstart_iend_i converteds r<__iter__zTimedeltaArray.__iter__3s 99q=3t9% 1g  ==DYFI )Q.F6] %i-QUi/8/WU0CN $$$  %%sB BBBr)axisrloutkeepdimsinitialskipna min_countctjd||||dtj|j|||}|j ||S)Nr)rlrrr)rrr)nv validate_sumr'nansumrk_wrap_reduction_result) r8rrlrrrrrr:s r<sumzTimedeltaArray.sumFsP  %gV  MMVy **488r>r)rrlrddofrrctjd|||ddtj|j|||}||j dk(r|j |S|j|S)Nr)rlrrstd)fname)rrrr)rvalidate_stat_ddof_funcr'nanstdrkrri_from_backing_data)r8rrlrrrrr:s r<rzTimedeltaArray.stdZsi "" %B% t}}4TR <499>>>&) )&&v..r>c"ddlm}||dS)Nrget_format_timedelta64Tr)pandas.io.formats.formatr)r8boxedrs r< _formatterzTimedeltaArray._formatterpsC%d55r>)na_rep date_formatc ddlm}||j|}tj|dd|jS)Nrrr)rrrkrt frompyfunc)r8rrkwargsr formatters r<_format_native_typesz#TimedeltaArray._format_native_typesus: D+4==&A .r}}Y1-dmm<ct|trJtdt|jdt|j)Nzcannot add the type z to a )rsr TypeErrorrxrBr8rs r< _add_offsetzTimedeltaArray._add_offsetsEeT***"4;#7#7"8tDz?R?R>S T  r>__mul__ct|r^|j|z}d}|jt|s|j|z}t |j ||j |St|dstj|}t|t|k7r t|j s tdt|j rq|j}tt|Dcgc] }||||z}}tj|}t |j ||j S|j|z}t |j ||j Scc}w)Nrrlz$Cannot multiply with unequal lengthsrl)r"rkrTr&rxrzrlhasattrrtarrayrr$rr!r)r8rr:rTarrns r<rzTimedeltaArray.__mul__s< U ]]U*FDyy$T%[yy5(:))& 4)P Pug&HHUOE u:T "+? +LCD D 5;; '--C16s4y1ABAc!fuQx'BFBXXf%F:))& )E E&Dz%%fFLL%AA Cs9E= __truediv__ct||jr|t|}td|turPt j |jt j}|jt j|S|j|z Stj|rh|j|z }d}|j$|jj|z }t!|}t#|j%||j&|St)|dst j*|}t-|t-|k7r t/dt1|j&r|j|z St3|j&r|j5}|j5}t7t-|Dcgc] }||||z }}t j*|j9|j}tj:|d}|dk(rE|j5} t#|j=| j9|j}|S|d k(r|j?t@}|S|d k(r|t jz}|S|j|z }t#|j%||j&Scc}w) NTimedelta | NaTTyperrrl*Cannot divide vectors with unequal lengthsFrrfloatingdatetime)!rs_recognized_scalarsr rr rtemptyshaper1fillnanrkrr"rTdeltarrxrzrlrrrrr$r!ravelrreshape infer_dtyperrfloat) r8rr:rTsravoravr result_listinferredflats r<rzTimedeltaArray.__truediv__sJ eT55 6e$E)51S8$**BJJ? BFF# ==5( ( ]]5 !]]U*FDyy$yy. :))& 4)P Pug&HHUOE u:T "IJ J !%++ .==5( ( U[[ )::Fve|} tAjB| d} | jE|j}| d k(rtG|\}} t!||S| d k(r|t jzS|StI|j,stK|j,r |j|z}t!||StM|dt!|jN} tQd | d t!|jNcc}w) NrrrrTrl"Cannot divide with unequal lengthsFrrrr r ))r"rsrr rr rtrrr1rr __rfloordiv__rkrTnanosrxrrrrr$rlr4_isnanrrputmaskr!rrasarrayrrrrr rgetattrrBr) r8rr:rTmaskrrrres_list result_flatrrrls r<r zTimedeltaArray.__floordiv__s U %!9!9:!%(-u5<XXdjj CFKK'!M**4==99]]e+FDyy$yy5(::?tyy!'; D4:f40 0ug&HHUOE u:T "AB B !%++ .DJu%EYY%**,F;;-Dxxzrzz2 640M U[[ )::__rmod__cZt||jr t|}|||z|zz SrNrrs r<rzTimedeltaArray.__rmod__s2 eT55 6e$E ---r> __divmod__cft||jr t|}||z}|||zz }||fSrNrr8rres1res2s r<rzTimedeltaArray.__divmod__s? eT55 6e$Eu}dUl"Tzr> __rdivmod__cft||jr t|}||z}|||zz }||fSrNrr!s r<r$zTimedeltaArray.__rdivmod__s? eT55 6e$E}td{"Tzr>c|j)t||j |j St||j SNr)rTrxrkrPs r<__neg__zTimedeltaArray.__neg__sB 99 4:t}}nDII:> >tDz4==.))r>clt||jj|jSr')rxrkr~rTrPs r<__pos__zTimedeltaArray.__pos__s&tDz$--,,.TYY??r>c^t|tj|jSrN)rxrtabsrkrPs r<__abs__zTimedeltaArray.__abs__s tDz"&&/00r>clt|j}|j|j|z dS)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 ------- seconds : [ndarray, Float64Index, Series] When the calling object is a TimedeltaArray, the return type is ndarray. When the calling object is a TimedeltaIndex, the return type is a Float64Index. 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() Float64Index([0.0, 86400.0, 172800.0, 259200.0, 345600.0], dtype='float64') N)r2)rr5r7r4)r8ppss r<r]zTimedeltaArray.total_secondss1n!,'' CD'IIr>c,t|jS)z Return an ndarray of datetime.timedelta objects. Returns ------- timedeltas : ndarray[object] )rrkrPs r<r\zTimedeltaArray.to_pytimedeltas#4==11r>rVz Number of days for each element.rWz>Number of seconds (>= 0 and less than 1 day) for each element.rXzFNumber of microseconds (>= 0 and less than 1 second) for each element.rYzJNumber of nanoseconds (>= 0 and less than 1 microsecond) for each element.cddlm}gd|j}|rfd}nd}||Dcgc] }|| c}}|s|jd}|Scc}w)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 rr+)rVhoursminutesrW millisecondsrXrYclt|rtjgtzS|jSrN)r&rtrr components)rgcolumnss r<r=z$TimedeltaArray.components..f9s)7FF8c'l22||#r>c|jSrN)r6)rgs r<r=z$TimedeltaArray.components..f@s ||#r>)r7int64)pandasr,r6r)r8r,hasnansr=rgr:r7s @r<r6zTimedeltaArray.componentss_ % ++  $ $$/QAaD/A]]7+F 0sA)r@ztype[Timedelta])rgnp.timedelta64r@r)r@znp.dtype)r9rArTzBaseOffset | Noner@rI)r~boolr@rIrN)F)rr=r@r<)r@r)rr=r@None)T)r~r=) r int | NonerlNpDtype | Nonerr=rr=rint) rr?rlr@rrArr=rr=)rr=)r@znpt.NDArray[np.object_])r@rI)r@znpt.NDArray[np.float64])r@r,)FrB __module__ __qualname__rC_typrtrL_internal_fill_valuerr rr$_is_recognized_dtype_infer_matchesrDrQ__array_priority__rR__annotations__rSrUrZr[rarirlr{r_default_dtype classmethodrprzrrrrrrrrrrrrrrrr*r__rmul__rrr rrrrr$r(r*r-r]r\rGrVrWrXrYr6 __classcell__)r|s@r<rIrIQs< D)2>>%6$bnnd;/1N J Iy$XK%NJ N#- #;i#GyG(9B ##& E!N;?|  '8    (u B04 B  B B ^^  " " ""HNNH1    I%, $ 99 9  999. $ // /  ///,6 4 =  = i(B)B<Hm,CF-CFJn-).)Vn-JO.JOXo.-O/-O^i(.). j).*. l+,m,-* @18Jt2 66+M NDHG #PL "TK &&r>rIc|dvsJd}| t|}tj||d\}}t|tr |j }t |jst|jrt|||}d}n>t|jrt||\}}|xr| }nt|jrtj|}t|xsd\}}|j!tj"} || z } |rtj$| |} | |z| |zj!tj"zj'd }t(||<d}nUt+|jr'|jt,k7r-t/|t, }d}nt1d |jd tj2|| }|jdk(sJ|||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. rNrI)cls_namererrorsF)rrKtimedelta64[ns]rdtype ' cannot be converted to timedelta64[ns]rr)rr!ensure_arraylike_for_datetimelikersrIrTr!rlr#_objects_to_td64nsr ints_to_td64nsrrtisnanrrr9r^rdrr$rrrr) rr~rrQr copy_maderrrpbasefracs r<rrMsB  && &M #D)66 d-JD$$' tzz"odjj&A!$T&A $** %(D9i%I   #xx~"4<401{{288$d{ 88D!$DqD1H,,RXX66<<=NOT  djj ) :: %&t<@DD& ,STUU 88Dt $D :: !'4' !  r>cd}||nd}|jtjk7r!|jtj}d}|dk7r.d|d}|j |}t |t }d}||fS|j 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 FrKTz timedelta64[]rrR)rlrtr9rrdrr)rrrY dtype_strs r<rWrWs I#4D zzRXX{{288$  t|"4&* yy#"4|< ?yy*+ ?r>ctj|tjd}t|||}|j 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. Fr}rPrR)rtrobject_rrd)rrrQr9r:s r<rVrVs8<XXd"**5 9F !&tF CF ;;( ))r>ct|}t|tjdr d}t |t|t st d|d|S)NrLzhPassing in 'timedelta' dtype with no precision is not allowed. Please pass in 'timedelta64[ns]' instead.rSrT)r%rrtrlrr)rlmsgs r<rnrnsY  EeRXXm45 8 o % .6%(OPQQ Lr>)rEstrr;rdrFrd)FNraise)r~r=r@ztuple[np.ndarray, Tick | None])rK)Nre)r@r)K __future__rrrtypingrrnumpyrt pandas._libsrrpandas._libs.tslibsr r r r r rrrrpandas._libs.tslibs.conversionrpandas._libs.tslibs.fieldsrpandas._libs.tslibs.timedeltasrrrpandas._typingrrrpandas.compat.numpyrrpandas.util._validatorsrpandas.core.dtypes.astyperpandas.core.dtypes.commonrrrr r!r"r#r$r%pandas.core.dtypes.missingr& pandas.corer'pandas.core.arraysr(rpandas.core.arrays._rangesr)pandas.core.commoncorecommonrpandas.core.ops.commonr*r:r,rG TimelikeOpsrIrrWrVrnrr>r<r|s"    ?:  /6A   ,2= ;   u S__u z18TT#Tn%P!*H r>