fume-manage-python.git

U  
¬ý°dUWã@sdZddlmZddlmZmZmZddlZddl    m
Z
mZddlm Z ddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZdd    lmZdd
l m!Z!ddl"m#Z#m$Z$m%Z%m&Z&m'Z'ddl(m)Z)ddl*m+m,Z-d2dddddddddZ.d3ddddddZ/d4dddddddddZ0ddZ1d d!Z2d"d#Z3d5dddd$d%d&Z4d'd(Z5dd)d*d+Z6dd,d-d.Z7ddd/d0d1Z8dS)6z,
Quantilization functions and related stuff
é)Úannotations)ÚAnyÚCallableÚLiteralN)Ú    TimedeltaÚ    Timestamp)Úinfer_dtype)ÚIntervalLeftRight) ÚDT64NS_DTYPEÚensure_platform_intÚ is_bool_dtypeÚis_categorical_dtypeÚis_datetime64_dtypeÚis_datetime64tz_dtypeÚis_datetime_or_timedelta_dtypeÚis_extension_array_dtypeÚ
is_integerÚis_list_likeÚis_numeric_dtypeÚ    is_scalarÚis_timedelta64_dtype)Ú    ABCSeries)Úisna)ÚCategoricalÚIndexÚ IntervalIndexÚto_datetimeÚto_timedelta)ÚnanopsTFéÚraiseÚboolÚintÚstr)ÚrightÚretbinsÚ    precisionÚinclude_lowestÚ
duplicatesÚorderedc    Cs|}    t|}t|\}}
t |¡sdt|r<|dkr<tdz
|j}Wn$tk
rjt |¡}|j}YnX|dkr|tdt     
|¡t     |¡f}dd|D\} }t | ¡s¶t |¡r¾td| |kr| | dkrÞdt | nd8} ||dkrúdt |nd7}tj| ||dd    d
}nJtj| ||dd    d
}|| d}|rR|d|8<n|d|7<nnt|tr|jrÒtdnPt|rtj|td }n
t |¡}t||
}t | d¡¡dk ¡rÒtdt|||||||
||d    \}}t||||
|    S)a*
    Bin values into discrete intervals.
 
    Use `cut` when you need to segment and sort data values into bins. This
    function is also useful for going from a continuous variable to a
    categorical variable. For example, `cut` could convert ages to groups of
    age ranges. Supports binning into an equal number of bins, or a
    pre-specified array of bins.
 
    Parameters
    ----------
    x : array-like
        The input array to be binned. Must be 1-dimensional.
    bins : int, sequence of scalars, or IntervalIndex
        The criteria to bin by.
 
        * int : Defines the number of equal-width bins in the range of `x`. The
          range of `x` is extended by .1% on each side to include the minimum
          and maximum values of `x`.
        * sequence of scalars : Defines the bin edges allowing for non-uniform
          width. No extension of the range of `x` is done.
        * IntervalIndex : Defines the exact bins to be used. Note that
          IntervalIndex for `bins` must be non-overlapping.
 
    right : bool, default True
        Indicates whether `bins` includes the rightmost edge or not. If
        ``right == True`` (the default), then the `bins` ``[1, 2, 3, 4]``
        indicate (1,2], (2,3], (3,4]. This argument is ignored when
        `bins` is an IntervalIndex.
    labels : array or False, default None
        Specifies the labels for the returned bins. Must be the same length as
        the resulting bins. If False, returns only integer indicators of the
        bins. This affects the type of the output container (see below).
        This argument is ignored when `bins` is an IntervalIndex. If True,
        raises an error. When `ordered=False`, labels must be provided.
    retbins : bool, default False
        Whether to return the bins or not. Useful when bins is provided
        as a scalar.
    precision : int, default 3
        The precision at which to store and display the bins labels.
    include_lowest : bool, default False
        Whether the first interval should be left-inclusive or not.
    duplicates : {default 'raise', 'drop'}, optional
        If bin edges are not unique, raise ValueError or drop non-uniques.
    ordered : bool, default True
        Whether the labels are ordered or not. Applies to returned types
        Categorical and Series (with Categorical dtype). If True,
        the resulting categorical will be ordered. If False, the resulting
        categorical will be unordered (labels must be provided).
 
        .. versionadded:: 1.1.0
 
    Returns
    -------
    out : Categorical, Series, or ndarray
        An array-like object representing the respective bin for each value
        of `x`. The type depends on the value of `labels`.
 
        * None (default) : returns a Series for Series `x` or a
          Categorical for all other inputs. The values stored within
          are Interval dtype.
 
        * sequence of scalars : returns a Series for Series `x` or a
          Categorical for all other inputs. The values stored within
          are whatever the type in the sequence is.
 
        * False : returns an ndarray of integers.
 
    bins : numpy.ndarray or IntervalIndex.
        The computed or specified bins. Only returned when `retbins=True`.
        For scalar or sequence `bins`, this is an ndarray with the computed
        bins. If set `duplicates=drop`, `bins` will drop non-unique bin. For
        an IntervalIndex `bins`, this is equal to `bins`.
 
    See Also
    --------
    qcut : Discretize variable into equal-sized buckets based on rank
        or based on sample quantiles.
    Categorical : Array type for storing data that come from a
        fixed set of values.
    Series : One-dimensional array with axis labels (including time series).
    IntervalIndex : Immutable Index implementing an ordered, sliceable set.
 
    Notes
    -----
    Any NA values will be NA in the result. Out of bounds values will be NA in
    the resulting Series or Categorical object.
 
    Reference :ref:`the user guide <reshaping.tile.cut>` for more examples.
 
    Examples
    --------
    Discretize into three equal-sized bins.
 
    >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3)
    ... # doctest: +ELLIPSIS
    [(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...
    Categories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ...
 
    >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3, retbins=True)
    ... # doctest: +ELLIPSIS
    ([(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...
    Categories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ...
    array([0.994, 3.   , 5.   , 7.   ]))
 
    Discovers the same bins, but assign them specific labels. Notice that
    the returned Categorical's categories are `labels` and is ordered.
 
    >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]),
    ...        3, labels=["bad", "medium", "good"])
    ['bad', 'good', 'medium', 'medium', 'good', 'bad']
    Categories (3, object): ['bad' < 'medium' < 'good']
 
    ``ordered=False`` will result in unordered categories when labels are passed.
    This parameter can be used to allow non-unique labels:
 
    >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3,
    ...        labels=["B", "A", "B"], ordered=False)
    ['B', 'B', 'A', 'A', 'B', 'B']
    Categories (2, object): ['A', 'B']
 
    ``labels=False`` implies you just want the bins back.
 
    >>> pd.cut([0, 1, 1, 2], bins=4, labels=False)
    array([0, 1, 1, 3])
 
    Passing a Series as an input returns a Series with categorical dtype:
 
    >>> s = pd.Series(np.array([2, 4, 6, 8, 10]),
    ...               index=['a', 'b', 'c', 'd', 'e'])
    >>> pd.cut(s, 3)
    ... # doctest: +ELLIPSIS
    a    (1.992, 4.667]
    b    (1.992, 4.667]
    c    (4.667, 7.333]
    d     (7.333, 10.0]
    e     (7.333, 10.0]
    dtype: category
    Categories (3, interval[float64, right]): [(1.992, 4.667] < (4.667, ...
 
    Passing a Series as an input returns a Series with mapping value.
    It is used to map numerically to intervals based on bins.
 
    >>> s = pd.Series(np.array([2, 4, 6, 8, 10]),
    ...               index=['a', 'b', 'c', 'd', 'e'])
    >>> pd.cut(s, [0, 2, 4, 6, 8, 10], labels=False, retbins=True, right=False)
    ... # doctest: +ELLIPSIS
    (a    1.0
     b    2.0
     c    3.0
     d    4.0
     e    NaN
     dtype: float64,
     array([ 0,  2,  4,  6,  8, 10]))
 
    Use `drop` optional when bins is not unique
 
    >>> pd.cut(s, [0, 2, 4, 6, 10, 10], labels=False, retbins=True,
    ...        right=False, duplicates='drop')
    ... # doctest: +ELLIPSIS
    (a    1.0
     b    2.0
     c    3.0
     d    3.0
     e    NaN
     dtype: float64,
     array([ 0,  2,  4,  6, 10]))
 
    Passing an IntervalIndex for `bins` results in those categories exactly.
    Notice that values not covered by the IntervalIndex are set to NaN. 0
    is to the left of the first bin (which is closed on the right), and 1.5
    falls between two bins.
 
    >>> bins = pd.IntervalIndex.from_tuples([(0, 1), (2, 3), (4, 5)])
    >>> pd.cut([0, 0.5, 1.5, 2.5, 4.5], bins)
    [NaN, (0.0, 1.0], NaN, (2.0, 3.0], (4.0, 5.0]]
    Categories (3, interval[int64, right]): [(0, 1] < (2, 3] < (4, 5]]
    éz$`bins` should be a positive integer.rzCannot cut empty arraycss|]}|dVqdS)gN©)Ú.0Úmir+r+úOd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/reshape/tile.pyÚ    <genexpr>szcut.<locals>.<genexpr>z?cannot specify integer `bins` when input data contains infinitygü©ñÒMbP?T)Zendpointéÿÿÿÿz*Overlapping IntervalIndex is not accepted.©ÚdtypeÚfloat64z!bins must increase monotonically.)r$Úlabelsr&r'r2r(r))Ú_preprocess_for_cutÚ_coerce_to_typeÚnpÚiterablerÚ
