a
    yn„f¶p  ã                   @  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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  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. d dl/m0Z0m1Z1m2Z2m3Z3m4Z4 d dl5m6Z6 d dl7m8Z8 d dl9m:Z: e$�rbd dl!m;Z; d dl<m=Z= e >¡ Z?e >¡ Z@e*G dd„ dee1 e1ƒƒZAdS )é    )ÚannotationsN)ÚMappingÚMutableMappingÚSequence)ÚBackend)ÚBitMaskedMeta)Ú	ArrayLike)ÚNumpy)Ú	IndexTypeÚNumpyMetadata)ÚPlaceholderArray)Ú	ShapeItemÚunknown_length)Ú	MaybeNoneÚ
TypeTracer)Ú
is_integerÚis_integer_like)ÚNO_HEAD)ÚTYPE_CHECKINGÚAnyÚCallableÚFinalÚSelfÚSupportsIndexÚfinal)ÚUNSET)ÚByteMaskedArray)ÚApplyActionOptionsÚContentÚImplementsApplyActionÚRemoveStructureOptionsÚToArrowOptions)ÚBitMaskedForm)Ú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d
d„ ƒZe	Z
ded< ee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/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$dSdSdFdFdWœdXdY„Z%dZd[d\dFd]œd^d_„Z&d­d`da„Z'dbdbdcddœdedf„Z(dFd#d#dgœdhdi„Z)djdk„ Z*dldFdmœdndo„Z+dFdFdpœdqdr„Z,dsdt„ Z-dudv„ Z.dwdx„ Z/dydz„ Z0d{d|„ Z1d}d~„ Z2dd€„ Z3d�d‚„ Z4dƒd„„ Z5d…d†„ Z6d‡dˆ„ Z7d‰dŠdŠdbd‹dŒœd�dŽ„Z8d�d�„ Z9dd‘d’d“œd”d•„Z:dFd.œd–d—„Z;d˜dbd™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 )¯ÚBitMaskedArraya‡  
    Like #ak.contents.ByteMaskedArray, BitMaskedArray implements an
    #ak.types.OptionType with two buffers, `mask` and `content`.
    However, the boolean `mask` values are packed into a bitmap.

    BitMaskedArray has an additional parameter, `lsb_order`; if True,
    the position of each bit is in
    [Least-Significant Bit order](https://en.wikipedia.org/wiki/Bit_numbering)
    (LSB):

        is_valid[j] = bool(mask[j // 8] & (1 << (j % 8))) == valid_when

    If False, the position of each bit is in Most-Significant Bit order
    (MSB):

        is_valid[j] = bool(mask[j // 8] & (128 >> (j % 8))) == valid_when

    If the logical size of the buffer is not a multiple of 8, the `mask`
    has to be padded. Thus, an explicit `length` is also part of the
    class's definition.

    This is equivalent to *all* of Apache Arrow's array types because they all
    [use bitmaps](https://arrow.apache.org/docs/format/Columnar.html#validity-bitmaps)
    to mask their data, with `valid_when=True` and `lsb_order=True`.

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

        class BitMaskedArray(Content):
            def __init__(self, mask, content, valid_when, length, lsb_order):
                assert isinstance(mask, IndexU8)
                assert isinstance(content, Content)
                assert isinstance(valid_when, bool)
                assert isinstance(length, int) and length >= 0
                assert isinstance(lsb_order, bool)
                assert len(mask) <= len(content)
                self.mask = mask
                self.content = content
                self.valid_when = valid_when
                self.length = length
                self.lsb_order = lsb_order

            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)
                    if self.lsb_order:
                        bit = bool(self.mask[where // 8] & (1 << (where % 8)))
                    else:
                        bit = bool(self.mask[where // 8] & (128 >> (where % 8)))
                    if bit == self.valid_when:
                        return self.content[where]
                    else:
                        return None

                elif isinstance(where, slice) and where.step is None:
                    # In general, slices must convert BitMaskedArray to ByteMaskedArray.
                    bytemask = np.unpackbits(
                        self.mask, bitorder=("little" if self.lsb_order else "big")
                    ).view(bool)
                    return ByteMaskedArray(
                        bytemask[where.start : where.stop],
                        self.content[where.start : where.stop],
                        valid_when=self.valid_when,
                    )

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

                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|›�ƒ‚|turÖt|ƒr¾|dksÖtt| ƒj› d|› �ƒ‚t |tƒsøtt| ƒj› d|›�ƒ‚|jjj�rP|tu�rP|jtu�rP||jd k�rPtt| ƒj› d	|› d
|jd › d�ƒ‚|jjj�r¤|tu�r¤|jtu�r¤||jd k�r¤tt| ƒj› d	|› d|j› d�ƒ‚|j|jju �s¸J ‚|| _|| _|| _|| _|| _|  ||j¡ d S )Nz/ 'mask' must be an Index with dtype=uint8, 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 r   z. 'length' must be a non-negative integer, not z" 'lsb_order' must be boolean, not é   z 'length' (z) must be <= len(mask) * 8 (ú)z) must be <= len(content) ()Ú
isinstancer$   ÚdtypeÚnpZuint8Ú	TypeErrorÚtypeÚ__name__r   Úis_unionÚ
is_indexedÚ	is_optionÚformatÚboolr   r   ÚbackendÚindex_nplikeÚ
known_dataÚlengthÚ
ValueErrorÚnplikeÚ_maskÚ_contentÚ_valid_whenÚ_lengthÚ
_lsb_orderÚ_init©ÚselfÚmaskÚcontentÚ
valid_whenr:   Ú	lsb_orderr)   © rI   úb/home/yuhw/wc/wire-cell-python/wcpy/lib/python3.9/site-packages/awkward/contents/bitmaskedarray.pyÚ__init__ˆ   sn    ÿ
ÿÿÿ
ÿÿ
ÿÿþýü ÿÿþýüÿzBitMaskedArray.__init__c                 C  s   | j S ©N)r=   ©rD   rI   rI   rJ   rE   Á   s    zBitMaskedArray.maskc                 C  s   | j S rL   )r?   rM   rI   rI   rJ   rG   Å   s    zBitMaskedArray.valid_whenc                 C  s   | j S rL   )rA   rM   rI   rI   rJ   rH   É   s    zBitMaskedArray.lsb_orderr   Ú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||tu rP| jn||tu r`| jn|d�S ©Nr(   )r'   r   r=   r>   r?   r@   rA   Ú_parametersrC   rI   rI   rJ   ÚcopyÏ   s    
úzBitMaskedArray.copyc                 C  s   |   ¡ S rL   )rQ   rM   rI   rI   rJ   Ú__copy__â   s    zBitMaskedArray.__copy__c                 C  s.   | j t  | j|¡t  | j|¡t  | j|¡d�S )N)rE   rF   r)   )rQ   Údeepcopyr=   r>   rP   )rD   ÚmemorI   rI   rJ   Ú__deepcopy__å   s
    ýzBitMaskedArray.__deepcopy__c          	      C  s´   |j s|js|jrœ|j}tjj |jd |j	¡}| 
