
    jN7                        d Z ddlZddlmZmZ ddlZddlmZmZ  G d de          Z	 G d d	e	          Z
 G d
 de	          Z G d de          Z G d de	          Z G d de	          Z G d de	          Z G d de	          ZdS )a  
    Dataset slicing test module.

    Tests all supported slicing operations, including read/write and
    broadcasting operations.  Does not test type conversion except for
    corner cases overlapping with slicing; for example, when selecting
    specific fields of a compound type.
    N   )TestCase	make_name)FileMultiBlockSlicec                       e Zd Zd Zd ZdS )BaseSlicingc                 T    t          |                                 d          | _        d S )Nw)r   mktempfselfs    Z/var/www/html/Carbon-Document/venv/lib/python3.11/site-packages/h5py/tests/test_slicing.pysetUpzBaseSlicing.setUp   s    dkkmmS))    c                 J    | j         r| j                                          d S d S Nr   closer   s    r   tearDownzBaseSlicing.tearDown   )    6 	FLLNNNNN	 	r   N)__name__
__module____qualname__r   r    r   r   r	   r	      s2        * * *    r   r	   c                   0    e Zd ZdZd Zd Zd Zd Zd ZdS )TestSingleElementzM
        Feature: Retrieving a single element works with NumPy semantics
    c                     | j                             t                      dd          }|d         }|                     |t          j                   dS )z; Single-element selection with [index] yields array scalar r   i1dtyper   Nr   create_datasetr   assertIsInstancenpint8r   dsetouts      r   test_single_indexz#TestSingleElement.test_single_index)   sI    v$$Y[[$d$CC1gc27+++++r   c                     | j                             t                      dd          }|d         }|                     |t          j                   |                     |j        d           dS )z3 Single-element selection with [()] yields ndarray r    r!   r"   r   Nr   r%   r   r&   r'   ndarrayassertEqualshaper)   s      r   test_single_nullz"TestSingleElement.test_single_null/   sa    v$$Y[[$d$CC2hc2:...D)))))r   c                     | j                             t                      dd          }|d         }|                     |t          j                   |                     |j        d           dS )z* Slicing with [...] yields scalar ndarray r   r   r1   r#   .Nr.   r)   s      r   test_scalar_indexz#TestSingleElement.test_scalar_index6   sa    v$$Y[[#$FF3ic2:...B'''''r   c                     | j                             t                      dd          }|d         }|                     |t          j                   dS )z' Slicing with [()] yields array scalar r   r!   r4   Nr$   r)   s      r   test_scalar_nullz"TestSingleElement.test_scalar_null=   sI    v$$Y[[$$GG2hc27+++++r   c                 @   t          j        ddg          }t          j        d|          }| j                            t                      d|          }|                     |d         |d                    |                     |d         t           j                   dS )z6 Compound scalar is numpy.void, not tuple (issue 135) )ai4)bf8)   r"   datar   N)	r'   r#   onesr   r%   r   r0   r&   void)r   dtvr*   s       r   test_compoundzTestSingleElement.test_compoundC   s    Xz*-..GD###v$$Y[[$Q$??a!A$'''d1grw/////r   N)	r   r   r   __doc__r,   r2   r5   r7   rD   r   r   r   r   r   #   si         , , ,* * *( ( (, , ,0 0 0 0 0r   r   c                   0    e Zd ZdZd Zd Zd Zd Zd ZdS )TestObjectIndexzH
        Feature: numpy.object_ subtypes map to real Python objects
    c                     | j                             t                      dt          j                  }| j         j        |d<   |                     t          |d                   t          j                   dS )z@ Indexing a reference dataset returns a h5py.Reference instance r    r"   r   N	r   r%   r   h5py	ref_dtyperefr0   type	Referencer   r*   s     r   test_referencezTestObjectIndex.test_referenceQ   sY    v$$Y[[$dn$MM&*Qd1g77777r   c                 J   | j                             t          d          dd          }|j        d         }| j                             t          d          dt          j                  }||d<   |                     t          |d                   t          j                   d	S )
zL Indexing a region reference dataset returns a h5py.RegionReference
        x)
   rS   f4.yr    r"   r   N)	r   r%   r   	regionrefrJ   regionref_dtyper0   rM   RegionReference)r   dset1regrefdset2s       r   test_regrefzTestObjectIndex.test_regrefW   s     %%inngtDD%%%innd$BV%WWaeAh)=>>>>>r   c                 @   t          j        ddt          j        fg          }| j                            t                      d|          }d| j        d         j        f|d<   |d         }|                     t          |d                   t          j
                   d	S )
