+
    xȇiA<                      ^ RI Ht ^ RIt^ RIt^ RIHtHtHtHtH	t	H
t
 ^ RIt^ RIt^ RIHtHtHt ^ RIHtHt ^ RIHt ^ RIHtHtHt ^ RIHt ^ R	IHt ^ R
I H!t! ^ RI"H#t#H$t$ ^ RI%H&t&H't'H(t(H)t)H*t* ^ RI+H,t,H-t-H.t.H/t/H0t0H1t1 ^ RI2H3t3H4t4H5t5H6t6H7t7 ^ RI8H9t9H:t:H;t;H<t< ^ RI=H>t> ^ RI?H@t@HAtAHBtB ^ RICHDtD ^ RIEHFu HGtH ^ RIIHJtJHKtKHLtLHMtMHNtN ^ RIOHPtP ^ RIQHRtRHStSHTtT ^ RIUHVtV ^ RIWHXtXHYtYHZtZH[t[H\t\H]t] ^ RI^H_t_ ^ RI`Hata ^ RIbHFu Hctd ^ RIeHftf ^ RIgHhthHiti ^ RIjHktk ^ RIlHmtm ]'       d1   ^ RInHotoHptpHqtqHrtr ^ RIsHtttHutuHvtvHwtwHxtxHytyHztzH{t{H|t|H}t} ^ R I~Ht ^ R!IHt ]EP                  ! R"4      t ! R# R$]a]EP                  4      t ! R% R&]4      t ! R' R(]4      t ! R) R*]4      t ! R+ R,]4      t ! R- R.]4      tR/ R0 ltR1 R2 ltRBR3 R4 lltR5R/R6 R7 lltR8 R9 ltR: R; ltRBR< R= lltRCR> R? lltR@ RA ltR# )D    )annotationsN)TYPE_CHECKINGAnyLiteralSelfcastfinal)NaT	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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)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)get_values_for_csv)Callable	GeneratorIterableSequence)
	ArrayLikeAxisIntDtypeBackendDtypeObjFillnaOptionsIgnoreRaiseInterpolateOptionsQuantileInterpolationShapenpt)Index)NDArrayBackedExtensionArrayobjectc            	         ] tR t^t$ RtR]R&   R]R&   R]R&   R]R	&   RtR
t]]	R R l4       4       t
]]	R R l4       4       t]]	R R l4       4       t]]	R R l4       4       t]]	R 4       4       t]]	R R l4       4       t]]R R l4       4       t]R 4       t]]	R 4       4       t]R 4       t]R R l4       t]P,                  R R l4       t]RR  R! ll4       t]RR" R# ll4       t]R$ R% l4       t]R& R' l4       t]R( R) l4       t]R* R+ l4       t]RR, R- ll4       t]R. R/ l4       t]R0 R1 l4       t]R2 R3 l4       t ]R4 R5 l4       t!]R6 R7 l4       t"]R8 R9 l4       t#]R: R; l4       t$]R< R= l4       t%]R> R? l4       t&RR@ RA llt']]	RB RC l4       4       t(]RRD RE ll4       t)]RFRGRHR/RI RJ ll4       t*]RK RL l4       t+RRM RN llt,]RO RP l4       t-]RRQ RR ll4       t.]RRS RT ll4       t/]RRU RV ll4       t0]RRW RX ll4       t1RY RZ lt2R[ t3]R\ R] l4       t4R^ R_ lt5R` Ra lt6RRb Rc llt7]R]8Pr                  3Rd Re ll4       t:Rf Rg lt;Rh Ri lt<Rj Rk lt=Rl Rm lt>RRn Ro llt?RpR
RqRRrR/Rs Rt llt@]RpR
RqRRuRvRrR/Rw Rx ll4       tA]Ry Rz l4       tBRR{ R| lltC]RR} R~ ll4       tD]R R l4       tER R ltF]R R l4       tG]R R l4       tHRR R lltIRtJR# )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   refsrH   __init__Fc                   V ^8  d   QhRR/#    returnbool )formats   "l/Users/max/.openclaw/workspace/postharvest/venv/lib/python3.14/site-packages/pandas/core/internals/blocks.py__annotate__Block.__annotate__   s     3 3 3    c                6    \        V P                  4      '       * # )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   &rg   _validate_ndimBlock._validate_ndim   s     'tzz222rj   c                   V ^8  d   QhRR/# ra   re   )rf   s   "rg   rh   ri      s     / /4 /rj   c                	<    V P                   P                  \        8H  # N)r[   rl   
_dtype_objrm   s   &rg   	is_objectBlock.is_object   s     {{  J..rj   c                   V ^8  d   QhRR/# ra   re   )rf   s   "rg   rh   ri      s     6 6d 6rj   c                	`    \         P                  ! V P                  P                  4      '       * # rs   )r   is_np_dtyper[   rl   rm   s   &rg   is_extensionBlock.is_extension   s      ??4;;#4#4555rj   c                   V ^8  d   QhRR/# ra   re   )rf   s   "rg   rh   ri      s     % %$ %rj   c                	$    V P                   '       * # rs   )rz   rm   s   &rg   _can_consolidateBlock._can_consolidate   s     $$$$rj   c                	F    V P                   V P                  P                  3# rs   )r~   rl   namerm   s   &rg   _consolidate_keyBlock._consolidate_key   s     $$djjoo55rj   c                   V ^8  d   QhRR/# ra   re   )rf   s   "rg   rh   ri      s     " "d "rj   c                    V P                   p\        V\        P                   4      '       d   VP                  R9  # VP                  # )z'
Can we store NA values in this Block?
iub)rl   
isinstancenpkind_can_hold_narn   rl   s   & rg   r   Block._can_hold_na   s9     

eRXX&&::U**!!!rj   c                   V ^8  d   QhRR/# ra   re   )rf   s   "rg   rh   ri      s     3 3 3rj   c                d    V P                   P                  \        P                  ! \        4      8H  # )zN
We can be bool if a) we are bool dtype or b) object dtype with bool objects.
)r[   rl   r   rd   rm   s   &rg   is_boolBlock.is_bool   s!     {{  BHHTN22rj   c                	,    \        V P                  4      # rs   )external_valuesr[   rm   s   &rg   r   Block.external_values   s    t{{++rj   c                	0    \        V P                  R R7      # )F)compat)r/   rl   rm   s   &rg   
fill_valueBlock.fill_value   s     "$**U;;rj   c                	~    V P                   \        8w  d(   \        WP                   4      '       d   V P                  pV# rs   )rl   rt   r-   r   rn   values   &&rg   _standardize_fill_valueBlock._standardize_fill_value   s-     ::#(=eZZ(P(POOErj   c                   V ^8  d   QhRR/# )rb   rc   r   re   )rf   s   "rg   rh   ri      s      . rj   c                	    V P                   # rs   	_mgr_locsrm   s   &rg   mgr_locsBlock.mgr_locs   s    ~~rj   c                    V ^8  d   QhRRRR/# )rb   new_mgr_locsr   rc   Nonere   )rf   s   "rg   rh   ri      s     & &^ & &rj   c                	    Wn         R # rs   r   )rn   r   s   &&rg   r   r      s    %rj   Nc               $    V ^8  d   QhRRRRRR/# )rb   	placementBlockPlacement | Noner^   BlockValuesRefs | Nonerc   rZ   re   )rf   s   "rg   rh   ri      s/     Q Q )Q %	Q
 
Qrj   c                    Vf   V P                   pV P                  '       d   \        WP                  R7      p\	        WV P                  VR7      # )zU
Create a new block, with type inference propagate any values that are
not specified
r]   r   r]   r^   )r   rz   ensure_block_shaper]   	new_blockrn   r[   r   r^   s   &&&&rg   
make_blockBlock.make_block   s@     I'YY?F4994PPrj   c               $    V ^8  d   QhRRRRRR/# )rb   r   r   r^   r   rc   r   re   )rf   s   "rg   rh   ri      s/     R R )R %	R
 
Rrj   c                ^    Vf   V P                   p\        V 4      ! WV P                  VR7      # )z2Wrap given values in a block of same type as self.r   )r   typer]   r   s   &&&&rg   make_block_same_classBlock.make_block_same_class   s,     I Dz&DIIDQQrj   c                   V ^8  d   QhRR/# )rb   rc   strre   )rf   s   "rg   rh   ri     s     	 	# 	rj   c                	X   \        V 4      P                  pV P                  ^8X  d    V R\        V 4       RV P                   2pV# RP                  V P                   Uu. uF  p\        V4      NK  	  up4      pV RV P                  P                   RV RV P                   2pV# u upi )   z: z dtype: z x z, z	, dtype: )
r   __name__r]   lenrl   joinshaper   r   indexer)rn   r   resultsr   s   &    rg   __repr__Block.__repr__  s     Dz""99>vRD	{(4::,?F
  JJ

;
1A
;<EvR 5 56byUF  <s   B'c                   V ^8  d   QhRR/# )rb   rc   r\   re   )rf   s   "rg   rh   ri     s          rj   c                	,    \        V P                  4      # rs   )r   r[   rm   s   &rg   __len__Block.__len__  s    4;;rj   c                    V ^8  d   QhRRRR/# )rb   slcslicerc   r   re   )rf   s   "rg   rh   ri     s     J Ju J Jrj   c                    V P                   V,          pV P                  V4      pV P                  p\        V 4      ! W2V P                  VR7      # )z3
Perform __getitem__-like, return result as block.
r^   )r   _slicer^   r   r]   )rn   r   r   
new_valuesr^   s   &&   rg   slice_block_columnsBlock.slice_block_columns  s@    
 ~~c*[[%
yyDz*DIIDIIrj   c                    V ^8  d   QhRRRR/# )rb   indicesnpt.NDArray[np.intp]rc   r   re   )rf   s   "rg   rh   ri   "  s     J J*> J4 Jrj   c                    V P                   V,          pV P                  V4      p\        V 4      ! W2V P                  RR7      # zg
Perform __getitem__-like, return result as block.

Only supports slices that preserve dimensionality.
Nr   )r   r   r   r]   )rn   r   r   r   s   &&  rg   take_block_columnsBlock.take_block_columns!  s7     ~~g.[[)
Dz*DIIDIIrj   c               (    V ^8  d   QhRRRRRRRR/# )	rb   slicerr   r   r   ref_inplace_oprd   rc   r   re   )rf   s   "rg   rh   ri   1  s2     
J 
J
J+9
JKO
J	
Jrj   c                    V P                  V4      pV'       d!   V P                  P                  4       '       d   V P                  MRp\        V 4      ! WBV P                  VR7      # r   )r   r^   has_referencer   r]   )rn   r   r   r   r   r^   s   &&&&  rg   getitem_block_columnsBlock.getitem_block_columns0  sI     [[(
 .$))2I2I2K2KtyyQUDz*DIIDIIrj   c                    V ^8  d   QhRRRR/# )rb   elementr   rc   rd   re   )rf   s   "rg   rh   ri   >  s     6 6 6 6rj   c                H    \        VRR7      p\        V P                  V4      # )z#require the same dtype as ourselvesTextract_numpy)rE   r   r[   )rn   r   s   &&rg   _can_hold_elementBlock._can_hold_element=  s!      t<W55rj   c                    V ^8  d   QhRRRR/# )rb   r   rL   rc   rd   re   )rf   s   "rg   rh   ri   D  s     ) )) ) )rj   c                4    VP                   V P                   8H  # )z