ValueErrorÚsizeÚAttributeErrorÚasarrayrZnanminZnanmaxÚisinfÚabsÚlinspaceÚ
isinstancerZis_overlappingrr
Ú_convert_bin_to_numeric_typeZdiffÚastypeÚanyÚ _bins_to_cutsÚ_postprocess_for_cut)ÚxÚbinsr$r4r%r&r'r(r)Úoriginalr2ÚszÚrngÚmnZmxZadjÚfacr+r+r.Úcut2sd@
 
ÿ
 
 
 
 
÷
rM)r%r&r(c    Cs|}t|}t|\}}t|r2t dd|d¡n|}t |¡}    |    t |    ¡}    t |    |¡}
t||
||d||d\}}
t    ||
|||S)a!
    Quantile-based discretization function.
 
    Discretize variable into equal-sized buckets based on rank or based
    on sample quantiles. For example 1000 values for 10 quantiles would
    produce a Categorical object indicating quantile membership for each data point.
 
    Parameters
    ----------
    x : 1d ndarray or Series
    q : int or list-like of float
        Number of quantiles. 10 for deciles, 4 for quartiles, etc. Alternately
        array of quantiles, e.g. [0, .25, .5, .75, 1.] for quartiles.
    labels : array or False, default None
        Used as labels for the resulting bins. Must be of the same length as
        the resulting bins. If False, return only integer indicators of the
        bins. If True, raises an error.
    retbins : bool, optional
        Whether to return the (bins, labels) or not. Can be useful if bins
        is given as a scalar.
    precision : int, optional
        The precision at which to store and display the bins labels.
    duplicates : {default 'raise', 'drop'}, optional
        If bin edges are not unique, raise ValueError or drop non-uniques.
 
    Returns
    -------
    out : Categorical or Series or array of integers if labels is False
        The return type (Categorical or Series) depends on the input: a Series
        of type category if input is a Series else Categorical. Bins are
        represented as categories when categorical data is returned.
    bins : ndarray of floats
        Returned only if `retbins` is True.
 
    Notes
    -----
    Out of bounds values will be NA in the resulting Categorical object
 
    Examples
    --------
    >>> pd.qcut(range(5), 4)
    ... # doctest: +ELLIPSIS
    [(-0.001, 1.0], (-0.001, 1.0], (1.0, 2.0], (2.0, 3.0], (3.0, 4.0]]
    Categories (4, interval[float64, right]): [(-0.001, 1.0] < (1.0, 2.0] ...
 
    >>> pd.qcut(range(5), 3, labels=["good", "medium", "bad"])
    ... # doctest: +SKIP
    [good, good, medium, bad, bad]
    Categories (3, object): [good < medium < bad]
 
    >>> pd.qcut(range(5), 4, labels=False)
    array([0, 0, 1, 2, 3])
    rr*T)r4r&r'r2r()
