
    MhÄ                       S r SSKJr  SSKJr  SSKJrJr  SSKr	SSKJ
r
  SSKJr  SSKJr  SS	KJr  SS
KJrJrJrJrJr  SSKJrJr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%  SSK&J'r'  SSK(J)r)  SSK*J+r,J-r-J.r.J/r/J0r0  SSK1J2r2J3r3J4r4J5r5J6r6J7r7J8r8  SSK9J:r:J;r;  SSK<J=r=J>r>J?r?J@r@  SSKAJBrBJCrCJDrDJErE  \(       a  SSKFJGrGJHrH  SSKIJJrJJKrKJLrLJMrM  SSSSS.           S3S jjrN          S4S jrOS5S6S jjrP        S7S jrQ        S8S jrRSSSS .         S9S! jjrS          S:S" jrTS;S# jrUS5S<S$ jjrVS=S% jrW      S>S& jrXS?S' jrY          S@S( jrZS?S) jr[          SAS* jr\S+ r] SB     SCS, jjr^SDS- jr_      SES. jr`      SFS/ jra        SGS0 jrb      SHS1 jrc  SI         SJS2 jjrdg)Kz~
Functions for preparing various inputs passed to the DataFrame or Series
constructors before passing them to a BlockManager.
    )annotations)abc)TYPE_CHECKINGAnyN)ma)using_pyarrow_string_dtype)lib)astype_is_view)"construct_1d_arraylike_from_scalardict_compatmaybe_cast_to_datetimemaybe_convert_platformmaybe_infer_to_datetimelike)is_1d_only_ea_dtypeis_integer_dtypeis_list_likeis_named_tupleis_object_dtype)ExtensionDtype)ABCDataFrame	ABCSeries)