Should we set self.values[indexer] = value inplace or do we need to cast?

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

Returns
-------
bool
rl   r   s   &&rg   should_storeBlock.should_storeC  s     {{djj((rj   c                   V ^8  d   QhRR/# rb   rc   list[Block]re   )rf   s   "rg   rh   ri   V  s     - -{ -rj   c                `    V! V P                   3/ VB p\        V4      pV P                  V4      # )zC
apply the function to my values; return a block if we are not
one
)r[   maybe_coerce_values_split_op_result)rn   funckwargsr   s   &&, rg   applyBlock.applyU  s2     dkk,V,$V,$$V,,rj   c                   V ^8  d   QhRR/# rb   rc   rZ   re   )rf   s   "rg   rh   ri   a  s     + +e +rj   c                	    V P                   ^8X  g   Q hV! V P                  4      pV P                  P                   ^8X  d   TpMVP                  R^4      pV P                  V4      # )rb   )r]   r[   reshaper   )rn   r   r   
res_valuess   &&  rg   reduceBlock.reduce`  sX     yyA~~dkk";;q JA.Jz**rj   c                    V ^8  d   QhRRRR/# )rb   r   rL   rc   r   re   )rf   s   "rg   rh   ri   p  s      y [ rj   c                	   VP                   ^8  d   \        VP                  \        4      '       d   . p\	        V P
                  4       Fb  w  r4\        VP                  4      '       g   WV^,            pMW,          p\        V4      pV P                  WVR7      pVP                  V4       Kd  	  V# V P                  V4      pV.# )r   )r[   r   )
r]   r   rl   r$   	enumerater   r   r   r   append)	rn   r   nbsilocvalsbpblocknbs	   &&       rg   r   Block._split_op_resulto  s     ;;?z&,,GG C#DNN3*6<<88!a!e,D!9D#C(tB

5! 4 J__V$trj   c                   V ^8  d   QhRR/# )rb   rc   zGenerator[Block]re   )rf   s   "rg   rh   ri     s      ( rj   c              #    "   V P                   ^8X  g   Q h\        V P                  4       FU  w  rV P                  \	        W^,           4      ,          p\        V4      p\        V 4      ! W4^V P                  R7      pVx  KW  	  R# 5i)z4
Split a block into a list of single-column blocks.
r   N)r]   r   r   r[   r   r   r   r^   )rn   r  ref_locr  r  r  s   &     rg   _splitBlock._split  sg     
 yyA~~#DNN3JA;;uQA/D(BdDQTYYGBH 4s   BBc                   V ^8  d   QhRR/# r   re   )rf   s   "rg   rh   ri     s      + rj   c                    V P                   ^8X  d   V P                  ^ ,          ^8w  g   Q h. pV P                  4        F   pV! V.VO5/ VB pVP                  V4       K"  	  V# )z
Split the block and apply func column-by-column.

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

Returns
-------
List[Block]
)r]   r   r  extend)rn   r   argsr   
res_blocksr  rbss   &&*,   rg   split_and_operateBlock.split_and_operate  sc     yyA~$**Q-1"444
++-Br+D+F+Cc"   rj   c                    V ^8  d   QhRRRR/# )rb   raise_on_upcastrd   rc   rZ   re   )rf   s   "rg   rh   ri     s     7 7T 7e 7rj   c                2   \        V P                  P                  V4      pW0P                  8X  d   \        R4      h\	        V4      '       d   \        V P                  P                  4      '       dk   \        V4      '       dZ   V\        JdP   \        V\        P                  \        P                  34      '       d   \        P                  ! V4      '       g   RpM\        V\        P                  4      '       dp   VP                  ^8X  d_   \        V P                  P                  4      '       d:   \        VP                  4      '       d   \         P"                  ! V4      '       d   RpV'       d'   \%        RV RV P                  P                   R24      hV P                  P                  V8X  d'   \        RV RV P                  P                   R24      h V P'                  V4      #   \(         d    p\)        R	T P                   R
24      ThRp?ii ; i)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
z\Something has gone wrong, please report a bug at https://github.com/pandas-dev/pandas/issuesFz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.z0Incompatible (high-resolution) value for dtype='z$'. Explicitly cast before operating.N)r   r[   rl   AssertionErrorr!   r   r.   r
   r   r   
datetime64timedelta64isnatndarrayr]   r   r   has_only_ints_or_nan	TypeErrorastyper   )rn   otherr  	new_dtypeerrs   &&&  rg   coerce_to_target_dtypeBlock.coerce_to_target_dtype  s    %T[[%6%6>	

" >  e !2!233US 52==".."ABBrxxPU $Oubjj))

a !2!233u{{++((//#OoeWM$++BSBSATTUVWW;;	) +I;6K;;$$% &?? 

	;;y))" 	
 &B4::, O4 4 	s   G, ,H7HHc                   V ^8  d   QhRR/# r   re   )rf   s   "rg   rh   ri     s     "8 "8 "8rj   c                   V P                   '       g   V P                  RR7      .# V P                  ^8w  d   V P                  ^ ,          ^8w  do   V P	                  \
        P                  4      p\        ;QJ d    R V 4       F  '       d   K   RM	  RM! R V 4       4      '       d   V P                  RR7      .# V# V P                  pVP                  ^8X  d
   V^ ,          p\        P                  ! VRR7      pRpW2J g'   \        V\        4      '       d   VP                  VJ d   V P                  p\        W0P                  4      p\!        V4      pV P#                  W4R7      .# )zb
Attempt to coerce any object types to better types. Return a copy
of the block (if copy = True).
Fdeepc              3  R   "   T F  qP                   P                  R 8H  x  K  	  R# 5i)ONrl   r   ).0blks   & rg   	<genexpr> Block.convert.<locals>.<genexpr>  s     ;FS99>>S(Fs   %'T)convert_non_numericNr   )ru   copyr]   r   r  rZ   convertallr[   r   maybe_convert_objectsr   r>   _ndarrayr^   r   r   r   )rn   blocksr[   r   r^   s   &    rg   r5  Block.convert  s    ~~~II5I)**99>djjmq0++EMM:Fs;F;sss;F;;;		u	-..M;;! AYF.. $

 z#677##v-99D'
II>
(4

677rj   c               4    V ^8  d   QhRRRRRRRRRRRRR	R
/# )rb   infer_objectsrd   convert_stringconvert_integerconvert_booleanconvert_floatingdtype_backendrN   rc   r   re   )rf   s   "rg   rh   ri     sP     , ,, , 	,
 , , $, 
,rj   c                	&  a  V'       d$   S P                   '       d   S P                  4       pMS .p\        WSWB.4      '       g"   V Uu. uF  qP                  R R7      NK  	  up# . p	V EF  p
V
P                  ^8X  g   S P
                  ^ ,          ^8X  d   V
.M\        V
P                  4       4      pV Uu. uF  p\        VP                  VVVVVV4      NK   	  pp\        ;QJ d    V 3R lV 4       F  '       d   K   R M	  RM! V 3R lV 4       4      '       d$   V	P                  V
P                  R R7      4       K  \        WRR7       F3  w  rV	P                  VP                  WP                  ^8g  R7      4       K5  	  EK  	  V	# u upi u upi )Fr*  c              3  @   <"   T F  qSP                   8H  x  K  	  R # 5irs   r   )r/  rl   rn   s   & rg   r1  'Block.convert_dtypes.<locals>.<genexpr>1  s     ;F5DJJ&Fs   Tstrict)rl   squeeze)ru   r5  anyr4  r]   r   listr  r   r[   r6  r  zipr"  )rn   r<  r=  r>  r?  r@  rA  blksbr  r0  sub_blksdtypesrl   s   f&&&&&&       rg   r   Block.convert_dtypes  s\    T^^^<<>D6DP
 
 1551FFF&55C Q$**Q-1*<$szz|BT  " "A HH"##$!! "   s;F;sss;F;;;

3888/0>

188%18EF ?- 0 
7 6s   F	5$Fc                   V ^8  d   QhRR/# )rb   rc   rO   re   )rf   s   "rg   rh   ri   ?  s     ! !x !rj   c                	.    V P                   P                  # rs   )r[   rl   rm   s   &rg   rl   Block.dtype=  s     {{   rj   c               (    V ^8  d   QhRRRRRRRR/# )	rb   rl   rO   errorsrQ   rG  rd   rc   rZ   re   )rf   s   "rg   rh   ri   C  s2     + ++ + 	+
 
+rj   c                d   V P                   pV'       dO   VP                  ^8X  d>   \        V4      '       d-   VP                  ^ ,          ^8w  d   \	        R4      hVR	,          p\        WAVR7      p\        V4      pRp\        VP                  VP                  4      '       d   V P                  pV P                  WVR7      pVP                  V P                  8w  dU   \        RV P                  P                   RV P                   RVP                  P                   RVP                   R2	4      hV# )
am  
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
z*Can not squeeze with more than one column.)rT  Nr   zcannot set astype for dtype (z [z]) to different shape (z]))r   NNN)r[   r]   r   r   
ValueErrorr   r   r   rl   r^   r   r!  r   )rn   rl   rT  rG  r[   r   r^   newbs   &&&&    rg   r"  Block.astypeB  s    . v{{a',?,F,F||A!# !MNND\F&vVD
(4
&,,
(8(89999Dz5::#JJOO$Btzzl 3JJOO$Btzzl"6 
 rj   na_repnanquotingc                    V ^8  d   QhRRRR/# )rb   rZ  r   rc   rZ   re   )rf   s   "rg   rh   ri   q  s     ' '=@'	'rj   c          	     Z    \        V P                  VVVVVR7      pV P                  V4      # )z"convert to our native types format)rZ  r\  float_formatdate_formatdecimal)rG   r[   r   )rn   r_  r`  ra  rZ  r\  r   s   &$$$$$ rg   rG   Block.get_values_for_csvp  s5    
 $KK%#
 v&&rj   c                    V ^8  d   QhRRRR/# )rb   r+  rd   rc   r   re   )rf   s   "rg   rh   ri     s     
W 
WD 
WT 
Wrj   c                   V P                   pV'       d   VP                  4       pRpMVP                  4       pV P                  p\	        V 4      ! W P
                  V P                  VR7      # )zcopy constructorNr   )r[   r4  viewr^   r   r   r]   )rn   r+  r[   r^   s   &$  rg   r4  
Block.copy  sP     [[]FD[[]F99DDz&NNQUVVrj   c               $    V ^8  d   QhRRRRRR/# )rb   inplacerd   r+  rc   r   re   )rf   s   "rg   rh   ri     s!     $ $4 $t $t $rj   c                	z    V'       d#   V P                   P                  4       '       g   V # V P                  VR 7      # )r*  )r^   r   r4  )rn   rh  r+  s   &&&rg   _maybe_copyBlock._maybe_copy  s-    4992244Kyydy##rj   c                   V ^8  d   QhRR/# )rb   rh  rd   re   )rf   s   "rg   rh   ri     s      $ rj   c                	    R pV'       * pV'       d2   V P                   P                  4       '       d   RpW23# V P                   pW23# )NT)r^   r   )rn   rh  r^   r4  s   &&  rg   _get_refs_and_copyBlock._get_refs_and_copy  sF    {yy&&(( z yyzrj   c               $    V ^8  d   QhRRRRRR/# )rb   rh  rd   maskznpt.NDArray[np.bool_] | Nonerc   r   re   )rf   s   "rg   rh   ri     s/     @ @ 	@ +@ 
@rj   c                   V P                   pV P                  V4      '       g   V P                  VRR7      .# Vf   \        P                  ! WQ4      pVP                  4       '       g   V P                  VRR7      .# V P                  V4      '       g#   V P                  R8X  d<   \        V4      '       d+   V P                  V4      p\        VP                   WB4       V.# V P                  ^8X  g   V P                  ^ ,          ^8X  da   Ve   V\        J d+   V P                  \        P                  ! \        4      4      pMV P                  VRR7      pVP!                  VVRVR7      # . p\#        V P%                  4       4       F<  w  rVP'                  \)        V 4      P!                  V	VVRWHV^,            R7      4       K>  	  V# )zm
replace the to_replace value with value, possible to create new
blocks here this is just a call to putmask.
Fr*  stringr  T
to_replacer   rh  rq  )r[   r   rj  r0   mask_missingrH  rl   r,   r2   r]   r   r   r"  r   rX   r&  replacer   r  r  r   )
rn   rv  r   rh  rq  r[   r0  r9  r  r  s
   &&&&&     rg   rx  Block.replace  s   " %%j11
 $$W5$9::<'';Dxxzz $$W5$9::##E**tzzX/E%PU,, ""7+CCJJ45LYY!^tzz!}1}kk"((6"2311%1O;;%	    F"4;;=1J&&#-# $!a!e_ '  2 Mrj   c                    V ^8  d   QhRRRR/# )rb   rh  rd   rc   r   re   )rf   s   "rg   rh   ri     s      - - 	- 
-rj   c                6   \        V4      '       g+   V P                  V4      '       g   V P                  RR7      .# \        V4      '       d+   V P                  \        R39  d   V P                  RR7      .# V P                  V4      '       gM   V P                  R8X  d   \        V4      '       g+   V P                  \        P                  ! \        4      4      pMV P                  V4      p\        P                  ! V4      p\        VP                  WbV4       V.# )an  
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*  rs  )r,   r   r4  rl   rX   r"  r   rj  recompiler8   r[   )rn   rv  r   rh  rq  r  rxs   &&&&&  rg   _replace_regexBlock._replace_regex  s    4 Z  )?)?
)K)K II5I)**FH3E!E II5I)** ""5))djjH.DuKK 01E$$W-EZZ
#ellBt4wrj   c          
     ,    V ^8  d   QhRRRRRRRRRR	/# )
rb   src_listzIterable[Any]	dest_listzSequence[Any]rh  rd   regexrc   r   re   )rf   s   "rg   rh   ri     sC     Y YY !Y 	Y
 Y 
Yrj   c           
       aaa V P                   o\        WRR7       UUu. uFE  w  rVV P                  V4      '       g'   V P                  R8X  g   K/  \	        V4      '       g   KB  WV3NKG  	  pppV'       g   V P                  RR7      .# \        V4      ^,
          p\        SP                  4      '       d   \        S4      ( oVVV3R lV 4       p	MV3R lV 4       p	V'       d   \        V	4      p	V .p
\        \        WyRR7      4       EFh  w  pw  w  rp. p\        V
4       EFH  w  pp\        V
4      ^8X  d   TpM&Tp\        V\        4      '       d   Q hVVV^,            pVP                  VVVVSR7      pXV8w  d   \        V P                  P                  4       UUu/ uF  w  pp\!        V! 4       4      VbK  	  pppV F  pVP                  V P                  J dR   \!        V4      V9   d@   VV Jd8   V P                  P                  P#                  V\!        V4      ,          4       Kj  Kl  Kn  VP                  P                  P%                  4        K  	  VP'                  V4       EKK  	  Tp
EKk  	  V
# u uppi u uppi )	z*
See BlockManager.replace_list docstring.
TrE  rs  Fr*  c           
   3  b   <"   T F$  p\        \        SV^ ,          SSR7      4      x  K&  	  R# 5i)r   )r  rq  N)r1   r7   )r/  r   na_maskr  r[   s   & rg   r1  %Block.replace_list.<locals>.<genexpr>1  s8      6 A #+FAaDGT  s   ,/c              3  `   <"   T F#  p\         P                  ! SV^ ,          4      x  K%  	  R# 5i)r   N)r0   rw  )r/  r   r[   s   & rg   r1  r  9  s%     GAW))&!A$77s   +.)rv  r   rq  rh  r  )r[   rJ  r   rl   r,   r4  r   r"   r.   rI  r   r   rd   _replace_coercer^   referenced_blocksidpopclearr  )rn   r  r  rh  r  xypairssrc_lenmasksrbr  srcdestrq  new_rbblk_numr0  mmibr   rL  self_blk_idsr  r[   s   &&&&f                  @@rg   replace_listBlock.replace_list  sX    
 H=
