HOME


sh-3ll 1.0
DIR:/usr/local/lib64/python3.6/site-packages/pandas/core/groupby/__pycache__/
Upload File :
Current File : //usr/local/lib64/python3.6/site-packages/pandas/core/groupby/__pycache__/groupby.cpython-36.pyc
3

���h�i�@s�dZddlmZddlZddlmZmZddlZddlZddl	Z	ddl
mZmZm
Z
mZmZmZmZmZmZmZmZmZmZmZddlZddlmZddlmZddlj j!Z"ddl#m$Z$m%Z%m&Z&m'Z'dd	l(m)Z*dd
l+m,Z,ddl-m.Z.m/Z/m0Z0m1Z1ddl2m3Z3dd
l4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<ddl=m>Z>m?Z?ddl@mAZAddlBjCjDZDddlEmFZFmGZGddlHmIZImJZJmKZKddlLjCjMZNddlOmPZPddlQmRZRddlSmTZTmUZUddlVmWZWmXZXmYZYddlZm[Z[ddl\m]Z]ddl^m_Z_dZ`eadddd�ZbdZcdZdd Zed!ZfGd"d#�d#eJ�Zged$d%��ZheeeeeegefeeegefeeeffZiGd&d'�d'eJeKee%�Zjed(eRd)�ZkGd*d+�d+eje%�Zle1el�d2eReeiemd.eneneneneneneneld/�d0d1��ZodS)3a
Provide the groupby split-apply-combine paradigm. Define the GroupBy
class providing the base-class of operations.

The SeriesGroupBy and DataFrameGroupBy sub-class
(defined in pandas.core.groupby.generic)
expose these user-facing objects to provide specific functionality.
�)�contextmanagerN)�partial�wraps)�Callable�Dict�	FrozenSet�Generic�Hashable�Iterable�List�Mapping�Optional�Sequence�Tuple�Type�TypeVar�Union)�option_context)�	Timestamp)�F�
FrameOrSeries�FrameOrSeriesUnion�Scalar)�function)�AbstractMethodError)�Appender�Substitution�cache_readonly�doc)�maybe_cast_result)�ensure_float�
is_bool_dtype�is_datetime64_dtype�is_extension_array_dtype�is_integer_dtype�is_numeric_dtype�is_object_dtype�	is_scalar)�isna�notna)�nanops)�Categorical�
DatetimeArray)�	DataError�PandasObject�SelectionMixin)�	DataFrame)�NDFrame)�base�ops)�CategoricalIndex�Index�
MultiIndex)�Series)�get_group_index_sorter)�maybe_use_numbazV
        See Also
        --------
        Series.%(name)s
        DataFrame.%(name)s
a�
    Apply function `func` group-wise and combine the results together.

    The function passed to `apply` must take a {input} as its first
    argument and return a DataFrame, Series or scalar. `apply` will
    then take care of combining the results back together into a single
    dataframe or series. `apply` is therefore a highly flexible
    grouping method.

    While `apply` is a very flexible method, its downside is that
    using it can be quite a bit slower than using more specific methods
    like `agg` or `transform`. Pandas offers a wide range of method that will
    be much faster than using `apply` for their specific purposes, so try to
    use them before reaching for `apply`.

    Parameters
    ----------
    func : callable
        A callable that takes a {input} as its first argument, and
        returns a dataframe, a series or a scalar. In addition the
        callable may take positional and keyword arguments.
    args, kwargs : tuple and dict
        Optional positional and keyword arguments to pass to `func`.

    Returns
    -------
    applied : Series or DataFrame

    See Also
    --------
    pipe : Apply function to the full GroupBy object instead of to each
        group.
    aggregate : Apply aggregate function to the GroupBy object.
    transform : Apply function column-by-column to the GroupBy object.
    Series.apply : Apply a function to a Series.
    DataFrame.apply : Apply a function to each row or column of a DataFrame.
    a�
    >>> df = pd.DataFrame({'A': 'a a b'.split(),
                           'B': [1,2,3],
                           'C': [4,6, 5]})
    >>> g = df.groupby('A')

    Notice that ``g`` has two groups, ``a`` and ``b``.
    Calling `apply` in various ways, we can get different grouping results:

    Example 1: below the function passed to `apply` takes a DataFrame as
    its argument and returns a DataFrame. `apply` combines the result for
    each group together into a new DataFrame:

    >>> g[['B', 'C']].apply(lambda x: x / x.sum())
              B    C
    0  0.333333  0.4
    1  0.666667  0.6
    2  1.000000  1.0

    Example 2: The function passed to `apply` takes a DataFrame as
    its argument and returns a Series.  `apply` combines the result for
    each group together into a new DataFrame:

    >>> g[['B', 'C']].apply(lambda x: x.max() - x.min())
       B  C
    A
    a  1  2
    b  0  0

    Example 3: The function passed to `apply` takes a DataFrame as
    its argument and returns a scalar. `apply` combines the result for
    each group together into a Series, including setting the index as
    appropriate:

    >>> g.apply(lambda x: x.C.max() - x.B.min())
    A
    a    5
    b    2
    dtype: int64
    a�
    >>> s = pd.Series([0, 1, 2], index='a a b'.split())
    >>> g = s.groupby(s.index)

    From ``s`` above we can see that ``g`` has two groups, ``a`` and ``b``.
    Calling `apply` in various ways, we can get different grouping results:

    Example 1: The function passed to `apply` takes a Series as
    its argument and returns a Series.  `apply` combines the result for
    each group together into a new Series:

    >>> g.apply(lambda x:  x*2 if x.name == 'b' else x/2)
    0    0.0
    1    0.5
    2    4.0
    dtype: float64

    Example 2: The function passed to `apply` takes a Series as
    its argument and returns a scalar. `apply` combines the result for
    each group together into a Series, including setting the index as
    appropriate:

    >>> g.apply(lambda x: x.max() - x.min())
    a    1
    b    0
    dtype: int64

    Notes
    -----
    In the current implementation `apply` calls `func` twice on the
    first group to decide whether it can take a fast or slow code
    path. This can lead to unexpected behavior if `func` has
    side-effects, as they will take effect twice for the first
    group.

    Examples
    --------
    {examples}
    )�template�dataframe_examplesZseries_examplesa�
Compute {fname} of group values.

Parameters
----------
numeric_only : bool, default {no}
    Include only float, int, boolean columns. If None, will attempt to use
    everything, then use only numeric data.
min_count : int, default {mc}
    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 {fname} of values within each group.
as
Apply a function `func` with arguments to this %(klass)s object and return
the function's result.

%(versionadded)s

Use `.pipe` when you want to improve readability by chaining together
functions that expect Series, DataFrames, GroupBy or Resampler objects.
Instead of writing

>>> h(g(f(df.groupby('group')), arg1=a), arg2=b, arg3=c)  # doctest: +SKIP

You can write

>>> (df.groupby('group')
...    .pipe(f)
...    .pipe(g, arg1=a)
...    .pipe(h, arg2=b, arg3=c))  # doctest: +SKIP

which is much more readable.

Parameters
----------
func : callable or tuple of (callable, str)
    Function to apply to this %(klass)s object or, alternatively,
    a `(callable, data_keyword)` tuple where `data_keyword` is a
    string indicating the keyword of `callable` that expects the
    %(klass)s object.
args : iterable, optional
       Positional arguments passed into `func`.
kwargs : dict, optional
         A dictionary of keyword arguments passed into `func`.

Returns
-------
object : the return type of `func`.

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 %(klass)s object.

Notes
-----
See more `here
<https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html#piping-function-calls>`_

Examples
--------
%(examples)s
a�
Call function producing a like-indexed %(klass)s on each group and
return a %(klass)s having the same indexes as the original object
filled with the transformed values

Parameters
----------
f : function
    Function to apply to each group.

    Can also accept a Numba JIT function with
    ``engine='numba'`` specified.

    If the ``'numba'`` engine is chosen, the function must be
    a user defined function with ``values`` and ``index`` as the
    first and second arguments respectively in the function signature.
    Each group's index will be passed to the user defined function
    and optionally available for use.

    .. versionchanged:: 1.1.0
*args
    Positional arguments to pass to func
engine : str, default None
    * ``'cython'`` : Runs the function through C-extensions from cython.
    * ``'numba'`` : Runs the function through JIT compiled code from numba.
    * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba``

    .. versionadded:: 1.1.0
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}`` and will be
      applied to the function

    .. versionadded:: 1.1.0
**kwargs
    Keyword arguments to be passed into func.

Returns
-------
%(klass)s

See Also
--------
%(klass)s.groupby.apply
%(klass)s.groupby.aggregate
%(klass)s.transform

Notes
-----
Each group is endowed the attribute 'name' in case you need to know
which group you are working on.

The current implementation imposes three requirements on f:

* f must return a value that either has the same shape as the input
  subframe or can be broadcast to the shape of the input subframe.
  For example, if `f` returns a scalar it will be broadcast to have the
  same shape as the input subframe.
* if this is a DataFrame, f must support application column-by-column
  in the subframe. If f also supports application to the entire subframe,
  then a fast path is used starting from the second chunk.
* f must not mutate groups. Mutation is not supported and may
  produce unexpected results.