|d|jj|jjf | |j¡|j|j||ƒ¡ |j r~| |d|… |¡S tjjj|d|… ||d�S n| ||||||d�S d S ©Nr*   Z,awkward_BitMaskedArray_to_IndexedOptionArrayr   r(   )r2   r3   r4   r7   ÚakÚindexÚIndex64Úemptyr:   r8   Úmaybe_kernel_errorr-   r0   Úrawr<   ÚdataZ_union_of_optionarraysÚcontentsr&   Ú
simplified)	ÚclsrE   rF   rG   r:   rH   r)   r7   rX   rI   rI   rJ   r_   ì   s<    þÿ
÷ÿÿúzBitMaskedArray.simplifiedzCallable[[Content], str | None]r"   )ÚgetkeyÚreturnc                 C  s0   || ƒ}| j | jj| j |¡| j| j| j|d�S )N)r)   Úform_key)rN   r=   Úformr>   Ú_form_with_keyr?   rA   rP   )rD   ra   rc   rI   rI   rJ   re     s    
úzBitMaskedArray._form_with_keyr#   z#Callable[[Content, Form, str], str]zMutableMapping[str, ArrayLike]r   Ústr)rd   ra   Ú	containerr7   Ú	byteorderc                 C  sR   t || jƒsJ ‚|| |dƒ}tj | j |j¡|¡||< | j 	|j
||||¡ d S )NrE   )r,   rN   rW   Z_utilZnative_to_byteorderr=   r\   r8   r>   Ú_to_buffersrF   )rD   rd   ra   rg   r7   rh   ÚkeyrI   rI   rJ   ri   "  s    ÿzBitMaskedArray._to_buffersr6   r   )Úforget_lengthrb   c                 C  s<   t  ¡ }t| j |¡| j |¡| j|r*tn| j	| j
| jd�S rO   )r   Úinstancer'   r=   Ú	to_npliker>   Ú_to_typetracerr?   r   r:   rA   rP   )rD   rk   ÚttrI   rI   rJ   rn   1  s    

