a
    DBìj&%  ã                   @  s¸   d dl mZ d dlmZ d dlmZmZmZ d dlZ	d dl
mZmZ d dlmZmZ er€d dlmZ d dlmZmZ d d	lmZ G d
d„ dƒZeejƒG dd„ dƒƒZG dd„ dƒZdS )é    )Úannotations)ÚIterable)ÚTYPE_CHECKINGÚLiteralÚcastN)Úcache_readonlyÚdoc)Ú
is_integerÚis_list_like)ÚPositionalIndexer)Ú	DataFrameÚSeries)Úgroupbyc                   @  s–   e Zd ZdZeddœdd„ƒZdddœd	d
„Zdddœdd„Zdddœdd„Zdddœdd„Z	dddœdd„Z
eddœdd„ƒZeddœdd„ƒZdS )ÚGroupByIndexingMixinz<
    Mixin for adding ._positional_selector to GroupBy.
    ÚGroupByPositionalSelector)Úreturnc                 C  s   t rttj| ƒ}n| }t|ƒS )aÌ
  
        Return positional selection for each group.

        ``groupby._positional_selector[i:j]`` is similar to
        ``groupby.apply(lambda x: x.iloc[i:j])``
        but much faster and preserves the original index and order.

        ``_positional_selector[]`` is compatible with and extends :meth:`~GroupBy.head`
        and :meth:`~GroupBy.tail`. For example:

        - ``head(5)``
        - ``_positional_selector[5:-5]``
        - ``tail(5)``

        together return all the rows.

        Allowed inputs for the index are:

        - An integer valued iterable, e.g. ``range(2, 4)``.
        - A comma separated list of integers and slices, e.g. ``5``, ``2, 4``, ``2:4``.

        The output format is the same as :meth:`~GroupBy.head` and
        :meth:`~GroupBy.tail`, namely
        a subset of the ``DataFrame`` or ``Series`` with the index and order preserved.

        Returns
        -------
        Series
            The filtered subset of the original Series.
        DataFrame
            The filtered subset of the original DataFrame.

        See Also
        --------
        DataFrame.iloc : Purely integer-location based indexing for selection by
            position.
        GroupBy.head : Return first n rows of each group.
        GroupBy.tail : Return last n rows of each group.
        GroupBy.nth : Take the nth row from each group if n is an int, or a
            subset of rows, if n is a list of ints.

        Notes
        -----
        - The slice step cannot be negative.
        - If the index specification results in overlaps, the item is not duplicated.
        - If the index specification changes the order of items, then
          they are returned in their original order.
          By contrast, ``DataFrame.iloc`` can change the row order.
        - ``groupby()`` parameters such as as_index and dropna are ignored.

        The differences between ``_positional_selector[]`` and :meth:`~GroupBy.nth`
        with ``as_index=False`` are:

        - Input to ``_positional_selector`` can include
          one or more slices whereas ``nth``
          just handles an integer or a list of integers.
        - ``_positional_selector`` can  accept a slice relative to the
          last row of each group.
        - ``_positional_selector`` does not have an equivalent to the
          ``nth()`` ``dropna`` parameter.

        Examples
        --------
        >>> df = pd.DataFrame([["a", 1], ["a", 2], ["a", 3], ["b", 4], ["b", 5]],
        ...                   columns=["A", "B"])
        >>> df.groupby("A")._positional_selector[1:2]
           A  B
        1  a  2
        4  b  5

        >>> df.groupby("A")._positional_selector[1, -1]
           A  B
        1  a  2
        2  a  3
        4  b  5
        )r   r   r   ÚGroupByr   ©ÚselfZgroupby_self© r   ú[/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/pandas/core/groupby/indexing.pyÚ_positional_selector%   s    Nz)GroupByIndexingMixin._positional_selectorúPositionalIndexer | tuplez
np.ndarray©Úargr   c                 C  s¼   t |ƒrHtdd„ tt|ƒD ƒƒr6|  ttt |ƒ¡}qŒ|  tt|ƒ¡}nDt|t	ƒr^|  
|¡}n.t|ƒrx|  tt|ƒ¡}ntdt|ƒ› d�ƒ‚t|tƒr°|r¦| jdk}n
| jdk }ttj|ƒS )Nc                 s  s   | ]}t |ƒV  qd S ©N)r	   )Ú.0Úir   r   r   Ú	<genexpr>€   ó    zJGroupByIndexingMixin._make_mask_from_positional_indexer.<locals>.<genexpr>zInvalid index zE. Must be integer, list-like, slice or a tuple of integers and slicesr   )r
   Úallr   r   Ú_make_mask_from_listÚintÚ_make_mask_from_tupleÚtupleÚ
isinstanceÚsliceÚ_make_mask_from_slicer	   Ú_make_mask_from_intÚ	TypeErrorÚtypeÚboolÚ_ascending_countÚnpZndarray©r   r   Úmaskr   r   r   Ú"_make_mask_from_positional_indexer{   s     
ÿ

