Ë
    u™ãjÝa ã                  ó  — d dl mZ d dlZd dlZd dlmZ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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 d dlmZ d d	l m!Z! d d
l"m#Z# d dl$m%Z%m&Z& d dl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z- d dl.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4 d dl5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z; d dl<m=Z=m>Z>m?Z?m@Z@ d dlAmBZB d dlCmDZDmEZEmFZF d dlGmHZH d dlImJc mKZ d dlLmMZMmNZNmOZOmPZPmQZQ d dlRmSZS d dlTmUZUmVZVmWZW d dlXmYZY d dlZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z` d dlambZb d dlcmdZd d dlemJc mfZg d dlhmiZi d dljmkZkmlZl d dlmmnZnmoZompZp d dlqmrZr er0d dlsmtZtmuZumvZvmwZw d dlxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZm€Z€m�Z�m‚Z‚ d d lƒm„Z„ d d!l…m†Z†  e�j                  d"«      Zˆ G d#„ d$ede�j                  «      Z‰ G d%„ d&e‰«      ZŠ G d'„ d(eŠ«      Z‹ G d)„ d*e‰«      ZŒ G d+„ d,eŠ«      Z� G d-„ d.e�«      ZŽd;d/„Z�d<d0„Z�d=d1„Z‘d>d2„Z’	 d?	 	 	 	 	 	 	 d@d3„Z“dd4œ	 	 	 	 	 	 	 dAd5„Z”dBd6„Z•	 	 	 	 	 	 	 	 dCd7„Z–d?dDd8„Z—dEdFd9„Z˜d<d:„Z™y)Gé    )ÚannotationsN)ÚTYPE_CHECKINGÚAnyÚLiteralÚSelfÚcastÚfinal)ÚNaTÚalgosÚ	internalsÚlib)ÚBlockPlacementÚBlockValuesRefs)ÚNA)ÚAbstractMethodErrorÚOutOfBoundsDatetimeÚPandas4Warning)Úcache_readonly)Úfind_stack_level)Úvalidate_bool_kwarg)Úastype_array_safeÚastype_is_view)ÚLossySetitemErrorÚcan_hold_elementÚ'construct_1d_object_array_from_listlikeÚconvert_dtypesÚfind_result_typeÚnp_can_hold_element)Úis_1d_only_ea_dtypeÚis_float_dtypeÚis_integer_dtypeÚis_list_likeÚ	is_scalarÚis_string_dtype)ÚCategoricalDtypeÚDatetimeTZDtypeÚExtensionDtypeÚIntervalDtypeÚNumpyEADtypeÚPeriodDtype)ÚABCDataFrameÚABCIndexÚABCNumpyExtensionArrayÚ	ABCSeries)Úis_re)Úis_valid_na_for_dtypeÚisnaÚna_value_for_dtype)Úmissing)Úextract_bool_arrayÚputmask_inplaceÚputmask_without_repeatÚsetitem_datetimelike_compatÚvalidate_putmask)Úquantile_compat)Úcompare_or_regex_searchÚreplace_regexÚshould_use_regex)Úshift)ÚDatetimeArrayÚExtensionArrayÚIntervalArrayÚNumpyExtensionArrayÚPeriodArrayÚTimedeltaArray)ÚStringDtype)ÚPandasObject)Úexpressions)Úensure_wrapped_if_datetimelikeÚextract_array)Úcheck_setitem_lengthsÚis_scalar_indexerÚlength_of_indexer)Úget_values_for_csv)ÚCallableÚ	GeneratorÚIterableÚSequence)
Ú	ArrayLikeÚAxisIntÚDtypeBackendÚDtypeObjÚFillnaOptionsÚIgnoreRaiseÚInterpolateOptionsÚQuantileInterpolationÚShapeÚnpt)ÚIndex)ÚNDArrayBackedExtensionArrayÚobjectc                  ó´  — e Zd ZU dZded<   ded<   ded<   ded	<   d
ZdZeedOd„«       «       Z	eedOd„«       «       Z
eedOd„«       «       ZeedOd„«       «       Zeed„ «       «       ZeedOd„«       «       ZeedOd„«       «       Zed„ «       Zeed„ «       «       Zed„ «       ZedPd„«       Zej*                  dQd„«       Ze	 	 dR	 	 	 	 	 dSd„«       Ze	 	 dR	 	 	 	 	 dTd„«       ZedUd„«       ZedVd„«       ZedWd„«       ZedXd„«       Ze	 dY	 	 	 	 	 	 	 dZd„«       Zed[d „«       Zed\d!„«       Zed]d"„«       Zed^d#„«       Z ed_d$„«       Z!ed`d%„«       Z"ed]d&„«       Z#edad'„«       Z$ed]d(„«       Z%	 	 	 	 	 	 db	 	 	 	 	 	 	 	 	 	 	 	 	 dcd)„Z&eeddd*„«       «       Z'e	 	 de	 	 	 	 	 	 	 dfd+„«       Z(ed,dd-œ	 	 	 dgd.„«       Z)edhd/„«       Z*didjd0„Z+edkd1„«       Z,e	 	 dl	 	 	 	 	 dmd2„«       Z-e	 	 dl	 	 	 dnd3„«       Z.e	 	 do	 	 	 	 	 	 	 	 	 dpd4„«       Z/e	 	 dq	 	 	 	 	 	 	 drd5„«       Z0dsd6„Z1d7„ Z2edtd8„«       Z3dud9„Z4	 	 	 	 dvd:„Z5dYdwd;„Z6ede7jp                  f	 	 	 	 	 	 	 dxd<„«       Z9	 	 	 	 dyd=„Z:d^d>„Z;d]d?„Z<d]d@„Z=	 	 dz	 	 	 	 	 d{dA„Z>ddddBœ	 	 	 	 	 	 	 	 	 d|dC„Z?edddDddEœ	 	 	 	 	 	 	 	 	 	 	 	 	 d}dF„«       Z@ed~dG„«       ZAdd€dH„ZBe	 d�	 	 	 	 	 d‚dI„«       ZCedƒdJ„«       ZDd]dK„ZEedOdL„«       ZFed„dM„«       ZGdd…dN„ZHy)†ÚBlockz�
    Canonical n-dimensional unit of homogeneous dtype contained in a pandas
    data structure

    Index-ignorant; let the container take care of that
    znp.ndarray | ExtensionArrayÚvaluesÚintÚndimr   ÚrefszCallable[..., None]Ú__init__© Fc                ó.   — t        | j                  «       S )z§
        We validate dimension for blocks that can hold 2D values, which for now
        means numpy dtypes or EA dtypes like DatetimeTZDtype and PeriodDtype.
        )r   Údtype©Úselfs    úg/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/core/internals/blocks.pyÚ_validate_ndimzBlock._validate_ndim¡   s   € ô ' t§z¡zÓ2Ð2Ð2ó    c                ó<   — | j                   j                  t        k(  S ©N)r`   rg   Ú
_dtype_objrh   s    rj   Ú	is_objectzBlock.is_objectª   s   € ð �{‰{× Ñ ¤JÑ.Ð.rl   c                óV   — t        j                  | j                  j                  «       S rn   )r   Úis_np_dtyper`   rg   rh   s    rj   Úis_extensionzBlock.is_extension¯   s    € ô —?‘? 4§;¡;×#4Ñ#4Ó5Ð5Ð5rl   c                ó   — | j                    S rn   )rs   rh   s    rj   Ú_can_consolidatezBlock._can_consolidate´   s   € ð ×$Ñ$Ð$Ð$rl   c                óF   — | j                   | j                  j                  fS rn   )ru   rg   Únamerh   s    rj   Ú_consolidate_keyzBlock._consolidate_keyº   s   € ð ×$Ñ$ d§j¡j§o¡oÐ5Ð5rl   c                ó‚   — | j                   }t        |t        j                   «      r|j                  dvS |j                  S )z7
        Can we store NA values in this Block?
        Úiub)rg   Ú
isinstanceÚnpÚkindÚ_can_hold_na©ri   rg   s     rj   r~   zBlock._can_hold_na¿   s6   € ð —
‘
ˆÜ�eœRŸX™XÔ&Ø—:‘: UÐ*Ð*Ø×!Ñ!Ð!rl   c                ób   — | j                   j                  t        j                  t        «      k(  S )z^
        We can be bool if a) we are bool dtype or b) object dtype with bool objects.
        )r`   rg   r|   Úboolrh   s    rj   Úis_boolzBlock.is_boolÊ   s!   € ð �{‰{× Ñ ¤B§H¡H¬T£NÑ2Ð2rl   c                ó,   — t        | j                  «      S rn   )Úexternal_valuesr`   rh   s    rj   r„   zBlock.external_valuesÒ   s   € ä˜tŸ{™{Ó+Ð+rl   c                ó0   — t        | j                  d¬«      S )NF)Úcompat)r2   rg   rh   s    rj   Ú
fill_valuezBlock.fill_valueÖ   s   € ô " $§*¡*°UÔ;Ð;rl   c                óp   — | j                   t        k7  r"t        || j                   «      r| j                  }|S rn   )rg   ro   r0   r‡   ©ri   Úvalues     rj   Ú_standardize_fill_valuezBlock._standardize_fill_valueÜ   s,   € ð �:‰:œÒ#Ô(=¸eÀTÇZÁZÔ(PØ—O‘OˆEØˆrl   c                ó   — | j                   S rn   ©Ú	_mgr_locsrh   s    rj   Úmgr_locszBlock.mgr_locsã   s   € à�~‰~Ðrl   c                ó   — || _         y rn   r�   )ri   Únew_mgr_locss     rj   r�   zBlock.mgr_locsç   s	   € à%ˆ�rl   Nc                ó–   — |€| j                   }| j                  rt        || j                  ¬«      }t	        ||| j                  |¬«      S )zm
        Create a new block, with type inference propagate any values that are
        not specified
        ©rb   ©Ú	placementrb   rc   )rŽ   rs   Úensure_block_shaperb   Ú	new_block©ri   r`   r•   rc   s       rj   Ú
make_blockzBlock.make_blockë   sA   € ð ÐØŸ™ˆIØ×ÒÜ'¨°T·Y±YÔ?ˆFä˜¨9¸4¿9¹9È4ÔPÐPrl   c                ó\   — |€| j                   } t        | «      ||| j                  |¬«      S )z2Wrap given values in a block of same type as self.r”   )rŽ   Útyperb   r˜   s       rj   Úmake_block_same_classzBlock.make_block_same_classý   s0   € ð ÐØŸ™ˆIð Œt�D‹z˜&¨I¸D¿I¹IÈDÔQÐQrl   c                óP  — t        | «      j                  }| j                  dk(  r|› dt        | «      › d| j                  › �}|S dj                  | j                  D �cg c]  }t        |«      ‘Œ c}«      }|› d| j                  j                  › d|› d| j                  › �}|S c c}w )Né   z: z dtype: z x z, z	, dtype: )
r›   Ú__name__rb   Úlenrg   ÚjoinÚshapeÚstrr�   Úindexer)ri   rw   ÚresultÚsr¢   s        rj   Ú__repr__zBlock.__repr__  s›   € ô �D‹z×"Ñ"ˆØ�9‰9˜Š>Ø�v˜R¤ D£	˜{¨(°4·:±:°,Ð?ˆFð
 ˆð —J‘J°·
±
Ö;¨1¤ A¥Ò;Ó<ˆEØ�v˜R §¡× 5Ñ 5Ð6°b¸¸¸yÈÏÉÈÐUˆFàˆùò  <s   ÁB#c                ó,   — t        | j                  «      S rn   )r    r`   rh   s    rj   Ú__len__zBlock.__len__  s   € ä�4—;‘;ÓÐrl   c                ó˜   — | j                   |   }| j                  |«      }| j                  } t        | «      ||| j                  |¬«      S )zC
        Perform __getitem__-like, return result as block.
        ©rc   )rŽ   Ú_slicerc   r›   rb   )ri   Úslcr‘   Ú
new_valuesrc   s        rj   Úslice_block_columnszBlock.slice_block_columns  sD   € ð
 —~‘~ cÑ*ˆà—[‘[ Ó%ˆ
Ø�y‰yˆØŒt�D‹z˜* l°D·I±IÀDÔIÐIrl   c                ó€   — | j                   |   }| j                  |«      } t        | «      ||| j                  d¬«      S ©z
        Perform __getitem__-like, return result as block.

        Only supports slices that preserve dimensionality.
        Nr«   )rŽ   r¬   r›   rb   )ri   Úindicesr‘   r®   s       rj   Útake_block_columnszBlock.take_block_columns(  s;   € ð —~‘~ gÑ.ˆà—[‘[ Ó)ˆ
ØŒt�D‹z˜* l°D·I±IÀDÔIÐIrl   c                ó¶   — | j                  |«      }|r| j                  j                  «       r| j                  nd} t        | «      ||| j                  |¬«      S r±   )r¬   rc   Úhas_referencer›   rb   )ri   Úslicerr‘   Úref_inplace_opr®   rc   s         rj   Úgetitem_block_columnszBlock.getitem_block_columns7  sJ   € ð —[‘[ Ó(ˆ
Ù .°$·)±)×2IÑ2IÔ2Kˆt�yŠyÐQUˆØŒt�D‹z˜* l°D·I±IÀDÔIÐIrl   c                óH   — t        |d¬«      }t        | j                  |«      S )z#require the same dtype as ourselvesT©Úextract_numpy)rH   r   r`   )ri   Úelements     rj   Ú_can_hold_elementzBlock._can_hold_elementD  s!   € ô   °tÔ<ˆÜ §¡¨WÓ5Ð5rl   c                ó4   — |j                   | j                   k(  S )zÝ
        Should we set self.values[indexer] = value inplace or do we need to cast?

        Parameters
        ----------
        value : np.ndarray or ExtensionArray

        Returns
        -------
        bool
        ©rg   r‰   s     rj   Úshould_storezBlock.should_storeJ  s   € ð �{‰{˜dŸj™jÑ(Ð(rl   c                ó`   —  || j                   fi |¤Ž}t        |«      }| j                  |«      S )z[
        apply the function to my values; return a block if we are not
        one
        )r`   Úmaybe_coerce_valuesÚ_split_op_result)ri   ÚfuncÚkwargsr¥   s       rj   ÚapplyzBlock.apply\  s2   € ñ �d—k‘kÑ, VÑ,ˆä$ VÓ,ˆØ×$Ñ$ VÓ,Ð,rl   c                óÆ   — | j                   dk(  sJ ‚ || j                  «      }| j                  j                   dk(  r|}n|j                  dd«      }| j                  |«      S )Né   rž   éÿÿÿÿ)rb   r`   Úreshaper™   )ri   rÄ   r¥   Ú
res_valuess       rj   ÚreducezBlock.reduceg  sX   € ð �y‰y˜AŠ~Ðˆ~á�d—k‘kÓ"ˆà�;‰;×Ñ˜qÒ Ø‰JàŸ™¨¨AÓ.ˆJà�‰˜zÓ*Ð*rl   c                ób  — |j                   dkD  r�t        |j                  t        «      rsg }t	        | j
                  «      D ]W  \  }}t        |j                  «      s	|||dz    }n||   }t        |«      }| j                  ||¬«      }|j                  |«       ŒY |S | j                  |«      }|gS )Nrž   )r`   r•   )
