Pi7UddlmZddlZddlmZmZmZmZmZm Z m Z m Z ddl Z ddl ZddlmZddlmZmZmZmZmZmZmZddlmZddlmZmZddlmZdd l m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'ddl(m)cm*Z+dd l,m-Z-dd l.m/Z/ddl0m1Z1m2Z2ddl3m4Z4ddl5m6Z6m7Z7m8Z8ddl9m:Z:ddl;mZ>ddl?m@Z@ddlAmBZBmCZCddlDmEZEmFZFddlGmHZHmIZIddlJmKZKddlLmMZMmNZNddlOmPZPmQZQer6ddlRmSZSmTZTddlmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbddlcmdZdmeZeddl3m4Z4iZfdegd<ed Gd!d"e6e1ZhGd#d$e1e2ZiGd%d&ehZjed Gd'd(eiejZkGd)d*ejZled Gd+d,eielZmGd-d.ejZned Gd/d0eienZodod4Zpehjqep_q dpdqd9Zred Gd:d;e:Zse drdAZte dsdCZtdtdEZt dudvdVZu dudwdYZvdxdbZw dydzdfZx d{d|dkZyd}dnZzdS)~) annotationsN) TYPE_CHECKING ConcatenateLiteralSelfcastfinal no_type_checkoverload)lib) BaseOffsetIncompatibleFrequencyNaTPeriod Timedelta Timestamp to_offset)NDFrameT)AbstractMethodErrorPandas4Warning) set_module)find_stack_level) ArrowDtype PeriodDtype) ABCDataFrame ABCSeries)ResamplerWindowApply)ArrowExtensionArray) PandasObjectSelectionMixin)NDFrame) BaseGroupByGroupBy get_groupby)Grouper) BinGrouper) MultiIndex)Index) DatetimeIndex date_range) PeriodIndex period_range)TimedeltaIndextimedelta_range)concat) is_subperiodis_superperiod)DayTick)CallableHashable)Any AnyArrayLikeAxis FreqIndexT Frequency IndexLabelInterpolateOptionsPTTimedeltaConvertibleTypesTimeGrouperOriginTimestampConvertibleTypesTimeUnitnpt) DataFrameSerieszdict[str, str]_shared_docs_kwargszpandas.api.typingceZdZUdZded<ded<ded<eZded <ehd Zgd Z d d d ddfdZ e dgdZ e dhdZ e edidZdjd Zd!Ze d"Zedkd*Zedld-Ze dmfd/ Ze dnd0ZeZeZe d1Zd2Zdodpd5Zdndqd8Zd9Ze drd<Zd=Ze dndpd>Ze dndpd?Z e dndpd@Z!e dsdBd dCd dDdtdKZ"e dndLZ#e dudvdOZ$e dudvdPZ%e dudvdQZ&e dudvdRZ'e dwdxdUZ(e dwdxdVZ)e dydzdWZ*e dydzdXZ+e d{d|d[Z,e d{d|d\Z-e d{d|d]Z.e d^Z/e d_Z0e d`Z1e daZ2e d}d~deZ3xZ4S) Resamplera Class for resampling datetimelike data, a groupby-like operation. See aggregate, transform, and apply functions on this object. It's easiest to use obj.resample(...) to use Resampler. Parameters ---------- obj : Series or DataFrame groupby : TimeGrouper Returns ------- a Resampler of the appropriate type Notes ----- After resampling, see aggregate, apply, and transform functions. r&_grouper TimeGrouper _timegrouperz,DatetimeIndex | TimedeltaIndex | PeriodIndexbinnerzfrozenset[Hashable] exclusions>axobj_indexer)freqclosedlabel conventionoriginoffsetFN) group_keys selectioninclude_groupsrOr! timegrouper gpr_indexr(rWboolrYreturnNonec|rtd||_d|_d|_||_d|_|j||d|\|_|_ |_ | \|_ |_ ||_|jj!t!|jjg|_dSt!|_dS)Nz)include_groups=True is no longer allowed.T)sortr[) ValueErrorrKkeysr`rWas_index _set_grouper _convert_objrOrNrP _get_binnerrLrI _selectionkey frozensetrM)selfrOrZr[rWrXrYs h/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/pandas/core/resample.py__init__zResampler.__init__s  JHII I'  $ +/+<+I+I   c " ",J, , ($'4=&*%5%5%7%7" T]#   ,'):)>(?@@DOOO'kkDOOOstrcfdjD}tjdd|dS)z@ Provide a nice str repr of our rolling object. c3xK|]4}tj|d|dtj|V5dS)N=)getattrrK).0krjs rk z$Resampler.__str__..s_  t(!T22> 2 274,a00 2 2>>>>  rmz [z, ]) _attributestype__name__join)rjattrss` rk__str__zResampler.__str__s\     %    t**%<<5)9)9<<<cdSrrjrrrs rkpipezResampler.pipe Crmtuple[Callable[..., T], str]r6cdSrrrs rkrzResampler.piperrm@Callable[Concatenate[Self, P], T] | tuple[Callable[..., T], str]c>tj|g|Ri|S)aN Apply a ``func`` with arguments to this Resampler object and return its result. Use `.pipe` when you want to improve readability by chaining together functions that expect Series, DataFrames, GroupBy or Resampler objects. Instead of writing >>> h = lambda x, arg2, arg3: x + 1 - arg2 * arg3 >>> g = lambda x, arg1: x * 5 / arg1 >>> f = lambda x: x**4 >>> df = pd.DataFrame([["a", 4], ["b", 5]], columns=["group", "value"]) >>> h(g(f(df.groupby("group")), arg1=1), arg2=2, arg3=3) # doctest: +SKIP You can write >>> ( ... df.groupby("group").pipe(f).pipe(g, arg1=1).pipe(h, arg2=2, arg3=3) ... ) # doctest: +SKIP which is much more readable. Parameters ---------- func : callable or tuple of (callable, str) Function to apply to this Resampler object or, alternatively, a `(callable, data_keyword)` tuple where `data_keyword` is a string indicating the keyword of `callable` that expects the Resampler object. *args : iterable, optional Positional arguments passed into `func`. **kwargs : dict, optional A dictionary of keyword arguments passed into `func`. Returns ------- any The result of applying ``func`` to the Resampler object. See Also -------- Series.pipe : Apply a function with arguments to a series. DataFrame.pipe: Apply a function with arguments to a dataframe. apply : Apply function to each group instead of to the full Resampler object. Notes ----- See more `here `_ Examples -------- >>> df = pd.DataFrame( ... {"A": [1, 2, 3, 4]}, index=pd.date_range("2012-08-02", periods=4) ... ) >>> df A 2012-08-02 1 2012-08-03 2 2012-08-04 3 2012-08-05 4 To get the difference between each 2-day period's maximum and minimum value in one pass, you can do >>> df.resample("2D").pipe(lambda x: x.max() - x.min()) A 2012-08-02 1 2012-08-04 1 )superr)rjrrr __class__s rkrzResampler.pipe s,Zuww|D242226222rmczt||||}||}|j|g|Ri|}|S)a Aggregate using one or more operations over the specified axis. Parameters ---------- func : function, str, list or dict Function to use for aggregating the data. If a function, must either work when passed a DataFrame or when passed to DataFrame.apply. Accepted combinations are: - function - string function name - list of functions and/or function names, e.g. ``[np.sum, 'mean']`` - dict of axis labels -> functions, function names or list of such. *args Positional arguments to pass to `func`. **kwargs Keyword arguments to pass to `func`. Returns ------- scalar, Series or DataFrame The return can be: * scalar : when Series.agg is called with single function * Series : when DataFrame.agg is called with a single function * DataFrame : when DataFrame.agg is called with several functions See Also -------- DataFrame.groupby.aggregate : Aggregate using callable, string, dict, or list of string/callables. DataFrame.resample.transform : Transforms the Series on each group based on the given function. DataFrame.aggregate: Aggregate using one or more operations over the specified axis. Notes ----- The aggregation operations are always performed over an axis, either the index (default) or the column axis. This behavior is different from `numpy` aggregation functions (`mean`, `median`, `prod`, `sum`, `std`, `var`), where the default is to compute the aggregation of the flattened array, e.g., ``numpy.mean(arr_2d)`` as opposed to ``numpy.mean(arr_2d, axis=0)``. `agg` is an alias for `aggregate`. Use the alias. Functions that mutate the passed object can produce unexpected behavior or errors and are not supported. See :ref:`gotchas.udf-mutation` for more details. A passed user-defined-function will be passed a Series for evaluation. If ``func`` defines an index relabeling, ``axis`` must be ``0`` or ``index``. Examples -------- >>> s = pd.Series( ... [1, 2, 3, 4, 5], index=pd.date_range("20130101", periods=5, freq="s") ... ) >>> s 2013-01-01 00:00:00 1 2013-01-01 00:00:01 2 2013-01-01 00:00:02 3 2013-01-01 00:00:03 4 2013-01-01 00:00:04 5 Freq: s, dtype: int64 >>> r = s.resample("2s") >>> r.agg("sum") 2013-01-01 00:00:00 3 2013-01-01 00:00:02 7 2013-01-01 00:00:04 5 Freq: 2s, dtype: int64 >>> r.agg(["sum", "mean", "max"]) sum mean max 2013-01-01 00:00:00 3 1.5 2 2013-01-01 00:00:02 7 3.5 4 2013-01-01 00:00:04 5 5.0 5 >>> r.agg({"result": lambda x: x.mean() / x.std(), "total": "sum"}) result total 2013-01-01 00:00:00 2.121320 3 2013-01-01 00:00:02 4.949747 7 2013-01-01 00:00:04 NaN 5 >>> r.agg(average="mean", total="sum") average total 2013-01-01 00:00:00 1.5 3 2013-01-01 00:00:02 3.5 7 2013-01-01 00:00:04 5.0 5 )rr)ragg_groupby_and_aggregate)rjrrrresulthows rk aggregatezResampler.aggregateYsXF&dDtFKKKOOQQ >C0T0FtFFFvFFF rmc^|j|jj|g|Ri|S)a Call function producing a like-indexed Series on each group. Return a Series with the transformed values. Parameters ---------- arg : function To apply to each group. Should return a Series with the same index. *args, **kwargs Additional arguments and keywords. Returns ------- Series A Series with the transformed values, maintaining the same index as the original object. See Also -------- core.resample.Resampler.apply : Apply a function along each group. core.resample.Resampler.aggregate : Aggregate using one or more operations over the specified axis. Examples -------- >>> s = pd.Series([1, 2], index=pd.date_range("20180101", periods=2, freq="1h")) >>> s 2018-01-01 00:00:00 1 2018-01-01 01:00:00 2 Freq: h, dtype: int64 >>> resampled = s.resample("15min") >>> resampled.transform(lambda x: (x - x.mean()) / x.std()) 2018-01-01 00:00:00 NaN 2018-01-01 01:00:00 NaN Freq: h, dtype: float64 ) _selected_objgroupbyrK transform)rjargrrs rkrzResampler.transformsNPGt!))$*;<<F         rmc  t|rr)rjrrs rk _downsamplezResampler._downsamplerrmlimit int | Nonec t|rr)rjfr fill_values rk _upsamplezResampler._upsamplerrmndimintc|j}||j}| ||}n |jdksJ|dkr |jdksJt|d||j}|S) Sub-classes to define. Return a sliced object. Parameters ---------- key : string / list of selections ndim : {1, 2} requested ndim of result subset : object, default None subset to act on NbygrouperrW)rIrOrr$rW)rjrhrsubsetrgroupeds rk_gotitemzResampler._gotitems~- >XF{a'''' 199;!#### tW   rmc|j}|j}t|d||j} t rfd}||}n|jgRi}n^#t tf$r|jgRi}Yn:t$r.} dt| vrn|jgRi}Yd} ~ nd} ~ wwxYw| |S)zA Re-evaluate the obj with a groupby aggregation. Nrc|gRiSrr)xrrrs rkz2Resampler._groupby_and_aggregate..#s!Q!8!8!8!8!8!8rmzMust produce aggregated value) rI_obj_with_exclusionsr$rWcallablerAttributeErrorKeyErrorapplyrarn _wrap_result) rjrrrrrOrrrerrs ``` rkrz Resampler._groupby_and_aggregatesK-'cdGXXX 9}} A988888 **400**3@@@@@@) 9 9 9#W]3888888FFF 9 9 9.#c((::#W]3888888FFFFFF 9  (((s=A))"C C$B??Crr#c2||||S)zG Return the correct class for resampling with groupby. )rrhparent)_resampler_for_grouping)rjrrhs rk_get_resampler_for_groupingz%Resampler._get_resampler_for_grouping?s*++,   rmct|tr|j |j|_t|trL|jrE|j}t |jdd|j|_t|dd|_|j j D|j |j j |_|jjj|j_|S)z/ Potentially wrap any results. NrrQname) isinstancerrgremptyrO_asfreq_compatindexrQrrrKrr)rjrrOs rkrzResampler._wrap_resultNs fi ( ( *T_-H/FK fi ( ( 5V\ 5(C)#)BQB-diHHHFL!#vt44FK   ) 5!<..t/@/MNNFL $ 3FL  rmc0|d|S)aQ Forward fill the values. This method fills missing values by propagating the last valid observation forward, up to the next valid observation. It is commonly used in time series analysis when resampling data to a higher frequency (upsampling) and filling gaps in the resampled output. Parameters ---------- limit : int, optional Limit of how many values to fill. Returns ------- Series The resampled data with missing values filled forward. See Also -------- Series.fillna: Fill NA/NaN values using the specified method. DataFrame.fillna: Fill NA/NaN values using the specified method. Examples -------- Here we only create a ``Series``. >>> ser = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 Example for ``ffill`` with downsampling (we have fewer dates after resampling): >>> ser.resample("MS").ffill() 2023-01-01 1 2023-02-01 3 Freq: MS, dtype: int64 Example for ``ffill`` with upsampling (fill the new dates with the previous value): >>> ser.resample("W").ffill() 2023-01-01 1 2023-01-08 1 2023-01-15 2 2023-01-22 2 2023-01-29 2 2023-02-05 3 2023-02-12 3 2023-02-19 4 Freq: W-SUN, dtype: int64 With upsampling and limiting (only fill the first new date with the previous value): >>> ser.resample("W").ffill(limit=1) 2023-01-01 1.0 2023-01-08 1.0 2023-01-15 2.0 2023-01-22 2.0 2023-01-29 NaN 2023-02-05 3.0 2023-02-12 NaN 2023-02-19 4.0 Freq: W-SUN, dtype: float64 ffillrrrjrs rkrzResampler.ffillasZ~~gU~333rmc0|d|S)a& Resample by using the nearest value. When resampling data, missing values may appear (e.g., when the resampling frequency is higher than the original frequency). The `nearest` method will replace ``NaN`` values that appeared in the resampled data with the value from the nearest member of the sequence, based on the index value. Missing values that existed in the original data will not be modified. If `limit` is given, fill only this many values in each direction for each of the original values. Parameters ---------- limit : int, optional Limit of how many values to fill. Returns ------- Series or DataFrame An upsampled Series or DataFrame with ``NaN`` values filled with their nearest value. See Also -------- bfill : Backward fill the new missing values in the resampled data. ffill : Forward fill ``NaN`` values. Examples -------- >>> s = pd.Series([1, 2], index=pd.date_range("20180101", periods=2, freq="1h")) >>> s 2018-01-01 00:00:00 1 2018-01-01 01:00:00 2 Freq: h, dtype: int64 >>> s.resample("15min").nearest() 2018-01-01 00:00:00 1 2018-01-01 00:15:00 1 2018-01-01 00:30:00 2 2018-01-01 00:45:00 2 2018-01-01 01:00:00 2 Freq: 15min, dtype: int64 Limit the number of upsampled values imputed by the nearest: >>> s.resample("15min").nearest(limit=1) 2018-01-01 00:00:00 1.0 2018-01-01 00:15:00 1.0 2018-01-01 00:30:00 NaN 2018-01-01 00:45:00 2.0 2018-01-01 01:00:00 2.0 Freq: 15min, dtype: float64 nearestrrrs rkrzResampler.nearestsp~~iu~555rmc0|d|S)a Backward fill the new missing values in the resampled data. In statistics, imputation is the process of replacing missing data with substituted values [1]_. When resampling data, missing values may appear (e.g., when the resampling frequency is higher than the original frequency). The backward fill will replace NaN values that appeared in the resampled data with the next value in the original sequence. Missing values that existed in the original data will not be modified. Parameters ---------- limit : int, optional Limit of how many values to fill. Returns ------- Series, DataFrame An upsampled Series or DataFrame with backward filled NaN values. See Also -------- nearest : Fill NaN values with nearest neighbor starting from center. ffill : Forward fill NaN values. Series.fillna : Fill NaN values in the Series using the specified method, which can be 'backfill'. DataFrame.fillna : Fill NaN values in the DataFrame using the specified method, which can be 'backfill'. References ---------- .. [1] https://en.wikipedia.org/wiki/Imputation_%28statistics%29 Examples -------- Resampling a Series: >>> s = pd.Series( ... [1, 2, 3], index=pd.date_range("20180101", periods=3, freq="h") ... ) >>> s 2018-01-01 00:00:00 1 2018-01-01 01:00:00 2 2018-01-01 02:00:00 3 Freq: h, dtype: int64 >>> s.resample("30min").bfill() 2018-01-01 00:00:00 1 2018-01-01 00:30:00 2 2018-01-01 01:00:00 2 2018-01-01 01:30:00 3 2018-01-01 02:00:00 3 Freq: 30min, dtype: int64 >>> s.resample("15min").bfill(limit=2) 2018-01-01 00:00:00 1.0 2018-01-01 00:15:00 NaN 2018-01-01 00:30:00 2.0 2018-01-01 00:45:00 2.0 2018-01-01 01:00:00 2.0 2018-01-01 01:15:00 NaN 2018-01-01 01:30:00 3.0 2018-01-01 01:45:00 3.0 2018-01-01 02:00:00 3.0 Freq: 15min, dtype: float64 Resampling a DataFrame that has missing values: >>> df = pd.DataFrame( ... {"a": [2, np.nan, 6], "b": [1, 3, 5]}, ... index=pd.date_range("20180101", periods=3, freq="h"), ... ) >>> df a b 2018-01-01 00:00:00 2.0 1 2018-01-01 01:00:00 NaN 3 2018-01-01 02:00:00 6.0 5 >>> df.resample("30min").bfill() a b 2018-01-01 00:00:00 2.0 1 2018-01-01 00:30:00 NaN 3 2018-01-01 01:00:00 NaN 3 2018-01-01 01:30:00 6.0 5 2018-01-01 02:00:00 6.0 5 >>> df.resample("15min").bfill(limit=2) a b 2018-01-01 00:00:00 2.0 1.0 2018-01-01 00:15:00 NaN NaN 2018-01-01 00:30:00 NaN 3.0 2018-01-01 00:45:00 NaN 3.0 2018-01-01 01:00:00 NaN 3.0 2018-01-01 01:15:00 NaN NaN 2018-01-01 01:30:00 6.0 5.0 2018-01-01 01:45:00 6.0 5.0 2018-01-01 02:00:00 6.0 5.0 bfillrrrs rkrzResampler.bfillsH~~gU~333rmlinearrforward)axisrlimit_direction limit_areamethodr<rr8r&Literal['forward', 'backward', 'both']c d|vrdtjdt|jdtt |d}|rtd|d}|j } t| j t} | s|j } t| trtd| j | } t!| dkr.t#|| j| g}|jd |||d ||d |} | r| S| j| } | | _ | S) a Interpolate values between target timestamps according to different methods. The original index is first reindexed to target timestamps (see :meth:`core.resample.Resampler.asfreq`), then the interpolation of ``NaN`` values via :meth:`DataFrame.interpolate` happens. Parameters ---------- method : str, default 'linear' Interpolation technique to use. One of: * 'linear': Ignore the index and treat the values as equally spaced. This is the only method supported on MultiIndexes. * 'time': Works on daily and higher resolution data to interpolate given length of interval. * 'index', 'values': use the actual numerical values of the index. * 'pad': Fill in NaNs using existing values. * 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'barycentric', 'polynomial': Passed to `scipy.interpolate.interp1d`, whereas 'spline' is passed to `scipy.interpolate.UnivariateSpline`. These methods use the numerical values of the index. Both 'polynomial' and 'spline' require that you also specify an `order` (int), e.g. ``df.interpolate(method='polynomial', order=5)``. Note that, `slinear` method in Pandas refers to the Scipy first order `spline` instead of Pandas first order `spline`. * 'krogh', 'piecewise_polynomial', 'spline', 'pchip', 'akima', 'cubicspline': Wrappers around the SciPy interpolation methods of similar names. See `Notes`. * 'from_derivatives': Refers to `scipy.interpolate.BPoly.from_derivatives`. axis : {{0 or 'index', 1 or 'columns', None}}, default None Axis to interpolate along. For `Series` this parameter is unused and defaults to 0. limit : int, optional Maximum number of consecutive NaNs to fill. Must be greater than 0. limit_direction : {{'forward', 'backward', 'both'}}, Optional Consecutive NaNs will be filled in this direction. limit_area : {{`None`, 'inside', 'outside'}}, default None If limit is specified, consecutive NaNs will be filled with this restriction. * ``None``: No fill restriction. * 'inside': Only fill NaNs surrounded by valid values (interpolate). * 'outside': Only fill NaNs outside valid values (extrapolate). **kwargs : optional Keyword arguments to pass on to the interpolating function. Returns ------- DataFrame or Series Interpolated values at the specified freq. See Also -------- core.resample.Resampler.asfreq: Return the values at the new freq, essentially a reindex. DataFrame.interpolate: Fill NaN values using an interpolation method. DataFrame.bfill : Backward fill NaN values in the resampled data. DataFrame.ffill : Forward fill NaN values. Notes ----- For high-frequent or non-equidistant time-series with timestamps the reindexing followed by interpolation may lead to information loss as shown in the last example. Examples -------- >>> start = "2023-03-01T07:00:00" >>> timesteps = pd.date_range(start, periods=5, freq="s") >>> series = pd.Series(data=[1, -1, 2, 1, 3], index=timesteps) >>> series 2023-03-01 07:00:00 1 2023-03-01 07:00:01 -1 2023-03-01 07:00:02 2 2023-03-01 07:00:03 1 2023-03-01 07:00:04 3 Freq: s, dtype: int64 Downsample the dataframe to 0.5Hz by providing the period time of 2s. >>> series.resample("2s").interpolate("linear") 2023-03-01 07:00:00 1 2023-03-01 07:00:02 2 2023-03-01 07:00:04 3 Freq: 2s, dtype: int64 Upsample the dataframe to 2Hz by providing the period time of 500ms. >>> series.resample("500ms").interpolate("linear") 2023-03-01 07:00:00.000 1.0 2023-03-01 07:00:00.500 0.0 2023-03-01 07:00:01.000 -1.0 2023-03-01 07:00:01.500 0.5 2023-03-01 07:00:02.000 2.0 2023-03-01 07:00:02.500 1.5 2023-03-01 07:00:03.000 1.0 2023-03-01 07:00:03.500 2.0 2023-03-01 07:00:04.000 3.0 Freq: 500ms, dtype: float64 Internal reindexing with ``asfreq()`` prior to interpolation leads to an interpolated timeseries on the basis of the reindexed timestamps (anchors). It is assured that all available datapoints from original series become anchors, so it also works for resampling-cases that lead to non-aligned timestamps, as in the following example: >>> series.resample("400ms").interpolate("linear") 2023-03-01 07:00:00.000 1.000000 2023-03-01 07:00:00.400 0.333333 2023-03-01 07:00:00.800 -0.333333 2023-03-01 07:00:01.200 0.000000 2023-03-01 07:00:01.600 1.000000 2023-03-01 07:00:02.000 2.000000 2023-03-01 07:00:02.400 1.666667 2023-03-01 07:00:02.800 1.333333 2023-03-01 07:00:03.200 1.666667 2023-03-01 07:00:03.600 2.333333 2023-03-01 07:00:04.000 3.000000 Freq: 400ms, dtype: float64 Note that the series correctly decreases between two anchors ``07:00:00`` and ``07:00:02``. inplacezThe 'inplace' keyword in zo.interpolate is deprecated and will be removed in a future version. resample(...).interpolate is never inplace. stacklevelz1Cannot interpolate inplace on a resampled object.asfreqa-Direct interpolation of MultiIndex data frames is not supported. If you tried to resample and interpolate on a grouped data frame, please use: `df.groupby(...).apply(lambda x: x.resample(...).interpolate(...))` instead, as resampling and interpolation has to be performed for each group independently.rF)rrrrrrr)warningswarnrxryrrpoprarrrrr+r'NotImplementedError differencerr/loc sort_index interpolate)rjrrrrrrrrrOis_period_index final_indexmissing_data_points_indexresult_interpolateds rkrzResampler.interpolatePs`    M>DJJ,?>>>+--     jj++G V !TUUU))  $SY <<  ,K+z22 )>), (<(<[(I(I %,--11SW%>?@*,,1f0 +!       '& &25kB%0!""rmc0|d|S)a' Return the values at the new freq, essentially a reindex. Parameters ---------- fill_value : scalar, optional Value to use for missing values, applied during upsampling (note this does not fill NaNs that already were present). Returns ------- DataFrame or Series Values at the specified freq. See Also -------- Series.asfreq: Convert TimeSeries to specified frequency. DataFrame.asfreq: Convert TimeSeries to specified frequency. Examples -------- >>> ser = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-31", "2023-02-01", "2023-02-28"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-31 2 2023-02-01 3 2023-02-28 4 dtype: int64 >>> ser.resample("MS").asfreq() 2023-01-01 1 2023-02-01 3 Freq: MS, dtype: int64 r)rr)rjrs rkrzResampler.asfreq sR~~h:~>>>rm numeric_only min_countc2|d||S)aq Compute sum of group values. This method provides a simple way to compute the sum of values within each resampled group, particularly useful for aggregating time-based data into daily, monthly, or yearly sums. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. .. versionchanged:: 2.0.0 numeric_only no longer accepts ``None``. min_count : int, default 0 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NA values are present the result will be NA. Returns ------- Series or DataFrame Computed sum of values within each group. See Also -------- core.resample.Resampler.mean : Compute mean of groups, excluding missing values. core.resample.Resampler.count : Compute count of group, excluding missing values. DataFrame.resample : Resample time-series data. Series.sum : Return the sum of the values over the requested axis. Examples -------- >>> ser = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 >>> ser.resample("MS").sum() 2023-01-01 3 2023-02-01 7 Freq: MS, dtype: int64 sumrrrrjrrs rkrz Resampler.sumKs tLIVVVrmc2|d||S)a} Compute prod of group values. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. .. versionchanged:: 2.0.0 numeric_only no longer accepts ``None``. min_count : int, default 0 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NA values are present the result will be NA. Returns ------- Series or DataFrame Computed prod of values within each group. See Also -------- core.resample.Resampler.sum : Compute sum of groups, excluding missing values. core.resample.Resampler.mean : Compute mean of groups, excluding missing values. core.resample.Resampler.median : Compute median of groups, excluding missing values. Examples -------- >>> ser = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 >>> ser.resample("MS").prod() 2023-01-01 2 2023-02-01 12 Freq: MS, dtype: int64 prodrrrs rkrzResampler.prods j\YWWWrmc2|d||S)av Compute min value of group. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. .. versionchanged:: 2.0.0 numeric_only no longer accepts ``None``. min_count : int, default 0 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NA values are present the result will be NA. Returns ------- Series or DataFrame Compute the minimum value in the given Series or DataFrame. See Also -------- core.resample.Resampler.max : Compute max value of group. core.resample.Resampler.mean : Compute mean of groups, excluding missing values. core.resample.Resampler.median : Compute median of groups, excluding missing values. Examples -------- >>> ser = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 >>> ser.resample("MS").min() 2023-01-01 1 2023-02-01 3 Freq: MS, dtype: int64 minrrrs rkrz Resampler.min jLIVVVrmc2|d||S)aw Compute max value of group. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. .. versionchanged:: 2.0.0 numeric_only no longer accepts ``None``. min_count : int, default 0 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NA values are present the result will be NA. Returns ------- Series or DataFrame Computes the maximum value in the given Series or Dataframe. See Also -------- core.resample.Resampler.min : Compute min value of group. core.resample.Resampler.mean : Compute mean of groups, excluding missing values. core.resample.Resampler.median : Compute median of groups, excluding missing values. Examples -------- >>> ser = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 >>> ser.resample("MS").max() 2023-01-01 2 2023-02-01 4 Freq: MS, dtype: int64 maxrrrs rkr z Resampler.maxrrmTskipnac4|d|||S)a- Compute the first non-null entry of each column. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. min_count : int, default 0 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NA values are present the result will be NA. skipna : bool, default True Exclude NA/null values. If an entire group is NA, the result will be NA. Returns ------- Series or DataFrame First values within each group. See Also -------- core.resample.Resampler.last : Compute the last non-null value in each group. core.resample.Resampler.mean : Compute mean of groups, excluding missing values. Examples -------- >>> s = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> s 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 >>> s.resample("MS").first() 2023-01-01 1 2023-02-01 3 Freq: MS, dtype: int64 firstrrr rrjrrr s rkr zResampler.first,s+b ,)F    rmc4|d|||S)a/ Compute the last non-null entry of each column. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. min_count : int, default 0 The required number of valid values to perform the operation. If fewer than ``min_count`` non-NA values are present the result will be NA. skipna : bool, default True Exclude NA/null values. If an entire group is NA, the result will be NA. Returns ------- Series or DataFrame Last of values within each group. See Also -------- core.resample.Resampler.first : Compute the first non-null value in each group. core.resample.Resampler.mean : Compute mean of groups, excluding missing values. Examples -------- >>> s = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> s 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 >>> s.resample("MS").last() 2023-01-01 2 2023-02-01 4 Freq: MS, dtype: int64 lastrrrs rkrzResampler.lastas+b 6    rmc0|d|S)a Compute median of groups, excluding missing values. For multiple groupings, the result index will be a MultiIndex Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. .. versionchanged:: 2.0.0 numeric_only no longer accepts ``None`` and defaults to False. Returns ------- Series or DataFrame Median of values within each group. See Also -------- Series.groupby : Apply a function groupby to a Series. DataFrame.groupby : Apply a function groupby to each row or column of a DataFrame. Examples -------- >>> ser = pd.Series( ... [1, 2, 3, 3, 4, 5], ... index=pd.DatetimeIndex( ... [ ... "2023-01-01", ... "2023-01-10", ... "2023-01-15", ... "2023-02-01", ... "2023-02-10", ... "2023-02-15", ... ] ... ), ... ) >>> ser.resample("MS").median() 2023-01-01 2.0 2023-02-01 4.0 Freq: MS, dtype: float64 medianrrrjrs rkrzResampler.medians`|DDDrmc0|d|S)aM Compute mean of groups, excluding missing values. Parameters ---------- numeric_only : bool, default False Include only `float`, `int` or `boolean` data. .. versionchanged:: 2.0.0 numeric_only now defaults to ``False``. Returns ------- DataFrame or Series Mean of values within each group. See Also -------- core.resample.Resampler.median : Compute median of groups, excluding missing values. core.resample.Resampler.sum : Compute sum of groups, excluding missing values. core.resample.Resampler.std : Compute standard deviation of groups, excluding missing values. core.resample.Resampler.var : Compute variance of groups, excluding missing values. Examples -------- >>> ser = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 >>> ser.resample("MS").mean() 2023-01-01 1.5 2023-02-01 3.5 Freq: MS, dtype: float64 meanrrrs rkrzResampler.meansh\BBBrmrddofc2|d||S)a Compute standard deviation of groups, excluding missing values. Parameters ---------- ddof : int, default 1 Degrees of freedom. numeric_only : bool, default False Include only `float`, `int` or `boolean` data. .. versionchanged:: 2.0.0 numeric_only now defaults to ``False``. Returns ------- DataFrame or Series Standard deviation of values within each group. See Also -------- core.resample.Resampler.mean : Compute mean of groups, excluding missing values. core.resample.Resampler.median : Compute median of groups, excluding missing values. core.resample.Resampler.var : Compute variance of groups, excluding missing values. Examples -------- >>> ser = pd.Series( ... [1, 3, 2, 4, 3, 8], ... index=pd.DatetimeIndex( ... [ ... "2023-01-01", ... "2023-01-10", ... "2023-01-15", ... "2023-02-01", ... "2023-02-10", ... "2023-02-15", ... ] ... ), ... ) >>> ser.resample("MS").std() 2023-01-01 1.000000 2023-02-01 2.645751 Freq: MS, dtype: float64 stdrrrrjrrs rkrz Resampler.std lD|LLLrmc2|d||S)a Compute variance of groups, excluding missing values. Parameters ---------- ddof : int, default 1 Degrees of freedom. numeric_only : bool, default False Include only `float`, `int` or `boolean` data. .. versionchanged:: 2.0.0 numeric_only now defaults to ``False``. Returns ------- DataFrame or Series Variance of values within each group. See Also -------- core.resample.Resampler.std : Compute standard deviation of groups, excluding missing values. core.resample.Resampler.mean : Compute mean of groups, excluding missing values. core.resample.Resampler.median : Compute median of groups, excluding missing values. Examples -------- >>> ser = pd.Series( ... [1, 3, 2, 4, 3, 8], ... index=pd.DatetimeIndex( ... [ ... "2023-01-01", ... "2023-01-10", ... "2023-01-15", ... "2023-02-01", ... "2023-02-10", ... "2023-02-15", ... ] ... ), ... ) >>> ser.resample("MS").var() 2023-01-01 1.0 2023-02-01 7.0 Freq: MS, dtype: float64 >>> ser.resample("MS").var(ddof=0) 2023-01-01 0.666667 2023-02-01 4.666667 Freq: MS, dtype: float64 varrrrs rkrz Resampler.var6s xD|LLLrmc2|d||S)a` Compute standard error of the mean of groups, excluding missing values. For multiple groupings, the result index will be a MultiIndex. Parameters ---------- ddof : int, default 1 Degrees of freedom. numeric_only : bool, default False Include only `float`, `int` or `boolean` data. .. versionchanged:: 2.0.0 numeric_only now defaults to ``False``. Returns ------- Series or DataFrame Standard error of the mean of values within each group. See Also -------- DataFrame.sem : Return unbiased standard error of the mean over requested axis. Series.sem : Return unbiased standard error of the mean over requested axis. Examples -------- >>> ser = pd.Series( ... [1, 3, 2, 4, 3, 8], ... index=pd.DatetimeIndex( ... [ ... "2023-01-01", ... "2023-01-10", ... "2023-01-15", ... "2023-02-01", ... "2023-02-10", ... "2023-02-15", ... ] ... ), ... ) >>> ser.resample("MS").sem() 2023-01-01 0.577350 2023-02-01 1.527525 Freq: MS, dtype: float64 semrrrs rkr!z Resampler.semtrrmc|j}|j}t|dkr|}t |j|j|_|jdkr.|}| gdd}n4tj |j gdg}| |d}|S| dS)a@ Compute open, high, low and close values of a group, excluding missing values. Returns ------- DataFrame Open, high, low and close values within each group. See Also -------- DataFrame.agg : Aggregate using one or more operations over the specified axis. DataFrame.resample : Resample time-series data. DataFrame.groupby : Group DataFrame using a mapper or by a Series of columns. Examples -------- >>> ser = pd.Series( ... [1, 3, 2, 4, 3, 5], ... index=pd.DatetimeIndex( ... [ ... "2023-01-01", ... "2023-01-10", ... "2023-01-15", ... "2023-02-01", ... "2023-02-10", ... "2023-02-15", ... ] ... ), ... ) >>> ser.resample("MS").ohlc() open high low close 2023-01-01 1 3 1 2 2023-02-01 4 5 3 5 rr)openhighlowclose)rohlc)rNrrcopyrrrQrto_framereindexr' from_productcolumnsr)rjrNrOmis rkr'zResampler.ohlcsHW' r77a<<((**C&sy$)<>> ser = pd.Series( ... [1, 2, 3, 3], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 3 dtype: int64 >>> ser.resample("MS").nunique() 2023-01-01 2 2023-02-01 1 Freq: MS, dtype: int64 nuniquerrs rkr/zResampler.nuniquesB ***rmc*|d}t|tr|js|}t |js9ddlm}|j j dkr |j j }nd}|g|j d|}|S)a Compute group sizes. Returns ------- Series Number of rows in each group. See Also -------- Series.groupby : Apply a function groupby to a Series. DataFrame.groupby : Apply a function groupby to each row or column of a DataFrame. Examples -------- >>> ser = pd.Series( ... [1, 2, 3], ... index=pd.DatetimeIndex(["2023-01-01", "2023-01-15", "2023-02-01"]), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 dtype: int64 >>> ser.resample("MS").size() 2023-01-01 2 2023-02-01 1 Freq: MS, dtype: int64 sizer)rErNint64rdtyper) rrrrstackrrNpandasrErrrr)rjrrErs rkr1zResampler.sizes@!!&)) fl + + $FL $\\^^F47|| N % % % % % %!&!++).VBfl'MMMF rmc|d}t|js`|jjdkr1t |jg|jd|jj}nddlm }|g|j|j d}|S)ag Compute count of group, excluding missing values. Returns ------- Series or DataFrame Count of values within each group. See Also -------- Series.groupby : Apply a function groupby to a Series. DataFrame.groupby : Apply a function groupby to each row or column of a DataFrame. Examples -------- >>> ser = pd.Series( ... [1, 2, 3, 4], ... index=pd.DatetimeIndex( ... ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-15"] ... ), ... ) >>> ser 2023-01-01 1 2023-01-15 2 2023-02-01 3 2023-02-15 4 dtype: int64 >>> ser.resample("MS").count() 2023-01-01 2 2023-02-01 2 Freq: MS, dtype: int64 countrr2r3r)rD)rr,r4) rrrNrrrxrrr6rDr,)rjrrDs rkr8zResampler.count6sF!!'**47|| !&!++1d011fl'@R@W-,,,,,"flFN' rm?q"float | list[float] | AnyArrayLikec  |jdd|i|S)ac Return value at the given quantile. Computes the quantile of values within each resampled group. Parameters ---------- q : float or array-like, default 0.5 (50% quantile) Value between 0 <= q <= 1, the quantile(s) to compute. **kwargs Additional keyword arguments to be passed to the function. Returns ------- DataFrame or Series Quantile of values within each group. See Also -------- Series.quantile Return a series, where the index is q and the values are the quantiles. DataFrame.quantile Return a DataFrame, where the columns are the columns of self, and the values are the quantiles. DataFrameGroupBy.quantile Return a DataFrame, where the columns are groupby columns, and the values are its quantiles. Examples -------- >>> ser = pd.Series( ... [1, 3, 2, 4, 3, 8], ... index=pd.DatetimeIndex( ... [ ... "2023-01-01", ... "2023-01-10", ... "2023-01-15", ... "2023-02-01", ... "2023-02-10", ... "2023-02-15", ... ] ... ), ... ) >>> ser.resample("MS").quantile() 2023-01-01 2.0 2023-02-01 4.0 Freq: MS, dtype: float64 >>> ser.resample("MS").quantile(0.25) 2023-01-01 1.5 2023-02-01 3.5 Freq: MS, dtype: float64 quantiler:)r=r)rjr:rs rkr=zResampler.quantilehs#p t::a:6:::rm) rOr!rZrJr[r(rWr\rYr\r]r^)r]rn)r}rn)r]r\rOrr]r)rrrrrrr]r>)rrrr6rr6r]r>)rrrr6rr6r]r>rNNrr)rr)rr#)r)rr<rr8rrrr)Fr)rr\rr)FrT)rr\rrr r\F)rr\)rF)rrrr\)r9)r:r;)5ry __module__ __qualname____doc____annotations__rirMsetrrwrlr r|rpropertyrrerrfr rrrrrrrrrrrrrrrrrrrr r rrrrrr!r'r/r1r8r= __classcell__rs@rkrHrHws;(8888&/ikkJ1111#77788K!$******8  = = = U = 333 U3     X U  " " " "(((  # # U #XX L3L3L3L3L3 UL3\ ggg UgR C E ) )  U) V((((((((8))))))V      U  & L4L4L4L4 UL4\ 76767676 U76r c4c4c4c4 Uc4J &.M# BKM#M#M#M#M# UM#^ (?(?(? U(?T #9W9W9W9W U9Wv #4X4X4X4X U4Xl #4W4W4W4W U4Wl #4W4W4W4W U4Wl # 2 2 2 2  U2 h # 2 2 2 2  U2 h /E/E/E/E U/Eb #3C3C3C3C U3Cj "5M5M5M5M U5Mn ";M;M;M;M U;Mz "5M5M5M5M U5Mn 3(3( U3(j  + + U +D .. U.` // U/b 7;7;7;7; U7;7;7;7;7;rmrHceZdZUdZded<dZded<ded<d ed <ddd ddZedZeZ eZ eZ e ddZ dS) _GroupByMixinz) Provide the groupby facilities. z list[str]rwNIndexLabel | Nonergr#_groupbyrJrK)rhrXrrHrrXr]r^c t|tsJt|t|tsJt||jD]!}t ||t ||"||_|j|_||_ ||_ tj |j |_ |j |_ |j|_dSr)rr#rxrHrwsetattrrrrgrLrhrMr(rKrNrO)rjrrrhrXr}s rkrlz_GroupByMixin.__init__s'7++::T']]::+&),,::d6ll::,$ 7 7D D$ 5 5 6 6 6 6#m   If&9::):rmcvfd}j|}t|trjt |dkrWt|jt s=|tj jddj d} |S)z Dispatch to _upsample; we are stripping all of the _upsample kwargs and performing the original function call on the grouped object. c|jj}ttrt |diS|jgRiS)N)rZr[r)_resampler_clsrKrNrrnrrr)rrrrrjs rkrz"_GroupByMixin._apply..funcsv##A43DPTPW#XXA!S!! /$wq!}}..v...171.t...v.. .rmrNrT)append) rMrrrrrr+ set_indexrrOrQr)rjrrrrrs```` rk_applyz_GroupByMixin._applys / / / / / / / /$$T** v| , , F q  v|[99!%%tx~bqb1 BBB4&F  (((rmc||j}| ||}n |jdksJ t|tr*|j|vr!|j||j|j|}n#t$r |j}YnwxYw|||}t||tt||}|S)rNr)rrrX) rOrrlistrhrSrM IndexError_infer_selectionrxrrH)rjrhrrrrXnew_rss rkrz_GroupByMixin._gotitems >XF{a'''' $#t$$ %)<)<AU 48$$$mC(GG $ $ $mGGG $))#v66 d 4((     sA A00BB)rrHrr#rXrLr]r^r)ryrBrCrDrErgrlr rUrrrr rrrmrkrKrKs$(J(((( '+ <))])8IK# $$$ U$$$rmrKc^eZdZUded<eddZdZdZdZddd Z fd Z xZ S)DatetimeIndexResamplerr)rNr]#type[DatetimeIndexResamplerGroupby]ctSr)DatetimeIndexResamplerGroupbyrs rkrz.DatetimeIndexResampler._resampler_for_groupings,,rmc@|j|jSr)rK_get_time_binsrNrs rkrz+DatetimeIndexResampler._get_binner_for_times //888rmc |j}|j}t|sj|}|j|j|_|jj|jksJ|jj|jf|S||jj |fi|}| |S) Downsample the cython defined function. Parameters ---------- how : string / cython mapped function **kwargs : kw args passed to how function ) rNrrr(r _with_freqrQrrIrr)rjrrrNrOrs rkrz"DatetimeIndexResampler._downsamplesW'2ww ((**C ,,TY77CI9>TY...0K...J6T]++5cDDVDD  (((rmcF|jdkr |dd}n |dd}|S)z| Adjust our binner when upsampling. The range of a new index should not be outside specified range rightrN)rRrjrLs rk_adjust_binner_for_upsamplez2DatetimeIndexResampler._adjust_binner_for_upsample9s2 ;' ! !ABBZFFCRC[F rmNrrc|jrtd|j}|j}|j}||}|st |j|jkrVt|t|kr6|j |r| }||_ n!|dkrd}| ||||}||S)aF Parameters ---------- method : string {'backfill', 'bfill', 'pad', 'ffill', 'asfreq'} method for upsampling limit : int, default None Maximum size gap to fill when reindexing fill_value : scalar, default None Value to use for missing values zvUpsampling from level= or on= selection is not supported, use .set_index(...) to explicitly set index to datetime-likeNr)rrr)rrarNrrLrir inferred_freqrQrrequalsr(r*r) rjrrrrNrOrL res_indexrs rkrz DatetimeIndexResampler._upsampleEs   ;  W 44V<<  M"*++ty88CC NN**   +++XXZZF$FLL!![[&*!F  (((rmct|}t|jtrt|jtst|jt rqt|jjdtsK|jjd|j }|j |d|_n$|j|j |_|S)Nrg)r) rrrrNr+rr'levels to_periodrQ set_levels)rjr new_levelrs rkrz#DatetimeIndexResampler._wrap_resultns%%f-- dg{ + + AJ L+5 5 A&, 33 A!&,"5b"9;GGP & 3B 7 A A$) L LI#)<#:#:9B#:#O#OFL%|55di@@  rm)r]r]r?r@) ryrBrCrErGrrrrirrrHrIs@rkr\r\s ---X-999)))4   ')')')')')Rrmr\c(eZdZdZedZdS)r_z9 Provides a resample of a groupby implementation ctSr)r\rs rkrRz,DatetimeIndexResamplerGroupby._resampler_clss%%rmNryrBrCrDrGrRrrmrkr_r_s9 &&X&&&rmr_cXeZdZUded<edZdZdfd Zd Zddd Z xZ S)PeriodIndexResamplerr+rNctSr)PeriodIndexResamplerGroupbyrs rkrz,PeriodIndexResampler._resampler_for_groupings**rmc@|j|jSr)rK_get_period_binsrNrs rkrz)PeriodIndexResampler._get_binner_for_times 11$':::rmrOrr]czt|}|jrd}t||S)NzResampling from level= or on= selection with a PeriodIndex is not currently supported, use .set_index(...) to explicitly set index)rrerr)rjrOmsgrs rkrez!PeriodIndexResampler._convert_objsDgg""3''   +>  &c** * rmc z|j}t|j|jr|j|fi|St |j|jr/|dkr||S|S|j|jkr|St d|jd|jd)rcr'z Frequency z cannot be resampled to z&, as they are not sub or super periods)rNr0rQrr1rr)rjrrrNs rkrz PeriodIndexResampler._downsamplesW  + + !.4.s==f== = BGTY / / !f}} 223777;;== W ! !;;== # 3 3 3$) 3 3 3   rmNrrc|j}|j}|j}||j|j}|dkrd}||||}t|||} || S)a8 Parameters ---------- method : {'backfill', 'bfill', 'pad', 'ffill'} Method for upsampling. limit : int, default None Maximum size gap to fill when reindexing. fill_value : scalar, default None Value to use for missing values. rrN)rr) rNrOrLrrQrT get_indexer_take_new_indexr) rjrrrrNrO new_indexmembrnew_objs rkrzPeriodIndexResampler._upsamplesWhK yyy88 X  F""9V5"II!        )))rmr>r?r@) ryrBrCrErGrrrerrrHrIs@rkrwrwsOOO ++X+;;;         >*********rmrwc(eZdZdZedZdS)ry: Provides a resample of a groupby implementation. ctSr)rwrs rkrRz*PeriodIndexResamplerGroupby._resampler_clss##rmNrurrmrkryrys9 $$X$$$rmryc<eZdZUded<edZdZdZdS)TimedeltaIndexResamplerr-rNctSr)TimedeltaIndexResamplerGroupbyrs rkrz/TimedeltaIndexResampler._resampler_for_groupings--rmc@|j|jSr)rK_get_time_delta_binsrNrs rkrz,TimedeltaIndexResampler._get_binner_for_times 55dg>>>rmc|S)z Adjust our binner when upsampling. The range of a new index is allowed to be greater than original range so we don't need to change the length of a binner, GH 13022 rrhs rkriz3TimedeltaIndexResampler._adjust_binner_for_upsample s  rmN)ryrBrCrErGrrrirrmrkrrs[ ..X.???rmrc(eZdZdZedZdS)rrctSr)rrs rkrRz-TimedeltaIndexResamplerGroupby._resampler_cls s&&rmNrurrmrkrr s9 ''X'''rmrrOSeries | DataFramer]c Ft|fi|}||S)z8 Create a TimeGrouper and return our resampler. )rJ_get_resampler)rOkwdstgs rk get_resamplerr s- S ! !D ! !B  S ! !!rmrr#rrc td||d|}||j}|||jS)zA Return our appropriate resampler when grouping as well. rQrh)rrhr)rJrrOrrh) rruler fill_methodronrr resamplers rkget_resampler_for_groupingr% sN  1$B 1 1& 1 1B!!'+..I  0 0bf 0 M MMrmceZdZUdZgejddddddRZded< dd"Z d?d@d(Z dAd+Z dBd0Z dCd2Z dAd3Z dDd5Z dEd d6dFfd;ZxZS)GrJah Custom groupby class for time-interval grouping. Parameters ---------- freq : pandas date offset or offset alias for identifying bin edges closed : closed end of interval; 'left' or 'right' label : interval boundary to use for labeling; 'left' or 'right' convention : {'start', 'end', 'e', 's'} If axis is PeriodIndex rRrSrrTrUrVr@NMinr start_dayFrOGrouper | NonerQr:rh str | NoneLiteral['left', 'right'] | Nonernrr(Literal['start', 'end', 'e', 's'] | NoneTLiteral['epoch', 'start', 'start_day', 'end', 'end_day'] | TimestampConvertibleTypes TimedeltaConvertibleTypes | NonerWr\r]r^c  |dvrtd|d|dvrtd|d| dvrtd| d||t|jts|/|-t ||dddkrt |d }nt |}t|t sX| (tjd tt | d kr(tjdtt hd}|j }||vs#d|vr(|d| d|vr |d}|d}n| dvr |d}|d}n|d}|d}||_ ||_| | nd|_||_||_||_| |_d|_| dvr| |_nC t-| |_n-#tt.f$r}td| d|d}~wwxYw | t1| nd|_n-#tt.f$r}td| d|d}~wwxYwd | d<t5jd||d| dS)N>NleftrfzUnsupported value z for `label`z for `closed`>Nesendstartz for `convention`r4periodT) is_periodzsThe 'offset' keyword does not take effect when resampling with a 'freq' that is not Tick-like (h, m, s, ms, us, ns)rrzsThe 'origin' keyword does not take effect when resampling with a 'freq' that is not Tick-like (h, m, s, ms, us, ns)>WMEQEYEBMEBQEBYE-rfrend_dayrr)epochrrrrz|'origin' should be equal to 'epoch', 'start', 'start_day', 'end', 'end_day' or should be a Timestamp convertible type. Got 'z ' instead.z6'offset' should be a Timedelta convertible type. Got 'r`rr)rarrr+rrrr3rrRuntimeWarningr rule_codefindrRrSrTrrrrWrrUr TypeErrorrrVrrl)rjrOrQrhrRrSrrrrTrUrVrWr end_typesrrrs rkrlzTimeGrouper.__init__Q sO* / / /E%EEEFF F 0 0 0G&GGGHH H = = =O*OOOPP P KCO 39k0R0RO OC'400H<<TT222DDT??D$%% ! P"/11  $$ P"/11 A@@ ~ 9  6F #6F1G91T1T~ }) ) )~ }~}  (2(>**C& $/3 F F F !DKK '//  *    WDJWWW   /5/A)F+++tDKKI&   ++++  v6d66v66666s0+GG*G%%G*.HH1H,,H1r!rHc||d\}}}t|trt|||j|St|t rt |||j|St|trt|||j|Stdt|j d)a  Return my resampler or raise if we have an invalid axis. Parameters ---------- obj : Series or DataFrame Returns ------- Resampler Raises ------ TypeError if incompatible axis Nr[)rZrWr[zVOnly valid with DatetimeIndex, TimedeltaIndex or PeriodIndex, but got an instance of '') rdrr)r\rWr+rwr-rrrxry)rjrO_rNs rkrzTimeGrouper._get_resampler s"$$SD$992q b- ( ( ) ?   K ( ( ' ?   N + + * ?   <'+Bxx'8 < < <   rmTrvalidateobservedtuple[BinGrouper, NDFrameT]cn||}|jtt|jfS)a Parameters ---------- obj : Series or DataFrame Object being grouped. validate : bool, default True Unused. Only for compatibility with ``Grouper._get_grouper``. observed : bool, default True Unused. Only for compatibility with ``Grouper._get_grouper``. Returns ------- A tuple of grouper, obj (possibly sorted) )rrIrrrO)rjrOrrrs rk _get_grouperzTimeGrouper._get_grouper s0$    $ $z4!%0000rmrNr)c t|ts$tdt|jt |dkr)tg|j|j|jx}}|g|fSt| | |j|j |j |j|j\}}t!|j|||j|jdd|j x}}|j}|||\}}t)j|||j |j}|j d kr|}|jd kr |d d}n|jd kr |d d}|jr6|dt2}|dt2}t |t |kr|dt |}|||fS) N5axis must be a DatetimeIndex, but got an instance of rdatarQrr4unitrRrUrVT shift_forward)rQrrtzr ambiguous nonexistentr)hasnansrfr)rr)rrxryrrQrr4_get_timestamp_range_edgesrr rrRrUrVr*rasi8_adjust_bin_edgesr generate_bins_dt64rrSinsertr) rjrNrLlabelsr r ax_values bin_edgesrs rkrazTimeGrouper._get_time_bins s "m,, 6"&r(("366  r77a<<+dibgRX FV2v% %0 FFHH FFHH I;;;   t %u'    G  2269EE % y$+rz    ;' ! !FzW$$ Z7 " "ABBZF : +]]1c**F]]1c**F t99s6{{ " "Kc$iiK(FtV##rmrLrnpt.NDArray[np.int64]+tuple[DatetimeIndex, npt.NDArray[np.int64]]c*|jjdvs'|jjdddvr|jdkr|d}|t d|jzt d|j|jz }||jj }n|j }|d | kr|dd }|dd }n|j }||fS) N)rrrrr)rrrrrrfr)daysrrg) rQrsplitrR tz_localizeras_unitrrrr )rjrLr edges_dtirs rkrzTimeGrouper._adjust_bin_edgesK s 9>/ / /49>3G3G3L3LQ3OT 4 4 {g%%"..t44 Q'''// ??@ 777?? OOP &11&)<<A "K }y}}..%crcN  Iy  rmr-ct|ts$tdt|jt|jt tfstd|jt|s#tg|j|j x}}|g|fS| | }}|j dkr ||jz }t|||j|j x}}|}|j dkr ||jz }|||j }|jr ||jz }|||fS)Nz6axis must be a TimedeltaIndex, but got an instance of zWResampling on a TimedeltaIndex requires fixed-duration `freq`, e.g. '24h' or '3D', not rrQrrfrrrQrrside)rr-rrxryrQr3r2rarrrr rRr. searchsortedrV)rjrNrLrrr end_stampsrs rkrz TimeGrouper._get_time_delta_binso so"n-- 6"&r(("366  $)dC[11 7+/977  2ww &,"4927SSS SFV2v% %VVXXrvvxxs ;' ! ! 49 C)Styrw     ;& $) #Jz << ; " dk !FtV##rmc t|ts$tdt|j|j}t |dkr$tg||j|j x}}|g|fSt|d|d||jx}}||z |d }|j r||j }||d}|||fS) Nrrrrgrrrr)rr)rrxryrQrr+rr4r,r to_timestamprrr)rjrNrQrLrrrs rk_get_time_period_binsz!TimeGrouper._get_time_period_bins s"m,, 6"&r(("366  y r77a<<)d FV2v% %&RU2TPRPWXXXXtm++D#66CCEE 5 7#//66Jz77tV##rmr+ct|ts$tdt|j||j|j}d}|jr'tj |j }||j }t|sytj gtj}tg|j|jx}}t|dkr#t!|||t|\}}}|||fS|jj}||j|j}||jd} d} t|jt(rct+|| |j|j|j|j\} } t3||jt3| |jz } | j|z} | }t5|| |j|jx}}|j} t||z}|| d | dz z }tj| d| d |z|}||z }|| z}t|j||j}||d }|dkrt!||||\}}}|||fS) Nz3axis must be a PeriodIndex, but got an instance of rr)r4rr)rRrUrVrrgrr) rr+rrxryrrQrTrnpr_isnanrarrayr2r_insert_nat_binnrr r3_get_period_range_edgesrRrUrVrr,rarange_datar4r)rjrNr nat_countrrLr freq_multrr bin_shiftp_start start_offseti8expected_bins_count i8_extendrngprngs rkr{zTimeGrouper._get_period_bins s"k** 6"&r(("366  yyy88 < &t{++I %D4yy (8Bbh///D)r PPP PFV2ww{{'6vtVSQSWW'U'U$f4' 'IK  t??ffhhoodiUo33 di & &  3 {{{ LGS"%33fWdi6P6PPL$2IE&Styrw    Y"&kkI5'2b6BqE>: i1r"v 19== y y tDJ4:666  F 33 q==#264#S#S FD&tV##rmrr`r[ Index | None3tuple[NDFrameT, Index, npt.NDArray[np.intp] | None]c8t|||\}}}t|jtrS|jjdvrE|j|_ttt|j  }|||fS)NrMm) rrdrr4rkindrr(rrr_maybe_convert_datelike_array)rjrOr`r[rNrrs rkrdzTimeGrouper._set_grouper s!77//TY/OOR bh + +  0E0E "D ("(33QQSSBBrm) NrNNNrNNNrNF)rOrrQr:rhrrRrrSrrrnrrrTrrUrrVrrWr\r]r^)rOr!r]rH)TT)rOrrr\rr\r]r)rNr))rLr)rrr]r)rNr-)rNr+rA)rOrr`r\r[rr]r)ryrBrCrDr%rwrErlrrrarrrr{rdrHrIs@rkrJrJ7 s            K#2615 ?C 37 !r7r7r7r7r7r7r7h, , , , ^FJ11111*A$A$A$A$F"!"!"!"!H%$%$%$%$N$$$$0I$I$I$I$X+0  NR             rmrJrDrnpt.NDArray[np.intp]rr(cdSrrrOrrs rkrr s rmrEcdSrrr s rkrr s SrmDataFrame | SeriescTt|tr7tj|j|}||||jSt|tr9|j ||d}| ||j Std)N)rrr)new_axisrr)axesz.'obj' should be either a Series or a DataFrame) rralgostake_nd_values _constructorrr_mgrreindex_indexer_constructor_from_mgrrra)rOrr new_valuesnew_mgrs rkrr s #y!!K]3;88  )#(KKK C & &K(**IwUV*WW((w|(DDDIJJJrmrrr rrrQr rrBrRLiteral['right', 'left']rUr@rVTimedelta | Nonetuple[Timestamp, Timestamp]c t|trk|j}t|tr|jdu|dukrt d|dkrtd|}t |||||||\}}nu|}|}|dkr#t||}nt||z }t||z}||fS)aW Adjust the `first` Timestamp to the preceding Timestamp that resides on the provided offset. Adjust the `last` Timestamp to the following Timestamp that resides on the provided offset. Input Timestamps that already reside on the offset will be adjusted depending on the type of offset and the `closed` parameter. Parameters ---------- first : pd.Timestamp The beginning Timestamp of the range to be adjusted. last : pd.Timestamp The ending Timestamp of the range to be adjusted. freq : pd.DateOffset The dateoffset to which the Timestamps will be adjusted. closed : {'right', 'left'}, default "left" Which side of bin interval is closed. origin : {'epoch', 'start', 'start_day'} or Timestamp, default 'start_day' The timestamp on which to adjust the grouping. The timezone of origin must match the timezone of the index. If a timestamp is not used, these values are also supported: - 'epoch': `origin` is 1970-01-01 - 'start': `origin` is the first value of the timeseries - 'start_day': `origin` is the first day at midnight of the timeseries offset : pd.Timedelta, default is None An offset timedelta added to the origin. Returns ------- A tuple of length 2, containing the adjusted pd.Timestamp objects. Nz4The origin must have the same timezone as the index.rz 1970-01-01)r)rRrUrVrr)rr3rrra_adjust_dates_anchored normalizerollback)r rrQrrRrUrVindex_tzs rkrr sR$&8 fi ( ( Ufi4.?XQUEU-V-VSTT T W  |999F,      tt!!~~ V  dmmE2233EEedl++E%% $;rmrtuple[Period, Period]c td||fDstd|}|}|| }||} t |||d|||\}}|t ||zz|}|t | |zz |}||fS)al Adjust the provided `first` and `last` Periods to the respective Period of the given offset that encompasses them. Parameters ---------- first : pd.Period The beginning Period of the range to be adjusted. last : pd.Period The ending Period of the range to be adjusted. freq : pd.DateOffset The freq to which the Periods will be adjusted. closed : {'right', 'left'}, default "left" Which side of bin interval is closed. origin : {'epoch', 'start', 'start_day'}, Timestamp, default 'start_day' The timestamp on which to adjust the grouping. The timezone of origin must match the timezone of the index. If a timestamp is not used, these values are also supported: - 'epoch': `origin` is 1970-01-01 - 'start': `origin` is the first value of the timeseries - 'start_day': `origin` is the first day at midnight of the timeseries offset : pd.Timedelta, default is None An offset timedelta added to the origin. Returns ------- A tuple of length 2, containing the adjusted pd.Period objects. c3@K|]}t|tVdSr)rr)rsrOs rkruz*_get_period_range_edges.. s,@@3z#v&&@@@@@@rmz3'first' and 'last' must be instances of type Periodnsr)allrr is_on_offsetrrrp) r rrQrRrUrVfirst_tslast_ts adjust_first adjust_lasts rkrri sL @@5$-@@@ @ @OMNNN!!##H!!G((222L##G,,K2'4d6&QWHgL))D0 0 ; ;D A AE c+&&- - 8 8 > >D $;rmrLr+r np.ndarrayrrr+tuple[PeriodIndex, np.ndarray, PeriodIndex]c|dksJ||z }tj|d|}|dt}|dt}|||fS)Nr)rrr)rLrrrs rkrr se q====ID 9T1i ( (D]]1c " "F]]1c " "F 4 rmrfr&r3c||}||}|||}t||j}d}|dkr|j}n|dkr|j}n}t |t r||j}nM|dvrI|dkr|n|d} | j|jz |z} |dkr| dz } | | |zz }|j}||r|jndz }|j} |j} | |d }| |d }|j|z |z} |j|z |z}|d kr7| dkr |j| z }n |j|z }|dkr|j||z z}n>|j}n6| dkr |j| z }n|j}|dkr|j||z z}n |j|z}t || }t || }| (| d | }| (| d | }||fS) NrrrrrDrrUTCrfr) rr_valuer rrceiltzinfo tz_convertr)r rrQrRrUrVr freq_valueorigin_timestamp origin_lastsub_freq_times first_tzinfo last_tzinfofoffsetloffset fresult_int lresult_intfresultlresults rkrr s MM$  E <<  D %%4((..5J  ??,,3 7   < FI & &(!>>$//6 % % %$oodd499S>> %,u|; J V   a Nnt33 <6 Q6 KK+KK Q;;,0KK ,K Q;;+g)=>KK+ 2K $///G $///G%%e,,77 EE%%e,,77 DD G rmFrr r\c4t|jtr|td|d}t|tr$t |drt |j}|}|j |||_nt|jdkr/|}t|j||_nd}t|jtr |jj }t|j|j||}|jj|_|||| }|r|j|_|S) z Utility frequency conversion method for Series/DataFrame. See :meth:`pandas.NDFrame.asfreq` for full documentation. Nz"'method' argument is not supportedE_period_dtype_coderrr&)rQr)rr)rrr+rr hasattrr_freqstrr(rrrr)rr*rr rr*r ) rOrQrrr rrrdtis rkrr s\#)[))6  %&JKK K ;C dJ ' ' 2t122 2"4((1((** ((3(77 SY1  ((**&sy$77  ci / / "9>D#)--//4PPP9>++c&Z+HH  6#M3355GM Nrmrr9ct|dkrtdt|tr||}nt|t rt g|j||j}nOt|trtg|j||j}ntt||S)z Helper to mimic asfreq on (empty) DatetimeIndex and TimedeltaIndex. Parameters ---------- index : PeriodIndex, DatetimeIndex, or TimedeltaIndex freq : DateOffset Returns ------- same type as index rzECan only set arbitrary freq for empty DatetimeIndex or TimedeltaIndexr)r4rQr) rrarr+rr)r4rr-rrx)rrQrs rkrr4 s 5zzQ S   %%%%LLdL++ E= ) )%!"EKdTTT E> * *%"2U[t%*UUU U $$$ rm)rOrr]rH)NNNN)rr#rrr]rH)rOrDrr rr(r]rD)rOrErr rr(r]rE)rOrrr rr(r]r)rrN)r rrrrQr rrBrRrrUr@rVrr]r)r rrrrQr rRrrUr@rVrr]r#) rLr+rr-rr+rrr]r.)rfrNr&)r rrrrQr3rRrrUr@rVrrrBr]r)NNFN)rOrr r\r]r)rr9r]r9){ __future__rr(typingrrrrrr r r rnumpyr pandas._libsr pandas._libs.tslibsr rrrrrrpandas._typingr pandas.errorsrrpandas.util._decoratorsrpandas.util._exceptionsrpandas.core.dtypes.dtypesrrpandas.core.dtypes.genericrrpandas.core.algorithmscore algorithmsrpandas.core.applyrpandas.core.arraysrpandas.core.baserr pandas.core.genericr!pandas.core.groupby.groupbyr"r#r$pandas.core.groupby.grouperr%pandas.core.groupby.opsr&pandas.core.indexes.apir'pandas.core.indexes.baser(pandas.core.indexes.datetimesr)r*pandas.core.indexes.periodr+r,pandas.core.indexes.timedeltasr-r.pandas.core.reshape.concatr/pandas.tseries.frequenciesr0r1pandas.tseries.offsetsr2r3collections.abcr4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCr6rDrErFrErHrKr\r_rwryrrrrDrrJrrrrrrrrrmrkrhsg"""""""                     $#####/.....444444 '&&&&&&&&222222222222 0/////............******.----- , ",+++++&(((((    h;h;h;h;h; \h;h;! h;V9nnnnnL.nnnbiiiiiYiiiX     & & & & &) & &!  &T*T*T*T*T*1T*T*T*n     $ $ $ $ $' $ $!  $4,     ' ' ' ' '* ' '!  '""""")   NNNNN$    J J J J J 'J J ! J Z      K K K K((. +#FFFFFZ(. +# 55555p    ,(/ +#QQQQQn   *****Zrm