a
    yn„f€¥  ã                   @  s¤  d dl mZ d dlZd dl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 d dlmZmZ d dlmZmZ d dl m!Z! d dl"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l0m1Z1m2Z2m3Z3m4Z4m5Z5 d dl6m7Z7 d dl8m9Z9 d dl:m;Z; d dl<m=Z= e'�rvd dl$m>Z> d dl?m@Z@ e A¡ ZBe A¡ ZCe-G dd„ dee2 e2ƒƒZDdS )é    )ÚannotationsN)ÚMappingÚMutableMappingÚSequence)ÚBackend)Úmaybe_posaxis)ÚByteMaskedMeta)Ú	ArrayLike)ÚNumpy)Ú	IndexTypeÚNumpyMetadata)ÚPlaceholderArray)Ú	ShapeItemÚunknown_length)Ú	MaybeNoneÚ
TypeTracer)Úparameters_intersect)Úis_integer_like)ÚNO_HEAD)ÚTYPE_CHECKINGÚAnyÚCallableÚFinalÚSelfÚSupportsIndexÚfinal)ÚUNSET)ÚApplyActionOptionsÚContentÚImplementsApplyActionÚRemoveStructureOptionsÚToArrowOptions)Ú	AxisError)ÚByteMaskedForm)ÚForm)ÚIndex)Ú	SliceItem)ÚIndexedOptionArrayc                   @  s  e Zd ZU dZddœdd„Ze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„ƒ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&œd)d*„Zed+d,œd-d.„ƒZd/d0„ Zd1d2„ Zd3d4„ Zd5d,œd6d7„Zd8d9„ Zd:d;„ Zd¯d<d=„Zd>d?„ Zd!d,œd@dA„ZdBdCœdDdE„Z dBdBdFdGœdHdI„Z!d°dKdLdFdMœdNdO„Z"d±dPdLdFdMœdQdR„Z#dSd!dFdTœdUdV„Z$dWd,œdXdY„Z%dZd[„ Z&dSdSdFdFd\œd]d^„Z'd_d`dadFdbœdcdd„Z(d²dedf„Z)dgdgdhdiœdjdk„Z*dFd!d!dlœdmdn„Z+dodp„ Z,dqdFdrœdsdt„Z-dFdFduœdvdw„Z.dxdy„ Z/dzd{„ Z0d|d}„ Z1d~d„ Z2d€d�„ Z3d‚dƒ„ Z4d„d…„ Z5d†d‡„ Z6dˆd‰„ Z7dŠd‹„ Z8dŒd�„ Z9dŽd�d�dgd�d‘œd’d“„Z:d”d•„ Z;dd–d—d˜œd™dš„Z<dFd,œd›dœ„Z=d�dgdždždŸd�d œd¡d¢„Z>d³d!d"d¤œd¥d¦„Z?d§d¨„ Z@dd"d©œdªd«„ZAd"d!d!d!d!d¬œd­d®„ZBdS )´ÚByteMaskedArraya¡  
    The ByteMaskedArray implements an #ak.types.OptionType with two aligned
    buffers, a boolean `mask` and `content`. At any element `i` where
    `mask[i] == valid_when`, the value can be found at `content[i]`. If
    `mask[i] != valid_when`, the value is missing (None).

    This is equivalent to NumPy's
    [masked arrays](https://docs.scipy.org/doc/numpy/reference/maskedarray.html)
    if `valid_when=False`.

    There is no Apache Arrow equivalent because Arrow
    [uses bitmaps](https://arrow.apache.org/docs/format/Columnar.html#validity-bitmaps)
    to mask all node types.

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

        class ByteMaskedArray(Content):
            def __init__(self, mask, content, valid_when):
                assert isinstance(mask, Index8)
                assert isinstance(content, Content)
                assert isinstance(valid_when, bool)
                assert len(mask) <= len(content)
                self.mask = mask
                self.content = content
                self.valid_when = valid_when

            def __len__(self):
                return len(self.mask)

            def __getitem__(self, where):
                if isinstance(where, int):
                    if where < 0:
                        where += len(self)
                    assert 0 <= where < len(self)
                    if self.mask[where] == self.valid_when:
                        return self.content[where]
                    else:
                        return None

                elif isinstance(where, slice) and where.step is None:
                    return ByteMaskedArray(
                        self.mask[where.start : where.stop],
                        self.content[where.start : where.stop],
                        valid_when=self.valid_when,
                    )

                elif isinstance(where, str):
                    return ByteMaskedArray(
                        self.mask, self.content[where], valid_when=self.valid_when
                    )

                else:
                    raise AssertionError(where)
    N©Ú
parametersc                C  s,  t |tƒr|jt tj¡ks4tt| ƒj› d|›�ƒ‚t |tƒsVtt| ƒj› d|›�ƒ‚|j	sh|j
sh|jr„td t| ƒjt|ƒj¡ƒ‚t |tƒs¦tt| ƒj› d|›�ƒ‚|jjjrô|jturô|jturô|j|jkrôtt| ƒj› d|j› d|j› d�ƒ‚|j|jju �sJ ‚|| _|| _|| _|  ||j¡ d S )Nz. 'mask' must be an Index with dtype=int8, not z* 'content' must be a Content subtype, not zd{0} cannot contain a union-type, option-type, or indexed 'content' ({1}); try {0}.simplified insteadz# 'valid_when' must be boolean, not z len(mask) (z) must be <= len(content) (ú))Ú
isinstancer%   ÚdtypeÚnpÚint8Ú	TypeErrorÚtypeÚ__name__r   Úis_unionÚ
is_indexedÚ	is_optionÚformatÚboolÚbackendÚindex_nplikeÚ
known_dataÚlengthr   Ú
ValueErrorÚnplikeÚ_maskÚ_contentÚ_valid_whenÚ_init©ÚselfÚmaskÚcontentÚ
valid_whenr*   © rG   úc/home/yuhw/wc/wire-cell-python/wcpy/lib/python3.9/site-packages/awkward/contents/bytemaskedarray.pyÚ__init__q   sD    ÿ
ÿÿÿ
ÿÿþý
üÿzByteMaskedArray.__init__c                 C  s   | j S ©N)r>   ©rC   rG   rG   rH   rD   •   s    zByteMaskedArray.maskc                 C  s   | j S rJ   )r@   rK   rG   rG   rH   rF   ™   s    zByteMaskedArray.valid_whenr   Ú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   r>   r?   r@   Ú_parametersrB   rG   rG   rH   ÚcopyŸ   s    üzByteMaskedArray.copyc                 C  s   |   ¡ S rJ   )rO   rK   rG   rG   rH   Ú__copy__§   s    zByteMaskedArray.__copy__c                 C  s.   | j t  | j|¡t  | j|¡t  | j|¡d�S )N)rD   rE   r*   )rO   Údeepcopyr>   r?   rN   )rC   ÚmemorG   rG   rH   Ú__deepcopy__ª   s
    ýzByteMaskedArray.__deepcopy__c                C  s–   |j s|js|jr‚|j}tjjj|j|j	d�}| 