rb   r{   rg   r'   Ú	enumeraterŽ   r   r   r™   Úappend)	ri   r¥   ÚnbsÚiÚlocÚvalsÚbpÚblockÚnbs	            rj   rÃ   zBlock._split_op_resultv  s¨   € ð �;‰;˜Š?œz¨&¯,©,¼ÔGð ˆCÜ# D§N¡NÓ3ò "‘��3Ü*¨6¯<©<Ô8Ø! ! a¨!¡eÐ,‘Dà! !™9�Dä# CÓ(�ØŸ™¨t¸r˜ÓB�Ø—
‘
˜5Õ!ð"ð ˆJà�_‰_˜VÓ$ˆàˆtˆrl   c              #  óü   K  — | j                   dk(  sJ ‚t        | j                  «      D ]O  \  }}| j                  t	        ||dz   «         }t        |«      } t        | «      ||d| j                  ¬«      }|–— ŒQ y­w)zD
        Split a block into a list of single-column blocks.
        rÈ   rž   r”   N)rb   rÎ   rŽ   r`   Úslicer   r›   rc   )ri   rÑ   Úref_locrÓ   rÔ   rÖ   s         rj   Ú_splitzBlock._splitŒ  su   è ø€ ð
 �y‰y˜AŠ~Ðˆ~ä# D§N¡NÓ3ò 	‰JˆAˆwØ—;‘;œu Q¨¨A©›Ñ/ˆDä Ó(ˆBØ”�d“˜D¨B°Q¸T¿Y¹YÔGˆBØ‹Hñ	ùs   ‚A:A<c                ó´   — | j                   dk(  r| j                  d   dk7  sJ ‚g }| j                  «       D ]  } ||g|¢­i |¤Ž}|j                  |«       Œ! |S )zÙ
        Split the block and apply func column-by-column.

        Parameters
        ----------
        func : Block method
        *args
        **kwargs

        Returns
        -------
        List[Block]
        rÈ   r   rž   )rb   r¢   rÚ   Úextend)ri   rÄ   ÚargsrÅ   Ú
res_blocksrÖ   Úrbss          rj   Úsplit_and_operatezBlock.split_and_operateš  sh   € ð �y‰y˜AŠ~ $§*¡*¨Q¡-°1Ò"4Ð4Ð4àˆ
Ø—+‘+“-ò 	#ˆBÙ�rÐ+˜DÒ+ FÑ+ˆCØ×Ñ˜cÕ"ð	#ð Ðrl   c                ó  — t        | j                  j                  |«      }|| j                  k(  r:t        j                  |d«      rt        d| j                  › d�«      ‚t        d«      ‚t        |«      rtt        | j                  j                  «      rUt        |«      rJ|t        urBt        |t        j                  t        j                  f«      rt        j                  |«      sd}ntt        |t        j                   «      rZ|j"                  dk(  rKt        | j                  j                  «      r,t%        |j                  «      rt        j&                  |«      rd}|r&t)        d|› d| j                  j                  › d	�«      ‚| j                  j                  |k(  r&t        d
|› d| j                  j                  › d�«      ‚	 | j+                  |«      S # t
        $ r}t        d| j                  › d�«      |‚d}~ww xY w)zé
        coerce the current block to a dtype compat for other
        we will return a block, possibly object, and not raise

        we can also safely try to coerce to the same dtype
        and will receive the same block
        ÚmMz0Incompatible (high-resolution) value for dtype='z$'. Explicitly cast before operating.z\Something has gone wrong, please report a bug at https://github.com/pandas-dev/pandas/issuesFrž   zInvalid value 'z' for dtype 'ú'zDid not expect new dtype z to equal self.dtype zE. Please report a bug at https://github.com/pandas-dev/pandas/issues.N)r   r`   rg   r   rr   r   ÚAssertionErrorr#   r!   r1   r
   r{   r|   Ú
datetime64Útimedelta64ÚisnatÚndarrayrb   r    Úhas_only_ints_or_nanÚ	TypeErrorÚastype)ri   ÚotherÚraise_on_upcastÚ	new_dtypeÚerrs        rj   Úcoerce_to_target_dtypezBlock.coerce_to_target_dtype´  sÇ  € ô % T§[¡[×%6Ñ%6¸Ó>ˆ	Ø˜Ÿ
™
Ò"Ü�‰˜y¨$Ô/ô *ðØ"Ÿj™j˜\ð *8ð8óð ô !ð>óð ô �eÔÜ  §¡×!2Ñ!2Ô3Ü�U”ØœSÑ ä˜5¤2§=¡=´"·.±.Ð"AÔBÄrÇxÁxÐPUÄð $‰Oä�uœbŸj™jÔ)Ø—
‘
˜a’Ü  §¡×!2Ñ!2Ô3Ü˜uŸ{™{Ô+Ü×(Ñ(¨Ô/à#ˆOáÜ˜o¨e¨W°MÀ$Ç+Á+×BSÑBSÐATÐTUÐVÓWÐWØ�;‰;×Ñ 	Ò)Ü Ø+¨I¨;Ð6KØ—;‘;×$Ñ$Ð%ð &?ð?óð ð

	Ø—;‘;˜yÓ)Ð)øÜ"ò 	ô
 &ØBÀ4Ç:Á:À,ð O4ð 4óð ðûð	ús   ÇG Ç	G>ÇG9Ç9G>c                óF  — | j                   s| j                  d¬«      gS | j                  dk7  rX| j                  d   dk7  rF| j	                  t
        j                  «      }t        d„ |D «       «      r| j                  d¬«      gS |S | j                  }|j                  dk(  r|d   }t        j                  |d¬«      }d	}||u st        |t        «      r|j                  |u r| j                  }t        || j                  «      }t!        |«      }| j#                  ||¬
«      gS )zz
        Attempt to coerce any object types to better types. Return a copy
        of the block (if copy = True).
        F©Údeeprž   r   c              3  óN   K  — | ]  }|j                   j                  d k(  –— Œ y­w)ÚON©rg   r}   )Ú.0Úblks     rj   ú	<genexpr>z Block.convert.<locals>.<genexpr>  s   è ø€ Ò;¨S�3—9‘9—>‘> SÕ(Ñ;ùs   ‚#%rÈ   T)Úconvert_non_numericNr«   )rp   Úcopyrb   r¢   rà   r_   ÚconvertÚallr`   r   Úmaybe_convert_objectsr{   rA   Ú_ndarrayrc   r–   rÂ   r™   )ri   Úblocksr`   rË   rc   s        rj   rü   zBlock.convert÷  s  € ð �~Š~Ø—I‘I 5�IÓ)Ð*Ð*à�9‰9˜Š>˜dŸj™j¨™m¨qÒ0Ø×+Ñ+¬E¯M©MÓ:ˆFÜÑ;°FÔ;Ô;àŸ	™	 u˜	Ó-Ð.Ð.ØˆMà—‘ˆØ�;‰;˜!Òð ˜A‘YˆFä×.Ñ.ØØ $ô
ˆ
ð ˆØ˜ÑÜ�zÔ#6Ô7Ø×#Ñ# vÑ-à—9‘9ˆDä'¨
°D·I±IÓ>ˆ
Ü(¨Ó4ˆ
Ø—‘ 
°�Ó6Ð7Ð7rl   c                ó�  ‡— |r| j                   r| j                  «       }n| g}t        ||||g«      s |D �cg c]  }|j                  d¬«      ‘Œ c}S g }	|D ]â  Š‰j                  dk(  s‰j
                  d   dk(  r‰gnt        ‰j                  «       «      }
|
D �cg c]  }t        |j                  ||||||«      ‘Œ }}t        ˆfd„|D «       «      r"|	j                  ‰j                  d¬«      «       Œžt        ||
d¬«      D ]4  \  }}|	j                  |j                  ||j                  dk7  ¬«      «       Œ6 Œä |	S c c}w c c}w )	NFrò   rž   r   c              3  ó<   •K  — | ]  }|‰j                   k(  –— Œ y ­wrn   r¿   )r÷   rg   rø   s     €rj   rù   z'Block.convert_dtypes.<locals>.<genexpr>A  s   øè ø€ Ò:¨%�5˜CŸI™IÕ%Ñ:ùs   ƒT©Ústrict)rg   Úsqueeze)rp   rü   Úanyrû   rb   r¢   ÚlistrÚ   r   r`   rý   rÏ   Úziprë   )ri   Úinfer_objectsÚconvert_stringÚconvert_integerÚconvert_booleanÚconvert_floatingÚdtype_backendÚblksÚbrß   Úsub_blksÚdtypesrg   rø   s                @rj   r   zBlock.convert_dtypes  sS  ø€ ñ ˜TŸ^š^Ø—<‘<“>‰Dà�6ˆDäØ˜°ÀÐPô
ð 15Ö5¨1�A—F‘F �FÕ&Ò5Ð5àˆØò 	GˆCð Ÿ™ Qš¨#¯)©)°A©,¸!Ò*;�‘ÄÀcÇjÁjÃlÓASð ð "öð ô Ø—H‘HØ"Ø#Ø#Ø$Ø!Ø!õðˆFð ô Ó:°6Ô:Ô:à—
‘
˜3Ÿ8™8¨˜8Ó/Ô0Øä ¨¸Ô>ò G‘��qØ—
‘
˜1Ÿ8™8¨%¸¿¹À1¹˜8ÓEÕFñGð-	Gð0 ˆ
ùò7 6ùòs   ·D>Â"Ec                ó.   — | j                   j                  S rn   )r`   rg   rh   s    rj   rg   zBlock.dtypeM  s   € ð �{‰{× Ñ Ð rl   c                ó0  — | j                   }|r@|j                  dk(  r1t        |«      r&|j                  d   dk7  rt	        d«      ‚|ddd…f   }t        |||¬«      }t        |«      }d}t        |j                  |j                  «      r| j                  }| j                  ||¬«      }|j                  | j                  k7  rTt        d| j                  j                  › d	| j                  › d
|j                  j                  › d	|j                  › d�	«      ‚|S )aÕ  
        Coerce to the new dtype.

        Parameters
        ----------
        dtype : np.dtype or ExtensionDtype
        errors : str, {'raise', 'ignore'}, default 'raise'
            - ``raise`` : allow exceptions to be raised
            - ``ignore`` : suppress exceptions. On error return original object
        squeeze : bool, default False
            squeeze values to ndim=1 if only one column is given

        Returns
        -------
        Block
        rÈ   r   rž   z*Can not squeeze with more than one column.N)Úerrorsr«   zcannot set astype for dtype (z [z]) to different shape (z]))r`   rb   r   r¢   Ú
ValueErrorr   rÂ   r   rg   rc   r™   rê   rw   )ri   rg   r  r  r`   r®   rc   Únewbs           rj   rë   zBlock.astypeR  sý   € ð. —‘ˆÙ�v—{‘{ aÒ'Ô,?ÀÔ,FØ�|‰|˜A‰ !Ò#Ü Ð!MÓNÐNØ˜Ašq˜D‘\ˆFä& v¨u¸VÔDˆ
ä(¨Ó4ˆ
àˆÜ˜&Ÿ,™,¨
×(8Ñ(8Ô9Ø—9‘9ˆDà�‰˜z°ˆÓ5ˆØ�:‰:˜Ÿ™Ò#ÜðØ—J‘J—O‘OÐ$ B t§z¡z lð 3Ø—J‘J—O‘OÐ$ B t§z¡z l°"ð6óð ð
 ˆrl   Únan)Úna_repÚquotingc               óZ   — t        | j                  |||||¬«      }| j                  |«      S )z"convert to our native types format)r  r  Úfloat_formatÚdate_formatÚdecimal)rL   r`   r™   )ri   r  r  r  r  r  r¥   s          rj   rL   zBlock.get_values_for_csv€  s5   € ô
 $Ø�K‰KØØØ%Ø#Øô
ˆð �‰˜vÓ&Ð&rl   c               ó(  — | j                   }|r@t        |t        j                  «      r|j	                  d¬«      }n|j	                  «       }d}n|j                  «       }| j                  } t        | «      || j                  | j                  |¬«      S )zcopy constructorÚK)ÚorderNr”   )
r`   r{   r|   rè   rû   Úviewrc   r›   rŽ   rb   )ri   ró   r`   rc   s       rj   rû   z
Block.copy�  st   € ð —‘ˆáÜ˜&¤"§*¡*Ô-ð  Ÿ™¨3˜Ó/‘àŸ™›�Ø‰Dà—[‘[“]ˆFØ—9‘9ˆDØŒt�D‹z˜&¨D¯N©NÀÇÁÐQUÔVÐVrl   c                ób   — |r| j                   j                  «       s| S | j                  |¬«      S )Nrò   )rc   rµ   rû   )ri   Úinplaceró   s      rj   Ú_maybe_copyzBlock._maybe_copy¤  s*   € Ù˜4Ÿ9™9×2Ñ2Ô4ØˆKØ�y‰y˜dˆyÓ#Ð#rl   c                óp   — d }| }|r,| j                   j                  «       rd}||fS | j                   }||fS )NT)rc   rµ   )ri   r$  rc   rû   s       rj   Ú_get_refs_and_copyzBlock._get_refs_and_copy©  sG   € àˆØˆ{ˆÙØ�y‰y×&Ñ&Ô(Ø�ð �TˆzÐð —y‘y�Ø�TˆzÐrl   c                ó2  — | j                   }| j                  |«      s| j                  |d¬«      gS |€t        j                  ||«      }|j                  «       s| j                  |d¬«      gS | j                  |«      s| j                  dk(  r6t        |«      r+| j                  |«      }t        |j                   ||«       |gS | j                  dk(  s| j                  d   dk(  r[|�|t        u r)| j                  t        j                  t        «      «      }n| j                  |d¬«      }|j!                  ||d|¬«      S g }t#        | j%                  «       «      D ]9  \  }}	|j'                  t)        | «      j!                  |	||d|||dz    ¬«      «       Œ; |S )	z…
        replace the to_replace value with value, possible to create new
        blocks here this is just a call to putmask.
        Frò   Ústringrž   r   ©rí   T©Ú
