ujddlmZddlZddlmZmZmZmZmZddl Z ddl Z ddl m Z ddlmZddlmZddlmcmZddlmZddlmZdd lmZmZdd lmZdd lm Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,ddl-m.Z.ddl/Z0ddl/m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBddlCmDZDddlEmFZFddlGmHZHddlImJZJerddlKmLZLmMZMddlNmOZO dA dBdZPdCdZQ dD dEdZR dFdZSede jdddddddfe jd  dGd!ZU dH dId"ZV dJ dKd#ZWdLd$ZX dMe jd  dNd%ZY dO dPd&ZZ dQ dRd'Z[ dS dTd(Z\ dU dVd)Z] dW dXd*Z^ dYdd, dZd-Z_eddde je je jd.f d[d/Z`edeed0d1dddde jd+dde jde je jd2f dd+d3 d\d4Zaedeed0d1eed5dd67dddddd+e jd+dd+e jde je jd8f d]d9Zbd^d:Zcd_d;Zdd`d<Zedad=Zf dbd>Zgdcd?Zh dd ded@Ziy)f) annotationsN) TYPE_CHECKINGAnyLiteralNoReturncast)lib)is_matching_na) SparseIndex)compare_mismatched_resolutions)Pandas4Warning)deprecate_kwarg set_module)find_stack_level)'construct_1d_object_array_from_listlike)is_boolis_float_dtypeis_integer_dtype is_numberis_numeric_dtypeneeds_i8_conversion)CategoricalDtypeDatetimeTZDtypeExtensionDtype NumpyEADtype)array_equivalent) CategoricalCategoricalIndex DataFrame DatetimeIndexIndex IntervalDtype IntervalIndex MultiIndex PeriodIndex RangeIndexSeriesTimedeltaIndex) DatetimeArrayExtensionArray IntervalArray PeriodArrayTimedeltaArray)DatetimeLikeArrayMixin) StringDtype)safe_sort_index) pprint_thing) ContainerIterable)DtypeObjequivh㈵>:0yE>c  t|trt||fd|||d|yt|trt ||fd|||d|yt|t rt ||fd|||d|y|rut|r t|rn^t|r t|rnGt|tjst|tjrd}nd}t|||tj||ft|||d|y) at Check that the left and right objects are approximately equal. By approximately equal, we refer to objects that are numbers or that contain numbers which may be equivalent to specific levels of precision. Parameters ---------- left : object right : object check_dtype : bool or {'equiv'}, default 'equiv' Check dtype if both a and b are the same type. If 'equiv' is passed in, then `RangeIndex` and `Index` with int64 dtype are also considered equivalent when doing type checking. rtol : float, default 1e-5 Relative tolerance. Only applied to numeric dtypes; values of other dtypes, such as interval, are always compared exactly. atol : float, default 1e-8 Absolute tolerance. Only applied to numeric dtypes; values of other dtypes, such as interval, are always compared exactly. F) check_exactexactrtolatol)r9 check_dtyper;r< numpy arrayInputobj)r=r;r<N) isinstancer!assert_index_equalr'assert_series_equalrassert_frame_equalrrnpndarrayassert_class_equal_testingassert_almost_equalbool)leftrightr=r;r<kwargsrAs d/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/_testing/asserters.pyrJrJQs,:$       D& !   #    D) $   #    9U#375>dBJJ/:eRZZ3P'C!C"4C8 $$ % %)+%6T PV c |j}t||st|d|dt|dt||st|d|dt|dy)a Helper method for our assert_* methods that ensures that the two objects being compared have the right type before proceeding with the comparison. Parameters ---------- left : The first object being compared. right : The second object being compared. cls : The class type to check against. Raises ------ AssertionError : Either `left` or `right` is not an instance of `cls`. z Expected type z, found z insteadN)__name__rBAssertionErrortype)rLrMclscls_names rO_check_isinstancerWsv ||H dC juHT$ZL I   eS !juHT%[M J   "rPTcVt||ttj|||y)N) compare_keys)rWdictrIassert_dict_equal)rLrMrYs rOr[r[s"dE4( tUFrPcX|tjurt|ttfry|S)aw Resolve an unspecified check_freq for a Series/DataFrame axis. The hard freq check has long applied only to a flat DatetimeIndex or TimedeltaIndex, so preserve that. Freqs nested inside a MultiIndex level or inside Categorical categories were not checked before, so those go through the deprecation warning in assert_index_equal. GH#51920, GH#66761 T)r no_defaultrBr r()index check_freqs rO_resolve_check_freqr`s,S^^#  ~.) rPzpandas.testing)r_c >  d} | t|trdnd} d"d} tjur/| ||r$t j dt tdd#d$ fd } t||t| ||| |j|jk7r5| d }|jd |}|jd |}t| |||t|t|k7r3| d }t|d |}t|d |}t| ||||st|}t|}t|trtd|} tjurdn }t|jD]}| d|d} t!|j"||j"||||||| t%|j&||j&|| |j"||j"|| n|rĉr|j-|s |j.|j.k7}tt2j4std|j7d}t3j8|j;t<dzt|z }| dt3j>|dd}t| |||n>> from pandas import testing as tm >>> a = pd.Index([1, 2, 3]) >>> b = pd.Index([1, 2, 3]) >>> tm.assert_index_equal(a, b) TNr$r!c6t|txr:t|txr(t|t xrt|jxsLt|txr:t|txr(t|t xrt|jSN)rBr&r!rdtype)rLrMs rO_check_rangeindex_index_intz7assert_index_equal.._check_rangeindex_index_int1s tZ ( .5%( .uj11 .!-  uj ) -4' -tZ00 -!, rPzThe default value of 'equiv' for the `exact` parameter is deprecated and will be changed to 'True' in a future version. Please set exact to the desired value to avoid seeing this warning) stacklevelr5c`syt|||td|||t|jtrct|jtrIrFtd|||t t d|jt d|jytd|||y)N)r:rA inferred_typer@rdr)r:r_)rHassert_attr_equalrBrdrrCr categories)rLrMrAcheck_categoricalr_r:s rO _check_typesz(assert_index_equal.._check_typesIs 4e=/4C@ djj"2 3 KK)9 !!'4C@"+T2==+U3>>)  '4C8rPr@z levels are different, z length are differentz level [])r: check_namesr9rkr_r;r<rAz>types are not comparable (non-matching categorical categories)r*Y@ values are different ( %))r;r<r=rAlobjrobjnamesrdr+z_assert_index_equal will check the 'freq' attribute by default in a future version; these freqs z and zO do not match. Pass check_freq=True or check_freq=False to silence this warningfreqr category)r_rA)rLr!rMr!returnrK)r!)rLr!rMr!rAstrryNone)-rBr$r r]warningswarnr rrWr!nlevelsraise_assert_detaillenr0rrangerClevelsassert_numpy_array_equalcodesrSget_level_valuesequals_values TypeErrorrFrGfillnasumastypeintroundrKrIrJrir%r#assert_interval_array_equalr r(rwrdrassert_categorical_equal)rLrMr:ror9rk check_orderr;r<rAr___tracebackhide__rerlmsg1msg2msg3levels_check_freqlevelrtllevelrlevelmismatchdiffmsg exact_bools ` ` ` rOrCrCsd {(z:l    &tU 3 MMD+-  990dE5)u#& ||u}}$+,,,r$(--5'*CtT2 4yCJ+,d)Btf%e*Rw'CtT2 t$&$ #\5)%/#..$@Dj4<<(" LEU(5'+D "KK&LL' + +&70 )E):EKK  'yyEJJ& @@D }M ::.)BB#/1  fdEs ; djj"2 3z KK)8  %]DLL1]EMM2%e9%  8 k" ..u5//6" + +&7)    4 #T  s& AR:T:AS>=S>TTcd}dd}dd}t|t|k(ry|dk(r||r ||ry|d}t||||||y) z# Checks classes are equal. TcPt|tr|St|jSrc)rBr!rTrR)xs rO repr_classz&assert_class_equal..repr_classs! a HAwrPcHt|tuxst|tS)zClasses that are a RangeIndex (sub-)instance or exactly an `Index` . This only checks class equivalence. There is a separate check that the dtype is int64. )rTr!rBr&)idxs rOis_class_equivz*assert_class_equal..is_class_equivs CyE!@ZZ%@@rPNr5z classes are different)rrryr)rr!ryrK)rTr)rLrMr:rArrrrs rOrHrHsi  A DzT%[   $ N5$9  E' (CS*T"2Ju4EFrPcd}t||}t||}||us t||ry ||k(}|tju|tjuz rd}n t |t s|j}|sMt |ttfr7t|t|ur! tt|t|d}|sd|d}t||||y#t$rd}YwxYw#t$rd}Y5wxYw)aO Check attributes are equal. Both objects must have attribute. Parameters ---------- attr : str Attribute name being compared. left : object right : object obj : str, default 'Attributes' Specify object name being compared, internally used to show appropriate assertion message TNF strict_nanz Attribute "z" are different)getattrr rpdNArBrKalltuplelistrTrrr) attrrLrMrAr left_attr right_attrresultrs rOriris d#I%JJ.J"Gj( RUUzRUU23  %  y5$- 0 OtJ/ / %7 B7 CF D61Ci< 7 * F s#C ) C1 C.-C.1 C?>C?ct|ttfr |j}t|tj r3t |t jt j|yt|||jy)z#Assert that the sequence is sorted.N) rBr!r'rrFrGrsortarrayassert_extension_array_equalargsort)seqs rOassert_is_sortedrQsW#v'kk#rzz" bggbhhsm&<=$S#ckkm*<=rPct||tt|jtst|jtrd}nd}|rNt |j|j|d||t |j|j||dn |jj}|jj}t |||d||t |jt|jt|dtd |||y #t$r|j|j}}Y}wxYw) a$ Test that Categoricals are equivalent. Parameters ---------- left : Categorical right : Categorical check_dtype : bool, default True Check that integer dtype of the codes are the same. check_category_order : bool, default True Whether the order of the categories should be compared, which implies identical integer codes. If False, only the resulting values are compared. The ordered attribute is checked regardless. obj : str, default 'Categorical' Specify object name being compared, internally used to show appropriate assertion message. check_freq : bool, default True Whether to check the ``freq`` attribute of DatetimeIndex or TimedeltaIndex categories. .. versionadded:: 3.1.0 .. deprecated:: 3.1.0 Currently a ``freq`` mismatch only warns; in a future version ``check_freq=True`` will be the default and mismatches will raise. Pass ``check_freq`` explicitly to silence the warning. r5Tz .categories)rAr:r_z.codes)r=rAz.valuesr@orderedN) rWrrBrjr&rCrr sort_valuesrrobjectri) rLrMr=check_category_orderrAr_r:lcrcs rOrr\s7JdE;/$//:.* *3 OO   %{#!   ! JJ SE.  7,,.B!!--/B   %{#!   ! KK  LL %w iu#6) 7__e&6&6B 7s4D**!E Ect||tt|j|j|dt|j|j|dt d|||y)a- Test that two IntervalArrays are equivalent. Parameters ---------- left, right : IntervalArray The IntervalArrays to compare. obj : str, default 'IntervalArray' Specify object name being compared, internally used to show appropriate assertion message z.leftr@z.rightclosedN)rWr+ assert_equal_left_rightrirLrMrAs rOrrsR dE=1U[[Um<ell3%v?he5rPct||tt|j|j|dt d|||y)N ._ndarrayr@rd)rWr,r_ndarrayrirs rOassert_period_array_equalrs9dE;/T]]ENN3%y@QRgtU4rPcd}t||tt|j|j|dt d|||y)NTrr@tz)rWr)rrrirLrMrArs rOassert_datetime_array_equalrs?dE=1T]]ENN3%y@QRdD%S1rPctd}t||tt|j|j|dy)NTrr@)rWr-rrrs rOassert_timedelta_array_equalrs1dE>2T]]ENN3%y@QRrPc8d}|d|}t|trtj|}t|tjr|dt |z }t|tjr t |}n&t|t ttfr t|}t|tjr t |}n&t|t ttfr t|}|d|d|z }||d|z }||d|z }t|)NTz are different z [index]: z [left]: z [right]: z [diff]:  ) rBr!rFasarrayrGr1rr/rreprrS) rAmessagerLrMr first_diff index_valuesrrs rOrrs#e  C,&zz,/ , + \,7899$ #D! D+[,G HDz%$U# E,k<H IU    C  D6"" J<    rPF) class_objcd} t|||xst||tjd d} | |} | |} |dk(r| | ur)t | d| |dk(r| | urt | d| d fd } t || s | ||||rFt |tjr+t |tjrtd ||y y y y )a Check that 'np.ndarray' is equivalent. Parameters ---------- left, right : numpy.ndarray or iterable The two arrays to be compared. strict_nan : bool, default False If True, consider NaN and None to be different. check_dtype : bool, default True Check dtype if both a and b are np.ndarray. err_msg : str, default None If provided, used as assertion message. check_same : None|'copy'|'same', default None Ensure left and right refer/do not refer to the same memory area. obj : str, default 'numpy array' Specify object name being compared, internally used to show appropriate assertion message. index_values : Index | numpy.ndarray, default None optional index (shared by both left and right), used in output. class_obj : str, default None Specify object name for class comparison, internally used to show appropriate assertion message. Tr@c8t|dd |jS|S)Nbase)rrr@s rO _get_basez+assert_numpy_array_equal.._get_base=s"35AsxxJsJrPsamez is not copyz is c||j|jk7r%td|j|jd}t|j|jdD]\}}t || r|dz }|dz|j z }dt j|d d }t||| t|) Nz shapes are differentgTstrictrrprqrrrs)r) shaperzipravelrsizerFrrS) rLrMerr_msgrleft_val right_valrrrArs rO_raisez(assert_numpy_array_equal.._raiseJs ?zzU[[(#C5 56 EKKD'*4::<t'T #)') SAID  %<$))+DE0$1B0C3GC S$L QW%%rPrrdN)rA np.ndarrayryr)rLrrMrr str | Noneryr)rHrWrFrGrSrrBri)rLrMrr=r check_samerArrrr left_base right_basers ` `` rOrrsHtU (8S9dE2::.K$I5!JV J & I=!GH H v   " I=ZN!CD D&* D%J ?tUG$ dBJJ 'Jubjj,I gtU <-J 'rPr*c  |tjur|tjuro|tjur]t|jxrt |j xs-t|jxrt |j }n|tjurd}|tjur|nd}|tjur|nd}t |t sJdt |t sJd|rtd||d|t |trt |trt|t|k(rw|s*|jjd vrt |jtjs!td |jj}n"tj|jd }t |jtjs!td |jj} n"tj|jd } || k7r>t|j |j t"j$j'ry t)tj*|j,tj*|j,|| y tj*|j/} tj*|j/} t)| | |d|t |jt0r|jj2dk(rp|jj4tj6urJtj&|j | D cgc]} tj8| c} sJdt |jt0r|jj2dk(rp|jj4tj6urJtj&|j | D cgc]} tj8| c} sJd|| j;t<} || j;t<}|rt)| |||y t?j@| |tC|||||y cc} wcc} w)ai Check that left and right ExtensionArrays are equal. This method compares two ``ExtensionArray`` instances for equality, including checks for missing values, the dtype of the arrays, and the exactness of the comparison (or tolerance when comparing floats). Parameters ---------- left, right : ExtensionArray The two arrays to compare. check_dtype : bool, default True Whether to check if the ExtensionArray dtypes are identical. index_values : Index | numpy.ndarray, default None Optional index (shared by both left and right), used in output. check_exact : bool, default False Whether to compare number exactly. .. versionchanged:: 2.2.0 Defaults to True for integer dtypes if none of ``check_exact``, ``rtol`` and ``atol`` are specified. rtol : float, default 1e-5 Relative tolerance. Only used when check_exact is False, and only applied to numeric dtypes; values of other dtypes, such as interval, are always compared exactly. atol : float, default 1e-8 Absolute tolerance. Only used when check_exact is False, and only applied to numeric dtypes; values of other dtypes, such as interval, are always compared exactly. obj : str, default 'ExtensionArray' Specify object name being compared, internally used to show appropriate assertion message. .. versionadded:: 2.0.0 See Also -------- testing.assert_series_equal : Check that left and right ``Series`` are equal. testing.assert_frame_equal : Check that left and right ``DataFrame`` are equal. testing.assert_index_equal : Check that left and right ``Index`` are equal. Notes ----- Missing values are checked separately from valid values. A mask of missing values is computed for each and checked to match. The remaining all-valid values are cast to object dtype and checked. Examples -------- >>> from pandas import testing as tm >>> a = pd.Series([1, 2, 3, 4]) >>> b, c = a.array, a.array >>> tm.assert_extension_array_equal(b, c) Fr6r7zleft is not an ExtensionArrayzright is not an ExtensionArrayrdAttributes of r@mMrrN)rrAz NA mask)rArpythonzwrong missing value sentinels)rd)r=r;r<rAr)"r r]rrdrrBr*rir.rTkindrFrunit datetime_datar roperatoreqrrrasi8isnar/storagena_valuenanisnanto_numpyrrIrJrK)rLrMr=rr9r;r<rAl_unitr_unitleft_naright_naval left_valid right_valids rOrrgsF s~~% CNN " CNN " TZZ ( K 1K-KQu{{+ON5;;4O0O   & s~~-46Ds~~-46D dN +L-LL + e^ ,N.NN ,'4nSE4JK 4/0 u4 5 K4: %tzz$6djj"((3/<AA))$**5a8ekk2884/=BB))%++6q9& 2MM5>>8;;#% ! JJtyy ! JJuzz "%  jj%Gzz%**,'H#h/l 4::{+ JJ  ( * JJ  266 )vv&*mmG&< =sRXXc] =  + * +  5;; , KK  8 + KK BFF *vv&+nnX&> ?sRXXc] ?  + * + wh((v(6J "++&+9K  <  $$  [)% % > @s S;Scheck_datetimelike_compat) new_arg_namer') check_index check_likecd}|tjurI| tjur6| tjur#t|jxrt |j xs-t|jxrt |j }|j j dk(r|j jgntd|j j}|j j dk(r|j jgntd|j j}td|Dxstd|D}n|tjurd}d}n|}| tjur| nd} | tjur| nd} |s |r td t||t|rt||| t|t|k7rBt|d |j }t|d |j }t|d ||| r9|j |j k(s J|j d |j |rBt#|j |j ||||| t%|j | | | |d |r|j'|}|rIt)|jt*rt)|jt*r|snt-d||d| |r|j.}|j.}t)|t0r5t)|t0r%t3||||j t5|nz||}}t)|t0r|j7}t)|t0r|j7}t9|||t5||d|j n |rt;|jst;|jr`t=|j.j?t=|j.sd|j.d|j.d}tA|t)|jtBrPt)|jtBr6tEtd|jFtd|jFnt)|jt*st)|jt*rNtIjJ|j.|j.| | tM|t5||j nt)|jtNrUt)|jtNr;t3|j.|j.| | ||j t5|n&tQ|j|js tQ|j|jr8t3|j.|j.||j t5|nt;|jrMt;|jr8t3|j.|j.||j t5|nLtIjJ|j.|j.| | tM|t5||j |rt-d||| |r]t)|jt*st)|jt*r(tS|j.|j.|d| | yyy)a Check that left and right Series are equal. This function compares two Series and raises an ``AssertionError`` if they are not equal. It provides fine-grained control over which attributes to check, including dtype, index, names, and categorical properties. Parameters ---------- left : Series First Series to compare. right : Series Second Series to compare. check_dtype : bool, default True Whether to check the Series dtype is identical. check_index_type : bool or {'equiv'}, default 'equiv' Whether to check the Index class, dtype and inferred_type are identical. check_series_type : bool, default True Whether to check the Series class is identical. check_names : bool, default True Whether to check the Series and Index names attribute. check_exact : bool, default False Whether to compare number exactly. This also applies when checking Index equivalence. .. versionchanged:: 2.2.0 Defaults to True for integer dtypes if none of ``check_exact``, ``rtol`` and ``atol`` are specified. .. versionchanged:: 3.0.0 check_exact for comparing the Indexes defaults to True by checking if an Index is of integer dtypes. When ``check_exact=True``, the comparison of object-dtype values containing nested :class:`numpy.ndarray` objects takes the type of the nested object into account. In particular, a nested ``numpy.ndarray`` is not considered equivalent to a Python ``list``, Python ``tuple``, or a pandas :class:`~pandas.api.extensions.ExtensionArray` merely because the contained values are the same. check_datetimelike_compat : bool, default False Compare datetime-like which is comparable ignoring dtype. .. deprecated:: 3.0 check_categorical : bool, default True Whether to compare internal Categorical exactly. check_category_order : bool, default True Whether to compare category order of internal Categoricals. check_freq : bool, default True Whether to check the `freq` attribute on a DatetimeIndex or TimedeltaIndex. The index check is skipped if ``check_index=False`` or ``check_like=True``. .. deprecated:: 3.1.0 The ``freq`` attribute of a :class:`DatetimeIndex`/ :class:`TimedeltaIndex` MultiIndex level or Categorical categories is not yet checked by default; a mismatch currently only warns and will raise in a future version. Pass ``check_freq`` explicitly to silence the warning. check_flags : bool, default True Whether to check the `flags` attribute. rtol : float, default 1e-5 Relative tolerance. Only used when check_exact is False, and only applied to numeric dtypes; values of other dtypes, such as interval, are always compared exactly. atol : float, default 1e-8 Absolute tolerance. Only used when check_exact is False, and only applied to numeric dtypes; values of other dtypes, such as interval, are always compared exactly. obj : str, default 'Series' Specify object name being compared, internally used to show appropriate assertion message. check_index : bool, default True Whether to check index equivalence. If False, then compare only values. check_like : bool, default False If True, ignore the order of the index. Must be False if check_index is False. Note: same labels must be with the same data. See Also -------- testing.assert_index_equal : Check that two Indexes are equal. testing.assert_frame_equal : Check that two DataFrames are equal. Examples -------- >>> from pandas import testing as tm >>> a = pd.Series([1, 2, 3, 4]) >>> b = pd.Series([1, 2, 3, 4]) >>> tm.assert_series_equal(a, b) Trr$c38K|]}|jdvywiuNr.0rds rO z&assert_series_equal..s #(EJJ$  c38K|]}|jdvywr r rs rOrz&assert_series_equal..sDt#DrFr6r7z0check_like must be False if check_index is Falser@rmzSeries length are different != .index r:ror9rkrr_r;r<rArdr)r=rrAz values)r=rArrzatetimelike_compat=True] z is not equal to .r+)r;r<r=rAr)r;r<r=rrAnamerx)rArr_N)*r r]rrdrr^r~rdtypesr ValueErrorrWr'rHrrflagsrCr` reindex_likerBrrirr*rrzrrrr!rrSr"rrrIrJrKr0is_extension_array_dtype_and_needs_i8_conversionr)rLrMr=check_index_typecheck_series_typeror9rrkrr_ check_flagsr;r<rArrrleft_index_dtypesright_index_dtypescheck_exact_indexrr left_values right_valueslvrvrs rOrDrDshs~~% CNN " CNN " TZZ ( K 1K-KQu{{+ON5;;4O0O  zz!!Q&ZZ   lDJJ/66 {{""a'[[   lEKK077    ,=  E D1CD D   & !'s~~-46Ds~~-46D :KLLdE6*4C0 4yCJd)Btzzl+e*R }-C!>dKzzU[[(NTZZN$u{{o*NN( JJ KK"#)/&*4::zB%v   ' tzz#3 45;;(89%  gtU.8N Oll }} k> 2z .8  )'!ZZH  !,B+~6 ))+,7!**, $'H E/!ZZ   #DJJ'+>u{{+KT\\"))% *>?-dll^<##(==/4 !% % DJJ .: ]4 $ $** -tOU[[/Q  DJJ 0 1Z %6 $$ LL MM[)C  DJJ /J ^5 % LL MM#C  : EKK  9%++tzz R$ LL MM#C   TZZ (-@-M$ LL MM#C   $$ LL MM[)C &$37 djj"2 3z KK)8  %  e9%%9%  8 rP by_blocks)rrfrcRd}|tjur|nd}|tjur|nd}|tjur|nd}t||tt |j | }|rt |t|sJ|j|jk7r't||d|j|j| r9|j|jk(s J|jd|jt|j |j |||| | ||||d t|j|j|||| | | |||d  | r|j|}|r|j}|j}tt!t|j#t|j#zD]$}||vsJ||vsJt%|||||| | &yt'|jD]\}}|j)|d }|j)|d }t+j,5t+j.d dt0t3||||||| | | |d|d|d||dddddy#1swYxYw)a Check that left and right DataFrame are equal. This function is intended to compare two DataFrames and output any differences. It is mostly intended for use in unit tests. Additional parameters allow varying the strictness of the equality checks performed. Parameters ---------- left : DataFrame First DataFrame to compare. right : DataFrame Second DataFrame to compare. check_dtype : bool, default True Whether to check the DataFrame dtype is identical. check_index_type : bool or {'equiv'}, default 'equiv' Whether to check the Index class, dtype and inferred_type are identical. check_column_type : bool or {'equiv'}, default 'equiv' Whether to check the columns class, dtype and inferred_type are identical. Is passed as the ``exact`` argument of :func:`assert_index_equal`. check_frame_type : bool, default True Whether to check the DataFrame class is identical. check_names : bool, default True Whether to check that the `names` attribute for both the `index` and `column` attributes of the DataFrame is identical. by_blocks : bool, default False Specify how to compare internal data. If False, compare by columns. If True, compare by blocks. .. deprecated:: 3.1 check_exact : bool, default False Whether to compare number exactly. If False, the comparison uses the relative tolerance (``rtol``) and absolute tolerance (``atol``) parameters to determine if two values are considered close, according to the formula: ``|a - b| <= (atol + rtol * |b|)``. .. versionchanged:: 2.2.0 Defaults to True for integer dtypes if none of ``check_exact``, ``rtol`` and ``atol`` are specified. .. versionchanged:: 3.0.0 When ``check_exact=True``, the comparison of object-dtype values containing nested :class:`numpy.ndarray` objects takes the type of the nested object into account. In particular, a nested ``numpy.ndarray`` is not considered equivalent to a Python ``list``, Python ``tuple``, or a pandas :class:`~pandas.api.extensions.ExtensionArray` merely because the contained values are the same. check_datetimelike_compat : bool, default False Compare datetime-like which is comparable ignoring dtype. .. deprecated:: 3.0 check_categorical : bool, default True Whether to compare internal Categorical exactly. check_like : bool, default False If True, ignore the order of index & columns. Note: index labels must match their respective rows (same as in columns) - same labels must be with the same data. check_freq : bool, default True Whether to check the `freq` attribute on a DatetimeIndex or TimedeltaIndex index or columns. The index and columns checks are skipped if ``check_like=True``. .. deprecated:: 3.1.0 The ``freq`` attribute of :class:`DatetimeIndex`/:class:`TimedeltaIndex` columns, MultiIndex levels, and Categorical categories is not yet checked by default; a mismatch currently only warns and will raise in a future version. Pass ``check_freq`` explicitly to silence the warning. check_flags : bool, default True Whether to check the `flags` attribute. rtol : float, default 1e-5 Relative tolerance. Only used when check_exact is False, and only applied to numeric dtypes; values of other dtypes, such as interval, are always compared exactly. atol : float, default 1e-8 Absolute tolerance. Only used when check_exact is False, and only applied to numeric dtypes; values of other dtypes, such as interval, are always compared exactly. obj : str, default 'DataFrame' Specify object name being compared, internally used to show appropriate assertion message. See Also -------- assert_series_equal : Equivalent method for asserting Series equality. DataFrame.equals : Check DataFrame equality. Examples -------- This example shows comparing two DataFrames that are equal but with columns of differing dtypes. >>> from pandas.testing import assert_frame_equal >>> df1 = pd.DataFrame({"a": [1, 2], "b": [3, 4]}) >>> df2 = pd.DataFrame({"a": [1, 2], "b": [3.0, 4.0]}) df1 equals itself. >>> assert_frame_equal(df1, df1) df1 differs from df2 as column 'b' is of a different type. >>> assert_frame_equal(df1, df2) Traceback (most recent call last): ... AssertionError: Attributes of DataFrame.iloc[:, 1] (column name="b") are different Attribute "dtype" are different [left]: int64 [right]: float64 Ignore differing dtypes in columns with check_dtype. >>> assert_frame_equal(df1, df2, check_dtype=False) Tr6r7Fz shape mismatchrrrz.columns)r=r_rAr)axisignorez'the 'check_datetimelike_compat' keyword)rcategoryz .iloc[:, z] (column name="z")) r=rr9rorrkr_rAr;r<rrN)r r]rWrr`r^rBrTrrrrCcolumnsr_to_dict_of_blocksrsetkeysrE enumerate_ixsr|catch_warningsfilterwarningsr rD)rLrMr=rcheck_column_typecheck_frame_typeror'r9rrkrr_rr;r<rAr_rtol_atol _check_exact _check_freqrblockslblocksrdicollcolrcols rOrErEEsd.DFE.DFE"-S^^"C;LdE9- &djj*=K$U ,,, zzU[[  C5(TZZN  zzU[[(NTZZN$u{{o*NN(   +"N  e6N    +"N  e8    '**,))+#d7<<>2T',,.5IIJK EG# ##G# ## '%     -" FAs99QQ9'D::aa:(D ((* ''E+ $ +%5 + +.G&7 *%y+;C5C % %#   "   s ?JJ& c d}t|tr6t|ttfr|j ddt ||fi|yt|t rt||fi|yt|trt||fi|yt|trt||fi|yt|trt||fi|yt|trt||fi|yt|t rt#||fi|yt|t$rt'||fi|yt|t(j*rt-||fi|yt|t.r|ik(sJ||k(sJy|ik(sJt1||y)aC Wrapper for tm.assert_*_equal to dispatch to the appropriate test function. Parameters ---------- left, right : Index, Series, DataFrame, ExtensionArray, or np.ndarray The two items to be compared. **kwargs All keyword arguments are passed through to the underlying assert method. Tr_N)rBr!r r( setdefaultrCr'rDrrEr+rr,rr)rr-rr*rrFrGrrzrJ)rLrMrNrs rOrrHsH$ d]N; <   lD 141&1 D& !D%262 D) $41&1 D- (#D%:6: D+ &!$88 D- (#D%:6: D. )$T5;F; D. )$T5;F; D"** % u77 D# ||u}}||D%(rPct||tjjt |j |j t |jtsJt |jtsJ|j}|j}|j|stdd||n td||td||t |j|jy)z Check that the left and right SparseArray are equal. Parameters ---------- left : SparseArray right : SparseArray zSparseArray.indexzindex are not equal fill_valuerdN) rWrarrays SparseArrayr sp_valuesrBsp_indexr rrrito_dense)rLrM left_index right_indexs rOassert_sp_array_equalrLtsdE299#8#89T^^U__= dmm[ 11 1 ennk 22 2J..K   [ ) !6 K lD%0gtU+T]]_enn.>?rPc.|D]}||vrJd|y)NzDid not contain item: )iterabledicks rOassert_contains_allrRs* 8Cx71!77x8rPc t||dD]8\}}t||fi|dt|dt|d}||ur3J|y)z iter1, iter2: iterables that produce elements comparable with assert_almost_equal Checks that the elements are equal, but not the same object. (Does not check that items in sequences are also not the same object) TrzExpected object z and object z8 to be different objects, but they were the same object.N)rrJrT)iter1iter2 eql_kwargselem1elem2rs rO assert_copyrYskE56' uE57J7tE{o\$u+I@ @ E!&3&! 'rPc<t|txr t|S)z Checks that we have the combination of an ExtensionArraydtype and a dtype that should be converted to int64 Returns ------- bool Related to issue #37609 )rBrr) left_dtype right_dtypes rOrrs j. 1 V6I+6VVrPc|j|}t|j||t|jst|||yy)z_ Check that ser.iloc[i_slc] matches ser.loc[l_slc] and, if applicable, ser[l_slc]. N)ilocrDlocrr^)serl_slci_slcexpecteds rO!assert_indexing_slices_equivalentrdsB xxH1 CII &CJ1 'rPcr|jD](}t||d}||J|t||dk(r(Jy)z: Check that ._metadata attributes are equivalent. N) _metadatar)rLrMrrs rOassert_metadata_equivalentrgsK 5dD$' =; ;'%t44 44 5rP)r5r6r7)rLrrMrr=bool | Literal['equiv']r;floatr<rirNrryr{)rLrrMrrUrTryr{)T)rLdict[Any, Any]rMrjrYrKryr{)r^r!r_bool | lib.NoDefaultryrk)rLr!rMr!r:zbool | str | lib.NoDefaultrorKr9rKrkrKrrKr;rir<rirArr_rkryr{)Tr?) rLrrMrr:z bool | strrArzryr{) Attributes) rrzrLrrMrrArzryr{)rz,Index | Series | np.ndarray | ExtensionArrayryr{)TTr)rLrrMrr=rKrrKrArzr_rkryr{)r+)rLr+rMr+rArzryr{)r,)rLr,rMr,rArzryr{)r))rLr)rMr)rArzryr{)r-)rLr-rMr-rArzryr{)NNN)rArrrzrLrrMrrrrrrIndex | np.ndarray | Noneryr)FTNNr>N)rLrrMrrrKr=rhrrrzLiteral['copy', 'same'] | NonerArzrrmrrryr{)rLr*rMr*r=rhrrmr9rkr;float | lib.NoDefaultr<rnrArzryr{)$rLr'rMr'r=rhrrhrrKrorKr9rkrrKrkrKrrKr_rkrrKr;rnr<rnrArzrrKrrKryr{)$rLrrMrr=rhrrhr5rhr6rKrorKr'rKr9rkrrKrkrKrrKr_rkrrKr;rnr<rnrArzryr{)rLrrMrrNrryr{)rLrrMrryr{)rO Iterable[Any]rPzContainer[Any]ryr{)rTrorUrorVrryr{)r[r4r\r4ryrK)r`r'raslicerbrpryr{rc)rLzDataFrame | SeriesrMzDataFrame | Series | Noneryr{)j __future__rrtypingrrrrrr|numpyrF pandas._libsr pandas._libs.missingr pandas._libs.sparser pandas._libs.testing_libstestingrIpandas._libs.tslibs.np_datetimer pandas.errorsr pandas.util._decoratorsrrpandas.util._exceptionsrpandas.core.dtypes.castrpandas.core.dtypes.commonrrrrrrpandas.core.dtypes.dtypesrrrrpandas.core.dtypes.missingrpandasrrrrr r!r"r#r$r%r&r'r(pandas.core.arraysr)r*r+r,r-pandas.core.arrays.datetimeliker.pandas.core.arrays.string_r/pandas.core.indexes.apir0pandas.io.formats.printingr1collections.abcr2r3pandas._typingr4rJrWr[r`r]rCrHrirrrrrrrrrrDrErrLrRrYrrdrgrNrPrOrs"/+''J(5K 8    C233 ( ,3 Q Q Q )Q   Q  Q  Q  Q h :GKG G!/G?CG G 2$ ),"X(+~~X X X &X X  X  XX X X X%X XXxAHG GG",G:=G GF2>6 66!$6+.6 6r>!% S7(+~~S7 S7 S7S7 S7 S7%S7 S7r6 6 6 6 627D5 5)5035 5;J2 2 -2472 2=MS S!/S69S S.2) ) ) )  )  )  ),))^+/15.2S=!S= S= S=S=) S=  S= / S= S=,S=S= S=l ,0.2(+"%.."%..[ [ [ )[ , [ & [ [  [  [  [ [ ~ !<4P,007"(+&+"!%'*~~"%.."%..x"%x x x)x. x  x  x&x $xxx%xx x x x"#x$%x& 'xQxx  !<4P4AN,00718!(+&+"'*~~"%.."%..#| | |)|. | / |  |||&| $|||%|| | !|" #|$ %|OQ|~))X@B8 '$ W W'/ W  W 2BF 5  5%> 5  5rP