MhaSSKJr SSKrSSKJrJrJrJr SSKr SSK J r SSK J r SSKJr SSKJs Jr SSKJr SSKJrJrJrJrJrJr SS KJrJrJ r J!r! SS K"J#r# SSK$r%SS K$J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0 SS K1J2r2J3r3J4r4J5r5J6r6 SS K7J8r8 SSK9J:r: SSK;Jr> \(aSSK?J@r@ S2S3SjjrAS4SjrBS5S6SjjrCS7S8SjjrDS9S:SjjrES;SSjjrIS?S@SjjrJSASBSjjrKSCSDSjjrLSESDS jjrMSFSGS!jjrNSHSIS#jjrOSS\ R\ R\ RS$4SJS%jjrQSSSS\ RS"SSSS\ R\ RS&4 SS"S'.SKS(jjjrRSSSSSS"\ RS"SS"SS\ R\ RS)4SLS*jjrSS4S+jrTS4S,jrUS4S-jrVS4S.jrWSMS/jrXSNS0jrYSOSPS1jjrZg)Q) annotationsN) TYPE_CHECKINGLiteralNoReturncast)lib)is_matching_na) SparseIndex)compare_mismatched_resolutions)is_boolis_float_dtypeis_integer_dtype is_numberis_numeric_dtypeneeds_i8_conversion)CategoricalDtypeDatetimeTZDtypeExtensionDtype NumpyEADtype)array_equivalent) Categorical DataFrame DatetimeIndexIndex IntervalDtype IntervalIndex MultiIndex PeriodIndex RangeIndexSeriesTimedeltaIndex) DatetimeArrayExtensionArray IntervalArray PeriodArrayTimedeltaArray)DatetimeLikeArrayMixin) StringDtype)safe_sort_index) pprint_thing)DtypeObjequivc f[U[5(a[UU4SUUUS.UD6 g[U[5(a[ UU4SUUUS.UD6 g[U[ 5(a[ UU4SUUUS.UD6 gU(a[U5(a[U5(aOn[U5(a[U5(aOM[U[R5(d[U[R5(aSnOSn[XUS9 [R"X4[U5X4S.UD6 g) aV 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. atol : float, default 1e-8 Absolute tolerance. F) check_exactexactrtolatol)r. check_dtyper0r1 numpy arrayInputobj)r2r0r1N) isinstancerassert_index_equalr assert_series_equalrassert_frame_equalrr npndarrayassert_class_equal_testingassert_almost_equalbool)leftrightr2r0r1kwargsr6s K/var/www/html/env/lib/python3.13/site-packages/pandas/_testing/asserters.pyr?r?Bs>6$       D& ! !   #    D) $ $   #    9U#3#375>>dBJJ//:eRZZ3P3P'C!C"4C8 $$  %)+%6T PV c URn[X5(d[USUS[U5S35e[X5(d[USUS[U5S35eg)az 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__r7AssertionErrortype)rArBclscls_names rD_check_isinstancerLsx ||H d juHT$ZL I   e ! !juHT%[M J   "rETcN[X[5 [R"XUS9 g)N) compare_keys)rLdictr>assert_dict_equal)rArBrNs rDrPrPsd4( tFrEc ^^Sn SSUU4Sjjjn [X[5 U "XU S9 URUR:wa3U S3n URSU3n URSU3n[XX5 [ U5[ U5:wa1U S3n [ U5SU3n [ U5SU3n[XX5 U(d[ U5n[ U5n[ U[5(a[[U5n[UR5H}nSUS3n[URUURUTUUTUUUS 9 [URUURU5 U "URUURUU S9 M GOU(aT(aUR!U5(dUR"UR":gn[ U[$R&5(d[S U5R)S5n[$R*"UR-[.55S -[ U5- nU S [$R0"US 5S3n[U UX5 O:[3T5n[4R6"UR8UR8UUUU UUS9 U(a [;SXU S9 [ U[<5(d[ U[<5(a [;SXU S9 [ U[>5(d[ U[>5(a [AUR"UR"5 T(ab[ URB[D5(d[ URB[D5(a#[GUR"UR"U S3S9 ggg![a7 URU5nURU5n[UUTUUTUUUS 9 GNwf=f)a Check that left and right Index are equal. Parameters ---------- left : Index right : Index exact : bool or {'equiv'}, default 'equiv' Whether to check the Index class, dtype and inferred_type are identical. If 'equiv', then RangeIndex can be substituted for Index with an int64 dtype as well. check_names : bool, default True Whether to check the names attribute. check_exact : bool, default True Whether to compare number exactly. check_categorical : bool, default True Whether to compare internal Categorical exactly. check_order : bool, default True Whether to compare the order of index entries as well as their values. If True, both indexes must contain the same elements, in the same order. If False, both indexes must contain the same elements, but in any order. rtol : float, default 1e-5 Relative tolerance. Only used when check_exact is False. atol : float, default 1e-8 Absolute tolerance. Only used when check_exact is False. obj : str, default 'Index' Specify object name being compared, internally used to show appropriate assertion message. Examples -------- >>> from pandas import testing as tm >>> a = pd.Index([1, 2, 3]) >>> b = pd.Index([1, 2, 3]) >>> tm.assert_index_equal(a, b) Tc8>T(dg[XTUS9 [SXUS9 [UR[5(aQ[UR[5(a2T(a*[SXUS9 [ UR UR TS9 g[SXUS9 g)N)r/r6 inferred_typer5dtype)r/)r=assert_attr_equalr7rTrr8 categories)rArBr6check_categoricalr/s rD _check_types(assert_index_equal.._check_typess 4e=/4C@ djj"2 3 3 KK)9 9 !!'4C@"4??E4D4DER '4C8rEr5z levels are different, z length are differentzMultiIndex level [])r/ check_namesr.rWr0r1r6r#Y@ values are different ( %))r0r1r2r6lobjrobjnamesrT categoryN)rr6strreturnNone)$rLrnlevelsraise_assert_detaillenr)r7rrranger8levelsassert_numpy_array_equalcodesrHget_level_valuesequals_valuesr;r<fillnasumastypeintroundr@r>r?valuesrUrrassert_interval_array_equalrTrassert_categorical_equal)rArBr/r\r.rW check_orderr0r1r6__tracebackhide__rXmsg1msg2msg3levelrallevelrlevelmismatchdiffmsg exact_bools ` ` rDr8r8s`99&d5)#& ||u}}$+,,,r$(--5'*Ct2 4yCJ+,d)Btf%e*Rw'Ct2 t$&$ ##Z'4<<(E'wa0D "KK&LL' + +&7 )E):EKK.repr_classhs$ a  HAwrEcR[U5[L=(d [U[5$)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. )rIrr7r)idxs rDis_class_equiv*assert_class_equal..is_class_equivos CyE!@ZZ%@@rENr,z classes are different)rrrgr@)rIrj)rArBr/r6r|rrrs rDr=r=`sm  A DzT%[   $  N5$9$9  E' (C*T"2Ju4EFrEcbSn[X5n[X 5nXVLd[XV5(agXV:HnU[RLU[RL- (aSnO%[ U[ 5(dUR5nU(dSUS3n[X8XV5 g![a SnNzf=f)a# 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 TNFz Attribute "z" are different) getattrr TypeErrorpdNAr7r@allrj) attrrArBr6r| left_attr right_attrresultrs rDrUrUs#I%J."G"G( RUUzRUU23  % % D61Ci<  sB B.-B.cSSKJn SSKJn [ U[ [ R45(aw[ U[ 5(a URnUR5HAnS[[U5R53n[ X2[45(aM<U5e gS[[U5R53n[ X[[45(dU5eg)Nr)Artist)AxeszBone of 'objs' is not a matplotlib Axes instance, type encountered zoobjs is neither an ndarray of Artist instances nor a single ArtistArtist instance, tuple, or dict, 'objs' is a )matplotlib.artistrmatplotlib.axesrr7r r;r<rrravelreprrIrGrOtuple)objsrrelrs rD"assert_is_valid_plot_return_objectrs($$,-- dF # #< b,// 4 4/  BDJ''() + $ 566;;6rEc2[U[[45(a URn[U[R 5(a5[ U[R"[R"U555 g[XUR55 g)z#Assert that the sequence is sorted.N) r7rr rxr;r<rnsortarrayassert_extension_array_equalargsort)seqs rDassert_is_sortedrs[#v''jj#rzz"" bggbhhsm&<=$Sckkm*<=rEc[X[5 [UR[5(d[UR[5(aSnOSnU(aF[ URURUS3US9 [ URURX$S3S9 OURR5nURR5n[ XgUS3US9 [ URRUR5URRUR5US3US9 [SXUS 9 g ![a URURpvNf=f) 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. r,Tz .categories)r6r/z.codesr2r6z.valuesorderedr5N) rLrr7rVrr8rnro sort_valuesrtakerU)rArBr2check_category_orderr6r/lcrcs rDrzrzs<2d;/$//:..* *33 OOU--cU+3Fe  ! JJ E.  7,,.B!!--/B 2#k':%H OO  ,    ! !%++ .%w  i#6 7__e&6&6 7s"4E!E)(E)c([X[5 0nURRRS;aSUS'[ URUR4SUS30UD6 [ UR UR 4SUS30UD6 [SXUS9 g) a Test that two IntervalArrays are equivalent. Parameters ---------- left, right : IntervalArray The IntervalArrays to compare. exact : bool or {'equiv'}, default 'equiv' Whether to check the Index class, dtype and inferred_type are identical. If 'equiv', then RangeIndex can be substituted for Index with an int64 dtype as well. obj : str, default 'IntervalArray' Specify object name being compared, internally used to show appropriate assertion message mMF check_freqr6z.leftclosedr5N)rLr$_leftrTkind assert_equal_rightrU)rArBr/r6rCs rDryrys$d=1 F zz$$|U[[FUmFvFellH3%u HHh5rEc~[X[5 [URURUS3S9 [ SXUS9 g)N ._ndarrayr5rT)rLr%rn_ndarrayrU)rArBr6s rDassert_period_array_equalr&s3d;/T]]ENN3%y@QRgt4rEcSn[X[5 [URURUS3S9 U(a [ SXUS9 [ SXUS9 g)NTrr5freqtz)rLr"rnrrUrArBr6rr|s rDassert_datetime_array_equalr-sJd=1T]]ENN3%y@QR&$37dDS1rEcSn[X[5 [URURUS3S9 U(a [ SXUS9 gg)NTrr5r)rLr&rnrrUrs rDassert_timedelta_array_equalr9sCd>2T]]ENN3%y@QR&$37rEczSnUSU3n[U[5(a[R"U5n[U[R5(aUS[ U53- n[U[R5(a [ U5nO+[U[ [[45(a [U5n[U[R5(a [ U5nO+[U[ [[45(a [U5nUSUSU3- nUbUSU3- nUbUSU3- n[U5e)NTz are different z [index]: z [left]: z [right]: z [diff]:  ) r7rr;asarrayr<r*rrr(rrH) r6messagerArBr first_diff index_valuesr|rs rDrjrjCs5e  C,&&zz,/ , ++ \,7899$ ##D! D+\;G H HDz%$$U# E,lKH I IU    C  D6"" J<    rEFc^^^Sn[XTS9 [X[R5 Sn U "U5n U "U5n US:Xa'XLa"[ [ U 5S[ U 535eO,US:Xa&XLa"[ [ U 5S[ U 535eS UUU4Sjjn [ XTS 9(d U "XU5 U(aL[U[R5(a,[U[R5(a [S XTS9 g g g g ) 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. Tr5c:[USS5b UR$U$)Nbase)rrr5s rD _get_base+assert_numpy_array_equal.._get_bases"35AsxxJsJrEsamez is not copyz is cl>UcURUR:wa%[TTS3URUR5 Sn[X5HupE[XET S9(aMUS- nM US-UR- nTS[ R "US5S3n[TX`UTS 9 [U5e) Nz shapes are differentr strict_nanr]r^r_r`)r)shaperjziprsizer;rwrH) rArBerr_msgrleft_arr right_arrrrr6rs rD_raise(assert_numpy_array_equal.._raises ?zzU[[(#C5 56 EKKD'*4'7#' SSAID(8 %<$))+DE0$1B0C3GC SL QW%%rErrTNrgr) r=rLr;r<rHrrr7rU) rArBrr2r check_samer6rr|r left_base right_basers ` `` rDrnrnis>t,d2::.K$I5!JV  & DO#4HT*=M>> 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) Fh㈵>:0yE>zleft is not an ExtensionArrayzright is not an ExtensionArrayrTAttributes of r5rrN)rr6z NA mask)r6r)rT)r2r0r1r6r)r no_defaultrrTr r7r#rUr'rIrr;rrunit datetime_datar roperatoreqrrnrasi8isnato_numpyobjectr>r?r@)rArBr2rr.r0r1r6l_unitr_unitleft_naright_na left_valid right_valids rDrrsh s~~% CNN " CNN " TZZ ( /"4::.. 0 ,0"5;;//   & s~~-46Ds~~-46D dN + +L-LL + e^ , ,N.NN ,'4nSE4JK 4/00 u4 5 5 K4: %tzz$6djj"((33otzz:??))$**5a8ekk28844ou{{;@@))%++6q9 2MM5>>8;;#% ! JJtyy ! JJuzz "%  jj%Gzz%**,'H#h/lh((v(6J "++&+9K   $$  [)% rEr ) check_index check_likec >SnU[RLaSOUnU[RLaU [RLaU [RLat[UR5=(a [ UR5(+=(d6 [UR5=(a [ UR5(+nOU[RLaSnU [RLaU OSn U [RLaU OSn U(dU(a [ S5e[ X[5 U(a [XUS9 [U5[U5:waB[U5SUR3n[U5SUR3n[USUU5 U (aLURUR:Xd2[UR5S [UR535eU(a.[URURUUUUU(+U U US 3S 9 U(aURU5nU (at[!UR["[$45(aOURnURnUR&UR&:XdUR&UR&45eU(aT[!UR[(5(a'[!UR[(5(aU(dO[+S XS U3S9 U(aUR,nUR,n[!U[.5(a7[!U[.5(a"[1UUUUR[3U5S9 GOUUnn[!U[.5(aUR55n[!U[.5(aUR55n[7UUU[3U5URS9 GO3U(a[9UR5(d[9UR5(af[;UR,5R=[;UR,55(d(SUR,SUR,S3n[?U5eGO[!UR[@5(aA[!UR[@5(a"[CURDURD5 GO2[!UR[(5(d[!UR[(5(aL[FRH"UR,UR,U U [KU5[3U5URS9 GO[!UR[L5(aW[!UR[L5(a8[1UR,UR,U U UUR[3U5S9 GO2[OURUR5(d%[OURUR5(a5[1UR,UR,UUR[3U5S9 O[9UR5(aO[9UR5(a5[1UR,UR,UUR[3U5S9 OJ[FRH"UR,UR,U U [KU5[3U5URS9 U(a [+SXUS9 U(ac[!UR[(5(d[!UR[(5(a$[QUR,UR,US3U S9 ggg)a Check that left and right Series are equal. Parameters ---------- left : Series right : Series 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. .. versionchanged:: 2.2.0 Defaults to True for integer dtypes if none of ``check_exact``, ``rtol`` and ``atol`` are specified. check_datetimelike_compat : bool, default False Compare datetime-like which is comparable ignoring dtype. 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. 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. atol : float, default 1e-8 Absolute tolerance. Only used when check_exact is False. 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. .. versionadded:: 1.3.0 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. .. versionadded:: 1.5.0 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) TFrrz0check_like must be False if check_index is Falser5rZzSeries length are different != .indexr/r\r.rWr{r0r1r6rTr)r2rr6)r2r6rzatetimelike_compat=True] z is not equal to .)r0r1r2r6r)r0r1r2rr6namerd)r6rN))rrrrTr ValueErrorrLr r=rkindexrjflagsrr8 reindex_liker7rr!rrrUrrr#rrfrrnrrrqrHrryrr>r?r@r0is_extension_array_dtype_and_needs_i8_conversionrz)rArBr2check_index_typecheck_series_typer\r.check_datetimelike_compatrWrr check_flagsr0r1r6rrr|check_exact_indexr}r~lidxridx left_values right_valueslvrvrs rDr9r9;sZ!,!>Ks~~% CNN " CNN " TZZ ( /"4::.. 0 ,0"5;;//   & s~~-46Ds~~-46D :KLLd6*4C0 4yCJd)Btzzl+e*R }-C!>dKzzU[[(VT$**-=,>d4 CTBU*VV( JJ KK"#)/&%v   'jm^-LMMzz{{yyDII%= 499'==% tzz#3 4 45;;(899%  gt.8N Oll }} k> 2 2z .8 8  )'!ZZH  !,B+~66 ))+,77!**, $'H!ZZ   #DJJ''+>u{{+K+KT\\"))% *>??-dll^<##(==/4 !% % @ DJJ . .: ]44 $DJJ < DJJ 0 1 1Z %66 $$ LL MM[)C  DJJ / /J ^55 % LL MM#C  : EKK   9%++tzz R R$ LL MM#C   TZZ ( (-@-M-M$ LL MM#C   $$ LL MM[)C &$37 djj"2 3 3z KK)8 8  %  e9%%9  8 rErcSnU[RLaUOSnU[RLaUOSnU[RLaUOSn[X[5 U(a[ U[ U55(deUR UR :wa9[UUS3[UR 5[UR 55 U (aLURUR:Xd2[UR5S[UR535e[URURUUUU U (+UUUS3S9 [URURUUUU U (+UUUS 3S9 U (aURU5nU(aUR5nUR5n[[![UR#55[UR#55-55H%nUU;deUU;de[%UUUUUUS 9 M' g['UR5HEunnUR)US S 9nUR)US S 9n[+UUUUUUU U U US USUS3UUSSS9 MG g)ak 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. 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. check_datetimelike_compat : bool, default False Compare datetime-like which is comparable ignoring dtype. 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. 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. atol : float, default 1e-8 Absolute tolerance. Only used when check_exact is False. 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) TrrFz shape mismatchrrrz.columnsrr)axisz .iloc[:, z] (column name="z")) r2rr.r\rrWrr6r0r1rrN)rrrLrr7rIrrjrrr8rcolumnsr_to_dict_of_blockslistsetkeysr: enumerate_ixsr9)rArBr2rcheck_column_typecheck_frame_typer\ by_blocksr.rrWrrrr0r1r6r|_rtol_atol _check_exactrblockslblocksrTicollcolrcols rDr:r:Fs{\.DFE.DFE"-S^^"C;Ld9-$U ,,,, zzU[[  C5(T$**-=,>DDUCV zzU[[(VT$**-=,>d4 CTBU*VV(   +"N  e6N    +"N  e8    '**,))+#d7<<>2T',,.5IIJKEG# ##G# ## KS L  -FAs99QQ9'D::aa:(D '!1''*C"3%e9QC'7uB?!! .rEc Sn[U[5(a`[X40UD6 [U[[45(a8UR UR :XdUR UR 45egg[U[ 5(a [X40UD6 g[U[5(a [X40UD6 g[U[5(a [X40UD6 g[U[5(a [X40UD6 g[U[5(a [X40UD6 g[U[ 5(a [#X40UD6 g[U[$5(a ['X40UD6 g[U[(R*5(a [-X40UD6 g[U[.5(aU0:XdeX:XdegU0:Xde[1X5 g)a# 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. TN)r7rr8rr!rr r9rr:r$ryr%rr"rr&rr#rr;r<rnrfr?)rArBrCr|s rDrrsn$41&1 d]N; < <99 * CTYY ,C C* = D& ! !D262 D) $ $41&1 D- ( (#D:6: D+ & &!$88 D- ( (#D:6: D. ) )$T;F; D. ) )$T;F; D"** % % 77 D#  ||}}||D(rEc [X[RR5 [ UR UR 5 [ UR[5(de[ UR[5(deURnURnURU5(d[SSX#5 O[SX5 [SX5 [ UR5UR55 g)zt Check that the left and right SparseArray are equal. Parameters ---------- left : SparseArray right : SparseArray zSparseArray.indexzindex are not equal fill_valuerTN) rLrarrays SparseArrayrn sp_valuesr7sp_indexr rqrjrUto_dense)rArB left_index right_indexs rDassert_sp_array_equalr/:sd299#8#89T^^U__= dmm[ 1 11 1 ennk 2 22 2J..K   [ ) ) !6  lD0gt+T]]_enn.>?rEcFUHnX!;aM S[U535e g)NzDid not contain item: )r)iterabledicks rDassert_contains_allr4[s' x;1$q';;xrEc [X5HIup4[X440UD6 S[[U55S[[U55S3nX4LaMDU5e g)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) zExpected object z and object z8 to be different objects, but they were the same object.N)rr?rrI)iter1iter2 eql_kwargselem1elem2rs rD assert_copyr;`shE) E7J7tDK01d4;>O=PQ@ @ !&3&! *rEcF[U[5=(a [U5$)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 )r7rr) left_dtype right_dtypes rDrrrs j. 1 V6I+6VVrEcURUn[URUU5 [UR5(d[XU5 gg)zS Check that ser.iloc[i_slc] matches ser.loc[l_slc] and, if applicable, ser[l_slc]. N)ilocr9locrr)serl_slci_slcexpecteds rD!assert_indexing_slices_equivalentrFsC xxH1 CII & &CJ1 'rEczURH+n[XS5nUcUbeMU[XS5:XaM+e g)z2 Check that ._metadata attributes are equivalent. N) _metadatar)rArBrvals rDassert_metadata_equivalentrJsB d$' =; ;'%t44 44 rE)r,rr)r2bool | Literal['equiv']r0floatr1rLrgrh)rgrh)T)rNr@rgrh)r,TTTTrrr)rArrBrr/ bool | strr\r@r.r@rWr@r{r@r0rLr1rLr6rfrgrh)Tr4)r/rMr6rfrgrh) Attributes)rrfr6rfrgrh)TTr)r2r@rr@r6rfrgrh)r,r$)r/rKr6rfrgrh)r%re)r"T)r6rfrr@rgrh)r&T)NNNr)FTNNr3N)rr@r2rKr6rfrgrh) r2rKr.bool | lib.NoDefaultr0float | lib.NoDefaultr1rPr6rfrgrh) r2rKrrKrr@r\r@r.rOrr@rWr@rr@rr@rr@r0rPr1rPr6rfrr@rr@rgrh) r2rKrrKrrKrr@r\r@rr@r.rOrr@rWr@rr@rr@rr@r0rPr1rPr6rfrgrh)r=r+r>r+rgr@)rBr rCslicerDrQrgrhr)rAzDataFrame | SeriesrBzDataFrame | Series | Nonergrh)[ __future__rrtypingrrrrnumpyr; pandas._libsrpandas._libs.missingr pandas._libs.sparser pandas._libs.testing_libstestingr>pandas._libs.tslibs.np_datetimer pandas.core.dtypes.commonr r rrrrpandas.core.dtypes.dtypesrrrrpandas.core.dtypes.missingrpandasrrrrrrrrrrr r!pandas.core.arraysr"r#r$r%r&pandas.core.arrays.datetimeliker'pandas.core.arrays.string_r(pandas.core.indexes.apir)pandas.io.formats.printingr*pandas._typingr+r?rLrPr8r=rUrrrzryrrrrjrnrrr9r:rr/r4r;rrFrJrErDrgsY"/+''J 8    C233' ,3 O )O   O  O  O d 8G "hY hY hY hY hY  hY  hYhY hY hY hY hYX7>G"G03G GD$N<,>!% :7:7 :7 :7  :7|GV6/6@C6 6>5AE 2 29= 2  2BF88:>8 8IM# #R+/ M=M=) M= M= M=f,0(+"%.."%..~ )~ & ~ ~  ~  ~  ~ J,007"(+&+"!%"%.."%..G"%G)G. G  G  G&G $GGGGG G G G"#G$%G& 'G\,00718!(+&+""%.."%..#H)H. H / H  HHH&H $HHHHH H !H" #H$ %HV&)R@B< '$ W W'/ W  W 2BF 5  5%> 5  5rE