to_replacerŠ   r$  Úmask)r`   r½   r%  r3   Úmask_missingr  rg   r/   r5   rb   r¢   r   rë   r|   r]   rð   ÚreplacerÎ   rÚ   rÜ   r›   )
ri   r,  rŠ   r$  r-  r`   rø   r   rÑ   rÖ   s
             rj   r/  zBlock.replace·  s•  € ð" —‘ˆà×%Ñ% jÔ1ð
 ×$Ñ$ W°5Ð$Ó9Ð:Ð:àˆ<Ü×'Ñ'¨°
Ó;ˆDØ�x‰xŒzð ×$Ñ$ W°5Ð$Ó9Ð:Ð:à×#Ñ# EÔ*¨t¯z©z¸XÒ/EÌ%ÐPUÌ,ð ×"Ñ" 7Ó+ˆCÜ˜CŸJ™J¨¨eÔ4Ø�5ˆLà�Y‰Y˜!Š^˜tŸz™z¨!™}°Ò1Øˆ} ¬¡Ø—k‘k¤"§(¡(¬6Ó"2Ó3‘à×1Ñ1°%ÈÐ1ÓO�Ø—;‘;Ø%ØØØð	 ó ð ð ˆFÜ" 4§;¡;£=Ó1ò 	‘��2Ø—‘Ü˜“J×&Ñ&ØØ#-Ø#Ø $Ø! ! a¨!¡e˜_ð 'ó õð	ð ˆMrl   c                ó~  — t        |«      s$| j                  |«      s| j                  d¬«      gS t        |«      r0t        | j                  «      t
        dfvr| j                  d¬«      gS | j                  |«      s‚| j                  dk(  rt        |«      sh| j                  t        j                  t
        «      «      }t        | j                  t        j                  t
        «      «      r$|j                  d¬«      }n| j                  |«      }t        j                  |«      }t        |j                  |||«       |gS )aæ  
        Replace elements by the given value.

        Parameters
        ----------
        to_replace : object or pattern
            Scalar to replace or regular expression to match.
        value : object
            Replacement object.
        inplace : bool, default False
            Perform inplace modification.
        mask : array-like of bool, optional
            True indicate corresponding element is ignored.

        Returns
        -------
        List[Block]
        Frò   r)  T©r$  )r/   r½   rû   Ú_regex_target_dtyperg   r]   rë   r|   r   r%  ÚreÚcompiler;   r`   )ri   r,  rŠ   r$  r-  rÕ   Úrxs          rj   Ú_replace_regexzBlock._replace_regexú  s  € ô4 �ZÔ ¨×)?Ñ)?À
Ô)Kð —I‘I 5�IÓ)Ð*Ð*ä�ÔÔ!4°T·Z±ZÓ!@ÜØðI
ñ "
ð —I‘I 5�IÓ)Ð*Ð*ð ×"Ñ" 5Ô)¨d¯j©j¸HÒ.DÌÈuÌð —K‘K¤§¡¬Ó 0Ó1ˆEÜ˜dŸj™j¬"¯(©(´6Ó*:Ô;Ø×)Ñ)°$Ð)Ó7‘à×$Ñ$ WÓ-ˆEä�Z‰Z˜
Ó#ˆä�e—l‘l B¨¨tÔ4Øˆwˆrl   c           
     óê  ‡‡‡— | j                   Št        ||d¬«      D ��cg c]4  \  }}| j                  |«      s| j                  dk(  rt	        |«      r||f‘Œ6 }}}|s| j                  d¬«      gS t        |«      dz
  }t        ‰j                  «      s ‰r8t        t        ‰j                  «      «      rt        ‰«       Šˆˆˆfd„|D «       }	nˆfd„|D «       }	|rt        |	«      }	| g}
t        t        ||	d¬«      «      D �]9  \  }\  \  }}}g }t        |
«      D �]  \  }}t        |
«      dk(  r|}n|}t        |t        «      rJ ‚|||dz    }|j                  ||||‰¬	«      }||k7  r»t        | j                  j                   «      D ��ci c]  \  }}t#         |«       «      |“Œ }}}|D �ch c]9  }|j                  | j                  u rt#        |«      |v r|| ur|t#        |«         ’Œ; }}t%        |d¬
«      D ]'  }| j                  j                   j'                  |«       Œ) |j)                  |«       �Œ |}
�Œ< i }|
D ]˜  }|j                  }|j+                  t#        |«      «      }|€5|j                   D �ch c]  }t#         |«       «      ’Œ }}||t#        |«      <   t#        |«      |vsŒn|j-                  |«       |j/                  t#        |«      «       Œš |
S c c}}w c c}}w c c}w c c}w )z:
        See BlockManager.replace_list docstring.
        Tr  r)  Frò   rž   c           	   3  óT   •K  — | ]  }t        t        ‰|d    ‰‰¬«      «      –— Œ! y­w)r   )Úregexr-  N)r4   r:   )r÷   r¦   Úna_maskr9  r`   s     €€€rj   rù   z%Block.replace_list.<locals>.<genexpr>Q  s2   øè ø€ ò 6ð ô #Ü+¨F°A°a±DÀÈGÔT÷ñ6ùs   ƒ%(c              3  óP   •K  — | ]  }t        j                  ‰|d    «      –— Œ y­w)r   N)r3   r.  )r÷   r¦   r`   s     €rj   rù   z%Block.replace_list.<locals>.<genexpr>Y  s"   øè ø€ ÒG¸A”W×)Ñ)¨&°!°A±$×7ÑGùs   ƒ#&)r,  rŠ   r-  r$  r9  )Úreverse)r`   r  r½   rg   r/   rû   r    r$   r2  r1   r  rÎ   r{   r�   Ú_replace_coercerc   Úreferenced_blocksÚidÚsortedÚpoprÜ   ÚgetÚadd_referenceÚadd) ri   Úsrc_listÚ	dest_listr$  r9  ÚxÚyÚpairsÚsrc_lenÚmasksÚrbrÑ   ÚsrcÚdestr-  Únew_rbÚblk_numrø   ÚmÚmibr¥   ÚidxÚrefÚself_blk_idsÚres_blkÚdropÚ
registeredÚret_blkrc   Úidsr:  r`   s        `                         @@rj   Úreplace_listzBlock.replace_list3  s  ú€ ð —‘ˆô
 ˜H i¸Ô=÷
á��1Ø×&Ñ& qÔ)¨d¯j©j¸HÒ.DÌÈqÌð �ŠFð
ˆñ 
ñ
 Ø—I‘I 5�IÓ)Ð*Ð*ä�e“*˜q‘.ˆä˜6Ÿ<™<Ô(Ù”oÔ&9¸&¿,¹,Ó&GÔHô ˜F“|�mˆGõ6ð ô	6‰Eó HÀÔGˆEñ Ü˜“KˆEð ˆVˆä&/´°E¸5ÈÔ0NÓ&Oó 4	Ñ"ˆAÑ"‘��d˜TØ"$ˆFô
 !*¨"£ó -&‘�˜Ü�r“7˜a’<Ø‘Aà�CÜ)¨#¬tÔ4Ð4Ð4Ø˜G g°¡kÐ2�Að
 ×,Ñ,Ø"ØØØ#Øð -ó �ð ˜’<ô )2°$·)±)×2MÑ2MÓ(N÷$á$˜C ô ™3›5›	 3™ð$�Lñ $ð (.öà#Ø"Ÿ<™<¨4¯9©9Ñ4Ü˜w›K¨<Ñ7Ø#¨4Ñ/ð	 %¤R¨£[Ó1ð�Dð ô  & d°DÔ9ò =˜ØŸ	™	×3Ñ3×7Ñ7¸Õ<ð=ð —‘˜fÖ%ð[-&ð\ ŠBði4	ðz +-ˆ
Øò 	%ˆGØ—<‘<ˆDØ—.‘.¤ D£Ó*ˆCØˆ{Ø,0×,BÑ,BÖC S”r™#›%•yÐC�ÐCØ'*�
œ2˜d›8Ñ$Ü�'‹{ #Ò%Ø×"Ñ" 7Ô+Ø—‘œ˜7›Õ$ð	%ð ˆ	ùóS
ùóz$ùòùò< Ds   ¡9KÆK%
Æ.>K+É;K0c                óú  — t        ||«      r| j                  ||||¬«      S |€Ä|j                  «       r¡| j                  j	                  «       }| j                  t        j                  t        «      «      }|s|j                  d¬«      }n0|r.|r,|j                  j	                  «       r|j                  d¬«      }t        |j                  ||«       |gS | j                  d¬«      gS | j                  ||||¬«      S )ai  
        Replace value corresponding to the given boolean array with another
        value.

        Parameters
        ----------
        to_replace : object or pattern
            Scalar to replace or regular expression to match.
        value : object
            Replacement object.
        mask : np.ndarray[bool]
            True indicate corresponding element is ignored.
        inplace : bool, default True
            Perform inplace modification.
        regex : bool, default False
            If true, perform regular expression substitution.

        Returns
        -------
        List[Block]
        )r$  r-  Trò   Fr+  )r<   r6  r  rc   rµ   rë   r|   rg   r]   rû   r5   r`   r/  )ri   r,  rŠ   r-  r$  r9  Úhas_refrÖ   s           rj   r=  zBlock._replace_coerce¬  sï   € ô< ˜E :Ô.Ø×&Ñ&ØØØØð	 'ó ð ð ˆ}à—8‘8”:Ø"Ÿi™i×5Ñ5Ó7�GØŸ™¤R§X¡X¬fÓ%5Ó6�BÙ"ØŸW™W¨$˜WÓ/™Ù ¡W°·±×1FÑ1FÔ1HàŸW™W¨$˜WÓ/˜Ü# B§I¡I¨t°UÔ;Ø˜4�KØŸ	™	 u˜	Ó-Ð.Ð.Ø—<‘<Ø%ØØØð	  ó ð rl   c                ó   — |S ©zA
        For compatibility with 1D-only ExtensionArrays.
        re   ©ri   Úargs     rj   Ú_maybe_squeeze_argzBlock._maybe_squeeze_argê  s	   € ð ˆ
rl   c                ó   — |S r_  re   )ri   r¤   s     rj   Ú_unwrap_setitem_indexerzBlock._unwrap_setitem_indexerð  s	   € ð ˆrl   c                ó.   — | j                   j                  S rn   )r`   r¢   rh   s    rj   r¢   zBlock.shapeø  s   € à�{‰{× Ñ Ð rl   c                ó    — | j                   |   S rn   ©r`   )ri   rÑ   s     rj   Úigetz
Block.igetü  s   € ð �{‰{˜1‰~Ðrl   c                ó    — | j                   |   S )zreturn a slice of my valuesrg  )ri   r¶   s     rj   r¬   zBlock._slice  s   € ð
 �{‰{˜6Ñ"Ð"rl   c                ód   — |r| j                   j                  «       | _         || j                   |<   y)a¨  
        Modify block values in-place with new item value.

        If copy=True, first copy the underlying values in place before modifying
        (for Copy-on-Write).

        Notes
        -----
        `set_inplace` never creates a new array or new Block, whereas `setitem`
        _may_ create a new array and always creates a new Block.

        Caller is responsible for checking values.dtype == self.dtype.
        N©r`   rû   ©ri   Úlocsr`   rû   s       rj   Úset_inplacezBlock.set_inplace  s)   € ñ ØŸ+™+×*Ñ*Ó,ˆDŒKØ"ˆ�‰�DÒrl   c                ó‚  — | j                   }|t        j                  u r| j                  }d}nd}t	        j
                  |||||¬«      }t        | t        «      r| j                  dk(  r|€J ‚|dk(  r|€J ‚|€| j                  }|j                  | j                  k7  r| j                  ||«      S | j                  ||«      S )zN
        Take values according to indexer and return them as a block.
        FT)ÚaxisÚ
allow_fillr‡   rž   r   )r`   r   Ú
no_defaultr‡   r   Útake_ndr{   ÚExtensionBlockrb   rŽ   rg   r™   rœ   )ri   r¤   rp  r‘   r‡   r`   rq  r®   s           rj   rs  zBlock.take_nd  sÂ   € ð —‘ˆàœŸ™Ñ'ØŸ™ˆJØ‰JàˆJô —]‘]Ø�G $°:È*ô
ˆ
ô �dœNÔ+ð Ÿ	™	 Qš¨<Ð+?Ð@Ð@Ø˜A’I ,Ð"6Ð7Ð7àÐØŸ>™>ˆLà×Ñ˜tŸz™zÒ)Ø—?‘? :¨|Ó<Ð<à×-Ñ-¨j¸,ÓGÐGrl   c                óÄ  — |j                  | j                  j                  |¬«      }|j                  }t        | j                  t        j
                  «      r| j                  |}}n.t        d| j                  «      }|j                  |j                  }}|j                  r#t	        j                  ||«      r| j                  }	nd}	t        |«      }
t        ||
|	¬«      g}|S )aÅ  
        Return a list of unstacked blocks of self

        Parameters
        ----------
        unstacker : reshape._Unstacker
        fill_value : int
            Only used in ExtensionBlock._unstack
        new_placement : np.ndarray[np.intp]
        needs_masking : np.ndarray[bool]
            Only used in ExtensionBlock._unstack

        Returns
        -------
        blocks : list of Block
            New blocks of unstacked values.
        ©r‡   r\   N)r•   rc   )Úget_new_valuesr`   ÚTr{   r|   rè   r   rÿ   Ú_indexer_is_identityÚmay_share_memoryrc   r   Únew_block_2d)ri   Ú	unstackerr‡   Únew_placementÚneeds_maskingr®   ÚsourceÚ	unstackedr`   rc   rÔ   r   s               rj   Ú_unstackzBlock._unstackF  sµ   € ð0 ×-Ñ-¨d¯k©k¯m©mÈ
Ð-ÓSˆ
Ø—\‘\ˆ
ô �d—k‘k¤2§:¡:Ô.Ø $§¡¨Z�I‰FäÐ7¸¿¹ÓEˆFØ &§¡°×1DÑ1D�IˆFà×)Ò)¬b×.AÑ.AÀ)ÈVÔ.TØ—9‘9‰DàˆDä˜MÓ*ˆÜ˜z°R¸dÔCÐDˆØˆrl   c           	     óŠ  — | j                  |«      }t        d| j                  «      }| j                  dk(  r|j                  }t        |||«       | j                  t        k7  rt        |d¬«      }	 t        |j                  |«      }| j                  t        k(  rÒt        ||j                  «      s¼t        |t        t        t        j                  t         t"        t$        f«      rt'        ||«      }nt)        ||   «      }t+        |||«      }| j                  dk(  rQt        |t         «      rAt)        |«      dkD  r3t        |d   t,        t         t        j                  f«      rt/        |«      }| j1                  d¬«      } t        d| j                  j                  «      }t        |t        j                  «      r"|j                  dk(  rt)        |«      dk(  r|d   }	 |||<   | S # t2        t4        f$ r}t7        |«      rt5        d	«      |‚‚ d
}~ww xY w# t8        $ r( | j;                  |d¬«      }|j=                  ||«      cY S w xY w)aÌ  
        Attempt self.values[indexer] = value, possibly creating a new array.

        Parameters
        ----------
        indexer : tuple, list-like, array-like, slice, int
            The subset of self.values to set
        value : object
            The value being set

        Returns
        -------
        Block

        Notes
        -----
        `indexer` is a direct slice/positional indexer. `value` must
        be a compatible shape.
        ú
np.ndarrayrÈ   Trº   rž   r   r1  )r   .z)setting an array element with a sequence.Nr*  )r‹   r   r`   rb   rx  rI   rg   ro   rH   r   rJ   r{   r.   r,   r|   rè   r  ÚrangerØ   rK   r    r7   Útupler   r%  rê   r  r"   r   rð   Úsetitem)ri   r¤   rŠ   r`   ÚcastedÚnum_setrï   rÖ   s           rj   r†  zBlock.setitemy  s÷  € ð* ×,Ñ,¨UÓ3ˆä�l D§K¡KÓ0ˆØ�9‰9˜Š>Ø—X‘XˆFô 	˜g u¨fÔ5à�:‰:œÒ#ä! %°tÔ<ˆEð(	Ü(¨¯©°uÓ=ˆFð �z‰zœZÒ'Ô0AÀ'È6Ï;É;Ô0WÜØœi¬´2·:±:¼tÄUÌEÐRôô 0°¸Ó@‘Gä! &¨¡/Ó2�GÜ4°V¸WÀfÓM�ð —I‘I ’NÜ" 6¬4Ô0Ü˜F› ašÜ" 6¨!¡9¬u´d¼B¿J¹JÐ.GÔHô EÀVÓL�Fà×#Ñ#¨DÐ#Ó1ˆDÜ˜,¨¯©¯©Ó6ˆFÜ˜&¤"§*¡*Ô-°&·+±+ÀÒ2BÄsÈ6Ã{ÐVWÒGWà ™�ðØ"(��w‘ð ˆøô œzÐ*ò Ü Ô'Ü$ØCóàðð ûðûôC !ò 	.à×,Ñ,¨UÀDÐ,ÓIˆBØ—:‘:˜g uÓ-Ò-ð	.ús*   Á1H ÇG" Ç"HÇ1H	È	HÈ.IÉIc                ó  — |}t        d| j                  «      }t        |j                  |«      \  }}t	        |t
        t        t        f«      rJ ‚|t        j                  u r| j                  }| j                  |«      }t        |d¬«      }|r| j                  d¬«      gS 	 t        |j                  |«      }| j!                  d¬«      } t        d| j                  «      }t#        |j                  ||«       | gS # t$        $ �r | j&                  dk(  s| j(                  d   dk(  r]t+        |«      s%| j-                  |d¬	«      j/                  ||«      cY S |j1                  «       d   }| j3                  |||   «      }|gcY S t	        |t4        j6                  «      }	g }
