Ë
    ¤ehRÙ  ã                  óH  — d dl mZ d dlmZmZmZmZmZ d dlZd dl	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mZmZmZmZmZ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* d dl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 d dl2m3Z3 d dl4m5Z5m6Z6m7Z7m8Z8 d dl9m:Z;m<Z<mZm=Z=m>Z> d dl?m@Z@mAZAmBZBmCZCmDZD d dlEmFZFmGZG d dlHmIZI d dlJmKZK d dlLmMZM d dlNmOZO d dlPmQZRmSZSmTZT d dlUmVZV d dlWmXZX d dlYmZZZ er"d dl[m\Z\m]Z] d dl^m_Z_ d dl`maZa d dlmbZbmcZc d dl`mdZd d dlemfZg  G d „ d!eKeO«      Zh	 	 	 	 d#d"„Ziy)$é    )Úannotations)ÚTYPE_CHECKINGÚAnyÚCallableÚLiteralÚoverloadN)ÚlibÚmissing)Úis_supported_dtype)Ú	ArrayLikeÚ	AstypeArgÚAxisIntÚDtypeObjÚFillnaOptionsÚInterpolateOptionsÚNpDtypeÚPositionalIndexerÚScalarÚScalarIndexerÚSelfÚSequenceIndexerÚShapeÚnpt)ÚIS64Úis_platform_windows©ÚAbstractMethodError)Údoc)Úvalidate_fillna_kwargs)ÚExtensionDtype)Úis_boolÚis_integer_dtypeÚis_list_likeÚ	is_scalarÚis_string_dtypeÚpandas_dtype)ÚBaseMaskedDtype)Úarray_equivalentÚis_valid_na_for_dtypeÚisnaÚnotna)Ú
algorithmsÚ	arrayliker
   ÚnanopsÚops)Úfactorize_arrayÚisinÚ	map_arrayÚmodeÚtake)Úmasked_accumulationsÚmasked_reductions)Úquantile_with_mask)ÚOpsMixin)Úto_numpy_dtype_inference)ÚExtensionArray)ÚarrayÚensure_wrapped_if_datetimelikeÚextract_array)Úcheck_array_indexer)Úinvalid_comparison)Ú
hash_array)ÚIteratorÚSequence)ÚSeries©ÚBooleanArray)ÚNumpySorterÚNumpyValueArrayLike©ÚFloatingArray)Úfunctionc                  ó�  ‡ — e Zd ZU dZded<   ded<   ded<   eZeZedgd„«       Z		 dh	 	 	 	 	 	 	 did
„Z
edd	dœdjd„«       Ze eej                  «      dkd„«       «       Zdhdld„Zedmd„«       Zednd„«       Zedod„«       Zdpd„Zddddœ	 	 	 	 	 	 	 	 	 dqd„Z eej*                  «      	 dr	 	 	 	 	 dsd„«       Zed	dœ	 	 	 	 	 dtd„«       Zd„ Zdud„Zdvˆ fd„Zdwd„Zdxd„Zedyd„«       Zedxd „«       Zdzd!„Zd{d|d#„Zdzd$„Z dzd%„Z!edzd&„«       Z"d{d}d'„Z#dzd(„Z$dzd)„Z%dzd*„Z&dzd+„Z'd~d,„Z(dd	e)jT                  f	 	 	 	 	 	 	 dd-„Z+ eejX                  «      d.„ «       Z,ed€d�d/„«       Z-ed€d‚d0„«       Z-ed€dƒd1„«       Z-d„dƒd2„Z-d3Z.	 d…	 	 	 	 	 d†d4„Z/d5ed6<   d‡d7„Z0dˆd8„Z1edvd9„«       Z2	 	 	 	 d‰d:„Z3d;„ Z4e4Z5dŠd<„Z6	 	 	 	 d‹d=„Z7d~d>„Z8ed?„ «       Z9edxd@„«       Z:e	 d{	 	 	 	 	 dŒdA„«       Z;	 	 	 	 	 	 	 	 d�dB„Z<d	dd"dCœ	 	 	 	 	 	 	 dŽdD„Z=d�dE„Z>dzdF„Z? eej€                  «      	 d�	 	 	 d‘dG„«       Z@dzdH„ZA eej„                  «      	 	 d’	 	 	 	 	 	 	 d“dI„«       ZB eej†                  «      	 d„	 	 	 d”dJ„«       ZC eejˆ                  «      d~dK„«       ZDd„d•dL„ZEd„d–dM„ZF eejŽ                  «      dvdN„«       ZG	 	 	 	 	 	 d—dO„ZHdd	dPœ	 	 	 	 	 d˜dQ„ZId™dR„ZJdS„ ZK	 	 d™dT„ZLdd"d"dUœ	 	 	 	 	 dšdV„ZMdd"d"dUœ	 	 	 	 	 dšdW„ZNdd"dXœd›dY„ZOdd"dZd[œ	 	 	 	 	 dœd\„ZPdd"dZd[œ	 	 	 	 	 dœd]„ZQdd"dXœd›d^„ZRdd"dXœd›d_„ZSdˆd`„ZTdd"dXœd›da„ZUdd"dXœd›db„ZV	 	 	 	 	 	 	 	 d�dc„ZWdddœ	 	 	 	 	 džde„ZX	 	 	 	 	 	 	 	 	 	 dŸdf„ZYˆ xZZS ) ÚBaseMaskedArrayzf
    Base class for masked arrays (which use _data and _mask to store the data).

    numpy based
    r   Ú_internal_fill_valueú
np.ndarrayÚ_dataúnpt.NDArray[np.bool_]Ú_maskc                óL   — t         j                  | «      }||_        ||_        |S ©N)rL   Ú__new__rO   rQ   )ÚclsÚvaluesÚmaskÚresults       úW/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/pandas/core/arrays/masked.pyÚ_simple_newzBaseMaskedArray._simple_new|   s%   € ä ×(Ñ(¨Ó-ˆØˆŒØˆŒØˆó    Fc                ó0  — t        |t        j                  «      r|j                  t        j                  k(  st        d«      ‚|j                  |j                  k7  rt        d«      ‚|r |j                  «       }|j                  «       }|| _	        || _
        y )NzGmask should be boolean numpy array. Use the 'pd.array' function insteadz"values.shape must match mask.shape)Ú
