d8yPdZddlmZddlmZmZddlmZmZm Z ddl Z ddl m Z mZmZddlmZmZmZmZmZddlmZdd lmZdd lmZmZmZmZdd lm Z m!Z!m"Z"erdd l#m$Z$d`dZ%dadZ&dbdcdZ'gdZ(gdZ)ddd!Z*ded%Z+ dfdgd5Z, dhdid7Z-djd8Z. dkdld=Z/ dmdnd>Z0 dodpdBZ1dqdrdCZ2 dsdtdGZ3dudIZ4 dvdwdKZ5 dxdydMZ6dzdPZ7e7 d{d|dRZ8e7 d{d|dSZ9e7d{d}dTZ:e7d{d~dUZ;e8e9dVZdd\Z?dd_Z@dS)z$ Routines for filling missing data. ) annotations)partialwraps) TYPE_CHECKINGAnycastN)NaTalgoslib) ArrayLikeAxisAxisIntFnpt)import_optional_dependency)infer_dtype_from) is_array_likeis_numeric_v_string_likeis_object_dtypeneeds_i8_conversion)is_valid_na_for_dtypeisnana_value_for_dtype)Indexmasknpt.NDArray[np.bool_]lengthintct|r=t||kr"tdt|d|||}|S)zJ Validate the size of the values passed to ExtensionArray.fillna. z'Length of 'value' does not match. Got (z ) expected )rlen ValueError)valuerrs O/var/www/html/t/fyr/venv311/lib/python3.11/site-packages/pandas/core/missing.pycheck_value_sizer$1skU u::  &#e**&&#&& d  Larrr returnctt|\}}tj||}d}t|rd}t |}t |}||}tj|jt}|D]}t||r|r5tj|jtj } |||k| |<n<||k} t| tj s| td} || z}| r|t |z}|S)a  Return a masking array of same size/shape as arr with entries equaling any member of values_to_mask set to True Parameters ---------- arr : ArrayLike values_to_mask: list, tuple, or scalar Returns ------- np.ndarray[bool] )dtypeFT)r)na_value)rnparrayrrzerosshapeboolrbool_ isinstancendarrayto_numpyany) r&values_to_maskr) potential_naarr_maskna_masknonnarxnew_masks r# mask_missingr<@sF"-^<<E> XnE:::NLs II:>""G G8 $E 8CIT * * *D  #C + +   M8CIRX>>>%(]a%7""!8!(BJ77M'00te0LLH H DD{{}} S  Kr%Fmethod str | None allow_nearestr/c|dvrdSt|tr%|}|dkrd}n|dkrd}ddg}d}|r|dd}||vrt d |d ||S) N)Nasfreqffillpadbfillbackfillzpad (ffill) or backfill (bfill)nearestz(pad (ffill), backfill (bfill) or nearestzInvalid fill method. Expecting z. Got )r1strlowerappendr!)r=r? valid_methods expectings r#clean_fill_methodrLys !!!t&#  W  FF w  FJ'M1I?Y'''>  ]""T9TTFTTUUU Mr%)lineartimeindexvalues)rFzeroslinear quadraticcubic barycentrickroghspline polynomialfrom_derivativespiecewise_polynomialpchipakima cubicsplinerGrOrc |d}|dvr|tdttz}||vrtd|d|d|dvr|jst|d|S) Norder)rWrXz7You must specify the order of the spline or polynomial.zmethod must be one of z. Got 'z ' instead.)rVrZr[z4 interpolation requires that the index be monotonic.)getr! NP_METHODS SP_METHODSis_monotonic_increasing)r=rOkwargsr_valids r#clean_interp_methodrfs JJw  E )))emRSSS  #E UR%RRRRRSSS ;;;, OOO  Mr%howis_valid int | NonecH|dvsJt|dkrdS|jdkr|d}|dkr|dd}n6|dkr0t|dz |ddd z }||}|sdS|S) aG Retrieves the index of the first valid value. Parameters ---------- values : ndarray or ExtensionArray how : {'first', 'last'} Use this parameter to change between the first or last valid index. is_valid: np.ndarray Mask to find na_values. Returns ------- int or None )firstlastrNaxisrkrl)r ndimr4argmax)rPrgrhidxpos chk_notnas r#find_valid_indexrvs$ # # # # # 6{{at {a<#8#8#:#:: I t Mr%rCforwarddata np.ndarrayrpr Index | Nonelimitlimit_direction limit_area fill_value Any | NonecoercedowncastNonec  t|} n#t$rd} YnwxYw| '|tdt|| |||dS|Jtd||||||||d| dS)z Wrapper to dispatch to either interpolate_2d or _interpolate_2d_with_fill. Notes ----- Alters 'data' in-place. Nz&Cannot pass both fill_value and method)r=rpr{r})rxrOrpr=r{r|r}r~)rLr!interpolate_2d_interpolate_2d_with_fill) rxr=rprOr{r|r}r~rrrdms r#interpolate_array_2drs( f % %   }  !EFF F !          ! +!!  s  !!rMc 8 t|fit|jrt|jddkr%t |jst ddgd} | vrt d| dd 2d d g} | vrt d | ddtjd t| d fd } tj | ||d S)z Column-wise application of _interpolate_1d. Notes ----- Alters 'data' in-place. The signature does differ from _interpolate_1d because it only includes what is needed for Block.interpolate. F)compatrNzStime-weighted interpolation only works on Series or DataFrames with a DatetimeIndexrP)rwbackwardbothz*Invalid limit_direction: expecting one of z, got 'z'.Ninsideoutsidez%Invalid limit_area: expecting one of z, got .)nobsr{yvaluesryr'rc 2td|dddS)NF)indicesrr=r{r|r}r~ bounds_errorr)_interpolate_1d)rr~rrdr{r}r|r=s r#funcz'_interpolate_2d_with_fill..funcRsM  +!!  r%)rryr'r) rfrr)rrr!rHr validate_limit_index_to_interp_indicesr+apply_along_axis) rxrOrpr=r{r|r}r~rdvalid_limit_directionsvalid_limit_areasrrs `````` @r#rrs,00000Z44B' 5AAA  "5;//    <<<%++--O444 B% B B.= B B B   %y1%%'' . . .!8I!!!!!   d% 8 8 8E&uf55G             *dD)))))r%c.|j}t|jr|d}|dkr|}t t j|}nAt j|}|dvr)|jt jkrtj |}|S)zE Convert Index to ndarray of indices to pass to NumPy/SciPy. i8rM)rPrO) _valuesrr)viewrr+r2asarrayobject_r maybe_convert_objects)rOr=xarrindss r#rrjs =D4:&&yy BJ%%z$ ( ( (zRZ''066 Kr%rrrr_c  t|} | } | sdS| rdStt j| } t |d| } | d} tt| }t |d| }|t|}ttd|zt| }|dkr"|tt| |dz}nF|dkr"|tt| d|z}ntt| ||}|d kr |||zz}n|d kr | |z |z }||z}t|}t|j }|r| d }|tvrRt j|| }t j|| || ||| ||| <n)t#|| || || f||||d | || <|rt$j||<ntj||<dS) a Logic for the 1-d interpolation. The input indices and yvalues will each be 1-d arrays of the same length. Bounds_error is currently hardcoded to False since non-scipy ones don't take it as an argument. Notes ----- Fills 'yvalues' in-place. Nrkrgrhrrlrnrwrrrr)r=r~rr_)rr4allsetr+ flatnonzerorvranger _interp_limitsortedrr)rraargsortinterp_interpolate_scipy_wrapperr r"nan)rrr=r{r|r}r~rr_rdinvalidreall_nansfirst_valid_index start_nanslast_valid_indexend_nans preserve_nansmid_nansis_datetimelikeindexers r#rrs07mmG HE 99;; yy{{2>'**++H(gNNN U,--..J'VeLLLw<<5--s5zz::;;H)##"Swq)I)I%J%JJ J & & 3}Wa'G'G#H#HH M'5%@@AA Xh.. y j(83! =))M)'-88O%,,t$$ *WU^,,9 G genW5wu~g7N  6 EN EN G   !%      (!$ !#  Fr%c f|d}td|ddlm} tj|}| j| jttd} t|ddr/|j d | d }}|d kr | j | d <n!|d kr t| d <n|d kr t| d <gd } || vr.|dkr|}| |||||} | |} n|dkrDt|s|dkrt!d|| j||fd|i|} | |} ns|jjs|}|jjs|}|jjs|}| |}||||fi|} | S)z Passed off to scipy.interpolate.interp1d. method is scipy's kind. Returns an array interpolated at new_x. Add any new methods to the list in _clean_interp_method. z interpolation requires SciPy.scipy)extrar interpolate)rUrVrYrZ _is_all_datesFrr[r\r])rFrQrRrSrTrXrX)kindr~rrWz;order needs to be specified and greater than 0; got order: k)rrrr+rbarycentric_interpolatekrogh_interpolate_from_derivativesgetattrrastypepchip_interpolate_akima_interpolate_cubicspline_interpolateinterp1drr!UnivariateSplineflags writeablecopy)r:ynew_xr=r~rr_rdrr alt_methodsinterp1d_methodsterpnew_ys r#rrs9 5 5 5Ewe4444!!!!!! Ju  E#:.- 1 Kq/5))>9##D))5<<+=+=5 *< G 7  1 G = %= M"!!! \ ! !F## qv*<$  U  8   ;; 5A::UeUU ,{+AqDDEDVDDU w  Aw  A{$ !JJLLEV$q!U--f-- Lr%derint | list[int] | None extrapolatecddlm}|jj}|||dd||}||S)a Convenience function for interpolate.BPoly.from_derivatives. Construct a piecewise polynomial in the Bernstein basis, compatible with the specified values and derivatives at breakpoints. Parameters ---------- xi : array-like sorted 1D array of x-coordinates yi : array-like or list of array-likes yi[i][j] is the j-th derivative known at xi[i] order: None or int or array-like of ints. Default: None. Specifies the degree of local polynomials. If not None, some derivatives are ignored. der : int or list How many derivatives to extract; None for all potentially nonzero derivatives (that is a number equal to the number of points), or a list of derivatives to extract. This number includes the function value as 0th derivative. extrapolate : bool, optional Whether to extrapolate to ouf-of-bounds points based on first and last intervals, or to return NaNs. Default: True. See Also -------- scipy.interpolate.BPoly.from_derivatives Returns ------- y : scalar or array-like The result, of length R or length M or M by R. rrrqrn)ordersr)rrBPolyrYreshape) xiyir:r_rrrr=rs r#rr9sWH"!!!!!  /Fr2::b!$$U LLLA 1Q44Kr%cXddlm}||||}|||S)a[ Convenience function for akima interpolation. xi and yi are arrays of values used to approximate some function f, with ``yi = f(xi)``. See `Akima1DInterpolator` for details. Parameters ---------- xi : array-like A sorted list of x-coordinates, of length N. yi : array-like A 1-D array of real values. `yi`'s length along the interpolation axis must be equal to the length of `xi`. If N-D array, use axis parameter to select correct axis. x : scalar or array-like Of length M. der : int, optional How many derivatives to extract; None for all potentially nonzero derivatives (that is a number equal to the number of points), or a list of derivatives to extract. This number includes the function value as 0th derivative. axis : int, optional Axis in the yi array corresponding to the x-coordinate values. See Also -------- scipy.interpolate.Akima1DInterpolator Returns ------- y : scalar or array-like The result, of length R or length M or M by R, rrro)nu)rrAkima1DInterpolator)rrr:rrprPs r#rrfsCH"!!!!!''BT'::A 1Q3<<<r% not-a-knotbc_typestr | tuple[Any, Any]cXddlm}||||||}||S)aq Convenience function for cubic spline data interpolator. See `scipy.interpolate.CubicSpline` for details. Parameters ---------- xi : array-like, shape (n,) 1-d array containing values of the independent variable. Values must be real, finite and in strictly increasing order. yi : array-like Array containing values of the dependent variable. It can have arbitrary number of dimensions, but the length along ``axis`` (see below) must match the length of ``x``. Values must be finite. x : scalar or array-like, shape (m,) axis : int, optional Axis along which `y` is assumed to be varying. Meaning that for ``x[i]`` the corresponding values are ``np.take(y, i, axis=axis)``. Default is 0. bc_type : string or 2-tuple, optional Boundary condition type. Two additional equations, given by the boundary conditions, are required to determine all coefficients of polynomials on each segment [2]_. If `bc_type` is a string, then the specified condition will be applied at both ends of a spline. Available conditions are: * 'not-a-knot' (default): The first and second segment at a curve end are the same polynomial. It is a good default when there is no information on boundary conditions. * 'periodic': The interpolated functions is assumed to be periodic of period ``x[-1] - x[0]``. The first and last value of `y` must be identical: ``y[0] == y[-1]``. This boundary condition will result in ``y'[0] == y'[-1]`` and ``y''[0] == y''[-1]``. * 'clamped': The first derivative at curves ends are zero. Assuming a 1D `y`, ``bc_type=((1, 0.0), (1, 0.0))`` is the same condition. * 'natural': The second derivative at curve ends are zero. Assuming a 1D `y`, ``bc_type=((2, 0.0), (2, 0.0))`` is the same condition. If `bc_type` is a 2-tuple, the first and the second value will be applied at the curve start and end respectively. The tuple values can be one of the previously mentioned strings (except 'periodic') or a tuple `(order, deriv_values)` allowing to specify arbitrary derivatives at curve ends: * `order`: the derivative order, 1 or 2. * `deriv_value`: array-like containing derivative values, shape must be the same as `y`, excluding ``axis`` dimension. For example, if `y` is 1D, then `deriv_value` must be a scalar. If `y` is 3D with the shape (n0, n1, n2) and axis=2, then `deriv_value` must be 2D and have the shape (n0, n1). extrapolate : {bool, 'periodic', None}, optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. If None (default), ``extrapolate`` is set to 'periodic' for ``bc_type='periodic'`` and to True otherwise. See Also -------- scipy.interpolate.CubicHermiteSpline Returns ------- y : scalar or array-like The result, of shape (m,) References ---------- .. [1] `Cubic Spline Interpolation `_ on Wikiversity. .. [2] Carl de Boor, "A Practical Guide to Splines", Springer-Verlag, 1978. rr)rprr)rr CubicSpline)rrr:rprrrrs r#rrsKZ"!!!!! BT7    A 1Q44Kr%rPcZt|}|}|st|d|}|d}t|d|}|t|}t ||||dkr d|||d z<n|d krdx|d|<||d zd<t j||<dSdS) a Apply interpolation and limit_area logic to values along a to-be-specified axis. Parameters ---------- values: np.ndarray Input array. method: str Interpolation method. Could be "bfill" or "pad" limit: int, optional Index limit on interpolation. limit_area: str Limit area for interpolation. Can be "inside" or "outside" Notes ----- Modifies values in-place. rkrNrrl)r=r{rFrnr)rrrvr rr+r)rPr=r{r}rrhrkrls r#_interpolate_with_limit_arears,6llGxH ;;==! WxHHH =EFXFFF <v;;D      ! !(-GED1H$ % % 9 $ $49 9GFUFOgdQhjj1&w'!!r%r c|.tjtt|||||dS|dkrdnd}|jdkr?|dkrt d|td|jz}t|}||}|d krt|| nt|| dS) a Perform an actual interpolation of values, values will be make 2-d if needed fills inplace, returns the result. Parameters ---------- values: np.ndarray Input array. method: str, default "pad" Interpolation method. Could be "bfill" or "pad" axis: 0 or 1 Interpolation axis limit: int, optional Index limit on interpolation. limit_area: str, optional Limit area for interpolation. Can be "inside" or "outside" Notes ----- Modifies values in-place. N)r=r{r}rc|SNrr:s r#z interpolate_2d..Isr%c|jSr)Trs r#rz interpolate_2d..Isr%rnz0cannot interpolate on a ndim == 1 with axis != 0rnrCr{) r+rrrrrAssertionErrorrtupler.rL_pad_2d _backfill_2d)rPr=rpr{r}transftvaluess r#rrs8  ,%      %   ( "aiikkkmmF{a 199 !STT TdV\&9 : :;; v & &FfVnnGu%%%%%WE**** Fr%npt.NDArray[np.bool_] | Nonecf|t|}|tj}|Sr)rrr+uint8)rPrs r# _fillna_prepr]s,  |F|| 99RX  D Kr%rrcdtdfd }tt|S)z> Wrapper to handle datetime64 and timedelta64 dtypes. Nct|jrQ|t|}|d||\}}||j|fS|||S)Nr)r{r)rr)rr)rPr{rresultrs r#new_funcz&_datetimelike_compat..new_funcns{ v| , , 3|F||4 D 1 1TJJJLFD;;v|,,d2 2tF%d3333r%NN)rrr)rrs` r#_datetimelike_compatrisE  4[[ 4 4 4 4 4[ 4 8  r%(tuple[np.ndarray, npt.NDArray[np.bool_]]cXt||}tj|||||fSNr)rr pad_inplacerPr{rs r#_pad_1dr}s5  % %D fd%0000 4<r%cXt||}tj|||||fSr)rr backfill_inplacers r# _backfill_1dr s5  % %D 64u5555 4<r%ct||}tj|jrt j|||n ||fSr)rr+rr.r pad_2d_inplacers r#rrsO  % %D vfl  VT77777 4<r%ct||}tj|jrt j|||n ||fSr)rr+rr.r backfill_2d_inplacers r#rrsO  % %D vfl  !&$e<<<<< 4<r%rCrErnrrcpt|}|dkr t|Sttd|S)Nrnr)rL _fill_methodsrr)r=rrs r# get_fill_funcrs6 v & &F qyyV$$ 5 5f ==r%c$t|dS)NT)r?)rL)r=s r#clean_reindex_fill_methodrs V4 8 8 88r%rct|t}t}fd}|:|dkr(ttj|d}n |||}|Y|dkr|St ||ddd|}tdz tj|z }|dkr|S||zS)ak Get indexers of values that won't be filled because they exceed the limits. Parameters ---------- invalid : np.ndarray[bool] fw_limit : int or None forward limit to index bw_limit : int or None backward limit to index Returns ------- set of indexers Notes ----- This is equivalent to the more readable, but slower .. code-block:: python def _interp_limit(invalid, fw_limit, bw_limit): for x in np.where(invalid)[0]: if invalid[max(0, x - fw_limit):x + bw_limit + 1].all(): yield x c \t|}t||dzd}tt j|d|ztt j|d|dzdkdz}|S)Nrnr)min_rolling_windowrrr+wherecumsum)rr{windowedidxNs r#innerz_interp_limit..innersE1 "7EAI66::1=="(8$$Q'%/003 Hw{{++3355: ; ;A >4 4   r%Nrrqrn)r rr+rlistr)rfw_limitbw_limitf_idxb_idxr b_idx_invrs @r#rrs> G A EEE EEE q==))!,--EEE'8,,E q==LUU744R4=(;;< [ [True, True], [True, False], [False, True], [True, False], ] Nrqrn)r.strides)r.r)r+r stride_tricks as_strided)r&r'r.r)s r#rrsb GCRCLAGBK&014f= =Ei19R=**G 6  * *1E7 * K KKr%)rrrr)r&r r'r)F)r=r>r?r/)r=rGrOrr'rG)rgrGrhrr'ri) rCrNNrwNNFN)rxryr=rGrprrOrzr{rir|rGr}r>r~rrr/rr>r'r)rMNrwNN)rxryrOrrprr=rGr{rir|rGr}r>r~rr'r)rOrr=rGr'ry)rMNrwNNFN)rryrryr=r>r{rir|rGr}r>r~rrr/r_rir'r)NFN)rr/)NrF)rrrr/)rr)rrrpr)rrN)rprrr) rPryr=rGr{rir}r>r'r)rCrNN) rPryr=rGrpr r{rir}r>r'rr)rrr'r)rrr'rr)rPryr{rirrr'r)rPryrr)rrr)rrr)r'r>)rr)r&rr'rr'r)A__doc__ __future__r functoolsrrtypingrrrnumpyr+ pandas._libsr r r pandas._typingr r rrrpandas.compat._optionalrpandas.core.dtypes.castrpandas.core.dtypes.commonrrrrpandas.core.dtypes.missingrrrpandasrr$r<rLrarbrfrvrrrrrrrrrrrrrr rrrrrrrrr%r#r8s #"""""  ?>>>>>444444      6666r03 2 2  $&&&&&V$!!2 2 2 2 2 r$!!O*O*O*O*O*d2"$!!i i i i i b JJJJJ\QV*****Z(((((^%1 SSSSSl,!,!,!,!b! D D D D D P26     ()-)- \:: >>>>>9999<<<<~LLLLLLr%