|d|jj|jjf |j|j|j|ƒ¡ |j rl| ||¡S tjjj|||d�S n| ||||d�S d S ©N©r=   Z,awkward_ByteMaskedArray_toIndexedOptionArrayr)   )r3   r4   r5   r8   ÚakÚindexÚIndex64Úemptyr;   r9   Úmaybe_kernel_errorr-   r1   ÚdataZ_union_of_optionarraysÚcontentsr'   Ú
simplified)ÚclsrD   rE   rF   r*   r8   rW   rG   rG   rH   r]   ±   s,    	þÿøÿÿzByteMaskedArray.simplifiedzCallable[[Content], str | None]r#   )ÚgetkeyÚreturnc                 C  s,   || ƒ}| j | jj| j |¡| j| j|d�S )N)r*   Úform_key)rL   r>   Úformr?   Ú_form_with_keyr@   rN   )rC   r_   ra   rG   rG   rH   rc   Ò   s    
ûzByteMaskedArray._form_with_keyr$   z#Callable[[Content, Form, str], str]zMutableMapping[str, ArrayLike]r   Ústr)rb   r_   Ú	containerr8   Ú	byteorderc                 C  sR   t || jƒsJ ‚|| |dƒ}tj | j |j¡|¡||< | j 	|j
||||¡ d S )NrD   )r,   rL   rV   Z_utilZnative_to_byteorderr>   Úrawr9   r?   Ú_to_buffersrE   )rC   rb   r_   re   r8   rf   ÚkeyrG   rG   rH   rh   Ü   s    ÿzByteMaskedArray._to_buffersr7   r   )Úforget_lengthr`   c                 C  s<   t  ¡ }| j |¡}t|r"| ¡ n|| j |¡| j| j	d�S rM   )
r   Úinstancer>   Ú	to_npliker(   rj   r?   Ú_to_typetracerr@   rN   )rC   rj   ÚttrD   rG   rG   rH   rm   ë   s    
üzByteMaskedArray._to_typetracer©Ú	recursivec                 C  s   | j  ¡  |r| j |¡ d S rJ   )r>   Ú_touch_datar?   ©rC   rp   rG   rG   rH   rq   õ   s    
zByteMaskedArray._touch_datac                 C  s   | j  ¡  |r| j |¡ d S rJ   )r>   Ú_touch_shaper?   rr   rG   rG   rH   rs   ú   s    
zByteMaskedArray._touch_shaper   )r`   c                 C  s   | j jS rJ   )r>   r;   rK   rG   rG   rH   r;   ÿ   s    zByteMaskedArray.lengthc                 C  s   t | j ¡ | j| j| jd�S rM   )r(   r>   rj   r?   r@   rN   rK   rG   rG   rH   Ú_forget_length  s    üzByteMaskedArray._forget_lengthc                 C  s   |   ddd¡S )NÚ )Ú_reprrK   rG   rG   rH   Ú__repr__  s    zByteMaskedArray.__repr__c                 C  s¼   ||dg}|  tt | j¡ƒ¡ |  d¡ |  tt| jƒƒ¡ |  d¡ | |  |d ¡¡ |  d¡ |  | j	 
|d dd¡¡ |  | j 
|d dd	¡¡ |  |d
 ¡ |  |¡ d |¡S )Nz<ByteMaskedArray valid_when=z len=ú>z    Ú