isinstanceÚnpÚndarrayÚdtypeÚbool_Ú	TypeErrorÚshapeÚ
ValueErrorÚcopyrO   rQ   )ÚselfrV   rW   re   s       rY   Ú__init__zBaseMaskedArray.__init__ƒ   sx   € ô ˜4¤§¡Ô,°·±¼r¿x¹xÒ1GÜð2óð ð �<‰<˜4Ÿ:™:Ò%ÜÐAÓBÐBáØ—[‘[“]ˆFØ—9‘9“;ˆDàˆŒ
Øˆ�
r[   N©r`   re   c               óB   — | j                  |||¬«      \  }} | ||«      S )Nrh   )Ú_coerce_to_array)rU   Úscalarsr`   re   rV   rW   s         rY   Ú_from_sequencezBaseMaskedArray._from_sequence–   s*   € à×+Ñ+¨G¸5ÀtÐ+ÓL‰ˆ�Ù�6˜4Ó Ð r[   c                ó  — t        j                  ||j                  ¬«      }|j                  | j                  «       t        j
                  |t        ¬«      } | ||«      }t        || «      r||j                  k7  rt        d|› d�«      ‚|S )N©r`   z5Default 'empty' implementation is invalid for dtype='ú')
r^   ÚemptyÚtypeÚfillrM   ÚonesÚboolr]   r`   ÚNotImplementedError)rU   rc   r`   rV   rW   rX   s         rY   Ú_emptyzBaseMaskedArray._empty›   s{   € ô —‘˜% u§z¡zÔ2ˆØ�‰�C×,Ñ,Ô-Ü�w‰w�u¤DÔ)ˆÙ�V˜TÓ"ˆÜ˜& #Ô&¨%°6·<±<Ò*?Ü%ØGÈÀwÈaÐPóð ð ˆr[   c                ó   — t         S rS   )Ústr)rf   Úboxeds     rY   Ú
_formatterzBaseMaskedArray._formatter¨   s   € äˆ
r[   c                ó   — t        | «      ‚rS   r   ©rf   s    rY   r`   zBaseMaskedArray.dtype¬   s   € ä! $Ó'Ð'r[   c                 ó   — y rS   © ©rf   Úitems     rY   Ú__getitem__zBaseMaskedArray.__getitem__°   ó   € àr[   c                 ó   — y rS   r~   r   s     rY   r�   zBaseMaskedArray.__getitem__´   r‚   r[   c                óÚ   — t        | |«      }| j                  |   }t        |«      r'|r| j                  j                  S | j
                  |   S | j                  | j
                  |   |«      S rS   )r>   rQ   r!   r`   Úna_valuerO   rZ   )rf   r€   Únewmasks      rY   r�   zBaseMaskedArray.__getitem__¸   sb   € Ü" 4¨Ó.ˆà—*‘*˜TÑ"ˆÜ�7ÔáØ—z‘z×*Ñ*Ð*Ø—:‘:˜dÑ#Ð#à×Ñ §
¡
¨4Ñ 0°'Ó:Ð:r[   T)ÚlimitÚ
limit_areare   c               ó  — | j                   }|j                  «       �rMt        j                  || j                  ¬«      }| j
                  j                  }|j                  }|r!|j                  «       }|j                  «       }n|�|j                  «       } ||||¬«       |�ž|j                  «       sŽ|j                  }| }	|	j                  «       }
t        |	«      |	d d d…   j                  «       z
  dz
  }|dk(  r)|d |
xxx |d |
 z  ccc ||dz   d xxx ||dz   d  z  ccc n|dk(  r||
dz   |xxx ||
dz   | z  ccc |r&| j                  |j                  |j                  «      S | S |r| j                  «       }|S | }|S )N©Úndim©r‡   rW   éÿÿÿÿé   ÚinsideÚoutside)rQ   Úanyr
   Úget_fill_funcr‹   rO   ÚTre   ÚallÚargmaxÚlenrZ   )rf   Úmethodr‡   rˆ   re   rW   ÚfuncÚnpvaluesÚnew_maskÚneg_maskÚfirstÚlastÚ
new_valuess                rY   Ú_pad_or_backfillz BaseMaskedArray._pad_or_backfillÄ   sv  € ð �z‰zˆà�8‰8�:Ü×(Ñ(¨°d·i±iÔ@ˆDà—z‘z—|‘|ˆHØ—v‘vˆHÙØ#Ÿ=™=›?�Ø#Ÿ=™=›?‘ØÐ'Ø—y‘y“{�Ù� ¨XÕ6àÐ%¨d¯h©h¬jØ—v‘v�Ø ˜5�Ø Ÿ™Ó)�Ü˜8“} x±°"°¡~×'<Ñ'<Ó'>Ñ>ÀÑB�Ø Ò)Ø˜V˜eÓ$¨¨V¨e¨Ñ4Ó$Ø˜T A™X˜ZÓ(¨D°¸±°Ð,<Ñ<Ô(Ø 9Ò,Ø˜U Q™Y¨Ó.°$°u¸q±yÀ4Ð2HÑHÓ.áØ×'Ñ'¨¯
©
°H·J±JÓ?Ð?à�áØ!ŸY™Y›[�
ð Ðð "�
ØÐr[   c                ó<  — t        ||«      \  }}| j                  }t        j                  ||t	        | «      «      }|j                  «       r·|�–t        j                  || j                  ¬«      }| j                  j                  }|j                  }|r |j                  «       }|j                  «       } ||||¬«       | j                  |j                  |j                  «      S |r| j                  «       }	n| d d  }	||	|<   |	S |r| j                  «       }	|	S | d d  }	|	S )NrŠ   rŒ   )r   rQ   r
   Úcheck_value_sizer–   r‘   r’   r‹   rO   r“   re   rZ   )
rf   Úvaluer—   r‡   re   rW   r˜   r™   rš   rž   s
             rY   ÚfillnazBaseMaskedArray.fillnað   s  € ô /¨u°fÓ=‰ˆˆvà�z‰zˆä×(Ñ(¨°´c¸$³iÓ@ˆà�8‰8Œ:ØÐ!Ü×,Ñ,¨V¸$¿)¹)ÔD�ØŸ:™:Ÿ<™<�ØŸ6™6�ÙØ'Ÿ}™}›�HØ'Ÿ}™}›�HÙ�X U°Õ:Ø×'Ñ'¨¯
©
°H·J±JÓ?Ð?ñ Ø!%§¡£‘Jà!%¡a �JØ#(�
˜4Ñ ð Ðñ	 Ø!ŸY™Y›[�
ð Ðð "¡!˜W�
ØÐr[   ©re   c               ó   — t        | «      ‚rS   r   )rU   rV   r`   re   s       rY   rj   z BaseMaskedArray._coerce_to_array  s   € ô " #Ó&Ð&r[   c                óˆ  — | j                   j                  }|dk(  rt        j                  |«      ro|S |dk(  r,t        j                  |«      st        j
                  |«      r>|S t        j                  |«      s%t        j
                  |«      r|j	                  «       r|S t        dt        |«      › d| j                   › �«      ‚)zy
        Check if we have a scalar that we can cast losslessly.

        Raises
        ------
        TypeError
        ÚbÚfzInvalid value 'z' for dtype )r`   Úkindr	   r!   Ú
is_integerÚis_floatrb   rx   )rf   r¢   r©   s      rY   Ú_validate_setitem_valuez'BaseMaskedArray._validate_setitem_value  s—   € ð �z‰z�‰ˆà�3Š;Ü�{‰{˜5Ô!Ø�à�SŠ[Ü�~‰~˜eÔ$¬¯©°UÔ(;Ø�ô �~‰~˜eÔ$¬¯©°eÔ)<À×AQÑAQÔASØ�ô
 ˜/¬#¨e«*¨°\À$Ç*Á*ÀÐNÓOÐOr[   c                óZ  — t        | |«      }t        |«      rVt        || j                  «      rd| j                  |<   y | j                  |«      }|| j                  |<   d| j                  |<   y | j                  || j                  ¬«      \  }}|| j                  |<   || j                  |<   y )NTFrn   )r>   r$   r)   r`   rQ   r¬   rO   rj   )rf   Úkeyr¢   rW   s       rY   Ú__setitem__zBaseMaskedArray.__setitem__3  sœ   € Ü! $¨Ó,ˆä�UÔÜ$ U¨D¯J©JÔ7Ø"&�—
‘
˜3‘ð
 ð ×4Ñ4°UÓ;�Ø"'�—
‘
˜3‘Ø"'�—
‘
˜3‘Øà×+Ñ+¨E¸¿¹Ð+ÓD‰ˆˆtàˆ�
‰
�3‰Øˆ�
‰
�3Šr[   c                ór  •— t        |«      r”|| j                  j                  ur|| j                  j                  j                  dk(  rYt        j                  |«      rDt        t        j                  | j                  «      | j                   z  j                  «       «      S t        t        ‰| �5  |«      «      S )Nr¨   )r*   r`   r…   rO   r©   r	   r«   rt   r^   ÚisnanrQ   r‘   ÚsuperÚ__contains__)rf   r®   Ú	__class__s     €rY   r³   zBaseMaskedArray.__contains__D  s   ø€ Ü�Œ9˜ D§J¡J×$7Ñ$7Ñ7à�z‰z×Ñ×$Ñ$¨Ò+´·±¸SÔ0AÜœRŸX™X d§j¡jÓ1°T·Z±Z°KÑ?×DÑDÓFÓGÐGä”E‘GÑ(¨Ó-Ó.Ð.r[   c              #  óB  K  — | j                   dk(  rl| j                  s| j                  D ]  }|–— Œ y | j                  j                  }t        | j                  | j                  «      D ]  \  }}|r|–— Œ|–— Œ y t        t        | «      «      D ]	  }| |   –— Œ y ­w)NrŽ   )	r‹   Ú_hasnarO   r`   r…   ÚziprQ   Úranger–   )rf   Úvalr…   Úisna_Úis        rY   Ú__iter__zBaseMaskedArray.__iter__L  s“   è ø€ Ø�9‰9˜Š>Ø—;’;ØŸ:™:ò �CØ“Iñð  Ÿ:™:×.Ñ.�Ü"% d§j¡j°$·*±*Ó"=ò "‘J�E˜3ÙØ&›à!›	ñ	"ô œ3˜t›9Ó%ò �Ø˜1‘g“ñùs   ‚BBc                ó,   — t        | j                  «      S rS   )r–   rO   r|   s    rY   Ú__len__zBaseMaskedArray.__len__\  s   € Ü�4—:‘:‹Ðr[   c                ó.   — | j                   j                  S rS   )rO   rc   r|   s    rY   rc   zBaseMaskedArray.shape_  s   € à�z‰z×ÑÐr[   c                ó.   — | j                   j                  S rS   )rO   r‹   r|   s    rY   r‹   zBaseMaskedArray.ndimc  s   € à�z‰z�‰Ðr[   c                ó–   — | j                   j                  ||«      }| j                  j                  ||«      }| j                  ||«      S rS   )rO   ÚswapaxesrQ   rZ   )rf   Úaxis1Úaxis2ÚdatarW   s        rY   rÂ   zBaseMaskedArray.swapaxesg  sA   € Ø�z‰z×"Ñ" 5¨%Ó0ˆØ�z‰z×"Ñ" 5¨%Ó0ˆØ×Ñ  dÓ+Ð+r[   r   c                ó®   — t        j                  | j                  ||¬«      }t        j                  | j                  ||¬«      }| j	                  ||«      S ©N©Úaxis)r^   ÚdeleterO   rQ   rZ   )rf   ÚlocrÉ   rÅ   rW   s        rY   rÊ   zBaseMaskedArray.deletel  sA   € Ü�y‰y˜Ÿ™ S¨tÔ4ˆÜ�y‰y˜Ÿ™ S¨tÔ4ˆØ×Ñ  dÓ+Ð+r[   c                ó–   —  | j                   j                  |i |¤Ž} | j                  j                  |i |¤Ž}| j                  ||«      S rS   )rO   ÚreshaperQ   rZ   ©rf   ÚargsÚkwargsrÅ   rW   s        rY   rÍ   zBaseMaskedArray.reshapeq  sK   € Ø!ˆt�z‰z×!Ñ! 4Ð2¨6Ñ2ˆØ!ˆt�z‰z×!Ñ! 4Ð2¨6Ñ2ˆØ×Ñ  dÓ+Ð+r[   c                ó–   —  | j                   j                  |i |¤Ž} | j                  j                  |i |¤Ž} t        | «      ||«      S rS   )rO   ÚravelrQ   rq   rÎ   s        rY   rÒ   zBaseMaskedArray.ravelv  sK   € àˆt�z‰z×Ñ Ð0¨Ñ0ˆØˆt�z‰z×Ñ Ð0¨Ñ0ˆØŒt�D‹z˜$ Ó%Ð%r[   c                óv   — | j                  | j                  j                  | j                  j                  «      S rS   )rZ   rO   r“   rQ   r|   s    rY   r“   zBaseMaskedArray.T|  s%   € à×Ñ §
¡
§¡¨d¯j©j¯l©lÓ;Ð;r[   c                óü   — | j                   j                  dk(  r| S t        j                  ||«       t	        j
                  | j                  fd|i|¤Ž}| j                  || j                  j                  «       «      S )aó  
        Round each value in the array a to the given number of decimals.

        Parameters
        ----------
        decimals : int, default 0
            Number of decimal places to round to. If decimals is negative,
            it specifies the number of positions to the left of the decimal point.
        *args, **kwargs
            Additional arguments and keywords have no effect but might be
            accepted for compatibility with NumPy.

        Returns
        -------
        NumericArray
            Rounded values of the NumericArray.

        See Also
        --------
        numpy.around : Round values of an np.array.
        DataFrame.round : Round values of a DataFrame.
        Series.round : Round values of a Series.
        r§   Údecimals)