When using ``engine='numba'``, there will be no "fall back" behavior internally.
The group data and group index will be passed as numpy arrays to the JITed
user defined function, and no alternative execution attempts will be tried.

Examples
--------

>>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
...                           'foo', 'bar'],
...                    'B' : ['one', 'one', 'two', 'three',
...                           'two', 'two'],
...                    'C' : [1, 5, 5, 2, 5, 5],
...                    'D' : [2.0, 5., 8., 1., 2., 9.]})
>>> grouped = df.groupby('A')
>>> grouped.transform(lambda x: (x - x.mean()) / x.std())
          C         D
0 -1.154701 -0.577350
1  0.577350  0.000000
2  0.577350  1.154701
3 -1.154701 -1.000000
4  0.577350 -0.577350
5  0.577350  1.000000

Broadcast result of the transformation

>>> grouped.transform(lambda x: x.max() - x.min())
   C    D
0  4  6.0
1  3  8.0
2  4  6.0
3  3  8.0
4  4  6.0
5  3  8.0
aO
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 {klass} or when passed to {klass}.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.

    Can also accept a Numba JIT function with
    ``engine='numba'`` specified.

    If the ``'numba'`` engine is chosen, the function must be
    a user defined function with ``values`` and ``index`` as the
    first and second arguments respectively in the function signature.
    Each group's index will be passed to the user defined function
    and optionally available for use.

    .. versionchanged:: 1.1.0
*args
    Positional arguments to pass to func
engine : str, default None
    * ``'cython'`` : Runs the function through C-extensions from cython.
    * ``'numba'`` : Runs the function through JIT compiled code from numba.
    * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba``

    .. versionadded:: 1.1.0
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}}`` and will be
      applied to the function

    .. versionadded:: 1.1.0
**kwargs
    Keyword arguments to be passed into func.

Returns
-------
{klass}

See Also
--------
{klass}.groupby.apply
{klass}.groupby.transform
{klass}.aggregate

Notes
-----
When using ``engine='numba'``, there will be no "fall back" behavior internally.
The group data and group index will be passed as numpy arrays to the JITed
user defined function, and no alternative execution attempts will be tried.
{examples}
c@s.eZdZdZdd�Zdd�Zed�dd�Zd	S)
�GroupByPlotzE
    Class implementing the .plot attribute for groupby objects.
    cCs
||_dS)N)�_groupby)�self�groupby�r@�=/tmp/pip-build-5_djhm0z/pandas/pandas/core/groupby/groupby.py�__init__�szGroupByPlot.__init__cs ��fdd�}d|_|jj|�S)Ncs|j���S)N)�plot)r>)�args�kwargsr@rA�f�szGroupByPlot.__call__.<locals>.frC)�__name__r=�apply)r>rDrErFr@)rDrErA�__call__�szGroupByPlot.__call__)�namecs��fdd�}|S)Ncs���fdd�}�jj|�S)Ncst|j�����S)N)�getattrrC)r>)rDrErJr@rArF�sz0GroupByPlot.__getattr__.<locals>.attr.<locals>.f)r=rH)rDrErF)rJr>)rDrErA�attr�sz%GroupByPlot.__getattr__.<locals>.attrr@)r>rJrLr@)rJr>rA�__getattr__�szGroupByPlot.__getattr__N)rG�
__module__�__qualname__�__doc__rBrI�strrMr@r@r@rAr<�sr<ccs|j�|V|j�dS)z3
    Set / reset the _group_selection_context.
    N)�_set_group_selection�_reset_group_selection)r?r@r@rA�_group_selection_context�srTc
@s6eZdZUdZe�Zeedaee	e
edeeeeeeed�dd�Z
ed	�d
d�Zed	�dd
�Zdd�Zedd��Zedd��Zedd��Zdd�Zdd�Zedd��Zdd�Zdd�Zd d!�Zd"d#�Zed$�d%d&�Zed'd(d)d*�ee �d+d,���Z!ee"�Z#d-d.�Z$dbd/d0�Z%d1d2�Z&ee'd3j(d4e'd5d6��d7d8��Z)e*e+e+d9�d:d;�Z,e-e.d	�d<d=�Z/d>d?�Z0dced@�dAdB�Z1eedC�dDdE�Z2ddeedF�dGdH�Z3e4e5j6e7j8fe	e9dI�dJdK�Z:e4e5j6e7j8fdL�dMdN�Z;deedO�dPdQ�Z<dgeeee=dS�dTdU�Z>dieeedV�dWdX�Z?dYddZ�d[d\�Z@djedO�d]d^�ZAd_d`�ZBdS)k�_GroupByNrTFzOptional[ops.BaseGrouper])�obj�keys�axis�grouper�as_index�sort�
group_keys�squeeze�observed�mutated�dropnac
Cs�||_t|t�stt|���||_|sHt|t�s8td��|dkrHtd��||_	||_
|	|_|
|_||_
||_|
|_||_|dkr�ddlm}||||||	||j|jd�\}}}||_|j|�|_||_|r�t|�nt�|_dS)Nz(as_index=False only valid with DataFramerz$as_index=False only valid for axis=0)�get_grouper)rX�levelr[r^r_r`)�
_selection�
isinstancer1�AssertionError�typerbr0�	TypeError�
ValueErrorrZrWr[r\r]r^r_r`�pandas.core.groupby.grouperrarVZ_get_axis_numberrXrY�set�
exclusions)r>rVrWrXrbrYrk�	selectionrZr[r\r]r^r_r`rar@r@rArB�s>
z_GroupBy.__init__)�returncCs
t|j�S)N)�len�groups)r>r@r@rA�__len__sz_GroupBy.__len__cCs
tj|�S)N)�object�__repr__)r>r@r@rArr sz_GroupBy.__repr__cCsdS)zi
        We create the grouper on instantiation sub-classes may have a
        different policy.
        Nr@)r>r@r@rA�_assure_grouper$sz_GroupBy._assure_groupercCs|j�|jjS)z4
        Dict {group name -> group labels}.
        )rsrYro)r>r@r@rAro+sz_GroupBy.groupscCs|j�|jjS)N)rsrY�ngroups)r>r@r@rArt3sz_GroupBy.ngroupscCs|j�|jjS)z5
        Dict {group name -> group indices}.
        )rsrY�indices)r>r@r@rAru8sz_GroupBy.indicescsdd��t|�dkrgSt�j�dkr6tt�j��}nd}|d}t|t�r�t|t�sbd}t|��t|�t|�ks�y�fdd�|D�Stk
r�}zd}t|�|�WYdd}~XnX�fd	d�|D���fd
d�|D�}n�|���fdd�|D�}�fd
d�|D�S)zd
        Safe get multiple indices, translate keys for
        datelike to underlying repr.
        cSs4t|tj�rdd�St|tj�r(dd�Sdd�SdS)NcSst|�S)N)r)�keyr@r@rA�<lambda>Jsz>_GroupBy._get_indices.<locals>.get_converter.<locals>.<lambda>cSs
t|�jS)N)rZasm8)rvr@r@rArwLscSs|S)Nr@)rvr@r@rArwNs)rd�datetime�npZ
datetime64)�sr@r@rA�
get_converterFs
z,_GroupBy._get_indices.<locals>.get_converterrNz<must supply a tuple to get_group with multiple grouping keyscsg|]}�j|�qSr@)ru)�.0rJ)r>r@rA�
<listcomp>`sz)_GroupBy._get_indices.<locals>.<listcomp>zHmust supply a same-length tuple to get_group with multiple grouping keyscsg|]}�|��qSr@r@)r|rz)r{r@rAr}isc3s&|]}tdd�t�|�D��VqdS)css|]\}}||�VqdS)Nr@)r|rF�nr@r@rA�	<genexpr>jsz2_GroupBy._get_indices.<locals>.<genexpr>.<genexpr>N)�tuple�zip)r|rJ)�
convertersr@rArjsz(_GroupBy._get_indices.<locals>.<genexpr>c3s|]}�|�VqdS)Nr@)r|rJ)�	converterr@rArnscsg|]}�jj|g��qSr@)ru�get)r|rJ)r>r@rAr}ps)rnru�next�iterrdr�rh�KeyError)r>�namesZindex_sampleZname_sample�msg�errr@)r�r�r{r>rA�_get_indices@s,


z_GroupBy._get_indicescCs|j|g�dS)zQ
        Safe get index, translate keys for datelike to underlying repr.
        r)r�)r>rJr@r@rA�
_get_indexrsz_GroupBy._get_indexcCsB|jdkst|jt�r2|jdk	r,|j|jS|jS|j|jSdS)N)rcrdrVr7�_group_selection)r>r@r@rA�
_selected_objxs

z_GroupBy._selected_objcCs|jdk	rd|_|jd�dS)z�
        Clear group based selection.

        Used for methods needing to return info on each group regardless of
        whether a group selection was previously set.
        Nr�)r��_reset_cache)r>r@r@rArS�s
