
    OwgJ                       d dl mZ d dlmZmZ d dlZd dlZd dlm	Z	m
ZmZmZ d dlmZ d dlmZ d dlmZ d dlmZmZ d d	lmZmZmZ d d
lmZ d dlmZm Z  d dl!m"Z"m#Z#m$Z$ d dl%m&Z& d dl'm(Z( d dl)m*Z*m+Z+ d dl,m-Z-m.Z. er"d dl/m0Z0 d dl1m2Z2m3Z3m4Z4m5Z5m6Z6 d dl7m8Z8 d dl)m9Z9m:Z: 	 	 	 	 	 	 	 	 d"dZ;	 	 	 	 	 	 	 	 d#dZ<	 	 	 	 	 	 	 	 d$dZ=d%dZ>	 	 	 	 	 	 d&dZ?	 	 	 	 d'dZ@	 	 	 	 	 	 	 	 	 	 d(dZA G d d      ZBd)dZCd*dZDd+d ZEd,d!ZFy)-    )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    |dk(  r| d   j                  | |      S |dk(  sJ | d   j                  | |      S )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      S/var/www/horilla/myenv/lib/python3.12/site-packages/pandas/core/internals/concat.py_concatenate_array_managersr/   F   sJ      aAw&&tT22 aAw((t44    c                *   |xr |dk(  }t        | d   d   t              rt        || |      }t        |||      S |dk(  r"t        || |      }|d   j	                  ||      S t        |       dkD  r| d   d   j                  dkD  r| d   d   j                  d   j                  t        j                  t        j                  fv rNt        fd| D              r:t        |       dkD  r,t        d |D              }t        | |      }t        |f|      S t        || |      }t        |      dk(  r |d   }|j!                  d      }	||	_        |	S t%        |      }
g }|
D ]  \  }}|d   }|j&                  }t)        |      r|D cg c]  }|j&                  j*                   }}|j,                  st        j.                  |d      }n>t1        |j                        rt3        |dd	      }t5        |d
      }nt3        |d      }t7        |      }|j*                  j                  |j                  k(  }nt9        ||      }d}|r|j;                  ||      }nt=        ||      }|j?                  |        t        t        |      |      S c c}w )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  <   K   | ]  \  }}t        |        y wN)_is_homogeneous_mgr).0mgr_first_dtypes      r.   	<genexpr>z'concatenate_managers.<locals>.<genexpr>   s     Vfc1'[9Vs   r(   c              3  2   K   | ]  }t        |        y wr3   )len)r5   xs     r.   r9   z'concatenate_managers.<locals>.<genexpr>   s     3c!f3   F)deepaxisTr@   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   rE   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-   rE   
needs_copyr+   shapenbr6   outconcat_planrJ   rF   
join_unitsunitblkjuvalsrU   fastpathbr8   s                        @r.   concatenate_managersrh   ^   s   $ *+*J -"1%|4.t]JO +$
 	
 a.t]JOAw((t44
=A-"21"5"="="A#A&q)003992::rzz22 VVV&* 3d331-T#RE400*4
KD
4yA~1ghhEh"
$T*KF "- #	:!}jj!*-.89BHHOO9D9## 15$SYY/&t!DI+F;&t!43F;Fzz''6<<7H,ZdCFH))&I)FAVy9AaG#J ft,,A :s   Jc                    g }|D ]`  \  }}|j                         D ]#  \  }}|j                  | |   ||   |dddd      }% |r|s|j                         }|j                  |       b |S )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)r@   rE   
only_slice
allow_dupsuse_na_proxy)itemsreindex_indexerrE   rZ   )r,   r[   r\   new_mgrsr6   indexersiindexers           r.   rH   rH      s     H& X #..* 		JAw%%Q! & C		 h((*C!" Or0   c                    | j                   dk7  ry| j                  d   }|j                  j                  r#|j                  j                  j
                  dk(  sy|j                  |k(  S )zC
    Check if this Manager can be treated as a single ndarray.
    r(   Fr   )rI   rJ   mgr_locsis_slice_likeas_slicesteprK   )r6   r8   rc   s      r.   r4   r4      sV     {{a
**Q-CLL&&3<<+@+@+E+E+J99##r0   c           	        t        d | D              r| D cg c](  \  }}|j                  d   j                  j                  * }}}t	        j
                  |      j                  }t        j                  t        |d               }t        ||      }|S t	        j                  ||      }|t        j                  k(  rt        j                  }	nt        j                  }	d}
| D ]r  \  }}|j                  d   }|
|z   }d|v r. |	|j                  d   j                  |d   |dd|
|f          n"|j                  d   j                  |dd|
|f<   |
|z  }
t t        j                  t        |d               }t        ||      }|S c c}}w )zl
    With single-Block managers with homogeneous dtypes (that can already hold nan),
    we avoid [...]
    c              3  (   K   | ]
  \  }}|   y wr3    )r5   r7   rp   s      r.   r9   z/_concat_homogeneous_fastpath.<locals>.<genexpr>  s     
