ó
    Ñ]jÐƒ  ã                  óz  • 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  SSKJrJrJrJrJr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&J'r(  SSK)J*r*  SSK+J,r,  SSK-J.r/J0r0J1r1J2r2  SSK3J4r4J5r5J6r6J7r7J8r8J9r9J:r:J;r;J<r<  SSK=J>r>J?r?J@r@JArA  SSKBJCrCJDrD  \(       a  SSKEJFrFJGrG  SSKHJIrIJJrJJKrKJLrL  SSSS.         S1S jjrM        S2S jrN      S3S jrO        S4S jrPSSS.       S5S jjrQ          S6S  jrRS7S! jrSS8S9S" jjrTS:S# jrU      S;S$ jrVS<S% jrW          S=S& jrXS<S' jrY          S>S( jrZS) r[ S?     S@S* jjr\SAS+ jr]      SBS, jr^      SCS- jr_        SDS. jr`      SES/ jra  SF         SGS0 jjrbg)Hz~
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_string_dtype)Úlib)Úastype_is_view)Ú"construct_1d_arraylike_from_scalarÚdict_compatÚmaybe_cast_to_datetimeÚmaybe_convert_platform)Úis_1d_only_ea_dtypeÚis_integer_dtypeÚis_list_likeÚis_named_tupleÚis_object_dtypeÚ	is_scalar)ÚBaseMaskedDtypeÚExtensionDtype)ÚABCDataFrameÚ	ABCSeries)Úisna)Ú
algorithmsÚcommon)ÚExtensionArray)ÚStringDtype)ÚarrayÚextract_arrayÚrange_to_ndarrayÚsanitize_array)	ÚDatetimeIndexÚIndexÚ
MultiIndexÚTimedeltaIndexÚdefault_indexÚensure_indexÚget_objs_combined_axisÚmaybe_sequence_to_rangeÚunion_indexes)ÚBlockPlacementÚensure_block_shapeÚ	new_blockÚnew_block_2d)Ú create_block_manager_from_blocksÚ'create_block_manager_from_column_arrays)ÚHashableÚSequence)Ú	ArrayLikeÚDtypeObjÚManagerÚnptT)ÚdtypeÚverify_integrityÚ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	[        X	XVS9$ 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))r9   Úrefs)Ú_extract_indexr'   Ú_homogenizer   ÚlenÚ
isinstanceÚnpÚndarrayr   ÚndimÚ
ValueErrorr0   )
ÚarraysÚcolumnsÚindexr7   r8   r9   r>   ÚxÚarrÚaxess
             Ú_/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pandas/core/internals/construction.pyÚarrays_to_mgrrN   `   s  € ö à‰=Ü" 6Ó*‰Eä  Ó'ˆEô # 6°%Ó8‰ˆ�ô ˜UÓ#ˆÙ@FÓGÂ¸1”- °Ô6ÁˆÐGàˆvœ˜F›Ñ#ˆó ˆCä˜s¤R§Z¡Z´Ð$@×AÑAØ—8‘8˜q“=Ü�s“8œs 5›zÕ)ä ð6óð ñ ô ˜7Ó#€GÜ