z_GroupBy._reset_group_selectioncCs||j}|jo0t|dd�dk	o0|jjdko0|jdks6dSdd�|jD�}t|�rx|jj}|j	t
|�dd�j�|_|jd�dS)	z�
        Create group based selection.

        Used when selection is not passed directly but instead via a grouper.

        NOTE: this should be paired with a call to _reset_group_selection
        �	groupingsN�cSs"g|]}|jdkr|jr|j�qS)N)rb�in_axisrJ)r|�gr@r@rAr}�sz1_GroupBy._set_group_selection.<locals>.<listcomp>F)r[r�)
rYrZrKrV�ndimr�r�rnZ
_info_axis�
differencer5�tolistr�)r>�grpZgroupers�axr@r@rArR�s
z_GroupBy._set_group_selectioncCs`|jjs@ttj|j|jj���}|j||jdd�|j	|jd�}|j|j
j|j�|jdd�|S)NT)rXZinplace)rX)rYZis_monotonicr5ry�concatenater��result_indexZset_axisrX�
sort_indexrV�	_get_axis)r>�result�indexr@r@rA�_set_result_index_ordered�sz"_GroupBy._set_result_index_orderedcCs|jj�|jBS)N)rV�_dir_additions�_apply_allowlist)r>r@r@rAr��sz_GroupBy._dir_additions)rLcCsH||jkrtj||�S||jkr(||Stdt|�j�d|�d���dS)N�'z' object has no attribute ')Z_internal_names_setrq�__getattribute__rV�AttributeErrorrfrG)r>rLr@r@rArM�s

z_GroupBy.__getattr__�GroupByz.. versionadded:: 0.21.0a>>> df = pd.DataFrame({'A': 'a b a b'.split(), 'B': [1, 2, 3, 4]})
>>> df
   A  B
0  a  1
1  b  2
2  a  3
3  b  4

To get the difference between each groups maximum and minimum value in one
pass, you can do

>>> df.groupby('A').pipe(lambda x: x.max() - x.min())
   B
A
a  2
b  2)�klassZversionadded�examplescOstj||f|�|�S)N)�com�pipe)r>�funcrDrEr@r@rAr��sz
_GroupBy.pipecsv��jkst��j�t�j���t�tj�s@�j�fdd��Stt	�j����t
j�������fdd�}�|_|S)Ncs
t|��S)N)rK)r>)rJr@rArw�sz(_GroupBy._make_wrapper.<locals>.<lambda>cs�d�jkr$�jdd�dkr$�j�d<���fdd�}�|_�tjkrN�j|�Sy�j|�j�St	k
r�}zt
jdt|��s��WYdd}~XnX�j
jdkr�t��j�f����}|S)NrXcs�|f����S)Nr@)�x)rDrFrEr@rA�curried�sz8_GroupBy._make_wrapper.<locals>.wrapper.<locals>.curriedz3reduction operation '.*' not allowed for this dtyper�)Z
parametersr�rXrGr2Zplotting_methodsrH�_python_apply_general�_obj_with_exclusionsrg�re�searchrQrVr�rhZ_aggregate_item_by_item)rDrEr�r�r�)rFrJr>�sig)rDrErA�wrapper�s"



z'_GroupBy._make_wrapper.<locals>.wrapper)
r�rerRrKr�rd�types�
MethodTyperHrf�inspect�	signaturerG)r>rJr�r@)rFrJr>r�rA�
_make_wrapper�s
%z_GroupBy._make_wrappercCs8|dkr|j}|j|�}t|�s(t|��|j||jd�S)a�
        Construct DataFrame from group with provided name.

        Parameters
        ----------
        name : object
            The name of the group to get as a DataFrame.
        obj : DataFrame, default None
            The DataFrame to take the DataFrame out of.  If
            it is None, the object groupby was called on will
            be used.

        Returns
        -------
        group : same type as obj
        N)rX)r�r�rnr�Z_take_with_is_copyrX)r>rJrVZindsr@r@rA�	get_groups
z_GroupBy.get_groupcCs|jj|j|jd�S)z�
        Groupby iterator.

        Returns
        -------
        Generator yielding sequence of (name, subsetted object)
        for each group
        )rX)rYZget_iteratorrVrX)r>r@r@rA�__iter__.s	z_GroupBy.__iter__r:Z	dataframer;)�inputr�cs�|j����s�r\t��r4t�����fdd��}q`ttd��rRttd��}q`td��n�}tdd��Ly|j||j	�}Wn2t
k
r�t|��|j||j	�SQRXYnXWdQRX|S)Nc
s(tjdd���|f����SQRXdS)N�ignore)�all)ryZerrstate)r�)rDr�rEr@rArFHsz_GroupBy.apply.<locals>.f�nanz6func must be a callable if args or kwargs are suppliedzmode.chained_assignment)�_is_builtin_func�callabler�hasattrr*rKrhrr�r�rgrT)r>r�rDrErFr�r@)rDr�rErArH9s 
	
$z_GroupBy.apply)rF�datarmcCs.|jj|||j�\}}}|j|||p(|jd�S)a-
        Apply function f in python space

        Parameters
        ----------
        f : callable
            Function to apply
        data : Series or DataFrame
            Data to apply f to

        Returns
        -------
        Series or DataFrame
            data after applying f
        )�not_indexed_same)rYrHrX�_wrap_applied_outputr_)r>rFr�rW�valuesr_r@r@rAr�jsz_GroupBy._python_apply_generalcCst|��dS)N)r)r>r@r@rA�_iterate_slices�sz_GroupBy._iterate_slicescOst|��dS)N)r)r>r�rDrEr@r@rA�	transform�sz_GroupBy.transform)�	ascendingcCs|jj\}}}t||�}||t|�}}|dkrBtjdtjd�Stjd|dd�|dd�kf}tjtjtj	|�d|f�}|j
�}	|r�|	tj|	||�8}	n&tj|	tj|dd�df|�|	}	tj|tjd�}
tj
|tjd�|
|<|	|
jtjdd�S)	a.
        Parameters
        ----------
        ascending : bool, default True
            If False, number in reverse, from length of group - 1 to 0.

        Notes
        -----
        this is currently implementing sort=False
        (though the default is sort=True) for groupby in general
        r)�dtypeTNr�F)�copy���)rY�
group_infor8rnry�empty�int64Zr_ZdiffZnonzero�cumsum�repeat�intp�arange�astype)r>r��ids�_rtZsorter�count�run�rep�out�revr@r@rA�_cumcount_array�s
"
&z_GroupBy._cumcount_array)�func_nmrmcCs4|jj�jd�}|dk	st�|jd�j�o2|tjkS)a
        Parameters
        ----------
        func_nm: str
            The name of the aggregation function being performed

        Returns
        -------
        bool
            Whether transform should attempt to cast the result of aggregation
        rN)rY�sizeZfillnare�gt�anyr2Zcython_cast_blocklist)r>r�Z
filled_seriesr@r@rA�_transform_should_cast�sz_GroupBy._transform_should_cast)�how�numeric_onlycKs�i}x�t|j��D]�\}}|j}t|j�}|r6|r6qy|jj|j|f|�\}	}
Wntk
rhwYnX|j	|�r�t
|	||d�}	tj||d�}|	||<qWt
|�dkr�td��|j|�S)N)r�)�label�positionrzNo numeric types to aggregate)�	enumerater�rJr%r�rYr�r��NotImplementedErrorr�rr2�	OutputKeyrnr-�_wrap_transformed_output)r>r�r�rE�output�idxrVrJ�
is_numericr�r�rvr@r@rA�_cython_transform�s"


z_GroupBy._cython_transform)r�r�cCst|��dS)N)r)r>r�r�r@r@rA�_wrap_aggregated_output�sz _GroupBy._wrap_aggregated_output)r�cCst|��dS)N)r)r>r�r@r@rAr��sz!_GroupBy._wrap_transformed_output)r�cCst|��dS)N)r)r>rWr�r�r@r@rAr��sz_GroupBy._wrap_applied_outputr�)r��	min_count�alias�npfunccs��j�d}y�j|�||d�}WnPtk
r6Yn>tk
rr}z"dt|�ksbdt|�kr`n�WYdd}~XnX|dkr��j��fdd��}|j�jdd�S)N)r��altr�r�z*function is not implemented for this dtypezcategory dtype not supportedcs�|�jd�S)N)rX)rX)r�)r�r>r@rArw�sz'_GroupBy._agg_general.<locals>.<lambda>r?)�method)rR�_cython_agg_generalr-r�rQ�	aggregateZ__finalize__rV)r>r�r�r�r�r�r�r@)r�r>rA�_agg_general�s z_GroupBy._agg_general)r�r�r�cCsi}d}x�|j�D]�}|j}t|j�}	|r2|	r2q|jj|j||d�\}
}|r�t|�|
jdksdt	�xxt
|
j|�D]0\}}
tj
|
|d�}t|||d�||<|d7}qrWq|
jdks�t	�tj
||d�}t|
||d�||<|d7}qWt|�dkr�td��|j||jjd�S)Nr)r�r�)r�r�)r�zNo numeric types to aggregate)r�)r�rJr%r�rYr��_valuesrn�shaperer��Tr2r�rr�r-r�r�)r>r�r�r�r�r�r�rVrJr�r�Z	agg_namesZ
result_columnZresult_namervr@r@rAr��s,

