i"ddlmZddlZddlmZddlmZmZddlZ ddl m Z ddl m cmcmZddlmZddlmZmZddlmZdd lmZdd lmZdd lmZdd lmZdd l m!Z!m"Z"m#Z#ddl$m%Z%m&Z&ddl'm(Z(ddl)m*Z*m+Z+ddl,m-Z-m.Z.ddl/m0Z0m1Z1erddl2m3Z3m4Z4m5Z5ddl6m7Z7m8Z8ddl9m:Z: ddZ; d dZ<edGdde0Z=edGdde1e=Z>Gdde=Z?y)!) annotationsN)partial) TYPE_CHECKINGcast) Timedelta) set_module)is_datetime64_dtypeis_numeric_dtype)DatetimeTZDtype) ABCSeries)isna)common) dtype_to_unit) BaseIndexerExponentialMovingWindowIndexerGroupbyIndexer)get_jit_argumentsmaybe_use_numba)zsqrt)generate_numba_ewm_funcgenerate_numba_ewm_table_func) EWMMeanStategenerate_online_numba_ewma_func) BaseWindowBaseWindowGroupby)TimedeltaConvertibleTypesTimeUnitnpt) DataFrameSeries)NDFramectj||||}|dkDr td||dkrtd|#|dkr td|dz dz }t |S|Q|dkr tddtjtj d|z z }d|z dz }t |S|(|dks|dkDr td d|z |z }t |Std t |S) Nz8comass, span, halflife, and alpha are mutually exclusiverz comass must satisfy: comass >= 0zspan must satisfy: span >= 1z#halflife must satisfy: halflife > 0g?z"alpha must satisfy: 0 < alpha <= 1z1Must pass one of comass, span, halflife, or alpha)rcount_not_none ValueErrornpexplogfloat)comassspanhalflifealpha valid_countdecays S/app/cer_product_mecsu/.venv/lib/python3.12/site-packages/pandas/core/window/ewm.pyget_center_of_massr2?s! ''hFKQSTT A:?@ @  !8;< <(a =   q=BC CBFF266#;122UQ =   A:AB Be)u$ =LMM =ct|j}td|}t|tr |j }t j|jt jt j}tt|j|j}t j||z S)a Return the diff of the times divided by the half-life. These values are used in the calculation of the ewm mean. Parameters ---------- times : np.ndarray, Series Times corresponding to the observations. Must be monotonically increasing and ``datetime64[ns]`` dtype. halflife : float, str, timedelta, optional Half-life specifying the decay Returns ------- np.ndarray Diff of the times divided by the half-life rdtype)rr6r isinstancer _valuesr'asarrayviewint64float64r*ras_unit_valuediff)timesr-unit_times _halflifes r1_calculate_deltasrD`s*  %D  D !D%#  ZZ 288,BJJ ?Fi)11$7>>?I 776?Y &&r3zpandas.api.typingc$eZdZdZgdZ ddd dfdZ ddZddZ d ddZdfd Z e Z d dd Z d dd Z ddd Z ddd Z d ddZ d ddZxZS)ExponentialMovingWindowa Provide exponentially weighted (EW) calculations. Exactly one of ``com``, ``span``, ``halflife``, or ``alpha`` must be provided if ``times`` is not provided. If ``times`` is provided and ``adjust=True``, ``halflife`` and one of ``com``, ``span`` or ``alpha`` may be provided. If ``times`` is provided and ``adjust=False``, ``halflife`` must be the only provided decay-specification parameter. Parameters ---------- com : float, optional Specify decay in terms of center of mass :math:`\alpha = 1 / (1 + com)`, for :math:`com \geq 0`. span : float, optional Specify decay in terms of span :math:`\alpha = 2 / (span + 1)`, for :math:`span \geq 1`. halflife : float, str, timedelta, optional Specify decay in terms of half-life :math:`\alpha = 1 - \exp\left(-\ln(2) / halflife\right)`, for :math:`halflife > 0`. If ``times`` is specified, a timedelta convertible unit over which an observation decays to half its value. Only applicable to ``mean()``, and halflife value will not apply to the other functions. alpha : float, optional Specify smoothing factor :math:`\alpha` directly :math:`0 < \alpha \leq 1`. min_periods : int, default 0 Minimum number of observations in window required to have a value; otherwise, result is ``np.nan``. adjust : bool, default True Divide by decaying adjustment factor in beginning periods to account for imbalance in relative weightings (viewing EWMA as a moving average). - When ``adjust=True`` (default), the EW function is calculated using weights :math:`w_i = (1 - \alpha)^i`. For example, the EW moving average of the series [:math:`x_0, x_1, ..., x_t`] would be: .. math:: y_t = \frac{x_t + (1 - \alpha)x_{t-1} + (1 - \alpha)^2 x_{t-2} + ... + (1 - \alpha)^t x_0}{1 + (1 - \alpha) + (1 - \alpha)^2 + ... + (1 - \alpha)^t} - When ``adjust=False``, the exponentially weighted function is calculated recursively: .. math:: \begin{split} y_0 &= x_0\\ y_t &= (1 - \alpha) y_{t-1} + \alpha x_t, \end{split} ignore_na : bool, default False Ignore missing values when calculating weights. - When ``ignore_na=False`` (default), weights are based on absolute positions. For example, the weights of :math:`x_0` and :math:`x_2` used in calculating the final weighted average of [:math:`x_0`, None, :math:`x_2`] are :math:`(1-\alpha)^2` and :math:`1` if ``adjust=True``, and :math:`(1-\alpha)^2` and :math:`\alpha` if ``adjust=False``. - When ``ignore_na=True``, weights are based on relative positions. For example, the weights of :math:`x_0` and :math:`x_2` used in calculating the final weighted average of [:math:`x_0`, None, :math:`x_2`] are :math:`1-\alpha` and :math:`1` if ``adjust=True``, and :math:`1-\alpha` and :math:`\alpha` if ``adjust=False``. times : np.ndarray, Series, default None Only applicable to ``mean()``. Times corresponding to the observations. Must be monotonically increasing and ``datetime64[ns]`` dtype. If 1-D array like, a sequence with the same shape as the observations. method : str {'single', 'table'}, default 'single' Execute the rolling operation per single column or row (``'single'``) or over the entire object (``'table'``). This argument is only implemented when specifying ``engine='numba'`` in the method call. Only applicable to ``mean()`` Returns ------- pandas.api.typing.ExponentialMovingWindow An instance of ExponentialMovingWindow for further exponentially weighted (EW) calculations, e.g. using the ``mean`` method. See Also -------- rolling : Provides rolling window calculations. expanding : Provides expanding transformations. Notes ----- See :ref:`Windowing Operations ` for further usage details and examples. Examples -------- >>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]}) >>> df B 0 0.0 1 1.0 2 2.0 3 NaN 4 4.0 >>> df.ewm(com=0.5).mean() B 0 0.000000 1 0.750000 2 1.615385 3 1.615385 4 3.670213 >>> df.ewm(alpha=2 / 3).mean() B 0 0.000000 1 0.750000 2 1.615385 3 1.615385 4 3.670213 **adjust** >>> df.ewm(com=0.5, adjust=True).mean() B 0 0.000000 1 0.750000 2 1.615385 3 1.615385 4 3.670213 >>> df.ewm(com=0.5, adjust=False).mean() B 0 0.000000 1 0.666667 2 1.555556 3 1.555556 4 3.650794 **ignore_na** >>> df.ewm(com=0.5, ignore_na=True).mean() B 0 0.000000 1 0.750000 2 1.615385 3 1.615385 4 3.225000 >>> df.ewm(com=0.5, ignore_na=False).mean() B 0 0.000000 1 0.750000 2 1.615385 3 1.615385 4 3.670213 **times** Exponentially weighted mean with weights calculated with a timedelta ``halflife`` relative to ``times``. >>> times = ['2020-01-01', '2020-01-03', '2020-01-10', '2020-01-15', '2020-01-17'] >>> df.ewm(halflife='4 days', times=pd.DatetimeIndex(times)).mean() B 0 0.000000 1 0.585786 2 1.523889 3 1.523889 4 3.233686 ) comr,r-r. min_periodsadjust ignore_nar@methodN selectionc  t |||dntt|dddd| | ||_||_||_||_||_||_ | |_ |jt|jdd} t| st| ts tdt!|jt!|k7r tdt|j t"t$j&t(j*fs tdt-|jj/r tdt1|j|j |_t5j6|j|j |jd kDrI|js t9d t;|j|j d|j|_yd |_y|j Dt|j t"t$j&t(j*fr td t)j>t|j@jBd dz d t(jD |_t;|j|j |j |j|_y)Nr#F)objrHoncenterclosedrKrMr6ztimes must be datetime64 dtype.z,times must be the same length as the object.z/halflife must be a timedelta convertible objectz$Cannot convert NaT values to integerrzRNone of com, span, or alpha can be specified if times is provided and adjust=Falseg?zKhalflife can only be a timedelta convertible argument if times is not None.r5)#super__init__maxintrGr,r-r.rIrJr@getattrr r7r r&lenstrdatetime timedeltar' timedelta64r anyrD_deltasrr%NotImplementedErrorr2_comonesrOshaper<)selfrOrGr,r-r.rHrIrJr@rKrM times_dtype __class__s r1rTz ExponentialMovingWindow.__init__Ds- (0c#k:JA6N       " :: !!$**gt 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 -------- pandas.DataFrame.rolling.aggregate 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 -------- >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]}) >>> df A B C 0 1 4 7 1 2 5 8 2 3 6 9 >>> df.ewm(alpha=0.5).mean() A B C 0 1.000000 4.000000 7.000000 1 1.666667 4.666667 7.666667 2 2.428571 5.428571 8.428571 )rS aggregate)rcfuncargskwargsres r1rwz!ExponentialMovingWindow.aggregates Lw 7777r3c t|ry|jdk(rt}nt}|d it ||j |j |jt|jdd}|j|dS|dvrx| td|jdn |j}ttj|j |j |j|d}|j|d| Std ) a Calculate the ewm (exponential weighted moment) mean. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nopython': True, 'nogil': False, 'parallel': False}`` Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.ewm : Calling ewm with Series data. DataFrame.ewm : Calling ewm with DataFrames. Series.mean : Aggregating mean for Series. DataFrame.mean : Aggregating mean for DataFrame. Notes ----- See :ref:`window.numba_engine` and :ref:`enhancingperf.numba` for extended documentation and performance considerations for the Numba engine. Examples -------- >>> ser = pd.Series([1, 2, 3, 4]) >>> ser.ewm(alpha=0.2).mean() 0 1.000000 1 1.555556 2 2.147541 3 2.775068 dtype: float64 singleTrGrIrJdeltas normalizemeannamecythonNN+cython engine does not accept engine_kwargsr numeric_only)engine must be either 'numba' or 'cython'rh)rrKrrrr`rIrJtupler^_applyr&r@rwindow_aggregationsewmrcrrqrrrxewm_funcr~ window_funcs r1rzExponentialMovingWindow.meansl 6 "{{h&.4#M2II{{..T\\* H;;xf;5 5 ' '( !NOO!ZZ/TT\\F!#''II{{.. K;;{l;S SHI Ir3c t|js td|j tdt|ry|jdk(rt }nt }|d it||j|j|jt|jdd}|j|dS|d vrx| td |jdn |j}ttj |j|j|j|d}|j|d| Std )a Calculate the ewm (exponential weighted moment) sum. Parameters ---------- numeric_only : bool, default False Include only float, int, boolean columns. engine : str, default None * ``'cython'`` : Runs the operation through C-extensions from cython. * ``'numba'`` : Runs the operation through JIT compiled code from numba. * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba`` engine_kwargs : dict, default None * For ``'cython'`` engine, there are no accepted ``engine_kwargs`` * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil`` and ``parallel`` dictionary keys. The values must either be ``True`` or ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is ``{'nopython': True, 'nogil': False, 'parallel': False}`` Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.ewm : Calling ewm with Series data. DataFrame.ewm : Calling ewm with DataFrames. Series.sum : Aggregating sum for Series. DataFrame.sum : Aggregating sum for DataFrame. Notes ----- See :ref:`window.numba_engine` and :ref:`enhancingperf.numba` for extended documentation and performance considerations for the Numba engine. Examples -------- >>> ser = pd.Series([1, 2, 3, 4]) >>> ser.ewm(alpha=0.2).sum() 0 1.000 1 2.800 2 5.240 3 8.192 dtype: float64 z(sum is not implemented with adjust=FalseNz!sum is not implemented with timesr|Fr}sumrrrrrrh)rIr_r@rrKrrrr`rJrr^rr&rrrrs r1rzExponentialMovingWindow.sumes!h{{%&PQ Q :: !%&IJ J 6 "{{h&.4#M2II{{..T\\* H;;xe;4 4 ' '( !NOO!ZZ/TT\\F!#''II{{.. K;;{\;R RHI Ir3c|rY|jjdk(r@t|jjs!t t |j d|j t dt|j||S)a Calculate the ewm (exponential weighted moment) standard deviation. Parameters ---------- bias : bool, default False Use a standard estimation bias correction. numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.ewm : Calling ewm with Series data. DataFrame.ewm : Calling ewm with DataFrames. Series.std : Aggregating std for Series. DataFrame.std : Aggregating std for DataFrame. Examples -------- >>> ser = pd.Series([1, 2, 3, 4]) >>> ser.ewm(alpha=0.2).std() 0 NaN 1 0.707107 2 0.995893 3 1.277320 dtype: float64 r#z$.std does not implement numeric_onlyz!std is not implemented with times)biasr) _selected_objndimr r6r_type__name__r@rvarrcrrs r1stdzExponentialMovingWindow.stdsD ""''1,$T%7%7%=%=>&:&&''KL  :: !%&IJ JTXX4lXCDDr3c|j tdtj}t ||j |j |j|fd}|j|d|S)a Calculate the ewm (exponential weighted moment) variance. Parameters ---------- bias : bool, default False Use a standard estimation bias correction. numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.ewm : Calling ewm with Series data. DataFrame.ewm : Calling ewm with DataFrames. Series.var : Aggregating var for Series. DataFrame.var : Aggregating var for DataFrame. Examples -------- >>> ser = pd.Series([1, 2, 3, 4]) >>> ser.ewm(alpha=0.2).var() 0 NaN 1 0.500000 2 0.991803 3 1.631547 dtype: float64 z!var is not implemented with times)rGrIrJrc|||||Srgrh)valuesbeginrjrHwfuncs r1var_funcz-ExponentialMovingWindow.var..var_funcs[&A Ar3rr) r@r_rewmcovrr`rIrJr)rcrrrrrs @r1rzExponentialMovingWindow.varsiB :: !%&IJ J)00   ;;nn   B{{8%l{KKr3cj tdddlmj d|fd}j j ||||S)a Calculate the ewm (exponential weighted moment) sample covariance. Parameters ---------- other : Series or DataFrame , optional If not supplied then will default to self and produce pairwise output. pairwise : bool, default None If False then only matching columns between self and other will be used and the output will be a DataFrame. If True then all pairwise combinations will be calculated and the output will be a MultiIndex DataFrame in the case of DataFrame inputs. In the case of missing elements, only complete pairwise observations will be used. bias : bool, default False Use a standard estimation bias correction. numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.ewm : Calling ewm with Series data. DataFrame.ewm : Calling ewm with DataFrames. Series.cov : Aggregating cov for Series. DataFrame.cov : Aggregating cov for DataFrame. Examples -------- >>> ser1 = pd.Series([1, 2, 3, 4]) >>> ser2 = pd.Series([10, 11, 13, 16]) >>> ser1.ewm(alpha=0.2).cov(ser2) 0 NaN 1 0.500000 2 1.524590 3 3.408836 dtype: float64 z!cov is not implemented with timesrr covc  j|} j|} j} j jn |j}|j t || j j j\}}tj||| j| j j j } ||j|jdS)N num_valuesrHrQrRstepFindexrcopy) _prep_valuesrorH window_sizeget_window_boundsrXrQrRrrrr`rIrJrr) xyx_arrayy_arraywindow_indexerrHrirjresultr rrcs r1cov_funcz-ExponentialMovingWindow.cov..cov_funcTs''*G''*G!557N##/  #//  (99w<'{{{{YY :JE3)//     F&aff5I Ir3r@r_pandasr _validate_numeric_only_apply_pairwiser)rcotherpairwiserrrr s` ` @r1rzExponentialMovingWindow.covs[d :: !%&IJ J! ##E<8 J>##   x<  r3cj tdddlmj d|fd}j j ||||S)a Calculate the ewm (exponential weighted moment) sample correlation. Parameters ---------- other : Series or DataFrame, optional If not supplied then will default to self and produce pairwise output. pairwise : bool, default None If False then only matching columns between self and other will be used and the output will be a DataFrame. If True then all pairwise combinations will be calculated and the output will be a MultiIndex DataFrame in the case of DataFrame inputs. In the case of missing elements, only complete pairwise observations will be used. numeric_only : bool, default False Include only float, int, boolean columns. Returns ------- Series or DataFrame Return type is the same as the original object with ``np.float64`` dtype. See Also -------- Series.ewm : Calling ewm with Series data. DataFrame.ewm : Calling ewm with DataFrames. Series.corr : Aggregating corr for Series. DataFrame.corr : Aggregating corr for DataFrame. Examples -------- >>> ser1 = pd.Series([1, 2, 3, 4]) >>> ser2 = pd.Series([10, 11, 13, 16]) >>> ser1.ewm(alpha=0.2).corr(ser2) 0 NaN 1 1.000000 2 0.982821 3 0.977802 dtype: float64 z"corr is not implemented with timesrrcorrc4 j|}j|}j}j jn |j |j t | j jj\  fd}tjd5|||}|||}|||}|t||zz } ddd  |j|jdS#1swY)xYw)Nrc ztj||jjjd S)NT)rrr`rIrJ)XYrjrHrcris r1_covz.cov_func.._covs=*11IIKKNN  r3ignore)allFr)rrorHrrrXrQrRrr'errstaterrr)rrrrrrrx_vary_varrrjrHrir rcs @@@r1rz.ExponentialMovingWindow.corr..cov_funcs ''*G''*G!557N##/  #//  (99w<'{{{{YY :JE3 * 47G,Wg.Wg.uUU]33  4 &aff5I I  4 4s 9-DDr)rcrrrrr s` @r1rzExponentialMovingWindow.corrws\^ :: !%&JK K! ##FL9# JJ##   x<  r3) NNNNrTFNr|)rOr!rG float | Noner,rr-(float | TimedeltaConvertibleTypes | Noner.rrH int | NonerIboolrJrr@np.ndarray | NDFrame | NonerKrYreturnNone)ri np.ndarrayrjrrkrVrr)rr)numbaN)rqrYrrsrg)FNN)rrFFrrrrNNFFrDataFrame | Series | Noner bool | NonerrrrNNFrrrrrr)r __module__ __qualname____doc__ _attributesrTrlrorurwaggrrrrrr __classcell__res@r1rFrF~svp K!!=A""#-1JJ JJ J ; J  J JJJ+JJ JX  &0 rr3)update update_timesci}|jjdk(}| tdtjt |jj ddz dtj}||jj tdd}|j|d <|r;|jjtjddf} |j|d <n%|jj} |j|d <tj| |j!f} nd}|jj|d <|r|jj|d <n|jj|d <|jj#tjj!} t%d it'|j(} |jj+|r| n| ddtjf||j,| } |s| j/} | |d} |jj0| fi|} | S) a[ Calculate an online exponentially weighted mean. Parameters ---------- update: DataFrame or Series, default None New values to continue calculating the exponentially weighted mean from the last values and weights. Values should be float64 dtype. ``update`` needs to be ``None`` the first time the exponentially weighted mean is calculated. update_times: Series or 1-D np.ndarray, default None New times to continue calculating the exponentially weighted mean from the last values and weights. If ``None``, values are assumed to be evenly spaced in time. This feature is currently unsupported. Returns ------- DataFrame or Series Examples -------- >>> df = pd.DataFrame({"a": range(5), "b": range(5, 10)}) >>> online_ewm = df.head(2).ewm(0.5).online() >>> online_ewm.mean() a b 0 0.00 5.00 1 0.75 5.75 >>> online_ewm.mean(update=df.tail(3)) a b 2 1.615385 6.615385 3 2.550000 7.550000 4 3.520661 8.520661 >>> online_ewm.reset() >>> online_ewm.mean() a b 0 0.00 5.00 1 0.75 5.75 r$Nz update_times is not implemented.r#rr5z;Must call mean with update=None first before passing updatercolumnsrrh)rrr_r'rarUrbr<rlast_ewmr&rnewaxisrrrto_numpyastyperrrrrun_ewmrHsqueeze _constructor) rcrrryrz result_kwargsis_frame update_deltas result_from last_valuenp_array ewma_funcrs r1rz"OnlineExponentialMovingWindow.meanAs X %%**a/  #%&HI I ""((,q0! 4BJJ   zz""* QK%+\\M' "!ZZ00Q? +1>> i(!ZZ00 (. f%~~z6??3D&EFHK%)%7%7%=%=M' "+/+=+=+E+E i((,(:(:(?(? f%))00<EEGH3  2 23 ## Hhq"**}&=        ^^%F %0##00I=I r3) NNNNrTFNrN)rOr!rGrr,rr-rr.rrHrrIrrJrr@rrqrYrrzdict[str, bool] | Nonerrrrg)F)rrrrrrrr) rrrrTrrwrrrrrrrs@r1rsrssD!!=A""#-104%E%E %E%E %E ; %E  %E %E%E%E+%E%E.%E %EN C= ,0 $" >(>> >,0 $" =(== =  =="&DVVr3rs) r+rr,rr-rr.rrr*)r@znp.ndarray | NDFramer-rrznpt.NDArray[np.float64])@ __future__rrZ functoolsrtypingrrnumpyr'pandas._libs.tslibsr pandas._libs.window.aggregations_libswindow aggregationsrpandas.util._decoratorsrpandas.core.dtypes.commonr r pandas.core.dtypes.dtypesr pandas.core.dtypes.genericr pandas.core.dtypes.missingr pandas.corerpandas.core.arrays.datetimelikerpandas.core.indexers.objectsrrrpandas.core.util.numba_rrpandas.core.window.commonrpandas.core.window.numba_rrpandas.core.window.onlinerrpandas.core.window.rollingrrpandas._typingrrrrrr pandas.core.genericr!r2rDrFrrsrhr3r1r$s#" )>>.60+9 ,  ,      B' '6''<  U  jU  !U  p  %68O!B^$;^r3