Sindbad~EG File Manager

Current Path : /usr/local/lib/python3.12/site-packages/pandas/core/indexers/__pycache__/
Upload File :
Current File : //usr/local/lib/python3.12/site-packages/pandas/core/indexers/__pycache__/objects.cpython-312.pyc

�

Mٜg�9��"�dZddlmZddlmZddlZddlmZddl	m
Z
ddlmZddl
mZdd	lmZdd
lmZdZGd�d
�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�Zy)zLIndexer objects for computing start/end window bounds for rolling operations�)�annotations)�	timedeltaN)�
BaseOffset)� calculate_variable_window_bounds)�Appender)�ensure_platform_int)�
DatetimeIndex)�Nanoa�
Computes the bounds of a window.

Parameters
----------
num_values : int, default 0
    number of values that will be aggregated over
window_size : int, default 0
    the number of rows in a window
min_periods : int, default None
    min_periods passed from the top level rolling API
center : bool, default None
    center passed from the top level rolling API
closed : str, default None
    closed passed from the top level rolling API
step : int, default None
    step passed from the top level rolling API
    .. versionadded:: 1.5
win_type : str, default None
    win_type passed from the top level rolling API

Returns
-------
A tuple of ndarray[int64]s, indicating the boundaries of each
window
c�f�eZdZdZ	d					dd�Zee�					d											dd��Zy)	�BaseIndexera�
    Base class for window bounds calculations.

    Examples
    --------
    >>> from pandas.api.indexers import BaseIndexer
    >>> class CustomIndexer(BaseIndexer):
    ...     def get_window_bounds(self, num_values, min_periods, center, closed, step):
    ...         start = np.empty(num_values, dtype=np.int64)
    ...         end = np.empty(num_values, dtype=np.int64)
    ...         for i in range(num_values):
    ...             start[i] = i
    ...             end[i] = i + self.window_size
    ...         return start, end
    >>> df = pd.DataFrame({"values": range(5)})
    >>> indexer = CustomIndexer(window_size=2)
    >>> df.rolling(indexer).sum()
        values
    0	1.0
    1	3.0
    2	5.0
    3	7.0
    4	4.0
    Nc�j�||_||_|j�D]\}}t|||��y�N)�index_array�window_size�items�setattr)�selfrr�kwargs�key�values      �G/usr/local/lib/python3.12/site-packages/pandas/core/indexers/objects.py�__init__zBaseIndexer.__init__Hs4��'���&��� �,�,�.�J�C���D�#�u�%�)�c��t�r)�NotImplementedError�r�
num_values�min_periods�center�closed�steps      r�get_window_boundszBaseIndexer.get_window_boundsQs
��"�!r)Nr)r�np.ndarray | Noner�int�return�None�rNNNN�rr$r�
int | Nonerzbool | Noner z
str | Noner!r)r%ztuple[np.ndarray, np.ndarray])�__name__�
__module__�__qualname__�__doc__rr�get_window_bounds_docr"�rrrr.s����4IJ�&�,�&�BE�&�	
�&��#�$��"&�"�!��
"��"� �"��	"�
�"��
"�
'�"�%�"rrc�P�eZdZdZee�					d											dd��Zy)�FixedWindowIndexerz3Creates window boundaries that are of fixed length.Nc�8�|s|jdk(r|jdz
dz}nd}tjd|z|dz|z|d��}||jz
}|dvr|dz}|dvr|dz}tj|d|�}tj|d|�}||fS)Nr���int64��dtype��left�both)r9�neither)r�np�arange�clip)	rrrrr r!�offset�end�starts	         rr"z$FixedWindowIndexer.get_window_bounds`s����T�%�%��*��&�&��*�q�0�F��F��i�i��F�
�J��N�V�$;�T��Q���d�&�&�&���%�%��Q�J�E��(�(��1�H�C��g�g�c�1�j�)������q�*�-���c�z�rr'r(�r*r+r,r-rr.r"r/rrr1r1]sh��=�
�#�$��"&�"�!��
��� ���	�
���
�
'��%�rr1c�P�eZdZdZee�					d											dd��Zy)�VariableWindowIndexerzNCreates window boundaries that are of variable length, namely for time series.Nc�J�t||j||||j�Sr)rrrrs      rr"z'VariableWindowIndexer.get_window_bounds~s/��0�����������

�	
rr'r(rBr/rrrDrD{sh��X�
�#�$��"&�"�!��

��
� �
��	
�
�
��

�
'�
�%�
rrDc���eZdZdZ				d									d�fd�
Zee�					d											dd��Z�xZS)�VariableOffsetWindowIndexeraP
    Calculate window boundaries based on a non-fixed offset such as a BusinessDay.

    Examples
    --------
    >>> from pandas.api.indexers import VariableOffsetWindowIndexer
    >>> df = pd.DataFrame(range(10), index=pd.date_range("2020", periods=10))
    >>> offset = pd.offsets.BDay(1)
    >>> indexer = VariableOffsetWindowIndexer(index=df.index, offset=offset)
    >>> df
                0
    2020-01-01  0
    2020-01-02  1
    2020-01-03  2
    2020-01-04  3
    2020-01-05  4
    2020-01-06  5
    2020-01-07  6
    2020-01-08  7
    2020-01-09  8
    2020-01-10  9
    >>> df.rolling(indexer).sum()
                   0
    2020-01-01   0.0
    2020-01-02   1.0
    2020-01-03   2.0
    2020-01-04   3.0
    2020-01-05   7.0
    2020-01-06  12.0
    2020-01-07   6.0
    2020-01-08   7.0
    2020-01-09   8.0
    2020-01-10   9.0
    c���t�|�||fi|��t|t�st	d��||_t|t�st	d��||_y)Nzindex must be a DatetimeIndex.z(offset must be a DateOffset-like object.)�superr�
isinstancer	�
ValueError�indexrr?)rrrrLr?r�	__class__s      �rrz$VariableOffsetWindowIndexer.__init__�sS���	����k�<�V�<��%��/��=�>�>���
��&�*�-��G�H�H���rc��|�td��|dkr.tjdd��tjdd��fS|�|j�dnd}|dv}|dv}|j|d	z
|jdkrd
}nd	}||jz}	tj|d��}
|
jd
�tj|d��}|jd
�d|
d<|rd	|d<nd|d<t
d�}td	|�D]�}
|j|
}||	z
}|r|td	�z}|
|
|
<t|
|
d	z
|
�D]#}|j||z
|z}||kDs�||
|
<n|j||
d	z
|z
|z}||k(r|s||
d	z
d	z||
<n||kr	|
d	z||
<n||
d	z
||
<|r��||
xxd	zcc<��|
|fS)Nz/step not implemented for variable offset windowrr5r6�rightr:)rOr:r8r3���)	rr<�emptyrLr?�fillr�ranger
)rrrrr r!�right_closed�left_closed�index_growth_sign�offset_diffrAr@�zero�i�	end_bound�start_bound�j�
start_diff�end_diffs                   rr"z-VariableOffsetWindowIndexer.get_window_bounds�s����%�&W�X�X���?��8�8�A�W�-�r�x�x���/I�I�I��>� $�
�
� 6�W�F�F��!2�2��� 0�0���:�:�j�1�n�%��
�
�1�
�5� "�� !��'�$�+�+�5������7�3��
�
�
�2���h�h�z��1���������a����C��F��C��F���|���q�*�%�A��
�
�1�
�I�#�k�1�K���t�A�w�&���E�!�H��5��Q��<��+��"�j�j��m�k�9�=N�N�
���$� �E�!�H��	,��
�
�3�q�1�u�:�.��:�>O�O�H��4����Q��U��a���A���T�!��Q���A���Q��U���A�� ��A��!���;&�>�c�z�r)NrNN)
rr#rr$rLzDatetimeIndex | Noner?zBaseOffset | Noner%r&r'r()	r*r+r,r-rrr.r"�
__classcell__�rMs@rrGrG�s����!�J*.��&*�$(��&����$�	�
"��
�� �#�$��"&�"�!��
J��J� �J��	J�
�J��
J�
'�J�%�JrrGc�P�eZdZdZee�					d											dd��Zy)�ExpandingIndexerz;Calculate expanding window bounds, mimicking df.expanding()Nc��tj|tj��tjd|dztj��fS)Nr6r3)r<�zerosr5r=rs      rr"z"ExpandingIndexer.get_window_boundss8��
�H�H�Z�r�x�x�0��I�I�a��a��r�x�x�8�
�	
rr'r(rBr/rrrbrbsh��E�
�#�$��"&�"�!��

��
� �
��	
�
�
��

�
'�
�%�
rrbc�P�eZdZdZee�					d											dd��Zy)�FixedForwardWindowIndexera�
    Creates window boundaries for fixed-length windows that include the current row.

    Examples
    --------
    >>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]})
    >>> df
         B
    0  0.0
    1  1.0
    2  2.0
    3  NaN
    4  4.0

    >>> indexer = pd.api.indexers.FixedForwardWindowIndexer(window_size=2)
    >>> df.rolling(window=indexer, min_periods=1).sum()
         B
    0  1.0
    1  3.0
    2  2.0
    3  4.0
    4  4.0
    Nc���|rtd��|�td��|�d}tjd||d��}||jz}|jrtj|d|�}||fS)Nz.Forward-looking windows can't have center=TruezAForward-looking windows don't support setting the closed argumentr3rr5r6)rKr<r=rr>)rrrrr r!rAr@s        rr"z+FixedForwardWindowIndexer.get_window_boundsBs~����M�N�N����S��
��<��D��	�	�!�Z��W�=���d�&�&�&������'�'�#�q�*�-�C��c�z�rr'r(rBr/rrrfrf)sl���0�#�$��"&�"�!��
��� ���	�
���
�
'��%�rrfc���eZdZdZdddedf											d�fd�
Zee�					d											dd��Z�xZ	S)	�GroupbyIndexerzMCalculate bounds to compute groupby rolling, mimicking df.groupby().rolling()Nrc���|xsi|_||_|r|j�ni|_t	�|�d||jj
d|�d�|��y)a4
        Parameters
        ----------
        index_array : np.ndarray or None
            np.ndarray of the index of the original object that we are performing
            a chained groupby operation over. This index has been pre-sorted relative to
            the groups
        window_size : int or BaseIndexer
            window size during the windowing operation
        groupby_indices : dict or None
            dict of {group label: [positional index of rows belonging to the group]}
        window_indexer : BaseIndexer
            BaseIndexer class determining the start and end bounds of each group
        indexer_kwargs : dict or None
            Custom kwargs to be passed to window_indexer
        **kwargs :
            keyword arguments that will be available when get_window_bounds is called
        r�rrNr/)�groupby_indices�window_indexer�copy�indexer_kwargsrIr�pop)rrrrlrmrorrMs       �rrzGroupbyIndexer.__init___sd���6 /�4�"���,���7E�n�1�1�3�2���
���	
�#��+�+�/�/�
�{�K�	
��	
rc��g}g}d}|jj�D�]�\}	}
|j�%|jjt	|
��}n|j}|j
d	||jd�|j��}|jt|
�||||�\}
}|
jtj�}
|jtj�}t|
�t|�k(sJd��tj||t|
�z�}|t|
�z
}tj||ddzg�jtjd��}|j|jt	|
���|j|jt	|������t|�dk(rJtjgtj��tjgtj��fStj |�}
tj |�}|
|fS)
Nrrkz6these should be equal in length from get_window_boundsrPr3F)rnr6r/)rlrr�takerrmrror"�len�astyper<r5r=�append�array�concatenate)rrrrr r!�start_arrays�
end_arrays�window_indices_startr�indicesr�indexerrAr@�window_indicess                rr"z GroupbyIndexer.get_window_bounds�s�����
� �� �0�0�6�6�8�L�C�����+�"�.�.�3�3�4G��4P�Q��"�.�.��)�d�)�)��'� �,�,���%�%��G�
!�2�2��G��k�6�6�4��J�E�3��L�L����*�E��*�*�R�X�X�&�C��u�:���"��
H�G�
H��
 �Y�Y�$�&:�S��\�&I��N�
!�C��L�0� ��Y�Y�~��r�8J�Q�8N�7O�P�W�W����u�X��N�
���� 3� 3�4G��4N� O�P����n�1�1�2E�c�2J�K�L�?9�@�|���!��8�8�B�b�h�h�/����"�B�H�H�1M�M�M����|�,���n�n�Z�(���c�z�r)rr#rzint | BaseIndexerrl�dict | Nonermztype[BaseIndexer]ror~r%r&r'r()
r*r+r,r-rrrr.r"r_r`s@rriri\s����W�*.�)*�'+�,7�&*�
"
�&�"
�'�"
�%�	"
�
*�"
�$�
"
�
�"
�H�#�$��"&�"�!��
2��2� �2��	2�
�2��
2�
'�2�%�2rric�P�eZdZdZee�					d											dd��Zy)�ExponentialMovingWindowIndexerz/Calculate ewm window bounds (the entire window)Nc��tjdgtj��tj|gtj��fS)Nrr6)r<rvr5rs      rr"z0ExponentialMovingWindowIndexer.get_window_bounds�s1���x�x���2�8�8�,�b�h�h�
�|�2�8�8�.T�T�Trr'r(rBr/rrr�r��sp��9�
�#�$��"&�"�!��
U��U� �U��	U�
�U��
U�
'�U�%�Urr�)r-�
__future__r�datetimer�numpyr<�pandas._libs.tslibsr�pandas._libs.window.indexersr�pandas.util._decoratorsr�pandas.core.dtypes.commonr�pandas.core.indexes.datetimesr	�pandas.tseries.offsetsr
r.rr1rDrGrbrfrir�r/rr�<module>r�s���R�"���*�I�,�9�7�'���8,"�,"�^���<
�K�
�4�+��D
�{�
�$0��0�fZ�[�Z�zU�[�Ur

Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists