+ xȇiZ^RIHt^RIHtHtHtHtHtHt^RI H t ^RI H t ^RI Ht^RIHtHtHtHtHt^RIt^RIt^RIHt^R IHtHtHt^R I H!t!^R I"H#t#H$t$H%t%H&t&H't'H(t(H)t)H*t*H+t+H,t,H-t-H.t.H/t/^R I0H1t2^R I3H4t4H5t5H6t6^RI7H8t8H9t9^RI:H;t;^RIt>^RI?H@t@HAtAHBtBHCtCHDtDHEtEHFtFHGtGHHtHHItI^RIJHKtKHLtL^RIMHNtNHOtO^RIPHQtQ^RIRHStSHTtT^RIUHVuHWt^RIXHYtY^RIZH[t[H\t\^RI]H^t^H_t_^RI`HVuHatb^RIcHdtd^RIeHVuHfuHgth^RIeHitiHjtjHktk^RIlHmtm^RInHoto^RIpHqtqHrtr^RIsHttt]'d ^RIuHvtvHwtwHxtx!R R!]P]P4t{!R"R#]P]P4t}!R$R%]P]P4t!R&R']P]EP4t!R(R)]P]EP4tR*R+lt]9!R,4!R-R.]i44tR/R0ltR=R1R2lltR3R4ltR5R6ltR>R7R8lltR9R:ltR;R<ltR#)?) annotations)Callable Collection GeneratorHashableIterableSequence)wraps) zip_longest getsizeof) TYPE_CHECKINGAnyLiteralSelfcastN) get_option)algosindexlib) duplicated) AnyAll AnyArrayLikeAxisDropKeepDtypeObjF IgnoreRaise IndexLabelIndexT NaPositionScalarShapenpt)function)InvalidIndexErrorPerformanceWarningUnsortedIndexError)cache_readonly set_module)find_stack_level)coerce_indexer_dtypemaybe_unbox_numpy_scalar) ensure_int64ensure_platform_int is_hashable is_integer is_iterator is_list_likeis_object_dtype is_scalaris_string_dtype pandas_dtype)CategoricalDtypeExtensionDtype) ABCDataFrame ABCSeries) is_array_like)array_equivalentisna)validate_putmask) CategoricalExtensionArray)factorize_from_iterablesrecode_for_categories)sanitize_array)Index ensure_indexget_unanimous_names) FrozenList)make_invalid_op)get_group_indexlexsort_indexer) pprint_thing)CategoricalIndex DataFrameSeriesc6]tRt^}tRt]P tRtRt R#)MultiIndexUInt64EnginezManages a MultiIndex by mapping label combinations to positive integers. The number of possible label combinations must not overflow the 64 bits integers. uint64N) __name__ __module__ __qualname____firstlineno____doc__libindex UInt64Engine_base _codes_dtype__static_attributes__rSi/Users/max/.openclaw/workspace/postharvest/venv/lib/python3.14/site-packages/pandas/core/indexes/multi.pyrQrQ}  ! !ELr^rQc6]tRt^tRt]P tRtRt R#)MultiIndexUInt32EnginezManages a MultiIndex by mapping label combinations to positive integers. The number of possible label combinations must not overflow the 32 bits integers. uint32rSN) rTrUrVrWrXrY UInt32Enginer[r\r]rSr^r_rbrbr`r^rbc6]tRt^tRt]P tRtRt R#)MultiIndexUInt16EnginezManages a MultiIndex by mapping label combinations to positive integers. The number of possible label combinations must not overflow the 16 bits integers. uint16rSN) rTrUrVrWrXrY UInt16Enginer[r\r]rSr^r_rfrfr`r^rfc6]tRt^tRt]P tRtRt R#)MultiIndexUInt8EnginezManages a MultiIndex by mapping label combinations to positive integers. The number of possible label combinations must not overflow the 8 bits integers. uint8rSN) rTrUrVrWrXrY UInt8Enginer[r\r]rSr^r_rjrjs  ELr^rjc6]tRt^tRt]P tRtRt R#)MultiIndexPyIntEnginezManages a MultiIndex by mapping label combinations to positive integers. 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. objectrSN) rTrUrVrWrXrY ObjectEnginer[r\r]rSr^r_rnrns  ! !ELr^rnc V^8dQhRRRR/#)methrreturnrS)formats"r_ __annotate__rvsqQr^cLa\S4V3Rl4p\\V4#)zz A decorator to allow either `name` or `names` keyword but not both. This makes it easier to share code with base class. c<RV9dRV9d \R4hRV9dVPR4VR&S!V.VO5/VB#)namenamesz*Can only provide one of `names` and `name`) TypeErrorpop) self_or_clsargskwargsrss&*,r_new_methnames_compat..new_methsM V 6 1HI I V $jj0F7OK1$1&11r^)r rr)rsrsf r_ names_compatrs* 4[22 8 r^pandasca]tRt^t$Rt]P ]!4,tRt.t R] R&] !4t ] !4t R.tR] R&RR R lltR RltRRRllt]R]P(3RRll4t]]RRRll44t]R]P(3RRll4t]RRRll4t]RRl4t]RRl4t]R4t]RRl4tR R!lt ]R"R#l4t!]R$R%l4t"R&RR'R R(R R)R /R*R+llt#R&RR)R /R,R-llt$]R.R/l4t%]R0R1l4t&]R2R3l4t'R&RR'R R(R R)R /R4R5llt(R&RR)R /R6R7llt)]R84t*]R9R:l4t+]P(3R;R<llt,R=R>lt-RR?R@llt.RRARBllt/RRCRDllt0RERFlt1]RGRHl4t2]RIRJl4t3RRKRLllt4]RMRNl4t5RRORPllt6RQt7RRRS/RTRUllt8RVR/RWRXllt9RYRZlt:R&R/R[R\llt;]!];]:R]R^7t<]R_R`l4t=RaRblt>]RcRdl4t?]ReRfl4t@RRgRhlltA]AtBRitCRRjRklltDRRlRmlltERnRoltFRRpltGR ]P(R 3RqRrlltHRsRtltIRuRvltJ]RwRxl4tKRRyRzlltLR{R|ltMR}tNR~tORRltPRRRlltQRtRRR/RRlltSRRRlltTRRRlltURRRlltVRRRlltWRRltXRRltYRRltZRRlt[RRRllt\RRlt]RRlt^RRlt_]RRl4t`RV3RlltaRV3RlltbRRltcRRltdRRV3RlllteRRRlltfRRltgRthRRRlltiRRRlltjRRRlltkRRltlRRltmRRRlltnRRltoRRltpRV3RlltqRRltrRRltsRttRRltuRRltvRtwERRRlltxRtyRRltzRRlt{RRlt|RRRllt}]Pt]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4t]!R4tRtV;t#( MultiIndexa( 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. name : Label Kept for compatibility with 1-dimensional Index. Should not be used. 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]_namesrz int | None sortorderNFTc$V^8dQhRRRRRR/#)rrcopyboolverify_integrityrtrrS)rus"r_rvMultiIndex.__annotate__)s*,,  ,, ,r^c 4VeTpVeVf \R4h\V4\V48wd \R4h\V4^8Xd \R4h\P V4p/VnVP WRR7VPW%RR7R.\V4,VnVeVPV4Ve\V4Vn MW8n V'dVP4p Wn VP4RVnV#)NzMust pass both levels and codesz,Length of levels and codes must be the same.z)Must pass non-zero number of levels/codesF)rvalidate)r{len ValueErrorro__new___cache _set_levels _set_codesr _set_namesintr_verify_integrity_codes_reset_identity _references) clslevelscodesrrzrryrresult new_codess &&&&&&&& r_rMultiIndex.__new__)s  E >U]=> > v;#e* $KL L v;! HI I$  6u=%U;V,     e $  "9~F (  002I%M ! r^c$V^8dQhRRRRRR/#)rrlevelrEcode np.ndarrayrtrS)rus"r_rvrWs!U*r^c \V4p\P!V4'd\P!W2,RV4pV#)a; Reassign code values as -1 if their corresponding levels are NaN. Parameters ---------- code : Index Code to reassign. level : np.ndarray 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>npanywhere)selfrr null_masks&&& r__validate_codesMultiIndex._validate_codesWs5 K 66)  88IOR6D r^c(V^8dQhRRRRRRRR/#)rrrz list | Nonerlevels_to_verifyzlist[int] | range | NonertrHrS)rus"r_rvrls8LLLL3 L  Lr^c  T;'g VPpT;'g VPpVf\\V44p\V4\V48wd \ R4h\V^,4pVEFpW%,pW,p\V4V8wd(\ RVUu.uFp\V4NK up 24h\V4'dKVP 4\V48d-\ RV RVP 4 R\V4 R24h\V4'd6VP 4R 8d!\ RV RVP 4 R24hVP'dEK\ R \V4 R V 24h VPeiVP\VPVP48d:\ R VP R \VPVP4 24h.p \\V44FOpWS9d0V PVPW%,W,44K8V PW,4KQ \V 4p V #uupi)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.zUnequal code lengths: z On level z , code max (z) >= length of level (z/). NOTE: this index is in an inconsistent statez, 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)rrrangerrmaxmin is_uniquelistr_lexsort_depthnlevelsappendrrH) rrrr codes_lengthir level_codescode_ result_codesrs &&&& r_rMultiIndex._verify_integritylsI:##&&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- $ |, =.Ms+J c$V^8dQhRRRRRR/#)rrrrrz-Sequence[Hashable] | Hashable | lib.NoDefaultrtrrS)rus"r_rvrs/D D D = D  D r^c Rp\V4'g \V4h\V4'd \V4pVFp\V4'dK\V4h \ ^\ V44F:p\ W,4\ W^, ,48wgK1\ R4h \V4wrxV\PJdVU u.uFp \V RR4NK pp V!VVVVRR7#uup i)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.zall arrays must be same lengthryNFrrrrzr) r3r{r2rrrrrBr no_defaultgetattr) rarraysrrz error_msgarrayrrrarrs &&&& r_ from_arraysMultiIndex.from_arrayssTF F##I& & v  &\FE&& ** q#f+&A69~VE]!33 !ABB'18  CNN ";AB6CWS&$/6EB"   CsC=c(V^8dQhRRRRRRRR/#) rrtupleszIterable[tuple[Hashable, ...]]rrrz$Sequence[Hashable] | Hashable | NonertrrS)rus"r_rvrs>LILI.LILI4 LI  LIr^c \V4'g \R4h\V4'd \V4p\ \ \ \R3,,V4p\V4'd\;QJdRV4F 'dK RM RM !RV44'dd\P!\V44.p\\P!V\P!R4R74.pV!VVVVRR7#\V4^8Xd%Vf \R 4h..\V4,pEM\!V\P"\34'da\!V\4'd!\P$!VP&4p\\(P*!V4P,4pM\!V\4'd+\\(P.!V4P,4pM?\1VR \P2/p\ \\4\,,V4pVP7WbVR 7#) 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`"TF$p\V\4;'dV'*xK& R#5iN) isinstancetuple).0es& r_ )MultiIndex.from_tuples..2s$Nv!z!U3==A=vs..FTrodtyperz-Cannot infer number of levels from empty list fillvaluerrz)r3r{r2rrrrrrallrzerosrEcomasarray_tuplesaferrndarrayasarray_valuesrtuples_to_object_arrayTto_object_array_tuplesr nanr r)rrrrzrrrarrss&&&& r_ from_tuplesMultiIndex.from_tuplessTF##MN N v  &\Fjx}!56? v;;33NvN333NvNNNXXc&k*+EC11&@RSTUF#!&   v;! } OPPTCJ&F U 3 4 4&%((FNN3#44V<>>?F  % %#44V<>>?F9"&&9D$x12D9Fv%HHr^c(V^8dQhRRRRRRRR/#) rr iterableszSequence[Iterable[Hashable]]rrrzrrtrrS)rus"r_rvrRs88D8D/8D8D= 8D  8Dr^c \V4'g \R4h\V4'd \V4p\ V4wrEV\ P JdVUu.uFp\VRR4NK pp\V4pV!WTW#R7#uupi)aE Make a MultiIndex from the cartesian product of multiple iterables. Parameters ---------- iterables : list / sequence of iterables Each iterable has unique labels for each level of the index. 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. If not explicitly provided, names will be inferred from the elements of iterables if an element has a name attribute. Returns ------- MultiIndex See Also -------- MultiIndex.from_arrays : Convert list of arrays to MultiIndex. MultiIndex.from_tuples : Convert list of tuples to MultiIndex. MultiIndex.from_frame : Make a MultiIndex from a DataFrame. Examples -------- >>> 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']) z-Input must be a list / sequence of iterables.ryNr) r3r{r2rrBrrrcartesian_product)rrrrzrrits&&&& r_ from_productMultiIndex.from_productQs\I&&KL L y ! !YI0;  CNN "9BC2WR.EC"%(6ICC DsB c(V^8dQhRRRRRRRR/#) rrdfrNrrrzrrtrrS)rus"r_rvrs>CJCJ CJCJ4 CJ  CJr^c \V\4'g \R4h\VP 4RR/wrEVfTMTpVP WRVR7#)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 DataFramestrictTr)rr:r{zipitemsr)rrrrz column_namescolumnss&&&& r_ from_frameMultiIndex.from_framesT~"l++78 8 #RXXZ = = % 5w5IIr^cV^8dQhRR/#rrrtrrS)rus"r_rvrsr^c .p\VP4EFpVPV,pVPV,pTp\ VP \ 4'd'\RV4pVPP4p\ VP \4'g(\P!VP R4'dVP\4p\P !V4p\"P$!WdVP&R7pVP)V4EK \P*!V4pV#)rMmM fill_value)rrrrrrr8r_data_internal_get_valuesr9r is_np_dtypeastyperorrrtake_nd _na_valuerfast_zip)rvaluesrrrvals array_valsrs& r_rMultiIndex._valuesst||$AKKNEJJqMED$**&677.5zz668$**n55 D::{{6*D)JzU__UJ MM* %!%$ll6" r^cV^8dQhRR/#rrS)rus"r_rvrs r^c VP#rrrs&r_r MultiIndex.valuess ||r^c \R4h)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  r^cV^8dQhRR/#)rrrtrOrS)rus"r_rvrsRRRr^c ^RIHp\P!VP4pT!VP Uu.uFq3P NK up\V4R7#uupi)aa Return the dtypes as a Series for the underlying MultiIndex. See Also -------- Index.dtype : Return the dtype object of the underlying data. Series.dtypes : Return the data type of the underlying Series. 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 )rO)r)rrOrfill_missing_namesrzrrrE)rrOrzrs& r_dtypesMultiIndex.dtypessD8 "&&tzz2 < u{{ >> 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']]) Trry)r_levelsr_rename_no_setting_namerH)rxryrrs& r_rMultiIndex.levels0si|t||T[[F F II4I F  E%)E "&!! sA!rrrrc(V^8dQhRRRRRRRR/#rrrrrrrtNonerS)rus"r_rvrus4++  +  ++ +r^c aV'dm\V4^8Xd \R4hVf&\V4VP8wd \R4hVe%\V4\V48wd \R4hVf+\V3RlV44p\ \V44pMrVUu.uFqP V4NK pp\ VP4p \WqRR7F"wr\VSR7P4W&K$ \V 4pV'dVPWgR 7p Wn VPp W`n\V 4'dVPV 4VP!4R#uupi) rz#Must set non-zero number of levels.Nz-Length of levels must match number of levels.z,Length of levels must match length of level.c3Z<"TF p\VSR7P4xK" R#5irN)rF_view)rlevrs& r_r)MultiIndex._set_levels..s'$@F St,2244s(+Tr'r4)rr)rrrrHr_get_level_numberrr)rrFr5rrrzrr _reset_cache) rrrrrr new_levels level_numbersr6new_levels_listlev_numrrzs &&$d$$ r_rMultiIndex._set_levelsusE 6{a !FGG}V !< !PQQ S[CJ%> !OPP =#$@F$J05S_/EMDIJES33C8EMJ"4<<0O #M$ G +7$+G+M+M+O(!H#O4J ..!/I$K ! u:: OOE " #Ks(E<c V^8dQhRRRR/#rrrrrtrrS)rus"r_rvrs uu7;u ur^c *\V\4'dM9\V4'd \V4pM\V4'd \ V4p\ W!R4wr!VP 4pVP4VPWRVR7V#)a Set new levels on MultiIndex. Defaults to returning new index. The `set_levels` method provides a flexible way to change the levels of a `MultiIndex`. This is particularly useful when you need to update the index structure of your DataFrame without altering the data. The method returns a new `MultiIndex` unless the operation is performed in-place, ensuring that the original index remains unchanged unless explicitly modified. The method checks the integrity of the new levels against the existing codes by default, but this can be disabled if you are confident that your levels are consistent with the underlying data. This can be useful when you want to perform optimizations or make specific adjustments to the index levels that do not strictly adhere to the original structure. 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 A new `MultiIndex` with the updated levels. See Also -------- MultiIndex.set_codes : Set new codes on the existing `MultiIndex`. MultiIndex.remove_unused_levels : Create new MultiIndex from current that removes unused levels. Index.set_names : Set Index or MultiIndex name. 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) rrEr<r3r_require_listliker5rr)rrrridxs&&$$ r_ set_levelsMultiIndex.set_levelssP fe $ $  6 " "6]F & ! !&\F)%B jjl   $AQ   r^cV^8dQhRR/#rrS)rus"r_rvrs!!!r^c ,\VP4#)a Integer number of levels in this MultiIndex. See Also -------- MultiIndex.levels : Get the levels of the MultiIndex. MultiIndex.codes : Get the codes of the MultiIndex. MultiIndex.from_arrays : Convert arrays to MultiIndex. MultiIndex.from_tuples : Convert list of tuples to MultiIndex. Examples -------- >>> mi = pd.MultiIndex.from_arrays([["a"], ["b"], ["c"]]) >>> mi MultiIndex([('a', 'b', 'c')], ) >>> mi.nlevels 3 )rr)rs&r_rMultiIndex.nlevelss*4<<  r^cV^8dQhRR/#)rrrtr#rS)rus"r_rvr1s22%2r^c \;QJd.RVP4FNK 5#!RVP44#)a  A tuple representing the length of each level in the MultiIndex. In a `MultiIndex`, each level can contain multiple unique values. The `levshape` property provides a quick way to assess the size of each level by returning a tuple where each entry represents the number of unique values in that specific level. This is particularly useful in scenarios where you need to understand the structure and distribution of your index levels, such as when working with multidimensional data. See Also -------- MultiIndex.shape : Return a tuple of the shape of the MultiIndex. MultiIndex.levels : Returns the levels of the MultiIndex. Examples -------- >>> mi = pd.MultiIndex.from_arrays([["a"], ["b"], ["c"]]) >>> mi MultiIndex([('a', 'b', 'c')], ) >>> mi.levshape (1, 1, 1) c38"TFp\V4xK R#5irr!rr,s& r_r&MultiIndex.levshape..Js1[SVV[)rrrs&r_levshapeMultiIndex.levshape0s.4u1T[[1u1u1T[[111r^cV^8dQhRR/#r%rS)rus"r_rvrPszr^c VP#)a Codes of the MultiIndex. Codes are the position of the index value in the list of level values for each level. Returns ------- tuple of numpy.ndarray The codes of the MultiIndex. Each array in the tuple corresponds to a level in the MultiIndex. See Also -------- MultiIndex.set_codes : Set new codes on MultiIndex. Examples -------- >>> arrays = [[1, 1, 2, 2], ["red", "blue", "red", "blue"]] >>> mi = pd.MultiIndex.from_arrays(arrays, names=("number", "color")) >>> mi.codes FrozenList([[0, 0, 1, 1], [1, 0, 1, 0]]) )rrs&r_rMultiIndex.codesOs2{{r^c(V^8dQhRRRRRRRR/#r/rS)rus"r_rvrjs4''  '  '' 'r^c  aV'dRVf&\V4VP8wd \R4hVe%\V4\V48wd \R4hVfA\V3Rl\ VP VRR744p\ \V44pMwVUu.uFqPV4NK pp\VP4p \ WqRR7F'wrVPV ,p\WSR7W&K) \V 4pV'dVPWgR7pW`n VP4R#uupi)Nz+Length of codes must match number of levelsz,Length of codes must match length of levels.c3^<"TF"wr\W!SR7P4xK$ R#5ir3)_coerce_indexer_frozenview)rr6rrs& r_r(MultiIndex._set_codes..{s.#(M$C'{dCHHJJ(Ms*-Tr'r4)rr)rrrrHrr)rr8rrrrXrr9) rrrrrrrr;r6new_codes_listr=rs &&$d$$ r_rMultiIndex._set_codesjs$ }Ut||!; !NOO SZ3u:%= !OPP ="#(+DLL%(M#I"#i.1MDIJES33C8EMJ!$++.N(+M(N$kk'**@4+')O #>2I ../I  !Ks#Ec V^8dQhRRRR/#r@rS)rus"r_rvrs DD6:D Dr^c \W!R4wr!VP4pVP4VPWVR7V#)ai 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``. See Also -------- MultiIndex.set_levels : Set new levels on MultiIndex. MultiIndex.codes : Get the codes of the levels in the MultiIndex. MultiIndex.levels : Get the levels of the MultiIndex. 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']) Codes)rr)rCr5rr)rrrrrDs&&$$ r_ set_codesMultiIndex.set_codess@@)w? jjl  u>> mi = pd.MultiIndex.from_arrays([["a"], ["b"], ["c"]]) >>> mi MultiIndex([('a', 'b', 'c')], ) >>> mi.copy() MultiIndex([('a', 'b', 'c')], ) )ryrzr~N)deepcopyFrr) _validate_namesrrrrrrrrr9_id) rrzr~rykeep_idrrr new_indexs &&&& r_rMultiIndex.copy*sn$$$$$G(d  %dkk*FTZZ(E!-4;;* Jnn"   ;;++- x(  HHIMr^cV^8dQhRR/#rrS)rus"r_rvr{s  * r^c VRJd \R4hVRJd#\P!VPVR7#VP#)z%the array interface, return my valuesFz:Unable to avoid copy while creating an array as requested.Tr)rrrr )rrrs&&&r_ __array__MultiIndex.__array__{sC 5=L  4<88DKKu5 5{{r^cV^8dQhRR/#)rrrtrrS)rus"r_rvrsr^c HVP4pVPVnV#)z0this is defined as a copy with the same identity)rr)rrrs&& r_rYMultiIndex.viewsXX  r^c V^8dQhRRRR/#)rrkeyrrtrrS)rus"r_rvrs))))r^c z\V4VPV4R# \\\3dR#i;i)a> Return a boolean indicating whether the provided key is in the index. Parameters ---------- key : label The key to check if it is present in the index. Returns ------- bool Whether the key search is in the index. Raises ------ TypeError If the key is not hashable. See Also -------- Index.isin : Returns an ndarray of boolean dtype indicating whether the list-like key is in the index. Examples -------- >>> mi = pd.MultiIndex.from_arrays([["a"], ["b"], ["c"]]) >>> mi MultiIndex([('a', 'b', 'c')], ) >>> "a" in mi True >>> "x" in mi False TF)hashget_loc LookupErrorr{rrrs&&r_ __contains__MultiIndex.__contains__s9H S   LL Y 3  s  ::cV^8dQhRR/#)rrrtznp.dtyperS)rus"r_rvrsxr^c .\P!R4#)O)rrrs&r_rMultiIndex.dtypesxx}r^cV^8dQhRR/#rrrtrrS)rus"r_rvrs<.__annotate__s   r^cl\V4;'g#\V4;'dVPR8H#)python)r4r6storagers&r_f0MultiIndex._is_memory_usage_qualified..fs2"5)&DD5==H+D r^c3H<"TFpS!VP4xK R#5irr)rrrs& r_r8MultiIndex._is_memory_usage_qualified..s;{e1U[[>>{s"TF)rr)rrs&@r__is_memory_usage_qualified%MultiIndex._is_memory_usage_qualifieds;  s;t{{;ss;s;s;t{{;;;r^c V^8dQhRRRR/#rrr~rrtrrS)rus"r_rvrs""""""#""r^c $VPV4#)ab Memory usage of the values. Parameters ---------- deep : bool, default False Introspect the data deeply, interrogate `object` dtypes for system-level memory consumption. Returns ------- bytes used Returns memory usage of the values in the Index in bytes. See Also -------- numpy.ndarray.nbytes : Total bytes consumed by the elements of the array. Notes ----- Memory usage does not include memory consumed by elements that are not components of the array if deep=False or if used on PyPy Examples -------- >>> mi = pd.MultiIndex.from_arrays([["a"], ["b"], ["c"]]) >>> mi.memory_usage() 81 _nbytes)rr~s&&r_ memory_usageMultiIndex.memory_usagesD||D!!r^cV^8dQhRR/#rrS)rus"r_rvrs###r^c $VPR4#)z1return the number of bytes in the underlying dataFrrs&r_nbytesMultiIndex.nbytess||E""r^c V^8dQhRRRR/#rrS)rus"r_rvrsDSr^c Faa^o\V3RlVP44p\RVP44p\V3RlVP44pW#,V,pRVP9d#WPP P SR7, pV#)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* c3F<"TFqPSR7xK R#5i)r~N)r)rrr~s& r_r%MultiIndex._nbytes..sJk>>t>44k!c38"TFqPxK R#5ir)r)rrs& r_rrs8Z88ZrOc3<<"TFp\VS4xK R#5irr )rrobjsizes& r_rrsE*Q9Q00*srnr)sumrrrzrrnsizeof)rr~ level_nbytes label_nbytes names_nbytesrrs&f @r_rMultiIndex._nbytessJdkkJJ 8TZZ88 E$**EE ,|;  # ll))t)4 4F r^c  RVP4p\;QJd.R\W!RR74FNK 5#!R\W!RR744#)zG Formats each item in tup according to its level's formatter function. c38"TFqPxK R#5ir)_formatter_funcrrs& r_r-MultiIndex._formatter_func..sJkU00krOc36"TFwrV!V4xK R#5irrS)rfuncvals& r_rrsW0V94T#YY0VsTr')rrr)rtupformatter_funcss&& r_rMultiIndex._formatter_func sEKdkkJuWOQU0VWuWuWOQU0VWWWr^na_reprc V^8dQhRRRR/#)rrrstrrtznpt.NDArray[np.object_]rS)rus"r_rvrs$$$ $r^c .p.p\VPVPRR7FwrVVP!RRV/VBpVR8HpVP 4'di\ V4p VP \4p\P!Wq4pVPP'dQhVP4pWV&VPV4VPV4K \ V4^8Xd9\V^,PV^,4RR7P4#\VVVP VP"RR7p V P$#)Tr'rFr4rrrzrrrSr)rrr_get_values_for_csvrrrrrrflags writeablerrEtakerrzrr) rrrr:rrr level_strsmask nan_indexmis &$, r_rMultiIndex._get_values_for_csvs8  #&dkk4::d"K E22K&KFKJ"$Dxxzz O '..s3 YYz: &,,66666)..0 $-D!   j )   [ )#L z?a 1 ""9Q<0u!!# $ !jj..!& B:: r^ formatterc(V^8dQhRRRRRRRR/#) rr include_namesrsparsifyzbool | None | lib.NoDefaultrzCallable | NonertrrS)rus"r_rvr9s4===. = # =  =r^c  p\V4^8Xd.#.p\VPVPRR7FwrV\ VP 4p\V4^8drVP V4;rVPRVR7p VR 8Hp V P4'd1\P!V \R7p WyV &V P4p MN\P!VPV4U u.uF#p \!\#V 4'dTMT R R7NK% p p VP%V 4K .p \W@P&RR7Fmwr].pV'd#TP%V e\!V R R7MR4VP)\P!V\R74V P%V4Ko Vf \+R4pV'd\Rp\-V\.4'gV\0P2JgQhV\0P2JdTp\5V \7V4VR 7p V #uup i) rTr'F) include_namerr) escape_charszdisplay.multi_sparse)startsentinelr)   )rrrr _get_na_reprr _format_flatrrrrotolistrrrrLr>rrzextendrrrrrsparsify_labelsr)rrrrstringified_levelsr6rnataken formattedrr, result_levelslev_namerrs&$$$ r_ _format_multiMultiIndex._format_multi9s t9>I #DKKD I CSYY'B3x!|$'HH[$99!..EY.W #b(88:: "& AI&(dO ) 0 0 2I #]]3;; DD!tAwwADVWD  % %i 0)!J,  !3ZZMMCE +!8JK LL#V4 5   'N  !"89H ;=Hh--S^^1K KK3>>)#+S%7(MEs5)H3cV^8dQhRR/#r%rS)rus"r_rvr{s''J'r^c ,\VP4#r)rHrrs&r_ _get_namesMultiIndex._get_names{s$++&&r^cV^8dQhRR/#rrrtr0rS)rus"r_rvr~s6$6$$6$r^c $aVe\V4'g \R4h\V4pVe%\V4\V48wd \R4hVf&\V4SP8wd \R4hVf\ SP4pM V3RlV4p\ W!RR7FJwr4Ve3\V4'g"\\S4P R24hVSPV&KL SPR 4R#) 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 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.c3F<"TFpSPV4xK R#5ir)r8)rr6rs& r_r(MultiIndex._set_names..sBEST++C00ErTr'z.name must be a hashable typer) r3rrrrrrr0r{rrrTrr9)rrzrr6rysf&$ r_rMultiIndex._set_names~s2  \%%8%8IJ JU   Us5z!9JK K =SZ4<<7L  =$,,'EBEBEU$7IC#4((#:..//LM $DKK 8 (#r^a Names of levels in MultiIndex. This attribute provides access to the names of the levels in a `MultiIndex`. The names are stored as a `FrozenList`, which is an immutable list-like container. Each name corresponds to a level in the `MultiIndex`, and can be used to identify or manipulate the levels individually. See Also -------- MultiIndex.set_names : Set Index or MultiIndex name. MultiIndex.rename : Rename specific levels in a MultiIndex. Index.names : Get names on index. Examples -------- >>> 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']) )fsetfgetdoccV^8dQhRR/#)rrrtrrS)rus"r_rvrssr^c R#)mixedrSrs&r_ inferred_typeMultiIndex.inferred_typesr^cV^8dQhRR/#rrS)rus"r_rvrs#r^c FVPPV4pV^8d!\V4'g\RV R24hVPP V4pV# \dp\T4'g\ RT R24ThT^8dOYP , pT^8d0YP , p\RTP RT R24ThR p?T#YP 8d$\RTP RT^, 24ThR p?T#R p?ii;i) rdz The name z* occurs multiple times, use a level numberzLevel z not foundz Too many levels: Index has only z levels, z is not a valid level numberz levels, not N)rzcountr1rrKeyErrorr IndexError)rrr err orig_levels&& r_r8MultiIndex._get_level_numbers<   ' AIz%00E7"LM  JJ$$U+E$ # e$$wj9:Cqy%19!&!5J$:4<<. %,&BD ,,& 6t||nE 19+''  # sA!! D ,A0D"3DD cV^8dQhRR/#rrS)rus"r_rvrsKKKr^c  .\;QJd&RVP4F 'gK RM RM!RVP44'dR#\;QJd&RVP4F 'dK RM RM!RVP44'dA\P !VPUu.uFqP RRR7NK up4#\\\VP444Uu.uFq PV4PNK pp\P!V4p\VRR7P#uupiuupi \ d%\TPRR7Pu#i;i)z9 Return a boolean if the values are equal or increasing. c3,"TF pRV9xK R#5i)rdNrrS)rrs& r_r5MultiIndex.is_monotonic_increasing..s1jdrTzjsTFc38"TFqPxK R#5iris_monotonic_increasingrs& r_rrsF+,,+rOint64r4)rrrrlibalgos is_lexsortedrreversedrr_get_level_valuesrrlexsortrErr{)rr,rr  sort_orders& r_r"MultiIndex.is_monotonic_increasings- 31djj13331djj1 1 1 3F$++F333F$++F F F((8< C 1'. C  8@c$++FV@W7X 7X! " "1 % - -7X   KF+J%0HH HD  KE2JJ J Ks=E#E .,E%%,FFcV^8dQhRR/#rrS)rus"r_rvrs222r^c .VRRR1,P#)z9 Return a boolean if the values are equal or decreasing. Nrrrs&r_is_monotonic_decreasing"MultiIndex.is_monotonic_decreasings DbDz111r^c V^8dQhRRRR/#)rrkeeprrtnpt.NDArray[np.bool_]rS)rus"r_rvrs:%:%x:%6K:%r^c \;QJd.RVP4FNK 5M!RVP44p\VPVRRR7p\ W14#)a Indicate duplicate index values. Duplicated values are indicated as ``True`` values in the resulting array. Either all duplicates, all except the first, or all except the last occurrence of duplicates can be indicated. Parameters ---------- keep : {'first', 'last', False}, default 'first' The value or values in a set of duplicates to mark as missing. - 'first' : Mark duplicates as ``True`` except for the first occurrence. - 'last' : Mark duplicates as ``True`` except for the last occurrence. - ``False`` : Mark all duplicates as ``True``. Returns ------- np.ndarray[bool] A numpy array of boolean values indicating duplicate index values. See Also -------- Series.duplicated : Equivalent method on pandas.Series. DataFrame.duplicated : Equivalent method on pandas.DataFrame. Index.drop_duplicates : Remove duplicate values from Index. Examples -------- By default, for each set of duplicated values, the first occurrence is set to False and all others to True: >>> mi = pd.MultiIndex.from_arrays((list("abca"), list("defd"))) >>> mi.duplicated() array([False, False, False, True]) which is equivalent to >>> mi.duplicated(keep="first") array([False, False, False, True]) By using 'last', the last occurrence of each set of duplicated values is set on False and all others on True: >>> mi.duplicated(keep="last") array([ True, False, False, False]) By setting keep on ``False``, all duplicates are True: >>> mi.duplicated(keep=False) array([ True, False, False, True]) c38"TFp\V4xK R#5irr!)rr6s& r_r(MultiIndex.duplicated..Ts6+3c#hh+rOF)sortxnull)rrrJrr)rr#shapeidss&& r_rMultiIndex.duplicatedsJn6$++66$++66djj%e5I#$$r^c \R4h)z* fillna is not implemented for MultiIndex z$fillna is not defined for MultiIndex)NotImplementedError)rvalues&&r_fillnaMultiIndex.fillna]s""HIIr^c V^8dQhRRRR/#)rrhowrrtrrS)rus"r_rvrcs'/'/&'/Z'/r^c TVPUu.uFq"R8HNK ppVR8Xd\P!V^R7pM.VR8Xd\P!V^R7pM\ RV 24hVPUu.uF q"V(,NK ppVP VR7#uupiuupi)aQ Return MultiIndex without NA/NaN values. Parameters ---------- how : {'any', 'all'}, default 'any' Drop the value when any or all levels are NaN. Returns ------- Index Returns an MultiIndex object after removing NA/NaN values. See Also -------- Index.fillna : Fill NA/NaN values with the specified value. Index.isna : Detect missing values. Examples -------- >>> mi = pd.MultiIndex.from_arrays(([np.nan, np.nan, 2.0], [3.0, np.nan, 4.0])) >>> mi.dropna() MultiIndex([(2.0, 4.0)], ) >>> mi.dropna(how="all") MultiIndex([(nan, 3.0), (2.0, 4.0)], ) r)axisrzinvalid how option: )rr)rrrrrr`)rr3rnansindexerrs&& r_dropnaMultiIndex.dropnacs<6:ZZ@Zkr!Z@ %<ffT*G E\ffT*G3C59: :>BjjIj{'**j I~~I~..AJs B :B%c$V^8dQhRRRRRR/#)rrrruniquerrtrErS)rus"r_rvrs!44s4D4U4r^c ,VPV,pVPV,pVPV,pV'd\P!V4p\P !VP WCPR7pVPWeR7#)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() rrrrr;rrrrw)rrr;r6rryfilleds&&& r_rMultiIndex._get_level_valuessk"kk% jj' {{5! ,,{3Ks{{KMMR   33r^cV^8dQhRR/#rrrtrErS)rus"r_rvrsCCCr^c JVPV4pVPV4pV#)a Return vector of label values for requested level. Length of returned vector is equal to the length of the index. The `get_level_values` method is a crucial utility for extracting specific level values from a `MultiIndex`. This function is particularly useful when working with multi-level data, allowing you to isolate and manipulate individual levels without having to deal with the complexity of the entire `MultiIndex` structure. It seamlessly handles both integer and string-based level access, providing flexibility in how you can interact with the data. Additionally, this method ensures that the returned `Index` maintains the integrity of the original data, even when missing values are present, by appropriately casting the result to a suitable data type. 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). See Also -------- MultiIndex : A multi-level, or hierarchical, index object for pandas objects. Index : Immutable sequence used for indexing and alignment. MultiIndex.remove_unused_levels : Create new MultiIndex from current that removes unused levels. 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='str', name='level_1') >>> mi.get_level_values("level_2") Index(['d', 'e', 'f'], dtype='str', 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') )r8r)rrr s&& r_get_level_valuesMultiIndex.get_level_valuess*B&&u-''. r^c rVfVP4#VPV4pVPVRR7#)a Return unique values in the index. Unique values are returned in order of appearance, this does NOT sort. Parameters ---------- level : int or hashable, optional Only return values from specified level (for MultiIndex). If int, gets the level by integer position, else by level name. Returns ------- MultiIndex Unique values in the MultiIndex. See Also -------- unique : Numpy array of unique values in that column. Series.unique : Return unique values of Series object. Examples -------- >>> mi = pd.MultiIndex.from_arrays((list("abca"), list("defd"))) >>> mi MultiIndex([('a', 'd'), ('b', 'e'), ('c', 'f'), ('a', 'd')], ) >>> mi.unique() MultiIndex([('a', 'd'), ('b', 'e'), ('c', 'f')], ) T)rr;)drop_duplicatesr8r)rrs&&r_r;MultiIndex.uniques?J ='') )**51E))d)C Cr^c$V^8dQhRRRRRR/#)rrrrallow_duplicatesrtrNrS)rus"r_rvrs-WWW W  Wr^c  ^RIHpV\PJdN\ V4'g \ R4h\ V4\ VP48wd \R4hTpMVP4pV'g.\ \V44\ V48wd \R4hT!\\ VP44Uu/uFqfVPV4bK upRR7pWWn V'dWnV#uupi)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. Returns ------- DataFrame DataFrame representation of the MultiIndex, with levels as columns. 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 )rNz1'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 FalseFr4)rrNrrr3r{rrr_get_level_namessetrrrr)rrryrHrN idx_namesrrs&&&& r_to_frameMultiIndex.to_framesv % s~~ %%% STT4yC ,, RI--/ICI$73y>$IT  ?DSEU?V W?VeD**51 1?V W # L  XsDcV^8dQhRR/#r@rS)rus"r_rvrpsDDuDr^c 2\VPRRR7#)aQ 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_colsr)rErrs&r_ to_flat_indexMultiIndex.to_flat_indexps8T\\UCCr^cV^8dQhRR/#rrS)rus"r_rvrs&3&3t&3r^c 4VPVP8H#)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_lexsortedsL""dll22r^cV^8dQhRR/#rrS)rus"r_rvrs 8 8 8r^c vVPe VP#\VPVP4#)z} Compute and return the lexsort_depth, the number of levels of the MultiIndex that are sorted lexically Returns ------- int )rrrrrs&r_rMultiIndex._lexsort_depths- >> %>> !djj$,,77r^c V^8dQhRRRR/#)rrraise_if_incomparablerrtrrS)rus"r_rvrsB B DB ZB r^c bVP4'dVP'dV#.p.p\VPVPRR7FwrEVP'gfVP 4pVP V4p\V4p\P!V\V44p\P!WuRR7pVPV4VPV4K \VVVP VP"RR7# \d T'dhL`i;i)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')], ) Tr'rF)rzrrr)rVrrrrargsortrr/rget_reverse_indexerrrrr{rrrzr)rr\r:rr6rr7ris&& r__sort_levels_monotonic!MultiIndex._sort_levels_monotonics F     D$@$@$@K  #DKKD I C... P!kkmG ((7+C2':G00#g,GB"'--B"OK   c "   [ )#!J&  **nn"   !,-s)DD.*D.-D.cV^8dQhRR/#rzrS)rus"r_rvr s``j`r^c l.p.pRp\VPVPRR7EFwrE\P!\P !V^,4^84^,^, p\ \V4;'d V^,R8H4p\V4\V4V,8wEdVP4P4'd\V4\V48XdMRp\P!V4pV'd>\P!VR8H4^,pWh^,^.,V^V^,.&\P!\V4V,4p \P!\V44V, W&W,pVPWgR4pVPV4VPV4EK VP!4p V'd7V P#4V P%VRR7V P'VRR7V #)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. The `remove_unused_levels` method is useful in cases where you have a MultiIndex with hierarchical levels, but some of these levels are no longer needed due to filtering or subsetting operations. By removing the unused levels, the resulting MultiIndex becomes more compact and efficient, which can improve performance in subsequent operations. Returns ------- MultiIndex A new MultiIndex with unused levels removed. See Also -------- MultiIndex.droplevel : Remove specified levels from a MultiIndex. MultiIndex.reorder_levels : Rearrange levels of a MultiIndex. MultiIndex.set_levels : Set new levels on a 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']]) FTr'Nrr)rrrrrbincountrrr>rrr;rarangerrrYrrr) rr:rchangedr6runiqueshas_nana_idx code_mappingrs & r_remove_unused_levelsMultiIndex.remove_unused_levels s`   #DKKD I I Chhr{{;?;a?@CaGGW<<71:+;=F7|s3x&0088:>>##G C(@  ,,{3XXgm4Q7F.5ay!n.EGQq N+ "xxC6(9: (* #g,(?&(H %*7 hhww/0   c "   [ )G!JJ   " " $   zE  :   i%  8 r^c  R\VP4R\VP4RVPR\VP4/p\ P \V4V3R3#)z*Necessary for making this object picklablerrrrzN)rrrrrzibase _new_Indexrr)rds& r_ __reduce__MultiIndex.__reduce__m s[ d4;;' T$**%  T$**%   $t*a$66r^c \P!V4p\V4'd\P!V4p.p\ VP VPRR7FQwr4WA,R8Xd"VP\P4K3VPW4V,,4KS \V4#Rp\P!V4'd*\P!V\R7pVPpMn\!V\"4'd-VP$eVP$^8d VPpM,\!V\&4'd\P!V4pVPUu.uF qDV,NK pp\)VP VVP*VRR7#uupi)Tr'NrFrr)ritem_from_zerodimr5rcast_scalar_indexerrrrrrrris_bool_indexerrrrrslicesteprErrz)rrretvalr6rrrs&& r_ __getitem__MultiIndex.__getitem__y sH##C( S>>))#.CF$' TZZ$M #r)MM"&&)MM##&6"78 %N = I""3''jjD1 NN C''88#sxx!| $IC''jjo=AZZHZkS))ZIH{{jj#!&  IsF<c$V^8dQhRRRRRR/#)rrrrslobjryrtrS)rus"r_rvr s!  Z  * r^c RpVPeVP^8d VPpVPUu.uF q3V,NK pp\V4!VPVVP VRR7#uupi)z8 Fastpath for __getitem__ when we know we have a slice. NFr)rzrrrrrr)rrrrrs&& r__getitem_sliceMultiIndex._getitem_slice sr :: aI;?::F:K'': FDz;;++"   GsA9c(V^8dQhRRRRRRRR/#)rrrrr5r allow_fillrrtrS)rus"r_rvr s8V V V V  V  V r^c R\P!RV4\V4pVPW4V4pVP^8Xd7\ P !V\V44'dVP4#RpVPUu.uFqwPV4NK ppV'dTVR8Hp V P4'd9.p VF.p T p WlV &V P\P!V 44K0 T p\VP WP"RR7#uupi)a Return a new MultiIndex of the values selected by the indices. For internal compatibility with numpy arrays. Parameters ---------- indices : array-like Indices to be taken. axis : {0 or 'index'}, optional The axis over which to select values, always 0 or 'index'. allow_fill : bool, default True How to handle negative values in `indices`. * False: negative values in `indices` indicate positional indices from the right (the default). This is similar to :func:`numpy.take`. * True: negative values in `indices` indicate missing values. These values are set to `fill_value`. Any other other negative values raise a ``ValueError``. fill_value : scalar, default None If allow_fill=True and fill_value is not None, indices specified by -1 are regarded as NA. If Index doesn't hold NA, raise ValueError. **kwargs Required for compatibility with numpy. Returns ------- Index An index formed of elements at the given indices. Will be the same type as self, except for RangeIndex. See Also -------- numpy.ndarray.take: Return an array formed from the elements of a at the given indices. Examples -------- >>> idx = pd.MultiIndex.from_arrays([["a", "b", "c"], [1, 2, 3]]) >>> idx MultiIndex([('a', 1), ('b', 2), ('c', 3)], ) >>> idx.take([2, 2, 1, 0]) MultiIndex([('c', 3), ('c', 3), ('b', 2), ('a', 1)], ) FrrrzrrSr)nv validate_taker/_maybe_disallow_fillndimris_range_indexerrrrrrrrrrrrz) rindicesr5rrrna_valuelabrrmasked new_label label_valuess &&&&&, r_rMultiIndex.take s| V$%g...zwO <<1 !5!5gs4y!I!I99; .2jj9js'"j9 b=Dxxzz!&I#,L)1&MM"**\":;"';;e::PU  :s D$c  aa a \V\\34'gV.p\;QJdV3RlV4F 'dK RM RM!V3RlV44'EdR.p.p.p\ SP 4EF#o SP S ,pVF%pVPVP S ,4pK' S.VOUu.uF4p\VPS ,VP S ,VRR7NK6 ppSPS ,o \;QJd V V 3RlV4F 'gK RM RM!V V 3RlV44'dRo VP\P!V44VPV4VPS 4EK& \W#VRR7#SP .\;QJd.RV4FNK 5M !RV44O5p\P!V4p \P#V 4#uupi \$\&3d\)T RR7u#i;i) a Append a collection of Index options together. The `append` method is used to combine multiple `Index` objects into a single `Index`. This is particularly useful when dealing with multi-level indexing (MultiIndex) where you might need to concatenate different levels of indices. The method handles the alignment of the levels and codes of the indices being appended to ensure consistency in the resulting `MultiIndex`. Parameters ---------- other : Index or list/tuple of indices Index or list/tuple of Index objects to be appended. Returns ------- Index The combined index. See Also -------- MultiIndex: A multi-level, or hierarchical, index object for pandas objects. Index.append : Append a collection of Index options together. concat : Concatenate pandas objects along a particular axis. Examples -------- >>> mi = pd.MultiIndex.from_arrays([["a"], ["b"]]) >>> mi MultiIndex([('a', 'b')], ) >>> mi.append(mi) MultiIndex([('a', 'b'), ('a', 'b')], ) c3<"TF6p\V\4;'dVPSP8xK8 R#5ir)rrr)rors& r_r$MultiIndex.append..- s3 OT!Z: & D D199 +D Dus A"AFTr4c3N<"TFqPS,S8gxK R#5irrz)rrr level_names& r_rr> sA5Rxx{j05s"%N)rrrzrc38"TFqPxK R#5irrrks& r_rrG s)CU))UrO)rrrrrrrunionrCrrzrrrrirrrr{r rE) rotherrrrz level_valuesrr to_concat new_tuplesrrs f& @@r_rMultiIndex.append sH%$//GE 3 OT 333 OT   EFE4<<(#{{1~ B#/#5#5biil#CL !%~u~  .* RYYq\>> midx = pd.MultiIndex.from_arrays([[3, 2], ["e", "c"]]) >>> midx MultiIndex([(3, 'e'), (2, 'c')], ) >>> order = midx.argsort() >>> order array([1, 0]) >>> midx[order] MultiIndex([(2, 'c'), (3, 'e')], ) >>> midx = pd.MultiIndex.from_arrays([[2, 2], [np.nan, 0]]) >>> midx.argsort(na_position="first") array([0, 1]) >>> midx.argsort() array([1, 0]) T)r\)r codes_given)ra_get_codes_for_sortingrrK)rrr~rtargetr6keyss&$*, r_r^MultiIndex.argsortR sLf,,4,H%+%B%B%DE%Dc %DEt$OOFsAc V^8dQhRRRR/#)rrrepeatsrrtrrS)rus"r_rvr sA A cA A r^c  z\P!RRV/4\V4p\VPVP Uu.uFPpVP \P4P\PRR7PV4NKR upVPVPRR7#uupi)a Repeat elements of a MultiIndex. Returns a new MultiIndex where each element of the current MultiIndex is repeated consecutively a given number of times. Parameters ---------- repeats : int or array of ints The number of repetitions for each element. This should be a non-negative integer. Repeating 0 times will return an empty MultiIndex. axis : None Must be ``None``. Has no effect but is accepted for compatibility with numpy. Returns ------- MultiIndex Newly created MultiIndex with repeated elements. See Also -------- Series.repeat : Equivalent function for Series. numpy.repeat : Similar method for :class:`numpy.ndarray`. Examples -------- >>> idx = pd.MultiIndex.from_arrays([["a", "b", "c"], [1, 2, 3]]) >>> idx MultiIndex([('a', 1), ('b', 2), ('c', 3)], ) >>> idx.repeat(2) MultiIndex([('a', 1), ('a', 1), ('b', 2), ('b', 2), ('c', 3), ('c', 3)], ) >>> idx.repeat([1, 2, 3]) MultiIndex([('a', 1), ('b', 2), ('b', 2), ('c', 3), ('c', 3), ('c', 3)], ) r5Fr4rrS)rvalidate_repeatr/rrrrYrrrintprepeatrzr)rrr5rs&&& r_rMultiIndex.repeat sh 2~.&g.;;$(::#-K  ,33BGG%3HOOPWX#-**nn"  sAB8 c$V^8dQhRRRRRR/#)rrrz.Index | np.ndarray | Iterable[Hashable] | NoneerrorsrrtrrS)rus"r_rvr s/j!j!>j! j!  j!r^c VeVPWV4#\V\P\34'g.\ P !V\P!R4R7p.pVEFGpVPV4p\V\4'dVPV4K?\V\4'dOVPe VPM^pVP\VP VP"V44K\ P$!V4'ds\'R4'd7VP(^8Xd&\*P,!R\.\14R7VP34^,pVPV4EK1R\5V4 2p\7V4h VP;V4# \dELoi;i \8dTR8wdhEKi;i)aR Make a new :class:`pandas.MultiIndex` with the passed list of codes deleted. This method allows for the removal of specified labels from a MultiIndex. The labels to be removed can be provided as a list of tuples if no level is specified, or as a list of labels from a specific level if the level parameter is provided. This can be useful for refining the structure of a MultiIndex to fit specific requirements. Parameters ---------- codes : array-like Must be a list of tuples when ``level`` is not specified. level : int or level name, default None Level from which the labels will be dropped. errors : str, default 'raise' If 'ignore', suppress error and existing labels are dropped. Returns ------- MultiIndex A new MultiIndex with the specified labels removed. See Also -------- MultiIndex.remove_unused_levels : Create new MultiIndex from current that removes unused levels. MultiIndex.reorder_levels : Rearrange levels using input order. MultiIndex.rename : Rename levels in a 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']) rorperformance_warningszYdropping on a non-lexsorted multi-index without a level parameter may impact performance. stacklevelzunsupported indexer of type ignore)_drop_from_levelrrrrErindex_labels_to_arrayrrrrrryrzrrrstoprxrrwarningswarnr'r+nonzerorrAssertionErrorr delete) rrrrindsrlocrzmsgs &&&& r_dropMultiIndex.drop sJ  ((v> >%"**e!455 11%rxx?QR K ll;/c3''KK$U++'*xx';388DKKcii4 @A((--!"899d>Q>QUV>V P.'7'9  ++-*CKK$8c DC(---!6{{4  ?  6 X%& s=,G 38G-A"GG-A/GG GGG54G5c V^8dQhRRRR/#)rrrrrtrrS)rus"r_rvr9 s$/ r^c @\P!V4pVPV4pVPV,pVP V4p\ V4pRV\ P!VR4VR8H,&VP^,VP^,8XdRV\ P!VR4&WR8H,p\V4^8wdVR8wd\RV R24h\P!VPV,V4(p W ,#)rrFTrzlabels z not found in levelr)rrr8r get_indexerr>requalr*rr risinr) rrrrrrr  nan_codes not_foundrs &&&& r_rMultiIndex._drop_from_level9 s))%0  " "5 ) A""5)K @BE*v|<= ;;q>TZZ] *02F288It, -B,' y>Q 6X#5WYK/BCD D 4::a=&11zr^cV^8dQhRR/#rzrS)rus"r_rvrN sJ J zJ r^c ^\VP4p\VP4p\VP4pVP V4pVP V4pW2,W1,uW1&W2&WB,WA,uWA&WB&WR,WQ,uWQ&WR&\ W4VRR7#)ah Swap level i with level j. Calling this method does not change the ordering of the values. Default is to swap the last two levels of the MultiIndex. 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. If i is a negative int, the first level is indexed relative to the end of the MultiIndex. j : int, str, default -1 Second level of index to be swapped. Can pass level name as string. Type of parameters can be mixed. If j is a negative int, the second level is indexed relative to the end of the MultiIndex. 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"], ["aaa", "bbb"]], ... codes=[[0, 0, 1, 1], [0, 1, 0, 1], [1, 0, 1, 0]], ... ) >>> mi MultiIndex([('a', 'bb', 'bbb'), ('a', 'aa', 'aaa'), ('b', 'bb', 'bbb'), ('b', 'aa', 'aaa')], ) >>> mi.swaplevel() MultiIndex([('a', 'bbb', 'bb'), ('a', 'aaa', 'aa'), ('b', 'bbb', 'bb'), ('b', 'aaa', 'aa')], ) >>> mi.swaplevel(0) MultiIndex([('bbb', 'bb', 'a'), ('aaa', 'aa', 'a'), ('bbb', 'bb', 'b'), ('aaa', 'aa', 'b')], ) >>> mi.swaplevel(0, 1) MultiIndex([('bb', 'a', 'bbb'), ('aa', 'a', 'aaa'), ('bb', 'b', 'bbb'), ('aa', 'b', 'aaa')], ) Fr)rrrrzr8r)rrjr:r new_namess&&& r_ swaplevelMultiIndex.swaplevelN sz$++& $ $  " "1 %  " "1 %'1}jm$ z}%.\9<" il%.\9<" iliRW  r^cV^8dQhRR/#rzrS)rus"r_rvr s00z0r^c pVUu.uFq PV4NK ppVPV4pV#uupi)a> Rearrange levels using input order. May not drop or duplicate levels. `reorder_levels` is useful when you need to change the order of levels in a MultiIndex, such as when reordering levels for hierarchical indexing. It maintains the integrity of the MultiIndex, ensuring that all existing levels are present and no levels are duplicated. This method is helpful for aligning the index structure with other data structures or for optimizing the order for specific data operations. 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 A new MultiIndex with levels rearranged according to the specified order. See Also -------- MultiIndex.swaplevel : Swap two levels of the MultiIndex. MultiIndex.set_names : Set names for the MultiIndex levels. DataFrame.reorder_levels : Reorder levels in a DataFrame with a 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']) )r8_reorder_ilevels)rorderrrs&& r_reorder_levelsMultiIndex.reorder_levels s<\5::Eq''*E:&&u- ;s3cV^8dQhRR/#rzrS)rus"r_rvr s     r^c ~\V4VP8wd%\RVP R\V4 24hVUu.uFq PV,NK ppVUu.uFq PV,NK ppVUu.uFq P V,NK pp\ W4VRR7#uupiuupiuupi)z2Length of order must be same as number of levels (z), got Fr)rrrrrrzr)rrrr:rrs&& r_rMultiIndex._reorder_ilevels s u: % DT\\NS5zl$ /44ekk!nne 4,12EqZZ]]E 2,12EqZZ]]E 2iRW  522sB0$B5B:c V^8dQhRRRR/#)rrrrrtzGenerator[np.ndarray]rS)rus"r_rvr s  #'   r^c# 4"\V4VP8d&\R\V4 RVP R24h\\V44F<p\ VP V,VP V,W,VR7xK> R#5i)zLength of new_levels (z) must be <= self.nlevels ()r4N)rrrrrCrr)rr:rrs&&$ r__recode_for_new_levels!MultiIndex._recode_for_new_levels s z?T\\ ) (Z(9:,,0LL>< s:'A' 1 t{{1~z}4 (sBBcV^8dQhRR/#)rrrtzlist[Categorical]rS)rus"r_rvr s  (9 r^c  RRlpVPUu.uF"p\P!W!!V4RRR7NK$ up#uupi)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 V^8dQhRRRR/#)rrrrrtrS)rus"r_rv7MultiIndex._get_codes_for_sorting..__annotate__ s  j Z r^c\P!\V4'dVP4^,M^VPR7#)rdr)rrgrrr)rs&r_cats/MultiIndex._get_codes_for_sorting..cats s799),[)9)9 !A%q!'' r^TFre)rr@ from_codes)rrrs& r_r!MultiIndex._get_codes_for_sorting sI  $zz )   " ";[0A4RW X)   s(Ac ,V^8dQhRRRRRRRRR R /#) rrrr ascendingzbool | list[bool]sort_remainingrrrrtz'tuple[MultiIndex, npt.NDArray[np.intp]]rS)rus"r_rvr sCt"t"t"%t" t"  t" 1 t"r^c \V4'gV.pVUu.uFpVPV4NK ppRpVUu.uFqPPV,NK pp\V\4'd&\ V4\ V48Xg \ R4hMhV'dXTP\\ VP44Uu.uFqUV9gK VPV,NK up4M V^,p\WrVRR7p\V4pVPU u.uFqPV4NK p p \V VPVPVRR7p W3#uupiuupiuupiuup i)a Sort MultiIndex at the requested level. This method is useful when dealing with MultiIndex objects, allowing for sorting at a specific level of the index. The function preserves the relative ordering of data within the same level while sorting the overall MultiIndex. The method provides flexibility with the `ascending` parameter to define the sort order and with the `sort_remaining` parameter to control whether the remaining levels should also be sorted. Sorting a MultiIndex can be crucial when performing operations that require ordered indices, such as grouping or merging datasets. The `na_position` argument is important in handling missing values consistently across different levels. 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 : bool, default True If True, sorts by the remaining levels after sorting by the specified `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. See Also -------- MultiIndex : A multi-level, or hierarchical, index object for pandas objects. Index.sort_values : Sort Index values. DataFrame.sort_index : Sort DataFrame by the index. Series.sort_index : Sort Series by the 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 ascendingT)ordersrrF)rrrzrr)r3r8rrrrrrrrrKr/rrrz) rrrrrr6rrr7rrrs &&&&& r_ sortlevelMultiIndex.sortlevel sd^E""GE    " "3 '   ,12ESCE2 i & &u:Y/ !KLL0  LL,1#dkk2B,CX,CSRWGWC,CX aI! $ &g.BF**M*;%%g.* M;;**"  !!C 3YNsE$E)E.E."E3cV^8dQhRR/#)rrpreserve_namesrrS)rus"r_rvrq sDr^c \V\4'gIVfTpMAV^8P4'dVPV4pM\P V4pVP W4pV# \ dTu#i;ir)rrrrrr{_maybe_preserve_names)rrr7rs&&&&r__wrap_reindex_resultMultiIndex._wrap_reindex_resultq s|&*--Q,##%%7+"'33F;F ++FC !"!M"s A22 BBc$V^8dQhRRRRRR/#)rrrr rrrtrS)rus"r_rvr s!FDVr^c V'dZVPVP8Xd?VPVP8wd$VPRR7pVPVnV#)Fr)rrzr)rrrs&&&r_r MultiIndex._maybe_preserve_names sE $,,.  *[[e[,F::FL r^cV^8dQhRR/#rrS)rus"r_rvr s))D)r^c `\V4'd\V4'd \V4hR#r)r0r2r&rs&&r__check_indexing_error MultiIndex._check_indexing_error s)3;s#3#3$C( ( $4r^cV^8dQhRR/#rrS)rus"r_rvr s===r^c <VP^,P#)z1 Should integer key(s) be treated as positional? )r_should_fallback_to_positionalrs&r_r)MultiIndex._should_fallback_to_positional s {{1~<<>> 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. r)rr_partial_tup_indexr-)rrrrs&&& r_get_slice_boundMultiIndex.get_slice_bound s;`%''HE(((:)&1 r^cV^8dQhRR/#)rrrtztuple[int, int]rS)rus"r_rvr s6464_64r^c $<\SV`WV4#)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)rrendrzrs&&&&r_r(MultiIndex.slice_locs slw!%d33r^c V^8dQhRRRR/#)rrrrrr rS)rus"r_rvr8 s1K1Ke1K3K1Kr^c ~\V4VP8d&\R\V4 RVP R24h\V4p^\V4rT\WPVP RR7p\ V4EFwpwrp WVp W9d\V4'gq\P!WVR7p \T 4'g\RT 24hTR8XdT ^8d T ^,p T\P!YTR7,u#VPW4p\V\4'd(Ws^, 8dVPpVP pKWs^, 8dBV\P!WRR7,pV\P!WR R7,pEK1\V\4'd.VPpV\P!WVR7,u#V\P!WVR7,u# R# \dp \RT 24T hRp ? ii;i) Key length (z-) was greater than MultiIndex lexsort depth (rTr'r"zLevel type mismatch: Nrightleft)rrr(rrr enumerater>r searchsortedr{r1_get_loc_single_level_indexrryrr)rrrnrr)zippedrrr6rsectionrr rDs&&& r_r#MultiIndex._partial_tup_index8 s s8d)) )$s3xj)''(+  HD sS++tzz$?*3F*; &A&+!,G~d3iiL,,SDAC"##&;C5$ABB7?sax1HCu11'TJJJ223r)rr8rs&&&r_r2&MultiIndex._get_loc_single_level_indexk s+& S>>d3iiI&&s+ +r^c baSPV4V3Rlp\V\4'gSPV^R7pV!V4#\ V4pSP V8d\ RV RSP R24hVSP 8Xd/SP'dSPPV4#SPpVRVWRrV'g^p \ S4p MSPW4wrW8Xd \ V4hV 'g \W4#\!R4'd&\"P$!R\&\)4R 7\*P,!W\*P.R 7p\1V \ V44F}wr|SP2V,V,SP5SP6V,V 48Hp V P94'g W=,p\ V4'dKt\ V4h \ V4W, 8wd V!V4#\W4# \ dp\ T4ThRp?i\d-SPT\SP 44wr6Tu#i;i \dp\ T4ThRp?ii;i) aw Get location for a label or a tuple of labels. The location is returned as an integer/slice or boolean mask. This method returns the integer location, slice object, or boolean mask corresponding to the specified key, which can be a single label or a tuple of labels. The key represents a position in the MultiIndex, and the location indicates where the key is found within the index. Parameters ---------- key : label or tuple of labels (one for each level) A label or tuple of labels that correspond to the levels of the MultiIndex. The key must match the structure of the MultiIndex. 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 cf<\V\P4'd VP\P8wdV#\ P !V\S44p\V\4'dV#\P!\S4RR7pVPR4RW&V#)z._maybe_to_slice s|c2::..#))rww2F ,,S#d),J> J I J"*JJ J. J))J.c V^8dQhRRRR/#)rrrr drop_levelrrS)rus"r_rvrs?? ?D?r^c R\V\\\34'gVP V4pMVUu.uFq@P V4NK ppVP WR7wrVV'g3\ P!V4'dWV^,pWV3#W,pWV3#uupi)a] Get location and sliced index for requested label(s)/level(s). The `get_loc_level` method is a more advanced form of `get_loc`, allowing users to specify not just a label or sequence of labels, but also the level(s) in which to search. This method is useful when you need to isolate particular sections of a MultiIndex, either for further analysis or for slicing and dicing the data. The method provides flexibility in terms of maintaining or dropping levels from the resulting index based on the `drop_level` parameter. Parameters ---------- key : label or sequence of labels The label(s) for which to get the location. level : int/level name or list thereof, optional The level(s) in the MultiIndex to consider. If not provided, defaults to the first level. drop_level : bool, default True If ``False``, the resulting index will not drop any level. Returns ------- tuple A 2-tuple where the elements : Element 0: int, slice object or boolean array. Element 1: The resulting sliced multiindex/index. If the key contains all levels, this will be ``None``. 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. Examples -------- >>> 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='str', name='B')) >>> mi.get_loc_level("e", level="B") (array([False, True, False]), Index(['b'], dtype='str', name='A')) >>> mi.get_loc_level(["b", "e"]) (1, None) rB)rrrrr8_get_loc_levelrr1)rrrrKr6rrs&&&& r_rDMultiIndex.get_loc_levelsf%%u!566**51E.maybe_mi_droplevelsKs9 W IFD1%991#> 2 r^z:Key for location must have same length as number of levelsNTr'rBrc3B"TFp\V\4xK R#5ir)rryrs& r_r,MultiIndex._get_loc_level..~s9Sz!U++SsFz'Expected label or tuple of labels, got )rrrrrrrMryrrrrrrCr{r&rrrrnrr rr1r!_supports_partial_string_indexingr0r is_null_slice is_full_slice)rrrrUrr6rrrrrr7r rilevels loc_levelk_indexr result_indexsf&& r_rMMultiIndex._get_loc_levelEs  eeT] + +3x3u:%$PFe6!%!4!4Q!4!Bc5))88CIT:D $DIC &FL 7 ")7 :  c4 *C c5 ! !eqj $++a.("55c5GG 3GaS AI"--)39S93339S999s8t||+ $ 4 4S 94@@,,s+&+CHoUoQ5tCT9T11oUw<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&+CHoUoQ5tCT9T11oU 3G EEE--c-?G3$$KK&HHH E*2237!%(("DM11 -27GD L( (_ "&\:   "$01  $5&sm4$V`V  -#G} L( ( -sS6S60T4T:T:AT?%T?>T?U2U U S32S36T  T  T7 T%% T72T76T7 U#"U#c V^8dQhRRRR/#)rrrrr7znpt.NDArray[np.bool_] | NonerS)rus"r_rvrs$oYoYoY,HoYr^c VPV,pVPV,pW53Rlp\V\4'EdVPpVRJ;'dV^8pVP eVP VP 4p MV'd\V4^, p M^p VPeVP VP4p M@V'd^p M5\V \4'd \V4p M\V4^, p \V \4'g\V \4'd$\V RV 4p \V RV 4p V!WV4#V^8gVP^8XgVe$V'd V ^, MV ^,p V!WV4#\P!WYRR7p \P!WZRR7p \WV4#VPWA4p V^8gVP^8Xd{\V \4'd$W]P 8W]P8,pV#\ P"!W]8H\$R7pVP'4'g \V4hV#\V \4'dF\P!W]P RR7p \P!W]PRR7pM0\P!W]RR7p \P!W]RR7pW8Xd \V4h\\)V 4\)V44# \dCTPTP TPTP4;rT PpELsi;i)cVe WC,pVeV^8XdW@8WA8,pM8\P!WW$PR7p\P!WF4pVfV#VP 4pWSV&V#)Nr)rrgrrrr)rrrzr7r new_indexerrs&&&&& r_convert_indexer6MultiIndex._get_level_indexer..convert_indexersq"|tqy$~%,? IIe4{{C#jj2 ""llnG*G Nr^Nrrr/r"r.r)rrrryrzrrrrr  slice_indexerrrrr1r2rrrrr-)rrrr7r8rrfrzis_negative_steprrrrrDlocsr)s&&&& r_rCMultiIndex._get_level_indexerskk%( jj' 7> , c5 ! !88D#4/<L:L:L:!L:L::A NNcV^8dQhRR/#rrS)rus"r_rvrKsE7E73E7r^c  a \\P!V44UUu.uFwr#V'gKVNK pppV'd4VR ,VP8d\ RV RVP 24h\ ;QJdRV4F 'gK RM RM !RV44'd \ R4h\V4o RV 3RllpR p\V4EFwr'R p\P!V4'do\V4S 8wd \R 4h\V\\34'd VPp\P!V4pVfVP!4pM\#V4'dBVP%WrVR 7pVf)\P0!.\P2R 7u#Mu\P4!V4'dGVf@V\V4^, 8Xd)\P6!S \P2R 7u#EKFVP%WrVR 7pV!V4pVfTpEKjWh,p\P !V4'dEK\P !V4'gEK\+V4h Vf'\P0!.\P2R 7#VP94^,p VP;W4#uuppi \&\(\*3dmp TF[p \-T 4'gT hTP%YTR 7p Tf T!T 4pK7\T \.4'dRY&KSY,pK] R p ? ELR p ? ii;i)aO Get location for a sequence of labels. Parameters ---------- seq : label, slice, list, mask or a sequence of such You should use one of the above for each level. If a level should not be used, set it to ``slice(None)``. Returns ------- numpy.ndarray NumPy array of integers suitable for passing to iloc. See Also -------- MultiIndex.get_loc : Get location for a label or a tuple of labels. MultiIndex.slice_locs : Get slice location given start label(s) and end label(s). Examples -------- >>> 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) zIMultiIndex slicing requires the index to be lexsorted: slicing on levels z, lexsort depth c30"TF q\JxK R#5ir)EllipsisrMs& r_r&MultiIndex.get_locs..vs*cH}csTFz2MultiIndex does not support indexing with EllipsiscV^8dQhRR/#rrrtr$rS)rus"r_rv)MultiIndex.get_locs..__annotate__}s  )> r^c<\V\4'd-\P!S\PR7pRW&V#V#)rT)rryrrbool_)r7rdr3s& r__to_bool_indexer-MultiIndex.get_locs.._to_bool_indexer}s7'5)) hhq9 '+ $""Nr^NzLcannot index with a boolean indexer that is not the same length as the index)rr7rr)r0ris_true_slicesrr(rr.rrxrrr;rErrrrr3rCr&r{r r0ryrrrZrgr_reorder_indexer)rseqrs true_slicesrvr7r lvl_indexerr r, item_indexer pos_indexerr3s&& @r_get_locsMultiIndex.get_locsKsH(11C1CC1H'IO'IVaQqq'I O ;r?d.A.AA$(M)9$:M:M9NP  3*c*333*c* * *%D  I  15cNDA@DK""1%%q6Q;$>a)U!344 A jjm ?"-"2"2"4Ka8"&"9"9!g"9"VK0&88Bbgg66' ""1%%?qCHqL'899Qbgg66#55a'5R +;7K%&vvg266++>+>"3-'E#J ?88Bbgg. .oo'* $$S66CPZ*9h?8 *1~~"%I(,'>'>(?( '.*:<*HK' e<<8VP6f0\P.!V3\P8R7V,p M\P!V4V,p V .VO5pEKl \P:!V4p W,,#)a Reorder an indexer of a MultiIndex (self) so that the labels are in the same order as given in seq Parameters ---------- seq : label/slice/list/mask or a sequence of such indexer: a position indexer of self Returns ------- indexer : a sorted position indexer of self ordered as seq FNrcTrrrS)r0rrZrxr5r3rrVrrrrryrzrrgrrArEr;rDrr;onesrRrrrrr) rrzr7 need_sortrrk_codesr3r new_order key_order_map level_indexerinds &&& r_ryMultiIndex._reorder_indexers( cNDA  ##s':':1'='=1aq6Q;''))#kk!n88;G%l3G!(" !; @ @ BI $IAu%%%%'' !d 2 A 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%%!&&*<!IIa!eR4W= Au%%!''/affnGGQD8A IIaL1 %%D;#@jj|r^cV^8dQhRR/#rzrS)rus"r_rvr,s0 0 :0 r^c V'dV'dW!8d \R4hVP^,PW4wr4VPW4wrV\VP4pV^,W4V^&VPUu.uFqWVNK p pV ^,V, V ^&\ VV VP RR7#uupi)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. See Also -------- DataFrame.truncate : Truncate a DataFrame before and after some index values. Series.truncate : Truncate a Series before and after some index values. 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 < beforeFr)rrr(rrrr) rbeforeafterrrr/r.r:rrs &&& r_truncateMultiIndex.truncate,s> V-. .{{1~((7oof4 $++& "1 a* 1 @D K , K |a' ! ++"   Ls Cc V^8dQhRRRR/#)rrrrortrrS)rus"r_rvr^s--F-t-r^c BVPV4'dR#\V\4'gR#\V4\V48wdR#\V\4'g:VP V4'gR#\ VPVP4#VPVP8wdR#\VP4FpVPV,pVPV,pVR8HpVR8Hp\P!WV4'gR#VPV,pVPV,p\WHVRR7p \P!W94'gR#VR,PVR,4'dKR# R#)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 TFr4NrNr)is_rrErr_should_comparer=rrrrr array_equalrrCequals) rrr self_codes other_codes self_mask other_mask self_level other_levelrs && r_rMultiIndex.equals^s3 88E??%'' t9E "%,,''..#DLL%--@ @ <<5== (t||$AAJ++a.K"b(I$*J>>)88QJ,,q/K-*5I>>*88b>((R99!%"r^c V^8dQhRRRR/#)rrrrrtrrS)rus"r_rvrs  *  r^c VPVP8wdR#\VP4F?pVPV,PVPV,4'dK>R# R#)zD Return True if the levels of both MultiIndex objects are the same FT)rrrr)rrrs&& r_ equal_levelsMultiIndex.equal_levelssS <<5== (t||$A;;q>((a99%r^cV^8dQhRR/#rzrS)rus"r_rvrs""Z"r^c d<VPV4wrVP'dl\\VP V4`VP V4V4p\ V\4'dV#\P\VRR/RVR7#VPVRR7p\V4'dVPV4pMVPV4pVRJdVP4pV#V# \d1TRJdh\P !R\"\%4R7T#i;i)rTNrFr(zTThe values in the array are unorderable. Pass `sort=False` to suppress this warning.r)_convert_can_do_setophas_duplicatesr rrename_unionrrr differencerr_get_reconciled_name_object sort_valuesr{rrRuntimeWarningr+)rrr( result_namesr right_missingrs&&& r_rMultiIndex._unions,"88?    :t{{<'@H \*DF&*-- ))V)D)T*  ",,T,>M=!!]399%@5  #//1FM6M!t|MMF#5  Ms C447D/.D/c V^8dQhRRRR/#)rrrrrtrrS)rus"r_rvrs&&(&t&r^c \V4#r)r4)rrs&&r__is_comparable_dtypeMultiIndex._is_comparable_dtypes u%%r^cV^8dQhRR/#rzrS)rus"r_rvrs%%J%r^c VPV4pVPV8wdVPV4#VPRR7#)zO If the result of a set operation will be self, return a shallow copy of self. Fr)_maybe_match_namesrzrr)rrrzs&& r_r&MultiIndex._get_reconciled_name_objects@ ''. :: ;;u% %yyey$$r^c H\VP4\VP48wdR.\VP4,#.p\VPVPRR7F/wr4W48XdVPV4KVPR4K1 V#)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. NTr')rrzrr)rrrza_nameb_names&& r_rMultiIndex._maybe_match_namess| tzz?c%++. .6C O+ +!$**ekk$GNF V$ T" H  r^cV^8dQhRR/#rzrS)rus"r_rvrs..*.r^c JVPV4wr4VPV4#r)r set_namesrrrrFrs&&& r__wrap_intersection_result$MultiIndex._wrap_intersection_results%44U; --r^c V^8dQhRRRR/#)rrrrrtrS)rus"r_rvrs22Z2J2r^c VPV4wr4\V4^8Xd VP4PV4#VPV4#r)rrrmrrs&&& r__wrap_difference_result"MultiIndex._wrap_difference_resultsK44U; v;! ..0::<H H##L1 1r^c BVPp\V\4'gL\V4^8XdVR,VP3#Rp\P WPR7pW3#\W4pW3# \ \3dp\T4ThRp?ii;i)rrz.other must be a MultiIndex or a list of tuplesrN) rzrrErrrrr{rG)rrrrr s&& r_r MultiIndex._convert_can_do_setopszz %''5zQBx++F2&225 2KE""/t;L""#I.2$C.c12s A<<B BBcV^8dQhRR/#)rrrrrS)rus"r_rvrs77$7r^c \V4p\V\4'dRp\V4h\ V4'g \ R4hVRJdVP 4#V#)a Create an MultiIndex with values cast to dtypes. The class of a new Index is determined by dtype. When conversion is impossible, a TypeError exception is raised. Parameters ---------- dtype : numpy dtype or pandas type Note that any signed integer `dtype` is treated as ``'int64'``, and any unsigned integer `dtype` is treated as ``'uint64'``, regardless of the size. copy : bool, default True By default, astype always returns a newly allocated object. If copy is set to False and internal requirements on dtype are satisfied, the original data is used to create a new Index or the original Index is returned. Returns ------- MultiIndex MultiIndex with values cast to specified dtype. See Also -------- Index.dtype: Return the dtype object of the underlying data. Index.dtypes: Return the dtype object of the underlying data. Index.convert_dtypes: Convert columns to the best possible dtypes. Examples -------- >>> mi = pd.MultiIndex.from_arrays(([1, 2, 3], [4, 5, 6])) >>> mi MultiIndex([(1, 4), (2, 5), (3, 6)], ) >>> mi.astype("object") MultiIndex([(1, 4), (2, 5), (3, 6)], ) z3> 1 ndim Categorical are not supported at this timezISetting a MultiIndex dtype to anything other than object is not supportedT)r7rr8r.r4r{r5)rrrrs&&& r_rMultiIndex.astypesdXU# e- . .GC%c* *u%%#  4<::<  r^c T\V\4'd3VPVP8wd \R4hVP#\V\ 4'g%V3RVP^, ,,pV#\ V4VP8wd \R4hV#)z0Item must have length equal to number of levels.)r)rrrrrrr)ritems&&r__validate_fill_valueMultiIndex._validate_fill_value9s dJ ' '||t||+ !STT<< D%((7UdllQ&677D Y$,, &OP P r^c V^8dQhRRRR/#)rrr/rrtrS)rus"r_rvrGs& & :& *& r^c  R\W4wrV'dVP4#\V4\V48XdW!,P4pMVP4p.p.p\ \ VP VP VPRR74Fmwpwrp V PVRR7p V PVPV44p \V 4p WV&VPV 4VPV 4Ko \WVVPRR7#)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 Tr'Frr)r?rrrmr0rrrrrrBr.rrrz)rrr/noopsubsetr:rr value_levelrr new_level value_codesnew_codes&&& r_putmaskMultiIndex.putmaskGs&d1  99;  t9E "[557F//1F  4=  t{{DJJt D5 0A0 K Ke rrrr.rrz) rrrr:rrrrlev_locs &&& r_rMultiIndex.insertos((.  %({{DJJt%T !Ak~e* W0'' G--*   e $   RYY|K'@#O P&UdjjSX  r^cV^8dQhRR/#rzrS)rus"r_rvrs  Z r^c VPUu.uFp\P!W!4NK pp\VPVVP RR7#uupi)zU Make new index with passed location deleted Returns ------- new_index : MultiIndex Fr)rrrrrrz)rrrrs&& r_rMultiIndex.deletesNEIJJOJ[RYY{0J O;;**"   PsAcV^8dQhRR/#rrrS)rus"r_rvrsT%T%*?T%r^c L\V\4'd \V4pVf\V4^8Xd1\P !\V43\P R7#\V\4'g\PV4pVP4PV4R8g#VPV4pVPV4pVP^8Xd0\P !\V4\P R7#VPV4#)a Return a boolean array where the index values are in `values`. Compute boolean array of whether each index value is found in the passed set of values. The length of the returned boolean array matches the length of the index. Parameters ---------- values : set or list-like Sought values. level : str or int, optional Name or position of the index level to use (if the index is a `MultiIndex`). Returns ------- np.ndarray[bool] NumPy array of boolean values. See Also -------- Series.isin : Same for Series. DataFrame.isin : Same method for DataFrames. Notes ----- In the case of `MultiIndex` you must either specify `values` as a list-like object containing tuples that are the same length as the number of levels, or specify `level`. Otherwise it will raise a ``ValueError``. If `level` is specified: - if it is the name of one *and only one* index level, use that level; - otherwise it should be a number indicating level position. Examples -------- >>> idx = pd.Index([1, 2, 3]) >>> idx Index([1, 2, 3], dtype='int64') Check whether each index value in a list of values. >>> idx.isin([1, 4]) array([ True, False, False]) >>> mi = pd.MultiIndex.from_arrays( ... [[1, 2, 3], ["red", "blue", "green"]], names=["number", "color"] ... ) >>> mi MultiIndex([(1, 'red'), (2, 'blue'), (3, 'green')], names=['number', 'color']) Check whether the strings in the 'color' level of the MultiIndex are in a list of colors. >>> mi.isin(["red", "orange", "yellow"], level="color") array([ True, False, False]) To check across the levels of a MultiIndex, pass a list of tuples: >>> mi.isin([(1, "red"), (3, "red")]) array([ True, False, False]) rr)rrrrrrrurrr;rr8rBr"r)rr rnumlevss&&& r_rMultiIndex.isinsJ fi ( (&\F =6{axxT BHH==fj11#//7==?2248B> >((/C((-DyyA~xxD ::99V$ $r^__add____radd____iadd____sub____rsub____isub____pow____rpow____mul____rmul__ __floordiv__ __rfloordiv__ __truediv__ __rtruediv____mod____rmod__ __divmod__ __rdivmod____neg____pos____abs__ __invert__)rr))NNNNFNT)NNN)NN)NFNrF)first)r)rTN)Nraise)r)rr)rTTr)r/)rTr)rN)T)rTrUrVrWrXrE _hidden_attrs frozenset_typr__annotations__rHr)r _comparablesrrr classmethodrrrrrrrr)rpropertyr rrrr"rrrErrPrrr`rnrsrwr5rrrYrrrrrrrrrrrrzrr8rr r _duplicatedr0r8rrBr;rMrRrVrrarmrsr|rrrr^rrrrrrrrrrrrrr r r r$r(r#r2rrDrMrCrryrrrrrrrrrrrrrrrrrrrIrrrrrrrrrrrrrrrrrrrrrrr] __classcell__)rs@r_rrsSj'')+5M D$&F !&lG \F9L ,\*L\!%?B~~ D D LLILI\!%?B~~ 8D8DtCJCJN2    RR@"B"B"H+ +  +  +"'+Zu#u>Bun!!,22<4' '  '  '"''RD"D=ADR%G%GR&&69^^K" Ob  )V<<""H##4X$$$L= &* =D'6$6$p     EB6KK<22:%|KJ '/R42CJ)DZ ^^!& WvD<&3P 8 8B H`J7!F $V pJ1X5P/55PnA Hj!X*J X0d    (t"l )== ; ;FF(*4l6464p1Kf,2~X@?BS)joYbE7RVp0 d-^  ""H&%".2#*77r & P# J T%p__F i(Gz*Hz*Hi(Gz*Hz*Hi(Gz*Hi(Gz*H">2L#O4M!-0K">2Li(Gz*H .J!-0Ki(Gi(Gi(G .Jr^rc$V^8dQhRRRRRR/#)rrrlist[np.ndarray]rrrtrS)rus"r_rvrvs"  * S S r^cVUu.uFp\V4NK pp\V^R4F&p\P!VRV4'gK$Vu# ^#uupi)zJCount depth (up to a maximum of `nlevels`) with which codes are lexsorted.Nr)r.rrr)rrr int64_codesrs&& r_rrsU@EF< ,KF 7Ar "  Ra 1 1H# GsAc V^8dQhRRRR/#)rrrrrrorS)rus"r_rvrv#s++s+&+r^c \\VRR/4p\V4pVRV^,pW1,pW1^,RFp.p\\WgRR74Fvwp wrW^, 8Xd%VP V 4VP V4MAW8XdVP V4KRVP WyR4VP V4M TpK \\VRR/4#)rTNr')rrrr0rr) label_listrrpivotedrrprevcur sparse_currpts &&& r_rr#s3 0401G JA [uqy !F >Dqy{# "3t#>?IAvEz!!!$ j)v!!(+!!#b'* j)@!$$ V)D) **r^c V^8dQhRRRR/#)rrrrrtrrS)rus"r_rvrv?sPPxPCPr^c\V\4'dVP #VPp\P R\P R/PVR4#)NaTNaN)rr9rrrr datetime64 timedelta64get)r dtype_types& r_rr?sI%((..!"ZZ MM5"..% 8 < 6r^c Rp\V4'g \V4hVFp\V4'dK\V4h \V4^8Xd.#\P!RV4\P R7p\P !V4p\P!V^84'd \R4h\P!V^4p^V^&VR,^8wdVR,V, pM\P!V4p\V4UUu.uFQwrr\P!\P!W&V,4\P!WW,44NKS upp#uuppi)a Numpy version of itertools.product. Sometimes faster (for large inputs)... Parameters ---------- X : list-like of list-likes Returns ------- product : list of ndarrays Examples -------- >>> cartesian_product([list("ABC"), [1, 2]]) [array(['A', 'A', 'B', 'B', 'C', 'C'], dtype='.s*1ArOrz+Product space too large to allocate arrays!r)r3r{rrfromiterrcumprodrrroll zeros_liker0tilerprod)r*rr,lenXcumprodXabrs& r_rrs,. 4C ??n AC.  1v{ ;;**"'' :Dzz$H vvhlFGG !A AaD|q RL8 # MM( #aL   !DA  IIa1  GGADM !   s"AE=)rrr) __future__rcollections.abcrrrrrr functoolsr itertoolsr sysr typingrrrrrrnumpyrpandas._configr pandas._libsrrrrYrpandas._libs.hashtablerpandas._typingrrrrrrrrr r!r"r#r$pandas.compat.numpyr%r pandas.errorsr&r'r(pandas.util._decoratorsr)r*pandas.util._exceptionsr+pandas.core.dtypes.castr,r-pandas.core.dtypes.commonr.r/r0r1r2r3r4r5r6r7pandas.core.dtypes.dtypesr8r9pandas.core.dtypes.genericr:r;pandas.core.dtypes.inferencer<pandas.core.dtypes.missingr=r>pandas.core.algorithmscore algorithmspandas.core.array_algos.putmaskr?pandas.core.arraysr@rApandas.core.arrays.categoricalrBrCpandas.core.commoncommonrpandas.core.constructionrDpandas.core.indexes.baseindexesbaserprErFrGpandas.core.indexes.frozenrHpandas.core.ops.invalidrIpandas.core.sortingrJrKpandas.io.formats.printingrLrrMrNrOBaseMultiIndexCodesEnginerZrQrdrbrhrfrlrjrprnrrrrrr"rXrCrrSr^r_r^s"!% ./ 5   7 '&<! 3(( 23 4X??AVAVX??AVAVX??AVAVH>>@T@T H>>@U@U & HRE/RE/RE/jJ +8PB."6r^