z<mask>z</mask>
z	<content>z</content>
z</ByteMaskedArray>ru   )ÚappendÚreprÚjsonÚdumpsr@   rd   r;   ÚextendZ_repr_extrar>   rv   r?   Újoin)rC   ÚindentÚpreÚpostÚoutrG   rG   rH   rv     s    




zByteMaskedArray._reprr'   c                 C  sŠ   t jjj| jj| jjd�}|j| jju r8| jj| jju s<J ‚| j 	| jd|j
j| jj
jf |j| jj| jj| jƒ¡ t jj|| j| jd�S rT   )rV   rW   rX   rY   r>   r;   Ú_backendr9   r=   rZ   r-   r1   r[   r@   r\   r'   r?   rN   )rC   rW   rG   rG   rH   Úto_IndexedOptionArray64  s.    ÿÿþþÿøÿ
ÿz'ByteMaskedArray.to_IndexedOptionArray64c              
   C  s\   || j kr| S ttj | jjj| jj | jjj| j	j
tjd�¡tjd�¡| j|| jd�S d S )N©r-   r)   )r@   r(   rV   rW   ÚIndex8r„   r9   ZastypeZlogical_notr>   r[   r.   Zbool_r/   r?   rN   ©rC   rF   rG   rG   rH   Úto_ByteMaskedArray4  s"    

ÿÿúÿ
óz"ByteMaskedArray.to_ByteMaskedArrayc                 C  sÊ   | j jjsp| jdd� | j jjr6tt | jd ¡ƒ}nt}t	j
jt	j | j jj|tjd�¡| j|| j|| jd�S |rxdnd}|  |¡ tj¡}| jjj||d�}t	j
jt	j |¡| j|| j|| jd�S d S )	NFro   g       @r†   r)   ÚlittleÚbig)Zbitorder)r„   r=   r:   rq   ÚintÚmathÚceilr;   r   rV   r\   ZBitMaskedArrayrW   ZIndexU8rY   r.   Zuint8r?   rN   Úmask_as_boolÚviewr8   r9   Zpackbits)rC   rF   Z	lsb_orderZexcess_lengthZ	bit_orderZbytemaskZbitmaskrG   rG   rH   Úto_BitMaskedArrayH  s4    

ÿø
úz!ByteMaskedArray.to_BitMaskedArrayc                 C  sD   |d u r| j }|| j kr,| j | jj¡dkS | j | jj¡dkS d S )Nr   é   )r@   r>   rg   r„   r9   rˆ   rG   rG   rH   r�   h  s
    
zByteMaskedArray.mask_as_boolc                 C  s   | j  dd¡S ©Nr   )r?   Ú_getitem_rangerK   rG   rG   rH   Ú_getitem_nothingq  s    z ByteMaskedArray._getitem_nothingc                 C  s   t | jtƒrdS | j ¡ S ©NT)r,   r>   r   r?   Ú_is_getitem_at_placeholderrK   rG   rG   rH   r—   t  s    z*ByteMaskedArray._is_getitem_at_placeholderr   )Úwherec                 C  sŒ   | j jjs&| jdd� t| j |¡ƒS |dk r8|| j7 }| j jjrhd|  krX| jk shn tj	 
| |¡‚| j| | jkr„| j |¡S d S d S )NFro   r   )r„   r=   r:   rq   r   r?   Ú_getitem_atr;   rV   Ú_errorsÚindex_errorr>   r@   )rC   r˜   rG   rG   rH   r™   y  s    

