B W0d!2@s:dZddlmZddlmZddlmZddlmZm Z m Z m Z m Z m Z mZddlmZmZddlmZmZddlmZdd lmZdd lmmZdd lmZerdd lm Z d ddddZ!ddddZ"dddddZ#dddddZ$ddd d!d"Z%d#d#d$d%d&Z&d'd(d)d*d+d,d-d.Z'dd/dd0d1Z(d S)2z aggregation.py contains utility functions to handle multiple named and lambda kwarg aggregations in groupby and DataFrame/Series aggregation ) annotations) defaultdict)partial) TYPE_CHECKINGAnyCallable DefaultDictHashableIterableSequence) AggFuncType FrameOrSeries) is_dict_like is_list_like) ABCSeries)SpecificationErrorN)Index)SerieszAggFuncType | NonezCtuple[bool, AggFuncType | None, list[str] | None, list[int] | None])funcreturncKst|dkotf|}d}d}|sVt|trFt|tt|krFtdn|dkrVtd|rht|\}}}||||fS)a This is the internal function to reconstruct func given if there is relabeling or not and also normalize the keyword to get new order of columns. If named aggregation is applied, `func` will be None, and kwargs contains the column and aggregation function information to be parsed; If named aggregation is not applied, `func` is either string (e.g. 'min') or Callable, or list of them (e.g. ['min', np.max]), or the dictionary of column name and str/Callable/list of them (e.g. {'A': 'min'}, or {'A': [np.min, lambda x: x]}) If relabeling is True, will return relabeling, reconstructed func, column names, and the reconstructed order of columns. If relabeling is False, the columns and order will be None. Parameters ---------- func: agg function (e.g. 'min' or Callable) or list of agg functions (e.g. ['min', np.max]) or dictionary (e.g. {'A': ['min', np.max]}). **kwargs: dict, kwargs used in is_multi_agg_with_relabel and normalize_keyword_aggregation function for relabelling Returns ------- relabelling: bool, if there is relabelling or not func: normalized and mangled func columns: list of column names order: list of columns indices Examples -------- >>> reconstruct_func(None, **{"foo": ("col", "min")}) (True, defaultdict(, {'col': ['min']}), ('foo',), array([0])) >>> reconstruct_func("min") (False, 'min', None, None) NzFFunction names must be unique if there is no new column names assignedz4Must provide 'func' or tuples of '(column, aggfunc).)is_multi_agg_with_relabel isinstancelistlensetr TypeErrornormalize_keyword_aggregation)rkwargsZ relabelingcolumnsorderr I/var/www/html/venv/lib/python3.7/site-packages/pandas/core/aggregation.pyreconstruct_func's'r"bool)rcKs"tdd|Do t|dkS)ax Check whether kwargs passed to .agg look like multi-agg with relabeling. Parameters ---------- **kwargs : dict Returns ------- bool Examples -------- >>> is_multi_agg_with_relabel(a="max") False >>> is_multi_agg_with_relabel(a_max=("a", "max"), a_min=("a", "min")) True >>> is_multi_agg_with_relabel() False css$|]}t|tot|dkVqdS)N)rtupler).0vr r r! zsz,is_multi_agg_with_relabel..r)allvaluesr)rr r r!resrdictz!tuple[dict, list[str], list[int]])rrc Cstt}g}tt|\}}x6|D].\}}|||||t|pN|fq&Wt|}dd|D}t|} t|  |} ||| fS)aL Normalize user-provided "named aggregation" kwargs. Transforms from the new ``Mapping[str, NamedAgg]`` style kwargs to the old Dict[str, List[scalar]]]. Parameters ---------- kwargs : dict Returns ------- aggspec : dict The transformed kwargs. columns : List[str] The user-provided keys. col_idx_order : List[int] List of columns indices. Examples -------- >>> normalize_keyword_aggregation({"output": ("input", "sum")}) (defaultdict(, {'input': ['sum']}), ('output',), array([0])) cSs,g|]$\}}|D]}|t|p"|fqqSr )comget_callable_name)r&columnaggfuncsaggfuncr r r! sz1normalize_keyword_aggregation..) rrzipitemsappendr,r-_make_unique_kwarg_listr get_indexer) rZaggspecrrpairsr.r0Zuniquified_orderZ aggspec_orderZuniquified_aggspec col_idx_orderr r r!rs rzSequence[tuple[Any, Any]])seqrcsfddtDS)a Uniquify aggfunc name of the pairs in the order list Examples: -------- >>> kwarg_list = [('a', ''), ('a', ''), ('b', '')] >>> _make_unique_kwarg_list(kwarg_list) [('a', '_0'), ('a', '_1'), ('b', '')] c sNg|]F\}}|dkrF|dd|dtd||gfn|qS)r_N)countjoinstr)r&ipair)r9r r!r1sz+_make_unique_kwarg_list..) enumerate)r9r )r9r!r5s r5z Sequence[Any])r/rcCs`t|dkr|Sd}g}xB|D]:}t|dkrNt|}d|d|_|d7}||qW|S)aJ Possibly mangle a list of aggfuncs. Parameters ---------- aggfuncs : Sequence Returns ------- mangled: list-like A new AggSpec sequence, where lambdas have been converted to have unique names. Notes ----- If just one aggfunc is passed, the name will not be mangled. r:rzz)rr,r-r__name__r4)r/r?mangled_aggfuncsr0r r r!_managle_lambda_lists  rEr)agg_specrcCspt|}|st|s|St|}|rdxD|D].\}}t|rRt|sRt|}n|}|||<q0Wnt|}|S)aZ Make new lambdas with unique names. Parameters ---------- agg_spec : Any An argument to GroupBy.agg. Non-dict-like `agg_spec` are pass through as is. For dict-like `agg_spec` a new spec is returned with name-mangled lambdas. Returns ------- mangled : Any Same type as the input. Examples -------- >>> maybe_mangle_lambdas('sum') 'sum' >>> maybe_mangle_lambdas([lambda: 1, lambda: 2]) # doctest: +SKIP [, .f(*args, **kwargs)>] )rrtyper3rE)rFZis_dictZmangled_aggspeckeyr/rDr r r!maybe_mangle_lambdass   rIr zdict[str, list[Callable | str]]zIterable[Hashable]z Iterable[int]zdict[Hashable, Series])resultrrrrc Csddtt||dddD}i}d}t|t o@t|jdk}x~|D]r\}} ||} |rdd| D} t| j  | } | | } |||t| | _ | j |d d ||<|t| }qLW|S) a Internal function to reorder result if relabelling is True for dataframe.agg, and return the reordered result in dict. Parameters: ---------- result: Result from aggregation func: Dict of (column name, funcs) columns: New columns name for relabelling order: New order for relabelling Examples: --------- >>> result = DataFrame({"A": [np.nan, 2, np.nan], ... "C": [6, np.nan, np.nan], "B": [np.nan, 4, 2.5]}) # doctest: +SKIP >>> funcs = {"A": ["max"], "C": ["max"], "B": ["mean", "min"]} >>> columns = ("foo", "aab", "bar", "dat") >>> order = [0, 1, 2, 3] >>> _relabel_result(result, func, columns, order) # doctest: +SKIP dict(A=Series([2.0, NaN, NaN, NaN], index=["foo", "aab", "bar", "dat"]), C=Series([NaN, 6.0, NaN, NaN], index=["foo", "aab", "bar", "dat"]), B=Series([NaN, NaN, 2.5, 4.0], index=["foo", "aab", "bar", "dat"])) cSsg|] }|dqS)rr )r&r@r r r!r1>sz"relabel_result..cSs|dS)Nr:r )tr r r!>z relabel_result..)rHrr:cSs$g|]}t|tst|n|qSr )rr>r,r-)r&fr r r!r1]sF)copy) sortedr2rrrrr3Zdropnarindexr6Zreindex) rJrrrZreordered_indexesZreordered_result_in_dictidxZ reorder_maskcolZfunsr8r r r!relabel_result s  rUz0tuple[list[str], list[str | Callable[..., Any]]]cCsjd}t|}g}x@|D]4}t|tsDt|sDt|t|j| |qW|sbd}t|||fS)a Validates types of user-provided "named aggregation" kwargs. `TypeError` is raised if aggfunc is not `str` or callable. Parameters ---------- kwargs : dict Returns ------- columns : List[str] List of user-provied keys. func : List[Union[str, callable[...,Any]]] List of user-provided aggfuncs Examples -------- >>> validate_func_kwargs({'one': 'min', 'two': 'max'}) (['one', 'two'], ['min', 'max']) z-func is expected but received {} in **kwargs.z2Must provide 'func' or named aggregation **kwargs.) rr*rr>callablerformatrGrCr4)rZtuple_given_messagerrZcol_funcZno_arg_messager r r!validate_func_kwargsjsrX))__doc__ __future__r collectionsr functoolsrtypingrrrrr r r Zpandas._typingr r Zpandas.core.dtypes.commonrrZpandas.core.dtypes.genericrZpandas.core.baserZpandas.core.commoncorecommonr,Zpandas.core.indexes.apirZpandas.core.seriesrr"rrr5rErIrUrXr r r r!s(   $     >9!,J