Sindbad~EG File Manager
�
Mٜg&% � �� � d dl mZ d dlmZ d dlmZmZmZ d dlZ d dl
m Z m Z d dl
mZmZ erd dlmZ d dlmZmZ d d lmZ G d
� d � Z e ej0 � G d � d
� � Z G d� d� Zy)� )� annotations)�Iterable)�
TYPE_CHECKING�Literal�castN)�cache_readonly�doc)�
is_integer� is_list_like)�PositionalIndexer)� DataFrame�Series)�groupbyc �v � e Zd ZdZed d�� Z d d�Zd
d�Zdd�Zdd�Z dd�Z
edd�� Z edd �� Z y
)�GroupByIndexingMixinz<
Mixin for adding ._positional_selector to GroupBy.
c �r � t r%t t j | � }t |� S | }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 �GroupBy�GroupByPositionalSelector��self� groupby_selfs �G/usr/local/lib/python3.12/site-packages/pandas/core/groupby/indexing.py�_positional_selectorz)GroupByIndexingMixin._positional_selector% s7 � �\ � �����6�L� )� �6�6� �L�(� �6�6� c �F � t |� rgt d� t t |� D � � r'| j t t t
|� � }n�| j
t t |� � }net |t � r| j |� }nCt |� r | j t t
|� � }nt dt |� � d�� �t |t � r!|r| j dk\ }n| j dk }t t" j$ |� S )Nc 3 �2 K � | ] }t |� �� � y �w�N)r
)�.0�is r � <genexpr>zJGroupByIndexingMixin._make_mask_from_positional_indexer.<locals>.<genexpr>� s � �� �>�*=�Q�:�a�=�*=�s �zInvalid 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�np�ndarray�r �arg�masks r �"_make_mask_from_positional_indexerz7GroupByIndexingMixin._make_mask_from_positional_indexer{ s� � � �� ��>�$�x��*=�>�>��0�0��h�s�m�S�1I�J���1�1�$�u�c�2B�C��
��U�
#��-�-�c�2�D�
��_��+�+�D��c�N�;�D�� ��c�� � ,&� &��
� �d�D� !���,�,��1���,�,�q�0���B�J�J��%�%r c �P � |dk\ r| j |k( S | j | dz
k( S )Nr � )r- �_descending_count)r r1 s r r) z(GroupByIndexingMixin._make_mask_from_int� s1 � � �!�8��(�(�C�/� /��)�)�s�d�Q�h�7� 7r c � � |D �cg c]
}|dk\ s� |�� }}|D �cg c] }|dk s� | dz
�� }}d}|r#|t j | j |� z }|r#|t j | j |� z }|S c c}w c c}w )Nr r5 F)r. �isinr- r6 )r �argsr1 �positive�negativer2 s r r" z)GroupByIndexingMixin._make_mask_from_list� s� � �#'�4�4�C�3�!�8�C�4��4�(,�8����a��S�D�1�H���8�"'�� � �B�G�G�D� 1� 1�8�<� <�D� � �B�G�G�D� 2� 2�H�=� =�D�� �� 5��8s �
A=�A=�
B�Bc �� � d}|D ]l }t |� r#|| j t t |� � z }�1t |t
� r|| j
|� z }�Vt dt |� � d�� � |S )NFzInvalid argument z. Should be int or slice.) r
r) r r# r& r' r( �
ValueErrorr+ )r r9 r2 r1 s r r$ z*GroupByIndexingMixin._make_mask_from_tuple� sw � �"'���C��#����0�0��c�3� �@�@���C��'���2�2�3�7�7�� �'��S� �{�2K�L�� �
� � r c �l � |j }|j }|j }|�|dk rt d|� d�� �d}|�d}|�|dkD r�|| j |z dk( z }n�|dk\ r0|| j |k\ z }|dkD r�|| j |z
|z dk( z }ns|| j
| k z }| j
|z dz }| j | j
z |dz z dk }t
j || j |� }|||z dk( z }|�,|dk\ r|| j |k z }|S || j
| k\ z }|S )Nr z
Invalid step z. Must be non-negativeTr5 )�start�stop�stepr= r- r6 r. �where)r r1 r? r@ rA r2 � offset_array� limit_arrays r r( z*GroupByIndexingMixin._make_mask_from_slice� s � �� � ���x�x���x�x�� � ��q�� �}�T�F�2H� I�J� J�"&�� �<��D� �=��a�x���-�-��4��9�9��
�a�Z� �D�)�)�U�2� 2�D��a�x���.�.��6�$�>�!�C�C��
�D�*�*�e�V�3� 3�D� �1�1�E�9�A�=�L��%�%��(>�(>�>�%�!�)�L���K� �8�8�K��1F�1F� �U�L� �L�4�'�1�,� ,�D� � ��q�y���-�-��4�4�� � � ��.�.�4�%�7�7��� r c � � t r*t t j | � }|j � S | }|j � S r �r r r r �_cumcount_arrayr s r r- z%GroupByIndexingMixin._ascending_count� s< � � � �����6�L� �+�+�-�-� �L��+�+�-�-r c �l � t rt t j | � }n| }|j d�� S )NF)� ascendingrF r s r r6 z&GroupByIndexingMixin._descending_count� s. � � � �����6�L� �L��+�+�e�+�<�<r N)�returnr )r1 �PositionalIndexer | tuplerJ �
np.ndarray)r1 r# rJ rL )r9 z
Iterable[int]rJ �bool | np.ndarray)r9 r% rJ rM )r1 r' rJ rM )rJ rL )
�__name__�
__module__� __qualname__�__doc__r r r3 r) r" r$ r( r- r6 � r r r r sr � �� �S7� �S7�j&�
&�&�
�&�:8� �
� (�T �.� �.� �=� �=r r c � � e Zd Zdd�Zdd�Zy)r c � � || _ y r ��groupby_object�r rV s r �__init__z"GroupByPositionalSelector.__init__� �
� � ,��r c �n � | j j |� }| 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.
)rV r3 �_mask_selected_objr0 s r � __getitem__z%GroupByPositionalSelector.__getitem__� s1 � �> �"�"�E�E�c�J���"�"�5�5�d�;�;r N�rV zgroupby.GroupByrJ �None)r1 rK rJ �DataFrame | Series)rN rO rP rX r\ rR r r r r � s � �-� <r r c �6 � e Zd ZdZdd�Z d dd�Zd d�Zy)
�GroupByNthSelectorzO
Dynamically substituted for GroupBy.nth to enable both call and index
c � � || _ y r rU rW s r rX zGroupByNthSelector.__init__% rY r Nc �: � | j j ||� S r �rV �_nth)r �n�dropnas r �__call__zGroupByNthSelector.__call__( s � �
�"�"�'�'��6�2�2r c �8 � | j j |� S r rd )r rf s r r\ z GroupByNthSelector.__getitem__/ s � ��"�"�'�'��*�*r r] r )rf rK rg zLiteral['any', 'all', None]rJ r_ )rf rK rJ r_ )rN rO rP rQ rX rh r\ rR r r ra ra s7 � ��-� /3�3� $�3� ,�3�
� 3�+r ra )�
__future__r �collections.abcr �typingr r r �numpyr. �pandas.util._decoratorsr r �pandas.core.dtypes.commonr
r �pandas._typingr �pandasr
r �pandas.core.groupbyr r r r ra rR r r �<module>rs ss �� "� $�� � ��
�
�0�� ,�U=� U=�p ��.�.�/�$<� $<� 0�$<�N+� +r
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists