a
    yn„fúä  ã                   @  sx  d dl mZ d dlZd dlmZmZmZ d dlZd dl	m
Z
 d dlmZ d dlmZ d dlmZ d dlmZ d d	lmZmZ d d
lmZmZ d dlmZmZmZ d dlmZmZ d dl m!Z! d dl"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z) d dl*m+Z+ d dl,m-Z-m.Z.m/Z/m0Z0m1Z1 d dl2m3Z3 d dl4m5Z5 d dl6m7Z7 e#�rJd dl m8Z8 d dl9m:Z: e ;¡ Z<e ;¡ Z=e)G dd„ dee. e.ƒƒZ>dS )é    )ÚannotationsN)ÚMappingÚMutableMappingÚSequence)ÚBackend)Úmaybe_posaxis)ÚRegularMeta)Ú	ArrayLike)ÚNumpy)Ú	IndexTypeÚNumpyMetadata)Ú	ShapeItemÚunknown_length)Úparameters_intersectÚparameters_unionÚtype_parameters_equal)Ú
is_integerÚis_integer_like)ÚNO_HEAD)ÚTYPE_CHECKINGÚAnyÚCallableÚFinalÚSelfÚSupportsIndexÚfinal)ÚUNSET)ÚApplyActionOptionsÚContentÚImplementsApplyActionÚRemoveStructureOptionsÚToArrowOptions)ÚForm)ÚRegularForm)ÚIndex)Ú	SliceItem)ÚListOffsetArrayc                   @  s"  e Zd ZU dZd¯ddœdd„Zedd„ ƒZeZd	e	d
< e
e
e
fe
dœdd„Zdd„ Zdd„ Zed°ddœdd„ƒZeddœdd„ƒZeddœdd„ƒZedd„ ƒZdddœdd„Zd d!d"d#d$d%œd&d'„Zd(d)d*œd+d,„Zd(d-œd.d/„Zd(d-œd0d1„Zed2dœd3d4„ƒZd5d6„ Zd7d8„ Zd±d(d:d;œd<d=„Zd>d?„ Zd@dœdAdB„ZdCdD„ Zd(dœdEdF„ZdGdHœdIdJ„Z dGdGdKdLœdMdN„Z!d²dPdQdKdRœdSdT„Z"d³dUdQdKdRœdVdW„Z#dd(dKdXœdYdZ„Z$d[d\„ Z%dd:d]œd^d_„Z&dddKdKd`œdadb„Z'dcdddedKdfœdgdh„Z(dididjdkœdldm„Z)dKd(d(dnœdodp„Z*dqdKdrœdsdt„Z+dKdKduœdvdw„Z,dxdy„ Z-dzd{„ Z.d|d}„ Z/d~d„ Z0d€d�„ Z1d‚dƒ„ Z2d„d…„ Z3d†d‡„ Z4dˆd‰„ Z5dŠd‹„ Z6dŒd�„ Z7dŽd�„ Z8d�d‘d‘did’d“œd”d•„Z9d#d–d—d˜œd™dš„Z:dKdœd›dœ„Z;d�didždždŸd‘d œd¡d¢„Z<d´d(d)d¤œd¥d¦„Z=d§d¨„ Z>d#d)d©œdªd«„Z?d)d(d(d(d(d¬œd­d®„Z@dS )µÚRegularArrayaB  
    RegularArray describes lists that all have the same length, the single
    integer `size`. Its underlying `content` is a flattened view of the data;
    that is, each list is not stored separately in memory, but is inferred as a
    subinterval of the underlying data.

    If the `content` length is not an integer multiple of `size`, then the length
    of the RegularArray is truncated to the largest integer multiple.

    An extra field `zeros_length` is ignored unless the `size` is zero. This sets the
    length of the RegularArray in only those cases, so that it is possible for an
    array to contain a non-zero number of zero-length lists with regular type.

    A multidimensional #ak.contents.NumpyArray is equivalent to a one-dimensional
    #ak.layout.NumpyArray nested within several RegularArrays, one for each
    dimension. However, RegularArrays can be used to make lists of any other type.

    Like #ak.contents.ListArray and #ak.contents.ListOffsetArray, a RegularArray can
    represent strings if its `__array__` parameter is `"string"` (UTF-8 assumed) or
    `"bytestring"` (no encoding assumed) and it contains an #ak.contents.NumpyArray
    of `dtype=np.uint8` whose `__array__` parameter is `"char"` (UTF-8 assumed) or
    `"byte"` (no encoding assumed).

    RegularArray corresponds to an Apache Arrow
    [FixedSizeList](https://arrow.apache.org/docs/format/Columnar.html#fixed-size-list-layout).

    To illustrate how the constructor arguments are interpreted, the following is a
    simplified implementation of `__init__`, `__len__`, and `__getitem__`:

        class RegularArray(Content):
            def __init__(self, content, size, zeros_length=0):
                assert isinstance(content, Content)
                assert isinstance(size, int)
                assert isinstance(zeros_length, int)
                assert size >= 0
                if size != 0:
                    length = len(content) // size  # floor division
                else:
                    assert zeros_length >= 0
                    length = zeros_length
                self.content = content
                self.size = size
                self.length = length

            def __len__(self):
                return self.length

            def __getitem__(self, where):
                if isinstance(where, int):
                    if where < 0:
                        where += len(self)
                    assert 0 <= where < len(self)
                    return self.content[(where) * self.size : (where + 1) * self.size]

                elif isinstance(where, slice) and where.step is None:
                    start = where.start * self.size
                    stop = where.stop * self.size
                    zeros_length = where.stop - where.start
                    return RegularArray(
                        self.content[start:stop], self.size, zeros_length
                    )

                elif isinstance(where, str):
                    return RegularArray(self.content[where], self.size, self.length)

                else:
                    raise AssertionError(where)
    r   N©Ú
parametersc                C  sˆ  t |tƒs"tt| ƒj› d|›�ƒ‚|tu rJ|jjjrrtt| ƒj› d�ƒ‚n(t	|ƒrZ|dksrtt| ƒj› d|› �ƒ‚|tur¢t	|ƒrŠ|dks¢tt| ƒj› d|› �ƒ‚|d urä| 
d¡dkrä|jrÌ| d¡dksätt| ƒj› d	|›�ƒ‚|d u�r.| 
d¡d
k�r.|j�r| d¡dk�s.tt| ƒj› d|›�ƒ‚|| _|| _|jtu �sP|tu �rXt| _n|dk�rp|j| | _n|| _|  ||j¡ d S )Nz* 'content' must be a Content subtype, not zO 'size' must be a non-negative integer for backends with known shapes, not Noner   z, 'size' must be a non-negative integer, not z4 'zeros_length' must be a non-negative integer, not Ú	__array__ÚstringÚcharzE is a string, so its 'content' must be uint8 NumpyArray of char, not Ú
bytestringÚbytezI is a bytestring, so its 'content' must be uint8 NumpyArray of byte, not )Ú
isinstancer   Ú	TypeErrorÚtypeÚ__name__r   ÚbackendÚindex_nplikeÚ
known_datar   ÚgetZis_numpyÚ	parameterÚ
ValueErrorÚ_contentÚ_sizeÚlengthÚ_lengthÚ_init©ÚselfÚcontentÚsizeÚzeros_lengthr)   © rC   ú`/home/yuhw/wc/wire-cell-python/wcpy/lib/python3.9/site-packages/awkward/contents/regulararray.pyÚ__init__{   sN    
ÿ
ÿÿÿÿÿÿÿ
zRegularArray.__init__c                 C  s   | j S ©N)r:   ©r?   rC   rC   rD   rA   ¦   s    zRegularArray.sizer   Úform_clsc                C  sH   t |tu r| jn||tu r | jn||tu r0| jn||tu r@| jn|d�S ©Nr(   )r'   r   r9   r:   r<   Ú_parametersr>   rC   rC   rD   Úcopy¬   s    üzRegularArray.copyc                 C  s   |   ¡ S rF   )rK   rG   rC   rC   rD   Ú__copy__´   s    zRegularArray.__copy__c                 C  s"   | j t  | j|¡t  | j|¡d�S )N)r@   r)   )rK   Údeepcopyr9   rJ   )r?   ÚmemorC   rC   rD   Ú__deepcopy__·   s    þzRegularArray.__deepcopy__c                C  s   | ||||d�S rI   rC   )Úclsr@   rA   rB   r)   rC   rC   rD   Ú
simplified½   s    zRegularArray.simplifiedr$   )Úreturnc                 C  s
   |   d¡S ©NT©Ú_compact_offsets64rG   rC   rC   rD   ÚoffsetsÁ   s    zRegularArray.offsetsc                 C  s   |   d¡d d… S )NTéÿÿÿÿrT   rG   rC   rC   rD   ÚstartsÅ   s    zRegularArray.startsc                 C  s   |   d¡dd … S )NTé   rT   rG   rC   rC   rD   ÚstopsÉ   s    zRegularArray.stopszCallable[[Content], str | None]r#   )ÚgetkeyrR   c                 C  s&   || ƒ}| j | j |¡| j| j|d�S )N)r)   Úform_key)rH   r9   Ú_form_with_keyr:   rJ   )r?   r[   r\   rC   rC   rD   r]   Í   s    
üzRegularArray._form_with_keyr"   z#Callable[[Content, Form, str], str]zMutableMapping[str, ArrayLike]r   Ústr)Úformr[   Ú	containerr3   Ú	byteorderc                 C  s*   t || jƒsJ ‚| j |j||||¡ d S rF   )r/   rH   r9   Ú_to_buffersr@   )r?   r_   r[   r`   r3   ra   rC   rC   rD   rb   Ö   s    zRegularArray._to_buffersÚboolr   )Úforget_lengthrR   c                 C  s&   t | j |¡| j|rtn| j| jd�S rI   )r'   r9   Ú_to_typetracerr:   r   r<   rJ   )r?   rd   rC   rC   rD   re   á   s    
üzRegularArray._to_typetracer©Ú	recursivec                 C  s   |r| j  |¡ d S rF   )r9   Ú_touch_data©r?   rg   rC   rC   rD   rh   é   s    zRegularArray._touch_datac                 C  s   |r| j  |¡ d S rF   )r9   Ú_touch_shaperi   rC   rC   rD   rj   í   s    zRegularArray._touch_shaper   c                 C  s   | j S rF   )r<   rG   rC   rC   rD   r;   ñ   s    zRegularArray.lengthc                 C  s   |   ddd¡S )NÚ )Ú_reprrG   rC   rC   rD   Ú__repr__õ   s    zRegularArray.__repr__c                 C  s    ||dg}|  tt| jƒƒ¡ |  d¡ |  tt| jƒƒ¡ |  d¡ | |  |d ¡¡ |  d¡ |  | j |d dd¡¡ |  |d ¡ |  |¡ d	 	|¡S )
Nz<RegularArray size=z len=ú>z    Ú
z	<content>z</content>
z</RegularArray>rk   )
ÚappendÚreprr^   r:   r<   ÚextendZ_repr_extrar9   rl   Újoin)r?   ÚindentÚpreÚpostÚoutrC   rC   rD   rl   ø   s    