z> Compound types of which a reference is an element work right )r9   ir;   r    r"   *   /r   r   N)r'   r#   rJ   rK   r   r%   r   rL   r0   rM   rN   r   rB   r*   r+   s       r   test_reference_fieldz$TestObjectIndex.test_reference_field`   s    Xz3"7899v$$Y[[$b$AAtvc{'Q1gc!ft~66666r   c                     | j                             t                      dt          j                  }| j         j        |d<   |                     t          |d                   t          j                   dS )z: Indexing returns a real Python object on scalar datasets r   r"   NrI   rO   s     r   test_scalarzTestObjectIndex.test_scalarj   sY    v$$Y[["DN$KK6:Rd2h88888r   c                     | j                             t                      dt          j        d                    }d|d<   |                     t          |d                   t                     dS )zJ Indexing a byte string dataset returns a real python byte string
        r    ascii)encodingr"   s   Hello there!r   N)r   r%   r   rJ   string_dtyper0   rM   bytesrO   s     r   test_bytestrzTestObjectIndex.test_bytestrp   sb     v$$Y[[$d>OY`>a>a>a$bb!Qd1g.....r   N)	r   r   r   rE   rP   r\   rb   rd   rj   r   r   r   rG   rG   K   si         8 8 8? ? ?7 7 79 9 9/ / / / /r   rG   c                   *    e Zd ZdZd Zd Zd Zd ZdS )TestSimpleSlicingzQ
        Feature: Simple NumPy-style slices (start:stop:step) are supported.
    c                     t          |                                 d          | _        t          j        d          | _        | j                            d| j                  | _        d S )Nr   rS   rR   r>   )r   r   r   r'   arangearrr%   r*   r   s    r   r   zTestSimpleSlicing.setUp}   sL    dkkmmS))9R==F))#DH)==			r   c                 J    | j         r| j                                          d S d S r   r   r   s    r   r   zTestSimpleSlicing.tearDown   r   r   c                 f    |                      | j        dd         | j        dd                    dS )z0 Negative stop indexes work as they do in NumPy    N)assertArrayEqualr*   ro   r   s    r   test_negative_stopz$TestSimpleSlicing.test_negative_stop   s2    di"otx"~>>>>>r   c                    | j                             t                      dd          }t          j        d          }|dddf         |dddf<   |                     t                    5  ||dddf<   ddd           dS # 1 swxY w Y   dS )z0Assigning to a 1D slice of a 2D dataset
        )rS   rr   rT   )rS   r   Nr   r   )r   r%   r   r'   zerosassertRaises	TypeError)r   r*   rR   s      r   
test_writezTestSimpleSlicing.test_write   s     v$$Y[['4@@HWqqq!tWQQQT
y)) 	 	DAJ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	s   *
BBBN)r   r   r   rE   r   r   ru   rz   r   r   r   rl   rl   w   sZ         > > >
  ? ? ?    r   rl   c                   0    e Zd ZdZd Zd Zd Zd Zd ZdS )TestArraySlicingz<
        Feature: Array types are handled appropriately
    c                    t          j        d          }| j                            t	                      d|          }|                     |j        d           |                     |j        |           |d         }|                     |j        t          j        d                     |                     |j        d           |d         }|                     |j        t          j        d                     |                     |j        d           |d	d
d	         }|                     |j        t          j        d                     |                     |j        d           dS )z; Read arrays tack array dimensions onto end of shape tuple (3,)f8rS   r"   .r<   )rS      r   r   rr      )r   r   N)r'   r#   r   r%   r   r0   r1   ra   s       r   	test_readzTestArraySlicing.test_read   s6   Xhv$$Y[[%r$BBU+++R((( 3iBHTNN333F+++ 1gBHTNN333D))) 1Qq5kBHTNN333E*****r   c                     t          j        d          }| j                            t	                      d|          }|                     t                    5  d|d<   ddd           dS # 1 swxY w Y   dS )z@ Array fill from constant is not supported (issue 211).
        (3,)ir   r"   r_   .N)r'   r#   r   r%   r   rx   ry   )r   rB   r*   s      r   test_write_broadcastz%TestArraySlicing.test_write_broadcast   s     Xgv$$Y[[%r$BBy)) 	 	DI	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	s   A++A/2A/c                    t          j        d          }| j                            t	                      d|          }t          j        g d          }||d<   |d         }|                     t          j        ||k                         dS )zA Write a single element to the array

        Issue 211.
        r~   r   r"   )r   rr   g      @r=   N)r'   r#   r   r%   r   array
