o 5cUr@sddlmZddlZddlmZmZddlZddlZddl m m Z ddl mZddlmZddlmZddlmZddlmZdd lmZmZmZmZmZdd lmZdd lm Z ddl!m"m#Z$dd l%m&Z&dd l'm(Z(ddl)m*Z*ddl+m,Z,m-Z-ddl.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4m5Z5erddl6m7Z7ddl8m9Z9GdddZ:d;ddZ;d;dd"d#Z>d?d@d)d*Z?dAd+d,Z@dBd/d0ZA %d?dCd3d4ZBdDd9d:ZCdS)E) annotationsN) TYPE_CHECKINGcast)npt)PerformanceWarning)cache_readonly)find_stack_level) maybe_promote)ensure_platform_intis_1d_only_ea_dtypeis_extension_array_dtype is_integerneeds_i8_conversion)ExtensionDtype)notna)factorize_from_iterable)ensure_wrapped_if_datetimelike) DataFrame)Index MultiIndex)Series)compress_group_indexdecons_obs_group_idsget_compressed_idsget_group_indexget_group_index_sorter)ExtensionArray) FrozenListc@seZdZdZd)d*dd Zed+d d Zed,ddZd-ddZddZ ed.ddZ ed/ddZ d0ddZ d1dd Z d2d#d$Zed3d%d&Zed4d'd(ZdS)5 _Unstackera  Helper class to unstack data / pivot with multi-level index Parameters ---------- index : MultiIndex level : int or str, default last level Level to "unstack". Accepts a name for the level. fill_value : scalar, optional Default value to fill in missing values if subgroups do not have the same set of labels. By default, missing values will be replaced with the default fill value for that data type, NaN for float, NaT for datetimelike, etc. For integer types, by default data will converted to float and missing values will be set to NaN. constructor : object Pandas ``DataFrame`` or subclass used to create unstacked response. If None, DataFrame will be used. Examples -------- >>> index = pd.MultiIndex.from_tuples([('one', 'a'), ('one', 'b'), ... ('two', 'a'), ('two', 'b')]) >>> s = pd.Series(np.arange(1, 5, dtype=np.int64), index=index) >>> s one a 1 b 2 two a 3 b 4 dtype: int64 >>> s.unstack(level=-1) a b one 1 2 two 3 4 >>> s.unstack(level=0) one two a 1 3 b 2 4 Returns ------- unstacked : DataFrame NindexrreturnNonecCs|durt}||_||_|j||_d|jj|jvr dnd|_t|jj |_ t|jj |_ |j |j|_|j |j|_|j |j|_tdd|j D}|jj}||}|ttjjkrqtjd|dttd|dS) NrrcSsg|]}|jqS)size).0 index_levelr$r$Q/var/www/html/gps/gps/lib/python3.10/site-packages/pandas/core/reshape/reshape.py zsz'_Unstacker.__init__..z%The following operation may generate z& cells in the resulting pandas object.) stacklevel)r constructorremove_unused_levelsr _get_level_numberlevelcodesliftlistlevelsnew_index_levelsnamesnew_index_namespop removed_name removed_levelremoved_level_fullnpmaxr%iinfoint32warningswarnrr_make_selectors)selfr r.r+num_rows num_columns num_cellsr$r$r(__init__as*   z_Unstacker.__init__-tuple[npt.NDArray[np.intp], list[np.ndarray]]c Cs|j}t|jj}t|jj}|d|||dd||g}tdd|d|||dd||gD}t||\}}t|}t||} | |fS)Nr#cs|]}t|VqdSNlenr&xr$r$r( z2_Unstacker._indexer_and_to_sort..) r.r1r r/r2tuplerrJr) rAvr/levsto_sortsizes comp_indexobs_idsngroupsindexerr$r$r(_indexer_and_to_sorts  &4 z_Unstacker._indexer_and_to_sortlist[np.ndarray]cs|j\}fdd|DS)Ncg|]}|qSr$take)r&linerWr$r(r)z,_Unstacker.sorted_labels..)rX)rArRr$r^r( sorted_labelss z_Unstacker.sorted_labelsvalues np.ndarraycCs|j\}}tj||dd}|S)Nr)axis)rXalgostake_nd)rArarW_ sorted_valuesr$r$r(_make_sorted_valuess z_Unstacker._make_sorted_valuesc Cs|j}|jdd}tdd|D}t||\}}t|}t|}|jj|j|j }||f|_ |jd|||j }t j t |j td} | |d| t|jkr[td||_| |_|t ||_dS)NrcsrGrHrIrKr$r$r(rMrNz-_Unstacker._make_selectors..dtypeTz0Index contains duplicate entries, cannot reshape)r3r`rOrrJr r levshaper.r0 full_shaper:zerosprodboolputsum ValueError group_indexmask searchsortedarange compressor) rA new_levelsremaining_labels level_sizesrTrUrVstrideselectorrtr$r$r(r@s   z_Unstacker._make_selectorsrocCst|jSrH)rortallrAr$r$r(mask_allsz_Unstacker.mask_all2tuple[npt.NDArray[np.intp], npt.NDArray[np.bool_]]cCs6tjt|jtjd}|j|dd\}}||dfS)Nrir fill_valuer)r:rvrJr intpget_new_valuesany)rA dummy_arr new_valuesrtr$r$r( arange_resultsz_Unstacker.arange_resultrcCsn|jdkr|ddtjf}|dur|jddkrtd|||\}}||}|j}|j||||j dS)Nr#z-must pass column labels for multi-column data)r columnsrj) ndimr:newaxisshaperrrget_new_columns new_indexr+rj)rAra value_columnsrrfrr r$r$r( get_results   z_Unstacker.get_resultc Cs|jdkr|ddtjf}||}|j\}}|jd}||}||f}|j} |j} | rJt|rJ| ||| dd |} tj |t d} | | fS|j } | rZ|j } tj|| d} n*t| trq| }|j|| d} || dd<nt| |\} }tj|| d} | || j}tj|t d} t|j r|d}| d} n|j|dd}t|| d|||| | dt|j r| d} t| } | |j } | | fS) Nr#rii8F)copyu1zM8[ns])rr:rrhrlrrtrrJreshapeswapaxesonesrorjempty isinstancerconstruct_array_type_emptyr fillnamermrviewastype libreshapeunstackr)rArarrglengthwidthr{ result_width result_shapertrrnew_maskrjclsrr$r$r(rs^             z_Unstacker.get_new_valuesr Index | Nonec s|dur!|jdkr|jj|jdS|jjd|jjd}||jSt|j|j}t|}t t ||t |t rT|j |jf}|j|jf}fdd|jD}n||jg}|j|jg}g}|j}|t||t |||ddS)Nrr)itemcrZr$r[r&lab propagatorr$r(r)Ar_z._Unstacker.get_new_columns..Fr2r/r4verify_integrity)r0r8_renamer7insert _na_valuerenamerJr:repeatrvrrr2r9r4r/r _repeaterappendtile) rArlevr{rrx new_names new_codesrepeaterr$rr(r/s,    z_Unstacker.get_new_columnscCs^t|jt|jkr|j|j}|jrt|dd}|St|j|j}t||j}|S)Nrr)rJr9r8 get_indexerr0r:rrv)rArr{r$r$r(rRsz_Unstacker._repeatercsfddjddD}tjdkr9jd|d}}|dkr.|t||j}||jdSt j|jddS)Ncsg|]}|jqSr$)r\rwrr~r$r(r)dz(_Unstacker.new_index..rr#rFr) r`rJr3rrrr\rr5r)rA result_codesr. level_codesr$r~r(ras z_Unstacker.new_index)rN)r rr!r")r!rF)r!rY)rarbr!rb)r!ro)r!r)r!rrH)rr)r!rb)r!r)__name__ __module__ __qualname____doc__rErrXr`rhr@rrrrrrrr$r$r$r(r3s( -*        P# rcsxtdkr|S|jjvrgfddDfddtjD}fddD}fddD}fddD}fdd|D}fd d|D}fd d|D} td d |D} t|| d d d} t| d d\} } t| | | |d d}|st | dd}nt || g|| g| dgd d}t |t r| }||_|jd|d}|}|}|}npt |jt r|}ttD]}||j|d}fddDq|S|j d d}||_|jd|d}t |t r|j}n|j}t |t sJ|jdg|}|jjg|}|jdg}|D]}|||jdqt |||d d}t |t r7||_|S||_|S)Nrcsg|]}|qSr$)r-r&ir r$r(r)r_z%_unstack_multiple..csg|]}|vr|qSr$r$r)clocsr$r(r)rcg|]}j|qSr$r2rrr$r(r)r_crr$r/rrr$r(r)r_crr$r4rrr$r(r)r_crr$rrrr$r(r)r_crr$rrrr$r(r)r_crr$rrrr$r(r)r_csrGrHrIrKr$r$r(rMrNz$_unstack_multiple..F)sortxnull)r)r__placeholder__rrrcs g|] }|kr |n|dqS)r#r$)r&rP)valr$r(r) deepr)rJr r4rangenlevelsrOrrrrrrrrrrr2rr/rr\)datarrrlocsclevelsccodescnamesrlevelsrcodesrnamesrrscomp_idsrU recons_codes dummy_indexdummy unstackedrxrrresultrunstcolsrec new_columnsr$)rr rr(_unstack_multipleusv        robjSeries | DataFramecCst|ttfrt|dkrt|||dS|d}t|s&|dks&|j|}t|tr?t|jt r8t |||dS|j j ddSt|jt sPt dt|jdt|jr[t|||St|j||jd }|j|jd|d S) Nr#rrrFdropnaz'index must be a MultiIndex to unstack, z was passedr.r+rr)rrOr1rJrr r r-rr_unstack_frameTstackrrtyper rj_unstack_extension_seriesr_constructor_expanddimr_values)rr.r unstackerr$r$r(rs,        rrcCsVt|jtsJt|j||jd}|js!|jj||d}||S|j|j |j |dS)Nrrr) rr rr _constructor_can_fast_transpose_mgrrrrr)rr.rrmgrr$r$r(rs  rseriesrr!cCs(|}|j||d}|jd|_|S)a' Unstack an ExtensionArray-backed Series. The ExtensionDtype is preserved. Parameters ---------- series : Series A Series with an ExtensionArray for values level : Any The level name or number. fill_value : Any The user-level (not physical storage) fill value to use for missing values introduced by the reshape. Passed to ``series.values.take``. Returns ------- DataFrame Each column of the DataFrame will have the same dtype as the input Series. )r.rr)to_framerr droplevel)rr.rdfrr$r$r(rsrrTframerrocsdd}|j\}|j|}t|jtrt|||dSt|jtr`t|jj}fdd|jj D}||j\}} | || t | | t|jj} | |jjt||| dd} n*tt||j|jf\} \} } | t | | f}t| ||jj|jjgdd} |js|jrt|jj}|d}t|r|}|d d|D}t||}n |j }n|j }|rt|}||}| |} |j|| d S) z Convert DataFrame to Series with multi-level Index. Columns become the second level of the resulting hierarchical index Returns ------- stacked : Series or DataFrame cSs,|jr |tt|fSt|\}}||fSrH) is_uniquer:rvrJr)r r/ categoriesr$r$r( factorize)s zstack..factorize) level_numrcrZr$rrKr$r(r)8r_zstack..FrrcSg|]\}}|jqSr$r)r&rfcolr$r$r(r)Vr_r)rrr-rr_stack_multi_columnsr r1r2r/rr:rravelr4rzipmaprr_is_homogeneous_typedtypesrr r_concat_same_typeitems"_reorder_for_extension_array_stackr_constructor_sliced)rr.rrNrrxrclevclabrrr2ilabr/rrjarrrrtr$rr(rsP           rcstfdd|Dr}|D] }t|||d}q|Stdd|Dr_}fdd|D}tt|D]'}||}t|||d}g}|D]}||krT||dqF||qF|}q5|Std) Nc3s|] }|jjvVqdSrH)rr4r&rrr$r(rMlsz!stack_multiple..rcss|]}t|tVqdSrH)rintrr$r$r(rMrscsg|]}j|qSr$)rr-rrr$r(r)xrz"stack_multiple..r#zTlevel should contain all level names or all level numbers, not a mixture of the two.)r}rrrJrrr)rr.rrrr updated_levelotherr$rr(stack_multipleis*  rrrcCst|jdkr|jdj|jddSddt|jdd|jddD}t|}dd t|D}t|}tj d dt||jD|jddd S) zBCreates a MultiIndex from the first N-1 levels of this MultiIndex.rrrcs"g|] \}fdd|DqS)cs g|] }|dkr |ndqS)rNr$)r&crr$r(r)rz8_stack_multi_column_index...r$)r&r/r$rr(r)sz-_stack_multi_column_index..Nrcss|]\}}|VqdSrHr$)r&keyrfr$r$r(rMrNz,_stack_multi_column_index..cSs*g|]\}}d|vrt||jdn|qS)Nri)rrj)r&new_levrr$r$r(r)sr) rJr2rr4r r/ itertoolsgroupbyr from_arrays)rrQtuples unique_tuplesnew_levsr$r$r(_stack_multi_column_indexs  r(rrc# s^ddd}|jdd}|j}t|tsJ||jd kr@|}t||jd D]}|||}||d |} ||| }q&||_}|sS|d |} |j| d d }|j}t t|}t |} i} |j d } t t |jd }| t| d}t||}t|g}| D]}z|j|}Wnty||Yqwt|tst|}n|j|j}|kr|jdd|j|f}||jjd |_|j|d j}n\|jrt|jjd r||j|jjd }||j|}| !dd|"D}|j#\}}t$||%||j&'}||}n|j(r ||j|j}n |jdd|f}|j)d kr3|'}|| |<qt|d krD| *|} t|}t|j+trgt,|j+j }t,|j+j-}fdd|j+jD}nt.|j+\}} | g}|/g}|j+j0g}|| |t1||||jj-|t|||dd}!|j2| |!| d}"|r|"j3d dd}"|"S)NrrrrcSs||jvr |j|S|S)z Logic for converting the level number to something we can safely pass to swaplevel. If `level_num` matches a column name return the name from position `level_num`, otherwise return `level_num`. r)rrr$r$r(_convert_level_numbers  z3_stack_multi_columns.._convert_level_numberFrr#r)r.rcr)rcSrr$r)r&rfrLr$r$r(r)r_z(_stack_multi_columns..crZr$rrlevsizer$r(r)r_r)r rr})rchow)rrrr)4rrrrrr swaplevel _is_lexsorted sort_indexrr(r2sortedsetr/rrJr:r\get_locKeyErrorrslicestopstartlocreindexrar r rilocrrrrrvrrr _is_mixed_typer differencer r1r4rrrrrr)#rrrr)thismi_cols roll_columnsrlev1lev2 level_to_sortrnew_data level_valsrlevel_vals_nanlevel_vals_used drop_colsr r7 slice_lenchunk value_slicerjsubsetrridxrxrr old_codes old_levelsrrr$r*r(r s                         r rrn_rows n_columnscCs&t||||j}||S)a Re-orders the values when stacking multiple extension-arrays. The indirect stacking method used for EAs requires a followup take to get the order correct. Parameters ---------- arr : ExtensionArray n_rows, n_columns : int The number of rows and columns in the original DataFrame. Returns ------- taken : ExtensionArray The original `arr` with elements re-ordered appropriately Examples -------- >>> arr = np.array(['a', 'b', 'c', 'd', 'e', 'f']) >>> _reorder_for_extension_array_stack(arr, 2, 3) array(['a', 'c', 'e', 'b', 'd', 'f'], dtype='>> _reorder_for_extension_array_stack(arr, 3, 2) array(['a', 'd', 'b', 'e', 'c', 'f'], dtype='numpyr:pandas._libs.reshape_libsrrpandas._typingr pandas.errorsrpandas.util._decoratorsrpandas.util._exceptionsrpandas.core.dtypes.castr pandas.core.dtypes.commonr r r r rpandas.core.dtypes.dtypesrpandas.core.dtypes.missingrpandas.core.algorithmscore algorithmsrdpandas.core.arrays.categoricalrpandas.core.constructionrpandas.core.framerpandas.core.indexes.apirrpandas.core.seriesrpandas.core.sortingrrrrrpandas.core.arraysrpandas.core.indexes.frozenrrrrrrrrr(r rr$r$r$r(sL               D W % ! J )