zRegularArray._reprFr&   )Ústart_at_zerorR   c                 C  s   |   |¡}|  |¡S rF   )rU   Ú_broadcast_tooffsets64)r?   rx   rV   rC   rC   rD   Úto_ListOffsetArray64  s    
z!RegularArray.to_ListOffsetArray64c                 C  s   | S rF   rC   rG   rC   rC   rD   Úto_RegularArray	  s    zRegularArray.to_RegularArrayzak.contents.NumpyArray | Nonec                 C  sr   | j d | j| j …  ¡ }|d urj| j| jf|jjdd …  }tjj| j	j
 |j|¡t| j|jƒ|jd�S d S d S )NrY   ©r)   r3   )r9   r<   r:   Úmaybe_to_NumpyArrayÚdataÚshapeÚakÚcontentsÚ
NumpyArrayÚ_backendÚnplikeÚreshaper   rJ   r)   r3   )r?   r@   r   rC   rC   rD   r}     s    ýz RegularArray.maybe_to_NumpyArrayc                 C  s   | j  dd¡S )Nr   )r9   Ú_getitem_rangerG   rC   rC   rD   Ú_getitem_nothing  s    zRegularArray._getitem_nothingc                 C  s   dS )NFrC   rG   rC   rC   rD   Ú_is_getitem_at_placeholder  s    z'RegularArray._is_getitem_at_placeholderr   )Úwherec                 C  sF   | j j}| || j¡}| | j¡}|| |d |  }}| j ||¡S ©NrY   )rƒ   r4   Zregularize_index_for_lengthr<   Úshape_item_as_indexr:   r9   r†   )r?   r‰   r4   Zsize_scalarÚstartÚstoprC   rC   rD   Ú_getitem_at  s
    zRegularArray._getitem_atr   )rŒ   r�   rR   c                 C  sl   | j j}|js| jdd� | S | || ¡}|| | j¡ || | j¡  }}t| j 	||¡| j|| j