"zByteMaskedArray._getitem_atr   )ÚstartÚstopr`   c                 C  sB   | j jjs| jdd� | S t| j||… | j ||¡| j| j	d�S )NFro   r)   )
r„   r=   r:   rs   r(   r>   r?   r”   r@   rN   )rC   rœ   r�   rG   rG   rH   r”   ‡  s    
üzByteMaskedArray._getitem_rangerG   zstr | SupportsIndexztuple[str, ...])r˜   Úonly_fieldsr`   c                 C  s    t j| j| j ||¡| jd d�S rM   )r(   r]   r>   r?   Ú_getitem_fieldr@   ©rC   r˜   rž   rG   rG   rH   rŸ   “  s    üzByteMaskedArray._getitem_fieldzlist[str | SupportsIndex]c                 C  s    t j| j| j ||¡| jd d�S rM   )r(   r]   r>   r?   Ú_getitem_fieldsr@   r    rG   rG   rH   r¡   �  s    üzByteMaskedArray._getitem_fieldsr%   )ÚcarryÚ
allow_lazyr`   c              
   C  s€   t |tjjƒsJ ‚z| j|j }W n< ty^ } z$tj | |jt	|ƒ¡|‚W Y d }~n
d }~0 0 t
j|| j ||¡| j| jd�S rM   )r,   rV   rW   r%   r>   r[   Ú
IndexErrorrš   r›   rd   r(   r]   r?   Ú_carryr@   rN   )rC   r¢   r£   ÚnextmaskÚerrrG   rG   rH   r¥   §  s    .üzByteMaskedArray._carryz.tuple[int, ak.index.Index64, ak.index.Index64]c                 C  s:  t jjjd| jjd�}|j| jju r4| jj| jju s8J ‚| j | jd|j	j
| jj	j
f |j| jj| jj| jƒ¡ | jj |d ¡}t jjj| j| | jjd�}t jjj| j| jjd�}|j| jju râ|j| jju râ| jj| jju sæJ ‚| j | jd|j	j
|j	j
| jj	j
f |j|j| j | jj¡| jj| jƒ¡ |||fS )Nr’   rU   Úawkward_ByteMaskedArray_numnullr   Z2awkward_ByteMaskedArray_getitem_nextcarry_outindex)rV   rW   rX   rY   r„   r9   r=   r>   rZ   r-   r1   r[   r;   r@   Úindex_as_shape_itemrg   )rC   Ú_numnullÚnumnullÚ	nextcarryÚoutindexrG   rG   rH   Ú_nextcarry_outindex¶  s`    ÿþþÿøÿþ
ÿÿþýýÿöÿz#ByteMaskedArray._nextcarry_outindexc              
   C  sx  |j jrZ| jj jrZ|j| jkrZtj | tjj|||d d�d|j› dt	| ƒj
› d| j› �¡‚|  ¡ \}}}tjjj| j| | jjd�}tjjj| j| | jjd�}	|j | jju ræ|j | jju ræ|j | jju ræ|j | jj u ræ|	j | jj u sêJ ‚| j| jd|jj	|jj	|jj	|jj	|	jj	f |j|j|j|j|	j| jƒtj |||¡d� | j |d¡}
|
 ||	||¡}tjjj||| jd�S )	Nr)   z$cannot fit jagged slice with length z into z	 of size rU   Z/awkward_MaskedArray_getitem_next_jagged_project)ZslicerT)r=   r:   r„   r;   rV   rš   r›   r\   Z	ListArrayr1   r2   r®   rW   rX   rY   r9   Z_maybe_index_errorr-   r[   r?   r¥   Ú_getitem_next_jaggedr'   r]   rN   )rC   ÚslicestartsÚ
slicestopsÚslicecontentÚtailr«   r¬   r­   ZreducedstartsZreducedstopsÚnextrƒ   rG   rG   rH   Ú_getitem_next_jagged_genericæ  sp    ÿþ
ýÿûþþÿþýüûûÿóðÿz,ByteMaskedArray._getitem_next_jagged_generic)r°   r±   r²   r`   c                 C  s   |   ||||¡S rJ   )rµ   )rC   r°   r±   r²   r³   rG   rG   rH   r¯      s    ÿz$ByteMaskedArray._getitem_next_jaggedzSliceItem | tupleztuple[SliceItem, ...]zIndex | None)Úheadr³   Úadvancedr`   c           	      C  sò   |t u r| S t|ƒs,t|ttjjtjjfƒrl|  	¡ \}}}| j
 |d¡}| |||¡}tjjj||| jd�S t|tƒr„|  |||¡S t|tƒrœ|  |||¡S |tju r²|  ||¡S |tu rÆ|  ||¡S t|tjjƒrâ|  |||¡S tt|ƒƒ‚d S ©NTr)   )r   r   r,   ÚslicerV   rW   rX   r\   ÚListOffsetArrayr®   r?   r¥   Ú_getitem_nextr'   r]   rN   rd   Z_getitem_next_fieldÚlistZ_getitem_next_fieldsr.   ZnewaxisZ_getitem_next_newaxisÚEllipsisZ_getitem_next_ellipsisZ_getitem_next_missingÚAssertionErrorr{   )	rC   r¶   r³   r·   Ú_r¬   r­   r´   rƒ   rG   rG   rH   r»   '  s,    
ÿÿ


zByteMaskedArray._getitem_nextc           	      C  sö  | j j}tjjjd| jjd�}|d u�r| jjj	r`||jkr`t
d|j› dt| ƒj› d|› d�ƒ‚tjjj|| jjd�}|j| jju r¢|j| jju r¢| j j| jju s¦J ‚| j | jd|jj|jj| j jjf |j|j| j j|| jƒ¡ d}t|| j|| jd	�}| ¡ S |j| jju �r&| j j| jju �s*J ‚| j | jd
|jj| j jjf |j| j j|| jƒ¡ | jj |d ¡}tjjj|| | jjd�}|j| jju �r¬| j j| jju �s°J ‚| j | jd|jj| j jjf |j| j j|| jƒ¡ | j |d¡S d S )Nr’   rU   zmask length (z) is not equal to z	 length (r+   Z$awkward_ByteMaskedArray_overlay_maskFr)   r¨   r   Z)awkward_ByteMaskedArray_getitem_nextcarry)r>   r;   rV   rW   rX   Zzerosr„   r9   r=   r:   r<   r1   r2   r‡   rY   rZ   r-   r[   r@   r(   r?   rN   Úprojectr©   r¥   )	rC   rD   Úmask_lengthrª   r¦   rF   r´   r«   r¬   rG   rG   rH   rÀ   L  s–    
ÿÿÿþýýÿöÿÿÿþþÿøÿÿÿþþÿøÿzByteMaskedArray.projectrŒ   ztuple[Index, Content])ÚaxisÚdepthr`   c                 C  s  t | ||ƒ}|d ur*|d |kr*tdƒ‚nà|  ¡ \}}}| j |d¡}| ||¡\}}	|jdkrx|tjj	||	| j
d�fS tjjj|j| | jjtjd�}
|
j| jju rÂ|j| jju rÂ|j| jju sÆJ ‚| j | jd|
jj|jj|jjf |
j|j|j|j|jƒ¡ |
|	fS d S )Nr’   zaxis=0 not allowed for flattenFr   r)   )r=   r-   Z'awkward_IndexedArray_flatten_none2empty)r   r"   r®   r?   r¥   Ú_offsets_and_flattenedr;   rV   r\   r'   rN   rW   rX   rY   r„   r9   r.   Zint64r=   rZ   r-   r1   r[   )rC   rÂ   rÃ   Úposaxisr«   r¬   r­   r´   ÚoffsetsZ	flattenedÚ
outoffsetsrG   rG   rH   rÄ   š  sN    