úzBitMaskedArray._to_typetracer©Ú	recursivec                 C  s   | j  ¡  |r| j |¡ d S rL   )r=   Ú_touch_datar>   ©rD   rq   rI   rI   rJ   rr   <  s    
zBitMaskedArray._touch_datac                 C  s   | j  ¡  |r| j |¡ d S rL   )r=   Ú_touch_shaper>   rs   rI   rI   rJ   rt   A  s    
zBitMaskedArray._touch_shaper   )rb   c                 C  s   | j S rL   )r@   rM   rI   rI   rJ   r:   F  s    zBitMaskedArray.lengthc                 C  s   |   ddd¡S )NÚ )Ú_reprrM   rI   rI   rJ   Ú__repr__J  s    zBitMaskedArray.__repr__c                 C  sÜ   ||dg}|  tt | j¡ƒ¡ |  d¡ |  tt | j¡ƒ¡ |  d¡ |  tt| jƒƒ¡ |  d¡ | |  	|d ¡¡ |  d¡ |  | j
 |d dd¡¡ |  | j |d d	d
¡¡ |  |d ¡ |  |¡ d |¡S )Nz<BitMaskedArray valid_when=z lsb_order=z len=ú>z    Ú
z<mask>z</mask>
z	<content>z</content>
z</BitMaskedArray>ru   )ÚappendÚreprÚjsonÚdumpsr?   rA   rf   r:   ÚextendZ_repr_extrar=   rv   r>   Újoin)rD   ÚindentÚpreÚpostÚoutrI   rI   rJ   rv   M  s    





zBitMaskedArray._reprr&   c                 C  s¢   t jj | jjd | jj¡}|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| j| jƒ¡ t jj|d| j… | j| jd�S rV   )rW   rX   rY   rZ   r=   r:   Ú_backendr8   r<   r[   r-   r0   r\   r]   r?   rA   r^   r&   r@   r>   rP   )rD   rX   rI   rI   rJ   Úto_IndexedOptionArray64]  s0    ÿÿþþÿ÷ÿÿz&BitMaskedArray.to_IndexedOptionArray64c                 C  s˜   t jj | jjd | jj¡}|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| jƒ¡ t|d | j… | j| j| jd�S )Nr*   Ú)awkward_BitMaskedArray_to_ByteMaskedArrayFr(   )rW   rX   ÚIndex8rZ   r=   r:   r„   r8   r<   r[   r-   r0   r]   rA   r   r@   r>   r?   rP   )rD   ÚbytemaskrI   rI   rJ   Úto_ByteMaskedArrayv  s6    ÿÿþþÿ÷ÿüz!BitMaskedArray.to_ByteMaskedArrayc                 C  s´   || j krJ|| jkr| S ttj | jj | j	j
¡¡| j|| j|| jd�S nf|rRdnd}| jjj| j	j
|d�}| jjj||d�}|| jkrŽ| }ttj |¡| j|| j|| jd�S d S )Nr(   ÚlittleÚbig)Zbitorder)rA   r?   r'   rW   rX   ZIndexU8r„   r8   Zlogical_notr=   r]   r>   r@   rP   r7   Z
unpackbitsZpackbits)rD   rG   rH   Z	bit_orderrˆ   ZbitmaskrI   rI   rJ   Úto_BitMaskedArray’  s8    