z7GroupByIndexingMixin._make_mask_from_positional_indexerr"   c                 C  s&   |dkr| j |kS | j| d kS d S )Nr   é   )r,   Ú_descending_count)r   r   r   r   r   r(   ˜   s    
z(GroupByIndexingMixin._make_mask_from_intzIterable[int]zbool | np.ndarray)Úargsr   c                 C  sP   dd„ |D ƒ}dd„ |D ƒ}d}|r6|t  | j|¡O }|rL|t  | j|¡O }|S )Nc                 S  s   g | ]}|d kr|‘qS )r   r   ©r   r   r   r   r   Ú
<listcomp>Ÿ   r   z=GroupByIndexingMixin._make_mask_from_list.<locals>.<listcomp>c                 S  s   g | ]}|d k r| d ‘qS )r   r1   r   r4   r   r   r   r5       r   F)r-   Úisinr,   r2   )r   r3   ZpositiveÚnegativer/   r   r   r   r!   ž   s    z)GroupByIndexingMixin._make_mask_from_listr$   c                 C  s^   d}|D ]P}t |ƒr*||  tt|ƒ¡O }qt|tƒrD||  |¡O }qtdt|ƒ› d�ƒ‚q|S )NFzInvalid argument z. Should be int or slice.)	r	   r(   r   r"   r%   r&   r'   Ú
ValueErrorr*   )r   r3   r/   r   r   r   r   r#   ¬   s    
ÿz*GroupByIndexingMixin._make_mask_from_tupler&   c                 C  s*  |j }|j}|j}|d ur2|dk r2td|› d�ƒ‚d}|d u rBd}|d u rf|dkrò|| j| dkM }nŒ|dkrœ|| j|kM }|dkrò|| j| | dkM }nV|| j| k M }| j| d }| j| j |d  dk }t || j|¡}||| dkM }|d u�r&|dk�r|| j|k M }n|| j| kM }|S )Nr   zInvalid step z. Must be non-negativeTr1   )ÚstartÚstopÚstepr8   r,   r2   r-   Úwhere)r   r   r9   r:   r;   r/   Zoffset_arrayZlimit_arrayr   r   r   r'   »   s6    þ

z*GroupByIndexingMixin._make_mask_from_slicec                 C  s   t rttj| ƒ}n| }| ¡ S r   ©r   r   r   r   Z_cumcount_arrayr   r   r   r   r,   å   s    z%GroupByIndexingMixin._ascending_countc                 C  s"   t rttj| ƒ}n| }|jdd�S )NF)Z	ascendingr=   r   r   r   r   r2   î   s    z&GroupByIndexingMixin._descending_countN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r   r0   r(   r!   r#   r'   r,   r2   r   r   r   r   r       s   U*r   c                   @  s,   e Zd Zdddœdd„Zdddœd	d
„ZdS )r   úgroupby.GroupByÚNone©Úgroupby_objectr   c                 C  s
   || _ d S r   ©rE   ©r   rE   r   r   r   Ú__init__ú   s    z"GroupByPositionalSelector.__init__r   úDataFrame | Seriesr   c                 C  s   | j  |¡}| j  |¡S )a  
        Select by positional index per group.

        Implements GroupBy._positional_selector

        Parameters
        ----------
        arg : PositionalIndexer | tuple
            Allowed values are:
            - int
            - int valued iterable such as list or range
            - slice with step either None or positive
            - tuple of integers and slices

        Returns
        -------
        Series
            The filtered subset of the original groupby Series.
        DataFrame
            The filtered subset of the original groupby DataFrame.

        See Also
        --------
        DataFrame.iloc : Integer-location based indexing for selection by position.
        GroupBy.head : Return first n rows of each group.
        GroupBy.tail : Return last n rows of each group.
        GroupBy._positional_selector : Return positional selection for each group.
        GroupBy.nth : Take the nth row from each group if n is an int, or a
            subset of rows, if n is a list of ints.
        )rE   r0   Z_mask_selected_objr.   r   r   r   Ú__getitem__ý   s    z%GroupByPositionalSelector.__getitem__N)r>   r?   r@   rH   rJ   r   r   r   r   r   ø   s   r   c                   @  sD   e Zd ZdZdddœdd„Zddd	d
dœdd„Zdd
dœdd„ZdS )ÚGroupByNthSelectorzO
    Dynamically substituted for GroupBy.nth to enable both call and index
    rB   rC   rD   c                 C  s
   || _ d S r   rF   rG   r   r   r   rH   %  s    zGroupByNthSelector.__init__Nr   zLiteral['any', 'all', None]rI   )ÚnÚdropnar   c                 C  s   | j  ||¡S r   ©rE   Z_nth)r   rL   rM   r   r   r   Ú__call__(  s    zGroupByNthSelector.__call__)rL   r   c                 C  s   | j  |¡S r   rN   )r   rL   r   r   r   rJ   /  s    zGroupByNthSelector.__getitem__)N)r>   r?   r@   rA   rH   rO   rJ   r   r   r   r   rK      s
    ýrK   )Ú
__future__r   Úcollections.abcr   Útypingr   r   r   Únumpyr-   Zpandas.util._decoratorsr   r   Zpandas.core.dtypes.commonr	   r
   Zpandas._typingr   Zpandasr   r   Zpandas.core.groupbyr   r   r   r   rK   r   r   r   r   Ú<module>   s    Y'