r5r6rr7r?r<ÚisnanZquantilerDrE)rFÚqr4r%r&r(rHr2Z    quantilesZx_nprGrLr+r+r.Úqcut4s"=
ù
 
rPz
np.ndarray)rGr$r&r'r(r)c    Csþ|s|dkrtd|dkr$tdt|trP| |¡}    tj|    |dd}
|
|fSt |¡}t|t|krt|dkr|dkrtdt    |d    |}|rd
nd}t
|j||d}    |rÎd |    t  |¡|dk<t||    t|kB|    dkB} |  ¡}|dk    rÌ|dkst|std|dkr6t|||||d}nD|r\tt|t|kr\tdnt|t|d krztdt|s¬t|tt|t|kr¢|nd|d}t |    | d¡t ||    d ¡}
n*|    d }
|rö|
 tj¡}
t |
| tj¡|
|fS)Nz.'labels' must be provided if 'ordered = False')r ZdropzHinvalid value for 'duplicates' parameter, valid options are: raise, dropT)Ú
categoriesr)ér zBin edges must be unique: z@.
You can drop duplicate edges by setting the 'duplicates' kwargÚleftr$)Úsider*rFzJBin labels must either be False, None or passed in as a list-like argument)r$r'r2zNlabels must be unique if ordered=True; pass ordered=False for duplicate labelsz9Bin labels must be one fewer than the number of bin edges)r9r@rZget_indexerrZ
from_codesÚalgosÚuniqueÚlenÚreprrZsearchsortedr7r<rrCrÚ_format_labelsÚsetr ZputmaskZtake_ndrBr3Únan)rFrGr$r4r&r'r2r(r)ÚidsÚresultZunique_binsrTZna_maskZhas_nasr+r+r.rDsrÿ
 
 
ÿ
ÿ
ÿÿÿ
ýrDcCsÆd}t|jr|j}nt|jr>t|jddd}t d¡}n\t|jr\t|}t d¡}n>t|jrt| tj    ¡}n&t
|jrt|jr|jtj tjd}|dk    r¾t | ¡| tj    ¡tj¡}||fS)z¥
    if the passed data is of datetime/timedelta, bool or nullable int type,
    this method converts it to numeric so that cut or qcut method can
    handle it
    Núdatetime64[ns]F©Úcopyztimedelta64[ns])r2Zna_value)rr2rrrBr7rrrÚint64rrZto_numpyr3r[ÚwhereZnotnaÚview)rFr2r+r+r.r6Ûs 
 
 
 