d�S )NFrf   r(   )rƒ   r4   r5   rj   Úindex_as_shape_itemr‹   r:   r'   r9   r†   rJ   )r?   rŒ   r�   r4   rB   ZsubstartZsubstoprC   rC   rD   r†   &  s    þüzRegularArray._getitem_rangerC   zstr | SupportsIndexztuple[str, ...])r‰   Úonly_fieldsrR   c                 C  s   t | j ||¡| j| jd d�S rI   )r'   r9   Ú_getitem_fieldr:   r<   ©r?   r‰   r�   rC   rC   rD   r‘   8  s    üzRegularArray._getitem_fieldzlist[str | SupportsIndex]c                 C  s   t | j ||¡| j| jd d�S rI   )r'   r9   Ú_getitem_fieldsr:   r<   r’   rC   rC   rD   r“   B  s    üzRegularArray._getitem_fields)ÚcarryÚ
allow_lazyrR   c                 C  sh  t |tjjƒsJ ‚|j}|dk}t|jjtj	ƒsH| j
jj|tj	d�}d}|dk }| j
jjr¬| j
j |¡rŠ|sx| ¡ }d}||  | j7  < | j
j || jk¡r¬tj | |¡‚|jd tu sÄ| jtu rÚtjj t| j
j¡}n tjj |jd | j | j
j¡}|j| j
ju �sJ ‚| j| j
d|jj|jjf |j||jd | jƒ|d� t| j ||¡| j|jd | jd�S )NÚcopied©ÚdtypeTr   Z"awkward_RegularArray_getitem_carry©Zslicerr(   )r/   r€   Úindexr$   r~   Ú
issubclassr˜   r1   ÚnpÚint64rƒ   r4   Úastyper5   ÚanyrK   r<   Ú_errorsÚindex_errorr   r   r:   ÚIndex64Úemptyr„   Ú_maybe_index_errorr'   r9   Ú_carryrJ   )r?   r”   r•   r‰   r–   ÚnegativeÚ	nextcarryrC   rC   rD   r¥   L  sV    
ÿÿþÿø
õüzRegularArray._carryc                 C  sr   | j j}| jtur4| jdkr4tjjj| jd |d�S tjj|j	d| 
| j| j ¡d | 
| j¡tjd�|d�S d S )Nr   rY   ©r„   r—   )rƒ   r4   r:   r   r€   rš   r¢   Úzerosr<   Úaranger‹   rœ   r�   )r?   rx   r4   rC   rC   rD   rU     s    
üùzRegularArray._compact_offsets64)rV   rR   c                 C  sÎ  | j dd� |  ¡  | jj}|j|u s*J ‚|jturH|jdkrHtdƒ‚nf|jrn|d dkrntd|d › �ƒ‚n@|jtur®| jtur®|jd | jkr®td| j› d|jd › �ƒ‚| j	tu�r|| j	dk�r||j
dd … |j
d d	…  }| jjj�r6|jtu �s6|jdk�s6|jtjk�s6| jj |¡t tj¡jk�s6J ‚tjj| |j| | j¡tjd
�| |tj¡¡|d�}| j |d¡}n>|  d¡}|j�r¨| |j
|j
¡�s¨tdƒ‚| jd |d	 … }tjj||| j d�S )NFrf   r   z=broadcast_tooffsets64 can only be used with non-empty offsetszIbroadcast_tooffsets64 can only be used with offsets that start at 0, not rY   z(cannot broadcast RegularArray of length z to length rW   r—   r¨   Tzcannot broadcast nested listr(   )!rh   rƒ   r4   r„   r;   r   ÚAssertionErrorr5   r<   r:   r~   rA   r˜   rœ   ÚintpÚmaxZiinfor€   rš   r¢   Úrepeatrª   r‹   r�   rž   r9   r¥   rU   Zarray_equalr8   r�   r&   rJ   )r?   rV   r4   Úcountr”   Znext_contentZthis_offsetsrC   rC   rD   ry   Ž  sh    ÿÿÿþýÿÿþý
üûÿüù	
ÿÿz#RegularArray._broadcast_tooffsets64)ÚslicestartsÚ
slicestopsÚslicecontentrR   c                 C  s   |   d¡}| ||||¡S rS   )rz   Ú_getitem_next_jagged)r?   r°   r±   r²   Útailrw   rC   rC   rD   r³   Å  s    
z!RegularArray._getitem_next_jaggedzSliceItem | tupleztuple[SliceItem, ...]zIndex | None)Úheadr´   ÚadvancedrR   c              
   C  s”  | j j}|tu r| S t|ƒrºtj |¡\}}tjj 	| j