=&&q))djjH.D INq QF= 	 

 II5I)**e*q.6<<(( F|mG6 	6E HGE KE V&/E0N&O"A"T"$F
 !*"r7a<AC)#t4444Ggk2A
 ,,"# -  <
 099T9T/U$/Utq!13
/U ! $ $66TYY.!!u4$ $		 ; ; ? ?RPQU@S T :G4 FF44::< $ f%I !.J BW 'PX 	Y
z$s   ,I8I8$I8!I>
c               (    V ^8  d   QhRRRRRRRR/# )rb   rq  npt.NDArray[np.bool_]rh  rd   r  rc   r   re   )rf   s   "rg   rh   ri   r  s4     7 7 $	7
 7 7 
7rj   c                D   \        WQ4      '       d   V P                  VVVVR7      # Vf   VP                  4       '       d   V P                  P	                  4       pV P                  \        P                  ! \        4      4      pV'       g   VP                  RR7      pMBV'       d;   V'       d3   VP                  P	                  4       '       d   VP                  RR7      p\        VP                  W24       V.# V P                  RR7      .# V P                  VVVVR7      # )a  
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]
)rh  rq  Tr*  Fru  )r9   r  rH  r^   r   r"  r   rl   rX   r4  r2   r[   rx  )rn   rv  r   rq  rh  r  has_refr  s   &&&&&&  rg   r  Block._replace_coerceq  s    < E..&&	 '   }88::"ii557GRXXf%56B"WW$W/ W1F1F1H1HWW$W/#BIIt;4K		u	-..<<%	    rj   c                    V ^8  d   QhRRRR/# )rb   arg
np.ndarrayrc   re   )rf   s   "rg   rh   ri     s      j Z rj   c                    V# z1
For compatibility with 1D-only ExtensionArrays.
re   rn   r  s   &&rg   _maybe_squeeze_argBlock._maybe_squeeze_arg  s	     
rj   c                    V# r  re   )rn   r   s   &&rg   _unwrap_setitem_indexerBlock._unwrap_setitem_indexer  s	     rj   c                   V ^8  d   QhRR/# rb   rc   rT   re   )rf   s   "rg   rh   ri     s     ! !u !rj   c                	.    V P                   P                  # rs   )r[   r   rm   s   &rg   r   Block.shape  s    {{   rj   c                    V ^8  d   QhRRRR/# )rb   r  )int | tuple[int, int] | tuple[slice, int]rc   r  re   )rf   s   "rg   rh   ri     s      ? J rj   c                	(    V P                   V,          # rs   r[   )rn   r  s   &&rg   iget
Block.iget  s     {{1~rj   c                    V ^8  d   QhRRRR/# )rb   r   4slice | npt.NDArray[np.bool_] | npt.NDArray[np.intp]rc   rL   re   )rf   s   "rg   rh   ri     s     # #J#	#rj   c                (    V P                   V,          # )zreturn a slice of my valuesr  )rn   r   s   &&rg   r   Block._slice  s    
 {{6""rj   c               $    V ^8  d   QhRRRRRR/# rb   r[   rL   r4  rd   rc   r   re   )rf   s   "rg   rh   ri     s!     # #	 # #$ #rj   c                p    V'       d    V P                   P                  4       V n         W P                   V&   R# )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[   r4  rn   locsr[   r4  s   &&&&rg   set_inplaceBlock.set_inplace  s'     ++**,DK"Drj   c               (    V ^8  d   QhRRRRRRRR/# )	rb   r   r   axisrM   r   r   rc   rZ   re   )rf   s   "rg   rh   ri     s8     %H %H%%H %H ,	%H 
%Hrj   c                   V P                   pV\        P                  J d   V P                  pRpMRp\        P
                  ! WQW&VR7      p\        V \        4      '       d   V P                  ^8X  d   Vf   Q hV^ 8X  d   Vf   Q hVf   V P                  pVP                  V P                  8w  d   V P                  Ws4      # V P                  Ws4      # )z>
Take values according to indexer and return them as a block.
FT)r  
allow_fillr   )r[   r   
no_defaultr   algostake_ndr   ExtensionBlockr]   r   rl   r   r   )rn   r   r  r   r   r[   r  r   s   &&&&&   rg   r  Block.take_nd  s     'JJJ ]]$*

 dN++ 		Q<+?@@AI,"677>>Ltzz)??:<<--jGGrj   c                    V ^8  d   QhRRRR/# rb   new_placementr   needs_maskingr  re   )rf   s   "rg   rh   ri     s      * * ,	*
 -*rj   c                    VP                  V P                  P                  VR7      w  rVVP                  ^ 4      pVP                  V,          pW6,          p\	        V4      p\        WWR7      .pW3# )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]
allow_fill : bool
needs_masking : np.ndarray[bool]

Returns
-------
blocks : list of Block
    New blocks of unstacked values.
mask : array-like of bool
    The mask of columns of `blocks` we should keep.
r   r   )get_new_valuesr[   TrH  r   new_block_2d)	rn   	unstackerr   r  r  r   rq  r  r9  s	   &&&&&    rg   _unstackBlock._unstack  so    4 %33KKMMj 4 

 xx{  \\$'
%+M*z89|rj   c                   V ^8  d   QhRR/# r   re   )rf   s   "rg   rh   ri   9  s     = = =rj   c                   V P                  V4      p\        \        P                  V P                  4      pV P
                  ^8X  d   VP                  p\        WV4       V P                  \        8w  d   \        VRR7      p \        VP                  V4      pV P                  \        8X  d;   W1,          p\        P                  ! V4      '       d   \        V\        V4      V4      pV P!                  RR7      p \        \        P                  V P                  P                  4      p\#        V\        P                  4      '       d+   VP
                  ^8X  d   \        V4      ^8X  d
   VR,          p WCV&   V #   \$        \&        3 d$   p\        T4      '       d   \'        R4      Thh Rp?ii ; i  \(         d(    T P+                  TRR7      pTP-                  Y4      u # i ; i)aT  
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.
Tr   rh  z)setting an array element with a sequence.Nrt  )r   .)r   r   r   r  r[   r]   r  rF   rl   rt   rE   r   r   r    r4   r   rj  r   r!  rW  r   r&  setitem)rn   r   r   r[   castedvir%  r  s   &&&     rg   r  Block.setitem9  s   * ,,U3bjj$++.99>XXF 	gf5::#!%t<E	(u=F zzZ'_##B'' 9R&QF##D#1D"**dkkmm4F&"**--&++2Bs6{VWGW"(w  z* ''$C ) ! 	.,,UD,IB::g--	.s*   F/ 2E8 8F,	F''F,//G! G!c                   V ^8  d   QhRR/# r   re   )rf   s   "rg   rh   ri   x  s     A" A"K A"rj   c                   Tp\        \        P                  V P                  4      p\	        VP
                  V4      w  r\        V\        \        \        34      '       d   Q hV\        P                  J d   V P                  pV P                  V4      p\        VRR7      pV'       d   V P                  RR7      .#  \!        VP"                  V4      pV P%                  RR7      p \        \        P                  V P                  4      p\'        VP
                  W4       V .#   \(         Ed(    T P*                  ^8X  g   T P,                  ^ ,          ^8X  dj   \/        T4      '       g%   T P1                  TRR7      P3                  Y4      u # TP5                  4       ^ ,          pT P7                  YrT,          4      pT.u # \        T\        P                  4      p	. p
\9        T P;                  4       4       FW  w  rTpT	'       d   TRY^,           13,          pTRY^,           13,          pTP3                  Y4      pT
P=                  T4       KY  	  T
u # i ; i)z
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]
Tr   Fr*  r  rt  rV  )r   r   r  r[   r5   r  r   r)   r+   r(   r   r  r   r   rE   r4  r   rl   rj  r3   r   r]   r   r    r&  putmasknonzeror  r   r  r  )rn   rq  new	orig_maskr[   noopr  r   r  is_arrayr  r  nsubmaskr  s   &&&            rg   r  Block.putmaskx  s     	bjj$++.%fhh5
cHi#FGGGG#.. //C**3/Ct4II5I)**#	"(s;F##D#1D"**dkk2F"688T:6M  	"yyA~A!!3 $C((66T 7 gd() #llnQ/Gg7|<B4K &c2::6
&t{{}5EAA11u9-'11u95G**W0C%%c* 6 "!7	"s!   <A$D! !A(I2I?BIIc                   V ^8  d   QhRR/# r   re   )rf   s   "rg   rh   ri     s     e) e)K e)rj   c                   VP                   V P                   8X  g   Q h\        V\        \        \        34      '       d   Q hV P                   ^8H  p\        V4      p\        \        P                  V P                  4      pTpV'       d   VP                  p\        WB( 4      w  rgV'       d   V P                  RR7      .# V\        P                  J d   V P                  pV P!                  V4      p \#        VP$                  V4      pTp\'        WFP)                  4       V4      p	WJdv   \+        V4      '       d=   \-        V4      \-        V4      8  d$   \        P.                  ! V( WA4       \1        R4      hVP                  4       p
\        P2                  ! WV	4       M\+        V4      '       dq   \        V\        P                  4      '       gQ   \-        V4      V P4                  R,          8X  d0   \        P6                  ! V4      P9                  VP4                  4      p\:        P.                  ! V( WA4      p
 V'       d   V
P                  p
V PM                  V
4      .#   \<        \>        \@        3 d    T P                   ^8X  g   T P4                  ^ ,          ^8X  d'   T PC                  TRR7      pTP/                  YR4      u # \        T\        P                  \D        34      p. p\G        T PI                  4       4       FX  w  rTpT'       d   TRY^,           13,          pTRY^,           13,          pTP/                  TT4      pTPK                  T4       KZ  	  Tu # i ; i)z
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]
Fr*  zThis should not be reached; call to np.where above is expected to raise ValueError. Please report a bug at github.com/pandas-dev/pandasrt  rV  r   )'r]   r   r)   r+   r(   r1   r   r   r  r[   r  r5   r4  r   r  r   r   r   rl   r4   sumr    r   whereNotImplementedErrorr  r   arrayr   rC   rW  r!  r   r&  r<   r   r  r  r   )rn   r#  cond	transposer[   
orig_othericondr  r  altr   r  r  r  r  r  othr  r  s   &&&                rg   r  Block.where  s    yyDII%%%eh	<%HIIIIIIN	!$' bjj$++.
XXF&vu5II5I)**CNN"OOE,,U3;	B )u=F4 E-fiik5IC&&3u:F+CHHeVV3-7 
  