z_GroupBy._cython_agg_generalZcython)�engine�
engine_kwargscs`|j���|dkr"���fdd�}i}x�t|j��D]�\}}	|	j}
|jjdkrPq4t|�r~|jj|	�f��||d����\}}n.y|jj|	|�\}}Wntk
r�w4YnX|dk	s�t	�t
j|
|d�}
t||	dd�||
<q4Wt
|�dkr�|j||j�S|jj�rN|j�dk}x@|j�D]4\}
}|}t|j��r6t|�}t|||�||
<�qW|j||jjd	�S)
NZnumbacs�|f����S)Nr@)r�)rDr�rEr@rArw&sz._GroupBy._python_agg_general.<locals>.<lambda>r)r�r�)r�r�T)r�)r�)r�r�r�rJrYrtr9Z
agg_seriesrgrer2r�rrnr�r�Z_filter_empty_groupsZravel�itemsr%r�r r�r�)r>r�r�r�rDrErFr�r�rVrJr��countsrv�maskr�r@)rDr�rErA�_python_agg_general!sB

z_GroupBy._python_agg_generalc
s0ddlm}�fdd�}|s�||�jd�}�jj�j�}|jr�|j�jj|�r�|jj	|j
�\}}	tj|�}|j
|�jd�}n|j|�jdd�}nx�jr�||�}�jr�|}
�jj}�jj}||�j|
||dd�}n ttt|���}||�j|d	�}n||�}||�jd�}t|t��r,�jdk	�r,�j|_|S)
Nr)�concatcs,x&tj|�D]}|j�j�}|j�qW|S)N)r�Znot_noner�rXZ_reset_identity)r��vr�)r>r@rA�reset_identityYsz0_GroupBy._concat_objects.<locals>.reset_identity)rXF)rXr�)rXrW�levelsr�r[)rXrW)�pandas.core.reshape.concatr�rXr�r�Zhas_duplicatesZaxes�equalsr�Zget_indexer_non_uniquer��
algorithmsZunique1d�take�reindexr\rZrYrr��list�rangernrdr7Z_selection_namerJ)
r>rWr�r�r�rr�r�Zindexerr�r\Zgroup_levelsZgroup_namesr@)r>rA�_concat_objectsVs<

z_GroupBy._concat_objectscCs�t|�dkrtjgdd�}ntjtj|��}|rD|jj||jd�}n^tjt|jj	�t
d�}|jd�d||jt
�<tj|t|jjdd��dg�j}|jj|�}|S)Nrr�)r�)rXFTr�)rnry�arrayr[r�r�rrXr�r��bool�fillr��intZtilerr�r��where)r>rur`�filteredr�r@r@rA�
_apply_filter�s
$z_GroupBy._apply_filter)
NrNNNNTTTFFFT)N)T)T)Fr�)Tr�r�)NTr�)F)CrGrNrOr��	frozensetr�rrQrr
�_KeysArgTyper
rrBrprrrs�propertyrortrur�r�rr�rSrRr�r�rMrr�_pipe_templater�r<rCr�r�r��_apply_docs�formatrHrrr�r
r7r�r�r�r�r�rr2r�ry�ndarrayr5r�r�r�rr�r�r�r	rr@r@r@rArU�sv
(+2
6
0  %4=rU�OutputFrameOrSeries)Zboundc
@s�eZdZdZeedd�dd��Zdd�Zedd	�e	e
�dved�dd
���Zedd	�e	e
�dwed�dd���Z
edd	�e	e
�dd���Zedd	�ee
d�dxed�dd���Zedd	�e	e
�dydd���Zedd	�e	e
�dzed�dd���Zedd	�e	e
�d{ed�dd���Zedd	�e	e
�d|ed�dd���Zedd	�e	e
�ed�d d!���Zeed"d
d#d$�d}eed%�d&d'��Zeed(d
d#d$�d~eed%�d)d*��Zeed+d,dd$�d�eed%�d-d.��Zeed/d,d�d$�d�eed%�d0d1��Zeed2d,d�d$�d�eed%�d3d4��Zeed5d,d�d$�d�eed%�d6d7��Zedd	�e	e
�ed�d8d9���Z eej!�d:d;��Z!d<d=�Z"edd	�e	e
�d>d?���Z#edd	�e	e
�d@dA���Z$d�dCdD�Z%edd	�d�dEdF��Z&e&Z'edd	�d�dGdH��Z(e(Z)edd	�ee
d�d�e*ee+efe,e-edI�dJdK���Z.d�e-dN�dOdP�Z/edd	�d�edQ�dRdS��Z0edd	�d�edQ�dTdU��Z1edd	�e	e
�d�e-ee-eedX�dYdZ���Z2edd	�e	e
�d�d[d\���Z3edd	�e	e
�d�d]d^���Z4edd	�e	e
�d�d_d`���Z5edd	�e	e
�d�dadb���Z6d�e-e7j8eeeeee,eeeedc�ddde�Z9edd	�d�dfdg��Z:edd	�e	e
�d�didj���Z;edd	�ee
d�d�dldm���Z<edd	�ee
d�d�dndo���Z=e7j>fe?e@e?dp�dqdr�ZAd�e,ee,eBee,e*eCeDfds�dtdu�ZEdBS)�r�a�
    Class for grouping and aggregating relational data.

    See aggregate, transform, and apply functions on this object.

    It's easiest to use obj.groupby(...) to use GroupBy, but you can also do:

    ::

        grouped = groupby(obj, ...)

    Parameters
    ----------
    obj : pandas object
    axis : int, default 0
    level : int, default None
        Level of MultiIndex
    groupings : list of Grouping objects
        Most users should ignore this
    exclusions : array-like, optional
        List of columns to exclude
    name : str
        Most users should ignore this

    Returns
    -------
    **Attributes**
    groups : dict
        {group name -> group labels}
    len(grouped) : int
        Number of groups

    Notes
    -----
    After grouping, see aggregate, apply, and transform functions. Here are
    some other brief notes about usage. When grouping by multiple groups, the
    result index will be a MultiIndex (hierarchical) by default.

    Iteration produces (key, group) tuples, i.e. chunking the data by group. So
    you can write code like:

    ::

        grouped = obj.groupby(keys, axis=axis)
        for key, group in grouped:
            # do something with the data

    Function calls on GroupBy, if not specially implemented, "dispatch" to the
    grouped data. So if you group a DataFrame and wish to invoke the std()
    method on each group, you can simply do:

    ::

        df.groupby(mapper).std()

    rather than

    ::

        df.groupby(mapper).aggregate(np.std)

    You can pass arguments to these "wrapped" functions, too.

    See the online documentation for full exposition on these topics and much
    more
    r7)rmcCs,t|jt�r|jjSt|jt�s$t�|jjS)N)rdrVr0Z_constructor_slicedr7re�_constructor)r>r@r@rA�_obj_1d_constructor�szGroupBy._obj_1d_constructorcCsXtjttjtfd�dd�}tjttjd�dd�}|jddd	tjtj�dd||||d
�
S)zO
        Shared func to call any / all Cython GroupBy implementations.
        )�valsrmcSs8t|�rtjdd�|D��}n
|jt�}|jtj�tfS)NcSsg|]}t|��qSr@)r)r|r�r@r@rAr}�sz;GroupBy._bool_agg.<locals>.objs_to_bool.<locals>.<listcomp>)r&ryr
r�r�view�uint8)rr@r@rA�objs_to_bool�s
z'GroupBy._bool_agg.<locals>.objs_to_bool)r��	inferencermcSs|j|dd�S)NF)r�)r�)r�rr@r@rA�result_to_boolsz)GroupBy._bool_agg.<locals>.result_to_boolZ
group_any_allTF)	r�r��cython_dtype�needs_values�
needs_mask�pre_processing�post_processing�val_test�skipna)ryrrr�_get_cythonized_resultr�r)r>r&r'rr r@r@rA�	_bool_agg�s
zGroupBy._bool_aggr?)rJT)r'cCs|jd|�S)a
        Return True if any value in the group is truthful, else False.

        Parameters
        ----------
        skipna : bool, default True
            Flag to ignore nan values during truth testing.

        Returns
        -------
        bool
        r�)r))r>r'r@r@rAr�szGroupBy.anycCs|jd|�S)a
        Return True if all values in the group are truthful, else False.

        Parameters
        ----------
        skipna : bool, default True
            Flag to ignore nan values during truth testing.

        Returns
        -------
        bool
        r�)r))r>r'r@r@rAr�"szGroupBy.allcCst�dS)z�
        Compute count of group, excluding missing values.

        Returns
        -------
        Series or DataFrame
            Count of values within each group.
        N)r�)r>r@r@rAr�3sz
GroupBy.count)Zsee_also)r�cs|jd�fdd��d�S)a�
        Compute mean of groups, excluding missing values.

        Parameters
        ----------
        numeric_only : bool, default True
            Include only float, int, boolean columns. If None, will attempt to use
            everything, then use only numeric data.

        Returns
        -------
        pandas.Series or pandas.DataFrame
        %(see_also)s
        Examples
        --------
        >>> df = pd.DataFrame({'A': [1, 1, 2, 1, 2],
        ...                    'B': [np.nan, 2, 3, 4, 5],
        ...                    'C': [1, 2, 1, 1, 2]}, columns=['A', 'B', 'C'])

        Groupby one column and return the mean of the remaining columns in
        each group.

        >>> df.groupby('A').mean()
             B         C
        A
        1  3.0  1.333333
        2  4.0  1.500000

        Groupby two columns and return the mean of the remaining column.

        >>> df.groupby(['A', 'B']).mean()
               C
        A B
        1 2.0  2
          4.0  1
        2 3.0  1
          5.0  2

        Groupby one column and return the mean of only particular column in
        the group.

        >>> df.groupby('A')['B'].mean()
        A
        1    3.0
        2    4.0
        Name: B, dtype: float64
        �meancst|�j�d�S)N)r�)r7r*)r�rX)r�r@rArwuszGroupBy.mean.<locals>.<lambda>)r�r�)r�)r>r�r@)r�rAr*As2
zGroupBy.meancs|jd�fdd��d�S)a�
        Compute median of groups, excluding missing values.

        For multiple groupings, the result index will be a MultiIndex

        Parameters
        ----------
        numeric_only : bool, default True
            Include only float, int, boolean columns. If None, will attempt to use
            everything, then use only numeric data.

        Returns
        -------
        Series or DataFrame
            Median of values within each group.
        �mediancst|�j|�d�S)N)rXr�)r7r+)r�rX)r�r@rArw�sz GroupBy.median.<locals>.<lambda>)r�r�)r�)r>r�r@)r�rAr+ys
zGroupBy.medianr�)�ddofc
Cs&|jdddddtjtj�dd�|d�S)aw
        Compute standard deviation of groups, excluding missing values.

        For multiple groupings, the result index will be a MultiIndex.

        Parameters
        ----------
        ddof : int, default 1
            Degrees of freedom.

        Returns
        -------
        Series or DataFrame
            Standard deviation of values within each group.
        Zgroup_var_float64TcSs
tj|�S)N)ry�sqrt)rrr@r@rArw�szGroupBy.std.<locals>.<lambda>)r��needs_countsr"�needs_2dr!r%r,)r(ryr��float64)r>r,r@r@rA�std�s
zGroupBy.stdc	sH�dkr|jd�fdd�d�S�fdd�}t|��|j|�SQRXdS)ac
        Compute variance of groups, excluding missing values.

        For multiple groupings, the result index will be a MultiIndex.

        Parameters
        ----------
        ddof : int, default 1
            Degrees of freedom.

        Returns
        -------
        Series or DataFrame
            Variance of values within each group.
        r��varcst|�j�d�S)N)r,)r7r2)r�rX)r,r@rArw�szGroupBy.var.<locals>.<lambda>)r�cs|j�d�S)N)r,)r2)r�)r,r@rArw�sN)r�rTr�)r>r,r�r@)r,rAr2�s
zGroupBy.varcCs�|j|d�}|jdkr*|tj|j��}nZ|jj|jj|j�j	��}|j
dd�|fjtj|j�j
dd�|f�j|j
dd�|f<|S)a�
        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.

        Returns
        -------
        Series or DataFrame
            Standard error of the mean of values within each group.
        )r,r�N)r1r�ryr-r��columnsZget_indexer_forr�rk�uniqueZilocr�)r>r,r��colsr@r@rA�sem�s
@zGroupBy.semcCsX|jj�}t|jjt�r,|j||jjd�}n
|j|�}|jsJ|j	d�j
�}|j|dd�S)z�
        Compute group sizes.

        Returns
        -------
        DataFrame or Series
            Number of rows in each group as a Series if as_index is True
            or a DataFrame if as_index is False.
        )rJr�r)�
fill_value)rYr��
issubclassrVrr7rrJrZ�rename�reset_index�_reindex_output)r>r�r@r@rAr��s

zGroupBy.size�sumr)�fname�noZmc)r�r�cCs|j||dtjd�S)N�add)r�r�r�r�)r�ryr<)r>r�r�r@r@rAr<szGroupBy.sum�prodcCs|j||dtjd�S)Nr@)r�r�r�r�)r�ryr@)r>r�r�r@r@rAr@	szGroupBy.prod�minFcCs|j||dtjd�S)NrA)r�r�r�r�)r�ryrA)r>r�r�r@r@rArAszGroupBy.min�maxcCs|j||dtjd�S)NrB)r�r�r�r�)r�ryrB)r>r�r�r@r@rArBszGroupBy.max�firstcCs$dttd�dd�}|j||d|d�S)Nr)rVrXcSsHtd�dd�}t|t�r&|j||d�St|t�r8||�Stt|���dS)N)r�cSs*|jt|j�}t|�dkr"tjS|dS)z>Helper function for first item that isn't NA.
                r)r
r)rnryr�)r�r@r@rArCsz2GroupBy.first.<locals>.first_compat.<locals>.first)rX)r7rdr0rHrgrf)rVrXrCr@r@rA�first_compats

z#GroupBy.first.<locals>.first_compatrC)r�r�r�r�)r)rr
r�)r>r�r�rDr@r@rArCsz
GroupBy.first�lastcCs$dttd�dd�}|j||d|d�S)Nr)rVrXcSsHtd�dd�}t|t�r&|j||d�St|t�r8||�Stt|���dS)N)r�cSs*|jt|j�}t|�dkr"tjS|dS)z=Helper function for last item that isn't NA.
                rr�r�)r
r)rnryr�)r�r@r@rArE7sz/GroupBy.last.<locals>.last_compat.<locals>.last)rX)r7rdr0rHrgrf)rVrXrEr@r@rA�last_compat6s

z!GroupBy.last.<locals>.last_compatrE)r�r�r�r�)r)rr
r�)r>r�r�rFr@r@rArE4szGroupBy.lastcCs|jdd��S)a
        Compute open, high, low and close values of a group, excluding missing values.

        For multiple groupings, the result index will be a MultiIndex

        Returns
        -------
        DataFrame
            Open, high, low and close values within each group.
        cSs
|jd�S)N�ohlc)r�)r�r@r@rArwZszGroupBy.ohlc.<locals>.<lambda>)Z_apply_to_column_groupbys)r>r@r@rArGMs
zGroupBy.ohlccs>t|��,|j�fdd��}|jdkr,|jS|j�SQRXdS)Ncs|jf��S)N)�describe)r�)rEr@rArw_sz"GroupBy.describe.<locals>.<lambda>r�)rTrHrXr�Zunstack)r>rEr�r@)rErArH\s


zGroupBy.describecOsddlm}|||f|�|�S)a<
        Provide resampling when using a TimeGrouper.

        Given a grouper, the function resamples it according to a string
        "string" -> "frequency".

        See the :ref:`frequency aliases <timeseries.offset_aliases>`
        documentation for more details.

        Parameters
        ----------
        rule : str or DateOffset
            The offset string or object representing target grouper conversion.
        *args, **kwargs
            Possible arguments are `how`, `fill_method`, `limit`, `kind` and
            `on`, and other arguments of `TimeGrouper`.

        Returns
        -------
        Grouper
            Return a new grouper with our resampler appended.

        See Also
        --------
        Grouper : Specify a frequency to resample with when
            grouping by a key.
        DatetimeIndex.resample : Frequency conversion and resampling of
            time series.

        Examples
        --------
        >>> idx = pd.date_range('1/1/2000', periods=4, freq='T')
        >>> df = pd.DataFrame(data=4 * [range(2)],
        ...                   index=idx,
        ...                   columns=['a', 'b'])
        >>> df.iloc[2, 0] = 5
        >>> df
                            a  b
        2000-01-01 00:00:00  0  1
        2000-01-01 00:01:00  0  1
        2000-01-01 00:02:00  5  1
        2000-01-01 00:03:00  0  1

        Downsample the DataFrame into 3 minute bins and sum the values of
        the timestamps falling into a bin.

        >>> df.groupby('a').resample('3T').sum()
                                 a  b
        a
        0   2000-01-01 00:00:00  0  2
            2000-01-01 00:03:00  0  1
        5   2000-01-01 00:00:00  5  1

        Upsample the series into 30 second bins.

        >>> df.groupby('a').resample('30S').sum()
                            a  b
        a
        0   2000-01-01 00:00:00  0  1
            2000-01-01 00:00:30  0  0
            2000-01-01 00:01:00  0  1
            2000-01-01 00:01:30  0  0
            2000-01-01 00:02:00  0  0
            2000-01-01 00:02:30  0  0
            2000-01-01 00:03:00  0  1
        5   2000-01-01 00:02:00  5  1

        Resample by month. Values are assigned to the month of the period.

        >>> df.groupby('a').resample('M').sum()
                    a  b
        a
        0   2000-01-31  0  3
        5   2000-01-31  5  1

        Downsample the series into 3 minute bins as above, but close the right
        side of the bin interval.

        >>> df.groupby('a').resample('3T', closed='right').sum()
                                 a  b
        a
        0   1999-12-31 23:57:00  0  1
            2000-01-01 00:00:00  0  2
        5   2000-01-01 00:00:00  5  1

        Downsample the series into 3 minute bins and close the right side of
        the bin interval, but label each bin using the right edge instead of
        the left.

        >>> df.groupby('a').resample('3T', closed='right', label='right').sum()
                                 a  b
        a
        0   2000-01-01 00:00:00  0  1
            2000-01-01 00:03:00  0  2
        5   2000-01-01 00:03:00  5  1
        r)�get_resampler_for_grouping)Zpandas.core.resamplerI)r>ZrulerDrErIr@r@rA�resampledsazGroupBy.resamplecOsddlm}||f|�|�S)zV
        Return a rolling grouper, providing rolling functionality per group.
        r)�RollingGroupby)�pandas.core.windowrK)r>rDrErKr@r@rA�rolling�szGroupBy.rollingcOsddlm}||f|�|�S)zc
        Return an expanding grouper, providing expanding
        functionality per group.
        r)�ExpandingGroupby)rLrN)r>rDrErNr@r@rA�	expanding�szGroupBy.expandingNc	Cs,|dkrd}|jdddtjtj�d||d�S)a�
        Shared function for `pad` and `backfill` to call Cython method.

        Parameters
        ----------
        direction : {'ffill', 'bfill'}
            Direction passed to underlying Cython function. `bfill` will cause
            values to be filled backwards. `ffill` and any other values will
            default to a forward fill
        limit : int, default None
            Maximum number of consecutive values to fill. If `None`, this
            method will convert to -1 prior to passing to Cython

        Returns
        -------
        `Series` or `DataFrame` with filled values

        See Also
        --------
        pad
        backfill
        Nr�Zgroup_fillna_indexerFT)r�r#r!�result_is_index�	direction�limitr�)r(ryr�r�)r>rQrRr@r@rA�_fill�s
z
GroupBy._fillcCs|jd|d�S)a�
        Forward fill the values.

        Parameters
        ----------
        limit : int, optional
            Limit of how many values to fill.

        Returns
        -------
        Series or DataFrame
            Object with missing values filled.

        See Also
        --------
        Series.pad
        DataFrame.pad
        Series.fillna
        DataFrame.fillna
        �ffill)rR)rS)r>rRr@r@rA�padszGroupBy.padcCs|jd|d�S)a�
        Backward fill the values.

        Parameters
        ----------
        limit : int, optional
            Limit of how many values to fill.

        Returns
        -------
        Series or DataFrame
            Object with missing values filled.

        See Also
        --------
        Series.backfill
        DataFrame.backfill
        Series.fillna
        DataFrame.fillna
        �bfill)rR)rS)r>rRr@r@rA�backfillszGroupBy.backfill)r~r`rmcCsjtttf}t||tf�s td��|�st|t�r8|g}nt||�rNtt|��}tj|tjd�}|j	�tj
