]j SSKJr SSKrSSKJrJrJr SSKrSSK J r SSK J r SSK Jr SSKJrJrJr SSKJr SS KJrJr SSKJs Jr SS KJr SS KJrJ r J!r! SS K"J#r# SS K$J%r% \(aSSK&J'r'J(r( SSK)J*r*J+r+J,r,J-r-J.r. SSK/J0r0 \ "S5SS Sjj5r1S!Sjr2S"S#Sjjr3S$S%Sjjr4S&S'Sjjr5S&S(Sjjr6Sr7\ "S5\ Rp\ RpS.S)Sjj5r9\ "S5S*S+Sjj5r:S$S,Sjjr;S-S.Sjjr<S/Sjr=g)0) annotationsN) TYPE_CHECKINGLiteralcast)lib) set_module)maybe_downcast_to_dtype) is_list_likeis_nested_list_like is_scalar)ExtensionDtype) ABCDataFrame ABCSeries)Grouper)Index MultiIndexget_objs_combined_axis)concat)Series)CallableHashable) AggFuncTypeAggFuncTypeBaseAggFuncTypeDict IndexLabelSequenceNotStr DataFramepandasc  t[U5n[U5n[U[5(ah/n /n UHDn[UUUUUUUUUU U U S9 nU R U5 U R [ USU55 MF [ XSS9nURUSS9$[UUUUUUUUUU U U 5 nURUSS9$)a Create a spreadsheet-style pivot table as a DataFrame. The levels in the pivot table will be stored in MultiIndex objects (hierarchical indexes) on the index and columns of the result DataFrame. Parameters ---------- data : DataFrame Input pandas DataFrame object. values : list-like or scalar, optional Column or columns to aggregate. index : column, Grouper, array, or sequence of the previous Keys to group by on the pivot table index. If a list is passed, it can contain any of the other types (except list). If an array is passed, it must be the same length as the data and will be used in the same manner as column values. columns : column, Grouper, array, or sequence of the previous Keys to group by on the pivot table column. If a list is passed, it can contain any of the other types (except list). If an array is passed, it must be the same length as the data and will be used in the same manner as column values. aggfunc : function, list of functions, dict, default "mean" If a list of functions is passed, the resulting pivot table will have hierarchical columns whose top level are the function names (inferred from the function objects themselves). If a dict is passed, the key is column to aggregate and the value is function or list of functions. If ``margins=True``, aggfunc will be used to calculate the partial aggregates. fill_value : scalar, default None Value to replace missing values with (in the resulting pivot table, after aggregation). margins : bool, default False If ``margins=True``, special ``All`` columns and rows will be added with partial group aggregates across the categories on the rows and columns. dropna : bool, default True Do not include columns whose entries are all NaN. If True, * rows with an NA value in any column will be omitted before computing margins, * index/column keys containing NA values will be dropped (see ``dropna`` parameter in :meth:``DataFrame.groupby``). margins_name : str, default 'All' Name of the row / column that will contain the totals when margins is True. observed : bool, default False This only applies if any of the groupers are Categoricals. If True: only show observed values for categorical groupers. If False: show all values for categorical groupers. .. versionchanged:: 3.0.0 The default value is now ``True``. sort : bool, default True Specifies if the result should be sorted. **kwargs : dict Optional keyword arguments to pass to ``aggfunc``. .. versionadded:: 3.0.0 Returns ------- DataFrame An Excel style pivot table. See Also -------- DataFrame.pivot : Pivot without aggregation that can handle non-numeric data. DataFrame.melt: Unpivot a DataFrame from wide to long format, optionally leaving identifiers set. wide_to_long : Wide panel to long format. Less flexible but more user-friendly than melt. Notes ----- Reference :ref:`the user guide ` for more examples. Examples -------- >>> df = pd.DataFrame( ... { ... "A": ["foo", "foo", "foo", "foo", "foo", "bar", "bar", "bar", "bar"], ... "B": ["one", "one", "one", "two", "two", "one", "one", "two", "two"], ... "C": [ ... "small", ... "large", ... "large", ... "small", ... "small", ... "large", ... "small", ... "small", ... "large", ... ], ... "D": [1, 2, 2, 3, 3, 4, 5, 6, 7], ... "E": [2, 4, 5, 5, 6, 6, 8, 9, 9], ... } ... ) >>> df A B C D E 0 foo one small 1 2 1 foo one large 2 4 2 foo one large 2 5 3 foo two small 3 5 4 foo two small 3 6 5 bar one large 4 6 6 bar one small 5 8 7 bar two small 6 9 8 bar two large 7 9 This first example aggregates values by taking the sum. >>> table = pd.pivot_table( ... df, values="D", index=["A", "B"], columns=["C"], aggfunc="sum" ... ) >>> table C large small A B bar one 4.0 5.0 two 7.0 6.0 foo one 4.0 1.0 two NaN 6.0 We can also fill missing values using the `fill_value` parameter. >>> table = pd.pivot_table( ... df, values="D", index=["A", "B"], columns=["C"], aggfunc="sum", fill_value=0 ... ) >>> table C large small A B bar one 4 5 two 7 6 foo one 4 1 two 0 6 The next example aggregates by taking the mean across multiple columns. >>> table = pd.pivot_table( ... df, values=["D", "E"], index=["A", "C"], aggfunc={"D": "mean", "E": "mean"} ... ) >>> table D E A C bar large 5.500000 7.500000 small 5.500000 8.500000 foo large 2.000000 4.500000 small 2.333333 4.333333 We can also calculate multiple types of aggregations for any given value column. >>> table = pd.pivot_table( ... df, ... values=["D", "E"], ... index=["A", "C"], ... aggfunc={"D": "mean", "E": ["min", "max", "mean"]}, ... ) >>> table D E mean max mean min A C bar large 5.500000 9 7.500000 6 small 5.500000 9 8.500000 8 foo large 2.000000 5 4.500000 4 small 2.333333 6 4.333333 2 ) valuesindexcolumns fill_valueaggfuncmarginsdropna margins_nameobservedsortkwargs__name__)keysaxis pivot_table)method) _convert_by isinstancelist__internal_pivot_tableappendgetattrr __finalize__)datar!r"r#r%r$r&r'r(r)r*r+piecesr.func_tabletables V/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pandas/core/reshape/pivot.pyr0r06st  E'"G'4  "$D+%)! F MM& ! KKj$7 8!$vq1!!$}!== "    E   d=  99c 6 X#-n USLn U (a[U5(aSn[U5nOSnU/nUHnX;dM [U5e /nX-H>n[U[5(a UR nUU;aUR U5 M>M@ [U5[UR5:aUUnO2URnU HnURU5nM [U5nURXXS9nU (aUUnUR"U40U D6nU(a>[U[5(a)[UR5(aURSS9nUnUR R"S:aU(aUR R$S[U5n/n['[U5[U 55HInUR R$UnUbUU;aUR U5 M8UR U5 MK UR)UUS9nU(d[UR [*5(aN[*R,"UR R.UR R$S 9nUR1US US 9n[UR[*5(aN[*R,"URR.URR$S 9nUR1USUS 9nU SLa$[U[5(aUR3SS 9nUb[UR5U5nU[LaAU (d:[6R8"U5(aUR;[<R>5nU(a9U(aXRA5RCSS 9n[EUUUUUUU UUUUS 9 nU (aAW(d:URR"S:a URRGS 5Ul [U5S :Xa[U5S :a URHn[U[5(aU(aURSSS9nU$![a GM(f=f![[[4a GMf=f)zD Helper of :func:`pandas.pivot_table` for any non-list ``aggfunc``. NTF)r)r*r'all)howr-r$namesr)r/r$r/)rowscolsr%r+r)r(r$r')rBr/)%r r4KeyErrorr3rkeyr6 TypeErrorlenr#drop ValueErrorgroupbyaggrr'r"nlevelsrErangeunstackr from_productlevelsreindex sort_indexfillnar is_integerastypenpint64notnarA _add_margins droplevelT)r9r!r"r#r%r$r&r'r(r)r*r+r. values_passed values_multii to_filterxrJgroupedaggedr= index_names to_unstacknamems r>r5r5s" ?D$&M   L&\F LXFA}qk! A!W%%EE 9$$Q'  y>C - - ?DC S) fll4lMG&/ KK *6 *E *UL11c%--6H6H  ' E {{Q5kk'' #e*5  s5z3t9-A;;$$Q'D|t{2!!!$!!$' .  jZ @  ekk: . .'' (:(:%++BSBSTAMM!! MCE emmZ 0 0'' (<((s~~j/I/ILL*E  ((a(01D   %!  \emm.C.Ca.G //2  5zQ3w, Q;:Q;>RRc [U[5(d [S5eSUS3n URRH,n XRR U 5;dM#[U 5e [ XXVU5n URS:XaIURRSSH,n XRR U 5;dM#[U 5e [U5S:aU4S[U5S- --nOUnU(d9[U[5(a$URURXU055$U(a2[UUUUUUUUUU 5 n[U[5(dU$UunnnOC[U[5(de[!XX4XVXxU 5 n[U[5(dU$UunnnUR#URU S9nUH-n[U[5(a U UUU'M"U USUU'M/ SS KJn U"U[)U/5S 9R*nURRn[-UR.5HQn[U[05(aMUR3U/5RnUUR5[6U4S 9UU'MS [9UU/5nUURlU$) Nz&margins_name argument must be a stringzConflicting name "z " in marginsr-rCrr)r#)args)r3strrNr"rEget_level_values_compute_grand_marginndimr#rLr_append_internal _constructor_generate_marginal_resultstupler)_generate_marginal_results_without_valuesrVrrrr`setdtypesr select_dtypesapplyr r)r=r9r!rGrHr%r+r)r(r$r'msglevel grand_marginrJmarginal_result_setresult margin_keys row_marginkr margin_dummy row_namesdtypes r>r^r^s lC ( (ABB |nL 9C"" ;;77> >S/ !#)w UL zzQ]]((,E}}==eDD o%-  4y1}oTQ 77 j 22%%   ,%?@ A   8            -u55& &*=' Z%....G Whf -u55& &*=' Z##FNNz#JJ  a  (OJqM(1.JqM  !Zu>@@L ""IV]]# e^ , , ##UG,44)$/55 #5(6 T $V\* +F"FLL Mr?cU(a0nXR5Hupg[U[5(a[Xr5"S0UD6XV'M0[U[5(a>[X&[5(a[XrU5"S0UD6XV'MtX&"U40UD6XV'MU"U40UD6XV'M U$XB"UR 40UD60$![ a Mf=f)N)itemsr3rqr7dictrKr")r9r!r%r+r(rrvs r>rsrss L&&(DA gs++&-a&9&CF&CLO..!'*c22*1!QZ*@*J6*J *1*Q*A&*A &-a&:6&:LO)gdjj;F;<<   s$(C AC C C CCc $^^[T5S:Ga/n /n UU4Sjn [U5S:aXU-RX7U S9R"U40UD6n SnURRSUS9HCunnURnU "U5nXUU'U R U5 U R U5 ME GO3UTSSU-RTSSXyS9R"U40UD6Rn SnURSUS9Hunn[T5S:a U "U5nOTnU R U5 XR 5Rn[ UR[5(a4[R"U//URRQSPS9UlO$[U/URRS9UlU R U5 U R U5 M U (dU$[XS9n[U5S:XaU$OUnURn [T5S:aUTU-RTXyS9R"U40UD6nUR5n[ R""[T5/[%[T555nUVs/sHnURRUPM nnURR'U5UlO(UR)[*R,URS 9nUU U4$s snf) Nrc0>UT4S[T5S- --$)Nrnr-rL)rJrHr(s r>_all_key,_generate_marginal_results.._all_key*s &#d)a-)@@ @r?r)r'r-)rr)rDrjrFr")rLrOrPr`r6to_framer3r"r from_tuplesrErrjrr#stack itertoolschainrRreorder_levels_constructor_slicedr[nan)r=r9r!rGrHr%r+r)r(r' table_piecesrrmargincat_axisrJpieceall_keytransformed_piecerrnew_order_indicesrcnew_order_namess ` ` r>rwrws 4y1}   A t9q=F]#@( &(  H#ggooAoI U"3-!'g##E*""7+JT"1X&'bqHD( &( H#mm!hmG Ut9q=&smG*G##E*$*K$8$8$:$<$<!ekk:66.8.D.D 8 1 1848/%+ /4WIEKKDTDT.U%+##$56""7+%H(LL8F t9>M mm  4y1}   WTHW < S  $" $   %%' &OOSYKs4y9IJ>OP>O:++11!4>OP%++::?K --bffFNN-K ; ** Qs#L c .^^[T5S:a/n UU4Sjn [U5S:aCURX&US9UR"U40UD6n U "5n XU 'Un U RU 5 OOURSXhS9R"U40UD6n U "5n XU 'Un U RU 5 U $Un URn [T5(a%URTXhS9TR"U40UD6nO"[ [ RU RS9nXU4$)NrcP>[T5S:XaT$T4S[T5S- --$)Nr-rnr)rHr(sr>r;_generate_marginal_results_without_values.._all_keys.4yA~## ?Uc$i!m%<< ryryxs. 4y1}  = t9q=\\$&\I$OUU!FjG#'NF   w '\\H\LRR!FjG#'NF   w 'Mmm  4yy\\$\I$OUU   BFF&..9  **r?cUc/nU$[U5(d?[U[R[[ [ 45(d[U5(aU/nU$[U5nU$N) r r3r[ndarrayrrrcallabler4)bys r>r2r2s_ z  I " b2::uiA B B B<<T I"X Ir?)r"r!c[R"U5n[SURR55(aWUR SS9nURRVs/sHoUbUO[ RPM snURlU[ RLaRU[ RLa[R"U5nO/nU[ RLnURXd-US9nGOvU[ RLa[UR[5(aH[URR5V s/sHoRRU 5PM n n OXURURURRS9/n O([R"U5V s/sHoU PM n n UV s/sHoU PM n n U R!U 5 [R""U 5n[%U5(a=[U[&5(d(UR)XR*U[-SU5S9nOURXR*US 9n[-S UR/U55nURRVs/sHoU[ RLaUOSPM snURlU$s snfs sn fs sn fs sn fs snf) a0 Return reshaped DataFrame organized by given index / column values. Reshape data (produce a "pivot" table) based on column values. Uses unique values from specified `index` / `columns` to form axes of the resulting DataFrame. This function does not support data aggregation, multiple values will result in a MultiIndex in the columns. See the :ref:`User Guide ` for more on reshaping. Parameters ---------- data : DataFrame Input pandas DataFrame object. columns : Hashable or a sequence of the previous Column to use to make new frame's columns. index : Hashable or a sequence of the previous, optional Column to use to make new frame's index. If not given, uses existing index. values : Hashable or a sequence of the previous, optional Column(s) to use for populating new frame's values. If not specified, all remaining columns will be used and the result will have hierarchically indexed columns. Returns ------- DataFrame Returns reshaped DataFrame. Raises ------ ValueError: When there are any `index`, `columns` combinations with multiple values. `DataFrame.pivot_table` when you need to aggregate. See Also -------- DataFrame.pivot_table : Generalization of pivot that can handle duplicate values for one index/column pair. DataFrame.unstack : Pivot based on the index values instead of a column. wide_to_long : Wide panel to long format. Less flexible but more user-friendly than melt. Notes ----- For finer-tuned control, see hierarchical indexing documentation along with the related stack/unstack methods. Reference :ref:`the user guide ` for more examples. Examples -------- >>> df = pd.DataFrame( ... { ... "foo": ["one", "one", "one", "two", "two", "two"], ... "bar": ["A", "B", "C", "A", "B", "C"], ... "baz": [1, 2, 3, 4, 5, 6], ... "zoo": ["x", "y", "z", "q", "w", "t"], ... } ... ) >>> df foo bar baz zoo 0 one A 1 x 1 one B 2 y 2 one C 3 z 3 two A 4 q 4 two B 5 w 5 two C 6 t >>> df.pivot(index="foo", columns="bar", values="baz") bar A B C foo one 1 2 3 two 4 5 6 >>> df.pivot(index="foo", columns="bar")["baz"] bar A B C foo one 1 2 3 two 4 5 6 >>> df.pivot(index="foo", columns="bar", values=["baz", "zoo"]) baz zoo bar A B C A B C foo one 1 2 3 x y z two 4 5 6 q w t You could also assign a list of column names or a list of index names. >>> df = pd.DataFrame( ... { ... "lev1": [1, 1, 1, 2, 2, 2], ... "lev2": [1, 1, 2, 1, 1, 2], ... "lev3": [1, 2, 1, 2, 1, 2], ... "lev4": [1, 2, 3, 4, 5, 6], ... "values": [0, 1, 2, 3, 4, 5], ... } ... ) >>> df lev1 lev2 lev3 lev4 values 0 1 1 1 1 0 1 1 1 2 2 1 2 1 2 1 3 2 3 2 1 2 4 3 4 2 1 1 5 4 5 2 2 2 6 5 >>> df.pivot(index="lev1", columns=["lev2", "lev3"], values="values") lev2 1 2 lev3 1 2 1 2 lev1 1 0.0 1.0 2.0 NaN 2 4.0 3.0 NaN 5.0 >>> df.pivot(index=["lev1", "lev2"], columns=["lev3"], values="values") lev3 1 2 lev1 lev2 1 1 0.0 1.0 2 2.0 NaN 2 1 4.0 3.0 2 NaN 5.0 A ValueError is raised if there are any duplicates. >>> df = pd.DataFrame( ... { ... "foo": ["one", "one", "two", "two"], ... "bar": ["A", "A", "B", "C"], ... "baz": [1, 2, 3, 4], ... } ... ) >>> df foo bar baz 0 one A 1 1 one A 2 2 two B 3 3 two C 4 Notice that the first two rows are the same for our `index` and `columns` arguments. >>> df.pivot(index="foo", columns="bar", values="baz") Traceback (most recent call last): ... ValueError: Index contains duplicate entries, cannot reshape c3(# UHoSLv M g7frr).0rjs r> pivot..Zs 5$4D4<$4sF)deepN)r6rr)r"r#rr)comconvert_to_list_likeanyr"rEcopyr no_default set_indexr3rrRrQrrrrjextend from_arraysr rxrv_valuesrrS)r9r#r"r!columns_listlikerjrHr6indexedrc index_listidxcol data_columns multiindexrs r>pivotrst//8  5DJJ$4$4 555yyey$EIZZEUEU EUT$D#.. 8EU     &++E2DD#..(..  #!  CNN "$**j11=B$**BTBT-=cS -= >,'++J7    65(A(A'' $$ -v6(G ..t|/C/C:.VG +w/?@ AFAGASASASCNN*4ASFLL Mo .P>$s)K$K K%K*' K/c UcUb [S5eUbUc [S5e[U5(dU/n[U5(dU/nSn X-V s/sH"n [U [[45(dM U PM$ n n U (a [ U SSS9n [ XSS9n[ XS S9n[X45un nnnS S KJ n 0[[XSS 95E[[UUSS 95EnU"UU S 9nUcS US'[S S.nO UUS'SU0nUR"SUUUUUUS.UD6nU SLa [UXUS9nURU S S9nURUSS9nU$s sn f)a! Compute a simple cross tabulation of two (or more) factors. By default, computes a frequency table of the factors unless an array of values and an aggregation function are passed. Parameters ---------- index : array-like, Series, or list of arrays/Series Values to group by in the rows. columns : array-like, Series, or list of arrays/Series Values to group by in the columns. values : array-like, optional Array of values to aggregate according to the factors. Requires `aggfunc` be specified. rownames : sequence, default None If passed, must match number of row arrays passed. colnames : sequence, default None If passed, must match number of column arrays passed. aggfunc : function, optional If specified, requires `values` be specified as well. margins : bool, default False Add row/column margins (subtotals). margins_name : str, default 'All' Name of the row/column that will contain the totals when margins is True. dropna : bool, default True Do not include columns whose entries are all NaN. normalize : bool, {'all', 'index', 'columns'}, or {0,1}, default False Normalize by dividing all values by the sum of values. - If passed 'all' or `True`, will normalize over all values. - If passed 'index' will normalize over each row. - If passed 'columns' will normalize over each column. - If margins is `True`, will also normalize margin values. Returns ------- DataFrame Cross tabulation of the data. See Also -------- DataFrame.pivot : Reshape data based on column values. pivot_table : Create a pivot table as a DataFrame. Notes ----- Any Series passed will have their name attributes used unless row or column names for the cross-tabulation are specified. Any input passed containing Categorical data will have **all** of its categories included in the cross-tabulation, even if the actual data does not contain any instances of a particular category. In the event that there aren't overlapping indexes an empty DataFrame will be returned. Reference :ref:`the user guide ` for more examples. Examples -------- >>> a = np.array( ... [ ... "foo", ... "foo", ... "foo", ... "foo", ... "bar", ... "bar", ... "bar", ... "bar", ... "foo", ... "foo", ... "foo", ... ], ... dtype=object, ... ) >>> b = np.array( ... [ ... "one", ... "one", ... "one", ... "two", ... "one", ... "one", ... "one", ... "two", ... "two", ... "two", ... "one", ... ], ... dtype=object, ... ) >>> c = np.array( ... [ ... "dull", ... "dull", ... "shiny", ... "dull", ... "dull", ... "shiny", ... "shiny", ... "dull", ... "shiny", ... "shiny", ... "shiny", ... ], ... dtype=object, ... ) >>> pd.crosstab(a, [b, c], rownames=["a"], colnames=["b", "c"]) b one two c dull shiny dull shiny a bar 1 2 1 0 foo 2 2 1 2 Here 'c' and 'f' are not represented in the data and will not be shown in the output because dropna is True by default. Set dropna=False to preserve categories with no data. >>> foo = pd.Categorical(["a", "b"], categories=["a", "b", "c"]) >>> bar = pd.Categorical(["d", "e"], categories=["d", "e", "f"]) >>> pd.crosstab(foo, bar) col_0 d e row_0 a 1 0 b 0 1 >>> pd.crosstab(foo, bar, dropna=False) col_0 d e f row_0 a 1 0 0 b 0 1 0 c 0 0 0 Nz&aggfunc cannot be used without values.z)values cannot be used without an aggfunc.TF) intersectr*row)prefixrrr)strictr __dummy__)r%r$r%)r"r#r&r(r'r)) normalizer&r()r"r/r-)r#r/)r)rNr r3rrr _get_names_build_names_mapperrrrziprLr0 _normalize rename_axis)r"r#r!rownamescolnamesr%r&r(r'r common_idxre pass_objsrownames_mapperunique_rownamescolnames_mapperunique_colnamesrr9dfr+r=s r>crosstabrsh~'-ABB goDEE u % % w ' ')J!OXOqz!i=V/WOIX+IER %%8H'E:H H/ !  s?$7 8  s?GD9 : D 4z *B ~; 2 ;W% NN !   E Yl    O!  E LiYs E4Ec~[U[[45(d SSS.nXAnUSLa1SSSS .nUS US 'XanU"U5nUR S 5nU$US LGaUR nURn URS SS24Rn X:;X::g-(a[ US35eURSS 2S 4n URS SS 24n URSS 2SS 24n[XSS9nUS:Xa6XR5- n [X /SS9nUR S 5nXlU$US:Xa;XR5- n URU S S9nUR S 5nXlU$US :XdUS LamXR5- n XR5- n SU RU'[X /SS9nURU S S9nUR S 5nXlXlU$[ S5e[ S5e![an[ S5UeSnAff=f![an[ S5UeSnAff=f)Nr"r#)rr-zNot a valid normalize argumentFc>XRSS9RSS9- $Nr-rFrsumres r>_normalize..zsQA!2!2!2!::r?c&XR5- $rrrs r>rr{s UUWr?c<URURSS9SS9$r)divrrs r>rr|squuQUUU]u;r?)rAr#r"rATrz not in pivoted DataFrame)rr&r-rF) ignore_indexzNot a valid margins argument)r3boolrqrIrNrXr"r#ilocrjrrrruloc) r=rr&r( axis_subserr normalizersf table_index table_columnslast_ind_or_col column_margin index_margins r>rrms i$ - -I.  H!,I%;,;3 (. D H&A% Qf Lc Dkk  **RU+00  /L4S T ~-FGH H 3B37+ zz"crc'*  3B38$5uE  !),=,=,??ME1:ELLOE)M2 L/' !'*:*:*< >788I H=>C G H H=>C G Hs.HH! H HH! H<+ H77H<clUcm/n[U5HZup4[U[5(a*URbUR UR5 MDUR USU35 M\ U$[ U5[ U5:wa [ S5e[U[5(d [U5nU$)N_z*arrays and names must have the same length) enumerater3rrjr6rLAssertionErrorr4)arrsrErrcarrs r>rrs }oFA#y))chh.B SXX& xq_- & L u:T " !MN N%&&KE Lr?c[U5[U5-n[U5VVs0sHup4XB;dM SU3U_M nnn[U5VVs/sHup4XB;aSU3OUPM nnn[U5VVs0sHup4XB;dM SU3U_M nnn[U5VVs/sHup4XB;aSU3OUPM nnnXVXx4$s snnfs snnfs snnfs snnf)aT Given the names of a DataFrame's rows and columns, returns a set of unique row and column names and mappers that convert to original names. A row or column name is replaced if it is duplicate among the rows of the inputs, among the columns of the inputs or between the rows and the columns. Parameters ---------- rownames: list[str] colnames: list[str] Returns ------- Tuple(Dict[str, str], List[str], Dict[str, str], List[str]) rownames_mapper: dict[str, str] a dictionary with new row names as keys and original rownames as values unique_rownames: list[str] a list of rownames with duplicate names replaced by dummy names colnames_mapper: dict[str, str] a dictionary with new column names as keys and original column names as values unique_colnames: list[str] a list of column names with duplicate names replaced by dummy names row_col_)rzr) rr dup_namesrcrjrrrrs r>rrs:H H -I)2((;(;WQt?P$qc D(;BK8ATATgad'$qc T1AT )2((;(;WQt?P$qc D(;BK8ATATgad'$qc T1AT _ MMs" C CC9 C C#C) NNNmeanNFTAllTT)r9rr%rr&rr'rr(rr)rr*rreturnr)r9rr%z!AggFuncTypeBase | AggFuncTypeDictr&rr'rr(rr)rr*rrr)rNT) r=zDataFrame | Seriesr9rr)rr(rr'r)r)r9rr(r)rT)r9rr)rr(rr'r) r=rr9rr)rr(rr'r) r9rr#rr"IndexLabel | lib.NoDefaultr!rrr)NNNNFrTF) r&rr(rr'rrz/bool | Literal[0, 1, 'all', 'index', 'columns']rr)r=rr&rr(rrr)r)rrqrr4)r list[str]rrrz;tuple[dict[str, str], list[str], dict[str, str], list[str]])> __future__rrtypingrrrnumpyr[ pandas._libsrpandas.util._decoratorsrpandas.core.dtypes.castr pandas.core.dtypes.commonr r r pandas.core.dtypes.dtypesr pandas.core.dtypes.genericrrpandas.core.commoncorecommonrpandas.core.groupbyrpandas.core.indexes.apirrrpandas.core.reshape.concatrpandas.core.seriesrcollections.abcrrpandas._typingrrrrrrrr0r5r^rsrwryr2rrrrrrrr?r>rs\" .; 5 ! ' .% ! H   !"b: b:  b:b: b:b:b: b:b:b:J@ @ / @@ @@@ @@X#_ _ ___ _FHM= =FMM`"-N-N#,-N@-Nr?