|¡}|j|u sLJ ‚t |¡dkrrttj|| j d�d ƒ}| j| j d|jjf |j|| j
| jƒ|d� | j |d¡}| |||¡S t|tƒ�rtj |¡\}}|j|| jd�\}	}
}}tjj 	| j
| |¡}|j|u �sJ ‚| j| j d|jjf |j|	|| j
| j|ƒ|d� | j |d¡}|d u �st|jtu�r’|jdk�r’t| |||¡|| j
| jd	�S tjj 	|j|¡}| |¡}|j|u �rÆ|j|u �sÊJ ‚| j| j d
|jj|jjf |j|j| j
|ƒ|d� t| |||¡|| j
| jd	�S �nrt|tƒ�r8|   |||¡S t|t!ƒ�rR|  "|||¡S |t#j$u �rj|  %||¡S |t&u �r€|  '||¡S t|tjjƒ�r8| |¡}| (| )|j¡d¡}tjj 	|j*d |¡}|j|u �sÔJ ‚| j| j d|jj|jjf |j||j*d | jƒ|d� tj |¡\}}|d u �s<|jtu�r"|jdk�r"tjj 	| j
|j*d  |¡}tjj 	|j|¡}|j|u �rŽ|j|u �rŽ|j|u �s’J ‚| j| j d|jj|jj|jjf |j|j|j| j
|j| jƒ|d� | j |d¡}| |||¡}|d u �rtj +||j, -d|jf¡| j
¡S |S �q�| jdk�rntjjj	d|d�}tjjj	d|d�}| j |d¡}| |||¡S tjj 	| j
|¡}tjj 	| j
|¡}| |¡}|j|u �rÌ|j|u �rÌ|j|u �rÌ|j|u �sÐJ ‚| j| j d|jj|jj|jj|jjf |j|j|j|j| j
| jƒ|d� | j |d¡}| |||¡S �nXt|tj.j/ƒ�rf|j}| | j ¡}|d u�rttj0 1| |d¡‚| j jj2�rº|j| jk�rºtj0 1| |d|j› dt| ƒj3› d| j› �¡‚tjj 	|j| j
 |¡}tjj 	|j| j
 |¡}|j4j|u �süJ ‚| j| j d|jj|jj|j4jjf |j|j|j4j|j| j
ƒ|d� | j 5|||j|¡}t||| j
| jd	�S t|tj.j6ƒ�r„|  7|||¡S t8t9|ƒƒ‚d S )NÚcuda)r3   r   Z$awkward_RegularArray_getitem_next_atr™   T)r;   Z'awkward_RegularArray_getitem_next_ranger(   Z6awkward_RegularArray_getitem_next_range_spreadadvanced)rW   Z2awkward_RegularArray_getitem_next_array_regularizeZ'awkward_RegularArray_getitem_next_arrayr   r¨   Z0awkward_RegularArray_getitem_next_array_advancedz:cannot mix jagged slice with NumPy-style advanced indexingz$cannot fit jagged slice with length z into z	 of size Z*awkward_RegularArray_getitem_jagged_expand):rƒ   r4   r   r   r€   Z_slicingZ	head_tailrš   r¢   r£   r<   r„   r3   ÚintÚ
to_backendr¤   r˜   r1   r~   r:   r9   r¥   Ú_getitem_nextr/   ÚsliceZderive_slice_for_lengthr;   r   r'   rJ   Z	to_npliker^   Z_getitem_next_fieldÚlistZ_getitem_next_fieldsrœ   ZnewaxisZ_getitem_next_newaxisÚEllipsisZ_getitem_next_ellipsisr…   Zasarrayr   Zgetitem_next_array_wrapÚmetadatar6   r�   r&   r    r¡   r5   r2   rV   r³   ÚIndexedOptionArrayZ_getitem_next_missingr«   rq   )r?   rµ   r´   r¶   r4   ZnextheadZnexttailr§   ÚnextcontentrŒ   r�   ÚstepZnextsizeZnextadvancedZflatheadZregular_flatheadrw   Z
headlengthZmultistartsZ
multistopsZdownrC   rC   rD   rº   Ë  sÒ   
ÿú÷ÿÿÿ÷ô
ÿÿü
ÿþþÿø
õü