|j�|�}tj
|jdd�d|�}||B}|jj
\}	}
}
||	dk@}|j|}|js�|S|jj}||	||_|jo�t|t��r�|j|�}|j|�}|j�r|j�S|St||��r,td��|dk�rFtd	|�d
���|dk�rT|nd|}
|jj||jd�}|jd
k�r�|jd
k�r�|jj}||j|j�}n0ddlm }|||j|j|j|j|j!d�\}}
}
|j"||j|jd�}|j#�|j$|�}}||
kj%}t&|��r"|j'��r"tj(|j)|<t&|j�t&|�k�sLt&|�t&|jj�k�rX|jj|_n|j|jj�}|S)a�
        Take the nth row from each group if n is an int, or a subset of rows
        if n is a list of ints.

        If dropna, will take the nth non-null row, dropna is either
        'all' or 'any'; this is equivalent to calling dropna(how=dropna)
        before the groupby.

        Parameters
        ----------
        n : int or list of ints
            A single nth value for the row or a list of nth values.
        dropna : None or str, optional
            Apply the specified dropna operation before counting which row is
            the nth row. Needs to be None, 'any' or 'all'.

        Returns
        -------
        Series or DataFrame
            N-th value within each group.
        %(see_also)s
        Examples
        --------

        >>> df = pd.DataFrame({'A': [1, 1, 2, 1, 2],
        ...                    'B': [np.nan, 2, 3, 4, 5]}, columns=['A', 'B'])
        >>> g = df.groupby('A')
        >>> g.nth(0)
             B
        A
        1  NaN
        2  3.0
        >>> g.nth(1)
             B
        A
        1  2.0
        2  5.0
        >>> g.nth(-1)
             B
        A
        1  4.0
        2  5.0
        >>> g.nth([0, 1])
             B
        A
        1  NaN
        1  2.0
        2  3.0
        2  5.0

        Specifying `dropna` allows count ignoring ``NaN``

        >>> g.nth(0, dropna='any')
             B
        A
        1  2.0
        2  3.0

        NaNs denote group exhausted when using dropna

        >>> g.nth(3, dropna='any')
            B
        A
        1 NaN
        2 NaN

        Specifying `as_index=False` in `groupby` keeps the original index.

        >>> df.groupby('A', as_index=False).nth(1)
           A    B
        1  1  2.0
        4  2  5.0
        z0n needs to be an int or a list/set/tuple of ints)r�F)r�r�z8dropna option with a list of nth values is not supportedr�r�zQFor a DataFrame groupby, dropna must be either None, 'any' or 'all', (was passed z).r)r�rXN)ra)rvrXrbr[r_)rZr[r�)r�r�r�)*rjrr�rdr