6#.
 !''&ubjj99E
djjn4
 HHUO33FLLAE
 %**E66A XXF'(({ I'89 	" yyA~A!!3 33E53Q{{:44 &ebjj.-IJ
&t{{}5EAC#Aqq5yL1"1aa%i<0G((30C%%c* 6 "!-	"s   0I A#MBMMc               $    V ^8  d   QhRRRRRR/# rb   limit
int | Nonerh  rd   rc   r   re   )rf   s   "rg   rh   ri   "  s*     " " " 	"
 
"rj   c                   \        VR4      pV P                  '       g   RpM-\        V P                  4      p\	        V P                  V4      w  rTV'       d   V P                  RR7      .# Ve3   RXVP                  V P                  P                  ^,
          4      V8  &   V'       d   V P                  XP                  V4      pMV P                  VXP                  ( 4      p\        V4      # )zm
fillna on the block with the value. If we fail, then convert to
block to hold objects instead and try again
rh  TFr*  )r   r   r.   r[   r5   r4  cumsumr]   r  r  r  extend_blocks)rn   r   r  rh  r  rq  r  s   &&&&   rg   fillnaBlock.fillna"  s     &gy9   D$D)$++t<JDII5I)**>CDT[[--12U:;,,tvvu-C**UTVVG,CS!!rj   rh  r  
limit_areac          
     ,    V ^8  d   QhRRRRRRRRR	R
/# rb   methodrP   rh  rd   r  r  r  #Literal['inside', 'outside'] | Nonerc   r   re   )rf   s   "rg   rh   ri   C  s>     = = = 	=
 = 8= 
=rj   c               	8   V P                   '       g   V P                  R R7      .# V P                  V4      w  rV\        \        V P
                  4      pVP                  P                  VVVVR7      P                  p\        VRR7      p	V P                  WR7      .# )Fr*  )r  r  r  r4  Tr   r   )
r   r4  rn  r   r>   array_valuesr  _pad_or_backfillrE   r   )
rn   r  rh  r  r  r4  r^   r  r   datas
   &$$$$     rg   pad_or_backfillBlock.pad_or_backfillC  s        II5I)**,,W5
 '):):;VV,,!	 - 

 ! 	 Zt<**4*;<<rj   limit_directionforwardc               4    V ^8  d   QhRRRRRRRRR	R
RRRR/# )rb   r  rR   indexrV   rh  rd   r  r  r  z&Literal['forward', 'backward', 'both']r  r  rc   r   re   )rf   s   "rg   rh   ri   _  sS     (= (= #(= 	(=
 (= (= @(= 8(= 
(=rj   c               	   \        VR 4      pVR8X  d   \        P                  ! V4       V P                  '       g   V P	                  RR7      .# V P
                  \        8X  d&   ^R^R/V P                  ,          p\        V R24      hV P                  V4      w  rV P                  P                  ! RRVRV P                  ^,
          R	VR
VRVRVRV	/VB p\        VRR7      pV P                  WR7      .# )rh  asfreqFr*  Series	DataFramez& cannot interpolate with object dtype.r  r  r  r  r  r  r4  Tr   r   re   )r   r0   clean_fill_methodr   r4  rl   rt   r]   r!  rn  r  interpolaterE   r   )rn   r  r  rh  r  r  r  r   r   r4  r^   r   r
  s   &$$$$$$,     rg   r  Block.interpolate^  s    &gy9X%%f-   II5I)**::#xK0;Dtf$JKLL,,W5
 &&22 	
	
Q	
 	
 		

 ,	
 "	
 	
 	

 Zt<**4*;<<rj   c                    V ^8  d   QhRRRR/# )rb   r  r\   rc   r   re   )rf   s   "rg   rh   ri     s     4 4c 4k 4rj   c                    \         P                  ! V P                  P                  V^ R7      P                  pV P	                  VR7      .# )z'return block for the diff of the valuesr  r  )r  diffr[   r  r   )rn   r  r   s   && rg   r  
Block.diff  s8    
 ZZqq9;;
z233rj   c               $    V ^8  d   QhRRRRRR/# rb   periodsr\   r   r   rc   r   re   )rf   s   "rg   rh   ri     s!     ,< ,<S ,<c ,<[ ,<rj   c                   V P                   ^,
          p\        P                  ! V4      '       g!   V P                  \        8w  d   \        R4      hV P                  V4      p \        V P                  V4      p\        \        P                  V P                  4      p\        WQW44      pV P                  V4      .#   \         d    T P                  P                  R9  g   \!        Y P                  4      '       g&   \"        P$                  ! R\&        \)        4       R7       T P+                  TRR7      pTP                  YR7      u # i ; i)z+shift the block by periods, possibly upcastzfill_value must be a scalarr   zshifting 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.
stacklevelFrt  r  )r]   r   r!   rl   rt   rW  r   r   r   r   r  r[   r:   r   r   r   r-   warningswarnr   r   r&  )rn   r  r   r  r  r[   r   r  s   &&&     rg   r:   Block.shift  s    yy1} }}Z((TZZ:-E :;;11*=
	< )

F* "**dkk2Fv=J..z:;;' ! 	<zze+3HJJ4 4 ( #/1 ,,Z,OB88G8;;	<s   "B: :BEEc               $    V ^8  d   QhRRRRRR/# )rb   qsrV   interpolationrS   rc   rZ   re   )rf   s   "rg   rh   ri     s(     > >> -> 
	>rj   c                    V P                   ^8X  g   Q h\        V4      '       g   Q h\        V P                  \        P
                  ! VP                  4      V4      p\        V^R7      p\        W0P                  R7      # )z
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]   r    r6   r[   r   asarray_valuesr   r  r   )rn   r'  r(  r   s   &&& rg   quantileBlock.quantile  sa    * yyA~~B bjj.DmT $F3Fnn==rj   c                    V ^8  d   QhRRRR/# )rb   decimalsr\   rc   r   re   )rf   s   "rg   rh   ri     s     "= "=c "=d "=rj   c                   V P                   '       d   V P                  '       dc   \        V P                  \        \
        \        34      '       d&   \        P                  ! R\        \        4       R7       V P                  RR7      # V P                  P                  V4      pRpW P                  J d   V P                  pV P                  W#R7      # )a(  
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;   r@   r?   r#  r$  UserWarningr   r4  roundr^   r   )rn   r/  r[   r^   s   &&  rg   r3  Block.round  s     $,,,$++~{'STT G/1	 99%9((
 ""8,[[ 99D))&)<<rj   c                   V ^8  d   QhRR/# r   re   )rf   s   "rg   rh   ri     s     . .[ .rj   c                   \        V4      '       g   V.pV P                  ^8X  dt   \        \        P                  V P
                  4      p\        P                  ! W!4      pV P                  P                  V4      p\        V 4      ! W#V P                  R7      .# \        P                  ! V4      V P
                  P                  ^ ,          8  d   \        h\        P                  ! WP
                  P                  ^ ,          ..4      pV P                  P                  p. pRpV P                  P                  4       '       d   V P                  MRpV Fu  pW^,           8X  d   MbV P
                  V^,           V1R3,          pWF^,           V p	\        V 4      ! V\!        V	4      V P                  VR7      p