r`   r©   ÚnvÚvalidate_roundr^   ÚroundrO   Ú_maybe_mask_resultrQ   re   )rf   rÕ   rÏ   rÐ   rV   s        rY   rØ   zBaseMaskedArray.round€  se   € ð0 �:‰:�?‰?˜cÒ!ØˆKÜ
×Ñ˜$ Ô'Ü—‘˜$Ÿ*™*ÑB¨xÐB¸6ÑBˆð ×&Ñ& v¨t¯z©z¯©Ó/@ÓAÐAr[   c                ól   — | j                  | j                   | j                  j                  «       «      S rS   ©rZ   rO   rQ   re   r|   s    rY   Ú
__invert__zBaseMaskedArray.__invert__£  ó&   € Ø×Ñ §¡ ¨T¯Z©Z¯_©_Ó->Ó?Ð?r[   c                ól   — | j                  | j                   | j                  j                  «       «      S rS   rÛ   r|   s    rY   Ú__neg__zBaseMaskedArray.__neg__¦  rÝ   r[   c                ó"   — | j                  «       S rS   r¤   r|   s    rY   Ú__pos__zBaseMaskedArray.__pos__©  s   € Ø�y‰y‹{Ðr[   c                ó|   — | j                  t        | j                  «      | j                  j	                  «       «      S rS   )rZ   ÚabsrO   rQ   re   r|   s    rY   Ú__abs__zBaseMaskedArray.__abs__¬  s(   € Ø×Ñ¤ D§J¡J£°·±·±Ó1BÓCÐCr[   c                ó8   — t        j                  | t        ¬«      S )Nrn   )r^   ÚasarrayÚobjectr|   s    rY   Ú_values_for_jsonz BaseMaskedArray._values_for_json±  s   € Ü�z‰z˜$¤fÔ-Ð-r[   c                ób  — | j                   }t        | |||«      \  }}|€t        }|r™|t        k7  r,t        |«      s!|t        j
                  u rt        d|› d�«      ‚t        j                  «       5  t        j                  dt        ¬«       | j                  j                  |«      }ddd«       || j                  <   |S t        j                  «       5  t        j                  dt        ¬«       | j                  j                  ||¬«      }ddd«       |S # 1 sw Y   ŒqxY w# 1 sw Y   S xY w)aF  
        Convert to a NumPy Array.

        By default converts to an object-dtype NumPy array. Specify the `dtype` and
        `na_value` keywords to customize the conversion.

        Parameters
        ----------
        dtype : dtype, default object
            The numpy dtype to convert to.
        copy : bool, default False
            Whether to ensure that the returned value is a not a view on
            the array. Note that ``copy=False`` does not *ensure* that
            ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
            a copy is made, even if not strictly necessary. This is typically
            only possible when no missing values are present and `dtype`
            is the equivalent numpy dtype.
        na_value : scalar, optional
             Scalar missing value indicator to use in numpy array. Defaults
             to the native missing value indicator of this array (pd.NA).

        Returns
        -------
        numpy.ndarray

        Examples
        --------
        An object-dtype is the default result

        >>> a = pd.array([True, False, pd.NA], dtype="boolean")
        >>> a.to_numpy()
        array([True, False, <NA>], dtype=object)

        When no missing values are present, an equivalent dtype can be used.

        >>> pd.array([True, False], dtype="boolean").to_numpy(dtype="bool")
        array([ True, False])
        >>> pd.array([1, 2], dtype="Int64").to_numpy("int64")
        array([1, 2])

        However, requesting such dtype will raise a ValueError if
        missing values are present and the default missing value :attr:`NA`
        is used.

        >>> a = pd.array([True, False, pd.NA], dtype="boolean")
        >>> a
        <BooleanArray>
        [True, False, <NA>]
        Length: 3, dtype: boolean

        >>> a.to_numpy(dtype="bool")
        Traceback (most recent call last):
        ...
        ValueError: cannot convert to bool numpy array in presence of missing values

        Specify a valid `na_value` instead

        >>> a.to_numpy(dtype="bool", na_value=False)
        array([ True, False, False])
        Nzcannot convert to 'zZ'-dtype NumPy array with missing values. Specify an appropriate 'na_value' for this dtype.Úignore©Úcategoryr¤   )r¶   r9   rç   r%   Ú
libmissingÚNArd   ÚwarningsÚcatch_warningsÚfilterwarningsÚRuntimeWarningrO   ÚastyperQ   )rf   r`   re   r…   ÚhasnarÅ   s         rY   Úto_numpyzBaseMaskedArray.to_numpy´  s  € ðD —‘ˆÜ2°4¸ÀÈ%ÓP‰ˆˆxØˆ=ÜˆEáàœ’Ü'¨Ô.Ø¤
§¡Ñ-ä Ø)¨%¨ð 1&ð &óð ô ×(Ñ(Ó*ñ 0Ü×'Ñ'¨¼>ÕJØ—z‘z×(Ñ(¨Ó/�÷0ð  (ˆD�—‘Ñð
 ˆô ×(Ñ(Ó*ñ ;Ü×'Ñ'¨¼>ÕJØ—z‘z×(Ñ(¨°TÐ(Ó:�÷;ð ˆ÷0ð 0ú÷
;ð ˆús   Á17DÃ9D$ÄD!Ä$D.c                ó  — | j                   dkD  r| D �cg c]  }|j                  «       ‘Œ c}S | j                  rd n| j                  j                  }| j                  |t        j                  ¬«      j                  «       S c c}w )NrŽ   ©r`   r…   )r‹   Útolistr¶   rO   r`   rõ   rí   rî   )rf   Úxr`   s      rY   rø   zBaseMaskedArray.tolist  s`   € à�9‰9�qŠ=Ø(,Ö- 1�A—H‘H•JÒ-Ð-ØŸš‘¨¯©×)9Ñ)9ˆØ�}‰} 5´:·=±=ˆ}ÓA×HÑHÓJÐJùò .s   ”Bc                 ó   — y rS   r~   ©rf   r`   re   s      rY   ró   zBaseMaskedArray.astype  r‚   r[   c                 ó   — y rS   r~   rû   s      rY   ró   zBaseMaskedArray.astype  r‚   r[   c                 ó   — y rS   r~   rû   s      rY   ró   zBaseMaskedArray.astype   r‚   r[   c                óÈ  — t        |«      }|| j                  k(  r|r| j                  «       S | S t        |t        «      r®t        j                  «       5  t        j                  dt        ¬«       | j                  j                  |j                  |¬«      }d d d «       | j                  u r| j                  n| j                  j                  «       }|j                  «       } |||d¬«      S t        |t        «      r$|j                  «       }|j                  | ||¬«      S |j                   dk(  rt"        j$                  }n5|j                   dk(  rt#        j&                  d«      }nt(        j*                  }|j                   d	v r| j,                  rt/        d
«      ‚|j                   dk(  r| j,                  rt/        d«      ‚| j1                  |||¬«      }|S # 1 sw Y   �ŒCxY w)Nrê   rë   r¤   Frh   r¨   ÚMÚNaTÚiuzcannot convert NA to integerr§   z cannot convert float NaN to bool)r`   r…   re   )r&   r`   re   r]   r'   rï   rð   rñ   rò   rO   ró   Únumpy_dtyperQ   Úconstruct_array_typer    rl   r©   r^   ÚnanÚ
datetime64r	   Ú
no_defaultr¶   rd   rõ   )rf   r`   re   rÅ   rW   rU   Úeaclsr…   s           rY   ró   zBaseMaskedArray.astype$  sŽ  € Ü˜UÓ#ˆà�D—J‘JÒÙØ—y‘y“{Ð"ØˆKô �eœ_Ô-ä×(Ñ(Ó*ñ GÜ×'Ñ'¨¼>ÕJà—z‘z×(Ñ(¨×):Ñ):ÀÐ(ÓF�÷Gð "&¨¯©Ñ!3�4—:’:¸¿¹¿¹Ó9JˆDØ×,Ñ,Ó.ˆCÙ�t˜T¨Ô.Ð.ä�eœ^Ô,Ø×.Ñ.Ó0ˆEØ×'Ñ'¨°EÀÐ'ÓEÐEð
 �:‰:˜Òä—v‘v‰HØ�Z‰Z˜3ÒÜ—}‘} UÓ+‰Hä—~‘~ˆHð �:‰:˜Ñ $§+¢+ÜÐ;Ó<Ð<Ø�:‰:˜Ò §¢äÐ?Ó@Ð@à�}‰} 5°8À$ˆ}ÓGˆØˆ÷CGñ Gús   ÁAGÇG!iè  c                ó&   — | j                  |¬«      S )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        rn   )rõ   rû   s      rY   Ú	__array__zBaseMaskedArray.__array__T  s   € ð �}‰} 5ˆ}Ó)Ð)r[   ztuple[type, ...]Ú_HANDLED_TYPESc                ó8  ‡	‡
— |j                  dd«      }||z   D ](  }t        || j                  t        fz   «      rŒ"t        c S  t        j                  | ||g|¢­i |¤Ž}|t        ur|S d|v rt        j                  | ||g|¢­i |¤ŽS |dk(  r%t        j                  | ||g|¢­i |¤Ž}|t        ur|S t        j                  t        | «      t        ¬«      Š	g }|D ]N  }t        |t        «      r+‰	|j                  z  Š	|j                  |j                  «       Œ>|j                  |«       ŒP dˆ	fd„Š
 t!        ||«      |i |¤Ž}|j"                  dkD  rt%        ˆ