ˆ7ƒ|”s˜6“{Ó"ÜÐ>Ó?Ð?ð Ð€Dä2Ø +ñð ùò/ Hs   Á Dc                ó(  • [         R                  " U 5      nUc  [        [        U5      5      nO[	        U5      nUb  [	        U5      n[        XR5      u  pg[        XgU[        U5      5      u  pgUc  Un[        XbXS9nU(       a  UR                  SS9nU$ )z9
Extract from a masked rec array and create the manager.
©r7   T©Údeep)	r   Úgetdatar&   rA   r'   Ú	to_arraysÚreorder_arraysrN   Úcopy)	ÚdatarI   rH   r7   rV   ÚfdatarG   Úarr_columnsÚmgrs	            rM   Úrec_array_to_mgrr[   ›   s‘   € ô �JŠJ�tÓ€EØ�}Üœc %›jÓ)‰ä˜UÓ#ˆàÑÜ˜wÓ'ˆÜ# EÓ3Ñ€Fô )¨¸gÄsÈ5ÃzÓRÑ€FØ�Øˆä
˜¨Ñ
<€CæØ�h‰h˜DˆhÐ!ˆØ€Jó    c                óà  • [        U [        [        [        45      (       + n[        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S 5      nS n[        U5      (       d  [        U5      (       G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(       a€  U  V	s/ s Hs  n	[        U	[        [        [        45      (       aN  [        U	R"                  5      (       a4  [        U	[        5      (       a  U	R%                  SS9OU	R%                  5       OU	PMu     n n	Uc  [        [        [        U 5      5      5      nO['        U5      n[)        XXUS9$ [        U [        [        45      (       a1  U(       d*  Ub  [+        U R"                  U5      (       a  U R,                  n[        U[.        5      (       aD  [1        U SS9n U(       a  U R%                  5       n U R                  S:X  a  U R3                  S	S5      n Oá[        U [        [        45      (       a:  U(       a  U R4                  R%                  5       n OU R4                  n [7        U 5      n OŒ[        U [        R                  [        45      (       a^  U(       a5  Ub  [+        U R"                  U5      (       a  [        R8                  " U SS
S9n O[        R:                  " U 5      n [7        U 5      n O	[=        XS9n Ub  U R"                  U:w  a  [?        U S UUSS9n [A        U R                   S   U R                   S   XS9u  p[C        XU5        U RD                  n Ucí  U(       aæ  [G        U R"                  5      (       aÌ  [I        U 5      n
U
 V	s/ s H/  n	[J        RL                  " U	SSS[        R"                  " S5      S9PM1     nn	[O        S [Q        X«SS9 5       5      (       a;  [S        U5       VVs/ s H"  u  pŒ[U        [W        US5      [Y        U5      S9PM$     nnnOÿ[Y        [[        [        U5      5      5      n[U        XUS9nU/nOÔUc§  U R"                  R\                  S:X  a�  [_        5       (       a~  [a        [        Rb                  S9n[I        U 5      n
[S        U
5       VVs/ s HC  u  nn[e        URg                  5       Ri                  UUS9[Y        [[        UUS-   5      5      SS9PME     nnnO*[Y        [[        [        U5      5      5      n[U        XUS9nU/n[        U5      S:X  a  / n[k        XÒU/SS9$ s  snf s  sn	f s  sn	f s  snnf s  snnf )N)r   r=   rP   r7   r=   TrQ   ©r7   r9   r;   éÿÿÿÿÚF)rV   Úorder©rV   )r7   rV   Úallow_2dr   )rI   rH   FúM8[s]©Úconvert_numericÚconvert_non_numericÚconvert_to_nullable_dtypeÚdtype_if_all_natc              3  ó,   #   • U  H
  u  pXLv •  M     g 7f©N© )Ú.0rJ   Úys      rM   Ú	<genexpr>Ú!ndarray_to_mgr.<locals>.<genexpr>A  s   é € ÐTÒ&S™d˜aˆq�zÒ&Sùs   ‚)Ústricté   )Ú	placement)rs   r>   ÚU)Úna_value)rE   )r8   )6rB   r   r#   r   ÚnamerI   ÚreindexrA   rC   ÚemptyÚobjectÚgetattrr   rD   rE   ÚrangeÚshaper7   rV   r'   rN   r
   Ú_referencesr   r   ÚreshapeÚ_valuesÚ
_ensure_2dr   ÚasarrayÚ_prep_ndarrayliker!   Ú	_get_axesÚ!_check_values_indices_shape_matchÚTr   Úlistr	   Úmaybe_convert_objectsÚanyÚzipÚ	enumerater.   r,   r+   ÚsliceÚkindr   r   Únanr-   Úconstruct_array_typeÚ_from_sequencer/   )ÚvaluesrI   rH   r7   rV   Úinfer_objectÚvdtyper>   ÚnrJ   Úobj_columnsÚmaybe_datetimeÚdvalÚblock_valuesÚbpÚnbÚirW   s                     rM   Úndarray_to_mgrr›   Á   s5  € ô
 " &¬9´e¼^Ð*LÓMÔM€Lä�&œ)×$Ñ$Ø‰?Ø�{‰{Ñ&Ü §¡ Ó.�Ø‰=Ø—L‘L‰Eà—^‘^ EÓ*ˆFô �6�{‰{˜wÑ2´s¸7·|±|Ü—X’X˜f¬FÑ3ˆFä�V˜W dÓ+€FØ€DÜ˜6×"Ñ"Ô&9¸%×&@Ò&@ô �fœrŸz™z¬>Ð:×;Ñ;ÀÇÁÈaÃô ˜vŸ|™|¨A™Ô/óâ/�Að ’q˜!�t”Ù/ð ð ˆFð
 �XˆFö ñ  óò
  �Aô ˜a¤.´%¼Ð!C×DÑDÜ'¨¯©×0Ñ0ô '1°´E×&:Ñ&:�—‘˜T�Ñ"ÀÇÁÄð òñ  ð ð ð ‰?ÜœE¤# f£+Ó.Ó/‰Gä" 7Ó+ˆGä˜V¨eÈdÑSÐSä�&œ9¤eÐ,×-Ñ-Þ˜™¬.¸¿¹Àu×*MÑ*MØ×%Ñ%ˆDä�&œ.×)Ñ)ô ˜v°TÑ:ˆÞØ—[‘[“]ˆFØ�;‰;˜!ÓØ—^‘^ B¨Ó*ˆFøä	�FœY¬Ð.×	/Ñ	/ÞØ—^‘^×(Ñ(Ó*‰Fà—^‘^ˆFä˜FÓ#‰ä	�FœRŸZ™Z¬Ð8×	9Ñ	9æ�U‘]¤n°V·\±\À5×&IÑ&Iô —X’X˜f¨4°sÑ;‰Fä—Z’Z Ó'ˆFÜ˜FÓ#‰ô
 # 6Ñ5ˆàÑ˜VŸ\™\¨UÓ2äØØØØØñ
ˆô Ø�‰�Q‰˜Ÿ™ a™°ñ�N€Eô & f°WÔ=à�X‰X€Fð
 �}ž¬/¸&¿,¹,×*GÑ*GÜ˜6“lˆñ !ó
ò !�ô ×%Ò%Øð !&Ø$(Ø*/Ü!#§¢¨'Ó!2ôñ !ð 	ð 
ô ÑT¤c¨+ÈdÒ&SÓT×TÑTô  )¨Ô8ôâ8‘G�Aô Ô/°°aÓ8ÄNÐSTÓDUÔVÙ8ð ñ ˆLô
  ¤¤c¨'£lÓ 3Ó4ˆBÜ˜f¸Ñ>ˆBØ˜4‰LØ	‰˜6Ÿ<™<×,Ñ,°Ó3Ô8J×8LÑ8LÜ¤R§V¡VÑ,ˆä˜6“lˆô % [Ô1ô
ò 2‘��4ô Ø×*Ñ*Ó,×;Ñ;¸DÈÐ;ÐNÜœu Q¨¨A©›Ó/Øôñ
 2ð 	ñ 
ˆô œE¤# g£,Ó/Ó0ˆÜ˜&°TÑ:ˆØ�tˆä
ˆ7ƒ|�qÓàˆä+Ø Ð&¸ñð ùòCùòùòV
ùóùó
s    Ä8WÅA:WÐ'6WÒ)W$Õ A
W*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|   rA   rF   )r�   rI   rH   ÚpassedÚimplieds        rM   r„   r„   e  s�   € ð ‡|�|�A�œ#˜g›,Ó&¨&¯,©,°q©/¼SÀ»ZÓ*Gð �<‰<˜‰?˜aÕ,¤# e£*Ö,ÜÐHÓIÐIà—‘ˆÜ�u“:œs 7›|Ð,ˆÜÐ5°f°XÐ=MÈgÈYÐWÓXÐXð +Hr\   ©r7   rV   c               óÌ  • UGb«  [        U5      nUb9  [        U[        R                  5      (       d  UR                  /[        U5      -  nO[        R                  /[        U5      -  n[        5       n[        U R                  5       5      n[        U R                  5       5      n[        U5       HT  u  pš UR                  U
5      nX‹   nXÅU	'   [        U5      (       d  M1  [!        U5      (       d  MC  UR                  U	5        MV     UcD  U(       a1  [#        [        U5       V	Vs/ s H  u  pœX–;  d  M  UPM     snn	5      nO[#        U5      nO[        U5      nU(       aN  [%        U5      (       d>  U H8  n	['        XY   [        U5      Ub  UO[        R                  " S5      5      nXÕU	'   M:     Og[)        [        U R                  5       5      5      nU(       a  [+        U5      O
[-        S5      nU Vs/ s H  n[.        R0                  " X   5      PM     nnU(       aŠ  U Vs/ s H}  n[        U[2        5      (       a  UR5                  5       OT[        U[*        5      (       d/  [        U[6        5      (       a)  [9        UR                  5      (       a  UR5                  SS9OUPM     nn[;        XRXUS9$ ! [         a    UR                  U	5         GM"  f = fs  sn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__
ry   r   TrQ   r^   )r'   rB   rC   r7   ru   rA   r�   ÚsetÚkeysr†   r�   rŠ   Úget_locÚKeyErrorÚaddr   r   r?   r   r   r)   r#   r&   ÚcomÚmaybe_iterable_to_listr   rV   r   r   rN   )rW   rI   rH   r7   rV   rG   ÚmidxsÚ	data_keysÚdata_valuesrš   ÚcolumnÚidxr   rK   r¢   ÚkrJ   s                    rM   Údict_to_mgrr®   w  su  € ð  ÒÜ˜wÓ'ˆØÑ¤Z°´r·x±x×%@Ñ%@à—n‘nÐ%¬¨G«Ñ4‰Fä—f‘f�X¤ G£Ñ,ˆFÜ“ˆÜ  §¡£Ó-ˆ	Ü˜4Ÿ;™;›=Ó)ˆä" 7Ö+‰IˆAðØ×'Ñ'¨Ó/�ð  Ñ$ˆEØ�1‰IÜ˜×Ó¤D¨§K£KØ—	‘	˜!–ñ ,ð ‰=ö Ü&Ü+4°VÔ+<ÔOÒ+<™x˜qÀÁ—UÑ+<ÒOó‘ô ' vÓ.‘ä  Ó'ˆEö Ô)¨%×0Ñ0ã�Ü8Ø‘IÜ˜“JØ"Ñ.‘E´B·H²H¸XÓ4Fó�ð
  �q“	ñ øô '¤t¨D¯I©I«KÓ'8Ó9ˆÞ!%”%˜”+¬=¸Ó+;ˆÙ?CÓDºt¸!”#×,Ò,¨T©WÖ5¹tˆÐDæñ  ó
ò �ô ˜a¤×0Ñ0ð —‘”ô
 # 1¤e×,Ñ,Ü& q¬)×4Ñ4Ô9LÈQÏWÉW×9UÑ9Uð —F‘F �FÑ%ð
 ò	ñ ð 	ð 
ô  ˜¨%È$ÑOÐOøôo ó Ø—	‘	˜!”Ûðüó Pùò* Eùò

s+   Â6J3Ä%K
Ä4K
Ç3"KÈ"BK!Ê3KËK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   rP   )	r   r'   Ú_fieldsrT   rB   r   Ú_get_names_from_indexr&   rA   )rW   rH   rI   r7   rG   s        rM   Únested_data_to_arraysr²   Ï  sz   € ô �d˜1‘g×Ñ 7¡?Ü˜t A™wŸ™Ó/ˆä °UÑ;�O€FÜ˜7Ó#€Gà�}Ü�d˜1‘gœy×)Ñ)Ü)¨$Ó/‰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   rE   r=   rr   )rA   r   rz   rB   r   rE   )rW   s    rM   Útreat_as_nestedr´   é  sc   € ô
 	ˆD‹	�A‰÷ 	FÜ˜˜a™Ó!÷	Fä�D˜‘G˜V QÓ'¨1Ñ,÷	Fô ˜D¤.Ó1×D°d·i±iÀ1±nÔ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   rP   .c                ó~   • [        U 5      (       a  [        U [        5      (       a  U $ [        U SS9n [	        U 5      nU$ )NTr;   )r   rB   r   r   r   )ÚvÚress     rM   ÚconvertÚ"_prep_ndarraylike.<locals>.convert  s9   € Ü˜A�‰¤*¨Q´×"=Ñ"=ØˆHä˜!¨4Ñ0ˆÜ$ QÓ'ˆð ˆ
r\   )rA   rC   rx   ry   rB   r{   r    Únewaxisr   r   rD   rE   r€   )r�   rV   rK   r¹   r·   s        rM   r‚   r‚   ø  sç   € ô ˆ6ƒ{�aÓô �xŠx˜¤fÑ-Ð-Ü	�FœE×	"Ñ	"Ü˜vÓ&ˆØ�3œŸ
™
�?Ñ#Ð#òô �F˜1‘I×ÑÜ—’©vÓ6ªv¨!˜7 1ž:©vÑ6Ó7‰Ü	�F˜1‘IœrŸz™z×	*Ñ	*¨v°a©y¯~©~ÀÓ/Bä—’©vÓ6ªv¨!˜7 1ž:©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   rr   zMust pass 2-d input. shape=)rE   r~   r|   rF   )r�   s    rM   r€   r€     s\   € ð ‡{�{�aÓØ—‘ §¡¨a¡°!Ð 4Ó5ˆð €Mð 
�‰˜Ó	ÜÐ6°v·|±|°nÐEÓFÐFØ€Mr\   c                óv  • S n/ n/ nU  GHª  n[        U[        [        45      (       ar  Ub  UR                  U5      n[        U[        5      (       a   UR                  ULa  UR                  U5      nUR                  UR                  5        UR                  nGO[        U[        5      (       aÁ  Uc  UR                  S5      n[        U[        [        45      (       a  [        U5      nO[        U5      n[        U[        5      (       d9  UR                  (       a(  SSKJn  U" U5      R                  U5      R                  nO-["        R$                  " XcR                  [&        R(                  S9n[+        XaUSS9n[,        R.                  " Xa5        UR                  S 5        UR                  U5        GM­     XE4$ )NÚOr   )ÚSeries)ÚdefaultFrŸ   )rB   r   r#   ÚastyperI   rw   Úappendr}   r   Údictr"   r%   r   r$   ÚhasnansÚpandasr¿   r	   Úfast_multigetrC   r�   r!   r¦   Úrequire_length_match)rW   rI   r7   ÚoindexÚhomogenizedr>   Úvalr¿   s           rM   r@   r@   )  s^  € ð €FØ€Kà€DäˆÜ�cœI¤uÐ-×.Ñ.ØÑ Ø—j‘j Ó'�Ü˜#œy×)Ñ)¨c¯i©i¸uÒ.Dð —k‘k %Ó(�Ø�K‰K˜Ÿ™Ô(Ø—+‘+ŠCä˜#œt×$Ñ$ð ‘>Ø"Ÿ\™\¨#Ó.�Fä˜e¤m´^Ð%D×EÑEä% cÓ*‘Cô ˜s›)�Cä! %¬×4Ñ4¸¿¿õ .á  ›+×-Ñ-¨eÓ4×<Ñ<‘Cô ×+Ò+¨C·±ÌÏÉÑP�Cä  °5¸uÑEˆCÜ×$Ò$ SÔ0Ø�K‰K˜Ôà×Ñ˜3×ñO ðR ÐÐr\   c                óÞ  • [        U 5      S:X  a  [        S5      $ [        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(       az  [        U5      S:”  a  [!        S	5      eU(       a  [!        S
5      eUR%                  5       nU(       a,  U[        W5      :w  a  SU S[        U5       3n	[!        U	5      eO[        U5      n['        W5      $ )zJ
Try to infer an Index from the passed data, raise ValueError on failure.
r   FTrE   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 )rA   r&   r¡   rB   r   rÂ   rI   rÃ   r†   r¢   r   rz   r¥   rC   rD   rE   rF   r*   Úpopr'   )
rW   Úraw_lengthsÚindexesÚhave_raw_arraysÚhave_seriesÚ
have_dictsrÊ   rI   Ú
raw_lengthÚmsgs
             rM   r?   r?   ]  s£  € ô
 ˆ4ƒy�Aƒ~Ü˜QÓÐä“%€KØ,.€Gà€OØ€KØ€JãˆÜ�cœ9×%Ñ%ØˆKØ�N‰N˜3Ÿ9™9Ö%Ü˜œT×"Ñ"ØˆJØ�N‰Nœ4 §¡£
Ó+Ö,Ü˜#×Ñ¤7¨3°¸Ó#:¸aÓ#?Ø"ˆOØ�O‰OœC ›HÖ%Ü˜œRŸZ™Z×(Ó(¨S¯X©X¸­\ÜÐKÓLÐLñ ö ž;ÜÐMÓNÐNæÜ˜gÓ&‰Þ	Ü˜g¨EÑ2ˆæÜˆ{Ó˜aÓÜÐDÓEÐEæÜØNóð ð !—_‘_Ó&ˆ
ÞØœS ›ZÓ'à# J <ð 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$ )z9
Preemptively (cheaply) reindex arrays with new columns.
r_   rP   )	ÚequalsÚget_indexerrŠ   rC   rx   ry   Úfillr�   rÂ   )	rG   rY   rH   ÚlengthÚ
new_arraysÚindexerrš   r­   rK   s	            rM   rU   rU   —  s�   € ð ÑØ�~‰~˜k×*Ñ*à*,ˆJØ!×-Ñ-¨gÓ6ˆGÜ! 'Ö*‘�Ø˜“7äŸ(š( 6´Ñ8�CØ—H‘HœRŸV™VÕ$à ™)�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)rv   N)rz   )rm   Úss     rM   ro   Ú(_get_names_from_index.<locals>.<genexpr>³  s   é € ÐKÂdÀœ  6¨4Ó0¸Õ<Âdùs   ‚r   rv   zUnnamed r=   )rˆ   r&   rA   r†   r{   rŠ   rz   r#   )rW   Úhas_some_namerI   Úcountrš   rß   r“   s          rM   r±   r±   ²  s‰   € ÜÑKÁdÓKÓK€MÞÜœS ›YÓ'Ð'ä ¤¤s¨4£yÓ!1Ó2€EØ€EÜ˜$–‰ˆÜ�A�v˜tÓ$ˆØ‰=Ø�!‹Hà! % Ð)ˆE‰HØ�Q‰JŠEñ  ô �‹<Ðr\   c                ót   • Uc  [        U 5      nO[        U5      nUc  [        U5      nX#4$ [        U5      nX#4$ rk   )r&   r'   )ÚNÚKrI   rH   s       rM   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)rW   rç   s     rM   Ú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      (       aP  U R                  R
                  b9  Uc  [        U R                  R
                  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  p‘X‘4$ 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   rr   )rA   rB   rC   rD   r7   Únamesr'   rŠ   rE   r#   r†   ÚtupleÚ_list_to_arraysr   ÚMappingÚ_list_of_dict_to_arraysr   Ú_list_of_series_to_arraysÚ_finalize_columns_and_data)
rW   rH   r7   rv   rG   rš   rK   r­   rJ   Úcontents
             rM   rT   rT   ÷  s­  € ô$ ˆt�9‰9Ü�dœBŸJ™J×'Ñ'Ø�z‰z×ÑÑ+ä& t§z¡z×'7Ñ'7Ó8�Ù18Ó9²¨˜tœ*±�Ð9ä�t“9 “>ô #,¨FÖ"3™˜ØŸ8™8 q�=Ø(+ªA¨q¨D©	˜F›Iñ #4ð �Ð&Ø”< Ó#Ð#Ð#ä	�Dœ"Ÿ*™*×	%Ñ	%¨$¯*©*×*:Ñ*:Ñ*Fà‰?Ü˜DŸJ™J×,Ñ,Ó-ˆGÙ#*Ó+¢7˜a�q”'¡7ˆÐ+ØˆÐä�$�q‘'œD¤%˜=×)Ñ)Ü˜dÓ#‰Ü	�D˜‘GœSŸ[™[×	)Ñ	)Ü.¨tÓ=‰ˆˆWÜ	�D˜‘GœY×	'Ñ	'Ü0°Ó?‰ˆˆWñ #'Ó'¢$˜Q”�a–¡$ˆÐ'Ü˜dÓ#ˆä1°#ÀÓFÑ€GØÐÐùò? :ùò  ,ùò (s   Á*G0Ä&G5Æ=G:c                ó’   • [        U S   [        5      (       a  [        R                  " U 5      nU$ [        R                  " U 5      nU$ )Nr   )rB   rí   r	   Úto_object_array_tuplesÚto_object_array)rW   ró   s     rM   rî   rî   0  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                  " X˜5      5        M”     [        R                  " U5      n
X¡4$ s  snf )NFrÌ   rI   Tr;   )rB   r   r   r(   rz   r&   rA   ÚidrØ   r   rÂ   r   Útake_ndrC   Úvstack)rW   rH   rJ   Ú	pass_dataÚindexer_cacheÚaligned_valuesrß   rI   rÜ   r�   ró   s              rM   rñ   rñ   ;  sæ   € ð �á $ÓQ¢˜1¬
°1´yÄ,Ð6O×(P—Q¡ˆ	ÐQÜ(¨¸Ñ?ˆà+-€Mà€NÛˆÜ˜˜7 DÓ)ˆØ‰=Ü!¤# a£&Ó)ˆEäˆe‹9˜Ó%Ø#¤B u£IÑ.‰Gà16×1BÑ1BÀ7Ó1KÐKˆG¤B u£IÑ.ä˜q°Ñ5ˆØ×Ñœj×0Ò0°ÓAÖBñ ô �iŠi˜Ó'€GØÐÐùò) Rs
   ˆC2«C2c                óf  • U  Vs/ s H"  n[        U5      [        L a  UO
[        U5      PM$     n nUcX  S U  5       n[        S U  5       5      (       + n[        R                  " X4S9n[        U5      n[        R                  " X5      nXa4$ [        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rk   )r†   r¢   )rm   rJ   s     rM   ro   Ú*_list_of_dict_to_arrays.<locals>.<genexpr>v  s   é € Ð,¢t !Œt�A—F‘F“H�~ˆ~¢tùs   ‚&(c              3  óB   #   • U  H  n[        U[        5      v •  M     g 7frk   )rB   rÃ   )rm   Úds     rM   ro   r   w  s   é € Ð9²D¨q”z !¤T×*Ð*²Dùó   ‚rÌ   )ÚtyperÃ   rˆ   r	   Úfast_unique_multiple_list_genr'   Údicts_to_arrayr†   )rW   rH   r  ÚgenrÍ   Úpre_colsró   s          rM   rð   rð   Z  sª   € ñ2 8<Ó<²t°!”�a“œD’‰A¤d¨1£gÒ-±t€DÐ<à�Ù,¡tÓ,ˆÜÑ9±DÓ9Ó9Ô9ˆÜ×4Ò4°SÑDˆÜ˜xÓ(ˆô ×$Ò$ TÓ4ˆð ÐÐô ×$Ò$ T¬4°«=Ó9ˆàÐÐùò =s   …)B.c                óè   • [        U R                  5      n [        X15      nU(       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   rP   )	r†   r…   Ú_validate_or_indexify_columnsÚAssertionErrorrF   r7   rC   Úobject_Úconvert_object_array)ró   rH   r7   ÚcontentsÚerrs        rM   rò   rò   „  sk   € ô �G—I‘I‹€Hð'Ü/°ÓBˆö
 �H˜Q‘K×%Ñ%¬¯©Ó3Ü'¨Ñ>ˆàÐÐøô ó 'ä˜‹o 3Ð&ûð'ús   —A Á
A1Á A,Á,A1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rk   )rB   r†   )rm   Úcols     rM   ro   Ú0_validate_or_indexify_columns.<locals>.<genexpr>¸  s   é € ð 7
Ú-4 cŒJ�sœD×!Ð!ªWùr  z! columns passed, passed data had z columnsr=   z<Length of columns passed for MultiIndex columns is differentr   )r&   rA   rB   r†   Úallr  rF   )ró   rH   Ú
is_mi_listr  s       rM   r
  r
  š  s  € ð4 �Ü¤ G£Ó-ˆð2 €Nô-   ¬Ó.÷ 
´3ñ 7
Ù-4ó7
ó 4
ˆ
ö œc '›l¬c°'«lÓ:ä Ü�w“<�.Ð AÄ#ÀgÃ,ÀÈxÐXóð ö ä©Ó0ª ”C˜–H©Ñ0Ó1°AÓ5Ü ØRóð ö
 œ3˜w q™z›?¬c°'«lÓ:Ü Ü˜7 1™:“Ð'Ð'HÜ˜7“|�n Hð.óð ð €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  TS:g  =(       d    [        T[        5      n[        R
                  " U TUS9n Tcö  U R                  [         R                  " S5      :X  a‡  TS:g  n[        R
                  " U SSU[         R                  " S5      S9n U(       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_floatrh   FTrd   re   rP   Úiufbrb   rŸ   ÚmM)rC   r7   rB   r   r	   r‡   r   rŽ   r�   rD   rŒ   Úpd_arrayr   r   )	rK   Úto_nullablerh   Ú	new_dtypeÚarr_clsÚclsÚcoerce_floatr7   Údtype_backends	         €€€rM   r¹   Ú%convert_object_array.<locals>.convertç  sv  ø€ Ø”B—H’H˜S“MÔ!ð (¨7Ñ2×X´jÀÌÓ6XˆKÜ×+Ò+ØØ&Ø*5ñˆCð ‰}Ø—9‘9¤§¢¨£Ó-à0=ÀÑ0HÐ-Ü×3Ò3Øð ).Ø,0Ø2KÜ)+¯ª°'Ó):ñ�Cö 1°S·Y±YÄ"Ç(Â(È3Ã-Ó5OÜ$/£M˜	Ø"+×"@Ñ"@Ó"B˜Ø%×4Ñ4°SÐ4ÐJ˜ð& ˆ
ð% # gÓ-´*¸SÄ"Ç*Á*×2MÑ2MØ—y‘y—~‘~¨Ó/Ü& s°Ñ7˜ð  ˆ
ô ˜E¤>×2Ñ2ð ×0Ñ0Ó2�Ø×(Ñ(¨°EÀÐ(ÐF�ð ˆ
ð —‘˜tÓ#ô -¨S°%Ó8�àˆ
r\   rl   )ró   r7   r"  r!  r¹   rK   rG   s    ```   rM   r  r  Ñ  s-   ú€ ÷,4ñl '.Ó.¢g˜sˆg�cŽl¡g€FÐ.à€Mùò /s   �%)
rH   r#   r7   úDtypeObj | Noner8   Úboolr9   r%  Úreturnr5   )rW   znp.rec.recarray | np.ndarrayr7   r$  rV   r%  r&  r5   )r7   r$  rV   r%  r&  r5   )r�   ú
np.ndarrayrI   r#   rH   r#   r&  ÚNone)rW   rÃ   r7   r$  rV   r%  r&  r5   )
rW   r2   rH   úIndex | NonerI   r)  r7   r$  r&  z$tuple[list[ArrayLike], Index, Index])r&  r%  )T)rV   r%  r&  r'  )r�   r'  r&  r'  )rI   r#   r7   r$  r&  z!tuple[list[ArrayLike], list[Any]])r&  r#   )
rG   úlist[ArrayLike]rY   r#   rH   r)  rÚ   Úintr&  útuple[list[ArrayLike], Index])
rä   r+  rå   r+  rI   r)  rH   r)  r&  ztuple[Index, Index]rk   )rH   r)  r7   r$  r&  r,  )rW   zlist[tuple | list]r&  r'  )rW   r†   rH   r)  r&  útuple[np.ndarray, Index])rW   z
list[dict]rH   r)  r&  r-  )ró   r'  rH   r)  r7   r$  r&  r,  )ró   zlist[np.ndarray]rH   r)  r&  r#   )r  F)
ró   zlist[npt.NDArray[np.object_]]r7   r$  r"  Ústrr!  r%  r&  r*  )cÚ__doc__Ú
__future__r   Úcollectionsr   Útypingr   r   r  rC   r   Úpandas._configr   Úpandas._libsr	   Úpandas.core.dtypes.astyper
   Úpandas.core.dtypes.castr   r   r   r   Úpandas.core.dtypes.commonr   r   r   r   r   r   Úpandas.core.dtypes.dtypesr   r   Úpandas.core.dtypes.genericr   r   Úpandas.core.dtypes.missingr   Úpandas.corer   r   r¦   Úpandas.core.arraysr   Úpandas.core.arrays.string_r   Úpandas.core.constructionr   r  r   r    r!   Úpandas.core.indexes.apir"   r#   r$   r%   r&   r'   r(   r)   r*   Úpandas.core.internals.blocksr+   r,   r-   r.   Úpandas.core.internals.managersr/   r0   Úcollections.abcr1   r2   Úpandas._typingr3   r4   r5   r6   rN   r[   r›   r„   r®   r²   r´   r‚   r€   r@   r?   rU   r±   rƒ   rê   rT   rî   rñ   rð   rò   r
  r  rl   r\   rM   Ú<module>rD     sF  ðñõ
 #å ÷ó
 Ý å -å å 4÷ó ÷÷ ÷÷õ ,÷õ .Ý 2÷ó ÷
÷ 
õ 
÷ó ÷ö
 ÷÷
ó ð "Ø!Øñ8àð8ð
 ð8ð ð8ð ð8ð õ8ðvØ
&ðð ð	ð
 ðð ôðLaØ#2ðaØ:>ðaàôaðHYØðYØ$ðYØ/4ðYà	ôYð. "ØñUPØ
ðUPð
 ðUPð ðUPð õUPðp"Ø
ð"àð"ð ð"ð ð	"ð
 *ô"ô4	ö#ôLð1Øð1Ø.ð1à&ô1ôh7ðtØðØ*/ðØ:FðØPSðà"ôô6ð$Ø
ðØðØ'ðØ2>ðàôò$#ðD ;?ð6Øð6Ø(7ð6à"õ6ôrðØ
ðàðð ôð>'Ø
ð'àð'ð ô'ðTØðàðð ðð #ô	ð,4Øð4Ø(4ð4à
ô4ðt !Øð	NØ*ðNàðNð ðNð ð	Nð
 öNr\   