assertTrueall)r   rB   r*   r?   r+   s        r   test_write_elementz#TestArraySlicing.test_write_element   s~    
 Xhv$$Y[[%r$BBx			""Q1gsd{++,,,,,r   c                    t          j        d          }t          j        d|          }t          j        d|          }| j                            t                      d|          }||ddddf<   |                     |ddddf         |           ||d	d
dddf<   |                     |d	d
dddf         |           dS )z Write slices to array type r   )rr   r"   )r=      )rS   	      r   rr   r=   r   r   r      r   N)r'   r#   r@   r   r%   r   rt   )r   rB   data1data2r*   s        r   test_write_slicesz"TestArraySlicing.test_write_slices   s    XgB'''R(((v$$Y[[)2$FFQq1Wd1Qqs7mU333"Q!QrT\d1ac1R4<0%88888r   c                     t          j        d          }| j                            t	                      d|          }|d         }||d<   |                     t          j        |d         |k                         dS )zO Read the contents of an array and write them back

        Issue 211.
        r~   r   r"   .N)r'   r#   r   r%   r   r   r   ra   s       r   test_roundtripzTestArraySlicing.test_roundtrip   sp    
 Xhv$$Y[[%r$BB3iS	tCyC/0011111r   N)	r   r   r   rE   r   r   r   r   r   r   r   r   r|   r|      si         + + +,  - - -9 9 9 2 2 2 2 2r   r|   c                   $    e Zd ZdZd Zd Zd ZdS )TestZeroLengthSlicingz.
        Slices resulting in empty arrays
    c           
         t          g d          D ]P\  }}| j                            t          d|           |t          dt          |          z            }|                     |j        |           |d         }|                     |t          j
                   |                     |j        |           |dd         }|                     |t          j
                   |                     |j        |           t          |          dk    rQ|ddddf         }|                     |t          j
                   |                     |j        dd         d	           RdS )
z] Slice a dataset with a zero in its shape vector
            along the zero-length dimension )r   )r   r   )r   rr   r   rR   r   r#   maxshape.Nr   rr   )r   r   	enumerater   r%   r   intlenr0   r1   r&   r'   r/   r   r^   r1   r*   r+   s        r    test_slice_zero_length_dimensionz6TestZeroLengthSlicing.test_slice_zero_length_dimension   sW    "";";";<< 	8 	8HAu6((7q77););U#X_`cdi`j`jXj(kkDTZ///s)C!!#rz222SY...qqq'C!!#rz222SY...5zzA~~111bqb5k%%c2:666  2A2777	8 	8r   c           
         t          g d          D ]\  }}| j                            t          d|           |t          dt          |          z            }|                     |j        |           |dd         }|                     |t          j
                   |                     |j        d|dd         z              dS )z_ Slice a dataset with a zero in its shape vector
            along a non-zero-length dimension ))r   r   )r   rr   r   )rr   r   r   rR   r   r   Nr   r    r   r   s        r   test_slice_other_dimensionz0TestZeroLengthSlicing.test_slice_other_dimension   s     ""@"@"@AA 	8 	8HAu6((7q77););U#X_`cdi`j`jXj(kkDTZ///rr(C!!#rz222SYU122Y7777	8 	8r   c           	         t          g d          D ]\  }}| j                            t          d|           t	          j        |t                    dt          |          z            }|                     |j	        |           |dd         }| 
                    |t          j                   |                     |j	        d|dd         z              dS )z5 Get a slice of length zero from a non-empty dataset )r   )rr   rr   )rr   r   r   rR   r   )r?   r   r   r   N)r   r   r%   r   r'   rw   r   r   r0   r1   r&   r/   r   s        r   test_slice_of_length_zeroz/TestZeroLengthSlicing.test_slice_of_length_zero  s    !"="="=>> 	8 	8HAu6((7q77););"(5RUBVBVahilmrisisas(ttDTZ///qs)C!!#rz222SYU122Y7777	8 	8r   N)r   r   r   rE   r   r   r   r   r   r   r   r      sK         8 8 8"8 8 88 8 8 8 8r   r   c                   x    e Zd ZdZ ej        g d          Z ej        de          Zd Z	d Z
d Zd Zd	 Zd
S )TestFieldNamesz*
        Field names for read & write
    ))r9   r   )r;   r^   )crT   d   r"   c                     t                               |            | j                            dd| j                  | _        | j        | j        d<   d S )NrR   r   r"   .)r	   r   r   r%   rB   r*   r?   r   s    r   r   zTestFieldNames.setUp  sG    $F))#vTW)EE		#r   c                 ^    |                      | j        d         | j        d                    dS )z! Test read with field selections r9   N)rt   r*   r?   r   s    r   r   zTestFieldNames.test_read  s*    dindin=====r   c                 8   |                      | j        d         | j        d                    | j                                        }| j                            t                      |          }d|d<   d|d<   |                      |d         |d                    dS )z, Unicode field names for for read and write r9   r>   r_   N)rt   r*   r?   copyr   r%   r   r   r?   r*   s      r   test_unicode_namesz!TestFieldNames.test_unicode_names"  s    dindin===y~~v$$Y[[t$<<S	S	d3ic33333r   c                 L   | j                                         }| j                            t	                      |          }|dxx         dz  cc<   ||d<   |                     t          j        |d         |k                         |dxx         dz  cc<   ||d<   |                     t          j        |d         |k                         |dxx         dz  cc<   |dxx         dz  cc<   ||d	<   |                     t          j        |d         |k                         d
S )z" Test write with field selections r>   r9   rr   .r;   r=   r   r   )r9   r   Nr?   r   r   r%   r   r   r'   r   r   s      r   rz   zTestFieldNames.test_write,  s   y~~v$$Y[[t$<<S			Q			S	tCyD011222S			Q			S	tCyD011222S			Q			S			Q			WtCyD01122222r   c                     | j                                         }| j                            t	                      |          }d|d<   d|d<   |                     t          j        |d         |k                         dS )z4 Test write with non-compound source (single-field) r>   g      ?r;   .Nr   r   s      r   test_write_noncompoundz%TestFieldNames.test_write_noncompound<  sn    y~~v$$Y[[t$<<S	S	tCyD01122222r   N)r   r   r   rE   r'   r#   rB   r@   r?   r   r   r   rz   r   r   r   r   r   r     s          
777	8	8B276$$$D# # #
> > >4 4 43 3 3 3 3 3 3 3r   r   c                   r     e Zd Z fdZd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd Zd Zd Zd Zd Z xZS )TestMultiBlockSlicec                     t                                                       t          j        d          | _        | j                            d| j                  | _        d S )NrS   rR   r>   )superr   r'   rn   ro   r   r%   r*   )r   	__class__s    r   r   zTestMultiBlockSlice.setUpH  sE    9R==F))#DH)==			r   c                     t                      }|                     |                    d          d           t          j                            | j        |         | j                   d S )NrS   r   r   rS   r   r   r0   indicesr'   testingassert_array_equalr*   ro   r   mbslices     r   test_defaultz TestMultiBlockSlice.test_defaultM  sV    !##,,m<<<

%%di&8$(CCCCCr   c                     t          dddd          }|                     |                    d          d           t          j                            | j        |         | j                   d S )Nr   rS   r   startcountstrideblockr   r   r   s     r   test_default_explicitz)TestMultiBlockSlice.test_default_explicitT  sa    !AQGGG,,m<<<

%%di&8$(CCCCCr   c                     t          d          }|                     |                    d          d           t          j                            | j        |         t          j        g d                     d S )Nr=   )r   rS   )r=   r   r   r   )r=   r   r      r   r   r   r0   r   r'   r   r   r*   r   r   s     r   
test_startzTestMultiBlockSlice.test_startZ  sj    !***,,l;;;

%%di&8"(CUCUCU:V:VWWWWWr   c                     t          d          }|                     |                    d          d           t          j                            | j        |         t          j        g d                     d S )Nr   r   rS   )r   r   r   r   )r   r   rr   r   r=   r   r   r   r   s     r   
test_countzTestMultiBlockSlice.test_count`  su    !***,,l;;;

%%Ig)>)>)> ? ?	
 	
 	
 	
 	
r   c                     t          d          }|                     t                    5  |                    d           d d d            d S # 1 swxY w Y   d S )Nr   r   rS   r   rx   
ValueErrorr   r   s     r   !test_count_more_than_length_errorz5TestMultiBlockSlice.test_count_more_than_length_errorh  s    !+++z** 	  	 OOB	  	  	  	  	  	  	  	  	  	  	  	  	  	  	  	  	  	 s   AAAc                     t          d          }|                     |                    d          d           t          j                            | j        |         t          j        g d                     d S )Nrr   )r   rS   )r   rr   r   r   )r   rr   r=   r   r   r   r   s     r   test_stridezTestMultiBlockSlice.test_stridem  sg    !+++,,l;;;

%%di&8"(???:S:STTTTTr   c                     |                      t                    5  t          dd                              d           d d d            d S # 1 swxY w Y   d S )Nr   r   r   rS   )rx   r   r   r   r   s    r   test_stride_zero_errorz*TestMultiBlockSlice.test_stride_zero_errors  s    z** 	; 	;1A...66r:::	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	; 	;s   %AAAc                     t          dd          }|                     |                    d          d           t          j                            | j        |         | j                   d S )Nrr   r   rS   )r   rr   r   rr   r   r   s     r   test_stride_block_equalz+TestMultiBlockSlice.test_stride_block_equalx  s]    !!444,,l;;;

%%di&8$(CCCCCr   c                    |                      t                    5  t          d           d d d            n# 1 swxY w Y   |                      t                    5  t          dd           d d d            d S # 1 swxY w Y   d S )Nr   )r   rr   r   )rx   r   r   r   s    r   !test_block_more_than_stride_errorz5TestMultiBlockSlice.test_block_more_than_stride_error~  s	   z** 	% 	%!$$$$	% 	% 	% 	% 	% 	% 	% 	% 	% 	% 	% 	% 	% 	% 	% z** 	/ 	/1A....	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/s   8<<A<<B B c                     t          dd          }|                     |                    d          d           t          j                            | j        |         t          j        g d                     d S )Nr   rr   r   rS   )r   r   r   rr   )r   r   r   r=   r   r   r   r   s     r   test_stride_more_than_blockz/TestMultiBlockSlice.test_stride_more_than_block  sl    !!444,,l;;;

%%di&8"(CUCUCU:V:VWWWWWr   c                     t          dddd          }|                     t                    5  |                    d           d d d            d S # 1 swxY w Y   d S )Nrr   r   r=   r   rS   r   r   s     r    test_block_overruns_extent_errorz4TestMultiBlockSlice.test_block_overruns_extent_error  s    !1AFFFz** 	  	 OOB	  	  	  	  	  	  	  	  	  	  	  	  	  	  	  	  	  	 s   AAAc                     t          dddd          }|                     |                    d          d           t          j                            | j        |         t          j        g d                     d S )	Nr   rr   r   r=   r   rS   )r   r   rr   r=   )r   rr   r   r=   r   r   r   r   r   r   s     r   test_fully_describedz(TestMultiBlockSlice.test_fully_described  s{    !1AFFF,,l;;;

%%Ig)A)A)A B B	
 	
 	
 	
 	
r   c                     t          ddd          }|                     |                    d          d           t          j                            | j        |         t          j        g d                     d S )Nr   r   rr   r   r   r   rS   )r   r   r   rr   )r   rr   r=   r   r   r   r   r   s     r   test_count_calculatedz)TestMultiBlockSlice.test_count_calculated  sn    !!1===,,l;;;

%%di&8"(CUCUCU:V:VWWWWWr   c                     t          ddd          }|                     t                    5  |                    d           d d d            d S # 1 swxY w Y   d S )Nr   r=   r   r   rS   r   r   s     r    test_zero_count_calculated_errorz4TestMultiBlockSlice.test_zero_count_calculated_error  s    !!1===z** 	  	 OOB	  	  	  	  	  	  	  	  	  	  	  	  	  	  	  	  	  	 s   AAA)r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   __classcell__)r   s   @r   r   r   F  s       > > > > >
D D DD D DX X X
 
 
     
U U U; ; ;
D D D/ / /X X X     
 
 
X X X             r   r   )rE   numpyr'   commonr   r   rJ   r   r   r	   r   rG   rl   r|   r   r   r   r   r   r   <module>r      s        ' ' ' ' ' ' ' '  & & & & & & & &    (   &0 &0 &0 &0 &0 &0 &0 &0P*/ */ */ */ */k */ */ */X       :O2 O2 O2 O2 O2{ O2 O2 O2d(8 (8 (8 (8 (8K (8 (8 (8T33 33 33 33 33[ 33 33 33l_  _  _  _  _ + _  _  _  _  _ r   