ÿþýÿþýýÿöÿz&ByteMaskedArray._offsets_and_flattened)ÚotherÚ	mergeboolr`   c                 C  s>   |j s|jrdS |js|jr,| j |j|¡S | j ||¡S d S r–   )Zis_identity_liker3   r5   r4   r?   Ú_mergeable_nextrE   )rC   rÈ   rÉ   rG   rG   rH   rÊ   É  s
    zByteMaskedArray._mergeable_nextc                 C  s   |   ¡  |¡S rJ   )r…   Ú_reverse_merge)rC   rÈ   rG   rG   rH   rË   Ó  s    zByteMaskedArray._reverse_mergezSequence[Content])Úothersr`   c           	        sö   t |ƒdkrˆ S t‡ fdd„|D ƒƒräˆ j}ˆ jj ˆ j¡}ˆ jjd |… g}g }d}|D ]T}ˆ jj |j¡}t	||jƒ}| 
|jjd |… ¡ | 
|jd |… ¡ ||j7 }qZttj ˆ jj |¡¡ˆ jd |…  |¡ˆ j|d�S ˆ  ¡  |¡S d S )Nr   c                 3  s$   | ]}t |tƒo|jˆ jkV  qd S rJ   )r,   r(   r@   )Ú.0ÚxrK   rG   rH   Ú	<genexpr>Ú  s   ÿz-ByteMaskedArray._mergemany.<locals>.<genexpr>r)   )ÚlenÚallrN   r„   r9   Zshape_item_as_indexr;   r>   r[   r   rz   r?   r(   rV   rW   r‡   r=   ÚconcatÚ
_mergemanyr@   r…   )	rC   rÌ   r*   Zself_length_scalarÚmasksZtail_contentsr;   rÎ   Zlength_scalarrG   rK   rH   rÓ   Ö  s2    þÿüzByteMaskedArray._mergemany)Úvaluer`   c                 C  s   |   ¡  |¡S rJ   )r…   Ú
_fill_none)rC   rÕ   rG   rG   rH   rÖ   ö  s    zByteMaskedArray._fill_nonec           	      C  sj   t | ||ƒ}|d ur(|d |kr(|  ¡ S |  ¡ \}}}| j |d¡}| ||¡}tjjj	||| j
d�S d S )Nr’   Fr)   )r   Z_local_index_axis0r®   r?   r¥   Ú_local_indexrV   r\   r'   r]   rN   )	rC   rÂ   rÃ   rÅ   r¿   r¬   r­   r´   rƒ   rG   rG   rH   r×   ù  s    ÿzByteMaskedArray._local_indexc                 C  s$   t jj| j| j ||¡| j| jd�S rM   )rV   r\   r(   r>   r?   Ú_numbers_to_typer@   rN   )rC   ÚnameZincluding_unknownrG   rG   rH   rØ     s    üz ByteMaskedArray._numbers_to_typec                 C  s$   | j jdkrdS |  ¡  ||||¡S )Nr   T)r>   r;   r…   Ú
_is_unique©rC   ÚnegaxisÚstartsÚparentsÚ	outlengthrG   rG   rH   rÚ     s
    ÿzByteMaskedArray._is_uniquec                 C  s$   | j jdkr| S |  ¡  ||||¡S r“   )r>   r;   r…   Ú_uniquerÛ   rG   rG   rH   rà     s
    ÿzByteMaskedArray._uniquec              	   C  s   |   ¡  |||||||¡S rJ   )r…   Ú_argsort_next)rC   rÜ   rÝ   ÚshiftsrÞ   rß   Ú	ascendingÚstablerG   rG   rH   rá     s    ÿzByteMaskedArray._argsort_nextc                 C  s   |   ¡  ||||||¡S rJ   )r…   Ú
_sort_next)rC   rÜ   rÝ   rÞ   rß   rã   rä   rG   rG   rH   rå   #  s    ÿzByteMaskedArray._sort_nextc                 C  sˆ   |dk rt dƒ‚t| ||ƒ}|d ur@|d |kr@|  ||||¡S |  ¡ \}}	}
| j |	d¡}| ||||||¡}tjj	j
|
||d�S d S )Nr’   z'in combinations, 'n' must be at least 1Tr)   )r<   r   Z_combinations_axis0r®   r?   r¥   Ú_combinationsrV   r\   r'   r]   )rC   ÚnÚreplacementZrecordlookupr*   rÂ   rÃ   rÅ   r¿   r¬   r­   r´   rƒ   rG   rG   rH   ræ   (  s    ÿÿzByteMaskedArray._combinationsc
                 C  s’  | j j}
tjjjd| jjd�}|j| jju r<| j j| jju s@J ‚| j 	| jd|j
j| j j
jf |j| j j|
| jƒ¡ | jj |d ¡}|
| }tjjj|| jjd�}tjjj|| jjd�}tjjj|
| jjd�}|j| jju �r"|j| jju �r"|j| jju �r"| j j| jju �r"|j| jju �s&J ‚| j 	| jd|j
j|j
j|j
j| j j
j|j
jf |j|j|j| j j|j|
| jƒ¡ | j\}}|j�r||�s|||k�r|tjjj|| jjd�}|d u �r|j| jju �rÜ| j j| jju �sàJ ‚| j 	| jd|j
j| j j
jf |j| j j|
| jƒ¡ nd|j| jju �r8| j j| jju �s<J ‚| j 	| jd|j
j| j j
j|j
jf |j| j j|
| j|jƒ¡ nd }| j |d¡}| |||||||||	¡	}|�s¼||k�r¼|S t|tjjƒ�rÔ|j}n2t|tjjƒ�rú|j|jd d … }ntd	| ƒ‚tjjj|jd | jjd�}|j| jju �s6J ‚| j 	| jd
|j
j|j
jf |j|j|j|jƒ¡ tjjj||d d�}tjj||d d�S d S )Nr’   rU   r¨   r   Z&awkward_ByteMaskedArray_reduce_next_64Z:awkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_64ZEawkward_ByteMaskedArray_reduce_next_nonlocal_nextshifts_fromshifts_64Fz€reduce_next with unbranching depth > negaxis is only expected to return RegularArray or ListOffsetArray64; instead, it returned Z/awkward_IndexedArray_reduce_next_fix_offsets_64r)   )r>   r;   rV   rW   rX   rY   r„   r9   r=   rZ   r-   r1   r[   r@   r©   Úbranch_depthZneeds_positionr?   r¥   Ú_reduce_nextr,   r\   ZRegularArrayrE   rº   rÆ   r<   r'   r]   )rC   ZreducerrÜ   rÝ   râ   rÞ   rß   rD   ZkeepdimsÚbehaviorrÁ   rª   r«   Znext_lengthr¬   Znextparentsr­   ÚbranchrÃ   Z
nextshiftsr´   rƒ   Zout_contentrÇ   ÚtmprG   rG   rH   rê   9  s$   ÿþþÿøÿÿÿÿÿþýüûûÿòÿ
ÿ
ÿþþÿøÿÿþýÿöÿ÷þÿÿþÿøÿÿzByteMaskedArray._reduce_nextc                 C  sD   | j jjr0| jj| jjk r0d|› dt| ƒ›d�S | j |d ¡S d S )Nzat z (z): len(content) < len(mask)z.content)r„   r=   r:   r?   r;   rD   r1   Ú_validity_error)rC   ÚpathrG   rG   rH   rî   ß  s    zByteMaskedArray._validity_errorc                 C  s   | j  ¡ | j ¡  S rJ   )rD   Ú_nbytes_partrE   rK   rG   rG   rH   rð   å  s    zByteMaskedArray._nbytes_partc           	      C  s  t | ||ƒ}|d ur,|d |kr,|  ||¡S |d urð|d |d krðtj | jdd�¡}tjjj|j| j	j
d�}|j| j	j
u rŽ| jj| j	j
u s’J ‚| j	 | j	d|jj| jjjf |j| jj| jjƒ¡ |  ¡  ||||¡}tjjj||| jd�S tjj| j| j ||||¡| j| jd�S d S )Nr’   F©rF   rU   Z3awkward_IndexedOptionArray_rpad_and_clip_mask_axis1r)   )r   Z_pad_none_axis0rV   rW   r‡   r�   rX   rY   r;   r„   r9   r=   r>   rZ   r-   r1   r[   rÀ   Ú	_pad_noner\   r'   r]   rN   r(   r?   r@   )	rC   ÚtargetrÂ   rÃ   ZcliprÅ   rD   rW   r´   rG   rG   rH   rò   è  sD    
ÿÿþþÿùÿÿüzByteMaskedArray._pad_noner   zContent | Noner!   )ÚpyarrowÚ	mask_nodeÚ
validbytesr;   Úoptionsc                 C  s,   | j dd�}| j || tjj ||¡||¡S )NTrñ   )r�   r?   Ú	_to_arrowrV   Ú_connectrô   Zand_validbytes)rC   rô   rõ   rö   r;   r÷   Zthis_validbytesrG   rG   rH   rø     s    ûzByteMaskedArray._to_arrowc                 C  s   |   ¡  ||¡S rJ   )r…   Ú_to_backend_array)rC   Zallow_missingr8   rG   rG   rH   rú     s    z!ByteMaskedArray._to_backend_arrayr    zlist[Content])r8   r÷   r`   c                 C  s8   | j \}}|s|d s|dkr.|  ¡  ||¡S | gS d S )NZ
drop_nonesr’   )ré   rÀ   Ú_remove_structure)rC   r8   r÷   rì   rÃ   rG   rG   rH   rû   !  s    
z!ByteMaskedArray._remove_structurec                 C  s   |   ¡ S rJ   )rÀ   rK   rG   rG   rH   Ú
_drop_none*  s    zByteMaskedArray._drop_noner   zMapping[str, Any] | Noner   )ÚactionrÃ   Údepth_contextÚlateral_contextr÷   r`   c              	     s²   ˆj jjrˆjdˆjj… ‰nˆj‰ˆd r\ˆd r<tj‰nt‰‡ ‡‡‡‡‡‡‡fdd„}n‡ ‡‡‡‡‡fdd„}ˆ ˆˆˆˆ|ˆj ˆd�}t|t	ƒr˜|S |d u r¦|ƒ S t
|ƒ‚d S )Nr   Zreturn_arrayZreturn_simplifiedc                	     s6   ˆˆj ˆ ˆ ˆt ˆ¡ˆˆ¡ˆjˆd r.ˆjnd d�S )NZkeep_parametersr)   )r>   Ú_recursively_applyrO   r@   rN   rG   ©rý   rE   rÃ   rþ   rÿ   Úmaker÷   rC   rG   rH   Úcontinuation@  s    ûöz8ByteMaskedArray._recursively_apply.<locals>.continuationc                     s   ˆ  ˆ ˆt ˆ¡ˆˆ¡ d S rJ   )r   rO   rG   )rý   rE   rÃ   rþ   rÿ   r÷   rG   rH   r  P  s    û)rÃ   rþ   rÿ   r  r8   r÷   )r„   r=   r:   r?   r>   r;   r(   r]   r,   r   r¾   )rC   rý   rÃ   rþ   rÿ   r÷   r  ÚresultrG   r  rH   r   -  s.    
	ù

z"ByteMaskedArray._recursively_applyT)rp   r`   c                 C  sœ   | j jrT|  ¡ }|r,|j d | jj…  d¡n|j d | jj… }tjj|j	||j
d�S |rp| j d | jj…  d¡n| j d | jj… }t| j|| j| j
d�S d S r¸   )r?   Z	is_recordr…   r>   r;   Ú	to_packedrV   r\   r'   Ú_indexrN   r(   r@   )rC   rp   r´   rE   rG   rG   rH   r  j  s     ÿý
ÿÿýÿzByteMaskedArray.to_packedc                 C  sp   | j jjstdƒ‚|  ||¡}|d ur*|S | jdd�}| j d|j¡ 	||¡}t
|ƒD ]\}}|sVd ||< qV|S )Nz0cannot convert typetracer arrays to Python listsTrñ   r   )r„   r=   r:   r0   Z_to_list_customr�   r?   r”   ÚsizeÚ_to_listÚ	enumerate)rC   rë   Zjson_conversionsrƒ   rD   ÚiZisvalidrG   rG   rH   r  ƒ  s    
ÿ
zByteMaskedArray._to_list)r8   r`   c                 C  s.   | j  |¡}| j |j¡}t||| j| jd�S )N)rF   r*   )r?   Z
to_backendr>   rl   r9   r(   r@   rN   )rC   r8   rE   rD   rG   rG   rH   Ú_to_backend–  s
    ÿzByteMaskedArray._to_backend)rÈ   Úindex_dtypeÚ
numpyarrayÚall_parametersr`   c                 C  s>   |   ||¡o<| j|jko<| j |j||¡o<| j |j|||¡S rJ   )	Z_is_equal_to_genericr@   rF   r>   Zis_equal_torD   r?   Ú_is_equal_torE   )rC   rÈ   r  r  r  rG   rG   rH   r  �  s    
ÿþ
ÿüzByteMaskedArray._is_equal_to)N)rG   )rG   )N)T)Cr2   Ú
__module__Ú__qualname__Ú__doc__rI   ÚpropertyrD   rF   r#   rL   Ú__annotations__r   rO   rP   rS   Úclassmethodr]   rc   rh   rm   rq   rs   r;   rt   rw   rv   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á   rå   ræ   rê   rî   rð   rò   rø   rú   rû   rü   r   r  r  r  r  rG   rG   rG   rH   r(   7   s†   
8$

ú 

 
	 ÿ ÿ
0:%
N/
  '$	=r(   )EÚ
__future__r   rO   r|   r�   Úcollections.abcr   r   r   ZawkwardrV   Zawkward._backends.backendr   Zawkward._layoutr   Zawkward._meta.bytemaskedmetar   Zawkward._nplikes.array_liker	   Zawkward._nplikes.numpyr
   Zawkward._nplikes.numpy_liker   r   Zawkward._nplikes.placeholderr   Zawkward._nplikes.shaper   r   Zawkward._nplikes.typetracerr   r   Zawkward._parametersr   Zawkward._regularizer   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.errorsr"   Zawkward.forms.bytemaskedformr#   Zawkward.forms.formr$   Zawkward.indexr%   r&   Zawkward.contentsr'   rk   r.   Únumpyr(   rG   rG   rG   rH   Ú<module>   s>   $	