t9        | j;                  «       «      D ]H  \  }}|}|	r|d
d
…||dz   …f   }|d
d
…||dz   …f   }|j/                  ||«      }|
j=                  |«       ŒJ |
cY S w xY w)aW  
        putmask the data to the block; it is possible that we may create a
        new dtype of block

        Return the resulting block(s).

        Parameters
        ----------
        mask : np.ndarray[bool], SparseArray[bool], or BooleanArray
        new : an ndarray/object

        Returns
        -------
        List[Block]
        rƒ  Trº   Frò   r1  rž   r   r*  N)r   r`   r8   rx  r{   r,   r.   r+   r   rr  r‡   r‹   rH   rû   r   rg   r%  r6   r   rb   r¢   r"   rð   ÚputmaskÚnonzeror†  r|   rè   rÎ   rÚ   rÜ   )ri   r-  ÚnewÚ	orig_maskr`   Únoopr‡  r¤   rÖ   Úis_arrayrÞ   rÑ   ÚnÚsubmaskrß   s                  rj   rŠ  zBlock.putmaskÅ  só  € ð  ˆ	Ü�l D§K¡KÓ0ˆÜ% f§h¡h°Ó5‰
ˆˆdÜ˜c¤H¬i¼Ð#FÔGÐGÐGà”#—.‘.Ñ Ø—/‘/ˆCà×*Ñ*¨3Ó/ˆÜ˜C¨tÔ4ˆáØ—I‘I 5�IÓ)Ð*Ð*ð#	"Ü(¨¯©°sÓ;ˆFà×#Ñ#¨DÐ#Ó1ˆDÜ˜,¨¯©Ó4ˆFä" 6§8¡8¨T°6Ô:Ø�6ˆMøÜ ó 	"Ø�y‰y˜AŠ~ §¡¨A¡°!Ò!3ô $ CÔ(à×6Ñ6Ø¨Tð 7ó ç‘g˜d CÓ(ò)ð #Ÿl™l›n¨QÑ/�GØŸ™ g¨s°7©|Ó<�BØ˜4’Kô & c¬2¯:©:Ó6�à�
Ü& t§{¡{£}Ó5ò +‘E�A�rØ�AÙà¢ 1 q¨1¡u 9 Ñ-˜à'ª¨1¨q°1©u¨9¨Ñ5�GØŸ*™* W¨aÓ0�CØ×%Ñ% cÕ*ð+ð "Ò!ð7	"ús!   Â!AC9 Ã9AHÅ+HÆBHÈHc                óÜ  — |j                   | j                   k(  sJ ‚t        |t        t        t        f«      rJ ‚| j                   dk(  }t        |«      }t        d| j                  «      }|}|r|j                  }t        || «      \  }}|r| j                  d¬«      gS |t        j                  u r| j                  }| j                  |«      }	 t        |j                   |«      }|}t#        ||j%                  «       |«      }	t        |t&        «      r[|j                   t(        k(  rHt+        j,                  dt.        ¬«      }
||
d<   |j                  «       }t+        j0                  |||
«       nø|	|urmt3        |«      r:t5        |«      t5        |«      k  r#t+        j6                  | ||«       t9        d«      ‚|j                  «       }t+        j0                  |||	«       n‡t3        |«      rct        |t*        j:                  «      sIt5        |«      | j<                  d	   k(  r.t+        j>                  |«      jA                  |j<                  «      }tC        j6                  | ||«      }	 |r|j                  }| jU                  |«      gS # tD        tF        tH        f$ rÓ | j                   dk(  s| j<                  d   dk(  r'| jK                  |d¬
«      }|j7                  ||«      cY S t        |t*        j:                  tL        f«      }g }tO        | jQ                  «       «      D ]H  \  }}|}|r|dd…||dz   …f   }|dd…||dz   …f   }|j7                  ||«      }|jS                  |«       ŒJ |cY S w xY w)a  
        evaluate the block; return result block(s) from the result

        Parameters
        ----------
        other : an ndarray/object
        cond : np.ndarray[bool], SparseArray[bool], or BooleanArray

        Returns
        -------
        List[Block]
        rÈ   rƒ  Frò   rž   r¿   r   z‡This should not be reached; call to np.where above is expected to raise ValueError. Please report a bug at github.com/pandas-dev/pandasrÉ   r*  N)+rb   r{   r,   r.   r+   r4   r   r`   rx  r8   rû   r   rr  r‡   r‹   r   rg   r7   Úsumr…  ro   r|   Úemptyr]   rŠ  r"   r    ÚwhereÚNotImplementedErrorrè   r¢   ÚarrayrÊ   rF   r  rê   r   rð   r?   rÎ   rÚ   rÜ   r™   )ri   rì   ÚcondÚ	transposer`   Ú
orig_otherÚicondrŽ  r‡  ÚaltÚfill_arrr¥   rÕ   r�  rÞ   rÑ   rÖ   Úothr‘  rß   s                       rj   r•  zBlock.where  s  € ð �y‰y˜DŸI™IÒ%Ð%Ð%Ü˜e¤h´	¼<Ð%HÔIÐIÐIà—I‘I ‘Nˆ	ä! $Ó'ˆô �l D§K¡KÓ0ˆØˆ
ÙØ—X‘XˆFä& v°¨uÓ5‰ˆˆtÙØ—I‘I 5�IÓ)Ð*Ð*à”C—N‘NÑ"Ø—O‘OˆEà×,Ñ,¨UÓ3ˆðB	Bô )¨¯©°uÓ=ˆFð4 ˆEÜ-¨f°e·i±i³kÀ5ÓIˆCÜ˜%¤Ô'¨F¯L©L¼JÒ,Fô Ÿ8™8 A¬VÔ4�Ø#�˜‘ØŸ™›�Ü—
‘
˜6 5¨(Õ3Ø˜EÑ!Ü Ô&¬3¨u«:¼¸F»Ò+Cä—H‘H˜e˜V V¨UÔ3Ü-ð7óð ð
  Ÿ™›�Ü—
‘
˜6 5¨#Õ.ô
 ! Ô'Ü& u¬b¯j©jÔ9Ü˜E›
 d§j¡j°¡nÒ4ô
 ŸH™H U›O×3Ñ3°F·L±LÓA�Eô
 %×*Ñ*¨E¨6°6¸5ÓA‘ñ Ø—X‘XˆFà—‘ Ó'Ð(Ð(øôI œIÔ'8Ð9ò 	"ð �y‰y˜AŠ~ §¡¨A¡°!Ò!3ð ×3Ñ3°EÈ5Ð3ÓQ�Ø—{‘{ :¨tÓ4Ò4ô & e¬b¯j©j¼.Ð-IÓJ�à�
Ü& t§{¡{£}Ó5ò +‘E�A�rØ�CÙà#¢A q¨1¨q©5 y LÑ1˜à"¢1 a¨!¨a©% i <Ñ0�GØŸ(™( 3¨Ó0�CØ×%Ñ% cÕ*ð+ð "Ò!ð-	"ús   ÃJ ÊAM+Ë BM+Í*M+c                ó   — t        |d«      }| j                  s| j                  d¬«      gS t        |«      �r| j                  t        j                  d«      t        j                  d«      t        j                  d«      fv rÅ|€|rÁt        d| j                  «      }	 t        |j                  |«      }| j                  |«      \  }}|r|j                  «       n|}|j                  dk(  rt        j                  |||¬	«      }	nt        j                  |||¬	«      }	|	d
k(  r| j                  d¬«      gS | j                  ||¬«      gS t#        | j                  «      }
t%        | j                  |
«      \  }
}|r| j                  d¬«      gS | j'                  |«      s^t)        || j                  «      sHt+        j,                  dt/        |«      j0                  › d| j                  › d�t2        t5        «       ¬«       |�.d|
|
j7                  | j                  j                  dz
  «      |kD  <   |r'| j9                  |
j:                  |«      }t?        |«      S | j=                  ||
j:                   «      }t?        |«      S # t        t         f$ r Y �ŒEw xY w)z…
        fillna on the block with the value. If we fail, then convert to
        block to hold objects instead and try again
        r$  Frò   Úfloat64Úfloat32r]   rƒ  rž   )Úlimitr   r«   rã   z'' is not supported as a fill value for z„ dtype. In a future version, calling fillna with an incompatible value will raise. Explicitly cast to a common dtype before filling.©Ú