VP#                  V
4       TpKw  	  V# )zDeletes 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.
r   r]   NrV  r   r   )r    r]   r   r   r  r[   deleter   r   maxr   
IndexErrorconcatenateas_arrayr^   r   r   r  )rn   r  r[   r   mgr_locs_arr
new_blocksprevious_locr^   idxr  r  s   &&         rg   r8  Block.delete  su    C  %C99>"**dkk2FYYv+F~~,,S1HJv		JKK66#;$++++A.. nncKK$5$5a$8#9:;~~.."$
 !II3355tyy4CQ&& \A%5%;Q%>?#1$4s;$ZnT&:QU !!"%L   rj   c                   V ^8  d   QhRR/# ra   re   )rf   s   "rg   rh   ri   6  s     ( ( (rj   c                    \        V 4      h)(return a boolean if I am possibly a viewr   rm   s   &rg   is_viewBlock.is_view5  s     "$''rj   c                   V ^8  d   QhRR/# rb   rc   r<   re   )rf   s   "rg   rh   ri   ;  s     ( (n (rj   c                    \        V 4      h)z@
The array that Series.array returns. Always an ExtensionArray.
rE  rm   s   &rg   r  Block.array_values:      
 "$''rj   c                    V ^8  d   QhRRRR/# rb   rl   DtypeObj | Nonerc   r  re   )rf   s   "rg   rh   ri   A  s     ( ( (: (rj   c                    \        V 4      h)zs
return an internal format, currently just the ndarray
this is often overridden to handle to_dense like operations
rE  r   s   &&rg   
get_valuesBlock.get_valuesA  rL  rj   )r   r[   re   )NNF)TTTTTnumpy_nullable)raiseF)T)FN)FF)TFNFrs   )linear)Kr   
__module____qualname____firstlineno____doc____annotations__	__slots__r1  r	   r   ro   ru   rz   r~   r   r   propertyr   r   r   r   r   setterr   r   r   r   r   r   r   r   r   r   r   r   r  r  r&  r5  r   rl   r"  rG   r4  rj  rn  rx  r  r  r  r  r  r   r  r   r  r   r  r  r  r  r  r  r   r  r  r  r:   r,  r3  r8  rF  r  rQ  __static_attributes__re   rj   rg   rZ   rZ      s    ('
I
IJ
3  3 /  / 6  6 %  % 6  6 "  " 3  3 , , <  <     __& & Q Q" R R 	 	     J J J J 
J 
J 6 6
 ) )" - - + +  *    2 7 7r "8 "8H,b !  ! + +Z 'CH'RV' ' 
W 
W$
   @ @D - -^ Y Yv 7 7z ! !##$ 
 /3>>%H %HN*\=~A"Fe)N"B= 	=
 != ;?=6 (=
 (= !(= CL(= ;?(= (=T 4 4,<\ > >: "= "=N.` ( ( ( (( (rj   rZ   c                     a  ] tR tRt$ RtR]R&   ]RR R ll4       t]R 4       t]R	 R
 l4       t	]R R l4       t
]R V 3R ll4       t]]R R l4       4       t]RR R ll4       t]RRRRRR/R R ll4       tRtV ;t# )EABackedBlockiI  z6
Mixin for Block subclasses backed by ExtensionArray.
r<   r[   Nc               $    V ^8  d   QhRRRRRR/# r  re   )rf   s   "rg   rh   EABackedBlock.__annotate__Q  s!     
8 
8S 
8c 
8[ 
8rj   c                    V P                   P                  P                  WR7      P                  pV P                  V4      .# )zk
Shift the block by `periods`.

Dispatches to underlying ExtensionArray and re-boxes in an
ExtensionBlock.
)r  r   )r[   r  r:   r   )rn   r  r   r   s   &&& rg   r:   EABackedBlock.shiftP  s9     [[]](((PRR
**:677rj   c                   TpTpV P                  V4      pV P                  V4      pV P                  pVP                  ^8X  d   VP                  p\        WV4        W%V&   V #   \        \        3 d    \        T P                  \        4      '       d'   T P                  TRR7      pTP                  Y44      u # \        T \        4      '       d'   T P                  TRR7      pTP                  Y44      u # h i ; i)a  
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.
Trt  )r  r  r[   r]   r  rF   rW  r!  r   rl   r%   r&  r  NDArrayBackedExtensionBlock)rn   r   r   orig_indexer
orig_valuer[   r  s   &&&    rg   r  EABackedBlock.setitem]  s    0 
..w7''.;;! XXFgf5	#7O K I& 	$**m4400T0Rzz,;;D"=>>00T0Rzz,;; 	s   A# #AC8::C86C8c                   V ^8  d   QhRR/# r   re   )rf   s   "rg   rh   rd    s     ? ?K ?rj   c                	(   V P                   P                  p\        V4      pTpTpV P                  V4      pV P                  V4      pV\        P
                  J d   V P                  p\        W2( 4      w  rgV'       d   V P                  R R7      .#  VP                  W!4      P                  pT P;                  T4      pT.#   \         d    h \        \        3 Ed    T P                  ^8X  g   T P                  ^ ,          ^8X  d   \        T P                   \"        \$        34      '       d   T P'                  TR R7      p	T P                  ^8X  dV   \        T\(        P*                  4      '       d6   TP                  ^8X  d%   \-        T	P                   4      '       g
   TR,          pT	P/                  YE4      u # \        T \0        4      '       d'   T P'                  TR R7      p	T	P/                  YE4      u # h \        T\(        P*                  \2        34      p
. p\5        T P7                  4       4       FW  w  rTpT
'       d   TRY^,           13,          pTRY^,           13,          pTP/                  Y4      pTP9                  T4       KY  	  Tu # i ; i)Fr*  rt  rV  rV  N)r[   r  r1   r  r   r  r   r5   r4  _wherer   rW  r!  r]   r   r   rl   r%   rA   r&  r   r  r   r  rh  r<   r   r  r  r   )rn   r#  r  arrr  	orig_condr  r  r   r0  r  r  r  r  r  r  r  s   &&&              rg   r  EABackedBlock.where  s,   kkmm!$'
	''.&&t,CNN"OOE&sE2 II5I)**)	"D022JT ''
3tU # 	I& %	"yyA~A!!3djj=+*FGG55jRW5XC		Q&y"**==%NNa/ 3CII > >$-g$6	99Z;;&ABB 55jRW5XC99Z;;  &j2::~2NO
&t{{}5EA"A&q!!e)|4'11u95G((1.C%%c* 6 "!K%	"s&   C JCJ9:J5BJJc                   V ^8  d   QhRR/# r   re   )rf   s   "rg   rh   rd    s     ; ;K ;rj   c                d   \        V4      pV\        P                  J d   V P                  pTpTpV P	                  V4      pV P	                  V4      pVP                  4       '       g   V P                  RR7      .# V P                  RR7      p V P                  pVP                  ^8X  d   VP                  p VP                  W4       V .#   \         d    h \        \        3 EdH    T P                  ^8X  g   T P                  ^ ,          ^8X  d   \!        T P"                  \$        4      '       d'   T P'                  TRR7      pTP)                  YC4      u # \!        T \*        4      '       d'   T P'                  TRR7      pTP)                  YC4      u # h \!        T\,        P.                  \0        34      p. p\3        T P5                  4       4       FW  w  rTpT'       d   TRY^,           13,          pTRY^,           13,          pT
P)                  Y4      pTP7                  T4       KY  	  Tu # i ; i)z
See Block.putmask.__doc__
Fr*  Tr  rt  rV  )r1   r   r  r   r  rH  r4  rj  r[   r]   r  _putmaskr   r!  rW  r   r   rl   r%   r&  r  rh  r   r  r<   r   r  r  )rn   rq  r  orig_newr  r[   r0  r  r  r  r  r  r  r  s   &&&           rg   r  EABackedBlock.putmask  s   
 "$'#.. //C	%%c*&&t,xxzzII5I)**-;;!XXF$	"OOD&H vG # 	:& 	"yyA~A!!3djj-88 55hPT5UC;;y;;&ABB 55hPT5UC;;y;;  &h^0LM
&t{{}5EA A$QE	\2'11u95G**W0C%%c* 6 "!?	"s&   7C H/'A.H/:H/BH/.H/c                   V ^8  d   QhRR/# r   re   )rf   s   "rg   rh   rd    s     	# 	#[ 	#rj   c                	&  < V P                   ^8X  dU   V P                  P                  V4      pV P                  P                  V4      p\	        V 4      ! W#V P                   R7      .# V P                  P                   ^8X  d   . # \
        SV `	  V4      # )r   r7  )r]   r[   r8  r   r   super)rn   r  r[   r   	__class__s   &&  rg   r8  EABackedBlock.delete  sv     99>[['',F~~,,S1HJv		JKK[["Iw~c""rj   c                   V ^8  d   QhRR/# rI  re   )rf   s   "rg   rh   rd  "  s      n rj   c                	    V P                   # rs   r  rm   s   &rg   r  EABackedBlock.array_values   s     {{rj   c                    V ^8  d   QhRRRR/# rN  re   )rf   s   "rg   rh   rd  &  s     6 6 6: 6rj   c                    V P                   pV\        8X  d   VP                  \        4      p\        P
                  ! V4      P                  V P                  4      # )zC
return object dtype as boxed values, such as Timestamps/Timedelta
)r[   rt   r"  rX   r   r*  r   r   )rn   rl   r[   s   && rg   rQ  EABackedBlock.get_values%  sA    
 !KKJ]]6*Fzz&!))$**55rj   rh  Fr  r  c          
     ,    V ^8  d   QhRRRRRRRRR	R
/# r  re   )rf   s   "rg   rh   rd  1  s>     8 8 8 	8
 8 88 
8rj   c               	   V P                   pR VRV/pR\        P                  ! VP                  4      P                  9   d   WFR&   M%Ve"   \        \        V4      P                   R24      hVP                  ^8X  d(   VP                  P                  ! R/ VB P                  pMVP                  ! R/ VB pV P                  V4      .# )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.re   )r[   inspect	signaturer	  
parametersr  r   r   r]   r  r   )rn   r  rh  r  r  r[   r   r   s   &$$$$   rg   r  EABackedBlock.pad_or_backfill0  s     "*FGU!C7,,V-D-DEPPP#-< #%<(() *A A  ;;!22<V<>>J00:6:J**:677rj   re   rs   )r   rX  rY  rZ  r[  r\  r	   r:   r  r  r  r8  r   r  rQ  r  r`  __classcell__r{  s   @rg   rb  rb  I  s     

8 
8 4 4l ? ?B ; ;z 	# 	#    6 6 8 	8
 !8 ;?8 8rj   rb  c                     a  ] tR tRt$ RtR]R&   RR V 3R lllt]R R l4       tR	 R
 lt	RR R llt
