HOME


sh-3ll 1.0
DIR:/opt/cloudlinux/venv/lib/python3.11/site-packages/xarray/core/__pycache__/
Upload File :
Current File : //opt/cloudlinux/venv/lib/python3.11/site-packages/xarray/core/__pycache__/indexing.cpython-311.pyc
�

���hh=��Z�ddlmZddlZddlZddlmZddlm	Z	m
Z
mZmZddlm
Z
d�Zd�Zd	�Zd
�Zd�Zd�Z		dd�Zdd�Zd�Zd�ZGd�dej��ZGd�dej��Zd�ZGd�dej��ZGd�dej��ZGd�dej��ZdS)�)�	timedeltaN�)�utils)�	iteritems�range�dask_array_type�suppress��
is_full_slicec��t|t��s|f}g}d}|D]�}|tura|s<|�|dzt	|��z
td��gz��d}�I|�td�����l|�|����t	|��|krtd���|�|t	|��z
td��gz��t|��S)aMGiven a key for indexing an ndarray, return an equivalent key which is a
    tuple with length equal to the number of dimensions.

    The expansion is done by replacing all `Ellipsis` items with the right
    number of full slices and then padding the key with full slices so that it
    reaches the appropriate dimensionality.
    FrNTztoo many indices)�
isinstance�tuple�Ellipsis�extend�len�slice�append�
IndexError)�key�ndim�new_key�found_ellipsis�ks     �I/opt/cloudlinux/venv/lib/python3.11/site-packages/xarray/core/indexing.py�expanded_indexerr
s���c�5�!�!���f���G��N�
������=�=�!�
,�����q��3�s�8�8� 3��d���}�D�E�E�E�!%������u�T�{�{�+�+�+�+��N�N�1�����
�7�|�|�d����+�,�,�,��N�N�D�3�w�<�<�'�E�$�K�K�=�8�9�9�9���>�>��c�\��d��t�fd�t||��D����S)z�Given an indexer for orthogonal array indexing, return an indexer that
    is a tuple composed entirely of slices, integer ndarrays and native python
    ints.
    c�x�t|t��s�tj|��}|jdkr"ttj|����}nc|jdkrtd���|jj	dkrtj
|��\}n"|jj	dkrtd|z���|S)Nrrz1orthogonal array indexing only supports 1d arrays�b�iz}invalid subkey %r for integer based array indexing; all subkeys must be slices, integers or sequences of integers or Booleans)r
r�np�asarrayr�int�asscalar�
ValueError�dtype�kind�nonzero)�indexers r�canonicalizez*canonicalize_indexer.<locals>.canonicalize-s����'�5�)�)�	G��j��)�)�G��|�q� � ��b�k�'�2�2�3�3����<�1�$�$�$�&1�2�2�2��=�%��,�,�!�z�'�2�2�H�G�G��]�'�3�.�.�$�&<�?F�&F�G�G�G��rc3�.�K�|]}�|��V��dS�N�)�.0rr*s  �r�	<genexpr>z'canonicalize_indexer.<locals>.<genexpr>?s+�����F�F�Q���a���F�F�F�F�F�Fr)rr)rrr*s  @r�canonicalize_indexerr0(sB���
���$�F�F�F�F�*:�3��*E�*E�F�F�F�F�F�Frc�D�tj|�|���Sr,)r!�arange�indices)�slice_�sizes  r�
_expand_slicer6Bs��
�9�f�n�n�T�*�*�+�+rc�N�����tt�t��������d�t���D��}��fd���|��}d��t	j���fd�|D���}t|��D]\}}||�|<�t
���S)z�Given a key for orthogonal array indexing, returns an equivalent key
    suitable for indexing a numpy.ndarray with fancy indexing.
    c�Z�g|](\}}t|ttjf���&|��)Sr-)r