fd„|D «       «      S |dk(  r(| j                  j'                  «       r| j(                  S |S  ‰
|«      S )	NÚoutr~   Úreducern   c                óä  •— ddl m}m}m} | j                  j
                  dk(  r‰j                  «       } || |«      S | j                  j
                  dv r‰j                  «       } || |«      S | j                  j
                  dk(  rU‰j                  «       }| j                  t        j                  k(  r| j                  t        j                  «      }  || |«      S t        j                  | ‰<   | S )Nr   )rE   rI   ÚIntegerArrayr§   r  r¨   )Úpandas.core.arraysrE   rI   r  r`   r©   re   r^   Úfloat16ró   Úfloat32r  )rù   rE   rI   r  ÚmrW   s        €rY   Úreconstructz4BaseMaskedArray.__array_ufunc__.<locals>.reconstruct†  s½   ø€ ÷ñ ð �w‰w�|‰|˜sÒ"Ø—I‘I“K�Ù# A qÓ)Ð)Ø—‘—‘ Ñ%Ø—I‘I“K�Ù# A qÓ)Ð)Ø—‘—‘ Ò$Ø—I‘I“K�Ø—7‘7œbŸj™jÒ(ð Ÿ™¤§¡Ó,�AÙ$ Q¨Ó*Ð*äŸ&™&��$‘ØˆHr[   rŽ   c              3  ó.   •K  — | ]  } ‰|«      –— Œ y ­wrS   r~   )Ú.0rù   r  s     €rY   ú	<genexpr>z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>£  s   øè ø€ Ò8¨A™ QŸÑ8ùs   ƒ)rù   rN   )Úgetr]   r
  rL   ÚNotImplementedr-   Ú!maybe_dispatch_ufunc_to_dunder_opÚdispatch_ufunc_with_outÚdispatch_reduction_ufuncr^   Úzerosr–   rt   rQ   ÚappendrO   ÚgetattrÚnoutÚtupler‘   Ú	_na_value)rf   Úufuncr—   ÚinputsrÐ   r  rù   rX   Úinputs2rW   r  s            @@rY   Ú__array_ufunc__zBaseMaskedArray.__array_ufunc___  sµ  ù€ ð �j‰j˜ Ó#ˆà˜#‘ò 	&ˆAÜ˜a ×!4Ñ!4¼Ð7IÑ!IÕJÜ%Ò%ð	&ô
 ×<Ñ<Ø�%˜ð
Ø"(ò
Ø,2ñ
ˆð œÑ'ØˆMà�F‰?ä×4Ñ4Ø�e˜VðØ&,òØ06ñð ð �XÒÜ×7Ñ7Ø�e˜VðØ&,òØ06ñˆFð œ^Ñ+Ø�ä�x‰xœ˜D›	¬Ô.ˆØˆØò 	"ˆAÜ˜!œ_Ô-Ø˜Ÿ™‘�Ø—‘˜qŸw™wÕ'à—‘˜qÕ!ð	"õ	ð4 (”˜ Ó'¨Ð;°FÑ;ˆØ�:‰:˜Š>äÓ8°Ô8Ó8Ð8Ø�xÒà�z‰z�~‰~ÔØ—~‘~Ð%ØˆMá˜vÓ&Ð&r[   c                óZ   — ddl }|j                  | j                  | j                  |¬«      S )z6
        Convert myself into a pyarrow Array.
        r   N)rW   rq   )Úpyarrowr;   rO   rQ   )rf   rq   Úpas      rY   Ú__arrow_array__zBaseMaskedArray.__arrow_array__¬  s$   € ó 	à�x‰x˜Ÿ
™
¨¯©¸$ˆxÓ?Ð?r[   c                ó6   — | j                   j                  «       S rS   )rQ   r‘   r|   s    rY   r¶   zBaseMaskedArray._hasna´  s   € ð �z‰z�~‰~ÓÐr[   c                óò   — |€e| j                   j                  «       }|t        j                  u r|dz  }|S t	        |«      r%t        |«      t        |«      k(  r|t        |«      z  }|S | j                   |z  }|S )NT)rQ   re   rí   rî   r#   r–   r*   )rf   rW   Úothers      rY   Ú_propagate_maskzBaseMaskedArray._propagate_mask½  sz   € ð ˆ<Ø—:‘:—?‘?Ó$ˆDØœ
Ÿ™Ñ%à˜d‘{�ð ˆô ˜eÔ$¬¨U«´s¸4³yÒ)@Øœd 5›kÑ)�ð
 ˆð —:‘: Ñ$ˆDð ˆr[   c                óà  — |j                   }d }t        |d«      s:t        |«      r/t        |«      t        | «      k(  rt	        |«      }t        |d¬«      }t        |t        «      r|j                  |j                  }}nJt        |«      r?t        |t        «      st        j                  |«      }|j                  dkD  rt        d«      ‚t        j                   |t        | «      f«      }t        j"                  |«      }t%        |«      }|dv r%t        |t        j&                  «      rt)        |«      }| j+                  ||«      }|t,        j.                  u r£t        j0                  | j                  «      }| j2                  j4                  dk(  r.|dv rt        d	|› d
�«      ‚|dv rd}nd}|j7                  |«      }n�d|v r‰| j2                  j4                  dk7  rp|j7                  t        j8                  «      }nP| j2                  j4                  dv r|dv r|}t        j:                  d¬«      5   || j                  |«      }d d d «       |dk(  r€t        j<                  | j                  dk(  | j                   z  d|«      }|�t        j<                  |dk(  | z  d|«      }n±|t,        j.                  urŸt        j<                  |dk(  d|«      }n„|dk(  r|�t        j<                  |dk(  | z  d|«      }n,|t,        j.                  urt        j<                  |dk(  d|«      }t        j<                  | j                  dk(  | j                   z  d|«      }| j?                  |«      S # 1 sw Y   �Œ%xY w)Nr`   T)Úextract_numpyrŽ   ú(can only perform ops with 1-d structures>   ÚpowÚrpowr§   >   r2  r3  ÚtruedivÚfloordivÚrtruedivÚ	rfloordivz
operator 'z!' not implemented for bool dtypes>   ÚmodÚrmodÚint8rt   r4  r¨   r  )r5  r8  rê   )r”   r2  Fr   r3  ) Ú__name__Úhasattrr#   r–   Úpd_arrayr=   r]   rL   rO   rQ   r:   r^   ræ   r‹   ru   r/   Úmaybe_prepare_scalar_for_opÚget_array_opr<   ra   rt   r.  rí   rî   Ú	ones_liker`   r©   ró   Úfloat64ÚerrstateÚwhererÙ   )	rf   r-  ÚopÚop_nameÚomaskÚpd_oprW   rX   r`   s	            rY   Ú_arith_methodzBaseMaskedArray._arith_methodÍ  sò  € Ø—+‘+ˆØˆô ˜˜wÔ'Ü˜UÔ#Ü�E“
œc $›iÒ'ô ˜U“OˆEÜ! %°tÔ<ˆEä�eœ_Ô-Ø Ÿ;™;¨¯©�5‰Eä˜%Ô Ü˜e¤^Ô4ÜŸ
™
 5Ó)�Ø�z‰z˜AŠ~Ü)Ð*TÓUÐUô ×/Ñ/°¼¸D»	°|ÓDˆÜ× Ñ  Ó$ˆÜ.¨uÓ5ˆà�oÑ%¬*°U¼B¿H¹HÔ*Eô ˜“KˆEà×#Ñ# E¨5Ó1ˆà”J—M‘MÑ!Ü—\‘\ $§*¡*Ó-ˆFØ�z‰z�‰ #Ò%Øð ñ ô .Ø$ W IÐ-NÐOóð ð ˜oÑ-Ø"‘Eà"�EØŸ™ uÓ-‘Ø˜gÑ%¨$¯*©*¯/©/¸SÒ*@ð  Ÿ™¤r§z¡zÓ2‘ð �z‰z�‰ $Ñ&¨7Ð6IÑ+Ið �ä—‘ Ô*ñ 2Ù˜tŸz™z¨5Ó1�÷2ð �eÒä—8‘8˜TŸZ™Z¨1™_°·±°Ñ;¸UÀDÓIˆDàÐ Ü—x‘x ¨!¡°¨vÑ 5°u¸dÓC‘ØœjŸm™mÑ+Ü—x‘x ¨¡
¨E°4Ó8‘à˜ÒàÐ Ü—x‘x ¨!¡°¨vÑ 5°u¸dÓC‘ØœjŸm™mÑ+Ü—x‘x ¨¡
¨E°4Ó8�ä—8‘8˜TŸZ™Z¨1™_°·±°Ñ;¸UÀDÓIˆDà×&Ñ& v¨tÓ4Ð4÷+2ñ 2ús   È,M#Í#M-c                ó|  — ddl m} d }t        |t        «      r|j                  |j
                  }}n\t        |«      rQt        j                  |«      }|j                  dkD  rt        d«      ‚t        | «      t        |«      k7  rt        d«      ‚|t        j                  u rWt        j                  | j                  j                   d¬«      }t        j"                  | j                  j                   d¬«      }nžt%        j&                  «       5  t%        j(                  dd	t*        «       t%        j(                  dd	t,        «       t/        | j                  d
