B W0d@sddlmZddlmZddlmZddlmZmZm Z m Z m Z m Z m Z mZmZmZddlZddlZddlmZddlmZmZmZddlmZdd lmZm Z m!Z!m"Z"dd l#m$Z%dd l&m'Z'm(Z(m)Z)dd l*m+Z+m,Z,m-Z-m.Z.dd l/m0Z0ddl1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;ddlm?Z?m@Z@mAZAddlBmCZCmDZDddlEmFmGZddlHmIZIddlJmKZKddlLmFmMZNddlOmPZPddlQmFmRmSZTddlQmUZUmVZVmWZWmXZXddlYmZZZddl[m\Z\ddl]m^Z^ddl_m`Z`maZambZbddlcmdZder"ddlemfZfmgZgmhZheieTjjZjejkdddGdd d ejlejmZnGd!d"d"ejlejoZpd#d$ZqGd%ddeUZrd&d'd'd(d)d*Zsd@d'd,d-d.Ztd/d0d1d2Zud3d3d4d5d6ZvdAd8d9d:d;d<Zwd/d=d>d?ZxdS)B) annotations)wraps) getsizeof) TYPE_CHECKINGAnyCallable CollectionHashableIterableListSequenceTuplecastN) get_option)algosindexlib) duplicated) AnyArrayLikeDtypeObjScalarShape)function)InvalidIndexErrorPerformanceWarningUnsortedIndexError)Appendercache_readonlydeprecate_nonkeyword_argumentsdoc)coerce_indexer_dtype) ensure_int64ensure_platform_intis_categorical_dtype is_hashable is_integer is_iterator is_list_likeis_object_dtype is_scalar pandas_dtype)ExtensionDtype) ABCDataFrameABCDatetimeIndexABCTimedeltaIndex)array_equivalentisna) Categorical)factorize_from_iterables)is_empty_indexer)Index_index_shared_docs ensure_indexget_unanimous_names) FrozenList) Int64Index)make_invalid_op)get_group_indexindexer_from_factorizedlexsort_indexer) pprint_thing)CategoricalIndex DataFrameSeries MultiIndexzMultiIndex or list of tuples)klassZ target_klassc@seZdZdZejZddZdS)MultiIndexUIntEngineza This class manages a MultiIndex by mapping label combinations to positive integers. cCs0||jK}|jdkr tj|Stjj|ddS)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_orreduce)selfcodesrNK/var/www/html/venv/lib/python3.7/site-packages/pandas/core/indexes/multi.py_codes_to_intsts   z#MultiIndexUIntEngine._codes_to_intsN)__name__ __module__ __qualname____doc__libindex UInt64Engine_baserPrNrNrNrOrDlsrDc@seZdZdZejZddZdS)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. cCs6|d|j>}|jdkr&tj|Stjj|ddS)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). objectrE)rF)astyperGrHrIrJrK)rLrMrNrNrOrPs  z$MultiIndexPyIntEngine._codes_to_intsN)rQrRrSrTrU ObjectEnginerWrPrNrNrNrOrXsrXcstfdd}|S)z A decorator to allow either `name` or `names` keyword but not both. This makes it easier to share code with base class. cs@d|krd|krtdnd|kr0|d|d<|f||S)Nnamenamesz*Can only provide one of `names` and `name`) TypeErrorpop)Z self_or_clsargskwargs)methrNrOnew_meths  znames_compat..new_meth)r)rbrcrN)rbrO names_compats rdc sD eZdZUdZejeBZdZeZ eZ eZ dgZ de d<dLd d d d Zd d dddZdMdddddZedejfddddZeedNdddddddZedejfddddZedOddd d!d"Zed#dd$d%Zed#dd&d'Zed(d)Zed*dd+d,Zd-dd.d/Zed0dd1d2Z dPd d d d3d4d5d6Z!e"dd7d8gd9dQd d d:d;Z#ed-dddd?d@Z%edAdBZ&dRd d d d3d4dCdDZ'e"dd7dEgd9dSd d dFdGZ(edHdIZ)edJddKdLZ*e+ej,ejfd#ddMdNdOZ,dddPdQZ-dTdRdSZ.dUd#ddTdUZ/dVdVdWZ0e+ej1dXd dYdZd[Z1ed\dd]d^Z2d dd_d`Z3e+ej4dWd d-dadbdcZ4ed-ddddeZ5dXd d-dadfdgZ6dhdiZ7dYdkdlZ8dZdndodpd d-d d dqdrdsZ9d0ddtduZ:d[d dvdwdxZ;ee;e:dydzZd-dddZ?ed dddZ@ed dddZAed dddZBeddddZCe+ejDd\d#dddZDeDZEd]ddZFe+ejGd^d}ddddZGd_d-d ddddZHddZIe+ejJd`fdd ZJdad ddddZKddddZLed dddZMd dddZNd dddZOeddZPed-dddZQddddZRddddZSddZTddZUddddddZVeWeXdeYdbdd-d ddddZZddZ[d#dddZ\eWeXdeYdcd-ddddÄZ]ddddƄZ^deddddȄZ_dfdddd̄Z`dddd΄ZaddddфZbdgd d ddӜddՄZcdhdddd؄ZdddڄZed ddd܄Zfd*dݜdd߄ZgddddZhddZididdpdd#dddZjdjdd}dpd-dddZkdkfdd ZldlddddZmddd-dddZndmddZodnd dddZpdodd dddZqdpd-dddZrddZsdddddd Ztdqddd d Zud d d ddZvdd d ddZwddfdd Zxdd dddZyddddZzddZ{ddZ|ddfdd Z}d d!Z~e+ejdrd d"d#d$Zd%d&Zd-dd'd(d)Zddd*d+Ze+ejdsd#dd,d-Ze"dd7dgd9dtd d.d/fd0d1 ZeZe"dd7gd9dud2dd3fd4d5 Zed6Zed7Zed8Zed9Zed:Zed;Zed<Zed=Zed>Zed?Zed@ZedAZedBZedCZedDZedEZedFZedGZedHZedIZedJZedKZZS(vrBa 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 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_locs 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. Z multiindexr]z int | None sortorderNFTbool)verify_integrityc Cs|dk r |}|dks|dkr$tdt|t|krsz0MultiIndex._verify_integrity..z On level z , code max (z) >= length of level (z/). NOTE: this index is in an inconsistent stater~z, code value (z) < -1zLevel values must be unique: z on level NzQValue for sortorder must be inferior or equal to actual lexsort_depth: sortorder z with lexsort_depth csg|]\}}||qSrN)r)rr|r})rLrNrOrs)rMrwrjrk enumeratezipmaxmin is_uniquer{re_lexsort_depthnlevelsr8)rLrMrwZ codes_lengthir| level_codesrzrN)rLrOrsos2    " zMultiIndex._verify_integrity)returnc Csd}t|st|nt|r&t|}x|D]}t|s,t|q,Wx:tdt|D](}t||t||dkrTtdqTWt|\}}|tj krdd|D}|||||ddS)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.rEzall arrays must be same lengthcSsg|]}t|ddqS)r\N)getattr)rarrrNrNrOrsz*MultiIndex.from_arrays..F)rwrMrer]rg) r'r^r&r{rangerjrkr2r no_default) rvarraysrer] error_msgarrayrrMrwrNrNrO from_arrayss(%      zMultiIndex.from_arrayszIterable[tuple[Hashable, ...]]zSequence[Hashable] | None)tuplesrer]rcCst|stdnt|r"t|}ttttdf|}t|dkrd|dkrTtdggt|}nnt |t j t frt |t rt |j}tt|j}n6t |trtt|j}nt|}tttt|}|j|||dS)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..rNz-Cannot infer number of levels from empty list)rer])r'r^r&r{rrr r rj isinstancerIndarrayr4asarray_valuesrZtuples_to_object_arrayTZto_object_array_tuplesrr r r)rvrrer]rZarrsrNrNrO from_tupless$+     zMultiIndex.from_tuplescCsjddlm}t|stdnt|r.t|}t|\}}|tjkrRdd|D}||}|||||dS)a 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. .. versionchanged:: 1.0.0 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']) r)cartesian_productz-Input must be a list / sequence of iterables.cSsg|]}t|ddqS)r\N)r)ritrNrNrOrisz+MultiIndex.from_product..)rer]) Zpandas.core.reshape.utilrr'r^r&r{r2rr)rv iterablesrer]rrMrwrNrNrO from_product2s.    zMultiIndex.from_productr@)dfrcCsBt|tstdt|\}}|dkr.|n|}|j|||dS)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 DataFrameN)rer])rr,r^ritemsr)rvrrer]Z column_namescolumnsrNrNrO from_frameos 9 zMultiIndex.from_framez np.ndarraycCsg}xvt|jD]h}||}t|jrsz%MultiIndex.dtypes..)pandasrArrw)rLrArNrNrOdtypess zMultiIndex.dtypesrrcCst|jdS)Nr)rjrM)rLrNrNrO__len__szMultiIndex.__len__r8cCs4ddt|j|jD}x|D] }d|_qWt|S)NcSsg|]\}}|j|dqS))r\)Z_rename)rxr\rNrNrOrsz%MultiIndex.levels..T)r_levelsrpZ_no_setting_namer8)rLryr|rNrNrOrws  zMultiIndex.levelsNone)rhrirgrc s|rVt|dkrtd|dkr6t|jkr6td|dk rVt|t|krVtd|dkrvtfdd|D}nPfdd|D}tj}x*t||D]\} } t| d || <qWt|}|r܈j |d } | _ j } |_t | r | dS) 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.c3s|]}t|dVqdS))rhN)r6_view)rlev)rhrNrO sz)MultiIndex._set_levels..csg|]}|qSrN)_get_level_number)rr)rLrNrOrsz*MultiIndex._set_levels..)rh)rw)rjrkrr8r{rrr6rrsrtr]rrq _reset_cache) rLrwr|rhrirg new_levels level_numbersZnew_levels_listlev_numrrzr]rN)rhrLrOrns.     zMultiIndex._set_levelsrLrw)versionZ allowed_argscCs|dk rtjdtddnd}t|r8t|ts8t|}t||d\}}|rR|}n|}| |j ||d|d|s||SdS) 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). inplace : bool If True, mutates in place. .. deprecated:: 1.2.0 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"), ... (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]]) Nz>inplace is deprecated and will be removed in a future version.) stacklevelFZLevelsT)r|rirg) warningswarn FutureWarningr'rr4r{_require_listlikerrurn)rLrwr|inplacergrrNrNrO set_levels"s"X zMultiIndex.set_levelscCs 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 )rjr)rLrNrNrOrszMultiIndex.nlevelsrcCstdd|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) css|]}t|VqdS)N)rj)rrrNrNrOrsz&MultiIndex.levshape..)tuplerw)rLrNrNrOlevshapeszMultiIndex.levshapecCs|jS)N)rt)rLrNrNrOrMszMultiIndex.codesc s|rB|dkr"t|jkr"td|dk rBt|t|krBtd|dkrjtfddtj|D}nXfdd|D}tj}x2t||D]$\} } j| } t | | d|| <qWt|}|r҈j |d}|_ dS) Nz+Length of codes must match number of levelsz,Length of codes must match length of levels.c3s$|]\}}t||dVqdS))rhN)_coerce_indexer_frozenview)rrr)rhrNrOrsz(MultiIndex._set_codes..csg|]}|qSrN)r)rr)rLrNrOrsz)MultiIndex._set_codes..)rh)rM) rjrrkr8rrr{rtrwrrsr) rLrMr|rhrirgrzrZnew_codes_listrrrrN)rhrLrOros(    zMultiIndex._set_codesrMcCsd|dk rtjdtddnd}t||d\}}|r8|}n|}||j|||d|s`|SdS)a Set new codes on MultiIndex. Defaults to returning new index. Parameters ---------- codes : sequence or list of sequence New codes to apply. level : int, level name, or sequence of int/level names (default None) Level(s) to set (None for all levels). inplace : bool If True, mutates in place. .. deprecated:: 1.2.0 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']) Nz>inplace is deprecated and will be removed in a future version.r)rFZCodes)r|rg)rrrrrruro)rLrMr|rrgrrNrNrO set_codess< zMultiIndex.set_codescCsttdd|jD}t|dddddd}t|dddggd}|ddkrtt|j|j|St |j|j|S)NcSsg|]}t|dqS)rE)rj)rr|rNrNrOr5sz&MultiIndex._engine..r~rEruint64@) rIceillog2rwZcumsum concatenaterZrXrMrD)rLsizesZlev_bitsrGrNrNrO_engine1s  zMultiIndex._enginezCallable[..., MultiIndex]cCs t|jS)N)typer)rLrNrNrO _constructorGszMultiIndex._constructor)rrcCs(|tjk r|n|j}t|j|d|dS)N)rer])rrr]rr)rLrr\r]rNrNrO _shallow_copyKszMultiIndex._shallow_copycCs<t||j|j|j|jdd}|j|_|jdd|S)NF)rwrMrer]rgrw)rrwrMrer]rmrhr_)rLryrNrNrOrQs zMultiIndex._viewc Cs|j|||d}|dk r(tjdtdd|dk r@tjdtdd|rtddlm}|dkrb||j}|dkrt||j}|dk r|n|j}|dk r|n|j}t||||j |d d }|j |_ |j d d|rtjd tdd| |}|S) ae Make a copy of this object. Names, dtype, levels and codes can be passed and will be set on new copy. Parameters ---------- names : sequence, optional dtype : numpy dtype or pandas type, optional .. deprecated:: 1.2.0 levels : sequence, optional .. deprecated:: 1.2.0 codes : sequence, optional .. deprecated:: 1.2.0 deep : bool, default False name : Label Kept for compatibility with 1-dimensional Index. Should not be used. Returns ------- MultiIndex Notes ----- In most cases, there should be no functional difference from using ``deep``, but if ``deep`` is passed it will attempt to deepcopy. This could be potentially expensive on large MultiIndex objects. )r\r]deepNzjparameter levels is deprecated and will be removed in a future version. Use the set_levels method instead.)rzhparameter codes is deprecated and will be removed in a future version. Use the set_codes method instead.r)deepcopyF)rwrMrer]rgrwzeparameter dtype is deprecated and will be removed in a future version. Use the astype method instead.) Z_validate_namesrrrrhrrwrMrrermr_rZ) rLr]rxrwrMrr\r new_indexrNrNrOrh_sD'     zMultiIndex.copycCs|jS)z%the array interface, return my values)r)rLrxrNrNrO __array__szMultiIndex.__array__cCs|}|j|_|S)z0this is defined as a copy with the same identity)rh_id)rLrvryrNrNrOrszMultiIndex.viewr)keyrc Cs6t|y||dStttfk r0dSXdS)NTF)hashget_loc LookupErrorr^rk)rLrrNrNrO __contains__s  zMultiIndex.__contains__znp.dtypecCs tdS)NO)rIrx)rLrNrNrOrxszMultiIndex.dtypecs ddtfdd|jDS)z5return a boolean if we need a qualified .info displaycSsd|kpd|kpd|kS)NmixedstringunicoderN)r|rNrNrOfsz0MultiIndex._is_memory_usage_qualified..fc3s|]}|VqdS)NrN)rr|)rrNrOrsz8MultiIndex._is_memory_usage_qualified..)r_inferred_type_levels)rLrN)rrO_is_memory_usage_qualifiedsz%MultiIndex._is_memory_usage_qualified)rrcCs ||S)N)_nbytes)rLrrNrNrO memory_usageszMultiIndex.memory_usagecCs |dS)z1return the number of bytes in the underlying dataF)r)rLrNrNrOnbytesszMultiIndex.nbytescsjdtfdd|jD}tdd|jD}tfdd|jD}|||}||jjd7}|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* c3s|]}|jdVqdS))rN)r)rr)rrNrOrsz%MultiIndex._nbytes..css|] }|jVqdS)N)r)rrrNrNrOrsc3s|]}t|VqdS)N)r)rr)objsizerNrOrs)r)sumrwrMr]rZsizeof)rLrZ level_nbytesZ label_nbytesZ names_nbytesryrN)rrrOrs  zMultiIndex._nbytescCs(dd|jD}tddt||DS)zW Formats each item in tup according to its level's formatter function. cSsg|] }|jqSrN)_formatter_func)rr|rNrNrOrsz.MultiIndex._formatter_func..css|]\}}||VqdS)NrN)rfuncvalrNrNrOrsz-MultiIndex._formatter_func..)rwrr)rLtupZformatter_funcsrNrNrOrszMultiIndex._formatter_funcnanc Ksg}g}xt|j|jD]z\}}|jfd|i|}|dk}|r~t|} |t}t ||}|j j rnt | }| ||<| || |qWt|dkrt|d|dSt|||j|jdd} | jSdS)Nna_repr~rErF)rwrMr]rerg)rrwrM_format_native_typesrrjrZstrrIrflags writeableAssertionErrorrhr4takerBr]rer) rLrrarrzr|rZ level_strsmaskZ nan_indexmirNrNrOrs.     zMultiIndex._format_native_typesrz bool | NonezCallable | Nonez str | None)r\ formatterrr]spaceadjoinrcs|dk r |}t|dkrgSg}xt|j|jD]\} } |dk rD|n t| jjt| dkr| | j|d} | dk} | rt j | t d} | | <| } nfddt| j| D} || q0Wg} x`t||jD]P\} }g}|r ||dk rt|ddnd |t j | t d| |qW|dkr@td }|rd }t|tsf|tjksft|d tjgkrz|}t| t||d } |rdd lm}|}|j|f|  dS| SdS)Nr)rr~)rxcs$g|]}tt|rn|ddqS))   ) escape_chars)r>r0)rr)narNrOrDsz%MultiIndex.format..)rrr)rzdisplay.multi_sparseF)startsentinel)get_adjustmentr)!rjrrwrM _get_na_reprxrrformatrrIrrYtolistrtake_ndrrr]r>extendrrrfrrrsparsify_labelsrrZpandas.io.formats.formatrrsplit)rLr\rrr]rZsparsifyrZstringified_levelsrr formattedrZ result_levelsZlev_namer|rrZadjrN)rrOr"sP       zMultiIndex.formatcCs t|jS)N)r8rp)rLrNrNrO _get_namespszMultiIndex._get_names)rics|dk rt|stdt|}|rb|dk rDt|t|krDtd|dkrbt|jkrbtd|dkrvtj}nfdd|D}xDt||D]6\}}|dk rt|stt j d|j |<qW dS)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.csg|]}|qSrN)r)rr)rLrNrOrsz)MultiIndex._set_names..z.name must be a hashable type) r'rkr{rjrrrr$r^rrQrpr)rLr]r|rirr\rN)rLrOrqss& zMultiIndex._set_namesam Names of levels in MultiIndex. 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']) )fsetfgetrc Cs|j|}|j|}|dk r@|j||}||}|ddfStj|dd\}}t|dkr|ddkr|dk} tj|| dd\} }tjt||j d}| || <d|| <t|t|kr||}n| }|j r|j|dd}n ||}|||fS)NT)sortrr~)rx) fill_value) rMrwrmaprZ factorizerjrIemptyrxrhZ _can_hold_na) rLmapperr|indexer level_indexZ level_valuesZgrouperrMuniquesrZok_codesrNrNrO_get_grouper_for_levels(       z!MultiIndex._get_grouper_for_levelrcCsdS)NrrN)rLrNrNrO inferred_typeszMultiIndex.inferred_typec Cs|j|}|dkr,t|s,td|dy|j|}Wntk r}zt|sjtd|d|nf|dkr||j7}|dkr||j}td|jd|d |n&||jkrtd|jd |d|Wdd}~XYnX|S) NrEz 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 )r]countr%rkrKeyErrorr IndexError)rLr|rerrZ orig_levelrNrNrOrs*    zMultiIndex._get_level_numbercCsdS)NTrN)rLrNrNrO_has_complex_internalssz!MultiIndex._has_complex_internalscstddjDrdStddjDrBtddjDSfddtttjD}yt |}t |j St k rt jj SXdS) zh return if the index is monotonic increasing (only equal or increasing) values. css|]}d|kVqdS)r~NrN)rr}rNrNrOrsz5MultiIndex.is_monotonic_increasing..Fcss|] }|jVqdS)N) is_monotonic)rr|rNrNrOrscSsg|]}|jdddqS)int64F)rh)rZ)rrrNrNrOrsz6MultiIndex.is_monotonic_increasing..csg|]}|jqSrN)rr)rr)rLrNrOrsN)rrMallrwlibalgos is_lexsortedreversedrrjrIlexsortr4rr^r)rLrZ sort_orderrN)rLrOis_monotonic_increasing s   z"MultiIndex.is_monotonic_increasingcCs|dddjS)zh return if the index is monotonic decreasing (only equal or decreasing) values. Nr~)r%)rLrNrNrOis_monotonic_decreasing'sz"MultiIndex.is_monotonic_decreasingz list[str]cCsdd|jDS)z7return a list of the inferred types, one for each levelcSsg|] }|jqSrN)r)rrrNrNrOr3sz4MultiIndex._inferred_type_levels..)rw)rLrNrNrOr0sz MultiIndex._inferred_type_levelsfirstcCs0tdd|jD}t|j|ddd}t||S)Ncss|]}t|VqdS)N)rj)rrrNrNrOr7sz(MultiIndex.duplicated..F)rZxnull)rrwr;rMr)rLkeepshapeZidsrNrNrOr5szMultiIndex.duplicatedcCs tddS)z: fillna is not implemented for MultiIndex z"isna is not defined for MultiIndexN)NotImplementedError)rLvalueZdowncastrNrNrOfillna@szMultiIndex.fillnar)howrcsndd|jD}|dkr(tj|ddn&|dkr@tj|ddntd|fdd|jD}|j|d S) NcSsg|] }|dkqS)r~rN)rrrNrNrOrHsz%MultiIndex.dropna..rr)rFr zinvalid how option: csg|]}|qSrNrN)rr)rrNrOrPs)rM)rMrIrr rkr)rLr-ZnansrzrN)rrOdropnaFszMultiIndex.dropnar4)r|uniquercCsN|j|}|j|}|j|}|r,t|}tj|j||jd}|j||dS)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 )r)r\) rwrMrprr/rrZ _na_valuer)rLr|r/rrr\ZfilledrNrNrOrSs    zMultiIndex._get_level_valuescCs||}||}|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 ------- values : Index Values is a level of this MultiIndex converted to a single :class:`Index` (or subclass thereof). 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') )rr)rLr|rrNrNrOget_level_valuesls  zMultiIndex.get_level_valuescs.|dkrtS||}|j|ddSdS)NT)r|r/)superr/rr)rLr|) __class__rNrOr/s  zMultiIndex.unique)rrcsddlm}|dk rDt|s$tdt|tjkr>td|}nj}|fddt|t tjDdd }|r~|_ |S) 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. Returns ------- DataFrame : a DataFrame containing the original MultiIndex data. 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)r@Nz1'name' must be a list / sequence of column names.z<'name' should have same length as number of levels on index.cs(i|] \}}||dkr |n|qS)N)r)rZlvlnamer|)rLrNrOrsz'MultiIndex.to_frame..F)rh) rr@r'r^rjrwrkr]rrr)rLrr\r@Z idx_namesryrN)rLrOto_frames 2  zMultiIndex.to_framecCst|jddS)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)Z tupleize_cols)r4r)rLrNrNrO to_flat_indexszMultiIndex.to_flat_indexcCsdS)NFrN)rLrNrNrO _is_all_datesszMultiIndex._is_all_datescCstjdtdd|S)NzxMultiIndex.is_lexsorted is deprecated as a public function, users should use MultiIndex.is_monotonic_increasing instead.r)r)rrr _is_lexsorted)rLrNrNrOr"s zMultiIndex.is_lexsortedcCs |j|jkS)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 )rr)rLrNrNrOr6s zMultiIndex._is_lexsortedcCstjdtdd|jS)NzxMultiIndex.is_lexsorted is deprecated as a public function, users should use MultiIndex.is_monotonic_increasing instead.r)r)rrrr)rLrNrNrO lexsort_depth3s zMultiIndex.lexsort_depthcCs|jdk r|jSt|j|jS)z Compute and return the lexsort_depth, the number of levels of the MultiIndex that are sorted lexically Returns ------- int N)rerrMr)rLrNrNrOr=s zMultiIndex._lexsort_depthc Cs|r|jr|Sg}g}xt|j|jD]r\}}|jsy |}Wntk rXYn0X||}t|}t |t |}t ||}||||q*Wt|||j|jddS)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')], ) F)r]rerg)r6rrrwrMargsortr^rr"rZget_reverse_indexerrjrrrrBr]re)rLrrzrrrrirNrNrO_sort_levels_monotonicKs,"    z!MultiIndex._sort_levels_monotonicc Csdg}g}d}xt|j|jD] \}}tt|ddkdd}tt|o\|ddk}t|t||kr| rt|t|krPd}t |}|rt|dkd}||ddg|d|dg<t t||} t t||| |<| |}|||d}||||qW|} |r`| | j|dd| j|dd| 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']]) FrErr~TN)ri)rrwrMrIrZbincountrrrjr0rrr/zerosarangerrrrurnro) rLrrzchangedrrrZhas_naZna_idxZ code_mappingryrNrNrOremove_unused_levelss4#   zMultiIndex.remove_unused_levelscCs6t|jt|j|jt|jd}tjt||fdfS)z*Necessary for making this object picklable)rwrMrer]N)r{rwrMrer]ibaseZ _new_Indexr)rLdrNrNrO __reduce__s zMultiIndex.__reduce__cstrjtjddg}xFt|j|jD]4\}}|dkrL|tjq*|||q*Wt |Sd}t rtj t d|j }n:ttrjdksjdkr|j }nttrt fdd|jD}t|j||j|dd SdS) NT)Z warn_floatr~)rxrcsg|] }|qSrNrN)rr)rrNrOr sz*MultiIndex.__getitem__..F)rwrMr]rerg)r)comZcast_scalar_indexerrrwrMrrIrris_bool_indexerrrfrerslicestepr4rBr])rLrretvalrrrerzrN)rrO __getitem__s0     zMultiIndex.__getitem__rD)rLslobjrcsLd}jdksjdkr|j}fdd|jD}t||j||j|ddS)zH Fastpath for __getitem__ when we know we have a slice. Nrcsg|] }|qSrNrN)rr)rHrNrOrsz-MultiIndex._getitem_slice..F)rwrMr]rerg)rErerMrrwrp)rLrHrerzrN)rHrO_getitem_sliceszMultiIndex._getitem_slicerr)rLrF allow_fillrc  std|t|||}d}fdd|jD}|rdk}|rg} x(|D] } | } || |<| t| qXW| }t |j ||j ddS)NrNr~csg|]}|qSrN)r)rlab)indicesrNrOr9sz#MultiIndex.take..F)rwrMr]rg) nvZ validate_taker"Z_maybe_disallow_fillrMrrrIrrBrwr]) rLrLrFrJrraZna_valueZtakenrZmaskedZ new_labelZ label_valuesrN)rLrOr(s  zMultiIndex.takec st|ttfs|g}tfdd|Dr~g}x>tjD]0}fdd|D}|||q:Wtj |j dSj ftdd|D}t |}ytj|j dSttfk rt|SXdS)z Append a collection of Index options together Parameters ---------- other : Index or list/tuple of indices Returns ------- appended : Index c3s$|]}t|to|jjkVqdS)N)rrBr)ro)rLrNrOrXsz$MultiIndex.append..csg|]}|qSrN)r)rrN)rrNrOr]sz%MultiIndex.append..)r]css|] }|jVqdS)N)r)rkrNrNrOrasN)rr{rr rrrrrBrr]rrIrrr^rr4)rLotherrlabelZappendedZ to_concatZ new_tuplesrN)rrLrOrHs   zMultiIndex.appendcOs|jj||S)N)rr8)rLr`rarNrNrOr8jszMultiIndex.argsortrepeat)repeatsrcs@tdd|itt|jfdd|jD|j|jddS)NrNrFcs&g|]}|tjtjqSrN)rrIrrZintprR)rr)rSrNrOrvsz%MultiIndex.repeat..F)rwrMr]rerg)rMZvalidate_repeatr"rBrwrMr]re)rLrSrFrN)rSrOrRms zMultiIndex.repeatraisec Cs@|dk r||||St|tjtfsTytj|tdd}Wntk rRYnXg}x|D]}y| |}t|t r| |nt|t r|j dk r|j nd}|t|j|j|nRt|r|jdkrtjdtdd|d}||nd t|}t|Wq^tk r0|d kr,Yq^Xq^W||S) a^ Make new MultiIndex with passed list of codes deleted Parameters ---------- codes : array-like Must be a list of tuples when level is not specified level : int or level name, default None errors : str, default 'raise' Returns ------- dropped : MultiIndex NrY)rxrErzYdropping on a non-lexsorted multi-index without a level parameter may impact performance.r)rzunsupported indexer of type ignore)_drop_from_levelrrIrr4rBindex_labels_to_arrayrxrkrrrrrDrErrrstoprCrrrrnonzerorrrdelete) rLrMr|errorsZindsrlocrEmsgrNrNrOdrop~s<            zMultiIndex.dropc Cst|}||}|j|}||}t|}d|t|d|dk@<|jd|jdkrld|t|d<||dk}t |dkr|dkrt d|dt |j ||} || S) NFr~rTrVzlabels z not found in level)rBrXrrw get_indexerr0rIequalr)rjrrisinrM) rLrMr|r\rrrZ nan_codes not_foundrrNrNrOrWs     zMultiIndex._drop_from_levelr`r~cCst|j}t|j}t|j}||}||}||||||<||<||||||<||<||||||<||<t|||ddS)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')], ) F)rwrMr]rg)r{rwrMr]rrB)rLrjrrz new_namesrNrNrO swaplevels+     zMultiIndex.swaplevelcsfdd|D}t|jkr:tdjdt|fdd|D}fdd|D}fdd|D}t|||dd S) 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']) csg|]}|qSrN)r)rr)rLrNrOr! sz-MultiIndex.reorder_levels..z2Length of order must be same as number of levels (z), got csg|]}j|qSrN)rw)rr)rLrNrOr' scsg|]}j|qSrN)rM)rr)rLrNrOr( scsg|]}j|qSrN)r])rr)rLrNrOr) sF)rwrMr]rg)rjrrrB)rLorderrrzrfrN)rLrOreorder_levels s zMultiIndex.reorder_levelszlist[Categorical]csddfdd|jDS)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 cSs*tjt|rt|dnd|jdS)NrEr)rx)rIr<rjrrrx)rrNrNrOcats8 sz/MultiIndex._get_codes_for_sorting..catscs g|]}tj||ddqS)T)Zordered)r1Z from_codes)rr)rjrNrOr? sz5MultiIndex._get_codes_for_sorting..)rM)rLrN)rjrO_get_codes_for_sorting/ s  z!MultiIndex._get_codes_for_sortingztuple[MultiIndex, np.ndarray]) ascendingsort_remainingrc s\t|ttfr|g}fdd|D}d}t|trht|t|ksLtdtfdd|D|dntjtjt fdd|D}t fd d|D}x(t |d d D]} | |qW|r||t 7}||t 7}n|d }t ||d d|s"dddt fddjD}t|jj|d d} | fS)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 Returns ------- sorted_index : pd.MultiIndex Resulting index. indexer : np.ndarray 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])) csg|]}|qSrN)r)rr)rLrNrOr{ sz(MultiIndex.sortlevel..Nz(level must have same length as ascendingcsg|]}j|qSrN)rM)rr)rLrNrOr s)Zordersc3s|]}|VqdS)NrN)rr)rMrNrOr sz'MultiIndex.sortlevel..c3s|]}|VqdS)NrN)rr)r)rNrOr sT)reverserF)compressr~csg|]}|qSrN)r)rr)rrNrOr s)rMrwr]rerg)rrrrr{rjrkr=rMrrsortedr_r<r"rBrwr]) rLr|rlrmreprimaryZprimshprrzrrN)rMrrLr)rO sortlevelC s@6    zMultiIndex.sortlevelz$tuple[MultiIndex, np.ndarray | None]c Cszt|d }|dk r|dk r$tdt|}t|dkrt|ts|j|}|}| ddt |j t j d|jdf|}nt|}|j||ddd \}} } n:t|}||rd} n"|jr|j||||d } ntd t|ts<| dkr|}nD| dkr|| }n*yt|}Wntk r:|| fSX|rr|j|jkrr|j|jkrr|jdd }|j|_|| fS) a Create index with target's values (move/add/delete values as necessary) Returns ------- new_index : pd.MultiIndex Resulting index indexer : np.ndarray[np.intp] or None Indices of output values in original index. r]Nz)Fill method not supported if level passedrfreq)rxrightF)r-Z keep_order)methodlimit tolerancez'cannot handle a non-unique multi-index!)r)hasattrr^r?Zensure_has_lenrjrr4rwZ_get_attributes_dictr_rZ _simple_newrIrrxr6Z _join_levelequalsrrarkrBr rrrr]rh) rLtargetrur|rvrwZpreserve_namesrattrsr_rNrNrOreindex sF          zMultiIndex.reindexcCst|rt|rt|dS)N)r$r&r)rLrrNrNrO_check_indexing_error sz MultiIndex._check_indexing_errorcCs|jdS)zA Should integer key(s) be treated as positional? r)rw_should_fallback_to_positional)rLrNrNrOr sz)MultiIndex._should_fallback_to_positional)seriescCsb|j|}t|r|St|dkr4|jdks4|dS||}t||}|j|||jd}||S)z Do a positional lookup on the given Series, returning either a scalar or a Series. Assumes that `series.index is self` rEr)rr\)rr)rjrmaybe_droplevelsrr\Z __finalize__)rLrr]r new_valuesrZnew_serrNrNrO_get_values_for_loc s  zMultiIndex._get_values_for_locznp.ndarray | NonecCsd}t|rt|dts|j|dd\}}|dkrLtjt|tjd}|S|jd|}|dk}| rt ||dnt ||rt |d|S)a Analogous to get_indexer when we are partial-indexing on our first level. Parameters ---------- keyarr : Index, np.ndarray, or ExtensionArray Indexer to convert. Returns ------- np.ndarray[intp] or None Nr)r|)rxr~z not in index) rjrrr}rIr<rTrwrarrr3)rLZkeyarrrr|checkrrNrNrO_convert_listlike_indexer s  z$MultiIndex._convert_listlike_indexercCst|tr4|jdjr4|ftdft|jd}t|trg}xHt|D]<\}}t|tr~|j|jr~|t||dqL||qLWt|}|S)z Translate any partial string timestamp matches in key, returning the new key. Only relevant for MultiIndex. rNrE) rrrwZ!_supports_partial_string_indexingrDrjrrr)rLrZnew_keyr componentrNrNrO'_get_partial_string_timestamp_match_key; s   z2MultiIndex._get_partial_string_timestamp_match_key)rzrurvrc Cst|sttgSt|tshyt|}Wn8ttfk rf|dkrbt |j j ||||dSYnX|dksx|dkr|j j |j |j ||d}n|j |j }t|S)N)rurvrwpadZbackfill)rzrrurv)rjr"rIrrrBrr^rkr4rrarZget_indexer_with_fill)rLrzrurvrwrrNrNrO _get_indexerX s   zMultiIndex._get_indexerzHashable | Sequence[Hashable])rQsidekindrcCst|ts|f}|j||dS)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'} kind : {'loc', 'getitem', None} 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. )r)rr_partial_tup_index)rLrQrrrNrNrOget_slice_bound s/ zMultiIndex.get_slice_boundcst|||S)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 kind : string, optional, defaults None 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. )r1 slice_locs)rLrendrEr)r2rNrOr s6zMultiIndex.slice_locsleftr)rcCst||jkr*tdt|d|jdt|}dt|}}t||j|j}x2t|D]$\}\}} } | ||} || krt|s| t j |gddst d|| j ||d} |d kr| dkr| d 8} || j | |dS| | |} t| tr||d kr| j}| j}q\||d krL|| j | d d}|| j | d d}q\t| trp| j} || j | |dS|| j | |dSq\WdS) Nz Key length (z-) was greater than MultiIndex lexsort depth ()rF)ZskipnazLevel type mismatch: )rrtrEr)rjrrrrwrMrr0Zis_type_compatiblerZ infer_dtyper^ searchsorted_get_loc_single_level_indexrrDrrY)rLrrnrrZzippedrOrKrZlabssectionr]rrNrNrOr s4   zMultiIndex._partial_tup_indexr )rrrcCs"t|rt|rdS||SdS)a If key is NA value, location of index unify as -1. Parameters ---------- level_index: Index key : label Returns ------- loc : int If key is NA value, loc is -1 Else, location of key in index. See Also -------- Index.get_loc : The get_loc method for (single-level) index. r~N)r)r0r)rLrrrNrNrOr sz&MultiIndex._get_loc_single_level_indexc s|dk rtdt|fdd}t|tsDj|dd}||St|}j|krntd|djd |jkrjrj |Sj }|d|||d}}|r ||n dtf\} } | | krt||st | | Stjd td d tj| | tjd }x`t|t|D]N\}} j||j|| k} | sT|| }t|st|qWt|| | kr||St | | S)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) method : None Returns ------- loc : 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 NzEonly the default get_loc method is currently supported for MultiIndexcsbt|tjr|jtjkr|St|t}t|tr:|Stj tdd}| dd||<|S)z._maybe_to_slicer)r|z Key length (z) exceeds index depth (rz3indexing past lexsort depth may impact performance. )r)rx)r*rrr_get_level_indexerrjrrrrrrrrDrrrrIr<rTrrMrrwr ) rLrrurr]ZkeylenrZlead_keyZ follow_keyrrYrOrrN)rLrOr) sD*        zMultiIndex.get_loc) drop_levelcs<t|ttfs|}nfdd|D}j|||dS)a Get location and sliced index for requested label(s)/level(s). Parameters ---------- key : label or sequence of labels level : int/level name or list thereof, optional drop_level : bool, default True If ``False``, the resulting index will not drop any level. Returns ------- loc : A 2-tuple where the elements are: 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='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) csg|]}|qSrN)r)rr)rLrNrOr sz,MultiIndex.get_loc_level..)r|r)rr{rr_get_loc_level)rLrr|rrN)rLrO get_loc_level s& zMultiIndex.get_loc_levelzint | list[int])r|rc sddfdd t|ttfrtt|kr8tdd}xdt|D]V\}}j||d\}}t|trtj tt d} d | |<| }|dkr|n||@}qHW|||fSttrtttr|d kry8j d krj |d} | d g}| |fSWnt tfk r,YnXtd d Dsdfd d } tjkrjryjdfStk r} zt| Wdd} ~ XYnXn| Snd} xtD]\} }t|ts j || d}t|tr|jd kr |jtkr tdd}n|}t|trJ|tddkrBqnt | dkrZ|} n| |M} qW| dkr|tdd} fddttD}| | |fSn j |d} | | |gfSdS)zX get_loc_level but with `level` known to be positional, not name-based. rf)rc sX|s |S|}}x:t|ddD]*}y||g}Wq&tk rN|SXq&W|S)NT)rn)rp_drop_level_numbersrk)rrwrZ orig_indexrr)rLrNrOmaybe_mi_droplevels s  z6MultiIndex._get_loc_level..maybe_mi_droplevelsz:Key for location must have same length as number of levelsN)r|)rxTrcss|]}t|tVqdS)N)rrD)rrOrNrNrOr sz,MultiIndex._get_loc_level..cs<|dkr}fddttD}|||fS)Ncs"g|]}|tddkr|qS)N)rD)rr)rrNrOr szHMultiIndex._get_loc_level..partial_selection..)rrrj)rrilevels)rrrL)rrOpartial_selection s z4MultiIndex._get_loc_level..partial_selectioncs"g|]}|tddkr|qS)N)rD)rr)rrNrOr% sz-MultiIndex._get_loc_level..)N)rrr{rjrrrrDrIr;rfrwrr^rrrrrrrrrrYr)rLrr|rryrrOr]rrrrerZk_indexrrN)rrrrLrOr sj           zMultiIndex._get_loc_level)r|cCs|j|}|j|}||fdd}t|trRy^|jdk rH||j}nd}|jdk rd||j}n t|trxt|}n t|d}|j} Wn2t k r| |j|j|j}}|j} YnXt|tst|trt |d|}t |d|}|||| S|dks|j dks| dk r(|||d| S|j |dd} |j |d d} t| | | Sn|||} |dkst|j dkrtj|| ktd d } | st || St| tr| j}| j}n|j | dd}|j | d d}||krt |t||SdS) Nc Ss|dk r"|dkr"|d|d}}t|||}|dk rt|t|krddlm}||}|t|}|t|| d}| |} t | } n,tj t|t d} d| tj||t|jd<| S)NrrE)rA)rxT)Z assume_unique)rIr<rjrrArr"r4rcrZrrr;rfZin1dr) rrYrErrMrrArrymrNrNrOconvert_indexer4 s   z6MultiIndex._get_level_indexer..convert_indexerrrErrYr)rrtF)rxrh)rwrMrrDrrrYrjrErZ slice_indexerrrrrrIrrfr)rLrr|rrrrrrYrErrerZlocsrrNrNrOr+ sP  #                zMultiIndex._get_level_indexerc sddtt|D}|r@|d|jkr@td|d|jt|d}ddfd d }d d d d fdd }x>> 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) cSsg|]\}}|r|qSrNrN)rrsrNrNrOr sz'MultiIndex.get_locs..r~zIMultiIndex slicing requires the index to be lexsorted: slicing on levels z, lexsort depth Nr9)rcs`t|tr.tjtd}d||<|d}n*t|rXt|krLt d|d}t |S)N)rxTrzLcannot index with a boolean indexer that is not the same length as the index) rrDrIr;rfrZrBrCrjrkr9)rr)rrNrO_convert_to_indexer s    z0MultiIndex.get_locs.._convert_to_indexerz Index | Noner4)idxrrrcsJ|dkrtt}|dkr"|S||}|jrF|jsF|jsFt||S)N)r4rIr< intersectionrr)rrrZindexer_intersection)rrNrO_update_indexer s z,MultiIndex.get_locs.._update_indexer)rr)r|rF)r)rx)r|rr)rrBZis_true_slicesrrrjrCrIrr'runionrrrZ is_null_slicerrDrr9rr_reorder_indexerr) rLseqZ true_slicesrrrrrOZindexersrZidxrsrN)rrOget_locs sX$             zMultiIndex.get_locsz,tuple[Scalar | Iterable | AnyArrayLike, ...]r9)rrrc Cs|rd}x|t|D]p\}}t|rd|s|j||}||dk}|dd|ddk}qt|tr|jdk r|jdkrd}qW|s|St |}d}xBt|D]4\}}t |r|g}t |rt ||} nt|rZt|}t jt |j|t jdt |j|} |j||} | | dk} t t | | | <| |j||} n|t|tr|jdk r|jdkrt |||} nDt|tr|jdkr|jdkrt |f|} nt ||} | f|}qWt |} || S) aq Reorder an indexer of a MultiIndex (self) so that the label are in the same order as given in seq Parameters ---------- seq : label/slice/list/mask or a sequence of such indexer: an Int64Index indexer of self Returns ------- indexer : a sorted Int64Index indexer of self ordered as seq FrNr~rETrN)rx)r6rr'rwrarrrDrErjr)rBrCrIr<rr/ZonesrrMrrYr$) rLrrZ need_sortrrOZk_codesrkeysZ new_orderZ key_order_mapZ level_indexerindrNrNrOr& sF     $$ zMultiIndex._reorder_indexercs|r|r||krtd|jd||\}}|||\t|j}|d|||d<fdd|jD}|d||d<t|||jddS)av 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 ------- truncated : MultiIndex zafter < beforercsg|]}|qSrNrN)rr)rrtrNrOr sz'MultiIndex.truncate..F)rwrMr]rg)rkrwrr{rMrBrp)rLbeforeafterrrerrzrN)rrtrOtruncaten s zMultiIndex.truncaterY)rPrc Cs2||rdSt|tsdSt|t|kr0dSt|tsV||sHdSt|j|jS|j|jkrfdSxt |jD]}|j |}|j |}|dk}|dk}t ||sdS||}|j |j|}||}|j |j|}t|dkrt|dkrqrt|t js||s*dSqrt||srdSqrWdS)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 TFr~r)is_rr4rjrBZ_should_comparer/rrrrMrIZ array_equalrwrrry) rLrPrZ self_codesZ other_codesZ self_maskZ other_maskZ self_valuesZ other_valuesrNrNrOry s>            zMultiIndex.equalscCsB|j|jkrdSx,t|jD]}|j||j|sdSqWdS)zT Return True if the levels of both MultiIndex objects are the same FT)rrrwry)rLrPrrNrNrO equal_levels s  zMultiIndex.equal_levelscs||\}}tdd|jDr6tdd|jDsB|jsB|jrRt||}n$|jjtdd}t j |j|g|d}t j t |d|dS) Ncss|]}d|kVqdS)r~NrN)rr}rNrNrOr sz$MultiIndex._union..css|]}d|kVqdS)r~NrN)rr}rNrNrOr sF)rh)rr)rer])_convert_can_do_setoprrMZhas_duplicatesr1_unionrrZrYrZfast_unique_multiplerBrr)rLrPr result_namesryZrvals)r2rNrOr szMultiIndex._unionr)rxrcCst|S)N)r()rLrxrNrNrO_is_comparable_dtype szMultiIndex._is_comparable_dtypecCs"||}|j|kr||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_namesr]rename)rLrPr]rNrNrO_get_reconciled_name_object s   z&MultiIndex._get_reconciled_name_objectcCsft|jt|jkr$dgt|jSg}x8t|j|jD]&\}}||krT||q8|dq8W|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)rjr]rr)rLrPr]a_nameZb_namerNrNrOr s zMultiIndex._maybe_match_namescCsL||\}}t|dkr4t|jgg|j|ddStjt|d|dSdS)NrF)rwrMr]rg)rer])rrjrBrwrrr)rLrPryrrNrNrO_wrap_intersection_result s  z$MultiIndex._wrap_intersection_resultcs\||\}}t||}t|dkrHtgg|jgg|j|ddStj|d|dSdS)NrF)rwrMr]rg)rer])rr1 _differencerjrBrr)rLrPrr difference)r2rNrOrs   zMultiIndex._differencec Cs|j}t|tszt|dkr.|dd|jfSd}ytj||jd}Wqttfk rv}zt||Wdd}~XYqXn t||}||fS)Nrz.other must be a MultiIndex or a list of tuples)r]) r]rr4rjrBrrkr^r7)rLrPrr^rrNrNrOr(s   z MultiIndex._convert_can_do_setop)rhcCsDt|}t|rd}t|n"t|s0tdn|dkr@|S|S)Nz3> 1 ndim Categorical are not supported at this timezISetting a MultiIndex dtype to anything other than object is not supportedT)r*r#r*r(r^r)rLrxrhr^rNrNrOrZ>s zMultiIndex.astypecCs:t|ts |fd|jd}nt||jkr6td|S)N)rrEz0Item must have length equal to number of levels.)rrrrjrk)rLitemrNrNrO_validate_fill_valueMs  zMultiIndex._validate_fill_value)r]rc Cs||}g}g}xht||j|jD]T\}}}||krLt|}|||}n ||}|||tt |||q$Wt |||j ddS)a Make new MultiIndex inserting new item at location Parameters ---------- loc : int item : tuple Must be same length as number of levels in the MultiIndex Returns ------- new_index : Index F)rwrMr]rg) rrrwrMrjinsertrrrIr!rBr]) rLr]rrrzrOr|rZlev_locrNrNrOrVs   zMultiIndex.insertcs(fdd|jD}t|j||jddS)z} Make new index with passed location deleted Returns ------- new_index : MultiIndex csg|]}t|qSrN)rIr[)rr)r]rNrOrsz%MultiIndex.delete..F)rwrMr]rg)rMrBrwr])rLr]rzrN)r]rOr[ys zMultiIndex.deletecCsh|dkr(tj||jdj}t|j|S||}||}|jdkrZt j t |t j dS||SdS)N)r]r)rx) rBrr]rrrcrr0sizerIr;rjZbool_)rLrr|numZlevsrNrNrOrcs   zMultiIndex.isinzMultiIndex | None)rrcstj|||dS)N)r]r|r)r1 set_names)rLr]r|r)r2rNrOrszMultiIndex.set_namesz str | bool)r(rcstj|dS)N)r()r1drop_duplicates)rLr()r2rNrOrszMultiIndex.drop_duplicates__add____radd____iadd____sub____rsub____isub____pow____rpow____mul____rmul__ __floordiv__ __rfloordiv__ __truediv__ __rtruediv____mod____rmod__ __divmod__ __rdivmod____neg____pos____abs____inv__)NNNNNFNT)NN)NN)NN)NFTF)NNT)NFTF)NNT)NNNNFN)N)N)F)F)r)NNNFrNT)NT)r')NN)r)F)N)TN)rTN)N)NrU)rU)r`r~)rTT)NNNN)NNN)N)NNNN)r)N)rT)rT)rN)NN)T)N)NF)r')rQrRrSrTr4Z _hidden_attrs frozensetZ_typr8rprrtZ _comparables__annotations__rlrrs classmethodrrrrdrrrrrpropertyrrrrrwrnrrrrrMrorrrrrrrhrrrrxrrrrrrrr rqr]rrrrr%r&rrZ _duplicatedr,r.rr0r/r3r4r5r"r6r7rr:r>rArGrIrr5_index_doc_kwargsrrr8rRr_rWrgrirkrrr}r~rrrrrrrrrrrrrrrrryrrrrrrrrrZrrr[rcrrrr:rrrrrrrrrrrrrrrrrrrrrr __classcell__rNrN)r2rOrBs~ L &>A=;A #o R  O   $F;%   $M " CZ "" 6:.lF# $28& p,fo  H":    # " "                     zlist[np.ndarray]rr)rMrrcCs>dd|D}x*t|ddD]}t|d|r|SqWdS)zJCount depth (up to a maximum of `nlevels`) with which codes are lexsorted.cSsg|] }t|qSrN)r!)rrrNrNrOrsz"_lexsort_depth..rr~N)rr!r")rMrZ int64_codesrOrNrNrOrs rr)rc Cstt|}t|}|d|d}||}x||ddD]}g}xrtt||D]`\} \} } | |dkr|| ||P| | kr||qV||| d||PqVW|}q>Wtt|S)NrE)r{rrjrrr) Z label_listrrZpivotedrOryprevcurZ sparse_currptrNrNrOr s$      r r)rcCstjdtjdi|dS)NZNaTNaN)rIZ datetime64Z timedelta64get)rxrNrNrOrsrr4)rrc Csn|}t|trDxZ|D]*}y|dg}Wqtk r<|SXqWn&y|dg}Wntk rhYnX|S)z Attempt to drop level or levels from the given index. Parameters ---------- index: Index key : scalar or tuple Returns ------- Index r)rrrrk)rrZoriginal_indexr|rNrNrOrs   rFrfz np.ndarray)rhrcCs"t||}|r|}d|j_|S)a Coerce the array-like indexer to the smallest integer dtype that can encode all of the given categories. Parameters ---------- array_like : array-like categories : array-like copy : bool Returns ------- np.ndarray Non-writeable. F)r rhrr)Z array_like categoriesrhrNrNrOrs  r)arrnamecCs|dk rNt|sNt|s&t|dt|dr@t|d|g}|g}n2|dks^t|rt|rrt|dst|d||fS)zT Ensure that level is either None or listlike, and arr is list-of-listlike. Nz must be list-likerz must be list of lists-like)r'r^)r|rrrNrNrOrs r)rr)F)y __future__r functoolsrsysrtypingrrrrr r r r r rrnumpyrIZpandas._configrZ pandas._libsrr!rrUrZpandas._libs.hashtablerZpandas._typingrrrrZpandas.compat.numpyrrMZ pandas.errorsrrrZpandas.util._decoratorsrrrrZpandas.core.dtypes.castr Zpandas.core.dtypes.commonr!r"r#r$r%r&r'r(r)r*Zpandas.core.dtypes.dtypesr+Zpandas.core.dtypes.genericr,r-r.Zpandas.core.dtypes.missingr/r0Zpandas.core.algorithmscoreZ algorithmsZpandas.core.arraysr1Zpandas.core.arrays.categoricalr2Zpandas.core.commoncommonrBZpandas.core.indexersr3Zpandas.core.indexes.baseZindexesbaser?r4r5r6r7Zpandas.core.indexes.frozenr8Zpandas.core.indexes.numericr9Zpandas.core.ops.invalidr:Zpandas.core.sortingr;r<r=Zpandas.io.formats.printingr>rr?r@rAdictrupdateZBaseMultiIndexCodesEnginerVrDr[rXrdrBrr rrrrrNrNrNrOs   0     0          ')