r#r!�integer)r.�nrs   r�
<listcomp>z&orthogonal_indexer.<locals>.<listcomp>Ps2��Y�Y�Y�$�!�Q�
�1�s�B�J�FW�8X�8X�Y�A�Y�Y�Yrc����fd�}|s|S|t|ddz����r�|dd���S|t|dt�������r�|dd���S|S)Nc�:��t�fd�|D����S)Nc3�B�K�|]}t�|��V��dSr,r
)r.r:rs  �rr/z^orthogonal_indexer.<locals>.full_slices_unselected.<locals>.all_full_slices.<locals>.<genexpr>Ts/�����@�@��}�S��V�,�,�@�@�@�@�@�@r)�all)�	key_indexrs �r�all_full_sliceszKorthogonal_indexer.<locals>.full_slices_unselected.<locals>.all_full_slicesSs&����@�@�@�@�i�@�@�@�@�@�@rrr���)rr)�n_listrA�full_slices_unselectedrs  ��rrDz2orthogonal_indexer.<locals>.full_slices_unselectedRs����	A�	A�	A�	A�	A��	��M�
�_�U�6�!�9�q�=�1�1�
2�
2�	�)�)�&����*�5�5�5�
�_�U�6�"�:�s�3�x�x�8�8�
9�
9�	�)�)�&��"��+�6�6�6��Mrc�P�t|t��rt||��n|Sr,)r
rr6)r�lengths  r�maybe_expand_slicez.orthogonal_indexer.<locals>.maybe_expand_slicegs&��+5�a��+?�+?�F�}�Q��'�'�'�Q�Frc3�H�K�|]}��|�|��V��dSr,r-)r.r:rrG�shapes  ���rr/z%orthogonal_indexer.<locals>.<genexpr>jsL�����3�3�"#�1�0��Q���q��B�B�3�3�3�3�3�3r)�listr0r�	enumerater!�ix_r)	rrI�non_int_keys�
array_keys�array_indexersr r:rDrGs	``     @@r�orthogonal_indexerrPFs�������
�#�C��U���4�4�
5�
5�C�
Z�Y�)�C�.�.�Y�Y�Y�L�
�
�
�
�
�
�&(�'��5�5�J�G�G�G��V�3�3�3�3�3�3�'1�3�3�3�4�N��*�%�%�#�#���1���"��A�����:�:�rc�P�	|���S#t$r|cYSwxYwr,)�item�AttributeError)�xs r�
_try_get_itemrUqs8����v�v�x�x��������������s��%�%c��t|t��rtj|��}nNt	j|��}|jdkr/t	jt|��t���}||dd�<|S)z�
    Convert values into a numpy array of at most 1-dimension, while preserving
    tuples.

    Adapted from pandas.core.common._asarray_tuplesafe
    ��r&N)
r
rr�tuple_to_0darrayr!r"r�emptyr�object)�values�results  r�_asarray_tuplesafer^xsp���&�%� � ���'��/�/�����F�#�#���;�!����X�c�&�k�k��8�8�8�F��F�1�1�1�I��Mr�c���i}|�||d<|�$tjdkrtd���||d<t|t��r�|�|�td���|�t
|j��t
|j��t
|j	����}t|t��std���n�t|��}|jdkr!|j
|���fi|��}n_|jjd	krt#j|��\}n8|j|fi|��}t#j|dk��rtd
|z���|S)z�Given a pandas.Index and labels (e.g., from __getitem__) for one
    dimension, return an indexer suitable for indexing an ndarray along that
    dimension
    N�methodz0.17z5the tolerance argument requires pandas v0.17 or newer�	tolerancez@cannot use ``method`` argument if any indexers are slice objectsz�cannot represent labeled-based slice indexer for dimension %r with a slice over integer positions; the index is unsorted or non-uniquerrz not all values found in index %r)�pd�__version__�NotImplementedErrorr
r�
slice_indexerrU�start�stop�step�KeyErrorr^r�get_locrRr&r'r!r(�get_indexer�any)�index�label�
index_namerarb�kwargsr)s       r�convert_label_indexerrr�s����F�
��!��x����
�>�F�"�"�%�G�I�I�
I�'��{���%����-����!6�%� �!�!�
!��%�%�m�E�K�&@�&@�&3�E�J�&?�&?�&3�E�J�&?�&?�A�A���'�5�)�)�	B��A�B�B�
B�	B�#�5�)�)���:��?�?�#�e�m�E�J�J�L�L�;�;�F�;�;�G�G�
�[�
��
$�
$��z�%�(�(�H�G�G�'�e�'��8�8��8�8�G��v�g��k�"�"�
-��A�!+� ,�-�-�-��Nrc�������$t�t��std���t���fd�t	|��D����S)zvGiven an xarray data object and label based indexers, return a mapping
    of equivalent location based indexers.
    Nz``method`` must be a stringc	3�x�K�|]4\}}|t�|���||����fV��5dSr,)rr�to_index)r.�dimro�data_objrarbs   ���rr/z'remap_label_indexers.<locals>.<genexpr>�sk�����7�7��C���+�H�S�M�,B�,B�,D�,D�e�,/���D�D�E�7�7�7�7�7�7r)r