þÿø
õ
ÿÿþÿþýýÿõò
ÿ
ÿþýüüÿôñ
ýýÿÿýÿöó
ÿÿzRegularArray._getitem_nextr¸   ztuple[Index, Content])ÚaxisÚdepthrR   c                 C  s   |   d¡ ||¡S rS   )rz   Ú_offsets_and_flattened)r?   rÂ   rÃ   rC   rC   rD   rÄ   É  s    z#RegularArray._offsets_and_flattened)ÚotherÚ	mergeboolrR   c                 C  sœ   |j s|jrdS |js|jr*|  |j|¡S t| j|jƒs<dS t|t	j
jt	j
jt	j
jfƒrh| j |j|¡S t|t	j
jƒr”t|jƒdkr”|  | ¡ |¡S dS d S )NTFrY   )Zis_identity_likeZis_unionZ
is_indexedÚ	is_optionÚ_mergeable_nextr@   r   rJ   r/   r€   r�   r'   Z	ListArrayr&   r9   r‚   Úlenr   Z_to_regular_primitive)r?   rÅ   rÆ   rC   rC   rD   rÈ   Ì  s"    ýþzRegularArray._mergeable_nextzSequence[Content])ÚothersrR   c                   sâ   t |ƒdkrˆ S tdd„ |D ƒƒr4tj ˆ ¡ |¡S dd„ |D ƒ}t‡ fdd„|D ƒƒrÎˆ j}g }ˆ j}|D ]6}t	||jƒ}| 
|jd |j|j … ¡ ||j7 }qltˆ jd ˆ jˆ j …  |¡ˆ j||d�S ˆ  d¡ |¡S d S )	Nr   c                 s  s   | ]}|j V  qd S rF   )rÇ   ©Ú.0ÚxrC   rC   rD   Ú	<genexpr>è  ó    z*RegularArray._mergemany.<locals>.<genexpr>c                 S  s&   g | ]}t |tjjƒr| ¡ n|‘qS rC   )r/   r€   r�   r‚   r{   )rÌ   ÚorC   rC   rD   Ú
<listcomp>ì  s   ÿz+RegularArray._mergemany.<locals>.<listcomp>c                 3  s    | ]}|j o|jˆ jkV  qd S rF   )Ú
is_regularrA   rË   rG   rC   rD   rÎ   ñ  rÏ   r(   T)rÉ   rŸ   r€   r�   ZUnmaskedArrayÚ
_mergemanyÚallrJ   r<   r   rp   r9   r:   r'   rz   )r?   rÊ   r)   Ztail_contentsrB   rÍ   rC   rG   rD   rÓ   ä  s,    þüzRegularArray._mergemany)ÚvaluerR   c                 C  s   t | j |¡| j| j| jd�S rI   )r'   r9   Ú
_fill_noner:   r<   rJ   )r?   rÕ   rC   rC   rD   rÖ     s    
üzRegularArray._fill_nonec                 C  sÈ   t | ||ƒ}|d ur(|d |kr(|  ¡ S |d ur¢|d |d kr¢tjjj| j| j | jj	d�}| j 
| jdtjf |j| j| jƒ¡ tj tj |j¡| j| j¡S tj | j ||d ¡| j| j¡S d S )NrY   r¨   Zawkward_RegularArray_localindex)r   Z_local_index_axis0r€   rš   r¢   r£   r<   r:   rƒ   r4   Úmaybe_kernel_errorrœ   r�   r~   r�   r'   r‚   r9   Ú_local_index)r?   rÂ   rÃ   ÚposaxisZ
localindexrC   rC   rD   rØ     s(    ÿýÿÿÿzRegularArray._local_indexc                 C  s$   t jj| j ||¡| j| j| jd�S rI   )r€   r�   r'   r9   Ú_numbers_to_typer:   r<   rJ   )r?   ÚnameZincluding_unknownrC   rC   rD   rÚ   #  s    üzRegularArray._numbers_to_typec                 C  s$   | j dkrdS |  d¡ ||||¡S )Nr   T)r<   rz   Ú
_is_unique)r?   ÚnegaxisrX   ÚparentsÚ	outlengthrC   rC   rD   rÜ   +  s    

üzRegularArray._is_uniquec                 C  sf   | j dkr| S |  d¡ ||||¡}t|tjjƒrbt|jtjjƒrbtjj|j 	¡ |j
|j |jd�S |S )Nr   Tr(   )r<   rz   Ú_uniquer/   r€   r�   r'   r9   r&   r{   r:   rJ   )r?   rÝ   rX   rÞ   rß   rw   rC   rC   rD   rà   6  s"    

üüzRegularArray._uniquec           
   	   C  sb   |   d¡}| |||||||¡}	t|	tjjƒr^t|	jtjjƒr^tjj|	j ¡ |	j	|	j