|j0                  › d
�«      } ||«      }|t2        u rt5        | j                  ||«      }d d d «       | j7                  ||«      } ||d¬«      S # 1 sw Y   Œ&xY w)Nr   rD   rŽ   r1  zLengths must match to comparert   rn   rê   ÚelementwiseÚ__Fr¤   )r  rE   r]   rL   rO   rQ   r#   r^   ræ   r‹   ru   r–   rd   rí   rî   r  rc   rs   rï   rð   rñ   ÚFutureWarningÚDeprecationWarningr  r;  r  r?   r.  )rf   r-  rD  rE   rW   rX   r—   s          rY   Ú_cmp_methodzBaseMaskedArray._cmp_method,  s_  € Ý3àˆä�eœ_Ô-ØŸ+™+ u§{¡{�4‰Eä˜%Ô Ü—J‘J˜uÓ%ˆEØ�z‰z˜AŠ~Ü)Ð*TÓUÐUÜ�4‹yœC ›JÒ&Ü Ð!@ÓAÐAà”J—M‘MÑ!ô
 —X‘X˜dŸj™j×.Ñ.°fÔ=ˆFÜ—7‘7˜4Ÿ:™:×+Ñ+°6Ô:‰Dä×(Ñ(Ó*ñ Gô ×'Ñ'¨°-ÄÔOÜ×'Ñ'¨°-ÔASÔTÜ  §¡¨r°"·+±+°¸bÐ-AÓB�Ù ›�àœ^Ñ+Ü/°·
±
¸EÀ2ÓF�F÷Gð ×#Ñ# D¨%Ó0ˆÙ˜F D¨uÔ5Ð5÷Gð Gús   ÄBF2Æ2F;c                ó   — t        |t        «      r)|\  }}| j                  ||«      | j                  ||«      fS |j                  j                  dk(  rddlm}  |||d¬«      S |j                  j                  dk(  rddlm}  |||d¬«      S t        j                  |j                  d«      rdt        |j                  «      rOdd	lm} |j                  j                  d
«      ||<   t        ||«      s|j                  ||j                  ¬«      S |S |j                  j                  dv rddlm}  |||d¬«      S t        j                   ||<   |S )z
        Parameters
        ----------
        result : array-like or tuple[array-like]
        mask : array-like bool
        r¨   r   rH   Fr¤   r§   rD   r  )ÚTimedeltaArrayr   rn   r  ©r  )r]   r!  rÙ   r`   r©   r  rI   rE   r	   Úis_np_dtyper   rP  rq   rZ   r  r^   r  )	rf   rX   rW   Údivr8  rI   rE   rP  r  s	            rY   rÙ   z"BaseMaskedArray._maybe_mask_resultT  s%  € ô �fœeÔ$à‰HˆC�à×'Ñ'¨¨TÓ2Ø×'Ñ'¨¨TÓ2ðð ð
 �<‰<×Ñ Ò#Ý8á  ¨°EÔ:Ð:à�\‰\×Ñ #Ò%Ý7á ¨°5Ô9Ð9ä�_‰_˜VŸ\™\¨3Ô/Ô4FÀvÇ|Á|Ô4Tå9à!Ÿ<™<×,Ñ,¨UÓ3ˆF�4‰Lä˜f nÔ5Ø%×1Ñ1°&ÀÇÁÐ1ÓMÐMàˆMà�\‰\×Ñ $Ñ&Ý7á ¨°5Ô9Ð9ô Ÿ6™6ˆF�4‰LØˆMr[   c                ó6   — | j                   j                  «       S rS   )rQ   re   r|   s    rY   r*   zBaseMaskedArray.isnaƒ  s   € Ø�z‰z�‰Ó Ð r[   c                ó.   — | j                   j                  S rS   r÷   r|   s    rY   r"  zBaseMaskedArray._na_value†  s   € à�z‰z×"Ñ"Ð"r[   c                ó\   — | j                   j                  | j                  j                  z   S rS   )rO   ÚnbytesrQ   r|   s    rY   rW  zBaseMaskedArray.nbytesŠ  s!   € à�z‰z× Ñ  4§:¡:×#4Ñ#4Ñ4Ð4r[   c                óä   — t        j                  |D �cg c]  }|j                  ‘Œ c}|¬«      }t        j                  |D �cg c]  }|j                  ‘Œ c}|¬«      } | ||«      S c c}w c c}w rÇ   )r^   ÚconcatenaterO   rQ   )rU   Ú	to_concatrÉ   rù   rÅ   rW   s         rY   Ú_concat_same_typez!BaseMaskedArray._concat_same_typeŽ  sV   € ô �~‰~°	Ö:¨1˜qŸw›wÒ:ÀÔFˆÜ�~‰~°	Ö:¨1˜qŸw›wÒ:ÀÔFˆÙ�4˜‹Ðùò ;ùÚ:s   ”A(ÁA-c               ó˜   — t        | j                  |||¬«      }t        | j                  j                  «      || j                  «       <   |S )N)ÚencodingÚhash_keyÚ
categorize)r@   rO   Úhashr`   r…   r*   )rf   r]  r^  r_  Úhashed_arrays        rY   Ú_hash_pandas_objectz#BaseMaskedArray._hash_pandas_object˜  sB   € ô "Ø�J‰J °HÈô
ˆô %)¨¯©×)<Ñ)<Ó$=ˆ�T—Y‘Y“[Ñ!ØÐr[   )Ú
allow_fillÚ
fill_valuerÉ   c               ó  — t        |«      r| j                  n|}t        | j                  ||||¬«      }t        | j                  |d||¬«      }|r-t        |«      r"t        j                  |«      dk(  }|||<   ||z  }| j                  ||«      S )N)rd  rc  rÉ   Tr�   )	r*   rM   r4   rO   rQ   r+   r^   ræ   rZ   )	rf   Úindexerrc  rd  rÉ   Údata_fill_valuerX   rW   Ú	fill_masks	            rY   r4   zBaseMaskedArray.take¡  s–   € ô 8<¸JÔ7G˜$×3Ò3ÈZˆÜØ�J‰JØØ&Ø!Øô
ˆô Ø�J‰J˜¨D¸ZÈdô
ˆñ œ% 
Ô+ÜŸ
™
 7Ó+¨rÑ1ˆIØ *ˆF�9ÑØ˜)Ñ#ˆDà×Ñ ¨Ó-Ð-r[   c                ób  ‡ — ddl m} t        j                  |«      }t	        ‰ j
                  |«      }‰ j                  r8|j                  t        k(  xr t        ˆ fd„|D «       «      }||‰ j                  <   t        j                  ‰ j
                  j                  t        ¬«      } |||d¬«      S )Nr   rD   c              3  óN   •K  — | ]  }|‰j                   j                  u –— Œ y ­wrS   r÷   )r  r¹   rf   s     €rY   r  z'BaseMaskedArray.isin.<locals>.<genexpr>Î  s'   øè ø€ ò @Ø/2��t—z‘z×*Ñ*Ô*ñ@ùs   ƒ"%rn   Fr¤   )r  rE   r^   ræ   r1   rO   r¶   r`   rç   r‘   rQ   r  rc   rt   )rf   rV   rE   Ú
values_arrrX   Úvalues_have_NArW   s   `      rY   r1   zBaseMaskedArray.isinÅ  s‘   ø€ Ý3ô —Z‘Z Ó'ˆ
Ü�d—j‘j *Ó-ˆà�;Š;Ø'×-Ñ-´Ñ7ò ¼Có @Ø6@ô@ó =ˆNð "0ˆF�4—:‘:Ñä�x‰x˜Ÿ
™
×(Ñ(´Ô5ˆÙ˜F D¨uÔ5Ð5r[   c                óŽ   — | j                   j                  «       }| j                  j                  «       }| j                  ||«      S rS   )rO   re   rQ   rZ   )rf   rÅ   rW   s      rY   re   zBaseMaskedArray.copyÙ  s5   € Ø�z‰z�‰Ó ˆØ�z‰z�‰Ó ˆØ×Ñ  dÓ+Ð+r[   c                ób   — | j                   }| j                  }t        j                  |||¬«      S )N)ÚkeeprW   )rO   rQ   ÚalgosÚ
duplicated)rf   ro  rV   rW   s       rY   rq  zBaseMaskedArray.duplicatedÞ  s+   € ð —‘ˆØ�z‰zˆÜ×Ñ ¨T¸Ô=Ð=r[   c                ó€   — t        j                  | j                  | j                  «      \  }}| j	                  ||«      S )z‚
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        )rp  Úunique_with_maskrO   rQ   rZ   )rf   ÚuniquesrW   s      rY   ÚuniquezBaseMaskedArray.uniqueæ  s5   € ô ×.Ñ.¨t¯z©z¸4¿:¹:ÓF‰ˆ�Ø×Ñ ¨Ó.Ð.r[   c                ó¶   — | j                   rt        d«      ‚t        |t        «      r|j	                  t
        «      }| j                  j                  |||¬«      S )NzOsearchsorted requires array to be sorted, which is impossible with NAs present.)ÚsideÚsorter)r¶   rd   r]   r:   ró   rç   rO   Úsearchsorted)rf   r¢   rw  rx  s       rY   ry  zBaseMaskedArray.searchsortedñ  sS   € ð �;Š;Üð$óð ô �eœ^Ô,Ø—L‘L¤Ó(ˆEà�z‰z×&Ñ& u°4ÀÐ&ÓGÐGr[   c                ó„  — | j                   }| j                  }t        |d|¬«      \  }}|j                  | j                  j                  k(  sJ |j                  | j                  f«       ‚|j                  «       }|s|st        |«      }nt        |«      dz   }t        j                  |t        ¬«      }|sw|ru|j                  «       }	|	dk(  rt        j                  d«      }
n|d |	 j                  «       dz   }
|||
k\  xx   dz  cc<   |
||dk(  <   t        j                  ||
d«      }d||
<   | j                  ||«      }||fS )NT)Úuse_na_sentinelrW   rŽ   rn   r   r�   )rO   rQ   r0   r`   r  r‘   r–   r^   r  rt   r•   ÚintpÚmaxÚinsertrZ   )rf   r{  ÚarrrW   Úcodesrt  Úhas_naÚsizeÚuniques_maskÚna_indexÚna_codeÚ
uniques_eas               rY   Ú	factorizezBaseMaskedArray.factorize  s-  € ð
 �j‰jˆØ�z‰zˆô )¨¸dÈÔN‰ˆˆwð �}‰} §
¡
× 6Ñ 6Ò6ÐS¸¿¹ÈÏ
É
Ð8SÓSÐ6à—‘“ˆÙ¡&Ü�w“<‰Dô �w“< !Ñ#ˆDÜ—x‘x ¬DÔ1ˆÙ¡6Ø—{‘{“}ˆHà˜1Š}ÜŸ'™' !›*‘à 	 Ð*×.Ñ.Ó0°1Ñ4�Ø�%˜7Ñ"Ó# qÑ(Ó#Ø!(ˆE�%˜2‘+Ñä—i‘i ¨°!Ó4ˆGØ$(ˆL˜Ñ!Ø×%Ñ% g¨|Ó<ˆ
à�jÐ Ð r[   c                ó   — | j                   S rS   )rO   r|   s    rY   Ú_values_for_argsortz#BaseMaskedArray._values_for_argsort'  s   € à�z‰zÐr[   c                óˆ  — ddl m}m} ddlm} t        j                  | j                  || j                  ¬«      \  }}}t        j                  t        |«      ft        j                  ¬«      }|j                  «       }	|dkD  rd|d<    |||	«      }
 | | j                  j                  «       ||«      «      } ||