rgryr
r�rRZin1dr�rYr�r�rZr�r�r^r4rr;r[r�rhrVr`rXrWrb�isinrirar_r?r��nthr�rnr�r��loc)r>r~r`Zvalid_containersZ
nth_valuesZ	nth_arrayZ	mask_leftZ
mask_rightr�r�r�r�r��max_lenZdroppedrXrYraZgrb�sizesr�r@r@rArY7shL







zGroupBy.nth��?�linear)�
interpolationc	sddlm}tjttjttfd�dd��tjtttjd��fdd��t|�rx�jd	d
dd
d
tj	tj
���|�d�
S����fd
d�|D�}||d|d�}ttd|j
j��dg}tj|j
j�}tjt|��|j
_|j|�}|||j
_tjt|��jt|��jg�jj�}|j|�SdS)a
        Return group values at the given quantile, a la numpy.percentile.

        Parameters
        ----------
        q : float or array-like, default 0.5 (50% quantile)
            Value(s) between 0 and 1 providing the quantile(s) to compute.
        interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
            Method to use when the desired quantile falls between two points.

        Returns
        -------
        Series or DataFrame
            Return type determined by caller of GroupBy object.

        See Also
        --------
        Series.quantile : Similar method for Series.
        DataFrame.quantile : Similar method for DataFrame.
        numpy.percentile : NumPy method to compute qth percentile.

        Examples
        --------
        >>> df = pd.DataFrame([
        ...     ['a', 1], ['a', 2], ['a', 3],
        ...     ['b', 1], ['b', 3], ['b', 5]
        ... ], columns=['key', 'val'])
        >>> df.groupby('key').quantile()
            val
        key
        a    2.0
        b    3.0
        r)r�)rrmcSs�t|�rtd��d}t|j�r@t|j�r8|jttjd�}tj	}nDt
|j�rft|j�rf|jttjd�}nt|j�r�d}tj|�j
t�}||fS)Nz7'quantile' cannot be performed against 'object' dtypes!)r�Zna_valuezdatetime64[ns])r&rgr$r�r#Zto_numpy�floatryr�r�r!r"Zasarrayr�)rrr@r@rA�
pre_processors


z'GroupBy.quantile.<locals>.pre_processor)rrrmcs"|rt|�o�dks|j|�}|S)Nr^�midpoint>rbr^)r$r�)rr)r_r@rA�post_processors

z(GroupBy.quantile.<locals>.post_processor�group_quantileTF)	r�r�r"r#r!r$r%�qr_c
s0g|](}�jddddtjtj���|�d�	�qS)rdT)r�r"r#r!r$r%rer_)r(ryr�r0)r|Zqi)r_rcrar>r@rAr}3sz$GroupBy.quantile.<locals>.<listcomp>)rXrWr�N)Zpandasr�ryrrr
rr'r(r�r0rrr�Znlevelsr
r�r�rnZreorder_levels�reshapertr��flattenr)	r>rer_r��resultsr��orderZindex_namesrur@)r_rcrar>rA�quantile�s2" 

$zGroupBy.quantile)r�c
CsFt|��4|jj}|j|jjd|�}|s8|jd|}|SQRXdS)a)
        Number each group from 0 to the number of groups - 1.

        This is the enumerative complement of cumcount.  Note that the
        numbers given to the groups match the order in which the groups
        would be seen when iterating over the groupby object, not the
        order they are first observed.

        Parameters
        ----------
        ascending : bool, default True
            If False, number in reverse, from number of group - 1 to 0.

        Returns
        -------
        Series
            Unique numbers for each group.

        See Also
        --------
        .cumcount : Number the rows in each group.

        Examples
        --------
        >>> df = pd.DataFrame({"A": list("aaabba")})
        >>> df
           A
        0  a
        1  a
        2  a
        3  b
        4  b
        5  a
        >>> df.groupby('A').ngroup()
        0    0
        1    0
        2    0
        3    1
        4    1
        5    0
        dtype: int64
        >>> df.groupby('A').ngroup(ascending=False)
        0    1
        1    1
        2    1
        3    0
        4    0
        5    1
        dtype: int64
        >>> df.groupby(["A", [1,1,2,3,2,1]]).ngroup()
        0    0
        1    0
        2    1
        3    3
        4    2
        5    0
        dtype: int64
        rr�N)rTr�r�rrYr�rt)r>r�r�r�r@r@rA�ngroupXs<