stacklevel) r   r~   rû   r#   rg   r|   r   r`   r   r'  rb   ÚlibalgosÚscalar_fillna_inplaceÚscalar_fillna_2d_inplacerœ   r   r–  r1   r8   r½   r0   ÚwarningsÚwarnr›   rŸ   r   r   ÚcumsumrŠ  rx  r•  Úextend_blocks)ri   rŠ   r¢  r$  r`   r‡  rû   rc   r®   Úfilledr-  rŽ  rÐ   s                rj   ÚfillnazBlock.fillnav  s\  € ô & g¨yÓ9ˆà× Ò à—I‘I 5�IÓ)Ð*Ð*ô �eÕØ—
‘
Ü—‘˜Ó#¤R§X¡X¨iÓ%8¼"¿(¹(À8Ó:LÐMñNàÐ"¡gä˜,¨¯©Ó4ˆFðKÜ,¨V¯\©\¸5ÓA�ð "×4Ñ4°WÓ=‘
��dÙ.2˜VŸ[™[œ]¸�
à—?‘? aÒ'Ü%×;Ñ;Ø" F°%ô‘Fô &×>Ñ>Ø" F°%ô�Fð ˜Q’;Ø ŸI™I¨5˜IÓ1Ð2Ð2à×2Ñ2°:ÀDÐ2ÓIÐJÐJô �D—K‘KÓ ˆÜ% d§k¡k°4Ó8‰
ˆˆdÙØ—I‘I 5�IÓ)Ð*Ð*à×%Ñ% eÔ,Ô5JØ�4—:‘:ô6
ô
 �M‰MØ”D˜“K×(Ñ(Ð)ð *"Ø"&§*¡* ð .(ð)ô
 Ü+Ó-õð ÐØ>CˆD�—‘˜TŸ[™[×-Ñ-°Ñ1Ó2°UÑ:Ñ;áØ—,‘,˜tŸv™v uÓ-ˆCô ˜SÓ!Ð!ð —*‘*˜U T§V¡V GÓ,ˆCÜ˜SÓ!Ð!øôa &Ô':Ð;ò Úðús   ÂI: É:JÊJ©r$  r¢  Ú
limit_areac               ó(  — | j                   s| j                  d¬«      gS | j                  |«      \  }}t        d| j                  «      }|j
                  j                  ||||¬«      j
                  }t        |d¬«      }	| j                  |	|¬«      gS )NFrò   rA   )Úmethodr¢  r¯  rû   Trº   r«   )	r~   rû   r'  r   Úarray_valuesrx  Ú_pad_or_backfillrH   rœ   )
ri   r±  r$  r¢  r¯  rû   rc   rÓ   r®   Údatas
             rj   Úpad_or_backfillzBlock.pad_or_backfillÆ  s    € ð × Ò à—I‘I 5�IÓ)Ð*Ð*à×,Ñ,¨WÓ5‰
ˆˆdô Ð)¨4×+<Ñ+<Ó=ˆØ—V‘V×,Ñ,ØØØ!Øð	 -ó 
÷
 ‰!ð 	ô ˜Z°tÔ<ˆØ×*Ñ*¨4°dÐ*Ó;Ð<Ð<rl   Úforward)r$  r¢  Úlimit_directionr¯  c               óŠ  — t        |d«      }| j                  s| j                  d¬«      gS | j                  t        k(  r dddœ| j
                     }t        |› d�«      ‚| j                  |«      \  }	}
 | j                  j                  d|| j
                  dz
  |||||	d	œ|¤Ž}t        |d
¬«      }| j                  ||
¬«      gS )Nr$  Frò   ÚSeriesÚ	DataFrame)rž   rÈ   z& cannot interpolate with object dtype.rž   )r±  rp  Úindexr¢  r·  r¯  rû   Trº   r«   re   )r   r~   rû   rg   ro   rb   rê   r'  r²  ÚinterpolaterH   rœ   )ri   r±  r»  r$  r¢  r·  r¯  rÅ   rw   rû   rc   r®   r´  s                rj   r¼  zBlock.interpolateá  sà   € ô & g¨yÓ9ˆà× Ò à—I‘I 5�IÓ)Ð*Ð*à�:‰:œÒ#à KÑ0°·±Ñ;ˆDÜ˜t˜fÐ$JÐKÓLÐLà×,Ñ,¨WÓ5‰
ˆˆdð 3�T×&Ñ&×2Ñ2ð 	
ØØ—‘˜Q‘ØØØ+Ø!Øñ	
ð ñ	
ˆ
ô ˜Z°tÔ<ˆØ×*Ñ*¨4°dÐ*Ó;Ð<Ð<rl   c                óš   — t        j                  | j                  || j                  j                  dz
  ¬«      }| j	                  |¬«      gS )z'return block for the diff of the valuesrž   ©rp  rg  )r   Údiffr`   rb   r™   )ri   r�  r®   s      rj   r¿  z
Block.diff  s=   € ô —Z‘Z §¡¨Q°T·[±[×5EÑ5EÈÑ5IÔJˆ
Ø—‘ z�Ó2Ð3Ð3rl   c                ó0  — t        j                  |«      s| j                  t        k7  rt	        d«      ‚| j                  |«      }	 t        | j                  |«      }t        d| j                  «      }t        |||«      }| j                  |«      gS # t        $ r{ | j                  j                  dvst        || j                  «      s$t        j                  dt         t#        «       ¬«       | j%                  |d¬«      }|j                  ||¬«      cY S w xY w)	z+shift the block by periods, possibly upcastzfill_value must be a scalarrƒ  ÚiubSUVz°shifting with a fill value that cannot be held by original dtype is deprecated and will raise in a future version. Explicitly cast to the desired dtype before shifting instead.r£  Fr*  rv  )r   r#   rg   ro   r  r‹   r   r   r`   r=   rœ   r   r}   r0   r¨  r©  r   r   rð   )ri   Úperiodsr‡   r‡  r`   r®   rÖ   s          rj   r=   zBlock.shift  s  € ô �}‰}˜ZÔ(¨T¯Z©Z¼:Ò-Eô Ð:Ó;Ð;à×1Ñ1°*Ó=ˆ
ð	<ô )Ø—
‘
ØóˆFô* ˜,¨¯©Ó4ˆFÜ˜v w°Ó7ˆJØ×.Ñ.¨zÓ:Ð;Ð;øô' !ò 	<Ø�z‰z�‰ hÑ.Ô6KØ˜DŸJ™Jô7ô —‘ð(ô #Ü/Ó1õð ×,Ñ,¨ZÈÐ,ÓOˆBØ—8‘8˜G°
�8Ó;Ò;ð	<ús   ÁB ÂBDÄDc                óî   — | j                   dk(  sJ ‚t        |«      sJ ‚t        | j                  t	        j
                  |j                  «      |«      }t        |d¬«      }t        || j                  ¬«      S )a  
        compute the quantiles of the

        Parameters
        ----------
        qs : Index
            The quantiles to be computed in float64.
        interpolation : str, default 'linear'
            Type of interpolation.

        Returns
        -------
        Block
        rÈ   r“   )r•   )
rb   r"   r9   r`   r|   ÚasarrayÚ_valuesr–   r{  rŽ   )ri   ÚqsÚinterpolationr¥   s       rj   ÚquantilezBlock.quantile<  s`   € ð* �y‰y˜AŠ~Ðˆ~Ü˜BÔÐÐä  §¡¬b¯j©j¸¿¹Ó.DÀmÓTˆô $ F°Ô3ˆÜ˜F¨d¯n©nÔ=Ð=rl   c                ó|  — | j                   r| j                  r[t        | j                  t        t
        t        f«      r$t        j                  dt        t        «       ¬«       | j                  d¬«      S | j                  j                  |«      }d}|| j                  u r| j                  }| j                  ||¬«      S )ax  
        Rounds the values.
        If the block is not of an integer or float dtype, nothing happens.
        This is consistent with DataFrame.round behavior.
        (Note: Series.round would raise)

        Parameters
        ----------
        decimals: int,
            Number of decimal places to round to.
            Caller is responsible for validating this
        zbobj.round has no effect with datetime, timedelta, or period dtypes. Use obj.dt.round(...) instead.r£  Frò   Nr«   )Ú
is_numericr‚   r{   r`   r>   rC   rB   r¨  r©  ÚUserWarningr   rû   Úroundrc   rœ   )ri   Údecimalsr`   rc   s       rj   rÌ  zBlock.roundZ  sš   € ð �Š $§,¢,Ü˜$Ÿ+™+¬´~Ä{Ð'SÔTô —‘ðGäÜ/Ó1õ	ð —9‘9 %�9Ó(Ð(Ø—‘×"Ñ" 8Ó,ˆàˆØ�T—[‘[Ñ Ø—9‘9ˆDà×)Ñ)¨&°tÐ)Ó<Ð<rl   c                ó.  — t        |«      s|g}| j                  dk(  rft        d| j                  «      }t	        j
                  ||«      }| j                  j                  |«      } t        | «      ||| j                  ¬«      gS t	        j                  |«      | j                  j                  d   k\  rt        ‚t	        j                  || j                  j                  d   gg«      }| j                  j                  }g }d}| j                  j                  «       r| j                  nd}|D ]f  }||dz   k(  rnY| j                  |dz   |…dd…f   }||dz   | }	 t        | «      |t        |	«      | j                  |¬«      }
|j!                  |
«       |}Œh |S )a?  Deletes the locs from the block.

        We split the block to avoid copying the underlying data. We create new
        blocks for every connected segment of the initial block that is not deleted.
        The new blocks point to the initial array.

        Assumes `loc` is strictly increasing when list-like.
        rž   rƒ  ©r•   rb   r   rÉ   Nr”   )r"   rb   r   r`   r|   ÚdeleterŽ   r›   Úmaxr¢   Ú
IndexErrorÚconcatenateÚas_arrayrc   rµ   r   rÏ   )ri   rÒ   r`   r�   Úmgr_locs_arrÚ
new_blocksÚprevious_locrc   rS  rm  rÖ   s              rj   rÐ  zBlock.delete~  s~  € ô ˜CÔ Ø�%ˆCà�9‰9˜Š>Ü˜,¨¯©Ó4ˆFÜ—Y‘Y˜v sÓ+ˆFØ—~‘~×,Ñ,¨SÓ1ˆHØ”D˜“J˜v°ÀÇ	Á	ÔJÐKÐKä�6‰6�#‹;˜$Ÿ+™+×+Ñ+¨AÑ.Ò.ÜÐô �n‰n˜c D§K¡K×$5Ñ$5°aÑ$8Ð#9Ð:Ó;ˆØ—~‘~×.Ñ.ˆØ"$ˆ
àˆð !ŸI™I×3Ñ3Ô5ˆt�yŠy¸4ˆØò 	ˆCØ�l QÑ&Ò&àð Ÿ™ \°AÑ%5¸Ð%;ºQÐ%>Ñ?�Ø# L°1Ñ$4°sÐ;�Ø”T˜$“ZØ¤n°TÓ&:ÀÇÁÐQUô�ð ×!Ñ! "Ô%à‰Lð	ð  Ðrl   c                ó   — t        | «      ‚)ú(return a boolean if I am possibly a view©r   rh   s    rj   Úis_viewzBlock.is_view°  s   € ô " $Ó'Ð'rl   c                ó   — t        | «      ‚)zP
        The array that Series.array returns. Always an ExtensionArray.
        rÚ  rh   s    rj   r²  zBlock.array_valuesµ  ó   € ô
 " $Ó'Ð'rl   c                ó   — t        | «      ‚)z‹
        return an internal format, currently just the ndarray
        this is often overridden to handle to_dense like operations
        rÚ  r   s     rj   Ú
get_valueszBlock.get_values¼  rÝ  rl   ©Úreturnr�   )rá  r   )r‘   r   rá  ÚNone)NN)r•   úBlockPlacement | Nonerc   úBlockValuesRefs | Nonerá  r_   )r•   rã  rc   rä  rá  r   )rá  r£   )rá  ra   )r­   rØ   rá  r   )r²   únpt.NDArray[np.intp]rá  r   ©F)r¶   rØ   r‘   r   r·   r�   rá  r   )r¼   r   rá  r�   )rŠ   rQ   rá  r�   ©rá  úlist[Block])rá  r_   )r¥   rQ   rá  rè  )rá  zGenerator[Block])rí   r�   rá  r_   )TTTTTÚnumpy_nullable)r	  r�   r
  r�   r  r�   r  r�   r  r�   r  rS   rá  rè  )rá  rT   )ÚraiseF)rg   rT   r  rV   r  r�   rá  r_   )r  r£   rá  r_   )ró   r�   rá  r   )T)r$  r�   ró   r�   rá  r   )r$  r�   )FN)r$  r�   r-  znpt.NDArray[np.bool_] | Nonerá  rè  )r$  r�   rá  rè  )FF)
rE  zIterable[Any]rF  zSequence[Any]r$  r�   r9  r�   rá  rè  )TF)r-  únpt.NDArray[np.bool_]r$  r�   r9  r�   rá  rè  )ra  rƒ  rá  rƒ  ©rá  rY   )rÑ   ú)int | tuple[int, int] | tuple[slice, int]rá  rƒ  )r¶   ú4slice | npt.NDArray[np.bool_] | npt.NDArray[np.intp]rá  rQ   ©r`   rQ   rû   r�   rá  râ  )r¤   rå  rp  rR   r‘   rã  rá  r_   ©r}  rå  r~  rë  ©NF©r¢  ú
int | Noner$  r�   rá  rè  ©
r±  rU   r$  r�   r¢  ró  r¯  ú#Literal['inside', 'outside'] | Nonerá  rè  )r±  rW   r»  r[   r$  r�   r¢  ró  r·  z&Literal['forward', 'backward', 'both']r¯  rõ  rá  rè  )r�  ra   rá  rè  rn   ©rÂ  ra   r‡   r   rá  rè  )Úlinear)rÆ  r[   rÇ  rX   rá  r_   )rÍ  ra   rá  r   ©rá  r?   ©rg   úDtypeObj | Nonerá  rƒ  )IrŸ   Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__Ú	__slots__rÊ  r	   r   rk   rp   rs   ru   rx   r~   Úpropertyr‚   r„   r‡   r‹   r�   Úsetterr™   rœ   r§   r©   r¯   r³   r¸   r½   rÀ   rÆ   rÌ   rÃ   rÚ   rà   rð   rü   r   rg   rë   rL   rû   r%  r'  r/  r6  r[  r=  rb  rd  r¢   rh  r¬   rn  r   rr  rs  r�  r†  rŠ  r•  r­  rµ  r¼  r¿  r=   rÈ  rÌ  rÐ  rÛ  r²  rß  re   rl   rj   r_   r_   ‘   so  … ñð (Ó'Ø
ƒIØ
ÓØ!Ó!à€IØ€Jà
Øò3ó ó ð3ð Øò/ó ó ð/ð Øò6ó ó ð6ð Øò%ó ó ð%ð Øñ6ó ó ð6ð Øò"ó ó ð"ð Øò3ó ó ð3ð ñ,ó ð,ð Øñ<ó ó ð<ð ñó ðð òó ðð ‡_�_ò&ó ð&ð ð ,0Ø'+ð	Qð )ðQð %ð	Qð
 