r6cCst|dd}t|r8|dkr.t| tj¡}qtdnLt|sHt|r|dkr|t    |}t|rn|j
ddd}| tj¡}ntd|S)    a
    if the passed bin is of datetime/timedelta type,
    this method converts it to integer
 
    Parameters
    ----------
    bins : list-like of bins
    dtype : dtype of data
 
    Raises
    ------
    ValueError if bins are not of a compat dtype to dtype
    F)Zskipna)Ú    timedeltaZtimedelta64z!bins must be of timedelta64 dtype)ÚdatetimeZ
datetime64r^r_z bins must be of datetime64 dtype)rrrrcr7rar9rrrrB)rGr2Z
bins_dtyper+r+r.rAüs
rAcCsFt|r&t| tj¡dd |j¡}nt|rBt| tj¡|d}|S)a/
    Convert bins to a DatetimeIndex or TimedeltaIndex if the original dtype is
    datelike
 
    Parameters
    ----------
    bins : list-like of bins
    dtype : dtype of data
 
    Returns
    -------
    bins : Array-like of bins, DatetimeIndex or TimedeltaIndex if dtype is
           datelike
    T)Úutcr1)    rrrBr7raZ
tz_convertÚtzrr)rGr2r+r+r.Ú_convert_bin_to_datelike_types
rh)r&r$r'cs°|rdnd}tr*fdddd}nNtr@tdd}n8trVtdd}n"t|fddfd    d}fd
d|D}|r¢|r¢||d|d<tj||d S)z%based on the dtype, return our labelsr$rScst|jdS)N)rg)rrg©rFr1r+r.Ú<lambda>=óz _format_labels.<locals>.<lambda>cSs|tdS©NZ1ns©rrir+r+r.rj>rkcSs|tdSrlrmrir+r+r.rjArkcSs|tdSrlrmrir+r+r.rjDrkcs
t|S)N©Ú_round_fracri©r&r+r.rjGrkcs|dS)Né
r+rirpr+r.rjHrkcsg|]}|qSr+r+©r,Úb)Ú    formatterr+r.Ú
<listcomp>Jsz"_format_labels.<locals>.<listcomp>r)Úclosed)rrrrrÚ_infer_precisionrZfrom_breaks)rGr&r$r'r2rvÚadjustZbreaksr+)r2rtr&r.rY4s"
 
 
 
rYcCs4t|dd}|dkrt |¡}|jdkr0td|S)z
    handles preprocessing for cut where we convert passed
    input to array, strip the index information and store it
    separately
    ÚndimNr*z!Input array must be 1 dimensional)Úgetattrr7r<ryr9)rFryr+r+r.r5Rs
 
r5)r%cCs8t|tr|j||j|jd}|s&|St||}||fS)z
    handles post processing for the cut method where
    we combine the index information if the originally passed
    datatype was a series
    )ÚindexÚname)r@rZ_constructorr{r|rh)rLrGr%r2rHr+r+r.rEcs
 
rErpcCsdt |¡r|dkr|St |¡\}}|dkrPtt t t|¡¡d|}n|}t ||¡SdS)z7
    Round the fractional part of the given number
    rr*N)r7ÚisfiniteÚmodfr"ÚfloorÚlog10r>Zaround)rFr&ÚfracZwholeÚdigitsr+r+r.rots$ro)Úbase_precisionÚreturncs@t|dD]0fdd|D}t |¡j|jkr
Sq
|S)z8
    Infer an appropriate precision for _round_frac
    écsg|]}t|qSr+rnrrrpr+r.rusz$_infer_precision.<locals>.<listcomp>)ÚrangerUrVr:)rrGÚlevelsr+rpr.rws
 
rw)TNFrFr T)NFrr )TNrFNr T)TFN)9Ú__doc__Ú
__future__rÚtypingrrrÚnumpyr7Zpandas._libsrrZpandas._libs.librZpandas._typingr    Zpandas.core.dtypes.commonr
rrr rrrrrrrrrZpandas.core.dtypes.genericrZpandas.core.dtypes.missingrZpandasrrrrrZpandas.corerZpandas.core.algorithmsÚcoreZ
algorithmsrUrMrPrDr6rArhrYr5rErorwr+r+r+r.Ú<module>s\<÷úW÷S!"ÿ