|dd	¬
«      S )aA  
        Returns a Series containing counts of each unique value.

        Parameters
        ----------
        dropna : bool, default True
            Don't include counts of missing values.

        Returns
        -------
        counts : Series

        See Also
        --------
        Series.value_counts
        r   )ÚIndexrC   rQ  ©ÚdropnarW   rn   Tr�   ÚcountF)ÚindexÚnamere   )Úpandasr‹  rC   Úpandas.arraysr  rp  Úvalue_counts_arraylikerO   rQ   r^   r  r–   ra   re   r`   r  )rf   r�  r‹  rC   r  ÚkeysÚvalue_countsÚ
na_counterÚ
mask_indexrW   r  r�  s               rY   r•  zBaseMaskedArray.value_counts+  s±   € ÷"	
õ 	/ä).×)EÑ)EØ�J‰J˜v¨D¯J©Jô*
Ñ&ˆˆl˜Jô —X‘Xœs <Ó0Ð2¼"¿(¹(ÔCˆ
Ø�‰Ó ˆà˜Š>Ø!ˆJ�r‰Ná˜<¨Ó.ˆÙØ-ˆD�J‰J×+Ñ+Ó-Ø�jóó
ˆñ
 �c ¨W¸5ÔAÐAr[   c                ó>  — |rRt        | j                  || j                  ¬«      }t        j                  |j
                  t        j                  ¬«      }n%t        | j                  || j                  ¬«      \  }} t        | «      ||«      }||j                  «          S )NrŒ  rn   )	r3   rO   rQ   r^   r  rc   ra   rq   Úargsort)rf   r�  rX   Úres_masks       rY   Ú_modezBaseMaskedArray._modeS  sr   € ÙÜ˜$Ÿ*™*¨V¸$¿*¹*ÔEˆFÜ—x‘x §¡´B·H±HÔ=‰Hä# D§J¡J°vÀDÇJÁJÔOÑˆF�HØ”�d“˜F HÓ-ˆØ�f—n‘nÓ&Ñ'Ð'r[   c                óB  — t        | «      t        |«      k7  ry|j                  | j                  k7  ryt        j                  | j                  |j                  «      sy| j
                  | j                      }|j
                  |j                      }t        ||dd¬«      S )NFT)Ú
strict_nanÚdtype_equal)rq   r`   r^   Úarray_equalrQ   rO   r(   )rf   r-  ÚleftÚrights       rY   ÚequalszBaseMaskedArray.equals\  s|   € ä�‹:œ˜e›Ò$ØØ�;‰;˜$Ÿ*™*Ò$Øô �~‰~˜dŸj™j¨%¯+©+Ô6Øà�z‰z˜4Ÿ:™:˜+Ñ&ˆØ—‘˜UŸ[™[˜LÑ)ˆÜ  e¸È$ÔOÐOr[   c                ó€  — t        | j                  | j                  t        j                  ||¬«      }| j
                  rÉ| j                  dk(  rt        ‚| j                  «       j                  «       rpt        j                  |j                  t        ¬«      }t        | j                  «      r�t        j                  |j                  | j                  j                   ¬«      }nKt        j                  |j                  t        ¬«      }n%t        j                  |j                  t        ¬«      }| j#                  ||¬«      S )z½
        Dispatch to quantile_with_mask, needed because we do not have
        _from_factorized.

        Notes
        -----
        We assume that all impacted cases are 1D-only.
        )rW   rd  ÚqsÚinterpolationé   rn   ©rW   )r7   rO   rQ   r^   r  r¶   r‹   ru   r*   r”   rs   rc   rt   r"   r`   r  r  rÙ   )rf   r¤  r¥  ÚresÚout_masks        rY   Ú	_quantilezBaseMaskedArray._quantilel  s×   € ô !Ø�J‰JØ—‘ô —v‘vØØ'ô
ˆð �;Š;ð �y‰y˜AŠ~ô *Ð)Ø�y‰y‹{�‰Ô ÜŸ7™7 3§9¡9´DÔ9�ä# D§J¡JÔ/ô Ÿ(™( 3§9¡9°D·J±J×4JÑ4JÔK‘CäŸ8™8 C§I¡I´TÔ:‘ä—x‘x §	¡	´Ô6ˆHØ×&Ñ& s°Ð&Ó:Ð:r[   )ÚskipnaÚkeepdimsc               óÀ  — |dv r t        | |«      dd|i|¤Ž}nJ| j                  }| j                  }t        t        d|› �«      }|j	                  dd «      }	 ||f|	||dœ|¤Ž}|r]t        |«      r| j                  |dd¬«      S |j                  d	«      }t        j                  d	t        ¬
«      }| j                  ||«      S t        |«      rt        j                  S |S )N>	   r”   r‘   r}  ÚminÚstdÚsumÚvarÚmeanÚprodr«  r  rÉ   )rÉ   r«  rW   r   )rŽ   )r�  rÉ   Ú	mask_sizerŽ   rn   r~   )r  rO   rQ   r.   Úpopr*   Ú_wrap_na_resultrÍ   r^   r  rt   rÙ   rí   rî   )
rf   r�  r«  r¬  rÐ   rX   rÅ   rW   rD  rÉ   s
             rY   Ú_reducezBaseMaskedArray._reduce˜  sß   € ð ÐTÑTØ(”W˜T 4Ó(ÑA°ÐA¸&ÑA‰Fð —:‘:ˆDØ—:‘:ˆDÜœ 3 t f Ó.ˆBØ—:‘:˜f dÓ+ˆDÙ˜ÐL 4°¸TÑLÀVÑLˆFáÜ�FŒ|Ø×+Ñ+°¸AÈÐ+ÓNÐNàŸ™¨Ó*�Ü—x‘x ¬Ô.�Ø×.Ñ.¨v°tÓ<Ð<ä�Œ<Ü—=‘=Ð àˆMr[   c               óÔ   — t        |t        j                  «      rM|r| j                  j	                  |¬«      }n| j                  j                  |¬«      }| j                  ||«      S |S rÇ   )r]   r^   r_   rQ   r”   r‘   rÙ   )rf   r�  rX   r«  rÉ   rW   s         rY   Ú_wrap_reduction_resultz&BaseMaskedArray._wrap_reduction_result²  sS   € Ü�fœbŸj™jÔ)Ùà—z‘z—~‘~¨4�~Ó0‘à—z‘z—~‘~¨4�~Ó0�à×*Ñ*¨6°4Ó8Ð8Øˆr[   c               ó¸  — t        j                  |t        ¬«      }| j                  dk(  rdnd}|dv r|}n{|dv s| j                  j                  dk(  r!| j                  j
                  j                  }n=t        «       xs t         }|rdnd	}|rd
nd}	|||	|dœ| j                  j                     }t        j                  dg|¬«      }
| j                  |
|¬«      S )Nrn   ÚFloat32r  rA  )r²  Úmedianr±  r¯  ÚskewÚkurt)r®  r}  é   Úint32Úint64Úuint32Úuint64)r§   r»   Úur¨   rŽ   r§  )r^   rs   rt   r`   Úitemsizer  r�  r   r   r©   r;   rÙ   )rf   r�  rÉ   r´  rW   Ú
float_dtypÚnp_dtypeÚis_windows_or_32bitÚint_dtypÚ	uint_dtypr¢   s              rY   r¶  zBaseMaskedArray._wrap_na_result½  sÊ   € Ü�w‰w�y¬Ô-ˆà"&§*¡*°	Ò"9‘Y¸yˆ
ØÐCÑCØ!‰HØ�^Ñ# t§z¡z×':Ñ':¸aÒ'?Ø—z‘z×-Ñ-×2Ñ2‰Hä"5Ó"7Ò"C¼t¸8ÐÙ"5‘w¸7ˆHÙ$7™¸XˆIØ%¨H¸9È:ÑVØ—
‘
—‘ñˆHô —‘˜!˜ HÔ-ˆØ×&Ñ& u°4Ð&Ó8Ð8r[   c               óÔ   — |dk(  rOt        |t        j                  «      r5| j                  |t        j                  |j
                  t        ¬«      «      S | j                  ||||¬«      S )Nr   rn   ©r«  rÉ   )r]   r^   r_   rÙ   r  rc   rt   r¹  )rf   r�  rX   r«  Ú	min_countrÉ   s         rY   Ú _wrap_min_count_reduction_resultz0BaseMaskedArray._wrap_min_count_reduction_resultÐ  sU   € ð ˜Š>œj¨´·±Ô<Ø×*Ñ*¨6´2·8±8¸F¿L¹LÔPTÔ3UÓVÐVØ×*Ñ*¨4°ÀÈTÐ*ÓRÐRr[   ©r«  rÍ  rÉ   c               ó¶   — t        j                  d|«       t        j                  | j                  | j
                  |||¬«      }| j                  d||||¬«      S )Nr~   rÏ  r°  )rÖ   Úvalidate_sumr6   r°  rO   rQ   rÎ  ©rf   r«  rÍ  rÉ   rÐ   rX   s         rY   r°  zBaseMaskedArray.sum×  s^   € ô 	�‰˜˜FÔ#ä"×&Ñ&Ø�J‰JØ�J‰JØØØô
ˆð ×4Ñ4Ø�6 &°IÀDð 5ó 
ð 	
r[   c               ó¶   — t        j                  d|«       t        j                  | j                  | j
                  |||¬«      }| j                  d||||¬«      S )Nr~   rÏ  r³  )rÖ   Úvalidate_prodr6   r³  rO   rQ   rÎ  rÒ  s         rY   r³  zBaseMaskedArray.prodì  s`   € ô 	×Ñ˜˜VÔ$ä"×'Ñ'Ø�J‰JØ�J‰JØØØô
ˆð ×4Ñ4Ø�F 6°YÀTð 5ó 
ð 	
r[   rÌ  c               ó²   — t        j                  d|«       t        j                  | j                  | j
                  ||¬«      }| j                  d|||¬«      S )Nr~   rÌ  r²  )rÖ   Úvalidate_meanr6   r²  rO   rQ   r¹  ©rf   r«  rÉ   rÐ   rX   s        rY   r²  zBaseMaskedArray.mean  sR   € Ü
×Ñ˜˜VÔ$Ü"×'Ñ'Ø�J‰JØ�J‰JØØô	
ˆð ×*Ñ*¨6°6À&ÈtÐ*ÓTÐTr[   rŽ   ©r«  rÉ   Úddofc               ó¸   — t        j                  d|d¬«       t        j                  | j                  | j
                  |||¬«      }| j                  d|||¬«      S )Nr~   r±  ©ÚfnamerØ  rÌ  )rÖ   Úvalidate_stat_ddof_funcr6   r±  rO   rQ   r¹  ©rf   r«  rÉ   rÙ  rÐ   rX   s         rY   r±  zBaseMaskedArray.var  óY   € ô 	×"Ñ" 2 v°UÕ;Ü"×&Ñ&Ø�J‰JØ�J‰JØØØô
