U sVc@@sUddlmZddlZddlmZddlmZddlmZm Z m Z m Z m Z m Z ddlZddlZddlmZddlmZmZmZmZmZmZmZddlmZmZmZmZm Z m!Z!dd l"m#Z$dd l%m&Z&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,dd l-m.Z.dd l/m0Z0m1Z1ddl2m3m4Z5ddl6m7Z7ddl8m9Z9ddl:m3m;Z<ddl=m>Z>m?Z?ddl@mAZAddlBmCZCmDZDmEZEmFZFddlGmHZHddlImJZJddlKmLZLmMZMddlNmOZOmPZPddlQmRZRmSZSddlTmUZUmVZVddlWmXZXmYZYmZZZm[Z[erddl\m]Z]m^Z^m_Z_iZ`dead<GdddeCe9ZbeDfdd d!d"d#d$d%Zcd&D]Zdecedd'q2d(D]Zdecedd)qHd*D]Zdecedd+q^d,D]Zdecedd-qtd.D]Zdecedd-eAqGd/d0d0e9ZeGd1d2d2ebZfGd3d4d4eeefZgGd5d6d6efZhGd7d8d8eeehZiGd9d:d:efZjGd;d<dd?d@Zlebjmel_mdndAdBZnGdCdDdDeHZododEdFdGdHdEdIdJdKZpdpdNdNdOdPdQdRdSdTdUZqdqdVdVdOdPdQdWdSdXdYZrdZd[dZdHd\d]d^d_ZsdrdNdNdadPdQdRdSdbdcZtdsdEdedEdfdgdhZudidjdkdlZvdS)t) annotationsN) timedelta)dedent) TYPE_CHECKINGCallableHashableLiteralfinal no_type_check)lib) BaseOffsetIncompatibleFrequencyNaTPeriod Timedelta Timestamp to_offset) IndexLabelNDFrameTTTimedeltaConvertibleTypesTimestampConvertibleTypesnpt)function)AbstractMethodError DataError)Appender Substitutiondeprecate_nonkeyword_argumentsdoc)find_stack_level) ABCDataFrame ABCSeries)ResamplerWindowApply) PandasObject)NDFrame _shared_docs) SeriesGroupBy) BaseGroupByGroupBy_pipe_template get_groupby)Grouper) BinGrouper) DatetimeIndex date_range) PeriodIndex period_range)TimedeltaIndextimedelta_range) is_subperiodis_superperiod) DateOffsetDayNanoTick) DataFrameIndexSerieszdict[str, str]_shared_docs_kwargsc sTeZdZUdZded<eZded<dddd d d d d dg Zdvej ddddddddddZ e ddZ ddddZ dd d!d"Zed#dd$d%Zed&d'Zed(dd)d*Zd+d+d,d-d.Zd/d0Ze d1d2Zedd3d4eed5d6d7fd8d9 Zed:Zed;Zeed<eed=d>d?dwd@dAZeZ eZ!dBdCZ"dDdEZ#dxdFdGZ$dyddHdIdJZ%dKdLZ&dMdNZ'dzdOdPZ(dQdRZ)d{dSdTZ*d|dUdVZ+d}dWdXZ,d~dYdZZ-dd[d\Z.dd]d^Z/e0dd_d`gdaee1j2fe3ddedfZ2ddgdhZ4diej fddjdkdlZ5diej fddjdmdnZ6ee7j8dodpZ8ee7j9dqdrZ9ddtduZ:Z;S) 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 axis : int, default 0 kind : str or None 'period', 'timestamp' to override default index treatment Returns ------- a Resampler of the appropriate type Notes ----- After resampling, see aggregate, apply, and transform functions. r-grouperzfrozenset[Hashable] exclusionsfreqaxisclosedlabel conventionloffsetkindoriginoffsetrN) group_keys selectionzDataFrame | Series TimeGrouperintbool | lib.NoDefaultNone)objgroupbyrBrJreturncKs||_d|_d|_||_||_d|_||_d|_|jj| |dd| \|_ |_ ||_ |jjdk rzt|jjg|_nt|_dS)NTF)sort)rQkeysrSrBrGZsqueezerJZas_index _set_grouper _convert_obj _get_binnerbinnerr? _selectionkey frozensetr@)selfrPrQrBrGrJrKkwargsr^8/tmp/pip-unpacked-wheel-xj8nt62q/pandas/core/resample.py__init__s  zResampler.__init__cKsBt||jr|j}|jD]}||krt||||<q|j|f|S)zE return a new object with the replacement attributes ) isinstance _constructorrP _attributesgetattr)r\rPr]attrr^r^r_ _shallow_copys   zResampler._shallow_copystrrRcs0fddjD}tjdd|dS)z@ Provide a nice str repr of our rolling object. c3s6|].}tj|ddk r|dtj|VqdS)N=)rdrQ).0kr\r^r_ sz$Resampler.__str__..z [z, ])rctype__name__join)r\attrsr^rlr___str__s zResampler.__str__)recCsJ||jkrt||S||jkr,t|j|S||jkr>||St||SN)Z_internal_names_setobject__getattribute__rcrdrQrP)r\rer^r^r_ __getattr__s     zResampler.__getattr__r%cCs|jjSrt)rQrPrlr^r^r_rPsz Resampler.objcCs|jjSrt)rQaxrlr^r^r_rxsz Resampler.axboolcCs"|jdk o |jjdk p |jjdk S)zP Is the resampling from a DataFrame column or MultiIndex level. N)rQrZlevelrlr^r^r__from_selections zResampler._from_selectionrrPrRcCs|S)z Provide any conversions for the object in order to correctly handle. Parameters ---------- obj : Series or DataFrame Returns ------- Series or DataFrame )Z _consolidate)r\rPr^r^r_rVs zResampler._convert_objcCs t|dSrtrrlr^r^r__get_binner_for_timeszResampler._get_binner_for_timecCs<|\}}}t|t|ks"tt|||jjd}||fS)zk Create the BinGrouper, assume that self.set_grouper(obj) has already been called. )indexer)r~lenAssertionErrorr-rQr)r\rXbins binlabelsZ bin_grouperr^r^r_rWszResampler._get_binnera >>> 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)klassexamplesz/Callable[..., T] | tuple[Callable[..., T], str]r)funcrRcstj|f||Srt)superpipe)r\rargsr] __class__r^r_rszResampler.pipea[ 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. a 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(np.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': np.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 aggregater:)Zsee_alsorrrBcOs@t||||d}|dkr2|}|j|f||}||}|S)N)rr])r#agg_groupby_and_aggregate_apply_loffset)r\rrr]resulthowr^r^r_rWs  zResampler.aggregatecOs|j|jj|f||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. Returns ------- transformed : Series 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_objrQ transform)r\argrr]r^r^r_rks zResampler.transformcKs t|dSrtr})r\fr]r^r^r_ _downsampleszResampler._downsamplecCs t|dSrtr})r\rlimit fill_valuer^r^r_ _upsampleszResampler._upsample)ndimcCsR|j}|dkr|j}t|d||j|jd}z ||WStk rL|YSXdS) 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 NZbyr?rBrJ)r?rPr+rBrJKeyError)r\rZrsubsetr?groupedr^r^r__gotitems  zResampler._gotitemc Os|j}|jjdkr|j}n|j}t|d||j|jd}z>> 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: 15T, 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: 15T, dtype: float64 nearestrrrr^r^r_r;s:zResampler.nearestcCs|jd|dS)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 -------- bfill : Alias of backfill. fillna : Fill NaN values using the specified method, which can be 'backfill'. 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_(statistics) 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: 30T, 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: 15T, 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 bfillrrrr^r^r_rwsdzResampler.bfillcCstjdttd|j|dS)ac Backward fill the values. .. deprecated:: 1.4 Use bfill instead. Parameters ---------- limit : int, optional Limit of how many values to fill. Returns ------- Series, DataFrame An upsampled Series or DataFrame with backward filled NaN values. zRbackfill is deprecated and will be removed in a future version. Use bfill instead.rr)rrrr rrr^r^r_backfills zResampler.backfillcCs|j||dS)a  Fill missing values introduced by upsampling. 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). Missing values that existed in the original data will not be modified. Parameters ---------- method : {'pad', 'backfill', 'ffill', 'bfill', 'nearest'} Method to use for filling holes in resampled data * 'pad' or 'ffill': use previous valid observation to fill gap (forward fill). * 'backfill' or 'bfill': use next valid observation to fill gap. * 'nearest': use nearest valid observation to fill gap. limit : int, optional Limit of how many consecutive missing values to fill. Returns ------- Series or DataFrame An upsampled Series or DataFrame with missing values filled. See Also -------- bfill : Backward fill NaN values in the resampled data. ffill : Forward fill NaN values in the resampled data. nearest : Fill NaN values in the resampled data with nearest neighbor starting from center. interpolate : Fill NaN values using interpolation. Series.fillna : Fill NaN values in the Series using the specified method, which can be 'bfill' and 'ffill'. DataFrame.fillna : Fill NaN values in the DataFrame using the specified method, which can be 'bfill' and 'ffill'. References ---------- .. [1] https://en.wikipedia.org/wiki/Imputation_(statistics) 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 Without filling the missing values you get: >>> s.resample("30min").asfreq() 2018-01-01 00:00:00 1.0 2018-01-01 00:30:00 NaN 2018-01-01 01:00:00 2.0 2018-01-01 01:30:00 NaN 2018-01-01 02:00:00 3.0 Freq: 30T, dtype: float64 >>> s.resample('30min').fillna("backfill") 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: 30T, dtype: int64 >>> s.resample('15min').fillna("backfill", 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: 15T, dtype: float64 >>> s.resample('30min').fillna("pad") 2018-01-01 00:00:00 1 2018-01-01 00:30:00 1 2018-01-01 01:00:00 2 2018-01-01 01:30:00 2 2018-01-01 02:00:00 3 Freq: 30T, dtype: int64 >>> s.resample('30min').fillna("nearest") 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: 30T, dtype: int64 Missing values present before the upsampling are not affected. >>> sm = pd.Series([1, None, 3], ... index=pd.date_range('20180101', periods=3, freq='h')) >>> sm 2018-01-01 00:00:00 1.0 2018-01-01 01:00:00 NaN 2018-01-01 02:00:00 3.0 Freq: H, dtype: float64 >>> sm.resample('30min').fillna('backfill') 2018-01-01 00:00:00 1.0 2018-01-01 00:30:00 NaN 2018-01-01 01:00:00 NaN 2018-01-01 01:30:00 3.0 2018-01-01 02:00:00 3.0 Freq: 30T, dtype: float64 >>> sm.resample('30min').fillna('pad') 2018-01-01 00:00:00 1.0 2018-01-01 00:30:00 1.0 2018-01-01 01:00:00 NaN 2018-01-01 01:30:00 NaN 2018-01-01 02:00:00 3.0 Freq: 30T, dtype: float64 >>> sm.resample('30min').fillna('nearest') 2018-01-01 00:00:00 1.0 2018-01-01 00:30:00 NaN 2018-01-01 01:00:00 NaN 2018-01-01 01:30:00 3.0 2018-01-01 02:00:00 3.0 Freq: 30T, dtype: float64 DataFrame resampling is done column-wise. All the same options are available. >>> 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').fillna("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 rr)r\methodrr^r^r_fillnaszResampler.fillnar\r)versionZ allowed_argslinearFforwardc Ks*|d} | jf|||||||d|S)zD Interpolate values according to different methods. asfreq)rrBrinplacelimit_direction limit_areadowncast)r interpolate) r\rrBrrrrrr]rr^r^r_rs zResampler.interpolatecCs|jd|dS)a6 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. r)rr)r\rr^r^r_rszResampler.asfreqr numeric_onlycOstd|||jd||dS)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. .. versionadded:: 1.5.0 Returns ------- DataFrame or Series Standard deviation of values within each group. stdddofrnvvalidate_resampler_funcrr\rrrr]r^r^r_rsz Resampler.stdcOstd|||jd||dS)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. .. versionadded:: 1.5.0 Returns ------- DataFrame or Series Variance of values within each group. varrrrr^r^r_rsz Resampler.varcCsP|d}t|jsLddlm}|jjdkr6|jj}nd}|g|jd|d}|S)Nsizer)r<rint64rdtyper) rrrxpandasr<rrrr)r\rr<rr^r^r_rs     zResampler.sizecCsb|d}t|js^|jjdkr>t|jg|jd|jjd}n ddlm }|g|j|j dd}|S)Ncountrrrr)r:)rcolumnsr) rrrxrrrorrrr:r)r\rr:r^r^r_r s"    zResampler.count?cKs|jdd|i|S)a Return value at the given quantile. Parameters ---------- q : float or array-like, default 0.5 (50% quantile) 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 coulmns are groupby columns, and the values are its quantiles. quantileq)r)r)r\rr]r^r^r_rszResampler.quantile)rN)N)NN)N)N)N)N)N)N)N)N)rrNFrNN)N)r)is        + " 1    < f  !    r>rgztuple[str, ...]rorO)rr docs_classrRcs|dks t|dkr2tjdfdddfdd }nT|dkrTtjfddfd d }n2|d krzd tjfddd fd d }n fd d}t|j|_tt|dS)z Add a kernel to Resampler. Arguments --------- name : str Name of the kernel. args : tuple Arguments of the method. docs_class : type Class to get kernel docstring from. )r min_countrrr^rrrNrMcs4t|||tjkr$dkr$d}|j||dS)NsumFr)rrr rr)r\rrrr]rr^r_rQsz!_add_downsample_kernel..frcst|||j|dS)Nrr)r\rrr]rr^r_rcsrrcst|||j||dS)Nrrrrr^r_rkscst|||Srtr)r\rr]rr^r_rwsN)rr rrdrsetattrr>)rrrrr^rr__add_downsample_kernel8s  r)rprodminmaxfirstlastr)meanZmedianr)Zsemr)ohlcr^)Znuniquec@s\eZdZUdZded<dZded<dddd d Zed d ZeZ eZ eZ e dd dZ dS) _GroupByMixinz) Provide the groupby facilities. z list[str]rcNzIndexLabel | NonerYrOrhc Ksv|dkr |}|jD]}t||||t||q|d|_|j|_||_||_d|j_d|jj _t |j |_ dS)NrKT) rcrgetrdrYrXrZ_groupbyZmutatedr?copyrQ)r\rPparentrQrZr]rer^r^r_r`s   z_GroupByMixin.__init__cs(fdd}j|}|S)z Dispatch to _upsample; we are stripping all of the _upsample kwargs and performing the original function call on the grouped object. cs<j|jd}ttr*t|fS|jfS)N)rQ)rfrQrargrdr)xrrr]r\r^r_rs z"_GroupByMixin._apply..func)rrr)r\rrr]rrr^rr__applys z_GroupByMixin._applycs|dkrj}fddjD}z.t|trDj|krD|jj|}Wntk rjj}YnXd}|jdkrt |r||kst |r|}t |f||d|}|S)rNcsi|]}|t|qSr^)rd)rjrerlr^r_ sz*_GroupByMixin._gotitem..)rQrrK) rPrcralistrZappendr IndexErrorrr Z is_scalarZ is_list_likero)r\rZrrr]rQrKZnew_rsr^rlr_rs8   z_GroupByMixin._gotitem)NNN)N)rprrrrrYr`r rrrrr rr^r^r^r_rs   rcsJeZdZeddZddZddZddZdd d Zfd d Z Z S)DatetimeIndexResamplercCstSrt)DatetimeIndexResamplerGroupbyrlr^r^r_rsz.DatetimeIndexResampler._resampler_for_groupingcCs&|jdkr|j|jS|j|jSNperiod)rGrQ_get_time_period_binsrx_get_time_binsrlr^r^r_r~s z+DatetimeIndexResampler._get_binner_for_timecKst|p |}|j}|jjdkr(|j}n|j}t|sr|}|j |j |_|jj |j ksnt |jj |j f|S|j dk s|j dk rt|j jt|kr|dkr|S|j|j |jdj|f|}||}||S) Downsample the cython defined function. Parameters ---------- how : string / cython mapped function **kwargs : kw args passed to how function rNrB)comget_cython_funcrxrrrrrrZ _with_freqrAr inferred_freqr?rrrQrBrrr)r\rr]rxrPrr^r^r_rs,    z"DatetimeIndexResampler._downsamplecCs(|jdkr|dd}n |dd}|S)z| Adjust our binner when upsampling. The range of a new index should not be outside specified range rightrN)rCr\rXr^r^r__adjust_binner_for_upsample"s  z2DatetimeIndexResampler._adjust_binner_for_upsampleNc Cs|jrtd|jrtd|j}|j}|j}||}|dkrpt|j |j krpt |t |krp| }||_ n|j||||d}||}||S)a 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 See Also -------- .fillna: Fill NA/NaN values using the specified method. zaxis must be 0zvUpsampling from level= or on= selection is not supported, use .set_index(...) to explicitly set index to datetime-likeN)rrr)rBrr{rrxrrXrrr rArrrreindexrr) r\rrrrxrPrXZ res_indexrr^r^r_r.s4  z DatetimeIndexResampler._upsamplecs6t|}|jdkr2t|jts2|j|j|_|Sr)rrrGrarr0 to_periodrA)r\rrr^r_r\s z#DatetimeIndexResampler._wrap_result)NN) rprrrrr~rrrrrr^r^rr_rs + .rc@seZdZdZeddZdS)rz9 Provides a resample of a groupby implementation cCstSrt)rrlr^r^r_rbksz*DatetimeIndexResamplerGroupby._constructorNrprrrrrbr^r^r^r_rfsrcsVeZdZeddZfddZdddfdd Zfd d Zdfd d ZZ S)PeriodIndexResamplercCstSrt)PeriodIndexResamplerGroupbyrlr^r^r_rqsz,PeriodIndexResampler._resampler_for_groupingcs"|jdkrtS|j|jS)N timestamp)rGrr~rQ_get_period_binsrxrlrr^r_r~us  z)PeriodIndexResampler._get_binner_for_timerr|csJt|}|jrd}t||jdk r.d|_|jdkrF|j|jd}|S)NzResampling from level= or on= selection with a PeriodIndex is not currently supported, use .set_index(...) to explicitly set indexrr)rrVr{NotImplementedErrorrFrG to_timestamprE)r\rPmsgrr^r_rVzs   z!PeriodIndexResampler._convert_objc s|jdkrtj|f|St|p&|}|j}t|j|jrJ|j|f|St |j|jrr|dkrj||S| S|j|jkr| St d|jd|jddS)rrrz Frequency z cannot be resampled to z&, as they are not sub or super periodsN) rGrrr r rxr4rArr5rr )r\rr]rxrr^r_rs   z PeriodIndexResampler._downsampleNc sl|jdkrtj|||dS|j}|j}|j}|j|j|jd}|j |||d}t ||||j d} | | S)a 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. See Also -------- .fillna: Fill NA/NaN values using the specified method. r)rrr)rrr) rGrrrxrPrXrrArEZ get_indexer_take_new_indexrBr) r\rrrrxrP new_indexmembrnew_objrr^r_rs zPeriodIndexResampler._upsample)NN) rprrrrr~rVrrrr^r^rr_rps    $rc@seZdZdZeddZdS)r: Provides a resample of a groupby implementation. cCstSrt)rrlr^r^r_rbsz(PeriodIndexResamplerGroupby._constructorNrr^r^r^r_rsrc@s(eZdZeddZddZddZdS)TimedeltaIndexResamplercCstSrt)TimedeltaIndexResamplerGroupbyrlr^r^r_rsz/TimedeltaIndexResampler._resampler_for_groupingcCs|j|jSrt)rQ_get_time_delta_binsrxrlr^r^r_r~sz,TimedeltaIndexResampler._get_binner_for_timecCs|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 r^rr^r^r_rsz3TimedeltaIndexResampler._adjust_binner_for_upsampleN)rprrrrr~rr^r^r^r_r s r c@seZdZdZeddZdS)r!rcCstSrt)r rlr^r^r_rbsz+TimedeltaIndexResamplerGroupby._constructorNrr^r^r^r_r!sr!zGDatetimeIndexResampler | PeriodIndexResampler | TimedeltaIndexResamplerrhcKstf|}|j||dS)z8 Create a TimeGrouper and return our resampler. rG)rL_get_resampler)rPrGkwdstgr^r^r_ get_resamplers r'c Ks4tf||d|}|j|j|d} | j||jdS)zA Return our appropriate resampler when grouping as well. )rArZr#r)rLr$rPrrZ) rQruler fill_methodrrGonr]r&Z resamplerr^r^r_get_resampler_for_groupingsr+cseZdZdZejdZd(d d d d d d dddd fdd Zd)ddZd*ddddZddddZ ddZ d dd!d"Z ddd#d$Z d%dd&d'Z ZS)+rLah 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 )rCrDrrFrGrErHrIMinNrr start_dayTz!Literal[('left', 'right')] | Nonez str | Nonez*Literal[('start', 'end', 'e', 's')] | Nonez int | Nonezstr | TimestampConvertibleTypesz TimedeltaConvertibleTypes | NonerNrO) rCrDrGrEbaserHrIrJrRc sV|dkrtd|d|dkr0td|d| dkrHtd| dt|}ddd d d d d h}|j}||ksd|kr|d|d|kr|dkrd}|dkrd}n:| dkr|dkrd}|dkrd}n|dkrd}|dkrd}||_||_| |_| dk r| nd|_||_||_ ||_ ||_ | dkr2| |_ nJzt | |_ Wn:ttfk rz}ztd| d|W5d}~XYnXz| dk rt| nd|_Wn:ttfk r}ztd| d|W5d}~XYnXd|d<| dk r| dk rtd| r t|tr t| |j|j|_t|tr4t|}||_tjf||d|dS)N>Nr leftzUnsupported value z for `label`z for `closed`>Nseendstartz for `convention`MAQZBMZBAZBQW-r r2end_dayr/r1)epochr3r-r2r:z|'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 'TrSz6'offset' and 'base' cannot be present at the same time)rArB)rrZ rule_codefindrCrDrGrErr)rrJrHr TypeErrorrrIrar9nanosnrgrFrr`)r\rArCrDrrBr)rrFrGrEr.rHrIrJr]Z end_typesr(rrr^r_r`2st&    zTimeGrouper.__init__cCs|||j}t|tr0t||||j|jdSt|tsB|dkrXt||||j|jdSt|t rvt |||j|jdSt dt |j ddS)a_ Return my resampler or raise if we have an invalid axis. Parameters ---------- obj : input object kind : string, optional 'period','timestamp','timedelta' are valid Returns ------- a Resampler Raises ------ TypeError if incompatible axis )rQrGrBrJr)rQrBrJzVOnly valid with DatetimeIndex, TimedeltaIndex or PeriodIndex, but got an instance of ''N)rUrxrar.rrBrJr0rr2r r=rorp)r\rPrGrxr^r^r_r$s8   zTimeGrouper._get_resamplerry)validatecCs||}|j|j|jfSrt)r$rXr?rP)r\rPrArr^r^r_ _get_groupers zTimeGrouper._get_grouperr.)rxc CsFt|tstdt|jt|dkrJtg|j|jd}}|g|fSt| | |j|j |j |j d\}}t|j|||j|jddd}}|j}|||\}}tj|||j |jd}|j d kr|}|jd kr|d d}n|jd kr|d d}|jr|dt}|dt}t|t|kr<|dt|}|||fS) N5axis must be a DatetimeIndex, but got an instance of rdatarArrCrHrITZ shift_forward)rAr3r2tzrZ ambiguousZ nonexistent)hasnansr r)rar.r=rorprrAr_get_timestamp_range_edgesrrrCrHrIr/rHasi8_adjust_bin_edgesr Zgenerate_bins_dt64rIrDinsertr) r\rxrXlabelsrr ax_values bin_edgesrr^r^r_rsX           zTimeGrouper._get_time_binscCs|jdkr~t|jdr~|jdkrN|d}|tdtd}||jj}n|j}|d|kr|dd}|dd}n|j}||fS)NDr rr ) rAr5rC tz_localizerr8rHrKr)r\rXrOrPr^r^r_rLs   zTimeGrouper._adjust_bin_edgesr2cCst|tstdt|jt|sFtg|j|jd}}|g|fS|| }}|j dkrl||j7}t |||j|jd}}|}|j dkr||j7}|j ||j d}|j r||j 7}|jr||j7}|||fS)Nz6axis must be a TimedeltaIndex, but got an instance of rEr r3r2rArr/Zside)rar2r=rorprrArrrrCr3 searchsortedrIrF)r\rxrXrNr3r2 end_stampsrr^r^r_r"s2         z TimeGrouper._get_time_delta_binscCst|tstdt|j|j}t|sJtg||jd}}|g|fSt |d|d||jd}}|| |d }|j r| |j }|j|dd}|||fS) NrDrErr rTr0r/rU)rar.r=rorprArr0rr1rrrHrSrV)r\rxrArXrNrWrr^r^r_r>s   z!TimeGrouper._get_time_period_binsr0cCst|tstdt|j|j|j|jd}d}|jrRt |j }||j }t |st j gt jd}tg|j|jd}}t |dkrt|||t |\}}}|||fS|jj}|j|j|jd}|j|jdd} d} t|jtr8t|| |j|j|j|jd\} } t||jt| |j} | j|} | }t|| |j|jd}}|j} t ||}|| d | d}t | d| d ||}||7}|| 8}t|j||jd}|j|d d }|dkrt||||\}}}|||fS) Nz3axis must be a PeriodIndex, but got an instance of rr)rrEr2rGrTr r/rU) rar0r=rorprrArErIrrZ_isnanrarrayrr_insert_nat_binr?rrr9_get_period_range_edgesrCrHrIrr1rKZarange_datarrV)r\rxr nat_countrrXrNZ freq_multr3r2Z bin_shiftZp_startZ start_offseti8Zexpected_bins_countZ i8_extendrngZprngr^r^r_rTs`          zTimeGrouper._get_period_bins)r,NNrrNNNNNNr-NT)N)T)rprrrr,rcr`r$rCrrLr"rrrr^r^rr_rLs0 $h )?#rLrznpt.NDArray[np.intp]r;rM)rPrrrBrRcCslt|tr*t|j|}|j|||jdSt|tr`|dkrDtd|j j ||dd}||St ddS)N)rrrzaxis 1 is not supported)Znew_axisrrBz.'obj' should be either a Series or a DataFrame) rar"algosZtake_ndZ_valuesrbrr!rZ_mgrZreindex_indexerr)rPrrrBZ new_valuesZnew_mgrr^r^r_rs   rr/r-rr zLiteral[('right', 'left')]zTimedelta | Noneztuple[Timestamp, Timestamp])rrrArCrIrRcCst|tr|j}t|tr6|jdk|dkkr6tdn|dkrJtd|d}t|tr||d}|d}t|tr||d}t||||||d\}}t|tr||}||}n@|}|}|dkrt| |}n t||}t||}||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.r;z 1970-01-01)rHrGr/) rar9rHrrr7rS_adjust_dates_anchored normalizerollback)rrrArCrHrIZindex_tzr^r^r_rJs:(              rJrztuple[Period, Period]c Cstdd||fDstd|}|}|| }||} t||||||d\}}|t|||}|t| ||}||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. css|]}t|tVqdSrt)rar)rjrPr^r^r_rm)sz*_get_period_range_edges..z3'first' and 'last' must be instances of type PeriodrG)allr=rZ is_on_offsetrJrMr) rrrArCrHrIZfirst_tsZlast_tsZ adjust_firstZ adjust_lastr^r^r_rZs"&   rZr0z np.ndarrayz+tuple[PeriodIndex, np.ndarray, PeriodIndex])rXrrNr\rRcCsD|dks t||7}t|d|}|dt}|dt}|||fS)Nr)rrrMr)rXrrNr\r^r^r_rY;s    rYr r9cCsd}|dkr|j}nt|dkr(|j}ndt|tr:|j}nR|dkr|dkrN|n|d}|j|j|j}|dkrz|d7}|||}|j}||r|jnd7}|j}|j} |dk r|d }| dk r|d }|j||j} |j||j} |d kr>| dkr|j| } n |j|j} | dkr6|j|j| } n|j} nD| dkrT|j| } n|j} | dkrv|j|j| } n |j|j} t| }t| }|dk r|d |}| dk r|d | }||fS) Nrr-r3r9r2rQr/rUTCr ) ravaluerarceilr>tzinfoZ tz_convertrS)rrrArCrHrIZ origin_nanosZsub_freq_timesZ first_tzinfoZ last_tzinfoZfoffsetrFZ fresult_intZ lresult_intZfresultZlresultr^r^r_r`MsV                 r`Fry)rPrarRcCst|jtrD|dk rtd|dkr(d}|}|jj||d|_njt|jdkrj|}t|j||_nDt|j |j |d}|jj |_ |j |||d}|r|j |_|S)z Utility frequency conversion method for Series/DataFrame. See :meth:`pandas.NDFrame.asfreq` for full documentation. Nz"'method' argument is not supportedErrr)rr)rarr0rrrrrr/rrrrra)rPrArrrarrZdtir^r^r_rs   rz,DatetimeIndex | PeriodIndex | TimedeltaIndex)rcCs|t|dkrtdt|tr,|j|d}nLt|trLtg|j||jd}n,t|trltg|j||jd}n t t ||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)rrAr) rrrar0rr.rrr2r=ro)rrArr^r^r_rs     r)N)NNNNN)r)r/r-N)r/r-N)r r-N)NNFN)w __future__rrdatetimertextwraprtypingrrrrr r rZnumpyrZ pandas._libsr Zpandas._libs.tslibsr r rrrrrZpandas._typingrrrrrrZpandas.compat.numpyrrZ pandas.errorsrrZpandas.util._decoratorsrrrrZpandas.util._exceptionsr Zpandas.core.dtypes.genericr!r"Zpandas.core.algorithmscoreZ algorithmsr_Zpandas.core.applyr#Zpandas.core.baser$Zpandas.core.commoncommonr Zpandas.core.genericr%r&Zpandas.core.groupby.genericr'Zpandas.core.groupby.groupbyr(r)r*r+Zpandas.core.groupby.grouperr,Zpandas.core.groupby.opsr-Zpandas.core.indexes.datetimesr.r/Zpandas.core.indexes.periodr0r1Zpandas.core.indexes.timedeltasr2r3Zpandas.tseries.frequenciesr4r5Zpandas.tseries.offsetsr6r7r8r9rr:r;r<r=rr>rrrrrrrr r!r'rr+rLrrJrZrYr`rrr^r^r^r_s     $         WK\{ k     R8O%