algorithmscommon)ExtensionArray)StringDtype)arrayensure_wrapped_if_datetimelikeextract_arrayrange_to_ndarraysanitize_array)DatetimeIndexIndexTimedeltaIndexdefault_indexensure_indexget_objs_combined_axisunion_indexes)ArrayManagerSingleArrayManager)BlockPlacementensure_block_shape	new_blocknew_block_2d)BlockManagerSingleBlockManager create_block_manager_from_blocks'create_block_manager_from_column_arrays)HashableSequence)	ArrayLikeDtypeObjManagernptT)dtypeverify_integritytypconsolidatec               \   U(       a)  Uc  [        U 5      nO[        U5      n[        XU5      u  pO[        U5      nU  Vs/ s H  n[        USS9PM     n nS/[	        U 5      -  nU  H[  n	[        U	[        R                  [        45      (       a*  U	R                  S:w  d  [	        U	5      [	        U5      :w  d  MR  [        S5      e   [        U5      n[	        U5      [	        U 5      :w  a  [        S5      eX/n
US:X  a
  [        X
XgS9$ US	:X  a  [        XU/5      $ [        S
U S35      es  snf )zg
Segregate Series based on type and coerce into matrices.

Needs to handle a lot of exceptional cases.
NTextract_numpy   zYArrays must be 1-dimensional np.ndarray or ExtensionArray with length matching len(index)z#len(arrays) must match len(columns)block)r;   refsr   2'typ' needs to be one of {'block', 'array'}, got '')_extract_indexr%   _homogenizer   len
isinstancenpndarrayr   ndim
ValueErrorr1   r(   )arrayscolumnsindexr8   r9   r:   r;   rA   xarraxess              T/var/www/html/env/lib/python3.13/site-packages/pandas/core/internals/construction.pyarrays_to_mgrrS   `   s9    ="6*E 'E #6%8 U#@FG1-6GvF# CsRZZ$@AA88q=s8s5z) 6   7#G
7|s6{">?? D
g~6k
 	
 
FG$455OPSuTUVWW= Hs    D)c                ,   [         R                  " U 5      nUc  [        [        U5      5      nO[	        U5      nUb  [	        U5      n[        Xb5      u  px[        XxU[        U5      5      u  pxUc  Un[        XrXUS9n	U(       a  U	R                  5       n	U	$ )z9
Extract from a masked rec array and create the manager.
r8   r:   )	r   getdatar$   rF   r%   	to_arraysreorder_arraysrS   copy)
datarN   rM   r8   rY   r:   fdatarL   arr_columnsmgrs
             rR   rec_array_to_mgrr^      s     JJtE}c%j)U#w'#E3F )gs5zRF

EChhjJ    c                V   US:X  a  [        U [        5      (       a  U nU$ U R                  S:X  a2  [        U R                  U R
                  S   U R
                  S   SS9nU$ [        R                  " U R                  S   U R                  5      n U$ US:X  a  [        U [        5      (       a  U nU$ U R                  S:X  a  [        [        U R
                  S   5      5       Vs/ s H  o@R                  U5      PM     nnU(       a  U Vs/ s H  ofR                  5       PM     nn[        XPR
                  S   U R
                  S   /5      nU$ U R                  5       nU(       a  UR                  5       n[        U/U R                  /5      n U$ [!        SU S35      es  snf s  snf )	z
Convert to specific type of Manager. Does not copy if the type is already
correct. Does not guarantee a copy otherwise. `copy` keyword only controls
whether conversion from Block->ArrayManager copies the 1D arrays.
r@      r   r?   )r:   r   rB   rC   )rG   r.   rJ   rS   rL   rQ   r/   
from_arrayrN   r(   rangerF   iget_valuesrY   internal_valuesr)   rK   )r]   r:   rY   new_mgrirL   rP   r   s           rR   
mgr_to_mgrrh      s    g~c<((G0 N- xx1}'JJSXXa[g* N# -77

1syyQ" N! 
c<((G N xx1}6;C<L6MN6M//!,6MN4:;FShhjFF;&vSXXa[/IJ N ++-!JJLE,eWsyykB N OPSuTUVWW O;s   %F!F&c                   [        U [        5      (       a  Uc#  U R                  b  [        U R                  /5      nUc  U R                  nOU R                  U5      n [        U 5      (       d,  Ub)  [        U5      (       a  [        R                  " S[        S9n US:X  a  SOUn[        U SS 5      nS n[        U5      (       d  [        U5      (       a  [        U [        R                  [        45      (       a@  U R                  S:  a0  [        U R                   S   5       V	s/ s H  n	U S S 2U	4   PM     n n	OU /n Uc  [        [        [        U 5      5      5      nO[#        U5      n[%        XXUS9$ [        U[&        5      (       aD  [)        U SS	9n U(       a  U R+                  5       n U R                  S:X  a  U R-                  S
S5      n O[        U [        [        45      (       ak  U(       d*  Ub  [/        U R0                  U5      (       a  U R2                  nU(       a  U R4                  R+                  5       n OU R4                  n [7        U 5      n Op[        U [        R                  [        45      (       aB  Ub  [/        U R0                  U5      (       a  UOSn
[        R8                  " X
S9n [7        U 5      n O	[;        XS9n Ub  U R0                  U:w  a  [=        U S UUSS9n [?        U R                   S   U R                   S   XS9u  p[A        XU5        US:X  Ga2  [C        U R0                  RD                  [F        5      (       a  [        R8                  " U [        S9n Uc\  [I        U R0                  5      (       aB  [        U R                   S   5       Vs/ s H  n[K        [M        U S S 2U4   5      5      PM      nnO_[N        RP                  " U R0                  S5      (       a  [K        U 5      n [        U R                   S   5       Vs/ s H  oS S 2U4   PM     nnU(       a  U Vs/ s H  oR+                  5       PM     nn[S        XU/SS9$ U RT                  n Uc  [I        U R0                  5      (       a  [W        U 5      nU Vs/ s H  n[M        U5      PM     nn[Y        S [[        UU5       5       5      (       aU  U Vs/ s H  n[]        US5      PM     nn[        [        U5      5       V	s/ s H  n	[_        UU	   [a        U	5      S9PM     nn	O[a        [c        [        U5      5      5      n[_        U UUS9nU/nOUc  U R0                  Rd                  S:X  a~  [g        5       (       ao  [i        SS9n[W        U 5      n[k        U5       VVs/ s HB  u  nn[m        URo                  5       Rq                  UUS9[a        [c        XS-   5      5      SS9PMD     nnnO+[a        [c        [        U5      5      5      n[_        U UUS9nU/n[        U5      S:X  a  / n[s        UX!/SS9$ s  sn	f s  snf s  snf s  snf s  snf s  snf s  sn	f s  snnf )N)r   r?   r8   r   Fr8   r?   rU   Tr=   rY   )r8   rY   allow_2dr   )rN   rM   mM)r9   c              3  ,   #    U  H
  u  pXLv   M     g 7fN ).0rO   ys      rR   	<genexpr>!ndarray_to_mgr.<locals>.<genexpr>p  s     G&Fdaqz&Fs   ra   )	placement)rv   rA   Upyarrow_numpy)storage)rJ   ):rG   r   namer"   rN   reindexrF   rH   emptyobjectgetattrr   rI   r   rJ   rc   shaper%   rS   r   r   rY   reshaper
   r8   _references_values
_ensure_2dr   _prep_ndarrayliker    	_get_axes!_check_values_indices_shape_match
issubclasstypestrr   r   r   r	   is_np_dtyper(   Tlistanyzipr+   r-   r*   slicekindr   r   	enumerater,   construct_array_type_from_sequencer0   )valuesrN   rM   r8   rY   r:   copy_on_sanitizevdtyperA   n_copyrg   rL   rP   obj_columnsrO   maybe_datetimedval
dvals_listblock_valuesbpnbrZ   s                          rR   ndarray_to_mgrr      s    &)$$?{{&.=LLE^^E*F 6{{w2s7||XXfF3F !$wuDVWd+FD6""&9%&@&@ frzz>:;;a v||A//A q!t/  F
 XF?E#f+./G"7+GVecJJ	FN	+	+ vT:[[]F;;!^^B*F	FY.	/	/M^FLL%@@%%D^^((*F^^FF#	FRZZ8	9	9 e!D!D  	
 &-F#
 #6AV\\U2!
 QaNE &fW=
g~fll''--XXfF3F=_V\\::
 v||A/	 0A //q!t= 0	  F v||T227?,1&,,q/,BC,BqQTl,BFC,23FShhjFF3FG$4uMMXXF
 }666lBMN+Q5a8+NGc+~&FGGGBPQ.$,T15.JQ s://A Z]nQ6GH/  L
  c'l 34Bf>B4L	6<<,,38R8T8TO46l %[1
 24 **,;;D;NuQA/
 2 	 
 E#g,/0&BT:t
7|q+w& ER D 4 O R
s1   !X %X%X*%X/X4 X9. X>A	Yc                <   U R                   S   [        U5      :w  d  U R                   S   [        U5      :w  ad  U R                   S   Ss=:X  a  [        U5      :  a  O  O[        S5      eU R                   n[        U5      [        U5      4n[        SU SU 35      eg)zP
Check that the shape implied by our axes matches the actual shape of the
data.
r?   r   z)Empty data passed with indices specified.zShape of passed values is z, indices imply N)r   rF   rK   )r   rN   rM   passedimplieds        rR   r   r     s     ||A#g,&&,,q/SZ*G <<?a,#e*,HIIu:s7|,5fX=MgYWXX +Hr_   r@   )r8   r:   rY   c          	     L   UGbX  SSK Jn  U" X[        S9nUR                  5       nUc  [	        Xx)    5      nO[        U5      nUR                  5       (       a  [        U5      (       d  UbL  UR                  R                  5       S   n	U	 H(  n
[        UR                  U
   XS9nXR                  U
'   M*     O[        R                  " S5      n[        [        R                  [!        U5      U5      nUR#                  5       nU(       a  U/U-  nO)[%        U5       Vs/ s H  nUR'                  5       PM     nnXR(                  U'   [+        U5      n[        U5      nO_[+        U R-                  5       5      nU(       a  [/        U5      O
[1        S5      nU Vs/ s H  n[2        R4                  " U U   5      PM     nnU(       a  US:X  a  U Vs/ s H}  n[7        U[8        5      (       a  UR'                  5       OT[7        U[.        5      (       d/  [7        U[:        5      (       a)  [=        UR                  5      (       a  UR'                  SS9OUPM     nnO3U Vs/ s H&  n[?        US	5      (       a  UR'                  5       OUPM(     nn[A        XrXXES
9$ s  snf s  snf s  snf s  snf )z
Segregate Series based on type and coerce into matrices.
Needs to handle a lot of exceptional cases.

Used in DataFrame.__init__
r   )Series)rN   r8   rj   r}   r@   T)deepr8   )r8   r:   r;   )!pandas.core.seriesr   r}   isnarD   r%   r   r   r   nonzeror    iatrH   r8   r   nanrF   sumrc   rY   locr   keysr"   r$   commaybe_iterable_to_listrG   r   r   r   hasattrrS   )rZ   rN   rM   r8   r:   rY   r   rL   missingmidxsrg   rP   	nan_dtypevalnmissingrhs_r   krO   s                       rR   dict_to_mgrr     sM   " -6:++-= #6(#34E 'E ;;==!1%!8!8    ..03A(AKC$'JJqM 
 HHX.	8UYW";;=%(*C 05X?!388:C?&)

7#fw' DIIK !%%+=+;?CDt!#,,T!W5tD'>    A a00  q%((!!Y//+AGG44	 VVV&     F GMMf'!W"5"5affh1<fFM%#XX? @ E Ns   J#JBJ-J!c                
   [        U S   5      (       a  Uc  [        U S   R                  5      n[        XUS9u  pA[        U5      nUc8  [	        U S   [
        5      (       a  [        U 5      nO[        [        U 5      5      nXAU4$ )z9
Convert a single sequence of arrays to multiple arrays.
r   rj   )	r   r%   _fieldsrW   rG   r   _get_names_from_indexr$   rF   )rZ   rM   rN   r8   rL   s        rR   nested_data_to_arraysr     sz     d1g7?tAw/U;OF7#G}d1gy)))$/E!#d),EE!!r_   c                    [        U 5      S:  =(       aZ    [        U S   5      =(       aE    [        U S   SS5      S:H  =(       a+    [        U [        5      =(       a    U R
                  S:H  (       + $ )z/
Check if we should use nested_data_to_arrays.
r   rJ   r?   ra   )rF   r   r~   rG   r   rJ   )rZ   s    rR   treat_as_nestedr     sc    
 	D	A 	Fa!	FDGVQ'1,	F D.1Ddii1nE	r_   c                @   [        U 5      S:X  a  [        R                  " S[        S9$ [	        U [
        5      (       a   [        U 5      nUS[        R                  4   $ S n[        U S   5      (       a-  [        R                  " U  Vs/ s H
  oC" U5      PM     sn5      n Oj[	        U S   [        R                  5      (       a@  U S   R                  S:X  a-  [        R                  " U  Vs/ s H
  oC" U5      PM     sn5      n OU" U 5      n [        U 5      $ s  snf s  snf )Nr   )r   r   rj   .c                ~    [        U 5      (       a  [        U [        5      (       a  U $ [        U SS9n [	        U 5      nU$ )NTr=   )r   rG   r   r   r   )vress     rR   convert"_prep_ndarraylike.<locals>.convert/  s9    A*Q"="=H!40$Q' 
r_   )rF   rH   r|   r}   rG   rc   r   newaxisr   r   rI   rJ   r   )r   rY   rP   r   r   s        rR   r   r   #  s     6{a xxf--	FE	"	"v&3

?## F1Iv6v!71:v67	F1Irzz	*	*vay~~/Bv6v!71:v67f 7 7s   D*Dc                    U R                   S:X  a"  U R                  U R                  S   S45      n U $ U R                   S:w  a  [        SU R                   35      eU $ )z:
Reshape 1D values, raise on anything else other than 2D.
r?   r   ra   zMust pass 2-d input. shape=)rJ   r   r   rK   )r   s    rR   r   r   I  s\     {{aa! 45 M 
	6v||nEFFMr_   c                   S n/ n/ nU  GHY  n[        U[        [        45      (       ao  Ub  UR                  USS9n[        U[        5      (       a  UR                  ULa  UR                  USS9nUR                  UR                  5        UR                  nO[        U[        5      (       as  Uc  UR                  S5      n[        U[        [        45      (       a  [        U5      nO[        U5      n[        R                  " XcR                  [        R                   S9n[#        XaUSS9n[$        R&                  " Xa5        UR                  S 5        UR                  U5        GM\     XE4$ )NFrl   O)defaultr8   rY   )rG   r   r"   astyperN   r{   appendr   r   dictr!   r#   r   r	   fast_multigetrH   r   r    r   require_length_match)rZ   rN   r8   oindexhomogenizedrA   r   s          rR   rE   rE   T  s0    FKDcIu-.. jjUj3#y))ciiu.D kk%ek4KK(++C#t$$ >"\\#.Fem^%DEE%c*C s)C''^^RVVL 5uEC$$S0KK3; > r_   c                   [        U 5      S:X  a  [        S5      $ / n/ nSnSnSnU  H  n[        U[        5      (       a  SnUR	                  UR
                  5        M7  [        U[        5      (       a,  SnUR	                  [        UR                  5       5      5        Mx  [        U5      (       a/  [        USS5      S:X  a  SnUR	                  [        U5      5        M  [        U[        R                  5      (       d  M  UR                  S:  d  M  [        S5      e   U(       d  U(       d  [        S5      eU(       a  [        U5      nOU(       a
  [        USS9nU(       a  [        [!        U5      5      n[        U5      S:  a  [        S	5      eU(       a  [        S
5      eU(       a2  US   [        W5      :w  a  SUS    S[        U5       3n	[        U	5      eO[        US   5      n[#        W5      $ )zJ
Try to infer an Index from the passed data, raise ValueError on failure.
r   FTrJ   r?   z,Per-column arrays must each be 1-dimensionalz2If using all scalar values, you must pass an indexsortz%All arrays must be of the same lengthz<Mixing dicts with non-Series may lead to ambiguous ordering.zarray length z does not match index length )rF   r$   rG   r   r   rN   r   r   r   r   r~   rH   rI   rJ   rK   r'   setr%   )
rZ   raw_lengthsindexeshave_raw_arrayshave_series
have_dictsr   rN   lengthsmsgs
             rR   rD   rD   ~  s   
 4yA~QK,.GOKJc9%%KNN399%T""JNN4
+,#73#:a#?"Os3x(RZZ((SXX\KLL  ;MNNg&	gE2s;'(w<!DEEN  qzSZ'#GAJ< 0!%j\+  !o% ( "'!*-Er_   c                8   Ub  UR                  U5      (       d  / nUR                  U5      n[        U5       HY  u  pgUS:X  a9  [        R                  " U[
        S9nUR                  [        R                  5        OX   nUR                  U5        M[     Un UnX4$ )z:
Pre-emptively (cheaply) reindex arrays with new columns.
rk   rj   )	equalsget_indexerr   rH   r|   r}   fillr   r   )	rL   r\   rM   length
new_arraysindexerrg   r   rP   s	            rR   rX   rX     s     ~~k***,J!--g6G!'*7((68CHHRVV$ )C!!#& +  F!Kr_   c                   [        S U  5       5      nU(       d  [        [        U 5      5      $ [        [	        [        U 5      5      5      nSn[        U 5       H'  u  pE[        USS 5      nUb  XbU'   M  SU 3X$'   US-  nM)     [        U5      $ )Nc              3  @   #    U  H  n[        US S5      SLv   M     g7f)rz   N)r~   )rr   ss     rR   rt   (_get_names_from_index.<locals>.<genexpr>  s     Kd640<ds   r   rz   zUnnamed r?   )r   r$   rF   r   rc   r   r~   r"   )rZ   has_some_namerN   countrg   r   r   s          rR   r   r     s    KdKKMSY'' s4y!12EE$Avt$=!H!%)EHQJE   <r_   c                t    Uc  [        U 5      nO[        U5      nUc  [        U5      nX#4$ [        U5      nX#4$ rp   )r$   r%   )NKrN   rM   s       rR   r   r     sJ     }a U#" > w'>r_   c                6    SSK Jn  [        [        X5      5      $ )as  
Converts a list of dataclass instances to a list of dictionaries.

Parameters
----------
data : List[Type[dataclass]]

Returns
--------
list_dict : List[dict]

Examples
--------
>>> from dataclasses import dataclass
>>> @dataclass
... class Point:
...     x: int
...     y: int

>>> dataclasses_to_dicts([Point(1, 2), Point(2, 3)])
[{'x': 1, 'y': 2}, {'x': 2, 'y': 3}]

r   )asdict)dataclassesr   r   map)rZ   r   s     rR   dataclasses_to_dictsr     s    0 #F!""r_   c                
   [        U 5      (       d  [        U [        R                  5      (       a  U R                  R
                  bv  [        U R                  R
                  5      nU Vs/ s H  o0U   PM	     nn[        U 5      S:X  a1  [        U5       H"  u  pVUR                  S:X  d  M  USS2S4   XE'   M$     XA4$ / [        / 5      4$ [        U [        R                  5      (       aV  U R                  R
                  b?  [        [        U R                  R
                  5      5      nU Vs/ s H  opU   PM	     nnXA4$ [        U S   [        [        45      (       a  [        U 5      nO|[        U S   [        R                  5      (       a  [        X5      u  paOL[        U S   [         5      (       a  [#        X5      u  paO&U  Vs/ s H  n[        U5      PM     n n[        U 5      n[%        XaU5      u  pX4$ s  snf s  snf s  snf )z
Return list of arrays, columns.

Returns
-------
list[ArrayLike]
    These will become columns in a DataFrame.
Index
    This will become frame.columns.

Notes
-----
Ensures that len(result_arrays) == len(result_index).
Nr   ra   )rF   rG   rH   rI   r8   namesr%   r   rJ   r"   r   tuple_list_to_arraysr   Mapping_list_of_dict_to_arraysr   _list_of_series_to_arrays_finalize_columns_and_data)
rZ   rM   r8   rz   rL   rg   rP   r   rO   contents
             rR   rW   rW     s   $ t99dBJJ''zz+&tzz'7'78189t*9t9> #,F"388q=(+AqD	FI #4 &<###	D"**	%	%$***:*:*FTZZ--./#*+7aq'7+$q'D%=))d#	DGS[[	)	).t=W	DGY	'	'0?W #''$Qa$'d#1#FG= : , (s   *G6,G;H c                    [        U S   [        5      (       a  [        R                  " U 5      nU$ [        R                  " U 5      nU$ )Nr   )rG   r   r	   to_object_array_tuplesto_object_array)rZ   r   s     rR   r   r   Q  sC     $q'5!!,,T2 N %%d+Nr_   c                   Uc9  U  Vs/ s H"  n[        U[        [        45      (       d  M   UPM$     nn[        USS9n0 n/ nU  H  n[	        USS 5      nUc  [        [        U5      5      n[        U5      U;   a  U[        U5         nOUR                  U5      =o[        U5      '   [        USS9n	UR                  [        R                  " X5      5        M     [        R                  " U5      n
X4$ s  snf )NFr   rN   Tr=   )rG   r   r   r&   r~   r$   rF   idr   r   r   r   take_ndrH   vstack)rZ   rM   rO   	pass_dataindexer_cachealigned_valuesr   rN   r   r   r   s              rR   r   r   \  s      $Q1
1y,6O(PQ	Q(?+-MN7D)=!#a&)Ee9%#BuI.G161B1B71KKGBuI.q5j00AB  ii'G) Rs
   C2C2c                4   Uc?  S U  5       n[        S U  5       5      (       + n[        R                  " X#S9n[        U5      nU  Vs/ s H"  n[	        U5      [
        L a  UO
[        U5      PM$     n n[        R                  " U [        U5      5      nXa4$ s  snf )a  
Convert list of dicts to numpy arrays

if `columns` is not passed, column names are inferred from the records
- for OrderedDict and dicts, the column names match
  the key insertion-order from the first record to the last.
- For other kinds of dict-likes, the keys are lexically sorted.

Parameters
----------
data : iterable
    collection of records (OrderedDict, dict)
columns: iterables or None

Returns
-------
content : np.ndarray[object, ndim=2]
columns : Index
c              3  T   #    U  H  n[        UR                  5       5      v   M      g 7frp   )r   r   )rr   rO   s     rR   rt   *_list_of_dict_to_arrays.<locals>.<genexpr>  s     ,t!tAFFH~~ts   &(c              3  B   #    U  H  n[        U[        5      v   M     g 7frp   )rG   r   )rr   ds     rR   rt   r	    s     9Dqz!T**D   r   )r   r	   fast_unique_multiple_list_genr%   r   r   dicts_to_arrayr   )rZ   rM   genr   pre_colsr  r   s          rR   r   r   {  s    . ,t,9D99944SDx( 8<<t!aDAd1g-tD<  tG}5G =s   )Bc                    [        U R                  5      n [        X15      n[        U5      (       a*  US   R                  [        R                  :X  a	  [        X2S9nX14$ ! [         a  n[	        U5      UeSnAff = f)z?
Ensure we have valid columns, cast object dtypes if possible.
Nr   rj   )
r   r   _validate_or_indexify_columnsAssertionErrorrK   rF   r8   rH   object_convert_object_array)r   rM   r8   contentserrs        rR   r   r     sq     GIIH'/B
 8}}!**bjj8'>  'o3&'s   A 
A:)A55A:c                   Uc  [        [        U 5      5      nU$ [        U[        5      =(       a    [	        S U 5       5      nU(       d;  [        U5      [        U 5      :w  a#  [        [        U5       S[        U 5       S35      eU(       a|  [        U Vs1 s H  n[        U5      iM     sn5      S:  a  [        S5      eU(       aA  [        US   5      [        U 5      :w  a&  [        [        US   5       S[        U 5       S35      eU$ s  snf )ah  
If columns is None, make numbers as column names; Otherwise, validate that
columns have valid length.

Parameters
----------
content : list of np.ndarrays
columns : Index or None

Returns
-------
Index
    If columns is None, assign positional column index value as columns.

Raises
------
1. AssertionError when content is not composed of list of lists, and if
    length of columns is not equal to length of content.
2. ValueError when content is list of lists, but length of each sub-list
    is not equal
3. ValueError when content is list of lists, but length of sub-list is
    not equal to length of content
c              3  B   #    U  H  n[        U[        5      v   M     g 7frp   )rG   r   )rr   cols     rR   rt   0_validate_or_indexify_columns.<locals>.<genexpr>  s      7
-4cJsD!!Wr  z! columns passed, passed data had z columnsr?   z<Length of columns passed for MultiIndex columns is differentr   )r$   rF   rG   r   allr  rK   )r   rM   
is_mi_listr  s       rR   r  r    s	   4 G-4 N/  . 
3 7
-47
 4

 c'lc'l: w<. Aw<.*  0CH01A5 R 
 3wqz?c'l: 71:''H7|nH.  N 1s   D
c                T   ^^^ UUU4S jnU  Vs/ s H
  oT" U5      PM     nnU$ s  snf )a  
Internal function to convert object array.

Parameters
----------
content: List[np.ndarray]
dtype: np.dtype or ExtensionDtype
dtype_backend: Controls if nullable/pyarrow dtypes are returned.
coerce_float: Cast floats that are integers to int.

Returns
-------
List[ArrayLike]
c                  > T[         R                  " S5      :w  Ga?  [        R                  " U TTS:g  S9n Tc  U R                  [         R                  " S5      :X  a`  [	        U 5      n TS:w  aM  U R                  [         R                  " S5      :X  a)  [        5       nUR                  5       nUR                  XS9n U $ TS:w  aC  [        U [         R                  5      (       a$  U R                  R                  S;   a
  [        U SS9n U $ [        T[        5      (       a#  TR                  5       nUR                  U TSS9n U $ TR                  S	;   a  [        U T5      n U $ )
Nr   numpy)	try_floatconvert_to_nullable_dtyperj   iufbFrl   r   rn   )rH   r8   r	   maybe_convert_objectsr   r   r   r   rG   rI   r   pd_arrayr   r   )rP   	new_dtypearr_clsclscoerce_floatr8   dtype_backends       rR   r   %convert_object_array.<locals>.convert  s;   BHHSM!++&*77*BC }99-5c:C$/CII#4N$/M	"+"@"@"B%44S4J& 
% #g-*S"**2M2Myy~~/&s7  
 E>22 002((E(F 
 t# -S%8
r_   rq   )r   r8   r*  r)  r   rP   rL   s    ```   rR   r  r    s-    ,(T '..gsgclgF.M /s   %)rM   r"   r8   DtypeObj | Noner9   boolr:   z
str | Noner;   r-  returnr6   )
rZ   znp.rec.recarray | np.ndarrayr8   r,  rY   r-  r:   r   r.  r6   )T)r:   r   rY   r-  r.  r6   )r8   r,  rY   r-  r:   r   r.  r6   )r   
np.ndarrayrN   r"   rM   r"   r.  None)
rZ   r   r8   r,  r:   r   rY   r-  r.  r6   )
rZ   r3   rM   Index | NonerN   r1  r8   r,  r.  z$tuple[list[ArrayLike], Index, Index])r.  r-  )rY   r-  r.  r/  )r   r/  r.  r/  )rN   r"   r8   r,  r.  z!tuple[list[ArrayLike], list[Any]])r.  r"   )
rL   list[ArrayLike]r\   r"   rM   r1  r   intr.  tuple[list[ArrayLike], Index])
r   r3  r   r3  rN   r1  rM   r1  r.  ztuple[Index, Index]rp   )rM   r1  r8   r,  r.  r4  )rZ   zlist[tuple | list]r.  r/  )rZ   r   rM   r1  r.  tuple[np.ndarray, Index])rZ   z
list[dict]rM   r1  r.  r5  )r   r/  rM   r1  r8   r,  r.  r4  )r   zlist[np.ndarray]rM   r1  r.  r"   )r   F)
r   zlist[npt.NDArray[np.object_]]r8   r,  r*  r   r)  r-  r.  r2  )e__doc__
__future__r   collectionsr   typingr   r   r   rH   r   pandas._configr   pandas._libsr	   pandas.core.dtypes.astyper
   pandas.core.dtypes.castr   r   r   r   r   pandas.core.dtypes.commonr   r   r   r   r   pandas.core.dtypes.dtypesr   pandas.core.dtypes.genericr   r   pandas.corer   r   r   pandas.core.arraysr   pandas.core.arrays.string_r   pandas.core.constructionr   r%  r   r   r   r    pandas.core.indexes.apir!   r"   r#   r$   r%   r&   r'   #pandas.core.internals.array_managerr(   r)   pandas.core.internals.blocksr*   r+   r,   r-   pandas.core.internals.managersr.   r/   r0   r1   collections.abcr2   r3   pandas._typingr4   r5   r6   r7   rS   r^   rh   r   r   r   r   r   r   r   rE   rD   rX   r   r   r   rW   r   r   r   r   r  r  rq   r_   rR   <module>rK     s   # 
   5  4   5
 . 2      
  "!>X>X
 >X >X 
>X >X >XB 
&  	 
   
   F"Re#2e:>eEHeePYY$Y/4Y	Y. "PY
PY
 PY 
PY PY PYf"
"" " 	"
 *"4	#L''.'&'T8v*/:FPS"6$
'2>$#D ;?55(75"5p
 >"
"" "J  #	,55(45
5v !	B*BB B 	B
 Br_   