ˆð ×*Ñ*¨5°&ÀÈdÐ*ÓSÐSr[   c               ó¸   — t        j                  d|d¬«       t        j                  | j                  | j
                  |||¬«      }| j                  d|||¬«      S )Nr~   r¯  rÛ  rØ  rÌ  )rÖ   rÝ  r6   r¯  rO   rQ   r¹  rÞ  s         rY   r¯  zBaseMaskedArray.std  rß  r[   c               ó²   — t        j                  d|«       t        j                  | j                  | j
                  ||¬«      }| j                  d|||¬«      S )Nr~   rÌ  r®  )rÖ   Úvalidate_minr6   r®  rO   rQ   r¹  r×  s        rY   r®  zBaseMaskedArray.min%  óP   € Ü
�‰˜˜FÔ#Ü"×&Ñ&Ø�J‰JØ�J‰JØØô	
ˆð ×*Ñ*¨5°&ÀÈdÐ*ÓSÐSr[   c               ó²   — t        j                  d|«       t        j                  | j                  | j
                  ||¬«      }| j                  d|||¬«      S )Nr~   rÌ  r}  )rÖ   Úvalidate_maxr6   r}  rO   rQ   r¹  r×  s        rY   r}  zBaseMaskedArray.max/  rã  r[   c                ó:   — t        | j                  «       ||¬«      S )N)Ú	na_action)r2   rõ   )rf   Úmapperrç  s      rY   ÚmapzBaseMaskedArray.map9  s   € Ü˜Ÿ™›¨&¸IÔFÐFr[   c               ód  — t        j                  d|«       | j                  j                  «       }t	        j
                  || j                  | j                  «       |j                  «       }|r|S |s(t        | «      dk(  s| j                  j                  «       s|S | j                  j                  S )aY  
        Return whether any element is truthy.

        Returns False unless there is at least one element that is truthy.
        By default, NAs are skipped. If ``skipna=False`` is specified and
        missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
        is used as for logical operations.

        .. versionchanged:: 1.4.0

        Parameters
        ----------
        skipna : bool, default True
            Exclude NA values. If the entire array is NA and `skipna` is
            True, then the result will be False, as for an empty array.
            If `skipna` is False, the result will still be True if there is
            at least one element that is truthy, otherwise NA will be returned
            if there are NA's present.
        axis : int, optional, default 0
        **kwargs : any, default None
            Additional keywords have no effect but might be accepted for
            compatibility with NumPy.

        Returns
        -------
        bool or :attr:`pandas.NA`

        See Also
        --------
        numpy.any : Numpy version of this method.
        BaseMaskedArray.all : Return whether all elements are truthy.

        Examples
        --------
        The result indicates whether any element is truthy (and by default
        skips NAs):

        >>> pd.array([True, False, True]).any()
        True
        >>> pd.array([True, False, pd.NA]).any()
        True
        >>> pd.array([False, False, pd.NA]).any()
        False
        >>> pd.array([], dtype="boolean").any()
        False
        >>> pd.array([pd.NA], dtype="boolean").any()
        False
        >>> pd.array([pd.NA], dtype="Float64").any()
        False

        With ``skipna=False``, the result can be NA if this is logically
        required (whether ``pd.NA`` is True or False influences the result):

        >>> pd.array([True, False, pd.NA]).any(skipna=False)
        True
        >>> pd.array([1, 0, pd.NA]).any(skipna=False)
        True
        >>> pd.array([False, False, pd.NA]).any(skipna=False)
        <NA>
        >>> pd.array([0, 0, pd.NA]).any(skipna=False)
        <NA>
        r~   r   )rÖ   Úvalidate_anyrO   re   r^   ÚputmaskrQ   Ú_falsey_valuer‘   r–   r`   r…   ©rf   r«  rÉ   rÐ   rV   rX   s         rY   r‘   zBaseMaskedArray.any<  s�   € ô~ 	�‰˜˜FÔ#à—‘—‘Ó"ˆô 	�
‰
�6˜4Ÿ:™: t×'9Ñ'9Ô:Ø—‘“ˆÙØˆMáœ˜T› aš¨t¯z©z¯~©~Ô/?Ø�à—z‘z×*Ñ*Ð*r[   c               óh  — t        j                  d|«       | j                  j                  «       }t	        j
                  || j                  | j                  «       |j                  |¬«      }|r|S |r(t        | «      dk(  s| j                  j                  «       s|S | j                  j                  S )aL  
        Return whether all elements are truthy.

        Returns True unless there is at least one element that is falsey.
        By default, NAs are skipped. If ``skipna=False`` is specified and
        missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
        is used as for logical operations.

        .. versionchanged:: 1.4.0

        Parameters
        ----------
        skipna : bool, default True
            Exclude NA values. If the entire array is NA and `skipna` is
            True, then the result will be True, as for an empty array.
            If `skipna` is False, the result will still be False if there is
            at least one element that is falsey, otherwise NA will be returned
            if there are NA's present.
        axis : int, optional, default 0
        **kwargs : any, default None
            Additional keywords have no effect but might be accepted for
            compatibility with NumPy.

        Returns
        -------
        bool or :attr:`pandas.NA`

        See Also
        --------
        numpy.all : Numpy version of this method.
        BooleanArray.any : Return whether any element is truthy.

        Examples
        --------
        The result indicates whether all elements are truthy (and by default
        skips NAs):

        >>> pd.array([True, True, pd.NA]).all()
        True
        >>> pd.array([1, 1, pd.NA]).all()
        True
        >>> pd.array([True, False, pd.NA]).all()
        False
        >>> pd.array([], dtype="boolean").all()
        True
        >>> pd.array([pd.NA], dtype="boolean").all()
        True
        >>> pd.array([pd.NA], dtype="Float64").all()
        True

        With ``skipna=False``, the result can be NA if this is logically
        required (whether ``pd.NA`` is True or False influences the result):

        >>> pd.array([True, True, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([1, 1, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([True, False, pd.NA]).all(skipna=False)
        False
        >>> pd.array([1, 0, pd.NA]).all(skipna=False)
        False
        r~   rÈ   r   )rÖ   Úvalidate_allrO   re   r^   rì  rQ   Ú_truthy_valuer”   r–   r‘   r`   r…   rî  s         rY   r”   zBaseMaskedArray.all�  s†   € ô~ 	�‰˜˜FÔ#à—‘—‘Ó"ˆô 	�
‰
�6˜4Ÿ:™: t×'9Ñ'9Ô:Ø—‘ �Ó&ˆáØˆMáœS ›Y¨!š^°4·:±:·>±>Ô3CØ�à—z‘z×*Ñ*Ð*r[   c               ó‚  — | j                   j                  dk(  rP|r5| j                  j                  «       }	| j                  j                  «       }
n�| j                  }	| j                  }
nh| j                   j                  dv r8d}| j                  j                  d«      }	| j                  j                  «       }
nt        d| j                   › �«      ‚t        j                  |	f|d|||||
dœ|¤Ž |s| S | j                   j                  dk(  rt        | «      j                  |	|
«      S ddlm}  |j                  |	|
«      S )	z2
        See NDFrame.interpolate.__doc__.
        r¨   r  TÚf8z)interpolate is not implemented for dtype=r   )r—   rÉ   r�  r‡   Úlimit_directionrˆ   rW   rH   )r`   r©   rO   re   rQ   ró   ru   r
   Úinterpolate_2d_inplacerq   rZ   r  rI   )rf   r—   rÉ   r�  r‡   rô  rˆ   re   rÐ   rÅ   rW   rI   s               rY   ÚinterpolatezBaseMaskedArray.interpolateß  s  € ð  �:‰:�?‰?˜cÒ!ÙØ—z‘z—‘Ó(�Ø—z‘z—‘Ó(‘à—z‘z�Ø—z‘z‘Ø�Z‰Z�_‰_ Ñ$ØˆDØ—:‘:×$Ñ$ TÓ*ˆDØ—:‘:—?‘?Ó$‰Dä%Ø;¸D¿J¹J¸<ÐHóð ô 	×&Ñ&Øð
	
àØØØØ+Ø!Øñ
	
ð ò
	
ñ ØˆKØ�:‰:�?‰?˜cÒ!Ü˜“:×)Ñ)¨$°Ó5Ð5å8à,�=×,Ñ,¨T°4Ó8Ð8r[   )r«  c               ó”   — | j                   }| j                  }t        t        |«      } |||fd|i|¤Ž\  }}| j	                  ||«      S )Nr«  )rO   rQ   r  r5   rZ   )rf   r�  r«  rÐ   rÅ   rW   rD  s          rY   Ú_accumulatezBaseMaskedArray._accumulate  sP   € ð �z‰zˆØ�z‰zˆäÔ)¨4Ó0ˆÙ˜˜dÑ<¨6Ð<°VÑ<‰
ˆˆdà×Ñ  dÓ+Ð+r[   c          	     óF  — ddl m} |j                  |«      } ||||¬«      }	| j                  }
|	j                  dk7  r|
j                  «       }nt        j                  |t        ¬«      }|dk(  r|j                  d«      dv rd	|d d   |	j                  | j                  f||||
|d
œ|¤Ž}|	j                  dk(  rH|	j                  j                  |	j                  d«      }t        j                  ||df«      j                  }|	j                  dv r|S | j!                  ||«      S )Nr   )ÚWrappedCythonOp)Úhowr©   Úhas_dropped_naÚ	aggregatern   ÚrankÚ	na_option)ÚtopÚbottomF)rÍ  ÚngroupsÚcomp_idsrW   Úresult_maskÚohlcrŽ   )ÚidxminÚidxmax)Úpandas.core.groupby.opsrú  Úget_kind_from_howrQ   r©   re   r^   r  rt   r  Ú_cython_op_ndim_compatrO   rû  Ú_cython_arityÚtiler“   rÙ   )rf   rû  rü  rÍ  r  ÚidsrÐ   rú  r©   rD  rW   r  Ú
res_valuesÚaritys                 rY   Ú_groupby_opzBaseMaskedArray._groupby_op!  s  € õ 	<à×0Ñ0°Ó5ˆÙ ¨4ÀÔOˆð �z‰zˆØ�7‰7�kÒ!ØŸ)™)›+‰KäŸ(™( 7´$Ô7ˆKà�&Š=˜VŸZ™Z¨Ó4Ð8IÑIØ"ˆK™ˆNà.�R×.Ñ.Ø�J‰Jð
àØØØØ#ñ
ð ñ
ˆ
ð �6‰6�VÒØ×$Ñ$×(Ñ(¨¯©°Ó3ˆEÜŸ'™' +°°q¨zÓ:×<Ñ<ˆKà�6‰6Ð)Ñ)àÐð ×*Ñ*¨:°{ÓCÐCr[   )rV   rN   rW   rP   Úreturnr   )F)rV   rN   rW   rP   re   rt   r  ÚNone)re   rt   r  r   )rc   r   r`   r    )ry   rt   r  zCallable[[Any], str | None])r  r'   )r€   r   r  r   )r€   r   r  r   )r€   r   r  z
Self | Any)
r—   r   r‡   ú
int | Nonerˆ   z#Literal['inside', 'outside'] | Nonere   rt   r  r   )NNNT)r‡   r  re   rt   r  r   )r`   r   re   rt   r  ztuple[np.ndarray, np.ndarray])r  r  )r  rt   )r  rA   )r  Úint)r  r   )r  r   )r   )rÉ   r   r  r   )rÕ   r  )r  rN   )r`   znpt.DTypeLike | Nonere   rt   r…   rç   r  rN   ).)r`   znpt.DTypeLikere   rt   r  rN   )r`   r    re   rt   r  r:   )r`   r   re   rt   r  r   )T)NN)r`   zNpDtype | Nonere   zbool | Noner  rN   )r#  znp.ufuncr—   rx   rS   )rW   znpt.NDArray[np.bool_] | Noner  rP   )r  rE   )rX   z*np.ndarray | tuple[np.ndarray, np.ndarray]rW   rN   )rZ  zSequence[Self]rÉ   r   r  r   )r]  rx   r^  rx   r_  rt   r  znpt.NDArray[np.uint64])rc  rt   rd  zScalar | NonerÉ   r   r  r   )rV   r   r  rE   )rœ   )ro  zLiteral['first', 'last', False]r  rP   )r   N)r¢   z$NumpyValueArrayLike | ExtensionArrayrw  zLiteral['left', 'right']rx  zNumpySorter | Noner  znpt.NDArray[np.intp] | np.intp)r{  rt   r  z!tuple[np.ndarray, ExtensionArray])r�  rt   r  rC   )r�  rt   r  r   )r¤  znpt.NDArray[np.float64]r¥  rx   r  rL   )r�  rx   r«  rt   r¬  rt   )r�  rx   )r«  rt   rÍ  r  rÉ   úAxisInt | None)r«  rt   rÉ   r  )r«  rt   rÉ   r  rÙ  r  )r—   r   rÉ   r  re   rt   r  rI   )r�  rx   r«  rt   r  rL   )
rû  rx   rü  rt   rÍ  r  r  r  r  znpt.NDArray[np.intp])[r;  Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__r   rñ  rí  ÚclassmethodrZ   rg   rl   r   r:   rv   rz   Úpropertyr`   r   r�   rŸ   r£   rj   r¬   r¯   r³   r¼   r¾   rc   r‹   rÂ   rÊ   rÍ   rÒ   r“   rØ   rÜ   rß   rá   rä   rè   r	   r  rõ   rø   ró   Ú__array_priority__r	  r&  r*  r¶   r.  rH  Ú_logical_methodrN  rÙ   r*   r"  rW  r[  rb  r4   r1   re   rq  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  Ú__classcell__)r´   s   @rY   rL   rL   k   s  ø… ñð !Ó àÓØ Ó ð €MØ€Màòó ðð MRðØ ðØ(=ðØEIðà	óð& Ø.2Àô !ó ð!ð Ùˆ×	Ñ	Óò	ó  ó ð	ôð ò(ó ð(ð òó ðð òó ðó
;ð  !Ø:>Øñ*ð ð*ð ð	*ð
 8ð*ð ð*ð 
ó*ñX 	ˆ×	Ñ	ÓàNRðØ.8ðØGKðà	òó  ððB à6;ñ'Ø'ð'Ø/3ð'à	&ò'ó ð'ò
Pó6õ"/óó ð ò ó ð ð òó ðó,ô
,ó
,ó
&ð ò<ó ð<ôBóF@ó@óóDó
.ð
 '+ØØŸ>™>ð	[à#ð[ð ð[ð ð	[ð
 
ó[ñz 	ˆ×	Ñ	ÓñKó  ðKð óó ðð óó ðð óó ðô,ð\ Ðð AEð*Ø#ð*Ø2=ð*à	ó*ð %Ó$óK'óZ@ð ò ó ð ðØ0ðà	óò [5ðz $€Oó&6ðP-Ø@ð-ØHRó-ó^!ð ñ#ó ð#ð ò5ó ð5ð ð ðà!ðð ðð 
ò	ó ððØðØ*-ðØ;?ðà	óð !Ø$(Øñ .ð ð	 .ð
 "ð .ð ð .ð 
ó .óH6ó(,ñ
 	ˆ×	"Ñ	"Ó#à6=ð>Ø3ð>à	ò>ó $ð>ó	/ñ 	ˆ×	$Ñ	$Ó%ð *0Ø%)ð	Hà3ðHð 'ðHð #ð	Hð
 
(òHó &ðHñ  	ˆ×	!Ñ	!Ó"ð !%ð"!àð"!ð 
+ò"!ó #ð"!ñH 	ˆ×	+Ñ	+Ó,òó -ðô&BôP(ñ 	ˆ×	Ñ	ÓòPó  ðPð';Ø)ð';Ø:=ð';à	ó';ðZ ,0À%ñØðØ$(ðØ;?óó4	ò9ð&SØóSð ØØ ñ
ð ð
ð ð	
ð
 ó
ð0 ØØ ñ
ð ð
ð ð	
ð
 ó
ð* &*À!õ Uð !%¸QÈAñTØðTØ,:ðTØFIóTð !%¸QÈAñTØðTØ,:ðTØFIóTð %)Àõ Tð %)Àõ TóGð %)Àõ O+ðb %)Àõ P+ðd29ð #ð29ð ð	29ð ð29ð 
ó29ðj ,0ñ	,Øð	,Ø$(ð	,à	ó	,ð-Dð ð-Dð ð	-Dð
 ð-Dð ð-Dð "÷-Dr[   rL   c                ó¢  — t        | «      } | d   j                  }| D �cg c]  }|j                  j                  dd«      ‘Œ  }}t	        j
                  |dt	        j                  t        | «      t        | d   «      fd|j                  ¬«      ¬«      }| D �cg c]  }|j                  j                  dd«      ‘Œ  }}t	        j
                  |dt	        j                  |t        ¬«      ¬«      }|j                  «       }g }t        |j                  d   «      D ]+  }	 ||dd…|	f   |dd…|	f   ¬	«      }
|j                  |
«       Œ- |S c c}w c c}w )
zÖTranspose masked arrays in a list, but faster.

    Input should be a list of 1-dim masked arrays of equal length and all have the
    same dtype. The caller is responsible for ensuring validity of input data.
    r   rŽ   r�   ÚF)Úorderr`   )rÉ   r  rn   Nr§  )Úlistr`   rO   rÍ   r^   rY  rp   r–   r  rQ   Ú
empty_likert   r  r¸   rc   r  )Úmasked_arraysr`   r  rV   Útransposed_valuesÚmasksÚtransposed_masksÚarr_typeÚtransposed_arraysr»   Útransposed_arrs              rY   Ú#transpose_homogeneous_masked_arraysr+  Q  sI  € ô ˜Ó'€MØ˜!Ñ×"Ñ"€Eà2?Ö@¨3ˆc�i‰i×Ñ  2Õ&Ð@€FÐ@ÜŸ™ØØÜ�H‰HÜ�Ó¤ ]°1Ñ%5Ó!6Ð7ØØ×#Ñ#ô
ôÐð 2?Ö?¨#ˆS�Y‰Y×Ñ˜q "Õ%Ð?€EÐ?Ü—~‘~Ø�Aœ2Ÿ=™=Ð):Ä$ÔGôÐð ×)Ñ)Ó+€HØ/1ÐÜÐ$×*Ñ*¨1Ñ-Ó.ò 1ˆÙ!Ð"3²A°q°DÑ"9Ð@PÒQRÐTUÐQUÑ@VÔWˆØ× Ñ  Õ0ð1ð Ðùò- Aùò @s   Ÿ#EÂ#E)r$  zSequence[BaseMaskedArray]r  zlist[BaseMaskedArray])jÚ
__future__r   Útypingr   r   r   r   r   rï   Únumpyr^   Úpandas._libsr	   r
   rí   Úpandas._libs.tslibsr   Úpandas._typingr   r   r   r   r   r   r   r   r   r   r   r   r   r   Úpandas.compatr   r   Úpandas.errorsr   Úpandas.util._decoratorsr   Úpandas.util._validatorsr   Úpandas.core.dtypes.baser    Úpandas.core.dtypes.commonr!   r"   r#   r$   r%   r&   Úpandas.core.dtypes.dtypesr'   Úpandas.core.dtypes.missingr(   r)   r*   r+   Úpandas.corer,   rp  r-   r.   r/   Úpandas.core.algorithmsr0   r1   r2   r3   r4   Úpandas.core.array_algosr5   r6   Ú pandas.core.array_algos.quantiler7   Úpandas.core.arrayliker8   Úpandas.core.arrays._utilsr9   Úpandas.core.arrays.baser:   Úpandas.core.constructionr;   r=  r<   r=   Úpandas.core.indexersr>   Úpandas.core.opsr?   Úpandas.core.util.hashingr@   Úcollections.abcrA   rB   r‘  rC   r  rE   rF   rG   rI   Úpandas.compat.numpyrJ   rÖ   rL   r+  r~   r[   rY   ú<module>rG     sæ   ðÝ "÷õ ó ã ÷õ 3÷÷ ÷ ÷ ÷ õ .Ý 'Ý :å 2÷÷ õ 6÷ó ÷õ ÷õ ÷õ @Ý *Ý >Ý 2÷ñ õ
 5Ý .Ý /á÷õ Ý/÷õ 1å .ôcD�h ô cDðL/!Ø,ð!àô!r[   