òQó ðQð" ð ,0Ø'+ð	Rð )ðRð %ð	Rð
 
òRó ðRð ò	ó ð	ð ò ó ð ð òJó ðJð òJó ðJð àRWð
JØð
JØ+9ð
JØKOð
Jà	ò
Jó ð
Jð ò6ó ð6ð
 ò)ó ð)ð" ò-ó ð-ð ò+ó ð+ð òó ðð* òó ðð òó ðð2 ò@ó ð@ðD ò"8ó ð"8ðL #Ø#Ø $Ø $Ø!%Ø&6ð,àð,ð ð,ð ð	,ð
 ð,ð ð,ð $ð,ð 
ó,ðb Øò!ó ó ð!ð ð &Øð	+àð+ð ð+ð ð	+ð
 
ò+ó ð+ðZ àCHÐRVñ'Ø=@ð'à	ò'ó ð'ð òWó ðWô($ð
 òó ðð ð
 à-1ð@ð ð	@ð +ð@ð 
ò@ó ð@ðD ð
 Øð6ð ð	6ð 
ò6ó ð6ðp ð
 Øðvàðvð !ðvð ð	vð
 ðvð 
òvó ðvðp ð Øð7ð $ð	7ð
 ð7ð ð7ð 
ò7ó ð7ózòð ò!ó ð!óð#ØJð#à	ó#ô#ð$ ð
 /3Ø—>‘>ð%Hà%ð%Hð ð%Hð ,ð	%Hð 
ò%Hó ð%HðN/ð ,ð	/ð
 -ó/ófJóXA"óFl)ðb !Øð	N"ð ðN"ð ð	N"ð
 
óN"ðh Ø Ø:>ñ=ð ð=ð ð	=ð
 ð=ð 8ð=ð 
ó=ð6 ð Ø ØBKØ:>ñ$=ð #ð$=ð ð	$=ð
 ð$=ð ð$=ð @ð$=ð 8ð$=ð 
ò$=ó ð$=ðL ò4ó ð4ô+<ðZ ð 08ð>àð>ð -ð>ð 
ò	>ó ð>ð: ò=ó ð=óF0ðd ò(ó ð(ð ò(ó ð(õ(rl   r_   c                  óæ   ‡ — e Zd ZU dZded<   eddd„«       Zed„ «       Zd„ Zedd„«       Z	edd	„«       Z
edˆ fd
„«       Zeedd„«       «       Zeddd„«       Zeddddœ	 	 	 	 	 	 	 	 	 dd„«       Zˆ xZS )ÚEABackedBlockz>
    Mixin for Block subclasses backed by ExtensionArray.
    r?   r`   Nc                ó`   — | j                   j                  ||¬«      }| j                  |«      gS )z‹
        Shift the block by `periods`.

        Dispatches to underlying ExtensionArray and re-boxes in an
        ExtensionBlock.
        )rÂ  r‡   )r`   r=   rœ   )ri   rÂ  r‡   r®   s       rj   r=   zEABackedBlock.shiftË  s1   € ð —[‘[×&Ñ&¨wÀ:Ð&ÓNˆ
Ø×*Ñ*¨:Ó6Ð7Ð7rl   c                ó^  — |}|}| j                  |«      }| j                  |«      }| j                  }|j                  rt	        d«      ‚|}|j
                  dk(  r| j                  ||«      \  }}}t        |||«       	 |||<   | S # t        t        f$ r— t        | j                  t        «      r'| j                  |d¬«      }|j                  ||«      cY S t        | t        «      rD|j
                  dk(  rt        |||«      r‚ | j                  |d¬«      }|j                  ||«      cY S ‚ w xY w)a7  
        Attempt self.values[indexer] = value, possibly creating a new array.

        This differs from Block.setitem by not allowing setitem to change
        the dtype of the Block.

        Parameters
        ----------
        indexer : tuple, list-like, array-like, slice, int
            The subset of self.values to set
        value : object
            The value being set

        Returns
        -------
        Block

        Notes
        -----
        `indexer` is a direct slice/positional indexer. `value` must
        be a compatible shape.
        úCannot modify read-only arrayrÈ   Tr*  )rd  rb  r`   Ú	_readonlyr  rb   Ú_setitem_targetrI   rê   r{   rg   r(   rð   r†  ÚNDArrayBackedExtensionBlockÚ_unbroadcastable_shape)ri   r¤   rŠ   Úorig_indexerÚ
orig_valuer`   ÚtargetrÖ   s           rj   r†  zEABackedBlock.setitemÖ  s7  € ð0 ˆØˆ
à×.Ñ.¨wÓ7ˆØ×'Ñ'¨Ó.ˆà—‘ˆØ×Òô
 Ð<Ó=Ð=ØˆØ�;‰;˜!ÒØ%)×%9Ñ%9¸'À5Ó%IÑ"ˆF�G˜UÜ˜g u¨fÔ5ð	Ø#ˆF�7‰Oð, ˆKøô+ œIÐ&ò 	Ü˜$Ÿ*™*¤mÔ4à×0Ñ0°ÈTÐ0ÓR�Ø—z‘z ,°
Ó;Ò;ä˜DÔ"=Ô>Ø—;‘; !Ò#Ô(>¸vÀwÐPUÔ(Vð Ø×0Ñ0°ÈTÐ0ÓR�Ø—z‘z ,°
Ó;Ò;ð ð%	ús   Á?B ÂAD,ÃAD,Ä*D,c                óð   — t        |t        «      s|t        d«      f}t        |«      dk(  r|ddd…   }t        |t        j
                  «      r|j                  dk(  r|j                  }| j                  ||fS )zN
        Get the array, indexer and value for setitem on a 2-D block.
        NrÈ   rÉ   )	r{   r…  rØ   r    r|   rè   rb   rx  r`   ©ri   r¤   rŠ   s      rj   r  zEABackedBlock._setitem_target  sg   € ô ˜'¤5Ô)Ø¤ d£Ð,ˆGÜˆw‹<˜1ÒØ™d ˜d‘mˆGÜ�eœRŸZ™ZÔ(¨U¯Z©Z¸1ª_Ø—G‘GˆEØ�{‰{˜G UÐ*Ð*rl   c                ó²  — | j                   j                  }t        |«      }|}|}| j                  |«      }| j                  |«      }|t        j
                  u r| j                  }t        || «      \  }}|r| j                  d¬«      gS 	 |j                  ||«      j                  }| j;                  |«      }|gS # t        $ r ‚ t        t        f$ �r� | j                  dk(  s| j                  d   dk(  rÕt        | j                   t"        t$        f«      r}| j'                  |d¬«      }	| j                  dk(  rGt        |t(        j*                  «      r-|j                  dk(  rt-        |	j                   «      s	|d d …d f   }|	j/                  ||«      cY S t        | t0        «      r'| j'                  |d¬«      }	|	j/                  ||«      cY S ‚ t        |t(        j*                  t2        f«      }
g }t5        | j7                  «       «      D ]H  \  }}|}|
r|d d …||dz   …f   }|d d …||dz   …f   }|j/                  ||«      }|j9                  |«       ŒJ |cY S w xY w)NFrò   rž   r   r*  rÈ   )r`   rx  r4   rb  r   rr  r‡   r8   rû   Ú_wherer   r  rê   rb   r¢   r{   rg   r(   rD   rð   r|   rè   r   r•  r	  r?   rÎ   rÚ   rÜ   rœ   )ri   rì   r˜  Úarrrš  Ú	orig_condr›  rŽ  rË   rø   r�  rÞ   rÑ   rÖ   r�  r‘  rß   s                    rj   r•  zEABackedBlock.where'  s;  € à�k‰k�m‰mˆä! $Ó'ˆàˆ
Øˆ	Ø×'Ñ'¨Ó.ˆØ×&Ñ& tÓ,ˆà”C—N‘NÑ"Ø—O‘OˆEä& s¨T¨EÓ2‰ˆˆtÙð —I‘I 5�IÓ)Ð*Ð*ð)	"ØŸ™ D¨%Ó0×2Ñ2ˆJðT ×'Ñ'¨
Ó3ˆØˆtˆøôU #ò 	ØÜœIÐ&ó %	"Ø�y‰y˜AŠ~ §¡¨A¡°!Ò!3Ü˜dŸj™j¬=¼+Ð*FÔGà×5Ñ5°jÐRWÐ5ÓX�CàŸ	™	 QšÜ& y´"·*±*Ô=Ø%ŸN™N¨aÒ/Ü 3°C·I±IÔ >à$-ªa°¨gÑ$6˜	ØŸ9™9 Z°Ó;Ò;ä Ô&AÔBð ×5Ñ5°jÐRWÐ5ÓX�CØŸ9™9 Z°Ó;Ò;ð ô & j´2·:±:¼~Ð2NÓO�à�
Ü& t§{¡{£}Ó5ò +‘E�A�rØ"�AÙà&¢q¨!¨a°!©e¨) |Ñ4˜à'ª¨1¨q°1©u¨9¨Ñ5�GØŸ(™( 1 gÓ.�CØ×%Ñ% cÕ*ð+ð "Ò!ðK%	"ús    ÂB< Â<CIÆ5IÇ
B	IÉIc                óª  — t        |«      }|t        j                  u r| j                  }|}|}| j	                  |«      }| j	                  |«      }|j                  «       s| j                  d¬«      gS | j                  d¬«      } | j                  }|j                  rt        d«      ‚|j                  dk(  rG|j                  }t        |t        j                  t         f«      r|j                  dk(  r|j                  }	 |j#                  ||«       | gS # t$        $ r ‚ t&        t        f$ �r% | j                  dk(  s| j(                  d   dk(  ryt        | j*                  t,        «      r'| j/                  |d¬	«      }|j1                  ||«      cY S t        | t2        «      r'| j/                  |d¬	«      }|j1                  ||«      cY S ‚ t        |t        j                  t         f«      }g }t5        | j7                  «       «      D ]H  \  }	}
|}|r|d
d
…|	|	dz   …f   }|d
d
…|	|	dz   …f   }|
j1                  ||«      }|j9                  |«       ŒJ |cY S w xY w)z+
        See Block.putmask.__doc__
        Frò   Tr1  r  rÈ   rž   r   r*  N)r4   r   rr  r‡   rb  r  rû   r%  r`   r  r  rb   rx  r{   r|   rè   r?   Ú_putmaskr   rê   r¢   rg   r(   rð   rŠ  r	  rÎ   rÚ   rÜ   )ri   r-  rŒ  Úorig_newr�  r`   rø   r�  rÞ   rÑ   rÖ   r�  r‘  rß   s                 rj   rŠ  zEABackedBlock.putmaski  s7  € ô
 " $Ó'ˆØ”#—.‘.Ñ Ø—/‘/ˆCàˆØˆ	Ø×%Ñ% cÓ*ˆØ×&Ñ& tÓ,ˆà�x‰xŒzØ—I‘I 5�IÓ)Ð*Ð*à×Ñ¨ÐÓ-ˆØ—‘ˆØ×Òô Ð<Ó=Ð=Ø�;‰;˜!Òð —6‘6ˆDÜ˜#¤§
¡
¬NÐ;Ô<ÀÇÁÈQÂØ—e‘e�ð$	"à�O‰O˜D #Ô&ðH ˆvˆøôG #ò 	ØÜœ:Ð&ó 	"Ø�y‰y˜AŠ~ §¡¨A¡°!Ò!3Ü˜dŸj™j¬-Ô8ð ×5Ñ5°hÐPTÐ5ÓU�CØŸ;™; y°(Ó;Ò;ä Ô&AÔBð ×5Ñ5°hÐPTÐ5ÓU�CØŸ;™; y°(Ó;Ò;ð ô & h´·±¼^Ð0LÓM�à�
Ü& t§{¡{£}Ó5ò +‘E�A�rØ �AÙà$¢Q¨¨A°©E¨	 \Ñ2˜à'ª¨1¨q°1©u¨9¨Ñ5�GØŸ*™* W¨aÓ0�CØ×%Ñ% cÕ*ð+ð "Ò!ð?	"ús    Ã?D ÄA9IÆ5IÇB	IÉIc                ó   •— | j                   dk(  rU| j                  j                  |«      }| j                  j                  |«      } t	        | «      ||| j                   ¬«      gS | j                  j                   dk(  rg S t
        ‰| �	  |«      S )Nrž   rÏ  )rb   r`   rÐ  rŽ   r›   Úsuper)ri   rÒ   r`   r�   Ú	__class__s       €rj   rÐ  zEABackedBlock.delete¶  sz   ø€ ð �9‰9˜Š>Ø—[‘[×'Ñ'¨Ó,ˆFØ—~‘~×,Ñ,¨SÓ1ˆHØ”D˜“J˜v°ÀÇ	Á	ÔJÐKÐKØ�[‰[×Ñ Ò"àˆIÜ‰w‰~˜cÓ"Ð"rl   c                ó   — | j                   S rn   rg  rh   s    rj   r²  zEABackedBlock.array_valuesÂ  s   € ð �{‰{Ðrl   c                ó²   — | j                   }|t        k(  r|j                  t        «      }t	        j
                  |«      j                  | j                  «      S )zS
        return object dtype as boxed values, such as Timestamps/Timedelta
        )r`   ro   rë   r]   r|   rÄ  rÊ   r¢   )ri   rg   r`   s      rj   rß  zEABackedBlock.get_valuesÇ  sA   € ð
 !ŸK™KˆØ”JÒØ—]‘]¤6Ó*ˆFä�z‰z˜&Ó!×)Ñ)¨$¯*©*Ó5Ð5rl   Fr®  c               ó€  — | j                   }||dœ}dt        j                  |j                  «      j                  v r||d<   n#|�!t        t        |«      j                  › d�«      ‚|j                  dk(  r' |j                  j                  di |¤Žj                  }n |j                  di |¤Ž}| j                  |«      gS )N)r±  r¢  r¯  z… does not implement limit_area (added in pandas 2.2). 3rd-party ExtensionArray authors need to add this argument to _pad_or_backfill.rÈ   re   )r`   ÚinspectÚ	signaturer³  Ú