zGroupBy.ngroupc
Cs4t|��"|jj}|j|d�}|j||�SQRXdS)a�
        Number each item in each group from 0 to the length of that group - 1.

        Essentially this is equivalent to

        .. code-block:: python

            self.apply(lambda x: pd.Series(np.arange(len(x)), x.index))

        Parameters
        ----------
        ascending : bool, default True
            If False, number in reverse, from length of group - 1 to 0.

        Returns
        -------
        Series
            Sequence number of each element within each group.

        See Also
        --------
        .ngroup : Number the groups themselves.

        Examples
        --------
        >>> df = pd.DataFrame([['a'], ['a'], ['a'], ['b'], ['b'], ['a']],
        ...                   columns=['A'])
        >>> df
           A
        0  a
        1  a
        2  a
        3  b
        4  b
        5  a
        >>> df.groupby('A').cumcount()
        0    0
        1    1
        2    2
        3    0
        4    1
        5    3
        dtype: int64
        >>> df.groupby('A').cumcount(ascending=False)
        0    3
        1    2
        2    1
        3    1
        4    0
        5    0
        dtype: int64
        )r�N)rTr�r�r�r)r>r�r�Z	cumcountsr@r@rA�cumcount�s6
zGroupBy.cumcount�average�keep)r�r��	na_option�pctrXc	Cs,|dkrd}t|��|jdd|||||d�S)	a
        Provide the rank of values within each group.

        Parameters
        ----------
        method : {'average', 'min', 'max', 'first', 'dense'}, default 'average'
            * average: average rank of group.
            * min: lowest rank in group.
            * max: highest rank in group.
            * first: ranks assigned in order they appear in the array.
            * dense: like 'min', but rank always increases by 1 between groups.
        ascending : bool, default True
            False for ranks by high (1) to low (N).
        na_option : {'keep', 'top', 'bottom'}, default 'keep'
            * keep: leave NA values where they are.
            * top: smallest rank if ascending.
            * bottom: smallest rank if descending.
        pct : bool, default False
            Compute percentage rank of data within each group.
        axis : int, default 0
            The axis of the object over which to compute the rank.

        Returns
        -------
        DataFrame with ranking of values within each group
        rn�top�bottomz3na_option must be one of 'keep', 'top', or 'bottom'�rankF)r�Zties_methodr�rorprX>rnrrrq)rhr�)r>r�r�rorprXr�r@r@rArs�s$zGroupBy.rankcs<tjd|�ddg��dkr0|j��fdd��S|jd��S)zq
        Cumulative product for each group.

        Returns
        -------
        Series or DataFrame
        �cumprodr�r'rcs|jfd�i���S)NrX)rt)r�)rXrEr@rArw	sz!GroupBy.cumprod.<locals>.<lambda>)rt)�nv�validate_groupby_funcrHr�)r>rXrDrEr@)rXrErArt	s
zGroupBy.cumprodcs<tjd|�ddg��dkr0|j��fdd��S|jd��S)zm
        Cumulative sum for each group.

        Returns
        -------
        Series or DataFrame
        r�r�r'rcs|jfd�i���S)NrX)r�)r�)rXrEr@rArw#	sz GroupBy.cumsum.<locals>.<lambda>)r�)rurvrHr�)r>rXrDrEr@)rXrErAr�	s
zGroupBy.cumsumcs(�dkr|j�fdd��S|jddd�S)zm
        Cumulative min for each group.

        Returns
        -------
        Series or DataFrame
        rcstjj|��S)N)ryZminimum�
accumulate)r�)rXr@rArw2	sz GroupBy.cummin.<locals>.<lambda>�cumminF)r�)rHr�)r>rXrEr@)rXrArx'	s
zGroupBy.cummincs(�dkr|j�fdd��S|jddd�S)zm
        Cumulative max for each group.

        Returns
        -------
        Series or DataFrame
        rcstjj|��S)N)ry�maximumrw)r�)rXr@rArwA	sz GroupBy.cummax.<locals>.<lambda>�cummaxF)r�)rHr�)r>rXrEr@)rXrArz6	s
zGroupBy.cummax)r�r!r�r�r.r"r/r�r#�
needs_ngroupsrPc#Ks^|r|rtd��|
r$t|
�s$td��|rDt|�s8td��|sDtd��|j}|j\}}}i}tt|�}d}�x�t|j��D�]�\}}|j}|j	}|r�t
|�r�qx|r�|}nt|�}tj
||d�}|r�|jd�}t||�}d}|�r�tj
|jtjd�}t||�}|�rt|}|�rLy||�\}}Wn.tk
�rJ} zt| �}wxWYdd} ~ XnX|j|d	d
�}|�rj|jd�}t||�}t||�}|dk	�r�t||�}|	�r�t|�jtj�}!t||!�}|
�r�t||�}|f|�|�r�|jd�}|�r�tj||�}|
�r�|
||�}tj||d�}"|||"<qxWt|�dk�r8|dk�r8t|��|�rP|j||jjd
�S|j|�SdS)aw	
        Get result for Cythonized functions.

        Parameters
        ----------
        how : str, Cythonized function name to be called
        cython_dtype : np.dtype
            Type of the array that will be modified by the Cython call.
        aggregate : bool, default False
            Whether the result should be aggregated to match the number of
            groups
        numeric_only : bool, default True
            Whether only numeric datatypes should be computed
        needs_counts : bool, default False
            Whether the counts should be a part of the Cython call
        needs_values : bool, default False
            Whether the values should be a part of the Cython call
            signature
        needs_2d : bool, default False
            Whether the values and result of the Cython call signature
            are 2-dimensional.
        min_count : int, default None
            When not None, min_count for the Cython call
        needs_mask : bool, default False
            Whether boolean mask needs to be part of the Cython call
            signature
        needs_ngroups : bool, default False
            Whether number of groups is part of the Cython call signature
        result_is_index : bool, default False
            Whether the result of the Cython operation is an index of
            values to be retrieved, instead of the actual values themselves
        pre_processing : function, default None
            Function to be applied to `values` prior to passing to Cython.
            Function should return a tuple where the first element is the
            values to be passed to Cython and the second element is an optional
            type which the values should be converted to after being returned
            by the Cython operation. This function is also responsible for
            raising a TypeError if the values have an invalid type. Raises
            if `needs_values` is False.
        post_processing : function, default None
            Function to be applied to result of Cython function. Should accept
            an array of values as the first argument and type inferences as its
            second argument, i.e. the signature should be
            (ndarray, Type).
        **kwargs : dict
            Extra arguments to be passed back to Cython funcs

        Returns
        -------
        `Series` or `DataFrame`  with filled values
        z6'result_is_index' and 'aggregate' cannot both be True!z%'post_processing' must be a callable!z$'pre_processing' must be a callable!z>Cannot use 'pre_processing' without specifying 'needs_values'!�)r�r�NF)r�)r�r�r)r�r�)r�r�r�)r�r�r�)rhr�rYr�rK�
libgroupbyr�r�rJr�r%rnry�zerosrfrrtr�rgrQr�r(rrrZtake_ndr2r�r�r�r�)#r>r�r!r�r�r.r"r/r�r#r{rPr$r%rErY�labelsr�rtr�Z	base_funcZ	error_msgr�rVrJr�Z	result_szr�r�Z
inferencesr�r�er�rvr@r@rAr(E	s�D













zGroupBy._get_cythonized_resultcsP�dk	s�dkst��r2|j����fdd��S|jddtjtj�dd�d�S)	u*
        Shift each group by periods observations.

        If freq is passed, the index will be increased using the periods and the freq.

        Parameters
        ----------
        periods : int, default 1
            Number of periods to shift.
        freq : str, optional
            Frequency string.
        axis : axis to shift, default 0
            Shift direction.
        fill_value : optional
            The scalar value to use for newly introduced missing values.

            .. versionadded:: 0.24.0

        Returns
        -------
        Series or DataFrame
            Object shifted within each group.

        See Also
        --------
        Index.shift : Shift values of Index.
        tshift : Shift the time index, using the index’s frequency
            if available.
        Nrcs|j�����S)N)�shift)r�)rXr7�freq�periodsr@rArw
szGroupBy.shift.<locals>.<lambda>Zgroup_shift_indexerFT)r�r!r{rPr�)r(rHr(ryr�r�)r>r�r�rXr7r@)rXr7r�r�rAr��	s
z
GroupBy.shiftrUc	sr�dk	s�dkr*|j�����fdd��S�dkr:d�d�t|���d�}|j|jj�}|j��d�}||dS)	z�
        Calculate pct_change of each value to previous entry in group.

        Returns
        -------
        Series or DataFrame
            Percentage changes within each group.
        Nrcs|j�����d�S)N)r��fill_methodrRr�rX)�
pct_change)r�)rXr�r�rRr�r@rArw
s
z$GroupBy.pct_change.<locals>.<lambda>rU)rR)r�r�r�)rHrKr?rY�codesr�)	r>r�r�rRr�rXZfilledZfill_grpZshiftedr@)rXr�r�rRr�rAr�
szGroupBy.pct_change�cCs|j�|j�|k}|j|S)a�
        Return first n rows of each group.

        Similar to ``.apply(lambda x: x.head(n))``, but it returns a subset of rows
        from the original DataFrame with original index and order preserved
        (``as_index`` flag is ignored).

        Does not work for negative values of `n`.

        Returns
        -------
        Series or DataFrame
        %(see_also)s
        Examples
        --------

        >>> df = pd.DataFrame([[1, 2], [1, 4], [5, 6]],
        ...                   columns=['A', 'B'])
        >>> df.groupby('A').head(1)
           A  B
        0  1  2
        2  5  6
        >>> df.groupby('A').head(-1)
        Empty DataFrame
        Columns: [A, B]
        Index: []
        )rSr�r�)r>r~r�r@r@rA�head,
szGroupBy.headcCs"|j�|jdd�|k}|j|S)a�
        Return last n rows of each group.

        Similar to ``.apply(lambda x: x.tail(n))``, but it returns a subset of rows
        from the original DataFrame with original index and order preserved
        (``as_index`` flag is ignored).

        Does not work for negative values of `n`.

        Returns
        -------
        Series or DataFrame
        %(see_also)s
        Examples
        --------

        >>> df = pd.DataFrame([['a', 1], ['a', 2], ['b', 1], ['b', 2]],
        ...                   columns=['A', 'B'])
        >>> df.groupby('A').tail(1)
           A  B
        1  a  2
        3  b  2
        >>> df.groupby('A').tail(-1)
        Empty DataFrame
        Columns: [A, B]
        Index: []
        F)r�)rSr�r�)r>r~r�r@r@rA�tailN
szGroupBy.tail)r�r7rmcCs�|jj}|dkr|St|�dkr$|S|jr.|Stdd�|D��sD|Sdd�|D�}tj||jjd�j�\}}|j	r�|j
j|j�|dd	d
|i}|j
f|�Sdd�t|�D�}t|�\}	}
|jt|
�dd�}|j|jj�j
|d	|d
�}|j|	d�}|jdd�S)a�
        If we have categorical groupers, then we might want to make sure that
        we have a fully re-indexed output to the levels. This means expanding
        the output space to accommodate all values in the cartesian product of
        our groups, regardless of whether they were observed in the data or
        not. This will expand the output space if there are missing groups.

        The method returns early without modifying the input if the number of
        groupings is less than 2, self.observed == True or none of the groupers
        are categorical.

        Parameters
        ----------
        output : Series or DataFrame
            Object resulting from grouping and applying an operation.
        fill_value : scalar, default np.NaN
            Value to use for unobserved categories if self.observed is False.

        Returns
        -------
        Series or DataFrame
            Object (potentially) re-indexed to include all possible groups.
        Nr�css|]}t|jttf�VqdS)N)rdrYr+r4)r|�pingr@r@rAr�
sz*GroupBy._reindex_output.<locals>.<genexpr>cSsg|]
}|j�qSr@)Zgroup_index)r|r�r@r@rAr}�
sz+GroupBy._reindex_output.<locals>.<listcomp>)r�r�Fr7css"|]\}}|jr||jfVqdS)N)r�rJ)r|�ir�r@r@rAr�
s)rrX)r�r7)rbT)�drop)rYr�rnr^r�r6Zfrom_productr�Z	sortlevelrZrVZ_get_axis_namerXrr�r�r�rZ	set_indexr�r:)r>r�r7r�Zlevels_listr�r��dZin_axis_grpsZg_numsZg_namesr@r@rAr;p
s4
zGroupBy._reindex_output)r~�frac�replace�weightsc	s�ddlm}�dk	r>t�|jjd���fdd�|jj�D�}ndg|j}�dk	r\tj	�������fdd�t
||�D�}|||jd�S)	a"
        Return a random sample of items from each group.

        You can use `random_state` for reproducibility.

        .. versionadded:: 1.1.0

        Parameters
        ----------
        n : int, optional
            Number of items to return for each group. Cannot be used with
            `frac` and must be no larger than the smallest group unless
            `replace` is True. Default is one if `frac` is None.
        frac : float, optional
            Fraction of items to return. Cannot be used with `n`.
        replace : bool, default False
            Allow or disallow sampling of the same row more than once.
        weights : list-like, optional
            Default None results in equal probability weighting.
            If passed a list-like then values must have the same length as
            the underlying DataFrame or Series object and will be used as
            sampling probabilities after normalization within each group.
            Values must be non-negative with at least one positive element
            within each group.
        random_state : int, array-like, BitGenerator, np.random.RandomState, optional
            If int, array-like, or BitGenerator (NumPy>=1.17), seed for
            random number generator
            If np.random.RandomState, use as numpy RandomState object.

        Returns
        -------
        Series or DataFrame
            A new object of same type as caller containing items randomly
            sampled within each group from the caller object.

        See Also
        --------
        DataFrame.sample: Generate random samples from a DataFrame object.
        numpy.random.choice: Generate a random sample from a given 1-D numpy
            array.

        Examples
        --------
        >>> df = pd.DataFrame(
        ...     {"a": ["red"] * 2 + ["blue"] * 2 + ["black"] * 2, "b": range(6)}
        ... )
        >>> df
               a  b
        0    red  0
        1    red  1
        2   blue  2
        3   blue  3
        4  black  4
        5  black  5

        Select one row at random for each distinct value in column a. The
        `random_state` argument can be used to guarantee reproducibility:

        >>> df.groupby("a").sample(n=1, random_state=1)
               a  b
        4  black  4
        2   blue  2
        1    red  1

        Set `frac` to sample fixed proportions rather than counts:

        >>> df.groupby("a")["b"].sample(frac=0.5, random_state=2)
        5    5
        2    2
        0    0
        Name: b, dtype: int64

        Control sample probabilities within groups by setting weights:

        >>> df.groupby("a").sample(
        ...     n=1,
        ...     weights=[1, 1, 1, 0, 0, 1],
        ...     random_state=1,
        ... )
               a  b
        5  black  5
        2   blue  2
        0    red  0
        r)r�N)r�csg|]}�|�qSr@r@)r|r�)r�r@rAr}&sz"GroupBy.sample.<locals>.<listcomp>c	s(g|] \\}}}|j���|�d��qS))r~r�r�r��random_state)�sample)r|r�rV�w)r�r~r�r�r@rAr}.s)rX)rr�r7r�r�rur�rtr�r�r�rX)	r>r~r�r�r�r�r��wsZsamplesr@)r�r~r�r�r�rAr��
s\
zGroupBy.sample)T)T)T)T)r�)r�)r�)Tr)Trr�r�)Fr�r�r�)Fr�r�r�)Fr�r�r�)Fr�)N)N)N)N)r]r^)T)T)rmTrnFr)r)r)r)r)FTFFFNFFFNN)r�NrN)r�rUNNr)r�)r�)NNFNN)FrGrNrOrPrrrr)rr�_common_see_alsorr�r�r�r*r+r
r1r2r6rr�r�_groupby_agg_method_templater<r@rArBrCrEr0rGrHrJrMrOrSrUrTrWrVrrr
rQrYrjrkrlrsrtr�rxrzryr�r(r�r�r�r��NaNrrr;r`rr7r�r@r@r@rAr��s�B
6
e	

%(*vB:)
** !
Vr�TFzOptional[ops.BaseGrouper])rV�byrXrYrZr[r\r]r^r_r`rmcCsjt|t�rddlm}|}n*t|t�r8ddlm}|}ntd|����|||||||||||	|
|||
d�S)Nr)�
SeriesGroupBy)�DataFrameGroupByzinvalid type: )rVrWrXrbrYrkrlrZr[r\r]r^r_r`)rdr7Zpandas.core.groupby.genericr�r0r�rg)rVr�rXrbrYrkrlrZr[r\r]r^r_r`r�r�r�r@r@rA�get_groupby7s,

r�)
NrNNNNTTTFFFT)prP�
contextlibrrx�	functoolsrrr�r�r�Ztypingrrrrr	r
rrr
rrrrrZnumpyryZpandas._config.configrZpandas._libsrZpandas._libs.groupbyZ_libsr?r}Zpandas._typingrrrrZpandas.compat.numpyrruZ
pandas.errorsrZpandas.util._decoratorsrrrrZpandas.core.dtypes.castrZpandas.core.dtypes.commonr r!r"r#r$r%r&r'Zpandas.core.dtypes.missingr(r)Zpandas.corer*Zpandas.core.algorithms�corerZpandas.core.arraysr+r,Zpandas.core.baser-r.r/Zpandas.core.common�commonr�Zpandas.core.framer0Zpandas.core.genericr1Zpandas.core.groupbyr2r3Zpandas.core.indexes.apir4r5r6Zpandas.core.seriesr7Zpandas.core.sortingr8Zpandas.core.util.numba_r9r��dictrr�rZ_transform_templateZ
_agg_templater<rTrrUrr�r
rr�r@r@r@rA�<module>s�@(
%('6f@
K