|	jd�S |	S ©NTr(   )rz   Ú_argsort_nextr/   r€   r�   r'   r9   r&   r{   r:   r<   rJ   )
r?   rÝ   rX   ÚshiftsrÞ   rß   Ú	ascendingÚstableÚnextrw   rC   rC   rD   râ   K  s    
ÿüzRegularArray._argsort_nextc                 C  s   |   d¡ ||||||¡}|S rS   )rz   Ú
_sort_next)r?   rÝ   rX   rÞ   rß   rä   rå   rw   rC   rC   rD   rç   ^  s    
ÿzRegularArray._sort_nextc              
   C  s¬  | j j}t| ||ƒ}|d ur8|d |kr8|  ||||¡S |d u�rZ|d |d k�rZ|  d¡dksp|  d¡dkrxtdƒ‚| j}	|rŽ|	|d  }	|}
|
|	kr d}nR|
|	kr®d}nD|
d |	krÂ|	|
 }
|	}td|
d ƒD ]}||	| d  }|| }qÔ|| j }|j	|t
jd�}g }t|ƒD ]<}tjjj	||t
jd	�}| |¡ | j jj�r|j||< �qtjjj	||t
jd�}tjjj	||t
jd�}| jdk�rê|j|u �r¦|j|u �sªJ ‚| j  | j d
t
j|jjj|jjjf ||j|j||| j| jƒ¡ g }t}|D ]$}| | j |d¡¡ |d j}�qö|tu�s*J ‚tjj||||| j d�}tjj||| j| jd�S | j| j }| j  d| !|¡¡ "||||||d ¡}tjj|| j| j| jd�S d S )NrY   r*   r+   r-   zgak.combinations does not compute combinations of the characters of a string; please split it into listsr   é   r—   )r„   r˜   Z$awkward_RegularArray_combinations_64TrW   r|   r(   )#rƒ   r4   r   Z_combinations_axis0r7   r8   r:   Úranger<   r£   rœ   r¬   r€   rš   r¢   r�   rp   r„   r5   Úptrr×   r~   r˜   r1   r   r9   r¥   r;   r�   ZRecordArrayr'   rJ   r†   r‹   Ú_combinations)r?   ÚnÚreplacementZrecordlookupr)   rÂ   rÃ   r4   rÙ   rA   ZthisnZcombinationslenÚjZtotallenZ
tocarryrawZtocarryÚirê   ZtoindexZ	fromindexr�   r;   Zrecordarrayræ   rC   rC   rD   rë   q  s®    ÿþÿ

ý
ÿÿýÿôÿûÿ
ÿþÿzRegularArray._combinationsc
                 C  s¤  | j j}
| j\}}| j| j }|�sœ||k�rœtjjj||
d�}tjjj||
d�}|j	|
u rp|j	|
u rp|j	|
u stJ ‚| j  
| j d|jj|jj|jjf |j|j|j| j| jƒ¡ tjjj|j| j |
d�}|j	|
u rÞ|j	|
u sâJ ‚| j  
| j d|jj|jjf |j|j|ƒ¡ |j�r,tjjj|j|
d�}nd }| j |d¡}|| j }| ||d |||||d|	¡	}tjj|| j|d d�}|�r˜tjj|d| jd d�}|S tjj ||
¡}|j	|
u �s¼J ‚| j  
| j d|jjf |j| j| jƒ¡ | jtu�r| jdk�rtjj|
 d|| j¡|
d�}n4|tu �s2|dk�s2J ‚tjj|
j|tjd	�|
d�}| j |||||| j|||	¡	}|�rŽ||d k�rŽ|j�s.J ‚n ||d
 k�r.|j�r"| d¡}|jd |j|jjd   }}|j ||¡}|jtu �s
|jtu �s
|j| j|j k�s
J ‚tjj|| j| jd�}n|j�s.J ‚tjj |d |
¡}|j	|
u �rZ|j	|
u �s^J ‚| j  
| j d|jj|jjf |j|j|j|ƒ¡ tjj ||d d�S d S )Nr¨   Z3awkward_RegularArray_reduce_nonlocal_preparenext_64Z5awkward_ListOffsetArray_reduce_nonlocal_nextstarts_64FrY   r(   Z0awkward_RegularArray_reduce_local_nextparents_64r   r—   rè   )rA   rB   Z2awkward_ListOffsetArray_reduce_local_outoffsets_64)!rƒ   r4   Zbranch_depthr<   r:   r€   rš   r¢   r£   r„   r×   r˜   r1   r~   r;   Zneeds_positionr©   r9   r¥   Ú_reduce_nextr�   r'   r   rª   rœ   r�   rÒ   Zis_listrz   rV   r@   r†   r&   )r?   ZreducerrÝ   rX   rã   rÞ   rß   ÚmaskÚkeepdimsÚbehaviorr4   ÚbranchrÃ   Znextlenr§   ZnextparentsZ
nextstartsZ
nextshiftsrÀ   ZnextoutlengthZ
outcontentrw   rŒ   r�   ZtrimmedZ
outoffsetsrC   rC   rD   rð   Î  s   
ÿþýýÿöÿ
ûÿÿþÿùÿÿ
ö
ÿÿÿúÿþþ÷%
þÿþýýþÿøÿzRegularArray._reduce_nextc                 C  s0   | j dk r d|› dt| ƒ›d�S | j |d ¡S )Nr   zat z (z): size < 0z.content)rA   r1   r9   Ú_validity_error)r?   ÚpathrC   rC   rD   rõ   ˜  s    
zRegularArray._validity_errorc                 C  s
   | j  ¡ S rF   )r@   Ú_nbytes_partrG   rC   rC   rD   r÷   ž  s    zRegularArray._nbytes_partc                 C  s   t | ||ƒ}|d ur,|d |kr,|  ||¡S |d urð|d |d krð|sh|| jk rV| S |  |||d¡S n†tjj | j| | j	j