ÿøÿ

úz BitMaskedArray.to_BitMaskedArrayc                 C  s¶   |d u r| j }tjj | jjd | jj¡}|j	| jj	u rH| jj	| jj	u sLJ ‚| j 
| jd|jj| jjjf |j| jj| jj|| j krˆdnd| jƒ¡ |jd | jj | j¡…  tj¡S )Nr*   r†   r   é   )r?   rW   rX   r‡   rZ   r=   r:   r„   r8   r<   r[   r-   r0   r]   rA   Zshape_item_as_indexr@   Úviewr.   Zbool_)rD   rG   rˆ   rI   rI   rJ   Úmask_as_boolµ  s8    ÿÿþþÿ÷ÿÿþzBitMaskedArray.mask_as_boolc                 C  s   | j  dd¡S ©Nr   )r>   Ú_getitem_rangerM   rI   rI   rJ   Ú_getitem_nothingÑ  s    zBitMaskedArray._getitem_nothingc                 C  s   t | jtƒrdS | j ¡ S ©NT)r,   r=   r   r>   Ú_is_getitem_at_placeholderrM   rI   rI   rJ   r”   Ô  s    z)BitMaskedArray._is_getitem_at_placeholderr
   )Úwherec                 C  sÊ   | j jjs&| jdd� t| j |¡ƒS |dk r8|| j7 }d|  krN| jk shn | j jjrhtj	 
| |¡‚| jrŽt| j|d  d|d > @ ƒ}nt| j|d  d|d ? @ ƒ}|| jkrÂ| j |¡S d S d S )NFrp   r   r*   r�   é€   )r„   r<   r9   rr   r   r>   Ú_getitem_atr:   rW   Ú_errorsZindex_errorrA   r6   r=   r?   )rD   r•   ÚbitrI   rI   rJ   r—   Ù  s    

" 
zBitMaskedArray._getitem_atr   )ÚstartÚstoprb   c                 C  s   |   ¡  ||¡S rL   )r‰   r‘   )rD   rš   r›   rI   rI   rJ   r‘   ë  s    zBitMaskedArray._getitem_rangerI   zstr | SupportsIndexztuple[str, ...])r•   Úonly_fieldsrb   c                 C  s(   t j| j| j ||¡| j| j| jd d�S rO   )r'   r_   r=   r>   Ú_getitem_fieldr?   r@   rA   ©rD   r•   rœ   rI   rI   rJ   r�   î  s    úzBitMaskedArray._getitem_fieldzlist[str | SupportsIndex]c                 C  s(   t j| j| j ||¡| j| j| jd d�S rO   )r'   r_   r=   r>   Ú_getitem_fieldsr?   r@   rA   rž   rI   rI   rJ   rŸ   ú  s    úzBitMaskedArray._getitem_fieldsr$   )ÚcarryÚ
allow_lazyrb   c                 C  s"   t |tjjƒsJ ‚|  ¡  ||¡S rL   )r,   rW   rX   r$   r‰   Ú_carry)rD   r    r¡   rI   rI   rJ   r¢     s    zBitMaskedArray._carry)ÚslicestartsÚ
slicestopsÚslicecontentrb   c                 C  s   |   ¡  ||||¡S rL   )r‰   Ú_getitem_next_jagged)rD   r£   r¤   r¥   ÚtailrI   rI   rJ   r¦   
  s    ÿz#BitMaskedArray._getitem_next_jaggedzSliceItem | tupleztuple[SliceItem, ...]zIndex | None)Úheadr§   Úadvancedrb   c                 C  sÄ   |t u r| S t|ƒs,t|ttjjtjjfƒr>|  	¡  