parametersr–  r›   rŸ   rb   rx  rœ   )ri   r±  r$  r¢  r¯  r`   rÅ   r®   s           rj   rµ  zEABackedBlock.pad_or_backfillÒ  sÅ   € ð —‘ˆà,2¸UÑ!CˆØœ7×,Ñ,¨V×-DÑ-DÓE×PÑPÑPØ#-ˆF�<Ò ØÐ#Ü%Ü˜“<×(Ñ(Ð)ð *Að Aóð ð �;‰;˜!Òà2˜Ÿ™×2Ñ2Ñ<°VÑ<×>Ñ>‰Jà0˜×0Ñ0Ñ:°6Ñ:ˆJØ×*Ñ*¨:Ó6Ð7Ð7rl   rn   rö  rç  rø  rù  rô  )rŸ   rû  rü  rý  rþ  r	   r=   r†  r  r•  rŠ  rÐ  r   r²  rß  rµ  Ú__classcell__©r  s   @rj   r  r  Ä  sÿ   ø… ñð Óà
ó8ó ð8ð ñ@ó ð@òD+ð ò?ó ð?ðB òJó ðJðX ô	#ó ð	#ð Øòó ó ðð ó6ó ð6ð ð
 Ø Ø:>ñ8ð ð8ð ð	8ð
 ð8ð 8ð8ð 
ò8ó ô8rl   r  c                  óÆ   ‡ — e Zd ZU dZded<   	 	 d	 	 	 	 	 dˆ fd„Zedd„«       Zdd„Zddd„Z	d„ Z
d	„ Zedd
„«       Zedd„«       Z	 	 	 	 dd„Zedd„«       Z	 	 	 	 dd„Zˆ xZS )rt  zñ
    Block for holding extension types.

    Notes
    -----
    This holds all 3rd-party extension array types. It's also the immediate
    parent class for our internal extension types' blocks.

    ExtensionArrays are limited to 1-D.
    r?   r`   c                ó   •— t        | j                  t        t        f«      r9t        | j                  t        «      r|�t	        d«      ‚t
        ‰| �  |||¬«      S | j                  r/| j                  j                  s| j                  }| j                  }n3| j                  |«      \  }}	 | j                  j                  |||¬«      }| j'                  ||¬«      gS # t        $ rg d }| j                  j                  ||¬«      }t        j                  dt        | j                  «      j                   › d�t"        t%        «       ¬«       Y Œƒw xY w)	Nzlimit must be None)rŠ   r¢  r$  )rŠ   r¢  rû   )rŠ   r¢  zÛExtensionArray.fillna added a 'copy' keyword in pandas 2.1.0. In a future version, ExtensionArray subclasses will need to implement this keyword or an exception will be raised. In the interim, the keyword is ignored by ú.r£  r«   )r{   rg   r(   rD   r  r  r­  r~   r`   Ú_hasnarc   r'  rê   r¨  r©  r›   rŸ   r   r   rœ   )ri   rŠ   r¢  r$  rc   r®   rû   r  s          €rj   r­  zExtensionBlock.fillnaý  s:  ø€ ô �d—j‘j¤=´+Ð">Ô?ä˜$Ÿ*™*¤mÔ4¸Ð9JÜ Ð!5Ó6Ð6Ü‘7‘>ØØØð "ó ð ð
 ×Ò T§[¡[×%7Ò%7Ø—9‘9ˆDØŸ™‰Jà×0Ñ0°Ó9‰JˆD�$ðØ!Ÿ[™[×/Ñ/°eÀ5ÈtÐ/ÓT�
ð$ ×*Ñ*¨:¸DÐ*ÓAÐBÐBøô# ò à�Ø!Ÿ[™[×/Ñ/°eÀ5Ð/ÓI�
ô —‘ðIô ˜DŸK™KÓ(×1Ñ1Ð2°!ð	5ô
 #Ü/Ó1÷	ðús   Â+C ÃA-EÅEc                ó    — | j                   dk(  rt        | j                  «      fS t        | j                  «      t        | j                  «      fS )Nrž   )rb   r    r`   rŽ   rh   s    rj   r¢   zExtensionBlock.shape(  s>   € ð �9‰9˜Š>Ü˜Ÿ™Ó$Ð&Ð&Ü�4—>‘>Ó"¤C¨¯©Ó$4Ð4Ð4rl   c                óV  — t        |t        «      r{|\  }}t        j                  |«      s|dk7  rt	        | › d�«      ‚t        |t
        «      r/|dk  r|t        | j                  «      z  }| j                  ||dz    S | j                  |   S |dk7  rt	        | › d�«      ‚| j                  S )Nr   z only contains one itemrž   )r{   r…  ÚcomÚis_null_slicerÒ  rØ   r    r`   )ri   rÑ   ÚcolrÒ   s       rj   rh  zExtensionBlock.iget/  s®   € ô �aœÔà‰HˆC�Ü×$Ñ$ SÔ)¨c°QªhÜ  D 6Ð)@Ð!AÓBÐBÜ˜#œuÔ%ð ˜’7Øœ3˜tŸ{™{Ó+Ñ+�Cð —{‘{ 3¨¨q©Ð1Ð1Ø—;‘;˜sÑ#Ð#à�AŠvÜ  D 6Ð)@Ð!AÓBÐBØ—;‘;Ðrl   c                ód   — |r| j                   j                  «       | _         || j                   d d  y rn   rk  rl  s       rj   rn  zExtensionBlock.set_inplaceK  s(   € ñ ØŸ+™+×*Ñ*Ó,ˆDŒKØˆ�‰‘A‰rl   c                óR  — t        |t        j                  t        f«      rE|j                  | j
                  j                  dz   k(  r|j                  d   dk(  sJ ‚|dd…df   }|S t        |t        «      r1|j                  d   dk(  sJ ‚|j                  dd¬«      j                  }|S )z@
        If necessary, squeeze a (N, 1) ndarray to (N,)
        rž   Nr   r¾  )
r{   r|   rè   r?   rb   r`   r¢   r+   Ú_ixsrÅ  r`  s     rj   rb  z!ExtensionBlock._maybe_squeeze_argR  s¡   € ô �sœRŸZ™Z¬Ð8Ô9Ø—‘˜DŸK™K×,Ñ,¨qÑ0Ò0ð —9‘9˜Q‘< 1Ò$Ð$Ð$ð ’a˜�d‘)ˆCð ˆ
ô ˜œ\Ô*ð —9‘9˜Q‘< 1Ò$Ð$Ð$Ø—(‘(˜1 1�(Ó%×-Ñ-ˆCàˆ
rl   c                ób  — t        |t        «      �rt        |«      dk(  �rt        d„ |D «       «      rO|\  }}|j                  dk(  r%|dk(  j                  «       r|j
                  d   dk(  st        d«      ‚|dd…df   }|S t        j                  |d   «      r|d   dk(  r|d   }|S t        j                  |d   «      r|d   }|S t        j                  |d   «      r$t        |d   «      dk(  r|d   d   r|d   }|S g }|S t        |d   «      r|d   d   dk(  r|d   }|S t        d«      ‚|S )zw
        Adapt a 2D-indexer to our 1D values.

        This is intended for 'setitem', not 'iget' or '_slice'.
        rÈ   c              3  ór   K  — | ]/  }t        |t        j                  «      xr |j                  d k(  –— Œ1 y­w)rÈ   N)r{   r|   rè   rb   )r÷   rG  s     rj   rù   z9ExtensionBlock._unwrap_setitem_indexer.<locals>.<genexpr>u  s+   è ø€ ÒNÀ”:˜a¤§¡Ó,Ò<°·±¸1±Ó<ÑNùs   ‚57rž   r   zPThis should not be reached. Please report a bug at github.com/pandas-dev/pandas/N)r{   r…  r    rý   Úsizer¢   r–  r   Ú
is_integerr(  r)  Úis_bool_indexerr"   )ri   r¤   ÚfirstÚseconds       rj   rd  z&ExtensionBlock._unwrap_setitem_indexerh  si  € ô �gœuÕ%¬#¨g«,¸!Ó*;ô
 ÑNÀgÔNÔNà '‘��và—K‘K 1Ò$¨&°A©+×):Ñ):Ô)<ÀÇÁÈQÁÐSTÒATä-ð8óð ð  ¢ 1 ™+�ð. ˆô+ —‘ ¨¡
Ô+°¸±
¸a²à! !™*�ð& ˆô# ×"Ñ" 7¨1¡:Ô.Ø! !™*�ð  ˆô ×$Ñ$ W¨Q¡ZÔ0´S¸À¹³_ÈÒ5IØ˜1‘:˜a’=Ø% a™j�Gð ˆð !�Gð ˆô ˜g a™jÔ)¨g°a©j¸©m¸qÒ.@Ø! !™*�ð ˆô	 *ð4óð ð ˆrl   c                 ó   — y)z,Extension arrays are never treated as views.Fre   rh   s    rj   rÛ  zExtensionBlock.is_view˜  s   € ð rl   c                óB   — | j                   j                  j                  S rn   )r`   rg   Ú_is_numericrh   s    rj   rÊ  zExtensionBlock.is_numericž  s   € à�{‰{× Ñ ×,Ñ,Ð,rl   c                óÖ   — | j                   dk(  rLt        |t        «      st        d|«      ‚t	        d«      |   }t        |«      st        d|«      ‚t        d«      }| j                  |   S )zþ
        Return a slice of my values.

        Parameters
        ----------
        slicer : slice, ndarray[int], or ndarray[bool]
            Valid (non-reducing) indexer for self.values.

        Returns
        -------
        ExtensionArray
        rÈ   z+invalid slicing for a 1-ndim ExtensionArrayrž   N)rb   r{   rØ   rä   r„  r    r`   )ri   r¶   Únew_locss      rj   r¬   zExtensionBlock._slice¢  sp   € ð& �9‰9˜Š>ô ˜f¤eÔ,Ü$ØAÀ6óð ô ˜Q“x Ñ'ˆHÜ�x”=Ü$ØAÀ6óð ô ˜4“[ˆFà�{‰{˜6Ñ"Ð"rl   c                ó†   — | j                   |   } t        | «      || j                  | j                  | j                  ¬«      S )zN
        Perform __getitem__-like specialized to slicing along index.
        )rb   rc   )r`   r›   rŽ   rb   rc   )ri   r¶   r®   s      rj   Úslice_block_rowszExtensionBlock.slice_block_rowsÊ  s5   € ð —[‘[ Ñ(ˆ
ØŒt�D‹z˜* d§n¡n¸4¿9¹9È4Ï9É9ÔUÐUrl   c                ó  — |j                   }t        t        |j                  |d¬«      «      D ���cg c]D  \  }\  }} t	        | «      | j
                  j                  |||   |¬«      t        |«      d¬«      ‘ŒF }	}}}|	S c c}}}w )NTr  )rq  r‡   rÈ   r“   )Úarange_resultrÎ   r  rx  r›   r`   Útaker   )
ri   r|  r‡   r}  r~  r®   rÑ   r²   Úplacer   s
             rj   r�  zExtensionBlock._unstackÔ  sš   € ð ×,Ñ,ˆ
ô (1Ü�J—L‘L -¸Ô=ó(÷
ð 
ñ $�Ñ#�G˜Uð ŒD�‹JØ—‘× Ñ Ø¨°aÑ(8ÀZð !ó ô ˜uÓ%Øöð
ˆò 
ð ˆùô
s   ²A	B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¢   rh  rn  rb  rd  r   rÛ  rÊ  r¬   r	   r;  r�  r   r!  s   @rj   rt  rt  ï  sÖ   ø… ñ	ð Óð
 !Øð	)Cð ð)Cð ð	)Cð
 
õ)CðV ò5ó ð5óô8 òò,.ð` òó ðð
 ò-ó ð-ð&#ØJð&#à	ó&#ðP òVó ðVð"ð ,ð	"ð
 -÷"rl   rt  c                  ó\   — e Zd ZU ded<   dZed	d„«       Zed
