
    MhJ                    $   S SK Jr  S SKJrJr  S SKrS SKrS SKJ	r	J
rJrJr  S SKJr  S SKJr  S SKJr  S SKJrJr  S S	KJrJrJr  S S
KJr  S SKJrJ r   S SK!J"r"J#r#J$r$  S SK%J&r&  S SK'J(r(  S SK)J*r*J+r+  S SK,J-r-J.r.  \(       a"  S SK/J0r0  S SK1J2r2J3r3J4r4J5r5J6r6  S SK7J8r8  S SK)J9r9J:r:          S"S jr;        S#S jr<        S$S jr=S%S jr>      S&S jr?    S'S jr@          S(S jrA " S S5      rBS)S jrCS*S jrDS+S  jrES,S! jrFg)-    )annotations)TYPE_CHECKINGcastN)NaTalgos	internalslib)NA)cache_readonly)find_stack_level)ensure_dtype_can_hold_nafind_common_type)is_1d_only_ea_dtype	is_scalarneeds_i8_conversion)concat_compat)ExtensionDtypeSparseDtype)is_valid_na_for_dtypeisnaisna_all)ensure_wrapped_if_datetimelike)ArrayManager)ensure_block_shapenew_block_2d)BlockManagermake_na_array)Sequence)	ArrayLikeAxisIntDtypeObj	Manager2DShape)Index)BlockBlockPlacementc                n    US:X  a  U S   R                  X5      $ US:X  d   eU S   R                  X5      $ )z
Concatenate array managers into one.

Parameters
----------
mgrs_indexers : list of (ArrayManager, {axis: indexer,...}) tuples
axes : list of Index
concat_axis : int

Returns
-------
ArrayManager
   r   )concat_verticalconcat_horizontal)mgrsaxesconcat_axiss      N/var/www/html/env/lib/python3.13/site-packages/pandas/core/internals/concat.py_concatenate_array_managersr/   F   sF      aAw&&t22 aAw((44    c                J  ^ U=(       a    US:H  n[        U S   S   [        5      (       a  [        XU5      n[        XQU5      $ US:X  a   [        XU5      nUS   R	                  XQ5      $ [        U 5      S:  a  U S   S   R                  S:  a  U S   S   R                  S   R                  mT[        R                  [        R                  4;   aT  [        U4S jU  5       5      (       a:  [        U 5      S:  a+  [        S U 5       5      n[        XT5      n[        U4U5      $ [        XU5      n[        U5      S:X  a  US   nUR!                  SS9n	Xl        U	$ [%        U5      n
/ nU
 GH  u  pUS   nUR&                  n[)        U5      (       a  U Vs/ s H  nUR&                  R*                  PM     nnUR,                  (       d  [        R.                  " USS9nO:[1        UR                  5      (       a  [3        USSS	9n[5        US
S9nO
[3        USS9n[7        U5      nUR*                  R                  UR                  :H  nO[9        XS9nSnU(       a  UR;                  UUS9nO
[=        UUS9nUR?                  U5        GM     [        [        U5      U5      $ s  snf )z
Concatenate block managers into one.

Parameters
----------
mgrs_indexers : list of (BlockManager, {axis: indexer,...}) tuples
axes : list of Index
concat_axis : int
copy : bool

Returns
-------
BlockManager
r   c              3  @   >#    U  H  u  p[        UT5      v   M     g 7fN)_is_homogeneous_mgr).0mgr_first_dtypes      r.   	<genexpr>'concatenate_managers.<locals>.<genexpr>   s     Vfc'[99s   r(   c              3  8   #    U  H  n[        U5      v   M     g 7fr3   )len)r5   xs     r.   r9   r:      s     3dc!ffd   F)deepaxisTrA   ea_compat_axis   )ndim)copy)	placement) 
isinstancer   _maybe_reindex_columns_na_proxyr/   r*   r<   nblocksblocksdtypenpfloat64float32alltuple_concat_homogeneous_fastpathr   rF   r,   _get_combined_planblock_is_uniform_join_unitsvaluesis_extensionconcatenater   r   r   r   _concatenate_join_unitsmake_block_same_classr   append)mgrs_indexersr,   r-   rF   
needs_copyr+   shapenbr6   outconcat_planrK   rG   
join_unitsunitblkjuvalsrV   fastpathbr8   s                        @r.   concatenate_managersri   ^   s{   $ *+*J -"1%|44.tJO +
 	
 a.tJOAw((44
=A-"21"5"="="A#A&q)003992::rzz22 VVVV&* 3d331-T#RE400*4
KD
4yA~1ghhEh"
$T*KF "-	!}jj!*--.89jBHHOOjD9## 15$SYY//&t!DI+F;&t!43F;Fzz''6<<7H,ZCFH))&I)FAVy9AaG "-J ft,,A :s    J c                    / nU Hf  u  pEUR                  5        H  u  pgUR                  X   XV   USSSSS9nM      U(       a  U(       d  UR                  5       nUR                  U5        Mh     U$ )z
Reindex along columns so that all of the BlockManagers being concatenated
have matching columns.

Columns added in this reindexing have dtype=np.void, indicating they
should be ignored when choosing a column's final dtype.
FT)rA   rF   
only_slice
allow_dupsuse_na_proxy)itemsreindex_indexerrF   r[   )r,   r\   r]   new_mgrsr6   indexersiindexers           r.   rI   rI      s}     H& #..*JA%%! & C + h((*C! '" Or0   c                    U R                   S:w  a  gU R                  S   nUR                  R                  (       a$  UR                  R                  R
                  S:X  d  gUR                  U:H  $ )z;
Check if this Manager can be treated as a single ndarray.
r(   Fr   )rJ   rK   mgr_locsis_slice_likeas_slicesteprL   )r6   r8   rd   s      r.   r4   r4      sV     {{a
**Q-CLL&&3<<+@+@+E+E+J99##r0   c           	     (   [        S U  5       5      (       a  U  VVs/ s H(  u  p4UR                  S   R                  R                  PM*     nnn[        R
                  " U5      R                  n[        R                  " [        US   5      5      n[        Xg5      nU$ [        R                  " XS9nU[        R                  :X  a  [        R                  n	O[        R                  n	Sn
U  Hp  u  p;UR                  S   nX-   nSU;   a-  U	" UR                  S   R                  US   USS2X24   5        O!UR                  S   R                  USS2X24'   X-  n
Mr     [        R                  " [        US   5      5      n[        Xg5      nU$ s  snnf )z`
With single-Block managers with homogeneous dtypes (that can already hold nan),
we avoid [...]
c              3  4   #    U  H  u  pU(       + v   M     g 7fr3    )r5   r7   rq   s      r.   r9   /_concat_homogeneous_fastpath.<locals>.<genexpr>  s     
9=KAx<<=s   r   )rL   r(   N)rP   rK   rV   TrM   rX   libinternalsr&   slicer   emptyrN   libalgostake_2d_axis0_float64_float64take_2d_axis0_float32_float32r^   )r\   r^   r8   r6   r7   arrsarrbpr_   	take_funcstartrq   mgr_lenends                 r.   rR   rR      s\    
9=
9995BC]63

1$$&&]CnnT"$$((uQx9#"	
((5
,Cbjj ::	::	E&))A,o=

1$$AuyL! !$

1 4 4C59 '  
	$	$U58_	5B	c	BIA Ds   /Fc           	     l   / nU S   R                   S   nU  Vs/ s H  o3R                  PM     nn[        R                  " U5      n[	        U5       HZ  u  nu  px/ n	[	        U 5       H/  u  pXz   n[        X8XS9n[        U5      nU	R                  U5        M1     UR                  X45        M\     U$ s  snf )Nr   )max_len)r^   blknosr~   get_concat_blkno_indexers	enumerate_get_block_for_concat_planJoinUnitr[   )r+   planr   r6   blknos_listpairsindr   r   units_for_bpkblknor_   rc   s                 r.   rS   rS   (  s     D1gmmAG)-.#::K.22;?E&u-\f oFAIE+CULBB<D% & 	R&' . K! /s   B1c                  U R                   U   n[        U5      [        UR                  5      :X  aC  UR                  R                  (       a(  UR                  R                  R
                  S:X  a  UnU$ U R                  UR                     n[        R                  " Xc5      n[        U[        5      (       a  UR                  U5      nU$ UR                  U5      nU$ )Nr(   )rK   r<   ru   rv   rw   rx   blklocsrs   r	   maybe_indices_to_slicerH   r   slice_block_columnstake_block_columns)r6   r   r   r   rd   r_   ax0_blk_indexerslcs           r.   r   r   B  s     **U
C 2w#cll##""s||'<'<'A'AQ'F I ++bjj1((B c5!!((-B
 I '',B Ir0   c                  d    \ rS rSrS
S jrSS jrSS jr\SS j5       r\SS j5       r	SS jr
Srg	)r   i^  c                    Xl         g r3   rT   )selfrT   s     r.   __init__JoinUnit.__init___  s    
r0   c                ^    [        U 5      R                   S[        U R                  5       S3$ )N())type__name__reprrT   )r   s    r.   __repr__JoinUnit.__repr__b  s*    t*%%&aTZZ(8'9;;r0   c                  ^ U R                   (       d  gU R                  nUR                  R                  S:X  a  gUR                  [        :X  a.  UR
                  n[        U4S jUR                  SS9 5       5      $ UR                  nU[        L a  UR                  T:w  a  gU[        L a  [        T5      (       a  g[        UT5      $ )z
Check that we are all-NA of a type/dtype that is compatible with this dtype.
Augments `self.is_na` with an additional check of the type of NA values.
FVTc              3  <   >#    U  H  n[        UT5      v   M     g 7fr3   )r   )r5   r=   rL   s     r.   r9   ,JoinUnit._is_valid_na_for.<locals>.<genexpr>s  s     X@W1,Q66@Ws   K)order)is_narT   rL   kindobjectrV   rP   ravel
fill_valuer   r
   r   r   )r   rL   rd   rV   na_values    `   r.   _is_valid_na_forJoinUnit._is_valid_na_fore  s    
 zzjj99>>S 99ZZFXSV@WXXX>>s?syyE1 r>1%88  %Xu55r0   c                   U R                   nUR                  R                  S:X  a  gUR                  (       d  gUR                  nUR
                  S:X  a  g[        UR                  [        5      (       a  gUR                  S:X  a1  US   n[        U5      (       a  [        U5      (       d  g[        U5      $ US   S   n[        U5      (       a  [        U5      (       d  g[        S U 5       5      $ )Nr   TFr   r(   c              3  8   #    U  H  n[        U5      v   M     g 7fr3   )r   )r5   rows     r.   r9   !JoinUnit.is_na.<locals>.<genexpr>  s     7x}}r>   )rT   rL   r   _can_hold_narV   sizerH   r   rE   r   r   r   rP   )r   rd   rV   vals       r.   r   JoinUnit.is_na  s    jj99>>S ;;!fllK00;;!)CS>>cF##)A,CS>>c7777r0   c                R    U R                   nUR                  R                  S:X  a  gg)zc
Will self.is_na be True after values.size == 0 deprecation and isna_all
deprecation are enforced?
r   TFrT   rL   r   )r   rd   s     r.   )is_na_after_size_and_isna_all_deprecation2JoinUnit.is_na_after_size_and_isna_all_deprecation  s#     jj99>>S r0   c                   Uc:  U R                   R                  R                  S:w  a  U R                   R                  $ UnU R	                  U5      (       a  U R                   R                  nU[
        R                  " S5      :X  aG  [        [
        R                  U R                   R                  5      nUR                  (       a  US   c  S n[        XR                   R                  U5      $ U R                   R                  $ )Nr   r   )r   r   )rT   rL   r   rV   r   rM   r   ndarrayr   r   r^   )r   empty_dtypeupcasted_nar   	blk_dtyperV   s         r.   get_reindexed_valuesJoinUnit.get_reindexed_values  s     4::#3#3#8#8C#?::$$$$J$$[11 JJ,,	 22 ""**djj.?.?@F{{vd|';%)
$[**2B2BJOO::$$$r0   r   N)rT   r%   returnNone)r   str)rL   r!   r   bool)r   r   )r   r!   r   r   )r   
__module____qualname____firstlineno__r   r   r   r   r   r   r   __static_attributes__r{   r0   r.   r   r   ^  s?    <6@ 8 8<  %r0   r   c                   [        U 5      u  p#[        S U  5       5      n[        X$5      nU  Vs/ s H  nUR                  X%S9PM     nn[        S U 5       5      (       aM  U Vs/ s H(  n[	        UR
                  5      (       a  UOUSSS24   PM*     nn[        USSS9n	[        U	S5      n	O
[        US	S
9n	X#:w  a1  X)R
                  :X  a"  [        R                  " S[        [        5       S9  U	$ s  snf s  snf )z:
Concatenate values from several join units along axis=1.
c              3  f   #    U  H'  oR                   R                  R                  S :H  v   M)     g7fr   Nr   r5   rc   s     r.   r9   *_concatenate_join_units.<locals>.<genexpr>  #     N:4****//36:   /1)r   r   c              3  L   #    U  H  n[        UR                  5      v   M     g 7fr3   )r   rL   )r5   ts     r.   r9   r     s     
;Aqww''s   "$r   NTrB   rD   r(   r@   a  The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.)
stacklevel)_get_empty_dtypeany_dtype_to_na_valuer   r   rL   r   r   warningswarnFutureWarningr   )
rb   rF   r   empty_dtype_futurehas_none_blocksr   re   	to_concatr   concat_valuess
             r.   rY   rY     s     '7z&B#KN:NNO$[BK B 	KQ  
 
;
;;; 	
  #177++ 1a4 	 	 
 &iaM*=!< &ia8(---MM(
 +- E
s   C0%/C5c                   [        U [        5      (       a  U R                  $ U R                  S;   a  U R	                  S5      $ U R                  S;   a  U R	                  S5      $ U R                  S:X  a  gU R                  S;   a  U(       d  g[
        R                  $ U R                  S:X  a  [
        R                  $ [        e)	z*
Find the NA value to go with this dtype.
mMr   fcNaNrh   NiuO)rH   r   r   r   r   rM   nanNotImplementedError)rL   r   s     r.   r   r     s     %((~~	t	zz%  	t	zz%  	s		t	vv	s	vv
r0   c                :   [         R                  " U  Vs/ s H  oR                  R                  PM     sn5      (       a  U S   R                  R                  nX"4$ [	        S U  5       5      nU  Vs/ s H+  oDR
                  (       a  M  UR                  R                  PM-     nn[        U5      (       dK  U  Vs/ s H>  oDR                  R                  R                  S:w  d  M(  UR                  R                  PM@     nn[        U5      nU(       a  [        U5      nUn[        U5      [        U 5      :w  a  U  Vs/ s H,  nUR                  (       a  M  UR                  R                  PM.     nn[        U5      (       dK  U  Vs/ s H>  oDR                  R                  R                  S:w  d  M(  UR                  R                  PM@     nn[        U5      [        U5      :w  a  [        U5      nU(       a  [        U5      nXg4$ s  snf s  snf s  snf s  snf s  snf )z
Return dtype and N/A values to use when concatenating specified units.

Returned N/A value may be None which means there was no casting involved.

Returns
-------
dtype
r   c              3  f   #    U  H'  oR                   R                  R                  S :H  v   M)     g7fr   r   r   s     r.   r9   #_get_empty_dtype.<locals>.<genexpr>  r   r   r   )r	   dtypes_all_equalrT   rL   r   r   r<   r   r   r   r   )	rb   re   r   r   rc   dtypesrL   dtype_futuredtypes_futures	            r.   r   r     s    jAjXX^^jABB m))//''N:NNO+5H:4ZZdjj:FHv;;)3
)3zz7G7G7L7LPS7SDJJ 	 
 V$E(/L
6{c*o% #
"AA DJJ" 	 

 =!!-7-7T::;K;K;P;PTW;W 

  Z   v;#m,,+M:L7EC B I

s5   H2H	
H	:'H%H<HH'H0Hc                   ^ U S   R                   mTR                  R                  S:X  a  g[        U4S jU  5       5      =(       a.    [        U4S jU  5       5      =(       a    [        S U  5       5      $ )z
Check if the join units consist of blocks of uniform type that can
be concatenated using Block.concat_same_type instead of the generic
_concatenate_join_units (which uses `concat_compat`).

r   r   Fc              3  d   >#    U  H%  n[        UR                  5      [        T5      L v   M'     g 7fr3   )r   rT   r5   re   firsts     r.   r9   )_is_uniform_join_units.<locals>.<genexpr>H  s"     ?JbDNd5k)Js   -0c              3     >#    U  HR  nUR                   R                  TR                  :H  =(       d#    UR                   R                  R                  S ;   v   MT     g7f)iubNr   r   s     r.   r9   r   K  sO      

 !	 HHNNekk) , xx~~""e+, !s   AAc              3  |   #    U  H2  oR                   (       + =(       d    UR                  R                  v   M4     g 7fr3   )r   rT   rW   )r5   re   s     r.   r9   r   U  s&     GJbL1BHH111Js   :<)rT   rL   r   rP   )rb   r   s    @r.   rU   rU   <  ss     qME{{3 	?J?? 	H 	 

 !
 	
	H 	GJGGr0   )r+   zlist[ArrayManager]r,   list[Index]r-   r    r   r"   )r,   r  r-   r    rF   r   r   r"   )r,   r  r\   z0list[tuple[BlockManager, dict[int, np.ndarray]]]r]   r   r   list[BlockManager])r6   r   r8   r!   r   r   )r^   r#   r8   znp.dtyper   r%   )r+   r  r   z+list[tuple[BlockPlacement, list[JoinUnit]]])
r6   r   r   r&   r   intr   r  r   r%   )rb   list[JoinUnit]rF   r   r   r   )rL   r!   r   r   )rb   zSequence[JoinUnit]r   ztuple[DtypeObj, DtypeObj])rb   r  r   r   )G
__future__r   typingr   r   r   numpyrM   pandas._libsr   r   r   r   r~   r	   pandas._libs.missingr
   pandas.util._decoratorsr   pandas.util._exceptionsr   pandas.core.dtypes.castr   r   pandas.core.dtypes.commonr   r   r   pandas.core.dtypes.concatr   pandas.core.dtypes.dtypesr   r   pandas.core.dtypes.missingr   r   r   pandas.core.constructionr   #pandas.core.internals.array_managerr   pandas.core.internals.blocksr   r   pandas.core.internals.managersr   r   collections.abcr   pandas._typingr   r    r!   r"   r#   pandasr$   r%   r&   r/   ri   rI   r4   rR   rS   r   r   rY   r   r   rU   r{   r0   r.   <module>r     s~   "    $ 2 4 
 4  D <
 (  5
5$/5>E550i-$i-3:i-BFi-i-X
C  	D
$,,.6,
,^
04	)25CF
8h% h%V+\.+\r0   