¡}|j| j	j
u s”J ‚| j	 | j	d|jjf |j|| j| jƒ¡ tjjj|| j| jd�}tjj||| j| jd�S n,tjj| j |||d |¡| j| j| jd�S d S )NrY   TZ(awkward_RegularArray_rpad_and_clip_axis1r(   )r   Z_pad_none_axis0r:   Ú	_pad_noner€   rš   r¢   r£   r<   rƒ   r4   r„   r×   r˜   r1   r~   r�   r¿   rQ   r9   rJ   r'   )r?   ÚtargetrÂ   rÃ   ZcliprÙ   rš   ræ   rC   rC   rD   rø   ¡  sF    
þ
ÿþÿ
ÿüüzRegularArray._pad_nonec                 C  s²  |   d¡}|dkrä|  d¡}|jjdtjd�}|d| jjj|jj|jjf | jj	|j	|j
|ƒ |j |d ¡}|tur€td|ƒ}|| j
 }|jj|tjd�}| jd| jjj|jj|jjf | jj	|j	|j
||ƒ | t d	|f¡¡S |d
k�rB| jtu�r&| jdk�r&|jj| j
tjd� t d¡¡S | jj	 t d| jf¡¡S nl| j ||¡}	| j| jf|	jdd …  }
| jjj| jjjk�s„J ‚| jj |	d | jj | j| j ¡… |
¡S d S )Nr*   r+   TrY   r—   Z/awkward_NumpyArray_prepare_utf8_to_utf32_paddedr   Z'awkward_NumpyArray_utf8_to_utf32_paddedÚUr-   )ÚSrY   rû   )r7   rU   r4   r£   rœ   r�   r9   r˜   r1   r~   r;   r�   r   r­   r„   Zuint32r3   Úviewr:   r©   Zuint8Ú_to_backend_arrayr<   r   rƒ   r5   r…   r‹   )r?   Zallow_missingr3   Zarray_paramrV   Z_max_code_pointsZmax_code_pointsZtotal_code_pointsÚbufferrw   r   rC   rC   rD   rý   Ê  sn    

ýÿ÷ÿ

ýÿö
ÿÿ

ÿÿúzRegularArray._to_backend_arrayr   zContent | Noner!   )ÚpyarrowÚ	mask_nodeÚ
validbytesr;   Úoptionsc           
   
   C  sL  | j jjsJ ‚|  d¡dkr4|  d¡ |||||¡S |  d¡dk}| jd | j| j … }|r¼t	|t
jjƒsnJ ‚|j t
jj | | j¡|d |d || ¡| jt
jj |¡| | t¡¡g¡S | |d d | j| j |¡}| |j¡j | ¡ ¡}	|jjt
jj | |	| j¡|d |d || ¡| jt
jj |¡g|gt
jj ||d ¡d�S d S )	Nr*   r+   Fr-   ZextensionarrayZrecord_is_scalarZcount_nulls)ÚchildrenZ
null_count)rƒ   r„   r5   r7   rz   Ú	_to_arrowr9   r<   r:   r/   r€   r�   r‚   ZArrayZfrom_buffersÚ_connectrÿ   Zto_awkwardarrow_typeÚbinaryZto_validbitsZ	py_bufferÚ_rawÚnumpyÚlist_r1   Zvalue_fieldZwith_nullableZ_arrow_needs_option_typeZto_null_count)
r?   rÿ   r   r  r;   r  Zis_bytestringZ	akcontentZpaarrayÚcontent_typerC   rC   rD   r    sX    

ÿ
ûþ÷ÿÿûÿÿózRegularArray._to_arrowr    zlist[Content])r3   r  rR   c                   st   ˆ   d¡dksˆ   d¡dkr"ˆ gS ˆ jj}ˆ jd | ˆ jˆ j ¡… }| ||¡}|d rl‡ fdd„|D ƒS |S d S )Nr*   r+   r-   rò   c                   s   g | ]}t ||jˆ jd �‘qS ))rA   r)   )r'   r;   rJ   )rÌ   ÚcrG   rC   rD   rÑ   _  s   ÿz2RegularArray._remove_structure.<locals>.<listcomp>)r7   rƒ   r4   r9   r‹   r<   r:   Ú_remove_structure)r?   r3   r  r4   r@   r�   rC   rG   rD   r  P  s    ÿþÿ
þzRegularArray._remove_structurec                 C  s   |   ¡  ¡ S rF   )rz   Ú
_drop_nonerG   rC   rC   rD   r  f  s    zRegularArray._drop_noner   zMapping[str, Any] | Noner   )ÚactionrÃ   Údepth_contextÚlateral_contextr  rR   c              	     sÌ   ˆd r ˆ  d¡ ˆ ˆˆˆˆ¡S ˆjjjrBˆjd ˆjˆj … ‰nˆjdd� ˆj‰ˆd rv‡ ‡‡‡‡‡‡fdd„}n‡ ‡‡‡‡‡fdd„}ˆ ˆˆˆˆ|ˆjˆd�}t	|t
ƒr²|S |d u rÀ|ƒ S t|ƒ‚d S )	NZregular_to_jaggedFrf   Zreturn_arrayc                     s:   t ˆ ˆ ˆd t ˆ¡ˆˆ¡ˆjˆjˆd r2ˆjnd d�S )NrY   Zkeep_parametersr(   )r'   Ú_recursively_applyrK   r:   r<   rJ   rC   ©r  r@   rÃ   r  r  r  r?   rC   rD   Úcontinuation~  s    ûöz5RegularArray._recursively_apply.<locals>.continuationc                     s    ˆ  ˆ ˆd t ˆ¡ˆˆ¡ d S rŠ   )r  rK   rC   )r  r@   rÃ   r  r  r  rC   rD   r  Ž  s    û)rÃ   r  r  r  r3   r  )rz   r  rƒ   r„   r5   r9   r<   r:   rh   r/   r   r«   )r?   r  rÃ   r  r  r  r  ÚresultrC   r  rD   r  i  s2    