|||¡S t|tƒrV|  |||¡S t|tƒrn|  |||¡S |tju r„|  ||¡S |tu r˜|  ||¡S t|tjjƒr´|  |||¡S tt|ƒƒ‚d S rL   )r   r   r,   ÚslicerW   rX   rY   r^   ZListOffsetArrayr‰   Ú_getitem_nextrf   Z_getitem_next_fieldÚlistZ_getitem_next_fieldsr.   ZnewaxisZ_getitem_next_newaxisÚEllipsisZ_getitem_next_ellipsisr&   Z_getitem_next_missingÚAssertionErrorr{   )rD   r¨   r§   r©   rI   rI   rJ   r«     s"    
ÿ


zBitMaskedArray._getitem_nextc                 C  s   |   ¡  |¡S rL   )r‰   Úproject)rD   rE   rI   rI   rJ   r¯   1  s    zBitMaskedArray.projectÚintztuple[Index, Content])ÚaxisÚdepthrb   c                 C  s   |   ¡  ||¡S rL   )r‰   Ú_offsets_and_flattened©rD   r±   r²   rI   rI   rJ   r³   4  s    z%BitMaskedArray._offsets_and_flattened)ÚotherÚ	mergeboolrb   c                 C  s>   |j s|jrdS |js|jr,| j |j|¡S | j ||¡S d S r“   )Zis_identity_liker2   r4   r3   r>   Ú_mergeable_nextrF   )rD   rµ   r¶   rI   rI   rJ   r·   7  s
    zBitMaskedArray._mergeable_nextc                 C  s   |   ¡  |¡S rL   )r…   Ú_reverse_merge)rD   rµ   rI   rI   rJ   r¸   A  s    zBitMaskedArray._reverse_mergezSequence[Content])Úothersrb   c                   sL   t |ƒdkrˆ S ˆ  ¡  |¡}t‡ fdd„|D ƒƒrD| ˆ jˆ j¡S |S d S )Nr   c                 3  s0   | ](}t |tƒo&|jˆ jko&|jˆ jkV  qd S rL   )r,   r'   r?   rA   )Ú.0ÚxrM   rI   rJ   Ú	<genexpr>J  s
   ý

ÿz,BitMaskedArray._mergemany.<locals>.<genexpr>)Úlenr…   Ú
_mergemanyÚallrŒ   r?   rA   )rD   r¹   rƒ   rI   rM   rJ   r¾   D  s    üzBitMaskedArray._mergemany)Úvaluerb   c                 C  s   |   ¡  |¡S rL   )r…   Ú
_fill_none)rD   rÀ   rI   rI   rJ   rÁ   T  s    zBitMaskedArray._fill_nonec                 C  s   |   ¡  ||¡S rL   )r‰   Ú_local_indexr´   rI   rI   rJ   rÂ   W  s    zBitMaskedArray._local_indexc                 C  s   |   ¡  ||¡S rL   )r‰   Ú_numbers_to_type)rD   ÚnameZincluding_unknownrI   rI   rJ   rÃ   Z  s    zBitMaskedArray._numbers_to_typec                 C  s$   | j jdkrdS |  ¡  ||||¡S )Nr   T)r=   r:   r…   Ú
_is_unique)rD   ÚnegaxisÚstartsÚparentsÚ	outlengthrI   rI   rJ   rÅ   ]  s
    ÿzBitMaskedArray._is_uniquec                 C  s:   | j jdkr| S |  ¡  ||||¡}|d u r0|S |jS d S r�   )r=   r:   r…   Ú_uniquer>   )rD   rÆ   rÇ   rÈ   rÉ   rƒ   rI   rI   rJ   rÊ   d  s    ÿzBitMaskedArray._uniquec              	   C  s   |   ¡  |||||||¡S rL   )r…   Ú_argsort_next)rD   rÆ   rÇ   ÚshiftsrÈ   rÉ   Ú	ascendingÚstablerI   rI   rJ   rË   o  s    ÿzBitMaskedArray._argsort_nextc                 C  s   |   ¡  ||||||¡S rL   )r…   Ú