d„«       Zddd„Ze	d	d„«       Z
y)Ú
NumpyBlockrƒ  r`   re   c                ó2   — | j                   j                  duS ©rÙ  N)r`   Úbaserh   s    rj   rÛ  zNumpyBlock.is_viewý  s   € ð �{‰{×Ñ tÐ+Ð+rl   c                ó,   — t        | j                  «      S rn   )rA   r`   rh   s    rj   r²  zNumpyBlock.array_values	  s   € ä" 4§;¡;Ó/Ð/rl   Nc                ój   — |t         k(  r| j                  j                  t         «      S | j                  S rn   )ro   r`   rë   r   s     rj   rß  zNumpyBlock.get_values	  s)   € Ø”JÒØ—;‘;×%Ñ%¤jÓ1Ð1Ø�{‰{Ðrl   c                óN   — | j                   j                  }|j                  }|dv S )NÚfciub)r`   rg   r}   )ri   rg   r}   s      rj   rÊ  zNumpyBlock.is_numeric	  s$   € à—‘×!Ñ!ˆØ�z‰zˆà�wˆÐrl   rà  rø  rn   rù  )rŸ   rû  rü  rþ  rÿ  r   rÛ  r²  rß  r   rÊ  re   rl   rj   rA  rA  ù  sL   … ØÓØ€Iàò,ó ð,ð ò0ó ð0ôð
 òó ñrl   rA  c                  ó4   — e Zd ZU dZded<   edd„«       Zd„ Zy)r	  z8
    Block backed by an NDArrayBackedExtensionArray
    r\   r`   c                óF   — | j                   j                  j                  duS rC  )r`   rÿ   rD  rh   s    rj   rÛ  z#NDArrayBackedExtensionBlock.is_view	  s   € ð �{‰{×#Ñ#×(Ñ(°Ð4Ð4rl   c                óZ   — t        |t        «      s|f}| j                  j                  ||fS rn   )r{   r…  r`   rx  r  s      rj   r  z+NDArrayBackedExtensionBlock._setitem_target 	  s*   € ô ˜'¤5Ô)à�jˆGØ�{‰{�}‰}˜g uÐ,Ð,rl   Nrà  )rŸ   rû  rü  rý  rþ  r   rÛ  r  re   rl   rj   r	  r	  	  s&   … ñð (Ó'àò5ó ð5ó
-rl   r	  c                  ó$   — e Zd ZU dZdZdZded<   y)ÚDatetimeLikeBlockz*Block for datetime64[ns], timedelta64[ns].re   FzDatetimeArray | TimedeltaArrayr`   N)rŸ   rû  rü  rý  rÿ  rÊ  rþ  re   rl   rj   rM  rM  )	  s   … Ù4à€IØ€JØ*Ô*rl   rM  c                ól  — 	 t        j                  | |   «      }t        j                  |«      }t        |«      t        |«      kD  r-|d   dk(  r%|dd }t        |«      t        |«      kD  r	|d   dk(  rŒ%	 t        j                  ||«      |k7  S # t        t        t        f$ r Y yw xY w# t        $ r Y yw xY w)a  
    Whether ``value`` cannot be broadcast into ``values[indexer]``.

    Returns False both when the value does fit and when that cannot be
    determined, so a caller can only use a True result to conclude a failed
    setitem is a shape problem rather than a dtype one.
    Fr   rž   NT)r|   r¢   rÒ  rê   r  r    Úbroadcast_shapes)r`   r¤   rŠ   Útarget_shapeÚvalue_shapes        rj   r
  r
  1	  sº   € ðÜ—x‘x  w¡Ó0ˆÜ—h‘h˜u“oˆô
 ˆkÓ
œS Ó.Ò
.°;¸q±>ÀQÒ3FØ! ! "�oˆô ˆkÓ
œS Ó.Ò
.°;¸q±>ÀQÓ3FðÜ×"Ñ" <°Ó=ÀÑMÐMøô œ	¤:Ð.ò Ùðûô ò Ùðús#   ‚-B Á4B' ÂB$Â#B$Â'	B3Â2B3c                óÎ   — t        | t        j                  «      rJt        | «      } t	        | j
                  j                  t        «      rt        j                  | t        ¬«      } | S )a:  
    Input validation for values passed to __init__. Ensure that
    any datetime64/timedelta64 dtypes are in nanoseconds.  Ensure
    that we do not have string dtypes.

    Parameters
    ----------
    values : np.ndarray or ExtensionArray

    Returns
    -------
    values : np.ndarray or ExtensionArray
    r¿   )
r{   r|   rè   rG   Ú
issubclassrg   r›   r£   r—  r]   rg  s    rj   rÂ   rÂ   L	  sE   € ô  �&œ"Ÿ*™*Ô%Ü/°Ó7ˆä�f—l‘l×'Ñ'¬Ô-Ü—X‘X˜f¬FÔ3ˆFà€Mrl   c                óR   — t        | t        «      r| j                  j                  S | S )z|
    The dtype a regex is actually matched against. A Categorical's elements have
    its categories' dtype (GH#38447).
    )r{   r%   Ú
categoriesrg   r¿   s    rj   r2  r2  e	  s&   € ô
 �%Ô)Ô*Ø×Ñ×%Ñ%Ð%Ø€Lrl   c                ó¾   — t        | t        «      rt        S t        | t        «      rt        S t        | t
        «      rt        S | j                  }|dv rt        S t        S )zÑ
    Find the appropriate Block subclass to use for the given values and dtype.

    Parameters
    ----------
    dtype : numpy or pandas dtype

    Returns
    -------
    cls : class, subclass of Block
    ÚMm)	r{   r&   rM  r*   r	  r'   rt  r}   rA  rö   s     rj   Úget_block_typerX  o	  sR   € ô �%œÔ)Ü Ð Ü	�Eœ;Ô	'Ü*Ð*Ü	�Eœ>Ô	*äÐð �:‰:€DØˆt�|Ü Ð äÐrl   c                óZ   — t        | j                  «      }t        | «      }  || d||¬«      S )NrÈ   ©rb   r•   rc   )rX  rg   rÂ   )r`   r•   rc   Úklasss       rj   r{  r{  Œ	  s-   € ô ˜6Ÿ<™<Ó(€Eä  Ó(€FÙ�˜a¨9¸4Ô@Ð@rl   r«   c               óD   — t        | j                  «      } || |||¬«      S )NrZ  )rX  rg   )r`   r•   rb   rc   r[  s        rj   r—   r—   ™	  s#   € ô ˜6Ÿ<™<Ó(€EÙ�˜d¨i¸dÔCÐCrl   c                óŽ  — | j                   |kD  rt        d| j                   › d|› d�«      ‚t        | j                  «      sf| j                   |k7  rt        d| j                   › d|› d�«      ‚t	        |«      t	        | «      k7  r#t        dt	        | «      › dt	        |«      › �«      ‚y|dk(  rt	        |«      d	k7  rt        d
«      ‚yy)aV  
    ndim inference and validation.

    Validates that values.ndim and ndim are consistent.
    Validates that len(values) and len(placement) are consistent.

    Parameters
    ----------
    values : array-like
    placement : BlockPlacement
    ndim : int

    Raises
    ------
    ValueError : the number of dimensions do not match
    z0Wrong number of dimensions. values.ndim > ndim [z > ú]z1Wrong number of dimensions. values.ndim != ndim [z != zWrong number of items passed z, placement implies rÈ   rž   zneed to splitN)rb   r  r   rg   r    )r`   r•   rb   s      rj   Ú
check_ndimr_  ¨	  sà   € ð$ ‡{�{�TÒäØ>¸v¿{¹{¸mÈ3ÈtÈfÐTUÐVó
ð 	
ô ˜vŸ|™|Ô,à�;‰;˜$ÒÜð(Ø(.¯© }°D¸¸¸aðAóð ô ˆy‹>œS ›[Ò(ÜØ/´°F³¨}ð =%Ü%(¨£^Ð$4ð6óð ð )ð
 
�Š”s˜9“~¨Ò*ä˜Ó)Ð)ð +ˆrl   c                óº   — t        | t        «      r,| j                  «       } |r|dkD  rt        j                  | «      } t        |t
        «      r|j                  }| |fS )zU
    Ensure that we don't allow NumpyExtensionArray / NumpyEADtype in internals.
    rž   )r{   r-   Úto_numpyr|   Ú
atleast_2dr)   Únumpy_dtype)r`   rg   rb   s      rj   Úextract_pandas_arrayrd  Ñ	  sQ   € ô �&Ô0Ô1Ø—‘Ó"ˆÙ�D˜1’Hä—]‘] 6Ó*ˆFä�%œÔ&Ø×!Ñ!ˆà�5ˆ=Ðrl   c                ó  — |€g }t        | t        «      r<| D ]5  }t        |t        «      r|j                  |«       Œ%|j                  |«       Œ7 |S t        | t        «      sJ t        | «      «       ‚|j                  | «       |S )z.return a new extended blocks, given the result)r{   r  rÜ   rÏ   r_   r›   )r¥   r   Úrs      rj   r«  r«  ç	  sz   € à€~ØˆÜ�&œ$ÔØò 	!ˆAÜ˜!œTÔ"Ø—‘˜aÕ à—‘˜aÕ ð		!ð €Mô ˜&¤%Ô(Ð6¬$¨v«,Ó6Ð(Ø�‰�fÔØ€Mrl   c                óŠ   — | j                   |k  r3t        | j                  «      st        d| «      } | j	                  dd«      } | S )z:
    Reshape if possible to have values.ndim == ndim.
    z+np.ndarray | DatetimeArray | TimedeltaArrayrž   rÉ   )rb   r   rg   r   rÊ   )r`   rb   s     rj   r–   r–   ÷	  s@   € ð
 ‡{�{�TÒÜ" 6§<¡<Ô0ô ÐGÈÓPˆFØ—^‘^ A rÓ*ˆFà€Mrl   c                ó  — t        | t        t        f«      r| j                  t        «      S t        | t
        t        f«      r| j                  } t        | t        j                  «      r#| j                  «       } d| j                  _        | S 	 | S )a+  
    The array that Series.values returns (public attribute).

    This has some historical constraints, and is overridden in block
    subclasses to return the correct array (e.g. period returns
    object ndarray and datetimetz a datetime64[ns] ndarray instead of
    proper extension array).
    F)r{   rB   r@   rë   r]   r>   rC   rÿ   r|   rè   r"  ÚflagsÚ	writeablerg  s    rj   r„   r„   
  sr   € ô �&œ;¬Ð6Ô7Ø�}‰}œVÓ$Ð$Ü	�Fœ]¬NÐ;Ô	<ð —‘ˆä�&œ"Ÿ*™*Ô%Ø—‘“ˆØ!&ˆ�‰Ôð €Mð 	à€Mrl   )r`   rQ   rá  r�   )r`   rQ   rá  rQ   )rg   rT   rá  rT   )rg   rT   rá  ztype[Block]rn   )r`   rQ   r•   r   rc   rä  rá  r_   )r•   r   rb   ra   rc   rä  rá  r_   )r•   r   rb   ra   rá  râ  )r`   rQ   rg   rú  rb   ró  rá  z!tuple[ArrayLike, DtypeObj | None]rç  )rž   )r`   rQ   rb   ra   rá  rQ   )šÚ
__future__r   r  r3  Útypingr   r   r   r   r   r	   r¨  Únumpyr|   Úpandas._libsr
   r   r¥  r   Úlibinternalsr   Úpandas._libs.internalsr   r   Úpandas._libs.missingr   Úpandas.errorsr   r   r   Úpandas.util._decoratorsr   Úpandas.util._exceptionsr   Úpandas.util._validatorsr   Úpandas.core.dtypes.astyper   r   Úpandas.core.dtypes.castr   r   r   r   r   r   Úpandas.core.dtypes.commonr   r    r!   r"   r#   r$   Úpandas.core.dtypes.dtypesr%   r&   r'   r(   r)   r*   Úpandas.core.dtypes.genericr+   r,   r-   r.   Úpandas.core.dtypes.inferencer/   Úpandas.core.dtypes.missingr0   r1   r2   Úpandas.corer3   Úpandas.core.algorithmsÚcoreÚ
algorithmsÚpandas.core.array_algos.putmaskr4   r5   r6   r7   r8   Ú pandas.core.array_algos.quantiler9   Úpandas.core.array_algos.replacer:   r;   r<   Ú"pandas.core.array_algos.transformsr=   Úpandas.core.arraysr>   r?   r@   rA   rB   rC   Úpandas.core.arrays.string_rD   Úpandas.core.baserE   Úpandas.core.commonÚcommonr(  Úpandas.core.computationrF   Úpandas.core.constructionrG   rH   Úpandas.core.indexersrI   rJ   rK   Úpandas.core.indexes.baserL   Úcollections.abcrM   rN   rO   rP   Úpandas._typingrQ   rR   rS   rT   rU   rV   rW   rX   rY   rZ   Úpandas.core.apir[   Úpandas.core.arrays._mixinsr\   rg   ro   r_   r  rt  rA  r	  rM  r
  rÂ   r2  rX  r{  r—   r_  rd  r«  r–   r„   re   rl   rj   ú<module>r’     s!  ðÝ "ã Û 	÷÷ ó ã ÷ó ÷õ $÷ñ õ
 3Ý 4Ý 7÷÷÷ ÷÷ ÷÷ ÷ó õ /÷ñ õ  ß &Ð &÷õ õ =÷ñ õ
 5÷÷ õ 3Ý )ß  Ð  Ý /÷÷ñ õ
 8á÷ó ÷÷ ÷ õ &ÝFð ˆR�XŠX�hÓ€
ôp(ˆL˜,×,Ò,ô p(ôf1h8�Eô h8ôV	G�]ô GôT�ô ô4- -ô -ô,+Ð3ô +óó6ó2óð< RVð
AØð
AØ"0ð
AØ8Nð
Aà
ó
Að$ $(ñDàðDð ð	Dð
 !ðDð óDó&*ðRØðØ-ðØ5?ðà&óô,ô ô rl   