Mh[/SSKJr SSKJrJrJrJrJr SSKJ r SSK J r SSK J r JrJrJrJr SSKrSSKrSSKJr SSKJrJrJr SS KJr SS KJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+ SS K,J-r. SS K/J0r0J1r1J2r2 SS K3J4r4J5r5J6r6 SSK7J8r8 SSK9J:r: SSK;Jr>J?r?J@r@JArAJBrBJCrCJDrD SSKEJFrFJGrG SSKHJIrIJJrJ SSKKJLrL SSKMJNrNJOrO SSKPJQs JRr SSKSJTrT SSKUJVrVJWrW SSKXJYrYJZrZ SSK[JQs J\r] SSK^J_r_ SSK`JQs Jas Jbrc SSK`JdrdJereJfrfJgrg SSKhJiri SSKjJkrk SSKlJmrmJnrn SSKoJprpJqrq \ (a SSKrJsrsJtrtJuru \v"\cR5rw\wRSS S!.5 "S"S#\R\R5r{"S$S%\R\R5r}S.S&jr~"S'S\d5rS/S(jrS0S1S)jjrS2S*jrS3S+jrS4S5S,jjrS6S-jrg)7) annotations) Collection GeneratorHashableIterableSequence)wraps getsizeof) TYPE_CHECKINGAnyCallableLiteralcastN) get_option)algosindexlib) duplicated) AnyAll AnyArrayLikeAxisDropKeepDtypeObjF IgnoreRaise IndexLabelScalarSelfShapenpt)function)InvalidIndexErrorPerformanceWarningUnsortedIndexError)Appendercache_readonlydoc)find_stack_level)coerce_indexer_dtype) ensure_int64ensure_platform_int is_hashable is_integer is_iterator is_list_likeis_object_dtype is_scalar pandas_dtype)CategoricalDtypeExtensionDtype) ABCDataFrame ABCSeries) is_array_like)array_equivalentisna)validate_putmask) CategoricalExtensionArray)factorize_from_iterablesrecode_for_categories)sanitize_array)Index_index_shared_docs ensure_indexget_unanimous_names) FrozenList)make_invalid_op)get_group_indexlexsort_indexer)get_adjustment pprint_thing)CategoricalIndex DataFrameSeries MultiIndexzMultiIndex or list of tuples)klass target_klassc6\rSrSrSr\R rSrSr g)MultiIndexUIntEnginezU This class manages a MultiIndex by mapping label combinations to positive integers. cXR-nURS:Xa[RR U5$[RR USS9$)a Transform combination(s) of uint64 in one uint64 (each), in a strictly monotonic way (i.e. respecting the lexicographic order of integer combinations): see BaseMultiIndexCodesEngine documentation. Parameters ---------- codes : 1- or 2-dimensional array of dtype uint64 Combinations of integers (one per row) Returns ------- scalar or 1-dimensional array, of dtype uint64 Integer(s) representing one combination (each). axis)offsetsndimnp bitwise_orreduceselfcodess K/var/www/html/env/lib/python3.13/site-packages/pandas/core/indexes/multi.py_codes_to_ints#MultiIndexUIntEngine._codes_to_intssN$ ,, ::?==''. .}}##E#22N) __name__ __module__ __qualname____firstlineno____doc__libindex UInt64Engine_basera__static_attributes__rdrcr`rRrRs  ! !E3rcrRc6\rSrSrSr\R rSrSr g)MultiIndexPyIntEnginez This class manages those (extreme) cases in which the number of possible label combinations overflows the 64 bits integers, and uses an ObjectEngine containing Python integers. cURS5UR-nURS:Xa[RR U5$[RR USS9$)a Transform combination(s) of uint64 in one Python integer (each), in a strictly monotonic way (i.e. respecting the lexicographic order of integer combinations): see BaseMultiIndexCodesEngine documentation. Parameters ---------- codes : 1- or 2-dimensional array of dtype uint64 Combinations of integers (one per row) Returns ------- int, or 1-dimensional array of dtype object Integer(s) representing one combination (each). objectrUrV)astyperXrYrZr[r\r]s r`ra$MultiIndexPyIntEngine._codes_to_intssY& X&$,,6 ::?==''. .}}##E#22rcrdN) rerfrgrhrirj ObjectEnginerlrarmrdrcr`roros  ! !E3rcrocL^[T5U4Sj5n[[U5$)zz A decorator to allow either `name` or `names` keyword but not both. This makes it easier to share code with base class. c~>SU;aSU;a [S5eSU;aURS5US'T"U/UQ70UD6$)Nnamenamesz*Can only provide one of `names` and `name`) TypeErrorpop) self_or_clsargskwargsmeths r`new_methnames_compat..new_methsM V 6 1HI I V $jj0F7OK1$1&11rc)r rr)rrs` r` names_compatrs* 4[22 8 rcc6 ^\rSrSr%Sr\R \"5-rSr/r S\ S'\ "5r \ "5r S/rS\ S'SSS jjrSS jrSSSjjr\S \R(4SSjj5r\\SSSjj55r\S \R(4SSjj5r\SSSjj5r\SSj5r\SSj5r\S5r\SSj5rSSjr \SSj5r!\SSj5r"S S S S S.SSjjr#S S S.SSjjr$\SSj5r%\SSj5r&\SS j5r'S S S S S.SS!jjr(S S S.SS"jjr)\S#5r*\SS$j5r+\,"\RZ5\R(4SS%jj5r-SS&jr.SSS'jjr/SSS(jjr0SSS)jjr1\,"\Rd5SS*j5r2\SS+j5r3SS,jr4\,"\Rj5SSS-jj5r5\SS.j5r6SSS/jjr7S0r8S1S2.SS3jjr9SSS4jjr:S S5.SS6jjr;SS7jr\SS<j5r?SS=jr@\SS>j5rA\SS?j5rB\SS@j5rC\,"\R5SSSAjj5rD\DrESSBjrF\,"\R5SSSCjj5rGSSSDjjrHSSEjrI\,"\R5SSFj5rJS \R(S 4SSGjjrKSSHjrLSSIjrM\SSJj5rNSSSKjjrOSSLjrPSMrQSNrRSSOjrS\T"\USP\V-5SSSQjj5rWSRrXSSST.SSUjjrY\T"\USV\V-5SSSWjj5rZSSSXjjr[SSSYjjr\SSSZjjr]SS[jr^SS\jr_SSS]jjr`SS^jraSSS_jjrbSS`jrcSSajrdSSbjre\SScj5rfSU4SdjjrgSU4SejjrhSSfjriSSgjrjSSU4ShjjjrkSSSijjrlSSjjrmSkrnSSSljjroSSSmjjrpSSSnjjrqSSojrrSSpjrsSSSqjjrtSSrjruSSsjrvSU4StjjrwSSujrxSSvjrySwrzSSxjr{SSyjr|Szr}\,"\R5SSS{jj5r~S|rSS}jrSS~jrSSjr\,"\GR5SSSjj5r\GRr\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5rSrU=r$)rNa A multi-level, or hierarchical, index object for pandas objects. Parameters ---------- levels : sequence of arrays The unique labels for each level. codes : sequence of arrays Integers for each level designating which label at each location. sortorder : optional int Level of sortedness (must be lexicographically sorted by that level). names : optional sequence of objects Names for each of the index levels. (name is accepted for compat). copy : bool, default False Copy the meta-data. verify_integrity : bool, default True Check that the levels/codes are consistent and valid. Attributes ---------- names levels codes nlevels levshape dtypes Methods ------- from_arrays from_tuples from_product from_frame set_levels set_codes to_frame to_flat_index sortlevel droplevel swaplevel reorder_levels remove_unused_levels get_level_values get_indexer get_loc get_locs get_loc_level drop See Also -------- MultiIndex.from_arrays : Convert list of arrays to MultiIndex. MultiIndex.from_product : Create a MultiIndex from the cartesian product of iterables. MultiIndex.from_tuples : Convert list of tuples to a MultiIndex. MultiIndex.from_frame : Make a MultiIndex from a DataFrame. Index : The base pandas Index type. Notes ----- See the `user guide `__ for more. Examples -------- A new ``MultiIndex`` is typically constructed using one of the helper methods :meth:`MultiIndex.from_arrays`, :meth:`MultiIndex.from_product` and :meth:`MultiIndex.from_tuples`. For example (using ``.from_arrays``): >>> arrays = [[1, 1, 2, 2], ['red', 'blue', 'red', 'blue']] >>> pd.MultiIndex.from_arrays(arrays, names=('number', 'color')) MultiIndex([(1, 'red'), (1, 'blue'), (2, 'red'), (2, 'blue')], names=['number', 'color']) See further examples for how to construct a MultiIndex in the doc strings of the mentioned helper methods. multiindexzlist[Hashable | None]_namesry int | None sortorderNFTc UbUnUbUc [S5e[U5[U5:wa [S5e[U5S:Xa [S5e[R U5n 0U lU R XSS9 U RX&SS9 S/[U5-U lUbU RU5 Ub[U5U l OX9l U(aU R5n Xl U R5 SU lU $)NzMust pass both levels and codesz,Length of levels and codes must be the same.rz)Must pass non-zero number of levels/codesF)copyvalidate)rzlen ValueErrorrr__new___cache _set_levels _set_codesr _set_namesintr_verify_integrity_codes_reset_identity _references) clslevelsr_rrydtyperrxverify_integrityresult new_codess r`rMultiIndex.__new__Es  E >U]=> > v;#e* $KL L v;! HI I$  6u=%U;V,     e $  "9~F (  002I%M ! rcc[U5n[R"U5(a[R"X2SU5nU$)a4 Reassign code values as -1 if their corresponding levels are NaN. Parameters ---------- code : list Code to reassign. level : list Level to check for missing values (NaN, NaT, None). Returns ------- new code where code value = -1 if it corresponds to a level with missing values (NaN, NaT, None). )r:rZanywhere)r^levelcode null_masks r`_validate_codesMultiIndex._validate_codests7 K 66)  88IOR6D rcc U=(d URnU=(d URnUc[[U55n[U5[U5:wa [ S5e[US5nUGH nX%nXn[U5U:wa([ SUVs/sHn[U5PM sn35e[U5(aIUR 5[U5:a,[ SUSUR 5S[U5S35e[U5(a4UR 5S:a [ SUS UR 5S 35eUR(aM[ S [U5S U35e URbgUR[URUR5:a9[ S URS[URUR535e/n [[U55HBnXS;a'U RURX%X55 M/U RX5 MD [U 5n U $s snf)a Parameters ---------- codes : optional list Codes to check for validity. Defaults to current codes. levels : optional list Levels to check for validity. Defaults to current levels. levels_to_validate: optional list Specifies the levels to verify. Raises ------ ValueError If length of levels and codes don't match, if the codes for any level would exceed level bounds, or there are any duplicate levels. Returns ------- new codes where code value = -1 if it corresponds to a NaN level. zTLength of levels and codes must match. NOTE: this index is in an inconsistent state.rzUnequal code lengths: z On level z , code max (z) >= length of level (z/). NOTE: this index is in an inconsistent staterz, code value (z) < -1zLevel values must be unique: z on level zQValue for sortorder must be inferior or equal to actual lexsort_depth: sortorder z with lexsort_depth )r_rrangerrmaxmin is_uniquelistr_lexsort_depthnlevelsappendrrE) r^r_rlevels_to_verify codes_lengthir level_codescode_ result_codesrs r`rMultiIndex._verify_integritysC:#&4;;  #$S[1  v;#e* $: 58} !AIE(K;</ ,e-LeUc%je-L,MN;KOO$5U$C s,{/@.AB!%j\*)) ;KOO$5$: 9QC~koo>O=PPV!WXX??? 3DK= 1#N#"( >> %~~tzz4<< HH 004/?@**8T\\*R)SU  s6{#A$##D$8$8EH$MN##EH- $ |, =.MsI! cSn[U5(d [U5e[U5(a [U5nUHn[U5(aM[U5e [ S[ U55H-n[ X5[ XS- 5:wdM$[ S5e [U5upxU[RLaUV s/sHn [U SS5PM nn U"UUUUSS9$s sn f)a Convert arrays to MultiIndex. Parameters ---------- arrays : list / sequence of array-likes Each array-like gives one level's value for each data point. len(arrays) is the number of levels. sortorder : int or None Level of sortedness (must be lexicographically sorted by that level). names : list / sequence of str, optional Names for the levels in the index. Returns ------- MultiIndex See Also -------- MultiIndex.from_tuples : Convert list of tuples to MultiIndex. MultiIndex.from_product : Make a MultiIndex from cartesian product of iterables. MultiIndex.from_frame : Make a MultiIndex from a DataFrame. Examples -------- >>> arrays = [[1, 1, 2, 2], ['red', 'blue', 'red', 'blue']] >>> pd.MultiIndex.from_arrays(arrays, names=('number', 'color')) MultiIndex([(1, 'red'), (1, 'blue'), (2, 'red'), (2, 'blue')], names=['number', 'color']) z/Input must be a list / sequence of array-likes.rUzall arrays must be same lengthrxNFrr_rryr) r0rzr/rrrrr>r no_defaultgetattr) rarraysrry error_msgarrayrr_rarrs r` from_arraysMultiIndex.from_arrayssTF F##I& & v  &\FE&& ** q#f+&A69~VE]!33 !ABB'18  CNN ";AB6CWS&$/6EB"   CsC*c[U5(d [S5e[U5(a [U5n[ [ [ [S4U5n[U5(at[SU55(a][R"[U55/n[[R"U[R"S5S95/nU"UUUUSS9$[U5S:XaUc [S 5e//[U5-nO[!U[R"[45(a_[!U[5(a [R$"UR&5n[[(R*"U5R,5nOe[!U[5(a*[[(R."U5R,5nO&[1U6n[ [[2[U5nUR5XbUS 9$) a Convert list of tuples to MultiIndex. Parameters ---------- tuples : list / sequence of tuple-likes Each tuple is the index of one row/column. sortorder : int or None Level of sortedness (must be lexicographically sorted by that level). names : list / sequence of str, optional Names for the levels in the index. Returns ------- MultiIndex See Also -------- MultiIndex.from_arrays : Convert list of arrays to MultiIndex. MultiIndex.from_product : Make a MultiIndex from cartesian product of iterables. MultiIndex.from_frame : Make a MultiIndex from a DataFrame. Examples -------- >>> tuples = [(1, 'red'), (1, 'blue'), ... (2, 'red'), (2, 'blue')] >>> pd.MultiIndex.from_tuples(tuples, names=('number', 'color')) MultiIndex([(1, 'red'), (1, 'blue'), (2, 'red'), (2, 'blue')], names=['number', 'color']) z/Input must be a list / sequence of tuple-likes..c3^# UH#n[U[5=(a U(+v M% g7fN) isinstancetuple).0es r` )MultiIndex.from_tuples..Ss!Nv!z!U3=A=vs+-rrrFrrz-Cannot infer number of levels from empty listrry)r0rzr/rrrrrrallrZzerosrAcomasarray_tuplesaferrndarrayasarray_valuesrtuples_to_object_arrayTto_object_array_tuplesziprr)rtuplesrryr_rrarrss r` from_tuplesMultiIndex.from_tuples!sVF##MN N v  &\Fjx}!56? v;;3NvNNNXXc&k*+EC11&@RSTUF#!&   v;! } OPPTCJ&F U 3 4 4&%((FNN3#44V<>>?F  % %#44V<>>?F>> numbers = [0, 1, 2] >>> colors = ['green', 'purple'] >>> pd.MultiIndex.from_product([numbers, colors], ... names=['number', 'color']) MultiIndex([(0, 'green'), (0, 'purple'), (1, 'green'), (1, 'purple'), (2, 'green'), (2, 'purple')], names=['number', 'color']) r)cartesian_productz-Input must be a list / sequence of iterables.rxNr) pandas.core.reshape.utilrr0rzr/rr>rrr)r iterablesrryrr_rits r` from_productMultiIndex.from_productrs\ ?I&&KL L y ! !YI0;  CNN "9BC2WR.EC"%(6ICC Ds!B c[U[5(d [S5e[UR 56upEUcUOUnUR XRUS9$)a Make a MultiIndex from a DataFrame. Parameters ---------- df : DataFrame DataFrame to be converted to MultiIndex. sortorder : int, optional Level of sortedness (must be lexicographically sorted by that level). names : list-like, optional If no names are provided, use the column names, or tuple of column names if the columns is a MultiIndex. If a sequence, overwrite names with the given sequence. Returns ------- MultiIndex The MultiIndex representation of the given DataFrame. See Also -------- MultiIndex.from_arrays : Convert list of arrays to MultiIndex. MultiIndex.from_tuples : Convert list of tuples to MultiIndex. MultiIndex.from_product : Make a MultiIndex from cartesian product of iterables. Examples -------- >>> df = pd.DataFrame([['HI', 'Temp'], ['HI', 'Precip'], ... ['NJ', 'Temp'], ['NJ', 'Precip']], ... columns=['a', 'b']) >>> df a b 0 HI Temp 1 HI Precip 2 NJ Temp 3 NJ Precip >>> pd.MultiIndex.from_frame(df) MultiIndex([('HI', 'Temp'), ('HI', 'Precip'), ('NJ', 'Temp'), ('NJ', 'Precip')], names=['a', 'b']) Using explicit names, instead of the column names >>> pd.MultiIndex.from_frame(df, names=['state', 'observation']) MultiIndex([('HI', 'Temp'), ('HI', 'Precip'), ('NJ', 'Temp'), ('NJ', 'Precip')], names=['state', 'observation']) zInput must be a DataFramer)rr6rzritemsr)rdfrry column_namescolumnss r` from_frameMultiIndex.from_framesO|"l++78 8 #RXXZ 0 % 5w5IIrcc|/n[UR5GH nURUnURUnUn[ UR [ 5(a&[SU5nURR5n[ UR [5(d&[R"UR S5(aUR[5n[R "U5n["R$"XTUR&S9nUR)U5 GM [R*"U5nU$)NrKmM fill_value)rrrr_rrr4r_data_internal_get_valuesr5r is_np_dtypersrrrZrrtake_nd _na_valuerfast_zip)r^valuesrrr_valsrs r`rMultiIndex._valuesst||$AKKNEJJqMED$**&677.5zz668$**n55 D::{{6*::d#D==ID MM$ !%$ll6" rccUR$rrr^s r`rMultiIndex.valuess ||rcc[S5e)zv Raises a ValueError for `MultiIndex` because there's no single array backing a MultiIndex. Raises ------ ValueError zcMultiIndex has no single backing array. Use 'MultiIndex.to_numpy()' to get a NumPy array of tuples.)rrs r`rMultiIndex.arrays F  rccSSKJn [R"URVs/sHo"R PM sn5nU"URVs/sHo"R PM sn[U5S9$s snfs snf)a Return the dtypes as a Series for the underlying MultiIndex. Examples -------- >>> idx = pd.MultiIndex.from_product([(0, 1, 2), ('green', 'purple')], ... names=['number', 'color']) >>> idx MultiIndex([(0, 'green'), (0, 'purple'), (1, 'green'), (1, 'purple'), (2, 'green'), (2, 'purple')], names=['number', 'color']) >>> idx.dtypes number int64 color object dtype: object r)rM)r)pandasrMrfill_missing_namesrrxrrA)r^rMrrys r`dtypesMultiIndex.dtypes#s[, "&& 'L u 'LM < u{{ s4::a=!!rcc[U5$)z7 Return the number of elements in the underlying data. rrs r`sizeMultiIndex.sizeAs 4yrcc[URUR5VVs/sHupURUS9PM nnnUH nSUlM [ U5$s snnf)a  Levels of the MultiIndex. Levels refer to the different hierarchical levels or layers in a MultiIndex. In a MultiIndex, each level represents a distinct dimension or category of the index. To access the levels, you can use the levels attribute of the MultiIndex, which returns a tuple of Index objects. Each Index object represents a level in the MultiIndex and contains the unique values found in that specific level. If a MultiIndex is created with levels A, B, C, and the DataFrame using it filters out all rows of the level C, MultiIndex.levels will still return A, B, C. Examples -------- >>> index = pd.MultiIndex.from_product([['mammal'], ... ('goat', 'human', 'cat', 'dog')], ... names=['Category', 'Animals']) >>> leg_num = pd.DataFrame(data=(4, 2, 4, 4), index=index, columns=['Legs']) >>> leg_num Legs Category Animals mammal goat 4 human 2 cat 4 dog 4 >>> leg_num.index.levels FrozenList([['mammal'], ['cat', 'dog', 'goat', 'human']]) MultiIndex levels will not change even if the DataFrame using the MultiIndex does not contain all them anymore. See how "human" is not in the DataFrame, but it is still in levels: >>> large_leg_num = leg_num[leg_num.Legs > 2] >>> large_leg_num Legs Category Animals mammal goat 4 cat 4 dog 4 >>> large_leg_num.index.levels FrozenList([['mammal'], ['cat', 'dog', 'goat', 'human']]) rxT)r_levelsr_rename_no_setting_namerE)r^xrxrrs r`rMultiIndex.levelsLs\j7:$,, 6TU6T71!)))&6TUE%)E "&!! VsA)rrrrc^U(ag[U5S:Xa [S5eUc$[U5UR:wa [S5eUb#[U5[U5:wa [S5eUc3[U4SjU55n[ [ [U555nOnUVs/sHoR U5PM nn[ UR5n [Xq5Hup[UTS9R5X'M! [U 5nU(aURXgS9n Xl URn X`l[U 5(aURU 5 UR!5 gs snf)Nrz#Must set non-zero number of levels.z-Length of levels must match number of levels.z,Length of levels must match length of level.c3T># UHn[UTS9R5v M g7frN)rC_view)rlevrs r`r)MultiIndex._set_levels..s'$@F St,2244s%(r)rr)rrrrErr_get_level_numberr rrCrrrryrr _reset_cache) r^rrrrr new_levels level_numbersrnew_levels_listlev_numrrys ` r`rMultiIndex._set_levelssG 6{a !FGG}V !< !PQQ S[CJ%> !OPP =#$@F$J!s:!78MDIJES33C8EMJ"4<<0O #M : +7$+G+M+M+O(!;#O4J ..!/I$K ! u:: OOE " #Ks*E4rrc[U[5(aO7[U5(a [U5nO[U5(a [ U5n[ X!S5up!UR 5nUR5 URXSUS9 U$)a Set new levels on MultiIndex. Defaults to returning new index. Parameters ---------- levels : sequence or list of sequence New level(s) to apply. level : int, level name, or sequence of int/level names (default None) Level(s) to set (None for all levels). verify_integrity : bool, default True If True, checks that levels and codes are compatible. Returns ------- MultiIndex Examples -------- >>> idx = pd.MultiIndex.from_tuples( ... [ ... (1, "one"), ... (1, "two"), ... (2, "one"), ... (2, "two"), ... (3, "one"), ... (3, "two") ... ], ... names=["foo", "bar"] ... ) >>> idx MultiIndex([(1, 'one'), (1, 'two'), (2, 'one'), (2, 'two'), (3, 'one'), (3, 'two')], names=['foo', 'bar']) >>> idx.set_levels([['a', 'b', 'c'], [1, 2]]) MultiIndex([('a', 1), ('a', 2), ('b', 1), ('b', 2), ('c', 1), ('c', 2)], names=['foo', 'bar']) >>> idx.set_levels(['a', 'b', 'c'], level=0) MultiIndex([('a', 'one'), ('a', 'two'), ('b', 'one'), ('b', 'two'), ('c', 'one'), ('c', 'two')], names=['foo', 'bar']) >>> idx.set_levels(['a', 'b'], level='bar') MultiIndex([(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b'), (3, 'a'), (3, 'b')], names=['foo', 'bar']) If any of the levels passed to ``set_levels()`` exceeds the existing length, all of the values from that argument will be stored in the MultiIndex levels, though the values will be truncated in the MultiIndex output. >>> idx.set_levels([['a', 'b', 'c'], [1, 2, 3, 4]], level=[0, 1]) MultiIndex([('a', 1), ('a', 2), ('b', 1), ('b', 2), ('c', 1), ('c', 2)], names=['foo', 'bar']) >>> idx.set_levels([['a', 'b', 'c'], [1, 2, 3, 4]], level=[0, 1]).levels FrozenList([['a', 'b', 'c'], [1, 2, 3, 4]]) LevelsT)rrr) rrAr8r0r_require_listlikerrr)r^rrridxs r` set_levelsMultiIndex.set_levelssf fe $ $  6 " "6]F & ! !&\F)%B jjl   $AQ   rcc,[UR5$)z Integer number of levels in this MultiIndex. Examples -------- >>> mi = pd.MultiIndex.from_arrays([['a'], ['b'], ['c']]) >>> mi MultiIndex([('a', 'b', 'c')], ) >>> mi.nlevels 3 )rr rs r`rMultiIndex.nlevelss4<<  rcc:[SUR55$)z A tuple with the length of each level. Examples -------- >>> mi = pd.MultiIndex.from_arrays([['a'], ['b'], ['c']]) >>> mi MultiIndex([('a', 'b', 'c')], ) >>> mi.levshape (1, 1, 1) c38# UHn[U5v M g7frrrrs r`r&MultiIndex.levshape..4s1[SVV[)rrrs r`levshapeMultiIndex.levshape&s1T[[111rccUR$r)rrs r`r_MultiIndex.codes9 {{rccp^U(aMUc$[U5UR:wa [S5eUb#[U5[U5:wa [S5eUc>[U4Sj[ UR U555n[ [U55nOoUVs/sHoRU5PM nn[UR5n [ Xq5H upURU n[XTS9X'M" [U 5nU(aURXgS9nX`l UR5 gs snf)Nz+Length of codes must match number of levelsz,Length of codes must match length of levels.c3X># UHup[X!TS9R5v M! g7fr)_coerce_indexer_frozenview)rrrrs r`r(MultiIndex._set_codes..Ns.#(@$C'{dCHHJJ(@s'*r)r_r)rrrrErr rrrrrr4rr) r^r_rrrrrrrnew_codes_listrrs ` r`rMultiIndex._set_codes=s  }Ut||!; !NOO SZ3u:%= !OPP ="#(+DLL%(@#I"#i.1MDIJES33C8EMJ!$++.N(+M(A$kk'**@4+')B #>2I ../I  !KsD3c[X!S5up!UR5nUR5 URXUS9 U$)a Set new codes on MultiIndex. Defaults to returning new index. Parameters ---------- codes : sequence or list of sequence New codes to apply. level : int, level name, or sequence of int/level names (default None) Level(s) to set (None for all levels). verify_integrity : bool, default True If True, checks that levels and codes are compatible. Returns ------- new index (of same type and class...etc) or None The same type as the caller or None if ``inplace=True``. Examples -------- >>> idx = pd.MultiIndex.from_tuples( ... [(1, "one"), (1, "two"), (2, "one"), (2, "two")], names=["foo", "bar"] ... ) >>> idx MultiIndex([(1, 'one'), (1, 'two'), (2, 'one'), (2, 'two')], names=['foo', 'bar']) >>> idx.set_codes([[1, 0, 1, 0], [0, 0, 1, 1]]) MultiIndex([(2, 'one'), (1, 'one'), (2, 'two'), (1, 'two')], names=['foo', 'bar']) >>> idx.set_codes([1, 0, 1, 0], level=0) MultiIndex([(2, 'one'), (1, 'two'), (2, 'one'), (1, 'two')], names=['foo', 'bar']) >>> idx.set_codes([0, 0, 1, 1], level='bar') MultiIndex([(1, 'one'), (1, 'one'), (2, 'two'), (2, 'two')], names=['foo', 'bar']) >>> idx.set_codes([[1, 0, 1, 0], [0, 0, 1, 1]], level=[0, 1]) MultiIndex([(2, 'one'), (1, 'one'), (2, 'two'), (1, 'two')], names=['foo', 'bar']) Codesr)r"rrr)r^r_rrr#s r` set_codesMultiIndex.set_codesfs@t)w? jjl  u>> mi = pd.MultiIndex.from_arrays([['a'], ['b'], ['c']]) >>> mi MultiIndex([('a', 'b', 'c')], ) >>> mi.copy() MultiIndex([('a', 'b', 'c')], ) )rxrydeepNNr)deepcopyNFrr) _validate_namesrrUrr_rJrrr{_id) r^ryrSrxkeep_idrr_rU new_indexs r`rMultiIndex.copysL$$$$$G("   %dkk*FTZZ(E!-4;;* Jnn"   ;;++- Xt,  HHIMrccUR$)z%the array interface, return my values)r)r^rrs r` __array__MultiIndex.__array__ r1rccHUR5nURUlU$)z0this is defined as a copy with the same identity)rrW)r^rrs r`r5MultiIndex.view$sXX  rcct[U5 URU5 g![[[4a gf=f)NTF)hashget_loc LookupErrorrzrr^keys r` __contains__MultiIndex.__contains__*s6 S   LL Y 3  s 77c.[R"S5$)NO)rZrrs r`rMultiIndex.dtype3sxx}rccL^SSjm[U4SjUR55$)z5return a boolean if we need a qualified .info displayc<SU;=(d SU;=(d SU;$)Nmixedstringunicoderdrs r`f0MultiIndex._is_memory_usage_qualified..f:s!e#Nx5'8NI# UH nT"U5v M g7frrd)rrrqs r`r8MultiIndex._is_memory_usage_qualified..=sD)C1U88)Csreturnbool)r_inferred_type_levels)r^rqs @r`_is_memory_usage_qualified%MultiIndex._is_memory_usage_qualified7s" OD)C)CDDDrcc$URU5$r_nbytes)r^rSs r` memory_usageMultiIndex.memory_usage@s ||D!!rcc$URS5$)z1return the number of bytes in the underlying dataFr|rs r`nbytesMultiIndex.nbytesGs||E""rcc^^Sm[U4SjUR55n[SUR55n[U4SjUR55nX#-U-nXPRR TS9- nU$)z return the number of bytes in the underlying data deeply introspect the level data if deep=True include the engine hashtable *this is in internal routine* c3@># UHoRTS9v M g7f)rSN)r~)rrrSs r`r%MultiIndex._nbytes..YsJk>>t>4ksc38# UHoRv M g7fr)r)rrs r`rrZs8Z88Zr,c3<># UHn[UT5v M g7frr )rrobjsizes r`rr[sE*Q9Q00*sr)sumrr_ryrGsizeof)r^rS level_nbytes label_nbytes names_nbytesrrs ` @r`r}MultiIndex._nbytesLstJdkkJJ 8TZZ88 E$**EE ,|; ,,%%4%00 rccURVs/sHo"RPM nn[S[X1555$s snf)zG Formats each item in tup according to its level's formatter function. c36# UHupU"U5v M g7frrd)rfuncvals r`r-MultiIndex._formatter_func..jsJ0I94T#YY0Is)r_formatter_funcrr)r^tuprformatter_funcss r`rMultiIndex._formatter_funces=?CkkJkU00kJJO0IJJJKsAnan)na_repc /n/n[URUR5HupVUR"SSU0UD6nUS:HnUR 5(ag[ U5n UR [5n[R"Xq5nURR(aeUR5nXU'URU5 URU5 M [ U5S:Xa.[USRUS55R5$[UUUR UR"SS9n U R$$)NrrrUrFrr_ryrrrd)rrr__get_values_for_csvrrrsstrrZrflags writeablerrAtakerNryrr) r^rr~rrrr level_strsmask nan_indexmis r`rMultiIndex._get_values_for_csvls+  #&dkk4::"> E22K&KFKJ"$Dxxzz O '..s3 YYz: &,,6666)..0 $-D!   j )   [ )#? z?a A++IaL9:NNP P!jj..!& B:: rcc [R"[U5RS3[[ 5S9 UbUn[ U5S:Xa/$/n[URUR5HupUbUO[U R5n [ U 5S:afU RU 5RUS9n U S:Hn U R5(a-[R "U ["S9n XU 'U R%5n OK[&R("U R*U 5Vs/sHn[-[/U5(aU OUSS9PM! n nUR1U 5 M /n[XR25Hfun n/nU(aUR1Ub [-USS9OS 5 UR5[R "U ["S95 UR1U5 Mh Uc [7S 5nU(aXS n[9U[:5(dU[<R>LdeUS [<R>4;aUn[AU[CU5US 9nU(a,[E5nURF"U/UQ76RIS 5$U$s snf)Nz.format is deprecated and will be removed in a future version. Convert using index.astype(str) or index.map(formatter) instead. stacklevelr formatterrr    escape_charsdisplay.multi_sparseFstartsentinelr)%warningswarnrJre FutureWarningr)rrrr_ _get_na_reprrformatrrZrrrtolistrrrrJr:rryextendrrrwrrsparsify_labelsrrIadjoinsplit)r^rxrrryspacesparsifyrstringified_levelsrrna formattedrr result_levelslev_namerradjs r`rMultiIndex.formatsM  Dz""#$, , ')    E t9>I #DKK < C!-;syy3IB3x!|HH[18898M #b(88:: "& AI&(dO ) 0 0 2I #]]3;; DD!tAwwADVWD  % %i 0'!=*  !3ZZ@MCE +!8JK LL#V4 5   'A  !"89H ;=Hh--S^^1K KKE3>>22#+SZ(M  "C::e4m4::4@ @ Ms(&Jrc 0[U5S:Xa/$/n[URUR5HupV[ UR 5n[U5S:ajUR U5=pURSUS9n US:Hn U R5(a-[R"U [S9n XyU 'U R5n OK[R"URU5V s/sHn [![#U 5(aUOU SS9PM! n n UR%U 5 M /n [X@R&5Heup]/nU(aUR%U b [!U SS9OS5 UR)[R"U[S95 U R%U5 Mg Uc [+S 5nU(aUSn[-U[.5(dU[0R2LdeU[0R2LaUn[5U [7U5US 9n U $s sn f) NrF) include_namerrrrrrrr)rrrr_rrr _format_flatrrZrrrrrrrrJr:rryrrrrwrrrr)r^ include_namesrrrrrrtakenrrrrrrrs r` _format_multiMultiIndex._format_multis t9>I #DKK < CSYY'B3x!|$'HH[$99!..EY.W #b(88:: "& AI&(dO ) 0 0 2I #]]3;; DD!tAwwADVWD  % %i 0)!=,  !3ZZ@MCE +!8JK LL#V4 5   'A  !"89H ;=Hh--S^^1K KK3>>)#+S%7(MEs*&Hc,[UR5$r)rErrs r` _get_namesMultiIndex._get_names#s$++&&rc)rrcFUb[U5(d [S5e[U5nU(aMUb#[U5[U5:wa [S5eUc$[U5UR:wa [S5eUc[ UR5nO UVs/sHo@R U5PM nn[X!5HGupEUb1[U5(d![[U5RS35eXPRU'MI UR5 gs snf)a^ Set new names on index. Each name has to be a hashable type. Parameters ---------- values : str or sequence name(s) to set level : int, level name, or sequence of int/level names (default None) If the index is a MultiIndex (hierarchical), level(s) to set (None for all levels). Otherwise level must be None validate : bool, default True validate that the names match level lengths Raises ------ TypeError if each name is not hashable. Notes ----- sets names on levels. WARNING: mutates! Note that you generally want to set this *after* changing levels, so that it only acts on copies Nz*Names should be list-like for a MultiIndexz+Length of names must match length of level.z:Length of names must match number of levels in MultiIndex.z.name must be a hashable type)r0rrrrrrrr-rzrJrerr)r^ryrrrrxs r`rMultiIndex._set_names&s6  \%%8%8IJ JU   SZ3u:%= !NOO}Ut||!; P =$,,'E>> mi = pd.MultiIndex.from_arrays( ... [[1, 2], [3, 4], [5, 6]], names=['x', 'y', 'z']) >>> mi MultiIndex([(1, 3, 5), (2, 4, 6)], names=['x', 'y', 'z']) >>> mi.names FrozenList(['x', 'y', 'z']) )fsetfgetr(cg)Nrmrdrs r` inferred_typeMultiIndex.inferred_typeusrcc URRU5nUS:a[U5(d[SUS35eURR U5nU$![an[U5(d[ SUS35UeUS:aEXR - nUS:a+XR - n[SUR SUS 35UeSnAU$XR :a[SUR S US-35UeSnAU$SnAff=f) NrUz The name z* occurs multiple times, use a level numberzLevel z not foundrz Too many levels: Index has only z levels, z is not a valid level numberz levels, not )rycountr.rrKeyErrorr IndexError)r^rrerr orig_levels r`rMultiIndex._get_level_numberys<   ' AIz%00E7"LM  JJ$$U+E$ # e$$wj9:Cqy%19!&!5J$:4<<. %,&BD ,,& 6t||nE 19+''  # sA D )A%D.DD c l[SUR55(ag[SUR55(a>[R "URVs/sHoR SSS9PM sn5$[[[UR555Vs/sHo RU5RPM nn[R"U5n[U5R$s snfs snf![ a" [UR5Rs$f=f)z9 Return a boolean if the values are equal or increasing. c3,# UH nSU;v M g7f)rNrd)rrs r`r5MultiIndex.is_monotonic_increasing..s1jdrTzjsFc38# UHoRv M g7fris_monotonic_increasing)rrs r`rrsF+,,+r,int64r)rr_rrlibalgos is_lexsortedrsreversedrr_get_level_valuesrrZlexsortrArrz)r^rrr sort_orders r`r"MultiIndex.is_monotonic_increasings 1djj1 1 1 F$++F F F((8< C 1'. C  8@c$++FV@W7X 7X! " "1 % - -7X   ?F+J$<< <D  ?&>> > ?s"C=+$D*D)D32D3c&USSS2R$)z9 Return a boolean if the values are equal or decreasing. Nrrrs r`is_monotonic_decreasing"MultiIndex.is_monotonic_decreasings DbDz111rccXURVs/sHoRPM sn$s snf)z7return a list of the inferred types, one for each level)rr)r^rs r`rx MultiIndex._inferred_type_levelss"*.5A555s'c|[SUR55n[URUSSS9n[ X15$)Nc38# UHn[U5v M g7frr)rrs r`r(MultiIndex.duplicated..s6+3c#hh+r,F)sortxnull)rrrGr_r)r^keepshapeidss r`rMultiIndex.duplicateds56$++66djj%e5I#$$rcc[S5e)z* fillna is not implemented for MultiIndex z"isna is not defined for MultiIndex)NotImplementedError)r^valuedowncasts r`fillnaMultiIndex.fillnas""FGGrcc:URVs/sHo"S:HPM nnUS:Xa[R"USS9nO*US:Xa[R"USS9nO[ SU35eURVs/sHo"U)PM nnUR US9$s snfs snf)NrrrrVrzinvalid how option: )r_)r_rZrrrr;)r^howrnansindexerrs r`dropnaMultiIndex.dropnas59ZZ@Zkr!Z@ %<ffT*G E\ffT*G3C59: :>BjjIj{'*j I~~I~..AJs B3BcURUnURUnURUnU(a[R"U5n[R "UR XCRS9nURXeS9$)z Return vector of label values for requested level, equal to the length of the index **this is an internal method** Parameters ---------- level : int unique : bool, default False if True, drop duplicated values Returns ------- Index rr ) rr_rruniquerrrrN)r^rr rrrxfilleds r`rMultiIndex._get_level_valuessk"kk% jj' {{5! ,,{3Ks{{KMMR   33rccJURU5nURU5nU$)a Return vector of label values for requested level. Length of returned vector is equal to the length of the index. Parameters ---------- level : int or str ``level`` is either the integer position of the level in the MultiIndex, or the name of the level. Returns ------- Index Values is a level of this MultiIndex converted to a single :class:`Index` (or subclass thereof). Notes ----- If the level contains missing values, the result may be casted to ``float`` with missing values specified as ``NaN``. This is because the level is converted to a regular ``Index``. Examples -------- Create a MultiIndex: >>> mi = pd.MultiIndex.from_arrays((list('abc'), list('def'))) >>> mi.names = ['level_1', 'level_2'] Get level values by supplying level as either integer or name: >>> mi.get_level_values(0) Index(['a', 'b', 'c'], dtype='object', name='level_1') >>> mi.get_level_values('level_2') Index(['d', 'e', 'f'], dtype='object', name='level_2') If a level contains missing values, the return type of the level may be cast to ``float``. >>> pd.MultiIndex.from_arrays([[1, None, 2], [3, 4, 5]]).dtypes level_0 int64 level_1 int64 dtype: object >>> pd.MultiIndex.from_arrays([[1, None, 2], [3, 4, 5]]).get_level_values(0) Index([1.0, nan, 2.0], dtype='float64') )rr)r^rrs r`get_level_valuesMultiIndex.get_level_valuess*`&&u-''. rccjUcUR5$URU5nURUSS9$)NT)rr )drop_duplicatesrr)r^rs r`r MultiIndex.unique,s< ='') )**51E))d)C Crcc  SSKJn U[RLaK[ U5(d [ S5e[ U5[ UR5:wa [S5eUnOUR5nU(d,[ [U55[ U5:wa [S5eU"[[ UR55Vs0sHofURU5_M snSS9nXWl U(aXlU$s snf)a Create a DataFrame with the levels of the MultiIndex as columns. Column ordering is determined by the DataFrame constructor with data as a dict. Parameters ---------- index : bool, default True Set the index of the returned DataFrame as the original MultiIndex. name : list / sequence of str, optional The passed names should substitute index level names. allow_duplicates : bool, optional default False Allow duplicate column labels to be created. .. versionadded:: 1.5.0 Returns ------- DataFrame See Also -------- DataFrame : Two-dimensional, size-mutable, potentially heterogeneous tabular data. Examples -------- >>> mi = pd.MultiIndex.from_arrays([['a', 'b'], ['c', 'd']]) >>> mi MultiIndex([('a', 'c'), ('b', 'd')], ) >>> df = mi.to_frame() >>> df 0 1 a c a c b d b d >>> df = mi.to_frame(index=False) >>> df 0 1 0 a c 1 b d >>> df = mi.to_frame(name=['x', 'y']) >>> df x y a c a c b d b d r)rLz1'name' must be a list / sequence of column names.z<'name' should have same length as number of levels on index.zBCannot create duplicate column labels if allow_duplicates is FalseFr)rrLrrr0rzrrr_get_level_namessetrrrr)r^rrxallow_duplicatesrL idx_namesrrs r`to_frameMultiIndex.to_frame4sx % s~~ %%% STT4yC ,, RI--/ICI$73y>$IT  ?DSEU?V W?VeD**51 1?V W # L  Xs Dc*[URSS9$)aT Convert a MultiIndex to an Index of Tuples containing the level values. Returns ------- pd.Index Index with the MultiIndex data represented in Tuples. See Also -------- MultiIndex.from_tuples : Convert flat index back to MultiIndex. Notes ----- This method will simply return the caller if called by anything other than a MultiIndex. Examples -------- >>> index = pd.MultiIndex.from_product( ... [['foo', 'bar'], ['baz', 'qux']], ... names=['a', 'b']) >>> index.to_flat_index() Index([('foo', 'baz'), ('foo', 'qux'), ('bar', 'baz'), ('bar', 'qux')], dtype='object') F) tupleize_cols)rArrs r` to_flat_indexMultiIndex.to_flat_indexs8T\\77rcc4URUR:H$)a Return True if the codes are lexicographically sorted. Returns ------- bool Examples -------- In the below examples, the first level of the MultiIndex is sorted because a>> pd.MultiIndex.from_arrays([['a', 'b', 'c'], ... ['d', 'e', 'f']])._is_lexsorted() True >>> pd.MultiIndex.from_arrays([['a', 'b', 'c'], ... ['d', 'f', 'e']])._is_lexsorted() True In case there is a tie, the lexicographical sorting looks at the next level of the MultiIndex. >>> pd.MultiIndex.from_arrays([[0, 1, 1], ['a', 'b', 'c']])._is_lexsorted() True >>> pd.MultiIndex.from_arrays([[0, 1, 1], ['a', 'c', 'b']])._is_lexsorted() False >>> pd.MultiIndex.from_arrays([['a', 'a', 'b', 'b'], ... ['aa', 'bb', 'aa', 'bb']])._is_lexsorted() True >>> pd.MultiIndex.from_arrays([['a', 'a', 'b', 'b'], ... ['bb', 'aa', 'aa', 'bb']])._is_lexsorted() False )rrrs r` _is_lexsortedMultiIndex._is_lexsortedsD""dll22rcctURb UR$[URUR5$)z} Compute and return the lexsort_depth, the number of levels of the MultiIndex that are sorted lexically Returns ------- int )rrr_rrs r`rMultiIndex._lexsort_depths- >> %>> !djj$,,77rccHUR5(aUR(aU$/n/n[URUR5HupEUR(dbUR 5nUR U5n[U5n[R"U[U55n[R"XuSS9nURU5 URU5 M [UUUR UR"SS9$![a U(aeN[f=f)a This is an *internal* function. Create a new MultiIndex from the current to monotonically sorted items IN the levels. This does not actually make the entire MultiIndex monotonic, JUST the levels. The resulting MultiIndex will have the same outward appearance, meaning the same .values and ordering. It will also be .equals() to the original. Returns ------- MultiIndex Examples -------- >>> mi = pd.MultiIndex(levels=[['a', 'b'], ['bb', 'aa']], ... codes=[[0, 0, 1, 1], [0, 1, 0, 1]]) >>> mi MultiIndex([('a', 'bb'), ('a', 'aa'), ('b', 'bb'), ('b', 'aa')], ) >>> mi.sort_values() MultiIndex([('a', 'aa'), ('a', 'bb'), ('b', 'aa'), ('b', 'bb')], ) rrF)ryrr)r!rrrr_argsortrr,rget_reverse_indexerrrrrzrrNryr)r^raise_if_incomparablerrrrrris r`_sort_levels_monotonic!MultiIndex._sort_levels_monotonicsD     D$@$@K  #DKK < C.. P!kkmG ((7+C2':G00#g,GB"'--B"OK   c "   [ )#!=&  **nn"   !,-s$D  D! D!c/n/nSn[URUR5GHupE[R"[R "US-5S:5SS- n[ [U5=(a USS:H5n[U5[U5U-:waUR5R5(a[U5[U5:Xa OSn[R"U5nU(a-[R"US:H5SnXhSS/USUS/'[R"[U5U-5n [R"[U55U- X'XnURXgS5nURU5 URU5 GM UR!5n U(a0U R#5 U R%USS9 U R'USS9 U $)a Create new MultiIndex from current that removes unused levels. Unused level(s) means levels that are not expressed in the labels. The resulting MultiIndex will have the same outward appearance, meaning the same .values and ordering. It will also be .equals() to the original. Returns ------- MultiIndex Examples -------- >>> mi = pd.MultiIndex.from_product([range(2), list('ab')]) >>> mi MultiIndex([(0, 'a'), (0, 'b'), (1, 'a'), (1, 'b')], ) >>> mi[2:] MultiIndex([(1, 'a'), (1, 'b')], ) The 0 from the first level is not represented and can be removed >>> mi2 = mi[2:].remove_unused_levels() >>> mi2.levels FrozenList([[1], ['a', 'b']]) FrUrrTNr)rrr_rZrbincountrrr:rrr rarangerrr5rrr) r^rrchangedrruniqueshas_nana_idx code_mappingrs r`remove_unused_levelsMultiIndex.remove_unused_levels#sF   #DKK < Chhr{{;?;a?@CaGGW<71:+;=F7|s3x&0088:>>##G C(@  ,,{3XXgm4Q7F.5ay!n.EGQq N+ "xxC6(9: (* #g,(?&(H %*7 hhww/0   c "   [ )G!=J   " " $   zE  :   i%  8 rcc[UR5[UR5UR[UR5S.n[ R [U5U4S4$)z*Necessary for making this object picklable)rr_rryN)rrr_rryibase _new_IndexrJ)r^ds r` __reduce__MultiIndex.__reduce__{sS4;;'$**%$**%   $t*a$66rcc[U5(a[R"U5n/n[URUR 5HDup4XAS:Xa!UR [R5 M.UR X4U5 MF [U5$Sn[R"U5(a&[R"U[S9nURnOj[U[5(a*UR bUR S:a URnO+[U["5(a[R"U5nUR Vs/sHoDUPM nn[%URUUR&USS9$s snf)NrrrFr)r2rcast_scalar_indexerrrr_rrZrris_bool_indexerrrwrrslicesteprArNry)r^reretvalrrrrs r` __getitem__MultiIndex.__getitem__s3 S>>))#.CF$' TZZ$@ #r)MM"&&)MM##&6"78 %A = I""3''jjD1 NN C''88#sxx!| $IC''jjo=AZZHZkS)ZIH{{jj#!&  IsFcSnURbURS:a URnURVs/sHo3UPM nn[U5"URUUR USS9$s snf)z8 Fastpath for __getitem__ when we know we have a slice. NrFr)rArr_rJrr)r^slobjrrrs r`_getitem_sliceMultiIndex._getitem_sliceso :: aI;?::F:K': FDz;;++"   GsA1rc [R"SU5 [U5nURX4U5nSnURVs/sHowR U5PM nnU(aRUS:Hn U R 5(a8/n UH.n U n XlU 'U R[R"U 55 M0 U n[URXRSS9$s snf)NrdrFrr_ryr) nv validate_taker,_maybe_disallow_fillr_rrrrZrrNrry) r^indicesrW allow_fillrr~na_valuelabrrmasked new_label label_valuess r`rMultiIndex.takes V$%g...zwO .2jj9js'"j9 b=Dxxzz!&I#,L)1&MM"**\":;"';;e::PU  :sCc |^^ ^ [U[[45(dU/n[U4SjU55(Ga/n/n/n[ TR 5Hm TR T nUH!nURUR T 5nM# T/UQVs/sH)n[URT UR T USS9PM+ nnTRT m [U U 4SjU55(aSm UR[R"U55 URU5 URT 5 M [X#USS9$TR 4[SU55-n[R"U5n [R#U 5$s snf![$[&4a [)U 5s$f=f)aT Append a collection of Index options together. Parameters ---------- other : Index or list/tuple of indices Returns ------- Index The combined index. Examples -------- >>> mi = pd.MultiIndex.from_arrays([['a'], ['b']]) >>> mi MultiIndex([('a', 'b')], ) >>> mi.append(mi) MultiIndex([('a', 'b'), ('a', 'b')], ) c3># UH5n[U[5=(a URTR:v M7 g7fr)rrNr)ror^s r`r$MultiIndex.append..s0 OT!Z: & D199 +D Dus=AFrc3F># UHoRTT:gv M g7frry)rrr level_names r`rrY sA5Rxx{j05s!N)r_rryrc38# UHoRv M g7frrrks r`rrY s+Eu!IIur,)rrrrrrrunionr?r_ryrrrZrDrNrrrzrrA) r^otherr_rry level_valuesrr to_concat new_tuplesrr\s ` @@r`rMultiIndex.appends.%$//GE  OT   EFE4<<(#{{1~ B#/#5#5biil#CL !%~u~  .* RYYq\[U[5(aMURb UROSnUR[UR UR"U55 M[ R$"U5(aYUR&S:Xa"[(R*"S[,[/5S9 UR15SnURU5 GMS[3U53n[5U5e UR9U5$![a GNQf=f![6a US:waeGMff=f) a Make a new :class:`pandas.MultiIndex` with the passed list of codes deleted. Parameters ---------- codes : array-like Must be a list of tuples when ``level`` is not specified. level : int or level name, default None errors : str, default 'raise' Returns ------- MultiIndex Examples -------- >>> idx = pd.MultiIndex.from_product([(0, 1, 2), ('green', 'purple')], ... names=["number", "color"]) >>> idx MultiIndex([(0, 'green'), (0, 'purple'), (1, 'green'), (1, 'purple'), (2, 'green'), (2, 'purple')], names=['number', 'color']) >>> idx.drop([(1, 'green'), (2, 'purple')]) MultiIndex([(0, 'green'), (0, 'purple'), (1, 'purple'), (2, 'green')], names=['number', 'color']) We can also drop from a specific level. >>> idx.drop('green', level='color') MultiIndex([(0, 'purple'), (1, 'purple'), (2, 'purple')], names=['number', 'color']) >>> idx.drop([1, 2], level=0) MultiIndex([(0, 'green'), (0, 'purple')], names=['number', 'color']) rrrrUrzYdropping on a non-lexsorted multi-index without a level parameter may impact performance.rzunsupported indexer of type ignore)_drop_from_levelrrZrrArindex_labels_to_arrayrrrbrrr@rArrrstopr?rrrr$r)nonzerorJAssertionErrorrdelete) r^r_rerrorsindsrlocrAmsgs r`dropMultiIndex.drop3 sh  ((v> >%"**e!455 11%rxx?QR K ll;/c3''KK$U++'*xx';388DKKcii4 @A((--**a/ P.'7'9  ++-*CKK$8c DC(---!6{{4  ?  6 X%& s7)F).7F:'A F: A1F:=F:) F76F7:GGc[R"U5nURU5nURUnUR U5n[ U5nSU[ R"US5US:H-'URSURS:XaSU[ R"US5'XS:Hn[U5S:waUS:wa[SUS35e[R"URUU5)n X $) NFrrTruzlabels z not found in level)rrwrr get_indexerr:rZequalrrrrisinr_) r^r_rr|rrr nan_codes not_foundrs r`rvMultiIndex._drop_from_level s))%0  " "5 ) A""5)K @BE*v|<= ;;q>TZZ] *02F288It, -B,' y>Q 6X#5WYK/BCD D 4::a=&11zrcc([UR5n[UR5n[UR5nUR U5nUR U5nX2X1sX1'X2'XBXAsXA'XB'XRXQsXQ'XR'[ X4USS9$)a Swap level i with level j. Calling this method does not change the ordering of the values. Parameters ---------- i : int, str, default -2 First level of index to be swapped. Can pass level name as string. Type of parameters can be mixed. j : int, str, default -1 Second level of index to be swapped. Can pass level name as string. Type of parameters can be mixed. Returns ------- MultiIndex A new MultiIndex. See Also -------- Series.swaplevel : Swap levels i and j in a MultiIndex. DataFrame.swaplevel : Swap levels i and j in a MultiIndex on a particular axis. Examples -------- >>> mi = pd.MultiIndex(levels=[['a', 'b'], ['bb', 'aa']], ... codes=[[0, 0, 1, 1], [0, 1, 0, 1]]) >>> mi MultiIndex([('a', 'bb'), ('a', 'aa'), ('b', 'bb'), ('b', 'aa')], ) >>> mi.swaplevel(0, 1) MultiIndex([('bb', 'a'), ('aa', 'a'), ('bb', 'b'), ('aa', 'b')], ) FrJ)rrr_ryrrN)r^rjrr new_namess r` swaplevelMultiIndex.swaplevel sV$++& $ $  " "1 %  " "1 %'1}jm$ z}%.\9<" il%.\9<" iliRW  rccrUVs/sHo RU5PM nnURU5nU$s snf)a Rearrange levels using input order. May not drop or duplicate levels. Parameters ---------- order : list of int or list of str List representing new level order. Reference level by number (position) or by key (label). Returns ------- MultiIndex Examples -------- >>> mi = pd.MultiIndex.from_arrays([[1, 2], [3, 4]], names=['x', 'y']) >>> mi MultiIndex([(1, 3), (2, 4)], names=['x', 'y']) >>> mi.reorder_levels(order=[1, 0]) MultiIndex([(3, 1), (4, 2)], names=['y', 'x']) >>> mi.reorder_levels(order=['y', 'x']) MultiIndex([(3, 1), (4, 2)], names=['y', 'x']) )r_reorder_ilevels)r^orderrrs r`reorder_levelsMultiIndex.reorder_levels s<@5::Eq''*E:&&u- ;s4cd[U5UR:wa$[SURS[U535eUVs/sHo RUPM nnUVs/sHo RUPM nnUVs/sHo R UPM nn[ X4USS9$s snfs snfs snf)Nz2Length of order must be same as number of levels (z), got FrJ)rrrzrr_ryrN)r^rrrrrs r`rMultiIndex._reorder_ilevels s u: % DT\\NS5zl$ /44ekk!ne 4,12EqZZ]E 2,12EqZZ]E 2iRW  522sB# B(>B-c## [U5UR:a%[S[U5SURS35e[[U55H-n[ UR UUR UXUS9v M/ g7f)NzLength of new_levels (z) must be <= self.nlevels ()r)rrrzrr?r_r)r^rrrs r`_recode_for_new_levels!MultiIndex._recode_for_new_levels s z?T\\ ) (Z(9:,,0LL>< s:'A' 1 t{{1~z}4 (sBBc SnURVs/sHn[R"X!"U5SSS9PM! sn$s snf)z we are categorizing our codes by using the available categories (all, not just observed) excluding any missing ones (-1); this is in preparation for sorting, where we need to disambiguate that -1 is not a valid valid c[R"[U5(a'[R"U5R 5S-OSUR S9$)NrUrr)rZr/rrrr)rs r`cats/MultiIndex._get_codes_for_sorting..cats% sB9936{3C3C%))+a/!'' rcTFr-)r_r< from_codes)r^rrs r`rj!MultiIndex._get_codes_for_sorting sI  $zz )   " ";[0A4RW X)   s&;c[U5(dU/nUVs/sHoPRU5PM nnSnUVs/sHoPRUPM nn[U[5(a$[ U5[ U5:Xd [ S5eO_U(aSUR[[ UR55Vs/sHoUU;dM URUPM sn5 OUSn[XrUSS9n[U5nURV s/sHoRU5PM n n [U URURUSS9n X4$s snfs snfs snfs sn f)a+ Sort MultiIndex at the requested level. The result will respect the original ordering of the associated factor at that level. Parameters ---------- level : list-like, int or str, default 0 If a string is given, must be a name of the level. If list-like must be names or ints of levels. ascending : bool, default True False to sort in descending order. Can also be a list to specify a directed ordering. sort_remaining : sort by the remaining levels after level na_position : {'first' or 'last'}, default 'first' Argument 'first' puts NaNs at the beginning, 'last' puts NaNs at the end. .. versionadded:: 2.1.0 Returns ------- sorted_index : pd.MultiIndex Resulting index. indexer : np.ndarray[np.intp] Indices of output values in original index. Examples -------- >>> mi = pd.MultiIndex.from_arrays([[0, 0], [2, 1]]) >>> mi MultiIndex([(0, 2), (0, 1)], ) >>> mi.sortlevel() (MultiIndex([(0, 1), (0, 2)], ), array([1, 0])) >>> mi.sortlevel(sort_remaining=False) (MultiIndex([(0, 2), (0, 1)], ), array([0, 1])) >>> mi.sortlevel(1) (MultiIndex([(0, 1), (0, 2)], ), array([1, 0])) >>> mi.sortlevel(1, ascending=False) (MultiIndex([(0, 2), (0, 1)], ), array([0, 1])) Nz(level must have same length as ascendingrT)ordersrgriF)r_rryrr)r0rr_rrrrrrrrHr,rrNry) r^r ascendingsort_remainingrgrrr_rrrrYs r` sortlevelMultiIndex.sortlevel0 sZ~E""GE49 38C " "3 '5   ,12ESCE2 i & &u:Y/ !KLL0  LL,1#dkk2B,CX,CSRWGWC,CX aI! $ &g.BF**M*;%%g.* M;;**"  !!A 3YNsEE? E EEc[U[5(dFUcUnO@US:R5(aURU5nO[R U5nUR X5nU$![ a Us$f=fr)rrNrrrrz_maybe_preserve_names)r^rkrpreserve_namess r`_wrap_reindex_resultMultiIndex._wrap_reindex_result s|&*--Q,##%%7+"'33F;F ++FC !"!M"sA// A>=A>cU(aTURUR:Xa:URUR:wa URSS9nURUlU$)NFr)rryr)r^rkrs r`r MultiIndex._maybe_preserve_names sE $,,.  *[[e[,F::FL rccZ[U5(a[U5(a [U5egr)r-r/r#rds r`_check_indexing_error MultiIndex._check_indexing_error s)3;s#3#3$C( ( $4rcc4URSR$)z1 Should integer key(s) be treated as positional? r)r_should_fallback_to_positionalrs r`r)MultiIndex._should_fallback_to_positional s {{1~<<Un[U[5(d[R"U5n[ U5(aA[US[ 5(d)UR U5nURXU5 XU4$[TU]%X5$r) rrArrrr_get_indexer_level_0_raise_if_missingsuper_get_indexer_strict)r^re axis_namekeyarrr __class__s r`rMultiIndex._get_indexer_strict s}&%((**62F v;;z&)U;;//7G  " "3 ;=') )w*3::rcc>Un[U[5(d[R"U5n[ U5(a[US[ 5(dqUS:HnUR 5(aVURSRU5nUS:HnUR 5(a[XGS35e[US35eg[TU]-XU5$)Nrrz not in index) rrArrrrrrrrrr) r^rerrrrcheckcmaskrs r`rMultiIndex._raise_if_missing s#u%%**3/F v;;z&)U;;b=Dxxzz A226: 99;;"fm_M#BCC&7887,S9E ErccURSnURSn[R"X2SS9n[ U5nUR U5$)zM Optimized equivalent to `self.get_level_values(0).get_indexer_for(target)`. rF)r_ categoriesr)rrr<rrAget_indexer_for)r^rkrr_catcis r`rMultiIndex._get_indexer_level_0 sJkk!n A$$55Q 3Z!!&))rccP[U[5(dU4nURXS9$)a For an ordered MultiIndex, compute slice bound that corresponds to given label. Returns leftmost (one-past-the-rightmost if `side=='right') position of given label. Parameters ---------- label : object or tuple of objects side : {'left', 'right'} Returns ------- int Index of label. Notes ----- This method only works if level 0 index of the MultiIndex is lexsorted. Examples -------- >>> mi = pd.MultiIndex.from_arrays([list('abbc'), list('gefd')]) Get the locations from the leftmost 'b' in the first level until the end of the multiindex: >>> mi.get_slice_bound('b', side="left") 1 Like above, but if you get the locations from the rightmost 'b' in the first level and 'f' in the second level: >>> mi.get_slice_bound(('b','f'), side="right") 3 See Also -------- MultiIndex.get_loc : Get location for a label or a tuple of labels. MultiIndex.get_locs : Get location for a label/slice/list/mask or a sequence of such. side)rr_partial_tup_index)r^labelrs r`get_slice_boundMultiIndex.get_slice_bound s-`%''HE&&u&88rcc$>[TU]XU5$)a For an ordered MultiIndex, compute the slice locations for input labels. The input labels can be tuples representing partial levels, e.g. for a MultiIndex with 3 levels, you can pass a single value (corresponding to the first level), or a 1-, 2-, or 3-tuple. Parameters ---------- start : label or tuple, default None If None, defaults to the beginning end : label or tuple If None, defaults to the end step : int or None Slice step Returns ------- (start, end) : (int, int) Notes ----- This method only works if the MultiIndex is properly lexsorted. So, if only the first 2 levels of a 3-level MultiIndex are lexsorted, you can only pass two levels to ``.slice_locs``. Examples -------- >>> mi = pd.MultiIndex.from_arrays([list('abbd'), list('deff')], ... names=['A', 'B']) Get the slice locations from the beginning of 'b' in the first level until the end of the multiindex: >>> mi.slice_locs(start='b') (1, 4) Like above, but stop at the end of 'b' in the first level and 'f' in the second level: >>> mi.slice_locs(start='b', end=('b', 'f')) (1, 3) See Also -------- MultiIndex.get_loc : Get location for a label or a tuple of labels. MultiIndex.get_locs : Get location for a label/slice/list/mask or a sequence of such. )r slice_locs)r^rendrArs r`rMultiIndex.slice_locs# sjw!%d33rcc[U5UR:a%[S[U5SURS35e[U5nS[U5pT[XRUR 5n[ U5GHWunupn XUn X;ao[U5(d_[R"XUS9n [U 5(d[SU35eUS:Xa U S:aU S-n U[R"XUS9-s $URX5n[U[5(a"XsS- :aURnUR nMXsS- :a3U[R"XSS9-nU[R"XS S9-nGM[U[5(a&URnU[R"XUS9-s $U[R"XUS9-s $ g![an [SU35U eSn A ff=f) N Key length (z-) was greater than MultiIndex lexsort depth (rrrzLevel type mismatch: rightrUleft)rrr%rrr_ enumerater:r searchsortedrzr._get_loc_single_level_indexrr@rrx)r^rrnrrzippedr_rQrrsectionr~rr#s r`rMultiIndex._partial_tup_indexZ s s8d)) )$s3xj)''(+  HD sS++tzz2*3F*; &A&+!,G~d3iiL,,SDAC"##&;C5$ABB7?sax1HCu11'TJJJ223>d3ii&&s+ +rcc ^TRU5 U4Sjn[U[5(dTRUSS9nU"U5$[ U5nTR U:a[ SUSTR S35eUTR :Xa-TR(aTRRU5$TRnUSUXSpU(dSn [ T5n OTRX5upX:Xa [ U5eU (d [!X5$["R$"S[&[)5S 9 [*R,"X[*R.S 9n[1U [ U55Hkup|TR2UUTR5TR6UU 5:Hn U R95(dX=n[ U5(aMb[ U5e [ U5X- :waU"U5$[!X5$![ an[ U5UeSnAf[a5 TRU[[TR 555up6Us$f=f![an[ U5UeSnAff=f) a Get location for a label or a tuple of labels. The location is returned as an integer/slice or boolean mask. Parameters ---------- key : label or tuple of labels (one for each level) Returns ------- int, slice object or boolean mask If the key is past the lexsort depth, the return may be a boolean mask array, otherwise it is always a slice or int. See Also -------- Index.get_loc : The get_loc method for (single-level) index. MultiIndex.slice_locs : Get slice location given start label(s) and end label(s). MultiIndex.get_locs : Get location for a label/slice/list/mask or a sequence of such. Notes ----- The key cannot be a slice, list of same-level labels, a boolean mask, or a sequence of such. If you want to use those, use :meth:`MultiIndex.get_locs` instead. Examples -------- >>> mi = pd.MultiIndex.from_arrays([list('abb'), list('def')]) >>> mi.get_loc('b') slice(1, 3, None) >>> mi.get_loc(('b', 'e')) 1 cZ>[U[R5(aUR[R:waU$[ R "U[T55n[U[5(aU$[R"[T5SS9nURS5 SX'U$)z._maybe_to_slice s|c2::..#))rww2F ,,S#d)>> mi = pd.MultiIndex.from_arrays([list('abb'), list('def')], ... names=['A', 'B']) >>> mi.get_loc_level('b') (slice(1, 3, None), Index(['e', 'f'], dtype='object', name='B')) >>> mi.get_loc_level('e', level='B') (array([False, True, False]), Index(['b'], dtype='object', name='A')) >>> mi.get_loc_level(['b', 'e']) (1, None) rprU)rrrr_get_loc_levelrr.)r^rer drop_levelrr~rs r`rMultiIndex.get_loc_level sR%$//**51ETUn[USS9HnURU/5nM U$)z^ If level does not exist or all levels were dropped, the exception has to be handled outside. T)reverse)sorted_drop_level_numbers)rrrYrr^s r`maybe_mi_droplevels6MultiIndex._get_loc_level..maybe_mi_droplevels] s9 W IFD1%991#> 2 rcz:Key for location must have same length as number of levelsNrprTrc3B# UHn[U[5v M g7fr)rr@r^s r`r,MultiIndex._get_loc_level.. s9Sz!U++Ssz'Expected label or tuple of labels, got )rrrrrzrrr@rZrrwrrrrzr#rrrrGrbrrr.r!_supports_partial_string_indexingrr is_null_slice is_full_slice)r^rerrrrr_r~rYrrrrrilevels loc_levelk_indexr result_indexs` r`rMultiIndex._get_loc_levelW s  eeT] + +3x3u:%$PFe/!%!4!4Q!4!Bc5))88CIT:D $DIC &FL * ")7 :  c4 *C c5 ! !eqj $++a.("55c5GG 3GaS AI"--)9S999s8t||+ $ 4 4S 94@@,,s+&+CHoUoQ5tCT9T1oUw<4<</!'**&},"'s3x!0A *363 7 7#';;q>#S#S   FeD$&77 !07|t||3"$ 3G EEE%cNDA%a//$($;$;A$;$G %i77"00;;s?P?P )3t9@@!)')hhs4y&EG15GI.'0G**1-- (*QRUQV(WXX")7*;+<?#D$/G&+CHoUoQ5tCT9T1oU 3G EEE--c-?G3$$KK&HH E*2237!%(("DM11 -27GD L( (_ "&\:   "$01  $5&sm4$V`V  -#G} L( ( -s~4Q=.Q50R 4R6R69R;R;*R;.SS SQ21Q25R R  R3 R"" R32R3SScdURUnURUnX54Sjn[U[5(GawURnUSL=(a US:nUR bUR UR 5n OU(a[U5S- n OSn URbUR UR5n O:U(aSn O0[U [5(a [U5n O[U5S- n [U [5(d[U [5(a#[U SU 5n [U SU 5n U"XU5$US:dURS:XdUbU(aU S- OU S-n U"XU5$[R"XYSS9n [R"XZSS9n [XU5$URXA5n US:dURS:Xaq[U [5(aX]R :X]R:-nU$[ R""X]:H[$S 9nUR'5(d [U5eU$[U [5(a?[R"X]R SS9n [R"X]RSS9nO*[R"X]SS9n [R"X]SS9nX:Xa [U5e[X5$![aB URUR URUR5=pU RnGN2f=f) NcUbXCnUbUS:Xa X@:XA:-nO5[R"XX$RS9n[R"XF5nUcU$UR 5nXSU'U$)NrUr)rZr/rrrr)rrxrArr_ new_indexerrs r`convert_indexer6MultiIndex._get_level_indexer..convert_indexer sq"|tqy$~%,? IIe4{{C#jj2 ""llnG*G NrcrrUrrxrrrr)rr_rr@rArrbrrxr slice_indexerrrrrrrZrrwr)r^rerrrrrrAis_negative_steprrxrrr#locsrs r`rMultiIndex._get_level_indexer skk%( jj' 7> , c5 ! !88D#4/>> mi = pd.MultiIndex.from_arrays([list('abb'), list('def')]) >>> mi.get_locs('b') # doctest: +SKIP array([1, 2], dtype=int64) >>> mi.get_locs([slice(None), ['e', 'f']]) # doctest: +SKIP array([1, 2], dtype=int64) >>> mi.get_locs([[True, False, True], slice('e', 'f')]) # doctest: +SKIP array([2], dtype=int64) rzIMultiIndex slicing requires the index to be lexsorted: slicing on levels z, lexsort depth c30# UH o[Lv M g7fr)Ellipsisr*s r`r&MultiIndex.get_locs.. s*cH}csz2MultiIndex does not support indexing with Ellipsisc>[U[5(a)[R"T[RS9nSX'U$U$)NrT)rr@rZrbool_)rrrs r`_to_bool_indexer-MultiIndex.get_locs.._to_bool_indexer s7'5)) hhq9 '+ $""NrcNzLcannot index with a boolean indexer that is not the same length as the index)rrTrrUrrvnpt.NDArray[np.bool_])rris_true_slicesrr%rrrr?rrZrrr0rr#rzrr-rr@rrqrr/ry_reorder_indexer)r^seqrs true_slicesrrr_ lvl_indexerrr item_indexer pos_indexerrs @r`get_locsMultiIndex.get_locs] sH(11C1CC1H'IO'IVaQq'I O ;r?d.A.AA$(M)9$:M:M9NP  *c* * *%D  I 15cNDA@DK""1%%q6Q;$>!jjm ?"-"2"2"4Ka8"&"9"9!g"9"VK0&88Bbgg66' ""1%%?qCHqL'899Qbgg66#55a'5R +;7K%&vvg266++>+>"3-'A#F ?88Bbgg. .oo'* $$S66PV*9h?8 *1~~"%I(,'>'>(?( '.*:<*HK' e<<8r_rrxrqr) r^rr need_sortrr_k_codesrrl new_order key_order_map level_indexerinds r`rMultiIndex._reorder_indexer s( cNDA  ##s':':1'='=1aq6Q;''))#kk!n88;G%l3G!(" !; @ @ BI $IAu%%%%'' !d 2 AqvvzI $I y/#0N I')cNDA||C""1%%IIaL1 a!!bjj.%%STT&q$/ALLO "DKKN(;299 MPSKKNQ! !% A : :1 = -q.@ A /1yy]9K/L ,)**Q-*@A Au%%!&&*<!IIaL2.w7 Au%%!''/affnGGQD8A IIaL1 <$&D;#@jj|rcchU(aU(aX!:a [S5eURSRX5up4URX5upV[UR5nUSX4US'URVs/sHoXVPM n nU SU- U S'[ UU UR SS9$s snf)a+ Slice index between two labels / tuples, return new MultiIndex. Parameters ---------- before : label or tuple, can be partial. Default None None defaults to start. after : label or tuple, can be partial. Default None None defaults to end. Returns ------- MultiIndex The truncated MultiIndex. Examples -------- >>> mi = pd.MultiIndex.from_arrays([['a', 'b', 'c'], ['x', 'y', 'z']]) >>> mi MultiIndex([('a', 'x'), ('b', 'y'), ('c', 'z')], ) >>> mi.truncate(before='a', after='b') MultiIndex([('a', 'x'), ('b', 'y')], ) zafter < beforerFrJ)rrrrr_rNr) r^beforeafterrrrrrrrs r`truncateMultiIndex.truncate<s4 V-. .{{1~((7oof4 $++& "1 a* 1 @D K , K |a' ! ++"   Ls? B/c"URU5(ag[U[5(dg[U5[U5:wag[U[5(d7UR U5(dg[ URUR5$URUR:wag[UR5GHHnURUnURUnUS:HnUS:Hn[R"XV5(d gX5)nURURRU5nXF)nURURRU5n[U5S:Xa[U5S:XaM[U[R5(dUR!U5(d gM[U[R5(dUR!U5(d gGM6[ Xx5(aGMI g g)z Determines if two MultiIndex objects have the same labeling information (the levels themselves do not necessarily have to be the same) See Also -------- equal_levels TFrr)is_rrArrN_should_comparer9rrrr_rZ array_equalrrrequals) r^rar self_codes other_codes self_mask other_mask self_values other_valuess r`r2MultiIndex.equalsis 88E??%'' t9E "%,,''..#DLL%--@ @ <<5== (t||$AAJ++a.K"b(I$*J>>)88#J/J++a.0055jAK%k2K <<?2277 DL ;1$\):a)?k2::66")),77 8 bjj99#**;77 8( BB =%@rccURUR:wag[UR5H5nURURURU5(aM5 g g)zD Return True if the levels of both MultiIndex objects are the same FT)rrrr2)r^rars r` equal_levelsMultiIndex.equal_levelssS <<5== (t||$A;;q>((a99%rcc>URU5upUR(aA[TU] X5n[ U[ 5(aU$[ R [U6SUS9$URUSS9n[U5(aURU5nOURU5nUSLaUR5nU$U$![a, USLae[R"S[ [#5S9 U$f=f)NrFrTzTThe values in the array are unorderable. Pass `sort=False` to suppress this warning.r)_convert_can_do_setophas_duplicatesr_unionrrNrr differencerr_get_reconciled_name_object sort_valuesrzrrRuntimeWarningr))r^rar result_namesr right_missingrs r`rAMultiIndex._unions"88?   W^E0F&*-- ))V L*  ",,T,>M=!!]399%@5  #//1FM6M!t|MMF#5  Ms0C2C:9C:c[U5$r)r1)r^rs r`_is_comparable_dtypeMultiIndex._is_comparable_dtypes u%%rccjURU5nURU:waURU5$U$)z If the result of a set operation will be self, return self, unless the names change, in which case make a shallow copy of self. )_maybe_match_namesryrename)r^rarys r`rC&MultiIndex._get_reconciled_name_objects4 ''. :: ;;u% % rcc8[UR5[UR5:waS/[UR5-$/n[URUR5H.up4X4:XaURU5 MURS5 M0 U$)z Try to find common names to attach to the result of an operation between a and b. Return a consensus list of names if they match at least partly or list of None if they have completely different names. N)rryrr)r^rarya_nameb_names r`rMMultiIndex._maybe_match_namessy tzz?c%++. .6C O+ +!$**ekk:NF V$ T" ;  rccJURU5up4URU5$r)r? set_namesr^rarrrFs r`_wrap_intersection_result$MultiIndex._wrap_intersection_results%44U; --rccURU5up4[U5S:XaUR5RU5$URU5$r)r?rr5rUrVs r`_wrap_difference_result"MultiIndex._wrap_difference_resultsK44U; v;! ..0::<H H##L1 1rcc.URn[U[5(dC[U5S:XaUSSUR4$Sn[R XRS9nX4$[X5nX4$![ [4an[U5UeSnAff=f)Nrz.other must be a MultiIndex or a list of tuplesr[) ryrrArrNrrrzrD)r^rarFrrs r`r? MultiIndex._convert_can_do_setopszz %''5zQBQx++F2&225 2KE""/t;L""#I.2$C.c12sA33B BBc[U5n[U[5(a Sn[U5e[ U5(d [ S5eUSLaUR 5$U$)Nz3> 1 ndim Categorical are not supported at this timezISetting a MultiIndex dtype to anything other than object is not supportedT)r3rr4rr1rzr)r^rrrs r`rsMultiIndex.astypesaU# e- . .GC%c* *u%%#  4<::<  rcc4[U[5(a1URUR:wa [S5eUR$[U[ 5(dU4SURS- --nU$[ U5UR:wa [S5eU$)Nz0Item must have length equal to number of levels.)rrU)rrNrrrrr)r^items r`_validate_fill_valueMultiIndex._validate_fill_value)s dJ ' '||t||+ !STT<< D%((7UdllQ&677D Y$,, &OP P rcc6[X5upU(aUR5$[U5[U5:XaX!R5nOUR5n/n/n[ [ UR UR UR55Hjunupn U RUSS9n U RURU55n [U 5n XU'URU 5 URU 5 Ml [XVURSS9$)z Return a new MultiIndex of the values set with the mask. Parameters ---------- mask : array like value : MultiIndex Must either be the same length as self or length one Returns ------- MultiIndex Fr>rJ)r;rrr5rrrr_r`rrr+rrNry)r^rrnoopsubsetrrr value_levelrr new_level value_codesnew_codes r`putmaskMultiIndex.putmask7s&d1  99;  t9E "[557F//1F  4=  t{{DJJ 75 0A0 K Ke  >((/C((-DyyA~xxD ::99V$ $rc__add____radd____iadd____sub____rsub____isub____pow____rpow____mul____rmul__ __floordiv__ __rfloordiv__ __truediv__ __rtruediv____mod____rmod__ __divmod__ __rdivmod____neg____pos____abs__ __invert__)rr )NNNNNFNT)rrwrrwrvr)rrrr)NNN)r_ list | Nonerrrzlist[int] | range | None)rrry-Sequence[Hashable] | Hashable | lib.NoDefaultrvrNrT)rzIterable[tuple[Hashable, ...]]rrry$Sequence[Hashable] | Hashable | NonervrN)rzSequence[Iterable[Hashable]]rrryrrvrN)rrLrrryrrvrN)rv np.ndarray)rvrM)rvr)rvrE)rrwrrwrrwrvNone)rrwrvrN)rvr )rvzCallable[..., MultiIndex])rrrvrN)rvrN)NFN)rSrwrvrr)rvr)rer rvrw)rvznp.dtyperuF)rSrwrvr)rrrvznpt.NDArray[np.object_])NNNFNT)rxz bool | NonerCallable | Nonerz str | Noneryrwrrrrwrvr)rrwrzbool | None | lib.NoDefaultrrrvr)rrw)rvr)rvz list[str])first)rrrvr)r)rrrvrN)rrr rwrvrA)rvrA)rrwrrwrvrL)r(rwrvrN)r^rNrFr@rvrN)rTN)r^rNrWrrOrwrvrN)rgrrvnpt.NDArray[np.intp])rrrrvrN)Nraise)rz.Index | np.ndarray | Iterable[Hashable] | Noner|rrvrN)r)r|rrvrN)rr)T)rrwrvz!Generator[np.ndarray, None, None])rvzlist[Categorical])rTTr) rrrzbool | list[bool]rrwrgrrvz'tuple[MultiIndex, npt.NDArray[np.intp]])rrw)rkrArrwrvrA)rvr)rrrvz"tuple[Index, npt.NDArray[np.intp]])rrrvr)rvr)rzHashable | Sequence[Hashable]rLiteral['left', 'right']rvr)rvztuple[int, int])r)rrrr)rrArerrvr)rT)rrrrw)r)rzint | list[int])rN)rrrznpt.NDArray[np.bool_] | None)rz,tuple[Scalar | Iterable | AnyArrayLike, ...]rrrvr)rarrrvrw)rarNrvrw)rrrvrw)rrNrvrN)rrw)rrNrvrN)r~rrvrNr)rerfrgrhrirA _hidden_attrs frozenset_typr__annotations__rEr r _comparablesrrr classmethodrrrrrrrr'rpropertyrrrrrrrr$rr-r_rr;rGrKr(rNrrr\r5rfrryr~rr}rrrrrrryrrrrrxr _duplicatedrr rrr rrr!rr*r5r;rCrGr&rB_index_doc_kwargsrrr&rnrrvrrrrrjrrrrrrrrrrrrrbrrrrrr,r2r;rArJrCrMrWrZr?rsrbrkrnr{rrUrNrFrwrxryrzr{r|r}r~rrrrrrrrrrrrrrrm __classcell__)rs@r`rNrNs. Qf'')+5M D$&F !&lG \F9L !%--- -^4""59 LLL3 L\!%?B~~ D D = D  D D L!%6: MI.MIMI4 MI  MIMI^!%?B~~ :D/:D:D= :D  :D:Dx!%6: BJ BJBJ4 BJ  BJBJL2    RR4"8"8"|!&+  +  ++ +\ $d`7;` `D ! ! 2 2$!&'  '  '' 'T#T>6:> >FFF:&&   58^^KK "  >>  >@    E   "" ##2K %"" "L!%)!O!O!#O! O!  O!  O!O! O!l&* ==. = # =  =D'*.8t     E*6??<2266   %%KH   / /442h DD ^^!& XX X  Xx8<"3H 8 8A FSp7 D $ (+<<=        > >=%@)/P"%P P *->>? @ (AE% Y!>Y! Y!  Y!x3:$/ *8 t"H  (,  $  *  ,'+#" c"c"%c" c"  c" 1 c"J )== ;! ; + ;F(*29,29'29 29j5454n1Kf,2xXt5nS)lLPo%o%,Ho%bC7NV 9V&V  Vp+ Z<|  D& ".2#*    & P! F  _%%(__F i(Gz*Hz*Hi(Gz*Hz*Hi(Gz*Hi(Gz*H">2L#O4M!-0K">2Li(Gz*H .J!-0Ki(Gi(Gi(G .JrccUVs/sHn[U5PM nn[USS5H%n[R"USU5(dM#Us $ gs snf)zJCount depth (up to a maximum of `nlevels`) with which codes are lexsorted.rrN)r+rrr)r_rr int64_codesr_s r`rrsU@EF< ,KF 7Ar "  Ra 1 1H# GsAc[[U65n[U5nUSUS-nX1nX1S-SHn/n[[Xg55Hpun upXS- :Xa$UR U 5 UR U5 O@X:XaUR U5 MLUR XyS5 UR U5 O UnM [[U65$)NrU)rrrrrr) label_listrrpivotedr_rprevcur sparse_currpts r`rrs3 #$G JA [uqy !F >Dqy{# "3t>2IAvEz!!!$ j)v!!(+!!#b'* j)3")$, V rcc[U[5(a UR$URn[R S[R S0RUS5$)NNaTNaN)rr5rPrJrZ datetime64 timedelta64get)r dtype_types r`rrsI%((..!"ZZ MM5"..% 8 < r?pandas.core.commoncommonrpandas.core.constructionr@pandas.core.indexes.baseindexesbaser8rArBrCrDpandas.core.indexes.frozenrEpandas.core.ops.invalidrFpandas.core.sortingrGrHpandas.io.formats.printingrIrJrrKrLrMdictrupdateBaseMultiIndexCodesEnginerkrRrurorrNrrrrr4r"rdrcr`rs}"% .    /  58   7 '&<! 3(( 23   001,JK $38==x?T?T$3N&3H>>@U@U&3R&_;/_;/Dw @PB.rc