�str�	TypeError�dictr)rw�indexersrarbs` ``r�remap_label_indexersr|�su�������*�V�S�"9�"9���5�6�6�6��7�7�7�7�7�7�"+�H�"5�"5�7�7�7�7�7�7rc���|jpd|jpdz}t||��|}t|��dkr|d}|d|z}|dkrd}nd}d}t|||��S)z�Given a slice and the size of the dimension to which it will be applied,
    index it with another slice to return a new slice equivalent to applying
    the slices sequentially
    rrrBN)rir6rr)�	old_slice�
applied_slicer5ri�itemsrgrhs       r�slice_slicer��s���

�N��a�M�$6�$;�!�<�D�

�)�T�*�*�=�9�E�
�5�z�z�A�~�~��a����R�y�4����!�8�8��D���������d�#�#�#rc�x�t|ttjttjf��sJ�t|t��r|t	d��kr|St|t��r>t|t��rt
|||��}nt||��|}n||}|Sr,)r
r#r!r9r�ndarrayr�r6)�old_indexer�applied_indexerr5r)s    r�_index_indexer_1dr��s����o��R�Z���
�'K�L�L�L�L�L��/�5�)�)��o��t���.L�.L����+�u�%�%�/��o�u�-�-�	H�!�+���E�E�G�G�#�K��6�6��G�G�G��o�.���Nrc��eZdZd�Zed���Zed���Zed���Zed���Zd�Z	d
d�Z
d	�ZdS)�LazyIntegerRangec�Z�||_||_d|jvsJ�t|i|��|_dS)zE
        Parameters
        ----------
        See np.arange
        r&N)�args�kwdargsr�array)�selfr�r�s   r�__init__zLazyIntegerRange.__init__�s=����	�����d�l�*�*�*�*��D�,�G�,�,��
�
�
rc�,�t|j��fSr,�rr��r�s rrIzLazyIntegerRange.shape�s���D�J���!�!rc�*�tjd��S)N�int64)r!r&r�s rr&zLazyIntegerRange.dtype�s���x�� � � rc��dS)Nrr-r�s rrzLazyIntegerRange.ndim�s���qrc�*�t|j��Sr,r�r�s rr5zLazyIntegerRange.sizes���4�:���rc�6�tj|��|Sr,)r!r��r�rs  r�__getitem__zLazyIntegerRange.__getitem__s���x��~�~�c�"�"rNc�8�tj|ji|j��Sr,)r!r2r�r��r�r&s  r�	__array__zLazyIntegerRange.__array__s���y�$�)�4�t�|�4�4�4rc�@�t|��j�d|j�d�S)N�(array=�))�type�__name__r�r�s r�__repr__zLazyIntegerRange.__repr__s&���d���$�$�$�d�j�j�j�2�	3rr,)r��
__module__�__qualname__r��propertyrIr&rr5r�r�r�r-rrr�r��s�������
-�
-�
-��"�"��X�"��!�!��X�!�����X������X��#�#�#�5�5�5�5�3�3�3�3�3rr�c�P�eZdZdZd
d�Zd�Zed���Zd
d�Zd�Z	d�Z
d	�ZdS)�LazilyIndexedArrayzIWrap an array that handles orthogonal indexing to make indexing lazy
    Nc�V�|�td��f|jz}||_||_dS)z�
        Parameters
        ----------
        array : array_like
            Array like object to index.
        key : tuple, optional
            Array indexer. If provided, it is assumed to already be in
            canonical expanded form.
        N)rrr�r)r�r�rs   rr�zLazilyIndexedArray.__init__s/���;���;�;�.�5�:�-�C���
�����rc	��tt||j����}g}t|jj|j��D]m\}}t|ttj
f��r|�|���<|�t|t|��|�����nt|��Sr,)�iterr0r�zipr�rIrr
r#r!r9rr��nextr)r�rrr5rs     r�_updated_keyzLazilyIndexedArray._updated_key"s����+�G�T�Y�?�?�@�@�����4�:�+�T�X�6�6�	F�	F�G�D�!��!�c�2�:�.�/�/�
F��
�
�1�
�
�
�
��
�
�,�Q��W�
�
�t�D�D�E�E�E�E��S�z�z�rc
�z�g}t|jj|j��D]�\}}t	|t
��r=|�tt|�	|��������Wt	|tj��r|�|j����t|��Sr,)r�r�rIrr
rrrrr3r!r�r5r)r�rIr5rs    rrIzLazilyIndexedArray.shape,s������4�:�+�T�X�6�6�	%�	%�G�D�!��!�U�#�#�
%����S���	�	�$���!8�9�9�:�:�:�:��A�r�z�*�*�
%����Q�V�$�$�$���U�|�|�rc�l�t|j��}tj||jd���S�NrX)�orthogonally_indexabler�r!r"r�r�r&r�s   rr�zLazilyIndexedArray.__array__6s,��&�t�z�2�2���z�%���/��6�6�6�6rc�d�t|��|j|�|����Sr,)r�r�r�r�s  rr�zLazilyIndexedArray.__getitem__:s*���t�D�z�z�$�*�d�&7�&7��&<�&<�=�=�=rc�D�|�|��}||j|<dSr,)r�r��r�r�values   r�__setitem__zLazilyIndexedArray.__setitem__=�$������$�$����
�3���rc�P�t|��j�d|j�d|j�d�S)Nr�z, key=r�)r�r�r�rr�s rr�zLazilyIndexedArray.__repr__As.���d���$�$�$�d�j�j�j�$�(�(�(�<�	=rr,)r�r�r��__doc__r�r�r�rIr�r�r�r�r-rrr�r�s���������
�
�
�
��������X��7�7�7�7�>�>�>� � � �=�=�=�=�=rr�c���t|tj��rt|��St|tj��rt
|��St|t��rt|��S|Sr,)	r
r!r��NumpyIndexingAdapterrc�Index�PandasIndexAdapterr�DaskIndexingAdapter�r�s rr�r�Fsk���%���$�$�+�#�E�*�*�*��%���"�"�)�!�%�(�(�(��%��)�)�*�"�5�)�)�)��Lrc�2�eZdZdZd�Zdd�Zd�Zd�Zd�ZdS)	r�z�Wrap a NumPy array to use orthogonal indexing (array indexing
    accesses different dimensions independently, like netCDF4-python variables)
    c�8�tj|��|_dSr,�r!r"r��r�r�s  rr�zNumpyIndexingAdapter.__init__Ws���Z��&�&��
�
�
rNc�8�tj|j|���Sr�r�r�s  rr�zNumpyIndexingAdapter.__array__Zs���z�$�*�E�2�2�2�2rc��t||j��}td�|D����rt||j��}|S)Nc3�fK�|],}t|ttjtf��V��-dSr,�r
r#r!r9r�r.rs  rr/z4NumpyIndexingAdapter._convert_key.<locals>.<genexpr>_�8����H�H�q�:�a�#�r�z�5�!9�:�:�:�H�H�H�H�H�Hr)rrrmrPrIr�s  r�_convert_keyz!NumpyIndexingAdapter._convert_key]sH���s�D�I�.�.���H�H�C�H�H�H�H�H�	6�$�S�$�*�5�5�C��
rc�F�|�|��}|j|Sr,�r�r�r�s  rr�z NumpyIndexingAdapter.__getitem__ds!������$�$���z�#��rc�D�|�|��}||j|<dSr,r�r�s   rr�z NumpyIndexingAdapter.__setitem__hr�rr,)	r�r�r�r�r�r�r�r�r�r-rrr�r�Psn��������'�'�'�3�3�3�3������� � � � � rr�c��eZdZdZd�Zd�ZdS)r�z5Wrap a dask array to support orthogonal indexing
    c��||_dSr,r�r�s  rr�zDaskIndexingAdapter.__init__ps
����
�
�
rc�$�t||j��}td�|D����rT|j}t	tt
|������D]"\}}|td��f|z|fz}�#n
|j|}|S)Nc3�fK�|],}t|ttjtf��V��-dSr,r�r�s  rr/z2DaskIndexingAdapter.__getitem__.<locals>.<genexpr>ur�r)rrrmr��reversedrJrKr)r�rr��axis�subkeys     rr�zDaskIndexingAdapter.__getitem__ss����s�D�I�.�.���H�H�C�H�H�H�H�H�	$��J�E� (��i��n�n�)=�)=� >� >�
A�
A���f��u�T�{�{�n�t�3�v�i�?�@���
A��J�s�O�E��rN)r�r�r�r�r�r�r-rrr�r�ms<���������������rr�c�Z�eZdZdZd	d�Zed���Zd	d�Zed���Zd�Z	d�Z
dS)
r�zvWrap a pandas.Index to be better about preserving dtypes and to handle
    indexing by length 1 tuples like numpy
    Nc�L�tj|��|_|��t|tj��rt
jd��}nRt|d��r
|j	j}n5tj
|j��st
jd��}n|j}||_dS)N�O�
categories)r�safe_cast_to_indexr�r
rc�PeriodIndexr!r&�hasattrr��is_valid_numpy_dtype�_dtype)r�r�r&s   rr�zPandasIndexAdapter.__init__�s����-�e�4�4��
��=��%���0�0�
$����
�
������-�-�
$��(�.����/���<�<�
$����
�
����������rc��|jSr,)r�r�s rr&zPandasIndexAdapter.dtype�s
���{�rc���|�|j}|j}t|tj��r3tt��5|j}ddd��n#1swxYwYtj	|j
|���Sr�)r&r�r
rcr�r	rS�asobjectr!r"r\r�s   rr�zPandasIndexAdapter.__array__�s����=��J�E��
���e�R�^�,�,�	'��.�)�)�
'�
'����
'�
'�
'�
'�
'�
'�
'�
'�
'�
'�
'����
'�
'�
'�
'��z�%�,�e�4�4�4�4s�A�A�Ac�,�t|j��fSr,r�r�s rrIzPandasIndexAdapter.shape�s���D�J���!�!rc���t|t��rt|��dkr|\}|j|}t|tj��rt
||j���}n�|tjurtj
dd��}net|t��r%tjt|d|��d��}n+|jtkrtj||j���}|S)NrrX�NaT�nsr�)r
rrr�rcr�r�r&r�r!�
datetime64r�timedelta64�getattrr[r")r�rr]s   rr�zPandasIndexAdapter.__getitem__�s����c�5�!�!�	�c�#�h�h�!�m�m��D�C���C����f�b�h�'�'�	:�'��d�j�A�A�A�F�F�
�r�v�
�
�
�]�5�$�/�/�F�F�
��	�
*�
*�	:��^�G�F�G�V�$D�$D�d�K�K�F�F�
�Z�6�
!�
!��Z��d�j�9�9�9�F��
rc�P�t|��j�d|j�d|j�d�S)Nr�z, dtype=r�)r�r�r�r&r�s rr�zPandasIndexAdapter.__repr__�s0����:�:�&�&�&��
�
�
�D�J�J�J�@�	Arr,)r�r�r�r�r�r�r&r�rIr�r�r-rrr�r�~s�����������������X��5�5�5�5��"�"��X�"����.A�A�A�A�Arr�)r_NN)NN)�datetimer�numpyr!�pandasrcr_r�pycompatrrrr	rrr0r6rPrUr^rrr|r�r��NDArrayMixinr�r�r�r�r�r�r-rr�<module>r�s+����������������������A�A�A�A�A�A�A�A�A�A�A�A� � � � � � ����<G�G�G�4,�,�,�(�(�(�V������$?C�$(�*�*�*�*�Z7�7�7�7�$�$�$�,���&3�&3�&3�&3�&3�u�)�&3�&3�&3�R3=�3=�3=�3=�3=��+�3=�3=�3=�l��� � � � � �5�-� � � �:�����%�,����">A�>A�>A�>A�>A��+�>A�>A�>A�>A�>Ar