Owg[/ddlmZddlmZmZmZmZmZddlm Z ddl m Z ddl m Z mZmZmZmZddlZddlZddlmZddlmZmZmZdd lmZdd lm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+dd l,m-Z.dd l/m0Z0m1Z1m2Z2dd l3m4Z4m5Z5m6Z6ddl7m8Z8ddl9m:Z:ddl;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDddlEmFZFmGZGddlHmIZImJZJddlKmLZLddlMmNZNmOZOddlPmQcmRZddlSmTZTddlUmVZVmWZWddlXmYZYmZZZddl[mQcm\Z]ddl^m_Z_ddl`mQcmacmbZcddl`mdZdmeZemfZfmgZgddlhmiZiddljmkZkddllmmZmmnZnddlompZpmqZqe r ddlrmsZsmtZtmuZuevecjZwewjdd d!Gd"d#ejejZ{Gd$d%ejejZ}d.d&Z~Gd'dedZd/d(Zd0d1d)Zd2d*Zd3d+Zd4d5d,Zd6d-Zy)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_klassc.eZdZdZej ZdZy)MultiIndexUIntEngineza This class manages a MultiIndex by mapping label combinations to positive integers. c||jz}|jdk(rtjj |Stjj |dS)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 P/var/www/horilla/myenv/lib/python3.12/site-packages/pandas/core/indexes/multi.py_codes_to_intsz#MultiIndexUIntEngine._codes_to_intssP$ $,, ::?==''. .}}##E#22N)__name__ __module__ __qualname____doc__libindex UInt64Engine_baser`rar_rRrRs  ! !E3rarRc.eZdZdZej ZdZy)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. c|jd|jz}|jdk(rtjj |Stjj |dS)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). objectrTrU)astyperWrXrYrZr[r\s r_r`z$MultiIndexPyIntEngine._codes_to_intssY& X&$,,6 ::?==''. .}}##E#22raN)rbrcrdrerf ObjectEnginerhr`rirar_rkrks  ! !E3rarkcJtfd}tt|S)z A decorator to allow either `name` or `names` keyword but not both. This makes it easier to share code with base class. crd|vrd|vr tdd|vr|jd|d<|g|i|S)Nnamenamesz*Can only provide one of `names` and `name`) TypeErrorpop) self_or_clsargskwargsmeths r_new_methznames_compat..new_methsM V 6 1HI I V $jj0F7OK1$1&11ra)r rr)ryrzs` r_ names_compatr{s* 4[22 8 rac eZdZUdZej ezZdZgZde d<e Z e Z dgZ de d< d dd Zdd Z d dd Zedej&f ddZee d ddZedej&f ddZe d ddZeddZeddZedZeddZddZeddZ eddZ!dd d d d ddZ"dd d ddZ#eddZ$eddZ%eddZ&dd d d d dd Z'dd d dd!Z(ed"Z)edd#Z*e+ejXej&fdd$Z,dd%Z- d dd&Z.ddd'Z/ddd(Z0e+ejbdd)Z1edd*Z2dd+Z3e+ejhddd,Z4edd-Z5ddd.Z6d/Z7d0d1 dd2Z8 d dd3Z9dd4 dd5Z:dd6Z;dd d7dd8Z<eedd<Z?edd=Z@edd>ZAedd?ZBe+ejddd@ZCeCZDddAZEe+ejdddBZFdddCZGddDZHe+ejddEZId ej&d f ddFZJddGZKddHZLeddIZMdddJZNddKZOdLZPdMZQddNZReSeTdOeUz d ddPZVdQZWdRdS ddTZXeSeTdUeUzdddVZY d ddWZZ d ddXZ[dddYZ\ddZZ]dd[Z^ d dd\Z_dd]Z` d dd^Zadd_Zbdd`ZcddaZdeddbZe dԈfdc ZfdՈfdd ZgddeZh ddfZidd؈fdg ZjdddhZkddiZldjZmdddkZndddlZo d ddmZpddnZq ddoZrdddpZsddqZtddrZudfds ZvddtZwdduZxdvZyddwZzddxZ{dyZ|e+ejdddzZ}d{Z~dd|Zdd}Zdd~Ze+ejdddZejZedZedZedZedZedZedZedZedZedZedZedZedZedZedZedZedZedZedZedZedZedZedZxZS)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]_namesrs int | None sortorderNFTc  ||}|| tdt|t|k7r tdt|dk(r tdtj |} i| _| j ||d| j||ddgt|z| _|| j||t|| _ n|| _ |r| j} | | _ | jd| _| S)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)rtlen ValueErrorrm__new___cache _set_levels _set_codesr~ _set_namesintr_verify_integrity_codes_reset_identity _references) clslevelsr^rrsdtyperrrverify_integrityresult new_codess r_rzMultiIndex.__new__Es   E >U]=> > v;#e* $KL L v;! HI I$  6u=%dU;V,     e $  "9~F (F  002I%FM ! raczt|}tj|rtj||d|}|S)a 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:rYanywhere)r]levelcode null_masks r__validate_codeszMultiIndex._validate_codests6 K 66) 88IdOR6D rac |xs |j}|xs |j}|tt|}t|t|k7r t dt|d}|D]}||}||}t||k7r%t d|Dcgc] }t|c}t|rH|j t|k\r,t d|d|j dt|dt|r3|j dkr t d|d |j d |jrt d t|d ||jf|jt|j|jkDr9t d |jdt|j|jg} tt|D]B}||vr(| j|j||||/| j||Dt| } | Scc}w)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_rzMultiIndex._verify_integritysN:#&4;;  #$S[1  v;#e* $: 58} ! A1IE(K;</ ,e-LUc%j-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$8E!H$MN##E!H-  . |, =.MsH< cd}t|s t|t|r t|}|D]}t|rt|t dt |D]-}t ||t ||dz k7s$t dt|\}}|tjur|D cgc]} t| dd}} |||||dScc} w)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.rTzall arrays must be same lengthrrNFrr^rrsr) r0rtr/rrrrr>r no_defaultgetattr) rarraysrrs error_msgarrayrr^rarrs r_ from_arrayszMultiIndex.from_arrayssTF F#I& & v &\F +E& ** + q#f+& CA6!9~VAE]!33 !ABB C18 v CNN ";ABCWS&$/BEB"   Cs5Cct|s tdt|r t|}t t t tdf|}t|rrtd|Dr`tjt|g}ttj|tjdg}|||||dSt|dk(r| td ggt|z}nt!|tj"tfrXt!|trtj$|j&}tt)j*|j,}n_t!|tr)tt)j.|j,}n&t1|}t tt2t|}|j5||| S) 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..c3FK|]}t|txr| ywN) isinstancetuple).0es r_ z)MultiIndex.from_tuples..Ss!N!z!U3=A=Ns!rmrFrrz-Cannot infer number of levels from empty listrrs)r0rtr/rrrrrrallrYzerosrAcomasarray_tuplesaferrndarrayasarray_valuesrtuples_to_object_arrayTto_object_array_tuplesziprr)rtuplesrrsr^rrarrss r_ from_tupleszMultiIndex.from_tuples!sVF#MN N v &\Fjx}!56? v;3NvNNXXc&k*+EC11&@RSTUF#!&   v;! } OPPTCJ&F U 3 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.rrNr) pandas.core.reshape.utilrr0rtr/rr>rrr)r iterablesrrsrr^rits r_ from_productzMultiIndex.from_productrs\ ?I&KL L y !YI0; v CNN "9BC2WR.CEC"%(65IUCC DsBct|ts tdt|j \}}||n|}|j |||S)aK 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)rr6rtritemsr)rdfrrs column_namescolumnss r_ from_framezMultiIndex.from_framesP|"l+78 8 #RXXZ 0 g % 5w)5IIracVg}t|jD]}|j|}|j|}|}t |j t r&td|}|jj}t |j ts tj|j dr|jt}tj |}t#j$|||j&}|j)|tj*|}|S)NrKmM fill_value)rrrr^rrr4r_data_internal_get_valuesr5r is_np_dtypernrmrYrrtake_nd _na_valuerfast_zip)r]valuesrrr^valsrs r_rzMultiIndex._valuesst||$ AKKNEJJqMED$**&67.5zz668$**n5 D:{{6*::d#D==uID MM$ ! $ll6" rac|jSrrr]s r_rzMultiIndex.valuess ||ractd)z 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_rzMultiIndex.arrays F  racddlm}tj|jDcgc]}|j c}}||jDcgc]}|j c}t|Scc}wcc}w)ax 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_namesrrrrrA)r]rMrrss r_dtypeszMultiIndex.dtypes#sW, "&& 'Lu 'LM s4::a=!!ract|S)zG Return the number of elements in the underlying data. rrs r_sizezMultiIndex.sizeAs 4yract|j|jDcgc]\}}|j|}}}|D] }d|_ t |Scc}}w)aA 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']]) rrT)r_levelsr~_rename_no_setting_namerE)r]xrrrrs r_rzMultiIndex.levelsLs`j7:$,, 6TU71d!)))&UU *E%)E " *&!! VsA)rrrrc|rbt|dk(r td|#t||jk7r td|"t|t|k7r td|2tfd|D}t t t|}np|Dcgc]}|j |}}t |j} t||D]#\} }t|j| | <%t| }|r|j||} | |_ |j} ||_t| r|j| |j!ycc}w)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.c3TK|]}t|j!ywrN)rC_view)rlevrs r_rz)MultiIndex._set_levels..s&$9< St,224$s%(r)rr)rrrrErr_get_level_numberrrrCrrrrsrr _reset_cache) r]rrrrr new_levels level_numbersrnew_levels_listlev_numrrss ` r_rzMultiIndex._set_levelssY 6{a !FGG}V !< !PQQ S[CJ%> !OPP =#$@F$J!s:!78MDIJST33C8JMJ"4<<0O #M6 : P +7$+G+M+M+O( P#O4J ..!M/I$DK ! u: OOE " #KsE&rrc t|trn-t|r t|}nt|r t |}t ||d\}}|j }|j|j||d||S)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_levelszMultiIndex.set_levelssf fe $  6 "6]F & !&\F)%B vjjl   %$AQ   rac,t|jS)a Integer number of levels in this MultiIndex. Examples -------- >>> mi = pd.MultiIndex.from_arrays([['a'], ['b'], ['c']]) >>> mi MultiIndex([('a', 'b', 'c')], ) >>> mi.nlevels 3 )rrrs r_rzMultiIndex.nlevelss4<<  rac:td|jDS)a 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) c32K|]}t|ywrrrrs r_rz&MultiIndex.levshape..4s1SV1)rrrs r_levshapezMultiIndex.levshape&s1T[[111rac|jSr)rrs r_r^zMultiIndex.codes9 {{rac`|rI|#t||jk7r td|"t|t|k7r td|=tfdt |j |D}t t|}nr|Dcgc]}|j|}}t|j} t ||D]%\} } |j| }t| || | <'t| }|r|j||}||_ |jycc}w)Nz+Length of codes must match number of levelsz,Length of codes must match length of levels.c3\K|]#\}}t||j%ywr)_coerce_indexer_frozenview)rrrrs r_rz(MultiIndex._set_codes..Ns/#$C'{CdCHHJ#s),r)r^r)rrrrErrrrrrrrrr) r]r^rrrrrrrnew_codes_listrrs ` r_rzMultiIndex._set_codes=s1 }Ut||!; !NOO SZ3u:%= !OPP ="#(+DLL%(@#I"#i.1MDIJST33C8JMJ!$++.N(+M5(A $kk'**@4+w'  #>2I ..-/I   !KsD+ct||d\}}|j}|j|j||||S)a0 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_codeszMultiIndex.set_codesfsFt)w? ujjl  uE>> mi = pd.MultiIndex.from_arrays([['a'], ['b'], ['c']]) >>> mi MultiIndex([('a', 'b', 'c')], ) >>> mi.copy() MultiIndex([('a', 'b', 'c')], ) )rrrsdeepNNr)deepcopyNFrr) _validate_namesrr0rr^r(rrru_id) r]rsr.rrkeep_idrr^r0 new_indexs r_rzMultiIndex.copysL$$$e$$G("   %dkk*FTZZ(E!-4;;* DJnn"   ;;++- Xt,  HHIMrac|jS)z%the array interface, return my values)r)r]rrs r_ __array__zMultiIndex.__array__ rracH|j}|j|_|S)z0this is defined as a copy with the same identity)rr2)r]rrs r_rzMultiIndex.view$sXX  racrt| |j|y#tttf$rYywxYw)NTF)hashget_loc LookupErrorrtrr]keys r_ __contains__zMultiIndex.__contains__*s6 S   LL Y 3  s 66c,tjdS)NO)rYrrs r_rzMultiIndex.dtype3sxx}racHddtfd|jDS)z5return a boolean if we need a qualified .info displayc"d|vxs d|vxsd|vS)Nmixedstringunicoderirs r_fz0MultiIndex._is_memory_usage_qualified..f:s!e#Nx5'8NI.=sD1U8Dsreturnbool)r_inferred_type_levels)r]rGs @r__is_memory_usage_qualifiedz%MultiIndex._is_memory_usage_qualified7s" OD)C)CDDDrac$|j|Sr_nbytes)r]r.s r_ memory_usagezMultiIndex.memory_usage@s ||D!!rac$|jdS)z1return the number of bytes in the underlying dataFrOrs r_nbyteszMultiIndex.nbytesGs||E""rac dtfd|jD}td|jD}tfd|jD}||z|z}||jj z }|S)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* c3BK|]}|jyw)r.N)rQ)rrr.s r_rz%MultiIndex._nbytes..YsJ1>>t>4Jc34K|]}|jywr)rS)rrs r_rz%MultiIndex._nbytes..Zs81888c36K|]}t|ywrr )rrobjsizes r_rz%MultiIndex._nbytes..[sEQ9Q0EsrW)sumrr^rsr&sizeof)r]r. level_nbytes label_nbytes names_nbytesrr\s ` @r_rPzMultiIndex._nbytesLsxJdkkJJ 8TZZ88 E$**EE  ,|; $,,%%4%00 rac|jDcgc]}|j}}tdt||DScc}w)zW Formats each item in tup according to its level's formatter function. c32K|]\}}||ywrri)rfuncvals r_rz-MultiIndex._formatter_func..jsJ94T#YJr)r_formatter_funcrr)r]tuprformatter_funcss r_rfzMultiIndex._formatter_funces@?CkkJU500JJJOS0IJJJKsAnan)na_repc g}g}t|j|jD]\}}|jdd|i|}|dk(}|j rct |} |j t}tj||}|jjrJ|j}| ||<|j||j|t |dk(r.t|dj|djSt|||j |j"d} | j$S)NrjrrTrFrr^rsrrri)rrr^_get_values_for_csvrrrnstrrYrflags writeablerrAtakerNrsrr) r]rjrxrrrr level_strsmask nan_indexmis r_rmzMultiIndex._get_values_for_csvls6  #&dkk4::"> * E;222K&KFKJ"$Dxxz O '..s3 YYz6: &,,6666)..0 $- D!   j )   [ ) * z?a A++IaL9:NNP P!jj..!& B:: rac tjt|jdtt ||}t |dk(rgSg}t|j|jD]\} } ||nt| j} t | dkDrg| j| j|} | dk(} | jrvtj | t"} | | | <| j%} nEt'j(| j*| Dcgc]}t-t/|r| n|d} }|j1| g}t||j2D]d\} }g}|r |j1| t-|dnd |j5tj | t"|j1|f| t7d }|rSd }t9|t:s|t<j>usJ|d t<j>fvr|}tA|tC|| }|r,tE}|jF|g|jId S|Scc}w)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~)%warningswarnr(rb FutureWarningr)rrrr^ _get_na_reprrqformatrrYrrmtolistrrrrJr:rrsextendrrrKrrsparsify_labelsrrIadjoinsplit)r]rrrzrjrsspacesparsifyrstringified_levelsrrna formattedrsr result_levelslev_namerradjs r_rzMultiIndex.formatsS  Dz""#$, , ')    E t9>I #DKK < 1 C!-;syy3IB3x!|HH[18898M #b(88: "& AI&(IdO ) 0 0 2I #]]3;; D!tAwADVW   % %i 0' 1*  !3TZZ@ (MCE +!8JK LL#V4 5   ' (  !"89H ;=Hh-S^^1K KKE3>>22#+SZ(M  "C3::e4m4::4@ @ Ms'!I.ryc  t|dk(rgSg}t|j|jD]\}}t |j }t|dkDrl|j |x}} |jd|} |dk(} | jrvtj| t} || | <| j} nEtj|j|D cgc]} t!t#| r|n| d} } |j%| g} t||j&D]d\}} g}|r |j%| t!| dnd|j)tj|t| j%|f| t+d }|rQd}t-|t.s|t0j2usJ|t0j2ur|}t5| t7|| } | Scc} w) NrF) include_namerzrrr{rrrr)rrrr^rrrq _format_flatrrYrrmrrrrrJr:rrsrrrrKrrrr)r] include_namesrrzrrrrtakenrrsrrrrrs r_ _format_multizMultiIndex._format_multis t9>I #DKK < 1 CSYY'B3x!|$'HH[$99 !..EY.W #b(88: "& AI&(IdO ) 0 0 2I #]]3;; D!tAwADVW   % %i 0) 1,  !3TZZ@ (MCE +!8JK LL#V4 5   ' (  !"89H ;=Hh-S^^1K KK3>>)#+S%7(MEs*!Hc,t|jSr)rEr~rs r_ _get_nameszMultiIndex._get_names#s$++&&ra)rrc|t|s tdt|}|rI|"t|t|k7r td|#t||jk7r td|t |j}n|Dcgc]}|j |}}t||D]B\}}|,t|s!tt|jd||j|<D|jycc}w)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-rtr(rbr~r)r]rsrrrrrs r_rzMultiIndex._set_names&s6  \%%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(cy)NrCrirs r_ inferred_typezMultiIndex.inferred_typeusrac|jj|}|dkDrt|std|d |jj |}|S#t$r}t|st d|d||dkr@||j z }|dkrZ||j z }td|j d|d |||j k\rtd|j d |dz|Yd}~|Sd}~wwxYw) NrTz 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 )rscountr.rrKeyErrorr IndexError)r]rrerr orig_levels r_rzMultiIndex._get_level_numberys,   ' AIz%0E7"LM  JJ$$U+E$ # e$wj9:Cqy%19!&!5J$:4<<. %,&BD $,,& 6t||nE 19+' # sA C;"BC66C;c Ptd|jDrytd|jDr>t j |jDcgc]}|j ddc}Sttt|jDcgc]}|j|j}} tj|}t|jScc}wcc}w#t $r"t|jjcYSwxYw)zI Return a boolean if the values are equal or increasing. c3$K|]}d|v yw)rNri)rrs r_rz5MultiIndex.is_monotonic_increasing..s1drTz1sFc34K|]}|jywris_monotonic_increasing)rrs r_rz5MultiIndex.is_monotonic_increasing..sFu,,FrZint64r)rr^rrlibalgos is_lexsortedrnreversedrr_get_level_valuesrrYlexsortrArrt)r]rrr sort_orders r_rz"MultiIndex.is_monotonic_increasings 1djj1 1 F$++F F((8< C1'.C  8@c$++FV@W7X 23D " "1 % - -   ?F+J$<< <D  ?&>> > ?sC0!"C5)C::(D%$D%c&|dddjS)zI Return a boolean if the values are equal or decreasing. Nrrrs r_is_monotonic_decreasingz"MultiIndex.is_monotonic_decreasings DbDz111racT|jDcgc]}|jc}Scc}w)z7return a list of the inferred types, one for each level)rr)r]rs r_rLz MultiIndex._inferred_type_levelss *.5A555s%ctd|jD}t|j|dd}t ||S)Nc32K|]}t|ywrr)rrs r_rz(MultiIndex.duplicated..s63c#h6rF)sortxnull)rrrGr^r)r]keepshapeidss r_rzMultiIndex.duplicateds76$++66djj%e5I#t$$ractd)z: fillna is not implemented for MultiIndex z"isna is not defined for MultiIndex)NotImplementedError)r]valuedowncasts r_fillnazMultiIndex.fillnas""FGGrac<|jDcgc]}|dk( }}|dk(rtj|d}n+|dk(rtj|d}nt d||jDcgc]}|| }}|j |Scc}wcc}w)NrrrrUrzinvalid how option: )r^)r^rYrrrr)r]howrnansindexerrs r_dropnazMultiIndex.dropnas59ZZ@k r!@@ %<ffT*G E\ffT*G3C59: :>BjjI{['*I I~~I~..AJs B3 Bc|j|}|j|}|j|}|rtj|}tj |j ||j}|j||S)aP 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^r~runiquerrrr+)r]rrrrrrfilleds r_rzMultiIndex._get_level_valuesso"kk% jj' {{5! ,,{3Ks{{KCMMR  d 33racJ|j|}|j|}|S)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_valueszMultiIndex.get_level_valuess*`&&u-''. racn||jS|j|}|j|dS)NT)rr)drop_duplicatesrr)r]rs r_rzMultiIndex.unique,s< ='') )**51E))d)C Crac ddlm}|tjurEt |s t dt |t |jk7r td|}n|j}|s+t t|t |k7r td|tt |jDcic]}||j|c}d}||_ |r||_|Scc}w)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)rrLrrr0rtrrr_get_level_namessetrrrr)r]rrrallow_duplicatesrL idx_namesrrs r_to_framezMultiIndex.to_frame4sx % s~~ %% STT4yC ,, RI--/ICI$73y>$IT  ?DSEU?V WeUD**51 1 W # FL  Xs=C1c0t|jdS)a 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_indexzMultiIndex.to_flat_indexs8T\\77rac4|j|jk(S)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_lexsortedzMultiIndex._is_lexsortedsD""dll22racr|j |jSt|j|jS)z Compute and return the lexsort_depth, the number of levels of the MultiIndex that are sorted lexically Returns ------- int )rrr^rrs r_rzMultiIndex._lexsort_depths- >> %>> !djj$,,77rac&|jr|jr|Sg}g}t|j|jD]\}}|jsd |j }|j |}t|}tj|t|}tj||d}|j||j|t|||j |j"dS#t$r|rYVwxYw)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)rsrr)rrrrr^argsortrqr,rget_reverse_indexerrrrrtrrNrsr)r]raise_if_incomparablerrrrrris r__sort_levels_monotonicz!MultiIndex._sort_levels_monotonicsD    D$@$@K  #DKK < * C.. P!kkmG ((7+C2':G00#g,GB"'--KB"OK   c "   [ )# *&  **nn"   !,-sD DDcg}g}d}t|j|jD]o\}}tjtj |dzdkDddz }t t|xr|ddk(}t|t||zk7r|jjrt|t|k(rnd}tj|}|r-tj|dk(d}||ddg|d|dg<tjt||z} tjt||z | |<| |}|j||d}|j||j|r|j!} |r6| j#| j%|d| j'|d| S)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']]) FrTrrTNr)rrr^rYrbincountrrr:rrrrarangerqrrrrr) r]rrchangedrruniqueshas_nana_idx code_mappingrs r_remove_unused_levelszMultiIndex.remove_unused_levels#sF   #DKK <# * Chhr{{;?;a?@CaGGW<71:+;=F7|s3x&0088:>>#G C(@  ,,{3XXgm4Q7F.5vay!n.EGQq N+ "xxC6(9: (* #g,(?&(H W%*;7 hhwvw/0   c "   [ )G# *J   " " $   zE  :   i%  8 ract|jt|j|jt|jd}t j t||fdfS)z*Necessary for making this object picklable)rr^rrsN)rrr^rrsibase _new_Indexr()r]ds r_ __reduce__zMultiIndex.__reduce__{sS4;;'$**%$**%   $t*a$66ract|rtj|}g}t|j|j D]D\}}||dk(r |j tj.|j |||Ft|Sd}tj|r(tj|t}|j}n]t|tr(|j |j dkDr2|j}n%t|t"rtj|}|j Dcgc]}|| }}t%|j||j&|dScc}w)NrrrFrl)r2rcast_scalar_indexerrrr^rrYriris_bool_indexerrrKrrslicesteprArNrs)r]r=retvalrrrrs r_ __getitem__zMultiIndex.__getitem__s2 S>))#.CF$' TZZ$@ 9 [s#r)MM"&&)MM#k#&6"78  9 = I""3'jjD1 NN C'88#sxx!| $IC'jjo=AZZHkS)HIH{{jj#!&  Is? E1cd}|j|jdkDr |j}|jDcgc]}|| }}t||j||j |dScc}w)zH Fastpath for __getitem__ when we know we have a slice. NrFrl)rrr^r(rr~)r]slobjrrrs r__getitem_slicezMultiIndex._getitem_slicesr :: aI;?::FK['F FtDz;;++"   Gs A0rqc tjd|t|}|j|||}d}|jDcgc]}|j |}}|rK|dk(} | j r6g} |D]-} | } || | <| jtj| /| }t|j||jdScc}w)NrirFrr^rsr) nv validate_taker,_maybe_disallow_fillr^rqrrrYrrNrrs) r]indicesrV allow_fillrrxna_valuelabrrsmasked new_label label_valuess r_rqzMultiIndex.takes V$%g...z:wO .2jj9s'"99 b=Dxxz!&>> mi = pd.MultiIndex.from_arrays([['a'], ['b']]) >>> mi MultiIndex([('a', 'b')], ) >>> mi.append(mi) MultiIndex([('a', 'b'), ('a', 'b')], ) c3tK|]/}t|txr|jjk\1ywr)rrNr)ror]s r_rz$MultiIndex.append..s2 JKZ: & D199 +D D s58Frc3BK|]}|jk7ywrrs)rrur level_names r_rz$MultiIndex.append.. sARrxx{j0ArXN)r^rrsrc34K|]}|jywrrrks r_rz$MultiIndex.append.. s+E!AII+ErZ)rrrrrrrunionr?r^rsrrrYr#rNrrrtrrA) r]otherr^rrs level_valuesrur to_concat new_tuplesrrs ` @@r_rzMultiIndex.appends.%$/GE  OT  EFE4<<( )#{{1~ DB#/#5#5biil#CLD !%~u~ * RYYq\>> 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']) rmrrTrzYdropping on a non-lexsorted multi-index without a level parameter may impact performance.rwzunsupported indexer of type ignore)_drop_from_levelrrYrrArindex_labels_to_arrayrrr:rrrrrrrstoprrrrr$r)nonzeror(AssertionErrorrdelete) r]r^rerrorsindsrlocrmsgs r_dropzMultiIndex.drop3 sh  ((v> >%"**e!45 11%rxx?QR  K ll;/c3'KK$U+'*xx';388DKKcii4 @A((-**a/ P.'7'9  ++-*CKK$8c DC(--- 6{{4  ?  6 X%& s$*F*DF" FF"F54F5ctj|}|j|}|j|}|j |}t |}d|t j|d|dk(z<|jd|jdk(rd|t j|d<||dk(}t|dk7r|dk7rtd|dtj|j||} || S) NFrrTr$zlabels z not found in level)rr&rr get_indexerr:rYequalrrrrisinr^) r]r^rr+rrr nan_codes not_foundrss r_r%zMultiIndex._drop_from_level s))%0  " "5 ) A""5)K @BE*v|<= ;;q>TZZ] *02F288It, -&B,' y>Q 6X#5WYK/BCD D 4::a=&11DzracHt|j}t|j}t|j}|j |}|j |}||||c||<||<||||c||<||<||||c||<||<t |||dS)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')], ) Fr)rrr^rsrrN)r]rjrr new_namess r_ swaplevelzMultiIndex.swaplevel sV$++& $ $  " "1 %  " "1 %'1!}jm$ 1 z!}%.q\9Q<" ! il%.q\9Q<" ! ilYiRW  racn|Dcgc]}|j|}}|j|}|Scc}w)aI 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_levelszMultiIndex.reorder_levels s=@5::q''*::&&u- ;s2c^t||jk7r$td|jdt||Dcgc]}|j|}}|Dcgc]}|j|}}|Dcgc]}|j |}}t |||dScc}wcc}wcc}w)Nz2Length of order must be same as number of levels (z), got Fr)rrr)rr^rsrN)r]r=rrrr9s r_r<zMultiIndex._reorder_ilevels s u: % DT\\NS5zl$ /44dkk!n4 4,12qTZZ]2 2,12qTZZ]2 2YiRW  522sB B%9B*c#Kt||jkDr%tdt|d|jdtt|D]0}t |j ||j ||||2yw)NzLength of new_levels (z) must be <= self.nlevels ()r)rrr)rr?r^r)r]rrrs r__recode_for_new_levelsz!MultiIndex._recode_for_new_levels s z?T\\ ) (Z(9:,,0LL>< s:' A' 1 t{{1~z!}4  sBBc d}|jDcgc]!}tj|||dd#c}Scc}w)a  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 ctjt|r&tj|j dznd|j S)NrTrr)rYrrrrr)rs r_catsz/MultiIndex._get_codes_for_sorting..cats% s?9936{3C%))+a/!'' raTFr)r^r< from_codes)r]rErs r_rz!MultiIndex._get_codes_for_sorting sD  $zz   " ";[0A4RW X   s&;ct|s|g}|Dcgc]}|j|}}d}|Dcgc]}|j|}}t|tr"t |t |k(s`t d|rN|jtt |jDcgc]}||vs|j|c}n|d}t|||d}t|}|jD cgc]} | j|} } t| |j|j|d} | |fScc}wcc}wcc}wcc} w)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)ordersrrF)r^rrsrr)r0rr^rrrrrrrrHr,rqrNrs) r]r ascendingsort_remainingrrrr^rrrr4s r_ sortlevelzMultiIndex.sortlevel0 sO~E"GE49 ,/D " "3 '   ,12SC22 i &u:Y/ !KLL  LL,1#dkk2B,CXSsRWGWCX aI! )$ &g.BF**M;[%%g.M M;;**"  '!!A 3YNsD<E* E4E:E ct|ts@||}n;|dk\jr|j|}n tj |}|j ||}|S#t $r|cYSwxYwr)rrNrrqrrt_maybe_preserve_names)r]rrpreserve_namess r__wrap_reindex_resultzMultiIndex._wrap_reindex_result sx&*-Q,##%7+"'33F;F ++FNC !"!M"sA%% A32A3c|rU|j|jk(r<|j|jk7r#|jd}|j|_|S)NFrW)rrsr)r]rrNs r_rMz MultiIndex._maybe_preserve_names sE $,,.  *[[e[,F::FL racFt|r t|r t|yr)r-r/r#r<s r__check_indexing_errorz MultiIndex._check_indexing_error s#3;s#3$C( ( $4rac4|jdjS)zA Should integer key(s) be treated as positional? r)r_should_fallback_to_positionalrs r_rTz)MultiIndex._should_fallback_to_positional s {{1~<<t|dt s+|j |}|j||||||fSt|%||Sr) rrArrrr_get_indexer_level_0_raise_if_missingsuper_get_indexer_strict)r]r= axis_namekeyarrr __class__s r_rYzMultiIndex._get_indexer_strict s{&%(**62F v;z&)U;//7G  " "3 ;=') )w*3 ::rac|}t|tstj|}t |r{t|dt sh|dk(}|j rR|jdj|}|dk(}|j rt||dt|dyt|-|||S)Nrrz not in index) rrArrrrrrr2rrXrW) r]r=rrZr[rscheckcmaskr\s r_rWzMultiIndex._raise_if_missing s#u%**3/F v;z&)U;b=Dxxz A226: 99;"fUm_M#BCC&7887,S'9E Erac|jd}|jd}tj||d}t |}|j |S)z] Optimized equivalent to `self.get_level_values(0).get_indexer_for(target)`. rF)r^ categoriesr)rrr<rFrAget_indexer_for)r]rrr^catcis r_rVzMultiIndex._get_indexer_level_0 sLkk!n A$$5S5Q 3Z!!&))racNt|ts|f}|j||S)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]labelrgs r_get_slice_boundzMultiIndex.get_slice_bound s,`%'HE&&u4&88rac&t||||S)aL 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. )rX slice_locs)r]rendrr\s r_rlzMultiIndex.slice_locs# sjw!%d33ract||jkDr%tdt|d|jdt|}dt|}}t||j|j }t |D]R\}\}} } | ||} || vrit|s^ tj| ||} t| std||dk(r | dk\r| dz} |tj| | |zcS|j| |}t|tr!||dz kr|j}|j }||dz kr7|tj| |dz}|tj| |d z}t|tr)|j}|tj| ||zcS|tj| ||zcSy#t$r} td|| d} ~ wwxYw) N Key length (z-) was greater than MultiIndex lexsort depth (rArrfzLevel type mismatch: rightrTleft)rrr%rrr^ enumerater:r searchsortedrtr._get_loc_single_level_indexrrrr')r]rgrgnrrmzippedrrrrsectionr-rr s r_rhzMultiIndex._partial_tup_indexZ s  s8d)) )$s3xj)''(+  HD sS$++tzz2*3F*;' K &A&S+!%,G#~d3iL,,S#DAC"##&;C5$ABB7?sax1HCu11'3TJJJ223d3i&&s+ +rac j|fd}t|tsj|d}||St |}j |krt d|dj d|j k(r(jr jj|Sj}|d|||d} }|sd} t } n j||\} } | | k(r t || s t!| | St#j$dt&t) t+j,| | t*j. }t1| t |D]b\}} j2||j5j6|| k(} | j9s|| }t |rYt |t || | z k7r||St!| | S#t $r}t ||d}~wt$r6j|ttj \}}|cYSwxYw#t$r}t ||d}~wwxYw) 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 cHt|tjr|jtjk7r|St j |t}t|tr|Stjtd}|jdd||<|S)z._maybe_to_slice sxc2::.#))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) rFrT)rrrr_get_loc_levelrr.)r]r=r drop_levelrr-rus r_rzMultiIndex.get_loc_level sR%$/**51E.maybe_mi_droplevels] s> W IFD1 ?%991#>  ? raz:Key for location must have same length as number of levelsNrFrTrc3<K|]}t|tywr)rrrs r_rz,MultiIndex._get_loc_level.. s9z!U+9sz'Expected label or tuple of labels, got )rrrrr)rrrrYrrKrrrrtr#rrrr&r:rrr.rn!_supports_partial_string_indexingrrr is_null_slice is_full_slice)r]r=rrrrrr-r4rsrurrrilevels loc_levelk_indexr^ result_indexs` r_rzMultiIndex._get_loc_levelW s  eeT] +3x3u:%$PFeS/ AQ!%!4!4Qc!4!BYc5)88CIT:D $DIC &FSL  A ")7 2:  c4 *C c5 !eqj $++a.("55c5GG 3GaS AI"I--)9S99s8t||+ $ 4 4S 94@@,,s+&+CHoUQ5tCT9T1UUw<4<</!'*&},"'s3x *3q63 7#';;q>#S#SFeD$&77 G7|t||3"$ 3GW EEE%cN+DAq%a/$($;$;AQ$;$G %i7"00;s?P?P )3t9@!)')hhs4y&EG15GI.'0G**1- (*QRUQV(WXX")7*;+<?#D$/G&+CHoUQ5tCT9T1UU 3GW EEE--c-?G3$KK&HH E*2237!%("DM11 -27UGD L( (_ "&\2:   "$01  $5&sm4$V`V  -#G} L( ( -ss0 P01PP5Q7Q:AQ"$Q'<Q': Q,PPP21P25 Q> Q  QQ,R?Rc|j|}|j|}||fd}t|trW|j}|duxr|dk} |j |j |j } n|rt|dz } nd} |j|j |j} n/|rd} n*t| tr t|} nt|dz } t| tst| tr$t| d| } t| d| } || | |S|dkDs|jdk(s||r| dz n| dz} || | |Stj|| d} tj|| d} t| | |S|j||} |dkDs|jdk(rlt| tr!|| j k\|| jkz}|St!j"|| k(t$ }|j's t||St| trEtj|| j d} tj|| jd}n0tj|| d} tj|| d}| |k(r t|t| |S#t$rC|j|j |j|jx} } | j}Y+wxYw) Nc|||}||dk(r ||k\||kz}n9tj||||j}tj||}||S|j }|||<|S)NrTr)rYrrrr4r)rr'rrr^ new_indexerrs r_convert_indexerz6MultiIndex._get_level_indexer..convert_indexer s"g|tqy$~%$,? IIeT4u{{C#jj2 ""llnG*GG NrarrTrr'rqrfrpr)rr^rrrrr:rr'r slice_indexerrrrrsrtrYrrKr)r]r=rrryrrris_negative_steprr'rr8r locsrms r_rzMultiIndex._get_level_indexer skk%( jj' 7>k , c5 !88D#4/ |j||| }|tj*gtj, cStj.|r;|8|t|d z k(r'tj0 tj, cS|j||| }||}||}||z}tj |r6tj |sMt#||%tj*gtj, S|j3d } |j5|| Scc}}w#tt t"f$rY} |D]I} t%| s| |j| || } | || }/t'| t(rd || <E|| z}KYd} ~ d} ~ wwxYw)a 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) rzIMultiIndex slicing requires the index to be lexsorted: slicing on levels z, lexsort depth c3,K|] }|tuywr)Ellipsisrs r_rz&MultiIndex.get_locs.. s*qH}*sz2MultiIndex does not support indexing with Ellipsisct|tr,tjtj}d||<|S|S)NrT)rrrYrbool_)rrrus r__to_bool_indexerz-MultiIndex.get_locs.._to_bool_indexer s6'5) hhq9 '+ G$""NraNzLcannot index with a boolean indexer that is not the same length as the index)rrTrrTrrJnpt.NDArray[np.bool_])rrris_true_slicesrr%rrrrrrYrrr0rr#rtrr-rrrr!rrr(_reorder_indexer)r]seqrs true_slicesrrr lvl_indexerrr item_indexer pos_indexerrus @r_get_locszMultiIndex.get_locs] sH(11C1CC1H'IOVaQqO O ;r?d.A.AA$(M)9$:M:M9NP  *c* *%D  I 15cN@ (DAq@DK""1%q6Q;$>!jjm ?"-"2"2"4Ka8"&"9"9!1g"9"VK0&88Bbgg66""1%?qCHqL'899Qbgg66#55aq'5R +;7K%;&vvg266++>"3-'A@ (F ?88Bbgg. .oo'* $$S+66PV*9h?8 8*1~"%I(,'>'>Q(?( '.*:<*HK' e<8>> 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 < beforerFr)rrrlrr^rNr~) r]beforeafterrr8rqrprrrs r_truncatezMultiIndex.truncate<s4 V-. .{{1~((71oofe4 e$++& "1 a* 1 @D K[e,K K |a' ! ++"   Ls: B,c|j|ryt|tsyt|t|k7ryt|ts2|j |syt |j|jS|j|jk7ryt|jD]'}|j|}|j|}|dk(}|dk(}tj||sy||}|j|jj|}||}|j|jj|}t|dk(rt|dk(rt|tjs|j!|ryt|tjs|j!|ryt ||r(yy)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^rY array_equalrrqrequals) r]rr self_codes other_codes self_mask other_mask self_values other_valuess r_rzMultiIndex.equalsis 88E?%' t9E "%,''.#DLL%--@ @ <<5== (t||$ !AAJ++a.K"b(I$*J>>)Z8#YJ/J++a.0055jAK%zk2K <<?2277 DL ;1$\):a)?k2::6")),7  bjj9#**;7 ' \B = !@rac|j|jk7ryt|jD]/}|j|j|j|r/yy)zT Return True if the levels of both MultiIndex objects are the same FT)rrrr)r]rrs r_ equal_levelszMultiIndex.equal_levelssU <<5== (t||$ A;;q>((a9 rac|j|\}}|jr@t| ||}t |t r|St j t|d|S|j|d}t|r|j|}n|j|}|dur |j}|S|S#t$r-|durtjdt t#Y|SwxYw)NrFrTzTThe values in the array are unorderable. Pass `sort=False` to suppress this warning.rw)_convert_can_do_setophas_duplicatesrX_unionrrNrr differencerr_get_reconciled_name_object sort_valuesrtrrRuntimeWarningr))r]rr result_namesr right_missingr\s r_rzMultiIndex._unions"88?|   W^E40F&*- ))V L*  ",,T,>M=!]399%@5  #//1FM6M!t|MMF#5  Ms(B<<2C21C2ct|Sr)r1)r]rs r__is_comparable_dtypezMultiIndex._is_comparable_dtypes u%%rach|j|}|j|k7r|j|S|S)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_namesrsrename)r]rrss r_rz&MultiIndex._get_reconciled_name_objects4 ''. :: ;;u% % rac2t|jt|jk7rdgt|jzSg}t|j|jD]-\}}||k(r|j||jd/|S)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)rrsrr)r]rrsa_nameb_names r_rzMultiIndex._maybe_match_namess tzz?c%++. .6C O+ +!$**ekk: #NFF V$ T"  #  racL|j|\}}|j|Sr)r set_namesr]rrrrs r__wrap_intersection_resultz$MultiIndex._wrap_intersection_results'44U;< --rac|j|\}}t|dk(r|jj|S|j|Sr)rrrrrs r__wrap_difference_resultz"MultiIndex._wrap_difference_resultsM44U;< v;! ..0::<H H##L1 1rac.|j}t|tsGt|dk(r|dd|jfSd} tj ||j}||fSt||}||fS#t tf$r}t||d}~wwxYw)Nrz.other must be a MultiIndex or a list of tuplesr ) rsrrArrNrrrtrD)r]rrr.rs r_rz MultiIndex._convert_can_do_setopszz %'5zQBQx++F2&225 2KEl""/tU;Ll""#I.2$C.c12s!A44B BBct|}t|tr d}t|t |s t d|dur|j S|S)Nz3> 1 ndim Categorical are not supported at this timezISetting a MultiIndex dtype to anything other than object is not supportedT)r3rr4rr1rtr)r]rrr.s r_rnzMultiIndex.astypes[U# e- .GC%c* *u%#  4<::<  ract|tr0|j|jk7r td|jSt|t s|fd|jdz zz}|St ||jk7r td|S)Nz0Item must have length equal to number of levels.)rrT)rrNrrrrr)r]items r__validate_fill_valuezMultiIndex._validate_fill_value)s dJ '||t||+ !STT<< D%(7UdllQ&677D Y$,, &OP P rac>t||\}}|r|jSt|t|k(r||j}n|j}g}g}t t |j |j |jD]n\}\}} } | j|d} | j|j|} t| } | | |<|j| |j| pt|||jdS)a 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 Frr)r;rrrrrrrr^rrbrr+rrNrs)r]rsrnoopsubsetrrr value_levelrr new_level value_codesnew_codes r_putmaskzMultiIndex.putmask7s&dD1 d 99;  t9E "4[557F//1F  4=  t{{DJJ 75  ' 0A0 UK Ke  >((/C((-DyyA~xxD ::99V$ $ra__add____radd____iadd____sub____rsub____isub____pow____rpow____mul____rmul__ __floordiv__ __rfloordiv__ __truediv__ __rtruediv____mod____rmod__ __divmod__ __rdivmod____neg____pos____abs__ __invert__)NNNNNFNT)rrKrrKrJr)rrrr)NNN)r^ list | Nonerr rzlist[int] | range | None)rrrs-Sequence[Hashable] | Hashable | lib.NoDefaultrJrNr/)rzIterable[tuple[Hashable, ...]]rrrs$Sequence[Hashable] | Hashable | NonerJrN)rzSequence[Iterable[Hashable]]rrrsr rJrN)rrLrrrsrrJrN)rJ np.ndarray)rJrM)rJr)rJrE)rrKrrKrrKrJNone)rrKrJrN)rJr )rJzCallable[..., MultiIndex])rrrJrN)rJrN)NFN)r.rKrJrr)rJr)r=r rJrK)rJznp.dtyperIF)r.rKrJr)rjrnrJznpt.NDArray[np.object_])NNNFNT)rrz bool | NonerzCallable | Nonerjz str | NonersrKrrrrKrJr)rrKrzbool | None | lib.NoDefaultrzrrJr)rrK)rJrn)rJz list[str])first)rrrJr)r)rrrJrN)rrrrKrJrA)rJrA)rrKrrKrJrL)rrKrJrN)r]rNrrrJrN)rTN)r]rNrVrrrKrJrN)rrnrJnpt.NDArray[np.intp])r"rrJrN)Nraise)rz.Index | np.ndarray | Iterable[Hashable] | Noner+rrJrN)r)r+rrJrN)r1r)T)rrKrJz!Generator[np.ndarray, None, None])rJzlist[Categorical])rTTr) rrrIzbool | list[bool]rJrKrrnrJz'tuple[MultiIndex, npt.NDArray[np.intp]])rNrK)rrArNrKrJrA)rJr)rZrnrJz"tuple[Index, npt.NDArray[np.intp]])rZrnrJr)rJr)rizHashable | Sequence[Hashable]rgLiteral['left', 'right']rJr)rJztuple[int, int])rq)rgrrgr)ryrAr=rrJr)rT)rrrrK)r)rzint | list[int])rN)rrrznpt.NDArray[np.bool_] | None)rz,tuple[Scalar | Iterable | AnyArrayLike, ...]rrrJr)rrmrJrK)rrNrJrK)rrrJrK)rrNrJrN)rrK)rrNrJrN)r-rrJrNr)rbrcrdrerA _hidden_attrs frozenset_typr~__annotations__rErr _comparablesrrr classmethodrrrr{rrrr'rpropertyrrrrrrrr rrr^rrr&r)r(r+rrr6rr>rrMrQrSrPrfrmrrrrrsrrrrrLr _duplicatedrrrrrrrrrrrrrrr&rB_index_doc_kwargsrqrrrr/r%r:r>r<rBrrKrOrMrRrTrYrWrVrjrlrhrtr:rrrrrrrrrrrrrrrrnrrrr*r4rrrFrrrrrrrrrrrrrrrrrrrr r r  __classcell__)r\s@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 29j54n1Kf,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 .Jrac|Dcgc] }t|}}t|ddD]}tj|d|s|cSycc}w)zJCount depth (up to a maximum of `nlevels`) with which codes are lexsorted.rrN)r+rrr)r^rr int64_codesrs r_rrsV@EF< ,FKF 7Ar "  Ra 1H GsActt|}t|}|d|dz}||}||dzdD]}g}tt||D]q\} \} } | |dz k(r$|j | |j |n?| | k(r|j |L|j || d|j |n|}tt|S)NrT)rrrrrrr) label_listrrpivotedrrprevcur sparse_currpts r_rrs3 #$G JA [uqy !F 5>Duqy{# "3tS>2 IAv1AEz!!!$ j)Av!!(+!!#ab'* j) "), V ract|tr |jS|j}tj dtj dij|dS)NNaTNaN)rr5rr(rY datetime64 timedelta64get)r dtype_types r_rrsF%(..!"ZZ MM5"..% 8 < r?pandas.core.commoncommonrpandas.core.constructionr@pandas.core.indexes.baseindexesbaserrArBrCrDpandas.core.indexes.frozenrEpandas.core.ops.invalidrFpandas.core.sortingrGrHpandas.io.formats.printingrIrJrrKrLrMdictr updateBaseMultiIndexCodesEnginergrRrorkr{rNrrrr5rr rirar_ras}"% .    /  58   7 '&<! 3(( 23   001,JK $38==x?T?T$3N&3H>>@U@U&3R&_;/_;/Dw @PB.ra