A>i7 %SSKJr SSKrSSKJrJrJrJrJrJ r J r J r SSK r SSK rSSKJr SSKJrJrJrJrJrJrJr SSKJr SSKJrJr SSKJr SS K J!r! SS K"J#r#J$r$ SS K%J&r&J'r' SSK(J)s J*r+ SS K,J-r- SS K.J/r/ SSK0J1r1J2r2 SSK3J4r4 SSK5J6r6J7r7J8r8 SSK9J:r: SSK;Jr> SSK?J@r@ SSKAJBrBJCrC SSKDJErEJFrF SSKGJHrHJIrI SSKJJKrK SSKLJMrMJNrN SSKOJPrPJQrQ \(a6SSKRJSrSJTrT SSKJUrUJVrVJWrWJXrXJYrYJZrZJ[r[J\r\J]r]J^r^J_r_J`r`JaraJbrb SSKcJdrdJere SSK3J4r4 0rfS\gS'\"S 5"S!S"\6\155rh"S#S$\1\25ri"S%S&\h5rj\"S 5"S'S(\i\j55rk"S)S*\j5rl\"S 5"S+S,\i\l55rm"S-S.\j5rn\"S 5"S/S0\i\n55roS>S1jrp\hR\plqS?S@S2jjrr\"S 5"S3S4\:55rs\ SAS5j5rt\ SBS6j5rtSCS7jrtSDSES8jjruSDSFS9jjrvSGS:jrwSHSIS;jjrxSJSKS<jjrySLS=jrzg)M) 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.typingcF^\rSrSr%SrS\S'S\S'S\S'\"5rS \S '\"1S k5r /S Qr S SS S.S;Sjjr \ SSj55rS?SjrSr\ S5r\S@Sj5r\SASj5r\ SBU4Sjj5r\ SCSj5r\r\r\ S5rSrSDSESjjrSCSFSjjrSr\ SGS j5rS!r\ SCSES"jj5r \ SCSES#jj5r!\ SCSES$jj5r"\ SHS%SS&SS'.SIS(jjj5r#\ SCS)j5r$\ SJSKS*jj5r%\ SJSKS+jj5r&\ SJSKS,jj5r'\ SJSKS-jj5r(\ SLSMS.jj5r)\ SLSMS/jj5r*\ SNSOS0jj5r+\ SNSOS1jj5r,\ SPSQS2jj5r-\ SPSQS3jj5r.\ SPSQS4jj5r/\ S55r0\ S65r1\ S75r2\ S85r3\ SRSSS9jj5r4S:r5U=r6$)T Resamplerwa 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_groupscU(a [S5eX lSUlSUlX@lSUlURR URU5SUS9uUlUl Ul UR5uUl Ul XPlURRb&[!URR/5Ulg[!5Ulg)Nz)include_groups=True is no longer allowed.T)sort gpr_index) ValueErrorrLkeysr\rXas_index _set_grouper _convert_objrPrOrQ _get_binnerrMrJ _selectionkey frozensetrN)selfrP timegrouperr]rXrYrZs S/var/www/html/land-tabula/venv/lib/python3.13/site-packages/pandas/core/resample.py__init__Resampler.__init__s HI I'  $ +/+<+<+I+I   c ",J, ($'4=&*%5%5%7" T]#    ,'):):)>)>(?@DO'kDOc^U4SjTR5n[T5RSSRU5S3$)z0 Provide a nice str repr of our rolling object. c3># UH:n[TRUS5cMUS[TRU53v M< g7f)N=)getattrrL).0krgs ri $Resampler.__str__..sE %t((!T2 3qc74,,a01 2%s A"Az [z, ]) _attributestype__name__join)rgattrss` ri__str__Resampler.__str__sB  %%  t*%%&b5)9(:!<[TU]"U/UQ70UD6$)a 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)rgrrr __class__s rirr sZw|D242622rlcl[XX#S9R5nUcUnUR"U/UQ70UD6nU$)aR 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)rgrrrresulthows ri aggregateResampler.aggregateYsCF&dtKOOQ >C00FtFvFF rlctURRUR5R"U/UQ70UD6$)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_objgroupbyrL transform)rgargrrs rirResampler.transformsBP!!))$*;*;<FF      rlc [U5er~r)rgrrs ri _downsampleResampler._downsamplerrlc[U5er~r)rgflimit fill_values ri _upsampleResampler._upsamplerrlcURnUc&URnUbX1nOURS:XdeUS:XaURS:Xde[USX@RS9nU$) 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 NbygrouperrX)rJrPndimr$rX)rgrersubsetrgroupeds ri_gotitemResampler._gotitemsp-- >XXF{{a''' 19;;!# ## tW rlc^^^URnURn[USX@RS9n[ T5(aUUU4SjnUR U5nOUR "T/TQ70TD6nURU5$![ [4a UR"T/TQ70TD6nN9[a1n S[U 5;aOeUR"T/TQ70TD6nSn A NnSn A ff=f)z1 Re-evaluate the obj with a groupby aggregation. Nrc>T"U/TQ70TD6$r~r)xrrrs ri2Resampler._groupby_and_aggregate..#sQ!8!8!8rlzMust produce aggregated value) rJ_obj_with_exclusionsr$rXcallablerAttributeErrorKeyErrorapplyr^str _wrap_result) rgrrrrrPrrrerrs ``` rir Resampler._groupby_and_aggregates--''cdGX 9}}9 **40 **3@@@.  ((-) 9]]3888F 9.#c(:]]3888F 9s#)BB&C&, C&5'C!!C&c$URUUUS9$)z7 Return the correct class for resampling with groupby. )rreparent)_resampler_for_grouping)rgrres ri_get_resampler_for_grouping%Resampler._get_resampler_for_grouping?s%++,  rlc4[U[5(aURbURUl[U[5(aUUR(aDUR n[ URSSURS9Ul[USS5UlURRbcURRURR5UlUR RRURlU$)z Potentially wrap any results. NrrRname) isinstancerrdremptyrP_asfreq_compatindexrRrprLrr)rgrrPs rirResampler._wrap_resultNs fi ( (T__-H//FK fi ( (V\\((C)#))BQ-diiHFL!#vt4FK    ) ) 5!<<..t/@/@/M/MNFL $ 3 3FLL  rlc"URSUS9$)aa 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 ffillrrrgrs rirResampler.ffillasZ~~gU~33rlc"URSUS9$)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 rirResampler.nearestsp~~iu~55rlc"URSUS9$)as 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 rirResampler.bfillsH~~gU~33rlrforward)axisrlimit_direction limit_areac SU;a\[R"S[U5RS3[[ 5S9 UR S5nU(a [S5eURS5nURn [U R[5n U (d}URn [U [5(a [S5eU RRU 5n [!U 5S:a'[#XR$U /5R'5nUR("S UUUS UUS .UD6n U (aU $U R$W n Xl U $) 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)methodrrrrrr)warningswarnrwrxrrpopr^rrrrr+r'NotImplementedError differencerr/loc sort_index interpolate)rgrrrrrrrrrPis_period_index final_indexmissing_data_points_indexresult_interpolateds rirResampler.interpolatePsa`   MM+DJ,?,?+@A>>+-  jj+G !TUU)   $SYY < ,,K+z22)>), (<(<[(I %,-1WW%>?@*,%00 +!    & &255kB%0!""rlc"URSUS9$)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)rgrs rirResampler.asfreq sR~~h:~>>rlc"URSXS9$)a 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 sum numeric_only min_countrrgr r s rir  Resampler.sumKstLVVrlc"URSXS9$)aE 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 prodr rrs rirResampler.prodsj\WWrlc"URSXS9$)a> 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 minr rrs rir Resampler.minjLVVrlc"URSXS9$)a? 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 maxr rrs rir Resampler.maxrrlc$URSXUS9$)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 firstr r skipnarrgr r rs rirResampler.first,s$b ,F   rlc$URSXUS9$)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 rir"Resampler.lastas$b 6   rlc"URSUS9$)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 medianr rrgr s rir%Resampler.medians`|DDrlc"URSUS9$)a 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 meanr&rr's rir*Resampler.meansh\BBrlc"URSXS9$)aD 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 stdddofr rrgr/r s rir- Resampler.stdlDLLrlc"URSXS9$)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 varr.rr0s rir4 Resampler.var6sxDLLrlc"URSXS9$)a0 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 semr.rr0s rir7 Resampler.semtr2rlcURnURn[U5S:XaUR5n[ UR UR 5UlURS:Xa$UR5nUR/SQSS9nU$[R"UR/SQ/5nURUSS9nU$URS5$)aP 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)rOrrcopyrrrRrto_framereindexr' from_productcolumnsr)rgrOrPmis rir>Resampler.ohlcsHWW'' r7a<((*C&syy$))>> 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 rirGResampler.nuniquesB **rlc`URS5n[U[5(a!UR(dUR 5n[ UR 5(dLSSKJn URRS:XaURRnOSnU"/URSUS9nU$)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) rrrrstackrrOpandasrErrrr)rgrrErs rirJResampler.sizes@!!&) fl + +FLL\\^F477|| %!!&&!+))..Bfll'MF rlcNURS5n[UR5(dyURRS:Xa<[ UR5"/UR SURRS9nU$SSKJ n U"/UR URSS9nU$)a 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 countrrKrLr)rD)rrCrM) rrrOrrrwrrrOrDrC)rgrrDs rirRResampler.count6sF!!'*477||!!&&!+d001fll'@R@R@W@W -"fllFNN' rlc *UR"SSU0UD6$)a 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 q)quantiler)rgrUrs rirVResampler.quantilehsp:a:6::rl) rJrQrdrLr`rOrMrNrXr_rPr\) rPr!rhrKr]r(rXboolrZrXreturnNone)rYr)rr)rYrXrPrrYr)rz!Callable[Concatenate[Self, P], T]rzP.argsrzP.kwargsrYr>)rztuple[Callable[..., T], str]rr6rr6rYr>)rz@Callable[Concatenate[Self, P], T] | tuple[Callable[..., T], str]rr6rr6rYr>r~NNr int | None)rint)rr#)linear)rr<rr8rr^rz&Literal['forward', 'backward', 'both'])Fr)r rXr r_)FrT)r rXr r_rrXF)r rX)rF)r/r_r rX)g?)rUz"float | list[float] | AnyArrayLike)7rx __module__ __qualname____firstlineno____doc____annotations__rfrNsetrrvrjr r{rpropertyrrbrrcr rrrrrrrrrrrrrrrrr rrrrr"r%r*r-r4r7r>rGrJrRrV__static_attributes__ __classcell__rs@rirHrHws=( 88&/kJ#178K!$* *!*  *  ** *8  =  = 3 3      "(  #  #/  *   L3NL3L3 L3 L3 L3\ g gR C E )  ) V((8))V        & L4 L4\ 76 76r c4 c4J &.M# BKM#"M# M#  M# @ M# M#^ (? (?T #9W9W9W 9Wv #4X4X4X 4Xl #4W4W4W 4Wl #4W4W4W 4Wl # 2 2 2  2  2 h # 2 2 2  2  2 h /E /Eb #3C3C 3Cj "5M5M5M 5Mn ";M;M;M ;Mz "5M5M5M 5Mn 3( 3(j  +  +D . .` / /b 7; 7;rlrHc\rSrSr%SrS\S'SrS\S'S\S 'S \S 'SSS .SS jjr\S5r \ r \ r \ r \ SSj5rSrg) _GroupByMixiniz! Provide the groupby facilities. z list[str]rvNIndexLabel | Nonerdr#_groupbyrKrL)rerYc [U[5(d[U55e[U[5(d[U55eURHn[ X[ X55 M X@lURUlX0l X l [R"UR5Ul URUl URUlgr~)rr#rwrHrvsetattrrprdrMreror?rLrOrP)rgrrrerYrs rirj_GroupByMixin.__init__s'7++:T']:+&),,:d6l:,$$D D 5 6%#mm   IIf&9&9:))::rlcl^^^^UUUU4SjnTRRU5n[U[5(ag[ U5S:XaX[UR [ 5(d9UR[TRR SSTRS9SS9nTRU5$)z Dispatch to _upsample; we are stripping all of the _upsample kwargs and performing the original function call on the grouped object. c>TRUTRTRS9n[T[5(a[ UT5"S0TD6$UR "T/TQ70TD6$)N)rhr]r)_resampler_clsrLrOrrrpr)rrrrrgs rir"_GroupByMixin._apply..funcsa##A43D3DPTPWPW#XA!S!!q!}.v..771.t.v. .rlrNrT)append) rorrrrrr+ set_indexrrPrRr)rgrrrrrs```` ri_apply_GroupByMixin._applys / /$$T* v| , ,F q v||[99%%txx~~bq1 B4&F  ((rlcUc&URnUbX1nOURS:Xde[U[5(a8URU;a(URbUR UR5 UR UnURX5n[U5"U[[U5US9nU$![a UR nNJf=f)rr)rrrY) rPrrlistrerwro IndexError_infer_selectionrwrrH)rgrerrrrYnew_rss rir_GroupByMixin._gotitems >XXF{{a''' $#t$$)<AU 488$mmC(G))#6 d 4(    $mmG $sAB99CC)rordrLrOrMrerP)rrHrr#rYrnrYrZr~)rxrbrcrdrerfrdrjr ryrrrr rrirrlrirmrms$(J!( '+   %  <))8IK# $ $rlrmch^\rSrSr%S\S'\S Sj5rSrSrSr S S Sjjr U4S jr S r U=r $)DatetimeIndexResamplerir)rOc[$r~)DatetimeIndexResamplerGroupbyrs rir.DatetimeIndexResampler._resampler_for_groupings,,rlcLURRUR5$r~)rL_get_time_binsrOrs rir+DatetimeIndexResampler._get_binner_for_times  //88rlc URnURn[U5(dUR5nURR UR 5UlURR UR :Xd'URR UR 45eU$URUR5R"U40UD6nURU5$) Downsample the cython defined function. Parameters ---------- how : string / cython mapped function **kwargs : kw args passed to how function ) rOrrr?r _with_freqrRrrJrr)rgrrrOrPrs rir"DatetimeIndexResampler._downsamplesWW''2ww((*C ,,TYY7CI99>>TYY. K0K K.JT]]+55cDVD  ((rlc>URS:XaUSSnU$USSnU$)zd Adjust our binner when upsampling. The range of a new index should not be outside specified range rightrN)rSrgrMs ri_adjust_binner_for_upsample2DatetimeIndexResampler._adjust_binner_for_upsample9s4 ;;' !ABZF CR[F rlcUR(a [S5eURnURnURnUR U5nUcr[ UR5UR:XaO[U5[U5:Xa7URRU5(aUR5nXxl OUS:XaSnURXqX#S9nURU5$)z 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)rr^rOrrMrr inferred_freqrRrrequalsr?rAr) rgrrrrOrPrM res_indexrs rir DatetimeIndexResampler._upsampleEs   ;  WW  44V<  M"**+tyy8CC N*   ++XXZF$L![[!F  ((rlc2>[TU]U5n[UR[5(a[UR [5(d[UR [ 5(a[UR RS[5(dQUR RSRUR5nUR RUSS9UlU$UR RUR5UlU$)Nr)r) rrrrOr+rr'levels to_periodrR set_levels)rgr new_levelrs rir#DatetimeIndexResampler._wrap_resultns%f- dgg{ + +J LL+5 5 &,, 33!&,,"5"5b"9;GG & 3 3B 7 A A$)) LI#)<<#:#:9B#:#OFL  &||55dii@  rlr)rYz#type[DatetimeIndexResamplerGroupby]r\r])rxrbrcrdrfrhrrrrrrrirjrks@rirrs: --9)4 ')Rrlrc(\rSrSrSr\S5rSrg)riz1 Provides a resample of a groupby implementation c[$r~)rrs riru,DatetimeIndexResamplerGroupby._resampler_clss%%rlrNrxrbrcrdrerhrurirrlrirrs &&rlrcb^\rSrSr%S\S'\S5rSrS U4SjjrSr S S Sjjr S r U=r $) PeriodIndexResamplerir+rOc[$r~)PeriodIndexResamplerGroupbyrs rir,PeriodIndexResampler._resampler_for_groupings**rlcLURRUR5$r~)rL_get_period_binsrOrs rir)PeriodIndexResampler._get_binner_for_times  11$''::rlcb>[TU]U5nUR(a Sn[U5eU$)NzResampling from level= or on= selection with a PeriodIndex is not currently supported, use .set_index(...) to explicitly set index)rrbrr)rgrPmsgrs rirb!PeriodIndexResampler._convert_objs7g"3'   >  &c* * rlc URn[URUR5(aUR"U40UD6$[ URUR5(a'US:XaURU5$UR 5$URUR:XaUR 5$[ SURSURS35e)rr>z Frequency z cannot be resampled to z&, as they are not sub or super periods)rOr0rRrr1rr)rgrrrOs rir PeriodIndexResampler._downsamplesWW  + +..s=f= = BGGTYY / /f} 22377;;= WW !;;= # !9$))E3 3  rlcURnURnURnURURUR S9nUS:XaSnUR XaUS9n[UUU5n URU 5$)z 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) rOrPrMrrRrU get_indexer_take_new_indexr) rgrrrrOrP new_indexmembrnew_objs rirPeriodIndexResampler._upsamplesWWhhKK yyy8 X F""95"I!       ))rlrr[r\r]) rxrbrcrdrfrhrrrbrrrirjrks@rirrs5 O ++;  >**rlrc(\rSrSrSr\S5rSrg)ri2 Provides a resample of a groupby implementation. c[$r~)rrs riru*PeriodIndexResamplerGroupby._resampler_clss##rlrNrrrlrirrs $$rlrc<\rSrSr%S\S'\S5rSrSrSr g) TimedeltaIndexResamplerir-rOc[$r~)TimedeltaIndexResamplerGroupbyrs rir/TimedeltaIndexResampler._resampler_for_groupings--rlcLURRUR5$r~)rL_get_time_delta_binsrOrs rir,TimedeltaIndexResampler._get_binner_for_times  55dgg>>rlcU$)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 rrs rir3TimedeltaIndexResampler._adjust_binner_for_upsample s  rlrN) rxrbrcrdrfrhrrrrirrlrirrs&  ..?rlrc(\rSrSrSr\S5rSrg)ri rc[$r~)rrs riru-TimedeltaIndexResamplerGroupby._resampler_cls s&&rlrNrrrlrirr s ''rlrc <[U40UD6nURU5$)z0 Create a TimeGrouper and return our resampler. )rK_get_resampler)rPkwdstgs ri get_resamplerr s$ S !D !B  S !!rlc [SXS.UD6nURUR5nURXRS9$)z9 Return our appropriate resampler when grouping as well. rRre)rrer)rKrrPrre) rruler fill_methodronrr resamplers riget_resampler_for_groupingr% sB  1$ 1& 1B!!'++.I  0 0ff 0 MMrlcN^\rSrSr%Sr/\R QSPSPSPSPSPSP7rS \S'SSU4S jjjrSS jr SSS jjr SSjr SSjr SSjr SSjrSSjrSS S.S U4SjjjjrSrU=r$)!rKi7 aD 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 rSrTrrUrVrWr@Nc  F>US;a[SUS35eUS;a[SUS35eU S;a[SU S35eUc"Ub[UR[5(dUb!Ub[ XSS5S:Xa [ US S 9nO [ U5n[U[ 5(dMU b"[R"S [[5S 9 U S :wa"[R"S[[5S 9 1SknURnX;dSU;a#USURS5U;a UcSnUcSnOU S;a UcSnUcSnO UcSnUcSnX@l XPlU bU OSUlX`lXplXlXlSUlU S;aXlO[-U 5UlU b [1U 5OSUlS U S'[4TU]l"SX#S.U D6 g![[.4an[SU S35UeSnAff=f![[.4an[SU S35UeSnAff=f)N>NleftrzUnsupported value z for `label`z for `closed`>Nesendstartz for `convention`rMperiodT) is_periodzsThe 'offset' keyword does not take effect when resampling with a 'freq' that is not Tick-like (h, m, s, ms, us, ns)r start_dayzsThe 'origin' keyword does not take effect when resampling with a 'freq' that is not Tick-like (h, m, s, ms, us, ns)>WMEQEYEBMEBQEBYE-rrend_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)r^rrr+rprr3rrRuntimeWarningr rule_codefindrSrTrUrrrrXrrVr TypeErrorrrWrrj)rgrPrRrerSrTrrrrUrVrWrXr end_typesrrrs rirjTimeGrouper.__init__Q s~* / /1% EF F 0 01&GH H = =1*=NOP P KCO 399k0R0R O'40H<TT2DT?D$%%! P"/1  $ P"/1 A ~~  6F #1G91T~ }) )~ }~}  (2(>*C& $/3 F F !K '/  /5/A)F+tDKv 6d6v6% *  DDJ8:W  I& xz+  s0G&G;G8#G33G8;H  HH cnURUSS9up#n[U[5(a[UUURUS9$[U[ 5(a[ UUURUS9$[U[5(a[UUURUS9$[S[U5RS35e)z Return my resampler or raise if we have an invalid axis. Parameters ---------- obj : Series or DataFrame Returns ------- Resampler Raises ------ TypeError if incompatible axis Nr])rhrXr]zVOnly valid with DatetimeIndex, TimedeltaIndex or PeriodIndex, but got an instance of '') rarr)rrXr+rr-rrrwrx)rgrP_rOs rirTimeGrouper._get_resampler s"$$SD$9q b- ( () ??   K ( (' ??   N + +* ??   ''+Bx'8'8&9 <  rlcpURU5nUR[[UR54$)aF 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) )rrJrrrP)rgrPvalidateobservedrs ri _get_grouperTimeGrouper._get_grouper s.$    $zz4!%%000rlc [U[5(d![S[U5R35e[ U5S:Xa0[/UR URURS9=p#U/U4$[UR5UR5UR URURURURS9upE[!UR UUUR"URSSURS9=p#UR$nUR'X&5up'[(R*"XgURUR,S9nURS :XaUnUR.S :XaUS SnOUR.S :XaUS SnUR,(a,UR1S[25nUR1S[25n[ U5[ U5:aUS[ U5nX(U4$) N5axis must be a DatetimeIndex, but got an instance of rdatarRrrMunitrSrVrWT shift_forward)rRrrtzr ambiguous nonexistentr)hasnansrr)rr)rrwrxrrRrrM_get_timestamp_range_edgesrrrrSrVrWr*rasi8_adjust_bin_edgesr generate_bins_dt64rrTinsertr) rgrOrMlabelsrr" ax_values bin_edgesrs rirTimeGrouper._get_time_bins s"m,,""&r("3"3!46  r7a<+diibggRXX F2v% %0 FFH FFH II;;;;;;  %uu'  GG  226E%% $++rzz  ;;' !FzzW$ ZZ7 "ABZF ::]]1c*F]]1c*F t9s6{ "Kc$i(FV##rlc@URRS;d,URRRS5SS;aURS:XaUR S5nU[ SS9R UR5-[ SURS9R UR5- nUR UR5RnO URnUS UR5:a USS nUSS nX4$URnX4$) N)rrrrr)rrrrrrr)daysrr) rRrsplitrS tz_localizeras_unitrrrr)rgrMr  edges_dtir s rirTimeGrouper._adjust_bin_edgesK s 99>>/ /499>>3G3G3LQ3OT 4 {{g%"..t4 Q'// ?@ 7?? OP &11&))<AA "KK }y}}.%crN    I  rlc[U[5(d![S[U5R35e[UR [ [45(d[SUR 35e[U5(d%[/UR URS9=p#U/U4$UR5UR5pTURS:XaXPR - n[XEUR URS9=p2UnURS:XaX`R - nURX`RS9nUR (aX0R - nX'U4$)Nz6axis must be a TimedeltaIndex, but got an instance of zWResampling on a TimedeltaIndex requires fixed-duration `freq`, e.g. '24h' or '3D', not rrRrrrrrRrrside)rr-rrwrxrRr3r2r^rrrrrSr. searchsortedrW)rgrOrMr rr end_stampsrs rir TimeGrouper._get_time_delta_binso s8"n--""&r("3"3!46  $))dC[11++/99+7  2ww,"499277S SF2v% %VVXrvvxs ;;' ! 99 C)tyyrww   ;;& )) #Jz < ;; kk !FV##rlc[U[5(d![S[U5R35eUR n[ U5S:Xa%[/X!RURS9=p4U/U4$[USUSX!RS9=pCXB-RUS5R5nUR(aURUR5nURUSS9nX6U4$) Nrrrrrrrr)rr)rrwrxrRrr+rrMr,r to_timestamprrr)rgrOrRrMr rrs ri_get_time_period_bins!TimeGrouper._get_time_period_bins s"m,,""&r("3"3!46  yy r7a<)d F2v% %&RU2TPWPWXXm++D#6CCE 55#//6Jz7V##rlc [U[5(d![S[U5R35eUR UR URS9nSnUR(a/[R"UR5nX"R)n[U5(do[R"/[RS9n[/UR URS9=pV[U5S:a[!XTU[U55upTnXTU4$UR R"nUR%5R UR URS9nUR'5R UR SS9n Sn [UR [(5(at[+UU UR UR,UR.UR0S9up[3XR 5[3XR 5- n U R"U-n U n[5XUR URS9=peUR6n [U5U-nXS U S- - n[R8"U SU S U-U5nUU- nUU -n[UR:5"UUR<S9nUR?US S 9nUS:a[!XTXc5upTnXTU4$) Nz3axis must be a PeriodIndex, but got an instance of rr)rMrr)rSrVrWrrrr) rr+rrwrxrrRrUrnpr _isnanrarrayrKr_insert_nat_binnrrr3_get_period_range_edgesrSrVrWrr,rarange_datarMr)rgrOr nat_countrrMr  freq_multrr bin_shiftp_start start_offseti8expected_bins_count i8_extendrngprngs rirTimeGrouper._get_period_bins sz"k**""&r("3"3!46  yyy8 <<t{{+I %D4yy88Bbhh/D)r P PF2w{'6vVSQSW'U$f' 'IIKK  t?ffhoodiiUo3 dii & & 3 {{{{{{ LG"%3fWii6PPL$2IE&tyyrww  YY"&kI5'b6BqE>: ii1r"v 19= y yDJJ4::6  F 3 q=#26#S F&V##rlrc$>[TU]XUS9upn[UR[5(a\URR S;aBURUl[[[UR5R55nXU4$)NrMm) rrarrMrkindrr(rrr&_maybe_convert_datelike_array)rgrPr\r]rOrrs riraTimeGrouper._set_grouper sy!7/Y/O bhh + + 0E "D ("((3QQSBrl) rrSrUrrXrrTrrWrV) NMinNNNr*NNNrNF)rPzGrouper | NonerRr:rez str | NonerSLiteral['left', 'right'] | NonerTr=rrrr^rUz(Literal['start', 'end', 'e', 's'] | NonerVzTLiteral['epoch', 'start', 'start_day', 'end', 'end_day'] | TimestampConvertibleTypesrWz TimedeltaConvertibleTypes | NonerXrXrYrZ)rPr!rYrH)TT)rPrrrXrrXrYztuple[BinGrouper, NDFrameT])rOr))rMr)r znpt.NDArray[np.int64]rYz+tuple[DatetimeIndex, npt.NDArray[np.int64]])rOr-)rOr+ra)rPrr\rXr]z Index | NonerYz3tuple[NDFrameT, Index, npt.NDArray[np.intp] | None])rxrbrcrdrer%rvrfrjrrrrrr!rrarirjrks@rirKrK7 s            K #2615 ?C 37 !r7 r7r7 r7 0 r7 / r7r7r7=r7 (r71r7 !r7$ %r7r7h, ^FJ11'+1>B1 $1*A$F"!#"!0E"! 4"!H%$N$0I$X+0  NR    #'  ?K  <   rlrKcgr~rrPrrs rirr srlcgr~rr?s rirr srlcH[U[5(a;[R"URU5nUR X2UR S9$[U[5(a3URRX!SS9nURXDRS9$[S5e)N)rrr)new_axisrr)axesz.'obj' should be either a Series or a DataFrame) rralgostake_nd_values _constructorrr_mgrreindex_indexer_constructor_from_mgrrCr^)rPrr new_valuesnew_mgrs rirr s #y!!]]3;;8  #((KK C & &((**IUV*W((||(DDIJJrlc [U[5(adURn[U[5(aURSLUSL:wa [ S5eUS:Xa [SUS9n[ UUUUUUUS9upX4$UR 5nUR 5nUS:Xa[URU55nO [X- 5n[X-5nX4$)a 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)rSrVrWrr)rr3rrr^_adjust_dates_anchored normalizerollback)rr"rRrrSrVrWindex_tzs rirr sR$88 fi ( (fii4.?XQUEU-VST T W |9F,    ( ;!~~ V dmmE23Eel+E% ;rlc z[SX455(d [S5eUR5nUR5nURU5(+nURU5n [ XgUSX4US9upgU[ U5U--R U5nU[ U 5U-- R U5nX4$)a 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. c3B# UHn[U[5v M g7fr~)rr)rqrPs rirs*_get_period_range_edges.. s@-3z#v&&-sz3'first' and 'last' must be instances of type Periodnsr)allrr  is_on_offsetrr_r) rr"rRrSrVrWfirst_tslast_ts adjust_first adjust_lasts rir)r)i sL @5-@ @ @MNN!!#H!G((22L##G,K24d6QWHL)D0 0 ; ;D AE c+&- - 8 8 >D ;rlcUS:deX- n[R"USU5nURS[5nURS[5nXU4$)Nr)r$r r)rMrr r,s rir'r' sY q==D 99T1i (D]]1c "F]]1c "F  rlcURU5nURU5nUbURU5n[U5RU5RnSnUS:XaUR5RnOUS:Xa URnO[ U[ 5(aURU5RnOYUS;aSUS:XaUOUR S5n U RUR- U-n US:XaU S- n XU-- nURnX(a UROS- nURn URn U bURS 5nU bURS 5nURU- U-n URU- U-nUS :XaJU S:aURU - nOURU- nUS:aURX~- -nOVURnOIU S:aURU - nO URnUS:aURX~- -nOURU-n[ XS 9n[ UUS 9nU b URS 5RU 5nU b URS 5RU 5nUU4$) NrrrrrDrrUTCrr) rr_valuerOrrceiltzinfo tz_convertr)rr"rRrSrVrWr freq_valueorigin_timestamp origin_lastsub_freq_times first_tzinfo last_tzinfofoffsetloffset fresult_int lresult_intfresultlresults rirNrN ss MM$ E << D %4((.55J  ??,33 7  << FI & &!>>$/66 % %$od499S> %,,u||; J V  a Nt33 << Q6 <K++K Q;,,0K ,,K Q;++)=>K++ 2K /G $/G%%e,77 E%%e,77 D G rlcR[UR[5(a~Ub [S5eUcSn[U[5(a&[ US5(a[ U5RnUR5nURRXS9UlU$[UR5S:Xa-UR5n[URU5UlU$Sn[UR[5(aURRn[URR5URR!5XS9nURR"UlUR%XUS9nU(aURR'5UlU$) zv Utility frequency conversion method for Series/DataFrame. See :meth:`pandas.NDFrame.asfreq` for full documentation. z"'method' argument is not supportedE_period_dtype_coderrrU)rRr)rr)rrr+rr hasattrr_freqstrr?rrrr)rr*rrrrArO) rPrRrrrOrrrdtis rirr sA#))[))  %&JK K ;C dJ ' 't122"4(11((* (((7 " N SYY1 ((*&syy$7  N cii / /99>>D#))--/P99>>++cZ+H #MM335GM Nrlc[U5S:wa [S5e[U[5(aUR US9nU$[U[ 5(a![ /UR XRS9nU$[U[5(a![/UR XRS9nU$[[U55e)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)rMrRr) rr^rr+rr)rMrr-rrw)rrRrs rirr4 s 5zQ S  %%%LLdL+   E= ) )!"EKKdT  E> * *"2U[[t**U  U $$rl)rPzSeries | DataFramerYrH)NNNN)rr#rr^rYrH)rPrDrnpt.NDArray[np.intp]rr(rYrD)rPrErrwrr(rYrE)rPDataFrame | Seriesrrwrr(rYrx)rrN)rrr"rrRr rrBrSLiteral['right', 'left']rVr@rWTimedelta | NonerYtuple[Timestamp, Timestamp])rrr"rrRr rSryrVr@rWrzrYztuple[Period, Period]) rMr+rz np.ndarrayr r+r,r_rYz+tuple[PeriodIndex, np.ndarray, PeriodIndex])rrNrU)rrr"rrRr3rSryrVr@rWrzrrBrYr{)NNFN)rPrrOrXrYr)rr9rYr9){ __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 algorithmsrDpandas.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@rArBrCrOrDrErFrfrHrmrrrrrrrrerrKrrr)r'rNrrrrlrirs+"    $/4 '&22 0..*.  ",&(^(  h; \h;!h;V9nL.nbiYiX   &) &! &T*1T*n   $' $! $4,   '* '! '""))   N N  NN$  J 'J !J Z  1>C    .;@   K  K ! K K K((. +#F F F F  F % F  F F!FZ(. +# 5 5 5 5 % 5  5  55p  ) 3> KN 0 ,(/ +#Q Q Q Q % Q  Q  Q Q!Qn   * *  **Zrl