R tR t]R R l4       t]R R l4       tR R lt]R R l4       tR R ltRtV ;t# )r  iM  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               $    V ^8  d   QhRRRRRR/# r  re   )rf   s   "rg   rh   ExtensionBlock.__annotate__[  s/     (C (C (C 	(C
 
(Crj   c                	  < \        V P                  \        \        34      '       dB   \        V P                  \        4      '       d   Ve   \	        R4      h\
        SV `  VVVR7      # V P                  '       d6   V P                  P                  '       g   V P                  pV P                  pM1V P                  V4      w  rd V P                  P                  WVR7      pV P'                  WTR7      .#   \         dh    R pT P                  P                  YR7      p\        P                  ! R\        T P                  4      P                    R2\"        \%        4       R7        Li ; i)	Nzlimit must be None)r   r  rh  )r   r  r4  )r   r  zExtensionArray.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   rl   r%   rA   rW  rz  r   r   r[   _hasnar^   rn  r!  r#  r$  r   r   r   r   r   )rn   r   r  rh  r^   r   r4  r{  s   &&&&   rg   r   ExtensionBlock.fillna[  s>    djj=+">??$**m449J !5667> "  
 T[[%7%7%799DJ009JD![[//et/T
$ **:*ABB#  ![[//e/I
 I DKK(112!	5
 #/1	s   C4 4A/E&%E&c                   V ^8  d   QhRR/# r  re   )rf   s   "rg   rh   r    s     5 5u 5rj   c                	    V P                   ^8X  d   \        V P                  4      3# \        V P                  4      \        V P                  4      3# r   )r]   r   r[   r   rm   s   &rg   r   ExtensionBlock.shape  s>     99>$&&4>>"C$444rj   c                   V ^8  d   QhRR/# )rb   r  r  re   )rf   s   "rg   rh   r    s      ? rj   c                	   \        V\        4      '       d   Vw  r#\        P                  ! V4      '       g   V^ 8w  d   \	        V  R24      h\        V\
        4      '       d9   V^ 8  d   V\        V P                  4      ,          pV P                  W3^,            # V P                  V,          # V^ 8w  d   \	        V  R24      hV P                  # )r   z only contains one item)r   tuplecomis_null_slicer:  r   r   r[   )rn   r  colr  s   &&  rg   r  ExtensionBlock.iget  s     aHC$$S))cQh D6)@!ABB#u%% 73t{{++C {{3q11;;s##Av D6)@!ABB;;rj   c               $    V ^8  d   QhRRRRRR/# r  re   )rf   s   "rg   rh   r    s!        	    $  rj   c                	p    V'       d    V P                   P                  4       V n         W P                   R &   R# rn  r  r  s   &&&&rg   r  ExtensionBlock.set_inplace  s&     ++**,DKArj   c                   \        V\        P                  \        34      '       dR   VP                  V P
                  P                  ^,           8X  d&   VP                  ^,          ^8X  g   Q hVR,          pV# \        V\        4      '       d8   VP                  ^,          ^8X  g   Q hVP                  ^ ^R7      P                  pV# )z0
If necessary, squeeze a (N, 1) ndarray to (N,)
r  rV  r   )
r   r   r  r<   r]   r[   r   r(   _ixsr+  r  s   &&rg   r  !ExtensionBlock._maybe_squeeze_arg  s     sRZZ899DKK,,q00 99Q<1$$$ d)C 
 \** 99Q<1$$$((11(%--C
rj   c                   \        V\        4      '       EdU   \        V4      ^8X  EdD   \        ;QJ d    R V 4       F  '       d   K   RM	  RM! R V 4       4      '       d]   Vw  r#VP                  ^8X  d2   V^ 8H  P                  4       '       d   VP
                  ^,          ^8X  g   \        R4      hVR,          pV# \        P                  ! V^,          4      '       d   V^,          ^ 8X  d   V^ ,          pV# \        P                  ! V^,          4      '       d   V^ ,          pV# \        V^,          4      '       d!   V^,          ^ ,          ^ 8X  d   V^ ,          pV# \        R4      hV# )z_
Adapt a 2D-indexer to our 1D values.

This is intended for 'setitem', not 'iget' or '_slice'.
c              3     "   T F6  p\        V\        P                  4      ;'       d    VP                  ^8H  x  K8  	  R# 5i)rb   N)r   r   r  r]   )r/  r  s   & rg   r1  9ExtensionBlock._unwrap_setitem_indexer.<locals>.<genexpr>  s.     Ng:a,<<1<gs
   %A A FTzPThis should not be reached. Please report a bug at github.com/pandas-dev/pandas/r  )r   r  r   r6  sizer   r  r   
is_integerr  r  r    )rn   r   firstseconds   &&  rg   r  &ExtensionBlock._unwrap_setitem_indexer  s9    gu%%#g,!*;
 sNgNsssNgNNN 'KK1$&A+):):)<)<QSTAT-8   +"  
++
a!!*  ""71:..!!*  gaj))gajmq.@!!* 	 *4  rj   c                   V ^8  d   QhRR/# ra   re   )rf   s   "rg   rh   r    s       rj   c                    R# )z,Extension arrays are never treated as views.Fre   rm   s   &rg   rF  ExtensionBlock.is_view  s     rj   c                   V ^8  d   QhRR/# ra   re   )rf   s   "rg   rh   r    s     - -D -rj   c                	B    V P                   P                  P                  # rs   )r[   rl   _is_numericrm   s   &rg   r1  ExtensionBlock.is_numeric  s    {{  ,,,rj   c                    V ^8  d   QhRRRR/# )rb   r   r  rc   r<   re   )rf   s   "rg   rh   r    s     &# &#J&#	&#rj   c                   V P                   ^8X  d]   \        V\        4      '       g   \        RV4      h\	        ^4      V,          p\        V4      '       g   \        RV4      h\        R4      pV P                  V,          # )z
Return a slice of my values.

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

Returns
-------
ExtensionArray
z+invalid slicing for a 1-ndim ExtensionArrayN)r]   r   r   r  ranger   r[   )rn   r   new_locss   && rg   r   ExtensionBlock._slice  su    & 99> fe,,$A6  Qx'Hx==$A6  4[F{{6""rj   c                    V ^8  d   QhRRRR/# )rb   r   r   rc   r   re   )rf   s   "rg   rh   r  "  s     V Vu V Vrj   c                    V P                   V,          p\        V 4      ! W P                  V P                  V P                  R7      # )z>
Perform __getitem__-like specialized to slicing along index.
)r]   r^   )r[   r   r   r]   r^   )rn   r   r   s   && rg   slice_block_rowsExtensionBlock.slice_block_rows!  s1     [[(
Dz*nn499499UUrj   c                    V ^8  d   QhRRRR/# r  re   )rf   s   "rg   rh   r  +  s      ) ) ,	)
 -)rj   c                	>   VP                   w  rVVP                  V,          pW6,          p\        \        WSR R7      4       UUU	u. uFG  w  pw  r\	        V 4      ! V P
                  P                  WV,          VR7      \        V	4      ^R7      NKI  	  p
ppp	W3# u up	ppi )TrE  )r  r   r   )arange_resultr  r   rJ  r   r[   taker   )rn   r  r   r  r  r   rq  r  r   placer9  s   &&&&&      rg   r  ExtensionBlock._unstack+  s     %22
  \\$'
%+ (1Jd;(
(##G J  a(8Z !  u%( 	 
 |
s   ABr  rV  rS  )r   rX  rY  rZ  r[  r\  r   r   r   r  r  r  r  r^  rF  r1  r   r	   r  r  r`  r  r  s   @rg   r  r  M  s    	 (C (CT 5 58 ,(T  
 - -&#P V V) )rj   r  c                  x    ] tR tRt$ R]R&   Rt]R R l4       t]R R l4       tRR	 R
 llt	]
R R l4       tRtR# )
NumpyBlockiW  r  r[   c                   V ^8  d   QhRR/# ra   re   )rf   s   "rg   rh   NumpyBlock.__annotate__\  s     , , ,rj   c                2    V P                   P                  RJ# rD  N)r[   baserm   s   &rg   rF  NumpyBlock.is_view[  s     {{t++rj   c                   V ^8  d   QhRR/# rI  re   )rf   s   "rg   rh   r  a  s     0 0n 0rj   c                	,    \        V P                  4      # rs   )r>   r[   rm   s   &rg   r  NumpyBlock.array_values`  s    "4;;//rj   Nc                    V ^8  d   QhRRRR/# rN  re   )rf   s   "rg   rh   r  d  s       : rj   c                	n    V\         8X  d    V P                  P                  \         4      # V P                  # rs   )rt   r[   r"  r   s   &&rg   rQ  NumpyBlock.get_valuesd  s)    J;;%%j11{{rj   c                   V ^8  d   QhRR/# ra   re   )rf   s   "rg   rh   r  j  s      D rj   c                	P    V P                   P                  pVP                  pVR 9   # )fciub)r[   rl   r   )rn   rl   r   s   &  rg   r1  NumpyBlock.is_numerici  s$    !!zzwrj   re   rs   )r   rX  rY  rZ  r\  r]  r^  rF  r  rQ  r   r1  r`  re   rj   rg   r  r  W  sL    I, , 0 0
  rj   r  c                  <    ] tR tRt$ RtR]R&   ]R R l4       tRtR# )	rh  iq  z0
Block backed by an NDArrayBackedExtensionArray
rW   r[   c                   V ^8  d   QhRR/# ra   re   )rf   s   "rg   rh   (NDArrayBackedExtensionBlock.__annotate__y  s     5 5 5rj   c                F    V P                   P                  P                  RJ# r  )r[   r8  r  rm   s   &rg   rF  #NDArrayBackedExtensionBlock.is_viewx  s     {{##((44rj   re   N)	r   rX  rY  rZ  r[  r\  r^  rF  r`  re   rj   rg   rh  rh  q  s!     ('5 5rj   rh  c                  .    ] tR tRt$ RtRtRtR]R&   RtR# )DatetimeLikeBlocki  z*Block for datetime64[ns], timedelta64[ns].FzDatetimeArray | TimedeltaArrayr[   re   N)	r   rX  rY  rZ  r[  r]  r1  r\  r`  re   rj   rg   r  r    s    4IJ**rj   r  c                    V ^8  d   QhRRRR/# rb   r[   rL   rc   re   )rf   s   "rg   rh   rh     s      	 i rj   c                ^   \        V \        P                  4      '       dR   \        V 4      p \	        V P
                  P                  \        4      '       d   \        P                  ! V \        R7      p \        V \        \        34      '       d    V P                  e   V P                  R4      p V # )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   N)r   r   r  rD   
issubclassrl   r   r   r  rX   r;   r@   freq
_with_freqr  s   &rg   r   r     sv      &"**%%/7fll''--XXfF3F&=.9::v{{?V""4(Mrj   c                    V ^8  d   QhRRRR/# )rb   rl   rO   rc   ztype[Block]re   )rf   s   "rg   rh   rh     s      ( { rj   c                    \        V \        4      '       d   \        # \        V \        4      '       d   \        # \        V \
        4      '       d   \        # V P                  pVR9   d   \        # \        # )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#   r  r'   rh  r$   r  r   r  r.  s   & rg   get_block_typer    s[     %))  	E;	'	'**	E>	*	* ::Dt|  rj   c               (    V ^8  d   QhRRRRRRRR/# )	rb   r[   rL   r   r   r^   r   rc   rZ   re   )rf   s   "rg   rh   rh     s2     
A 
A
A"0
A8N
A

Arj   c                X    \        V P                  4      p\        V 4      p V! V ^WR7      # )rb   r]   r   r^   )r  rl   r   )r[   r   r^   klasss   &&& rg   r  r    s+     6<<(E (Fa9@@rj   r^   c               (    V ^8  d   QhRRRRRRRR/# )	rb   r   r   r]   r\   r^   r   rc   rZ   re   )rf   s   "rg   rh   rh     s8     D DD 	D
 !D Drj   c               @    \        V P                  4      pV! WWR 7      # )r  )r  rl   )r[   r   r]   r^   r  s   &&$$ rg   r   r     s     6<<(EiCCrj   c               $    V ^8  d   QhRRRRRR/# )rb   r   r   r]   r\   rc   r   re   )rf   s   "rg   rh   rh     s!     &* &*. &* &* &*rj   c                   V P                   V8  d   \        RV P                    RV R24      h\        V P                  4      '       gl   V P                   V8w  d   \        RV P                    RV R24      h\	        V4      \	        V 4      8w  d$   \        R\	        V 4       R\	        V4       24      hR	# V^8X  d   \	        V4      ^8w  d   \        R4      hR	# R	# )
a&  
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 zneed to splitN)r]   rW  r   rl   r   )r[   r   r]   s   &&&rg   
check_ndimr    s    $ {{T>v{{m3tfTUV
 	
 v||,,;;$((.}DaA  y>S[(/F} =%%(^$46  )
 
s9~*)) +rj   c               (    V ^8  d   QhRRRRRRRR/# )	rb   r[   rL   rl   rO  r]   r\   rc   z!tuple[ArrayLike, DtypeObj | None]re   )rf   s   "rg   rh   rh   
	  s,      -58&rj   c                    \        V \        4      '       d6   V P                  4       p V'       d   V^8  d   \        P                  ! V 4      p \        V\
        4      '       d   VP                  pW3# )zM
Ensure that we don't allow NumpyExtensionArray / NumpyEADtype in internals.
)r   r*   to_numpyr   
atleast_2dr&   numpy_dtype)r[   rl   r]   s   &&&rg   extract_pandas_arrayr  
	  sU     &011"D1H]]6*F%&&!!=rj   c                   V ^8  d   QhRR/# r   re   )rf   s   "rg   rh   rh    	  s      + rj   c                6   Vf   . p\        V \        4      '       dF   V  F=  p\        V\        4      '       d   VP                  V4       K,  VP                  V4       K?  	  V# \        V \        4      '       g   Q \        V 4      4       hVP                  V 4       V# )z.return a new extended blocks, given the result)r   rI  r  r  rZ   r   )r   r9  rs   && rg   r  r   	  s~    ~&$A!T""a a 	  M &%((6$v,6(fMrj   c               $    V ^8  d   QhRRRRRR/# )rb   r[   rL   r]   r\   rc   re   )rf   s   "rg   rh   rh   0	  s!      y  I rj   c                    V P                   V8  d:   \        V P                  4      '       g   \        RV 4      p V P	                  ^R4      p V # )z2
Reshape if possible to have values.ndim == ndim.
z+np.ndarray | DatetimeArray | TimedeltaArrayr   )r]   r   rl   r   r   )r[   r]   s   &&rg   r   r   0	  sC    
 {{T"6<<00 GPF^^Ar*FMrj   c                    V ^8  d   QhRRRR/# r  re   )rf   s   "rg   rh   rh   @	  s      I ) rj   c                @   \        V \        \        34      '       d   V P                  \        4      # \        V \
        \        34      '       d   V P                  p \        V \        P                  4      '       d$   V P                  4       p RV P                  n        V #  V # )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   r?   r=   r"  rX   r;   r@   r8  r   r  re  flags	writeabler  s   &rg   r   r   @	  s{     &;677}}V$$	F]N;	<	< &"**%%!& M 	Mrj   rs   r  )
__future__r   r  r|  typingr   r   r   r   r   r	   r#  numpyr   pandas._libsr
   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   pandas.core.dtypes.commonr   r   r   r    r!   r"   pandas.core.dtypes.dtypesr#   r$   r%   r&   r'   pandas.core.dtypes.genericr(   r)   r*   r+   pandas.core.dtypes.inferencer,   pandas.core.dtypes.missingr-   r.   r/   pandas.corer0   pandas.core.algorithmscore
algorithmsr  pandas.core.array_algos.putmaskr1   r2   r3   r4   r5    pandas.core.array_algos.quantiler6   pandas.core.array_algos.replacer7   r8   r9   "pandas.core.array_algos.transformsr:   pandas.core.arraysr;   r<   r=   r>   r?   r@   pandas.core.arrays.string_rA   pandas.core.baserB   pandas.core.commoncommonr  pandas.core.computationrC   pandas.core.constructionrD   rE   pandas.core.indexersrF   pandas.core.indexes.baserG   collections.abcrH   rI   rJ   rK   pandas._typingrL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   pandas.core.apirV   pandas.core.arrays._mixinsrW   rl   rt   rZ   rb  r  r  rh  r  r   r  r  r   r  r  r  r   r   re   rj   rg   <module>r%     s   "  	    
 $ 
 3 4 7     /    & &  = 
 5  3 )     / 7 7    &F XXh
|(L,,, |(~-A8E A8HG] GT 45- 5+3 +::
AD
 $(D&*R,  rj   