9KAxx<
9s   r   )rK   r(   N)rO   rJ   rU   TrL   rW   libinternalsr&   slicer   emptyrM   libalgostake_2d_axis0_float64_float64take_2d_axis0_float32_float32r]   )r[   r]   r8   r6   r7   arrsarrbpr^   	take_funcstartrp   mgr_lenends                 r.   rQ   rQ      so    
9=
995BC63

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

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

1 4 4C59  
	$	$U58_	5B	c2	BIA Ds   -F	c                p   g }| d   j                   d   }| D cg c]  }|j                   }}t        j                  |      }t	        |      D ]`  \  }\  }}g }	t	        |       D ]5  \  }
}||
   }t        ||||      }t        |      }|	j                  |       7 |j                  ||	f       b |S c c}w )Nr   )max_len)r]   blknosr|   get_concat_blkno_indexers	enumerate_get_block_for_concat_planJoinUnitrZ   )r+   planr   r6   blknos_listpairsindr   r   units_for_bpkblknor^   rb   s                 r.   rR   rR   (  s     D1gmmAG)-.#3::.K.22;?E&u- (\fb o 	&FAs1IE+CUGLBB<D%	& 	R&'( K! /s   B3c                  | j                   |   }t        |      t        |j                        k(  r=|j                  j                  r'|j                  j                  j
                  dk(  r|}|S | j                  |j                     }t        j                  ||      }t        |t              r|j                  |      }|S |j                  |      }|S )Nr(   )rJ   r;   rt   ru   rv   rw   blklocsrr   r	   maybe_indices_to_slicerG   r}   slice_block_columnstake_block_columns)r6   r   r   r   rc   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                  P    e Zd ZddZd	dZd
dZedd       Zedd       ZddZ	y)r   c                    || _         y r3   )rS   )selfrS   s     r.   __init__zJoinUnit.__init___  s	    
r0   c                ^    t        |       j                   dt        | j                         dS )N())type__name__reprrS   )r   s    r.   __repr__zJoinUnit.__repr__b  s*    t*%%&aTZZ(8'9;;r0   c                x   | j                   sy| j                  }|j                  j                  dk(  ry|j                  t        k(  r0|j
                  }t        fd|j                  d      D              S |j                  }|t        u r|j                  k7  ry|t        u rt              ryt        |      S )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  6   K   | ]  }t        |        y wr3   )r   )r5   r<   rK   s     r.   r9   z,JoinUnit._is_valid_na_for.<locals>.<genexpr>s  s     X1,Q6Xs   K)order)is_narS   rK   kindobjectrU   rO   ravel
fill_valuer   r
   r   r   )r   rK   rc   rU   na_values    `   r.   _is_valid_na_forzJoinUnit._is_valid_na_fore  s    
 zzjj99>>S 99ZZFXSV@WXXX>>s?syyE1 r>1%8  %Xu55r0   c                   | j                   }|j                  j                  dk(  ry|j                  sy|j                  }|j
                  dk(  ryt        |j                  t              ry|j                  dk(  r'|d   }t        |      rt        |      syt        |      S |d   d   }t        |      rt        |      syt        d |D              S )Nr   TFr   r(   c              3  2   K   | ]  }t        |        y wr3   )r   )r5   rows     r.   r9   z!JoinUnit.is_na.<locals>.<genexpr>  s     7x}7r=   )rS   rK   r   _can_hold_narU   sizerG   r   rD   r   r   r   rO   )r   rc   rU   vals       r.   r   zJoinUnit.is_na  s    jj99>>S ;;!fllK0;;!)CS>cF##)A,CS>c7777r0   c                P    | j                   }|j                  j                  dk(  ryy)z{
        Will self.is_na be True after values.size == 0 deprecation and isna_all
        deprecation are enforced?
        r   TFrS   rK   r   )r   rc   s     r.   )is_na_after_size_and_isna_all_deprecationz2JoinUnit.is_na_after_size_and_isna_all_deprecation  s#     jj99>>S r0   c                   |9| j                   j                  j                  dk7  r| j                   j                  S |}| j	                  |      r| j                   j                  }|t        j                  d      k(  rAt        t
        j                  | j                   j                        }|j                  r|d   d }t        || j                   j                  |      S | j                   j                  S )Nr   r   )r   r   )rS   rK   r   rU   r   rL   r   ndarrayr   r   r]   )r   empty_dtypeupcasted_nar   	blk_dtyperU   s         r.   get_reindexed_valueszJoinUnit.get_reindexed_values  s     4::#3#3#8#8C#?::$$$$J$$[1 JJ,,	 22 ""**djj.?.?@F{{vd|';%)
