ujdZddlmZddlZddlmZmZmZddlZddl m Z m Z ddl mZmZmZmZmZmZmZddlmZddlmZdd lmZdd lmZmZdd lmZdd l m!Z!dd l"m#Z#ddl$m%Z%ddl&m'cm(Z)ddl*m+Z+m,Z,ddl-m.Z.ddl/m0Z0m1Z1er.ddl2m3Z3ddlm4Z4ddl5Z6ddl m7Z7ddl8m9Z9m:Z:m;Z;mZ>m?Z?ddl@mAZAdZBedGdde.ZCed ddd ddZDy)zimplement the TimedeltaIndex) annotationsN) TYPE_CHECKINGSelfcast)indexlib)Day ResolutionTick Timedelta Timestamp timezones to_offset)abbrev_to_npy_unit)parse_timedelta_string_reso) set_module) is_scalar pandas_dtype) ArrowDtype) ABCSeries)isna)TimedeltaArray)Indexmaybe_extract_name)DatetimeTimedeltaMixin)rmulrsub)Callable)Any)NaTType)AxisIntDtypeObjNpDtype TimeAmbiguousTimeNonexistentTimeUnitnpt) DataFramecd|vrt|dts|jd}t|tr|}n!tj||j }t |jdd}|jd|}|j|fi|}||_|Stj5tjd|j|fi|}ddd|S#1swYSxYw)zu This is called upon unpickling, rather than the default which doesn't have arguments and breaks __new__ data)dtype_freqNfreqignore) isinstanceTimedeltaIndexpopr _simple_newr+varsr,warningscatch_warnings simplefilter__new__)clsdr*tdarr legacy_freqr-results i/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/core/indexes/timedeltas.py_new_TimedeltaIndexr>Fs {:ai@uuV} dN +E"..t4::FE5koogt4 uuV[) ,!, M $ $ & +  ! !( + S[[**F + M + Ms :)C--C7pandasc(eZdZUdZdZeZed)dZde d<e jZ d*dZ d+dZ d,dZ d- d.d Z d- d.d Z d- d.d Zed,d Zed,d Zed,dZed,dZed/dZd0dZdddddddd d1dZddddddd d2dZddd d3dZdej8dddf d4dZdZd5dZd6d Z d6d!Z!d7fd" Z" d8d#Z#d9d$Z$d%Z%d:d&Z&d;d'Z'ed`. Examples -------- >>> pd.TimedeltaIndex(["0 days", "1 days", "2 days", "3 days", "4 days"]) TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[us]', freq=None) We can also let pandas infer the frequency when possible. >>> pd.TimedeltaIndex(np.arange(5) * 24 * 3600 * 1e9, freq="infer") TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[ns]', freq='D') timedeltaindexc"tjSN)libindexTimedeltaEngineselfs r= _engine_typezTimedeltaIndex._engine_types'''r_datacHt||j|jdS)z@Wrap an ndarray result computed from ``self._data`` in an Index.F)namer+copy)rrLr+rGr<s r=_wrap_field_resultz!TimedeltaIndex._wrap_field_resultsV$))6<>> idx = pd.to_timedelta(np.arange(5), unit="D") >>> idx TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[us]', freq=None) >>> idx.total_seconds() Index([0.0, 86400.0, 172800.0, 259200.0, 345600.0], dtype='float64') )rOrJ total_secondsrFs r=rUzTimedeltaIndex.total_secondss":&&tzz'?'?'ABBrIcZ|j|jj|||S)a Perform round operation on the data to the specified `freq`. This method rounds each timedelta value in the Series/Index to the nearest specified frequency using standard rounding rules (round half to even). Parameters ---------- freq : str or Offset The frequency level to round 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' Accepted for compatibility with :meth:`DatetimeIndex.round`; has no effect since TimedeltaIndex values are never tz-aware. nonexistent : 'shift_forward', 'shift_backward', 'NaT', timedelta, default 'raise' Accepted for compatibility with :meth:`DatetimeIndex.round`; has no effect since TimedeltaIndex values are never tz-aware. Returns ------- TimedeltaIndex Values rounded to the given `freq`. Raises ------ ValueError if the `freq` cannot be converted. See Also -------- TimedeltaIndex.floor : Perform floor operation on the data to the specified `freq`. TimedeltaIndex.ceil : Perform ceil operation on the data to the specified `freq`. Examples -------- >>> tdelta_idx = pd.timedelta_range("1 day", periods=3, freq="6h20min") >>> tdelta_idx TimedeltaIndex(['1 days 00:00:00', '1 days 06:20:00', '1 days 12:40:00'], dtype='timedelta64[us]', freq='380min') >>> tdelta_idx.round("h") TimedeltaIndex(['1 days 00:00:00', '1 days 06:00:00', '1 days 13:00:00'], dtype='timedelta64[us]', freq=None) )rSrJroundrGr- ambiguous nonexistents r=rWzTimedeltaIndex.rounds)l##DJJ$4$4T9k$RSSrIcZ|j|jj|||S)aj Perform floor operation on the data to the specified `freq`. This method rounds each timedelta value in the Series/Index down to the specified frequency (i.e., towards negative infinity). Parameters ---------- freq : str or Offset The frequency level to floor 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' Accepted for compatibility with :meth:`DatetimeIndex.floor`; has no effect since TimedeltaIndex values are never tz-aware. nonexistent : 'shift_forward', 'shift_backward', 'NaT', timedelta, default 'raise' Accepted for compatibility with :meth:`DatetimeIndex.floor`; has no effect since TimedeltaIndex values are never tz-aware. Returns ------- TimedeltaIndex Values rounded down to the given `freq`. Raises ------ ValueError if the `freq` cannot be converted. See Also -------- TimedeltaIndex.round : Perform round operation on the data to the specified `freq`. TimedeltaIndex.ceil : Perform ceil operation on the data to the specified `freq`. Examples -------- >>> tdelta_idx = pd.timedelta_range("1 day", periods=3, freq="6h20min") >>> tdelta_idx TimedeltaIndex(['1 days 00:00:00', '1 days 06:20:00', '1 days 12:40:00'], dtype='timedelta64[us]', freq='380min') >>> tdelta_idx.floor("h") TimedeltaIndex(['1 days 00:00:00', '1 days 06:00:00', '1 days 12:00:00'], dtype='timedelta64[us]', freq=None) )rSrJfloorrXs r=r\zTimedeltaIndex.floors)j##DJJ$4$4T9k$RSSrIcZ|j|jj|||S)ac Perform ceil operation on the data to the specified `freq`. This method rounds each timedelta value in the Series/Index up to the specified frequency (i.e., towards positive infinity). Parameters ---------- freq : str or Offset The frequency level to ceil 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' Accepted for compatibility with :meth:`DatetimeIndex.ceil`; has no effect since TimedeltaIndex values are never tz-aware. nonexistent : 'shift_forward', 'shift_backward', 'NaT', timedelta, default 'raise' Accepted for compatibility with :meth:`DatetimeIndex.ceil`; has no effect since TimedeltaIndex values are never tz-aware. Returns ------- TimedeltaIndex Values rounded up to the given `freq`. Raises ------ ValueError if the `freq` cannot be converted. See Also -------- TimedeltaIndex.round : Perform round operation on the data to the specified `freq`. TimedeltaIndex.floor : Perform floor operation on the data to the specified `freq`. Examples -------- >>> tdelta_idx = pd.timedelta_range("1 day", periods=3, freq="6h20min") >>> tdelta_idx TimedeltaIndex(['1 days 00:00:00', '1 days 06:20:00', '1 days 12:40:00'], dtype='timedelta64[us]', freq='380min') >>> tdelta_idx.ceil("h") TimedeltaIndex(['1 days 00:00:00', '1 days 07:00:00', '1 days 13:00:00'], dtype='timedelta64[us]', freq=None) )rSrJceilrXs r=r^zTimedeltaIndex.ceilPs'j##DJJOOD)[$QRRrIcL|j|jjS)a: Number of days for each element. This attribute returns the number of whole days in each timedelta value. It represents the days component of the duration, not the total duration expressed in days. 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 -------- >>> 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') )rOrJdaysrFs r=r`zTimedeltaIndex.dayss0&&tzz77rIcL|j|jjS)a Number of seconds (>= 0 and less than 1 day) for each element. This attribute returns the seconds component of each timedelta value, which is the number of seconds remaining after subtracting whole days. Values range from 0 to 86399. See Also -------- Series.dt.seconds : Return number of seconds for each element. Series.dt.nanoseconds : Return number of nanoseconds for each element. Examples -------- >>> 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[us]', freq=None) >>> tdelta_idx.seconds Index([1, 2, 3], dtype='int32') )rOrJsecondsrFs r=rbzTimedeltaIndex.secondss.&&tzz'9'9::rIcL|j|jjS)a/ Number of microseconds (>= 0 and less than 1 second) for each element. This attribute returns the microseconds component of each timedelta value, which is the number of microseconds remaining after subtracting whole seconds. Values range from 0 to 999999. See Also -------- Timedelta.microseconds : Number of microseconds (>= 0 and less than 1 second). Examples -------- >>> 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') )rOrJ microsecondsrFs r=rdzTimedeltaIndex.microsecondss0&&tzz'>'>??rIcL|j|jjS)ap Number of nanoseconds (>= 0 and less than 1 microsecond) for each element. This attribute returns the nanoseconds component of each timedelta value, which is the number of nanoseconds remaining after subtracting whole microseconds. Values range from 0 to 999. See Also -------- Series.dt.seconds : Return number of seconds for each element. Series.dt.microseconds : Return number of microseconds for each element. Examples -------- >>> 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') )rOrJ nanosecondsrFs r=rfzTimedeltaIndex.nanosecondss0&&tzz'='=>>rIc.|jjS)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 )rJ componentsrFs r=rhzTimedeltaIndex.componentss8zz$$$rIc6|jjS)a- Return an ndarray of datetime.timedelta objects. Each element of the :class:`TimedeltaIndex` is converted to the corresponding native Python :class:`datetime.timedelta` object. Returns ------- numpy.ndarray Object-dtype array of :class:`datetime.timedelta`. 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[us]', freq=None) >>> tdelta_idx.to_pytimedelta() array([datetime.timedelta(days=1), datetime.timedelta(days=2), datetime.timedelta(days=3)], dtype=object) )rJto_pytimedeltarFs r=rjzTimedeltaIndex.to_pytimedelta s<zz((**rINFTraxisr+outkeepdimsinitialskipna min_countc F|jj|||||||S)a  Return the sum of the values over the requested axis. Parameters ---------- axis : int, optional Axis for the function to be applied on. dtype, out, keepdims, initial Not implemented; kept for compatibility with :func:`numpy.sum`, which calls this method when ``numpy.sum(tdi)`` is used. Must be left at their default values. skipna : bool, default True Whether to ignore any NaT elements. min_count : int, default 0 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NaT values are present the result is NaT. Returns ------- Timedelta The sum, or NaT if it cannot be computed. See Also -------- numpy.ndarray.sum : Returns the sum of array elements along a given axis. Series.sum : Return the sum of the values in a Series. Examples -------- >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit="D") >>> tdelta_idx TimedeltaIndex(['1 days', '2 days', '3 days'], dtype='timedelta64[us]', freq=None) >>> tdelta_idx.sum() Timedelta('6 days 00:00:00') rk)rJsum)rGrlr+rmrnrorprqs r=rszTimedeltaIndex.sum,s4^zz~~  rIrlr+rmddofrnrpcD|jj||||||S)a3 Return the standard deviation of the values over the requested axis. Parameters ---------- axis : int, optional Axis for the function to be applied on. dtype, out, keepdims Not implemented; kept for compatibility with :func:`numpy.std`, which calls this method when ``numpy.std(tdi)`` is used. Must be left at their default values. ddof : int, default 1 Delta degrees of freedom. The divisor used in calculations is ``N - ddof``, where ``N`` represents the number of elements. skipna : bool, default True Whether to ignore any NaT elements. Returns ------- Timedelta The standard deviation, or NaT if it cannot be computed. See Also -------- numpy.ndarray.std : Returns the standard deviation of array elements along a given axis. Series.std : Return sample standard deviation over requested axis. Examples -------- >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit="D") >>> tdelta_idx TimedeltaIndex(['1 days', '2 days', '3 days'], dtype='timedelta64[us]', freq=None) >>> tdelta_idx.std() Timedelta('1 days 00:00:00') ru)rJstd)rGrlr+rmrvrnrps r=rxzTimedeltaIndex.stdes-^zz~~U$RX  rIrlrpc @|jjd||d|S)a Return the median of the values over the requested axis. Parameters ---------- axis : int, optional Axis for the function to be applied on. skipna : bool, default True Whether to ignore any NaT elements. **kwargs Additional keywords have no effect but might be accepted for compatibility with NumPy. Returns ------- Timedelta The median, or NaT if it cannot be computed. See Also -------- numpy.median : Compute the median along the specified axis. Series.median : Return the median of the values in a Series. Examples -------- >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit="D") >>> tdelta_idx TimedeltaIndex(['1 days', '2 days', '3 days'], dtype='timedelta64[us]', freq=None) >>> tdelta_idx.median() Timedelta('2 days 00:00:00') ry)rJmedian)rGrlrpkwargss r=r|zTimedeltaIndex.medians&N!tzz  Dd6DVDDrIct|||}|j|||\}}t|r|j|| t |}t |t rH|tjur6|||jk(r%|r|j}|j||St |trG|tjur5|3|||jk(r"|r|jS|jSt |tr |jnd}t j|||}d}|s"t |t t"fr |j$}|j|||} | j'||| S)NrQ)r+rM)rLrefs)r_maybe_copy_array_inputr_raise_scalar_data_errorrr/rr no_defaultr+rMr2r0_viewr-_from_sequencerr _references _pin_freq) r8r*r-r+rMrL inferred_freqr:rr<s r=r7zTimedeltaIndex.__new__sV"$c200tUC d T?  ( ( .   'E t^ ,&%4::"5yy{??4d?3 3 t^ ,& %4::"5yy{"zz|#&0n%E 4 --d%dK 4)U);<##DT=}- rIcr|j|j|jd}tt ||fdfS)N)r*rLr-)rJrLr,r>rR)rGr9s r= __reduce__zTimedeltaIndex.__reduce__s/ZZDJJ G"T$ZOT99rIclt|tr|jdk(Stj|dS)zF Can we compare values of the given dtype to our own? m)r/rkindr is_np_dtype)rGr+s r=_is_comparable_dtypez#TimedeltaIndex._is_comparable_dtypes. eZ (::$ $uc**rIc|jj}t|j||j}|j |j |_|SNrQ)rJ__neg__rRr2rLr-r,rGr<idxs r=rzTimedeltaIndex.__neg__ sM##%4j$$V$))$< 99  CI rIc|jj}t|j||j}|j |j |_|Sr)rJ__pos__rRr2rLr-r,rs r=rzTimedeltaIndex.__pos__sK##%4j$$V$))$< 99  CI rIc(t|||}|j t|s|Sd}t |t |r|j ||}n4tt|dddddk(r|tur|j|}|||_ |S)Nr+rM) super _arith_methodr-rr/rR_get_arith_result_freqgetattrr_get_rsub_datetime_result_freqr,)rGotheropr<new_freq __class__s r=rzTimedeltaIndex._arith_methods&ub1 99 Ie$4M fd4j )225"=H GFGT2FD AS HRSWZ ::5AH  #FL rIc|j}|J|tjtfvr,t t |ry||z}|j dk(ry|S|tjtjfvrt|trN|j |zdk(rt|j |z}n(tt|j |z }n||z }|jdk(r|jdk7ry|S|tur| Sy)z Compute the result freq for arithmetic operations whose result is also a TimedeltaIndex. Caller is responsible for checking self.freq is not None. Nr)r`)r-operatormulrboolrntruedivfloordivr/r rr nanosr)rGrrr-rs r=rz%TimedeltaIndex._get_arith_result_freq+syy (,,% %DK e|HzzQO (""H$5$56 6$$66E>Q&"466U?3H()?@5HH%<~~"tzzQO :5LrIc|j}|Jt|tr| St|tr |j}nt|j}|t j |r| Sy)z Compute the result freq for Timestamp/datetime - TimedeltaIndex. Mirrors the logic of _get_arithmetic_result_freq for the negated array case. N)r-r/r r tzris_utc)rGrr-rs r=rz-TimedeltaIndex._get_rsub_datetime_result_freqXskyy dD !5L eY 'B5!$$B :))"-5LrIc|j| |jj|d}t j ||S#t$r}t ||d}~wwxYw)z Get integer location for requested label Returns ------- loc : int, slice, or ndarray[int] F)unboxN)_check_indexing_errorrJ_validate_scalar TypeErrorKeyErrorrget_loc)rGkeyerrs r=rzTimedeltaIndex.get_locpsa ""3' )**--c-?C}}T3'' )3-S ( )sA A  AA ct|\}}t|tr:t|}tj|j }t ||}||fStj}||fSrC)rr/r r get_reso_from_freqstrresolution_stringminRESO_SEC)rGlabelparsedstring_reso_code string_reso value_resoresos r=_parse_with_resozTimedeltaIndex._parse_with_resosp$?u#E  fi ($%56K$99&:R:RSJ{J/Dt|&&Dt|rIc|j}|j|}|t|ztd|jj |jz }|t ||fS)Nrtunit) attr_abbrevr\rr ras_unitmax)rGrrreso_strlboundrbounds r=_parsed_string_to_boundsz'TimedeltaIndex._parsed_string_to_boundssf##h' ! " *22499= > s66***rIcy)N timedelta64r{rFs r= inferred_typezTimedeltaIndex.inferred_typesrI)returnztype[libindex.TimedeltaEngine])r<z np.ndarrayrr)r<rrr)rr)raiser)rYr$rZr%rr)rr()rznpt.NDArray[np.object_]) rlAxisInt | Noner+NpDtype | NonernrrprrqintrTimedelta | NaTType) rlrr+rrvrrnrrprrr)rlrrprrr)rMz bool | None)r+r"rr)rr0)robjectrCallable[..., Any]rr)rrrrrDay | Tick | None)rrrr)rstrrz&tuple[Timedelta | NaTType, Resolution])rr rr )rr)*__name__ __module__ __qualname____doc___typr _data_clspropertyrH__annotations__r_get_string_slicerOrSrUrWr\r^r`rbrdrfrhrjrsrxr|rrr7rrrrrrrrrrr __classcell__)rs@r=r0r0^sEN DI (( // M>CJ$+'. 6T!6T% 6T  6Tv$+'. 5T!5T% 5T  5Tt$+'. 5S!5S% 5S  5Sn882;;0@@2??2%%:+F $ $ 7 7  7  7 7 7  7 x $ $ 1 1  1  1 1 1  1 l $ 'E'E 'E  'E\ ^^  2  2h: +(++!3+ +Z0(* +rIr0rcv|tj|||rd}t|}tj||||dk7r t d|0||t |}t |}t d|}t d|}t|jt|jkDrt d|j}ntt d|j}n]|.t |}t d|}t d|j}n-t |}t d|}t d|j}|Ft d|}t|}|j|kDr t d|jj}tj||||||}tj||} || _| S) a Return a fixed frequency TimedeltaIndex with day as the default. This function generates a sequence of evenly spaced timedelta values between the specified bounds, using day as the default frequency. Parameters ---------- start : str or timedelta-like, default None Left bound for generating timedeltas. end : str or timedelta-like, default None Right bound for generating timedeltas. periods : int, default None Number of periods to generate. freq : str, Timedelta, datetime.timedelta, or DateOffset, default 'D' Frequency strings can have multiples, e.g. '5h'. name : Hashable, default None Name of the resulting TimedeltaIndex. closed : str, default None Make the interval closed with respect to the given frequency to the 'left', 'right', or both sides (None). unit : {'s', 'ms', 'us', 'ns', None}, default None Specify the desired resolution of the result. If not specified, this is inferred from the 'start', 'end', and 'freq' using the same inference as :class:`Timedelta` taking the highest resolution of the three that are provided. .. versionadded:: 2.0.0 Returns ------- TimedeltaIndex Fixed frequency, with day as the default. See Also -------- date_range : Return a fixed frequency DatetimeIndex. period_range : Return a fixed frequency PeriodIndex. Notes ----- Of the four parameters ``start``, ``end``, ``periods``, and ``freq``, a maximum of three can be specified at once. Of the three parameters ``start``, ``end``, and ``periods``, at least two must be specified. If ``freq`` is omitted, the resulting ``DatetimeIndex`` will have ``periods`` linearly spaced elements between ``start`` and ``end`` (closed on both sides). To learn more about the frequency strings, please see :ref:`this link`. Examples -------- >>> pd.timedelta_range(start="1 day", periods=4) TimedeltaIndex(['1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[us]', freq='D') The ``closed`` parameter specifies which endpoint is included. The default behavior is to include both endpoints. >>> pd.timedelta_range(start="1 day", periods=4, closed="right") TimedeltaIndex(['2 days', '3 days', '4 days'], dtype='timedelta64[us]', freq='D') The ``freq`` parameter specifies the frequency of the TimedeltaIndex. Only fixed frequencies can be passed, non-fixed frequencies such as 'M' (month end) will raise. >>> pd.timedelta_range(start="1 day", end="2 days", freq="6h") TimedeltaIndex(['1 days 00:00:00', '1 days 06:00:00', '1 days 12:00:00', '1 days 18:00:00', '2 days 00:00:00'], dtype='timedelta64[us]', freq='6h') Specify ``start``, ``end``, and ``periods``; the frequency is generated automatically (linearly spaced). >>> pd.timedelta_range(start="1 day", end="5 days", periods=4) TimedeltaIndex(['1 days 00:00:00', '2 days 08:00:00', '3 days 16:00:00', '5 days 00:00:00'], dtype='timedelta64[us]', freq=None) **Specify a unit** >>> pd.timedelta_range("1 Day", periods=3, freq="100000D", unit="s") TimedeltaIndex(['1 days', '100001 days', '200001 days'], dtype='timedelta64[s]', freq='100000D') DzVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedr r&z Tick | Day)closedrrQ)comany_nonercount_not_none ValueErrorr rrr_cresobasefreqstrr_generate_ranger0r2r,) startendperiodsr-rLrrcresor:r<s r=timedelta_rangersD | WeS9 T?D %gt49 8   |  e$EC.Ce,E{C(C!%**-0B3880LLJ 3J1  e$Ee,E EJJ/DC.C{C(C CHH-D   d+D&t,E{{U"J (9(9:  * * sGT&t E ' 'D ' 9FFL MrI)NNNNNN)rz int | NonerzTimeUnit | Nonerr0)Er __future__rrtypingrrrr4 pandas._libsrrDrpandas._libs.tslibsr r r r r rrpandas._libs.tslibs.dtypesrpandas._libs.tslibs.timedeltasrpandas.util._decoratorsrpandas.core.dtypes.commonrrpandas.core.dtypes.dtypesrpandas.core.dtypes.genericrpandas.core.dtypes.missingrpandas.core.arrays.timedeltasrpandas.core.commoncorecommonrpandas.core.indexes.baserr pandas.core.indexes.datetimelikerpandas.core.roperatorrrcollections.abcrrnumpynpr pandas._typingr!r"r#r$r%r&r'r?r(r>r0rr{rIr=r s "" :F.10+8 D ($!0 HF +F F R H    N!NN NNNrI