ÿ
	ù

zRegularArray._recursively_applyT)rg   rR   c                 C  sL   | j j}| j| j }| jd | |¡… }t|r8| d¡n|| j| j| jd�S rá   )	rƒ   r4   r<   r:   r9   r‹   r'   Ú	to_packedrJ   )r?   rg   r4   r;   r@   rC   rC   rD   r  ¨  s    üzRegularArray.to_packedc                 C  s¶  | j jjstdƒ‚|  d¡dkrÂ|d u r,d n|d }tj | jj	¡}| j
| j }}d g| }|d u r�t|ƒD ] }||| |d | … ||< qln.t|ƒD ]$}|||| |d | … ƒ||< q˜|S |  d¡dk�rB| jj	}	t|	dƒrîdd	„ }
nd
d	„ }
| j
| j }}d g| }t|ƒD ]&}|
|	|| |d | … ƒ||< �q|S |  ||¡}|d u�r\|S | j ||¡}| j
| j }}d g| }t|ƒD ]"}||| |d | … ||< �qŠ|S d S )Nz0cannot convert typetracer arrays to Python listsr*   r-   Úconvert_bytesrY   r+   Útobytesc                 S  s   |   ¡ jdd�S ©NÚsurrogateescape)Úerrors)r  Údecode©rÍ   rC   rC   rD   ÚtostringË  s    z'RegularArray._to_list.<locals>.tostringc                 S  s   |   ¡ jdd�S r  )r  r  r  rC   rC   rD   r  Ð  s    )rƒ   r„   r5   r0   r7   r€   Z_utilr  r9   r~   r<   r:   ré   ÚhasattrZ_to_list_customÚ_to_list)r?   ró   Zjson_conversionsr  r@   r;   rA   rw   rï   r~   r  rC   rC   rD   r  ´  sB    
ÿ
 "


$

 zRegularArray._to_list)r3   rR   c                 C  s"   | j  |¡}t|| j| j| jd�S )N)rB   r)   )r9   r¹   r'   r:   r<   rJ   )r?   r3   r@   rC   rC   rD   Ú_to_backendå  s    ÿzRegularArray._to_backend)rÅ   Úindex_dtypeÚ
numpyarrayÚall_parametersrR   c                 C  s@   |   ||¡o>| jtu s,|jtu s,| j|jko>| j |j|||¡S rF   )Z_is_equal_to_genericr:   r   rA   r9   Ú_is_equal_to)r?   rÅ   r!  r"  r#  rC   rC   rD   r$  ë  s    
ÿ
ü
ÿùzRegularArray._is_equal_to)r   )r   )F)rC   )rC   )T)Ar2   Ú
__module__Ú__qualname__Ú__doc__rE   ÚpropertyrA   r#   rH   Ú__annotations__r   rK   rL   rO   ÚclassmethodrQ   rV   rX   rZ   r]   rb   re   rh   rj   r;   rm   rl   rz   r{   r}   r‡   rˆ   rŽ   r†   r‘   r“   r¥   rU   ry   r³   rº   rÄ   rÈ   rÓ   rÖ   rØ   rÚ   rÜ   rà   râ   rç   rë   rð   rõ   r÷   rø   rý   r  r  r  r  r  r  r   r$  rC   rC   rC   rD   r'   4   sˆ   
E+

	 ÿ ÿ
37    ] K)F@?1r'   )?Ú
__future__r   rK   Úcollections.abcr   r   r   Zawkwardr€   Zawkward._backends.backendr   Zawkward._layoutr   Zawkward._meta.regularmetar   Zawkward._nplikes.array_liker	   Zawkward._nplikes.numpyr
   Zawkward._nplikes.numpy_liker   r   Zawkward._nplikes.shaper   r   Zawkward._parametersr   r   r   Zawkward._regularizer   r   Zawkward._slicingr   Zawkward._typingr   r   r   r   r   r   r   Zawkward._utilr   Zawkward.contents.contentr   r   r   r    r!   Zawkward.forms.formr"   Zawkward.forms.regularformr#   Zawkward.indexr$   r%   Z awkward.contents.listoffsetarrayr&   Úinstancerœ   r  r'   rC   rC   rC   rD   Ú<module>   s4   $	