$[$**2B2BJOO::$$$r0   N)rS   r%   returnNone)r   str)rK   r!   r   bool)r   r   )r   r!   r   r   )
r   
__module____qualname__r   r   r   r   r   r   r   rz   r0   r.   r   r   ^  s?    <6@ 8 8<  %r0   r   c                   t        |       \  }}t        d | D              }t        ||      }| D cg c]  }|j                  ||       }}t        d |D              rH|D cg c]"  }t	        |j
                        r|n|dddf   $ }}t        |dd      }	t        |	d      }	nt        |d	
      }	||k7  r3||	j
                  k(  r$t        j                  dt        t                      |	S c c}w c c}w )zB
    Concatenate values from several join units along axis=1.
    c              3  b   K   | ]'  }|j                   j                  j                  d k(   ) ywr   Nr   r5   rb   s     r.   r9   z*_concatenate_join_units.<locals>.<genexpr>  %     N4$****//36N   -/)r   r   c              3  F   K   | ]  }t        |j                          y wr3   )r   rK   )r5   ts     r.   r9   z*_concatenate_join_units.<locals>.<genexpr>  s     
;Aqww'
;s   !r   NTrA   rC   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   rK   r   r   warningswarnFutureWarningr   )
ra   rE   r   empty_dtype_futurehas_none_blocksr   rd   	to_concatr   concat_valuess
             r.   rX   rX     s    '7z&B#K#N:NNO$[/BK  	K[QI 
 
;
;; 	
  #177+ 1a4
	 
 &iaM*=!< &ia8((----MM(
 +- E
s   C.#'C3c                b   t        | t              r| j                  S | j                  dv r| j	                  d      S | j                  dv r| j	                  d      S | j                  dk(  ry| j                  dv r|syt
        j                  S | j                  dk(  rt
        j                  S t        )	z2
    Find the NA value to go with this dtype.
    mMr   fcNaNrg   NiuO)rG   r   r   r   r   rL   nanNotImplementedError)rK   r   s     r.   r   r     s     %(~~	t	zz%  	t	zz%  	s		t	vv	s	vv
r0   c                   t        j                  | D cg c]  }|j                  j                   c}      r| d   j                  j                  }||fS t	        d | D              }| D cg c]%  }|j
                  r|j                  j                  ' }}t        |      sG| D cg c]<  }|j                  j                  j                  dk7  s'|j                  j                  > }}t        |      }|rt        |      }|}t        |      t        |       k7  r| D cg c]$  }|j                  s|j                  j                  & }}t        |      sG| D cg c]<  }|j                  j                  j                  dk7  s'|j                  j                  > }}t        |      t        |      k7  rt        |      }|rt        |      }||fS c c}w c c}w c c}w c c}w c c}w )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  b   K   | ]'  }|j                   j                  j                  d k(   ) ywr   r   r   s     r.   r9   z#_get_empty_dtype.<locals>.<genexpr>  r   r   r   )r	   dtypes_all_equalrS   rK   r   r   r;   r   r   r   r   )	ra   rd   r   r   rb   dtypesrK   dtype_futuredtypes_futures	            r.   r   r     s    jARXX^^AB m))//K''N:NNO+5H4TZZdjjHFHv;)3
!%tzz7G7G7L7LPS7SDJJ
 
 V$E(/L
6{c*o% #
AA JJ
 

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

  M  v;#m,,+M:L7E,C B I

s/   G+G=G&(GG)G(G"G"c                    | d   j                   j                  j                  dk(  ryt        fd| D              xr( t        fd| D              xr t        d | D              S )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  ^   K   | ]$  }t        |j                        t              u  & y wr3   )r   rS   r5   rd   firsts     r.   r9   z)_is_uniform_join_units.<locals>.<genexpr>H  s"     ?bDNd5k)?s   *-c              3     K   | ]K  }|j                   j                  j                  k(  xs" |j                   j                  j                  d v  M yw)iubNr   r   s     r.   r9   z)_is_uniform_join_units.<locals>.<genexpr>K  sN      

 	 HHNNekk) , xx~~""e+,
s   AAc              3  f   K   | ])  }|j                    xs |j                  j                   + y wr3   )r   rS   rV   )r5   rd   s     r.   r9   z)_is_uniform_join_units.<locals>.<genexpr>U  s(     GbL1BHH111Gs   /1)rS   rK   r   rO   )ra   r   s    @r.   rT   rT   <  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    rE   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%   )ra   list[JoinUnit]rE   r   r   r   )rK   r!   r   r   )ra   zSequence[JoinUnit]r   ztuple[DtypeObj, DtypeObj])ra   r   r   r   )G
__future__r   typingr   r   r   numpyrL   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/   rh   rH   r4   rQ   rR   r   r   rX   r   r   rT   rz   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   