_sort_next)rD   rÆ   rÇ   rÈ   rÉ   rÍ   rÎ   rI   rI   rJ   rÏ   v  s    ÿzBitMaskedArray._sort_nextc                 C  s   |   ¡  ||||||¡S rL   )r‰   Ú_combinations)rD   ÚnÚreplacementZrecordlookupr)   r±   r²   rI   rI   rJ   rÐ   {  s    ÿzBitMaskedArray._combinationsc
           
      C  s   |   ¡  |||||||||	¡	S rL   )r‰   Ú_reduce_next)
rD   ZreducerrÆ   rÇ   rÌ   rÈ   rÉ   rE   ZkeepdimsÚbehaviorrI   rI   rJ   rÓ   €  s    ÷zBitMaskedArray._reduce_nextc                 C  s`   | j jd | jk r(d|› dt| ƒ›d�S | jj| jk rLd|› dt| ƒ›d�S | j |d ¡S d S )Nr*   zat z (z): len(mask) * 8 < lengthz): len(content) < lengthz.content)rE   r:   r0   r>   Ú_validity_error)rD   ÚpathrI   rI   rJ   rÕ   ˜  s
    zBitMaskedArray._validity_errorc                 C  s   | j  ¡ | j ¡  S rL   )rE   Ú_nbytes_partrF   rM   rI   rI   rJ   r×      s    zBitMaskedArray._nbytes_partc                 C  s   |   ¡  ||||¡S rL   )r‰   Ú	_pad_none)rD   Útargetr±   r²   ZcliprI   rI   rJ   rØ   £  s    zBitMaskedArray._pad_noner   zContent | Noner!   )ÚpyarrowÚ	mask_nodeÚ
validbytesr:   Úoptionsc                 C  s   |   ¡  |||||¡S rL   )r‰   Ú	_to_arrow)rD   rÚ   rÛ   rÜ   r:   rÝ   rI   rI   rJ   rÞ   ¦  s    
ÿzBitMaskedArray._to_arrowc                 C  s   |   ¡  ||¡S rL   )r‰   Ú_to_backend_array)rD   Zallow_missingr7   rI   rI   rJ   rß   ²  s    z BitMaskedArray._to_backend_arrayr    zlist[Content])r7   rÝ   rb   c                 C  s8   | j \}}|s|d s|dkr.|  ¡  ||¡S | gS d S )NZ
drop_nonesr�   )Zbranch_depthr¯   Ú_remove_structure)rD   r7   rÝ   Úbranchr²   rI   rI   rJ   rà   µ  s    
z BitMaskedArray._remove_structurec                 C  s   |   ¡  ¡ S rL   )r‰   Ú
_drop_nonerM   rI   rI   rJ   râ   ¾  s    zBitMaskedArray._drop_noner   zMapping[str, Any] | Noner   )Úactionr²   Údepth_contextÚlateral_contextrÝ   rb   c              	     s°   ˆj jjrˆjdˆj… ‰nˆj‰ˆd rZˆ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                	     s>   ˆˆj ˆ ˆ ˆt ˆ¡ˆˆ¡ˆjˆjˆjˆd r6ˆjnd d�S )NZkeep_parametersr(   )r=   Ú_recursively_applyrQ   r?   r@   rA   rP   rI   ©rã   rF   r²   rä   rå   ÚmakerÝ   rD   rI   rJ   ÚcontinuationÔ  s    ûôz7BitMaskedArray._recursively_apply.<locals>.continuationc                     s   ˆ  ˆ ˆt ˆ¡ˆˆ¡ d S rL   )ræ   rQ   rI   )rã   rF   r²   rä   rå   rÝ   rI   rJ   ré   æ  s    û)r²   rä   rå   ré   r7   rÝ   )
r„   r<   r9   r>   r@   r'   r_   r,   r   r®   )rD   rã   r²   rä   rå   rÝ   ré   ÚresultrI   rç   rJ   ræ   Á  s.    
	ù

z!BitMaskedArray._recursively_applyT)rq   rb   c                 C  sÐ   | j jrP|  ¡ }|r*|j d | j…  d¡n|j d | j… }tjj|j||j	d�S t
t | jd ¡ƒ}| jj|krx| j}n| jd |… }|r | j d | j…  d¡n| j d | j… }t||| j| j| j| j	d�S d S )NTr(   g       @)r>   Z	is_recordr…   r@   Ú	to_packedrW   r^   r&   Ú_indexrP   r°   ÚmathÚceilr=   r:   r'   r?   rA   )rD   rq   ÚnextrF   Zexcess_lengthrE   rI   rI   rJ   rë      s2    ÿý
ÿÿýúzBitMaskedArray.to_packedc                 C  sz   | j jjstdƒ‚|  ||¡}|d ur*|S | jdd�d | j… }| j d| j¡ 	||¡}t
|ƒD ]\}}|s`d ||< q`|S )Nz0cannot convert typetracer arrays to Python listsT)rG   r   )r„   r<   r9   r/   Z_to_list_customr�   r@   r>   r‘   Ú_to_listÚ	enumerate)rD   rÔ   Zjson_conversionsrƒ   rE   ÚiZisvalidrI   rI   rJ   rð   $  s    
ÿ
zBitMaskedArray._to_list)r7   rb   c                 C  s8   | j  |¡}| j |j¡}t||| jt| ƒ| j| j	d�S )N)rG   r:   rH   r)   )
r>   Z
to_backendr=   rm   r8   r'   r?   r½   rA   rP   )rD   r7   rF   rE   rI   rI   rJ   Ú_to_backend7  s    úzBitMaskedArray._to_backend)rµ   Úindex_dtypeÚ
numpyarrayÚall_parametersrb   c                 C  sJ   |   ||¡oH| j|jkoH| j|jkoH| j |j||¡oH| j 	|j
|||¡S rL   )Z_is_equal_to_genericr?   rG   rA   rH   r=   Zis_equal_torE   r>   Ú_is_equal_torF   )rD   rµ   rô   rõ   rö   rI   rI   rJ   r÷   C  s    
ÿ
þý
ÿûzBitMaskedArray._is_equal_to)N)rI   )rI   )N)T)Ar1   Ú
__module__Ú__qualname__Ú__doc__rK   ÚpropertyrE   rG   rH   r"   rN   Ú__annotations__r   rQ   rR   rU   Úclassmethodr_   re   ri   rn   rr   rt   r:   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÷   rI   rI   rI   rJ   r'   3   s’   
Tÿ9


úø	ø*#
 ÿ ÿ 

	?$r'   )BÚ
__future__r   rQ   r|   rí   Úcollections.abcr   r   r   ZawkwardrW   Zawkward._backends.backendr   Zawkward._meta.bitmaskedmetar   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._regularizer   r   Zawkward._slicingr   Zawkward._typingr   r   r   r   r   r   r   Zawkward._utilr   Z awkward.contents.bytemaskedarrayr   Zawkward.contents.contentr   r   r   r    r!   Zawkward.forms.bitmaskedformr"   Zawkward.forms.formr#   Zawkward.indexr$   r%   Zawkward.contentsr&   rl   r.   Únumpyr'   rI   rI   rI   rJ   Ú<module>   s:   $	