biUddlmZddlZddlZddlZddlZddlmZddl Z ddl Z ddl mZddlmZddlmZmZmZmZddlmZddlmZdd lmZmZmZdd lmZdd l m!Z!m"Z"m#Z#gd Z$d Z%de&d<dZ'dZ(dHdZ)e%ddddZ*e%ddddZ+e%ddfdZ,dZ-GddZ. dIdZ/ dJdZ0ddddZ1ddddZ2edd d d!Z3dedd fd"Z4dKd#Z5d$Z6ed%d&Z7dLd'Z8d(Z9dKd)Z:d*Z;d+Zd.Z?d/Z@d0ZAd1ZBd2ZCd3ZDd4ZEd5ZF dMd6ZGd7ZHd8ZId9ZJdKd:ZK dHd;ZLd<ZMd=ZNd>ZOdNd?ZPdNd@ZQdNdAZRdBZSdCZTdDZUdEZVdFZWdGZXy)O) annotationsN)partialtokenize)flatten) PANDAS_GE_220 PANDAS_GE_300check_groupby_axis_deprecationcheck_observed_deprecation)_convert_to_numeric)concat)get_numeric_only_kwargsis_dataframe_likeis_series_like) no_default)Mfuncname itemgetter)meanstdvarTz bool | NoneGROUP_KEYS_DEFAULTct|ttfr+t|dkDrtt t|Sy)z1Determine the correct levels argument to groupby.r) isinstancetuplelistlenrangebys Q/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/dask/dataframe/groupby.py_determine_levelsr#'s0"udm$R1E#b'N##ct|s t|r%jj|jSt |t t frtfd|DSy)z/Check if ``df`` and ``by`` have aligned indicesc36K|]}t|ywN) _is_aligned).0idfs r" z_is_aligned..4s2!;r1%2T)rrindexequalsrrrall)r+r!s` r"r(r(/sLb.r2xxrxx(( Bu &2r222r$c b|jd}|t||s d}t||Pt|rE|rCt |t r|g}t |}t|dk(r|d}|j|t5|jdi|cdddS#1swYyxYw)aGroupby, but raise if df and `by` key are unaligned. Pandas supports grouping by a column that doesn't align with the input frame/series/index. However, the reindexing does not seem to be threadsafe, and can result in incorrect results. Since grouping by an unaligned key is generally a bad idea, we just error loudly in dask. For more information see pandas GH issue #15244 and Dask GH issue #1876.r!NaGrouping by an unaligned column is unsafe and unsupported. This can be caused by filtering only one of the object or grouping key. For example, the following works in pandas, but not in dask: df[df.foo < 0].groupby(df.bar) This can be avoided by either filtering beforehand, or passing in the name of the column instead: df2 = df[df.foo < 0] df2.groupby(df2.bar) # or df[df.foo < 0].groupby('bar') For more information see dask GH issue #1876.rrr ) getr( ValueErrorrrstrrupdater groupby)r+convert_by_to_listkwargsr!msgs r"_groupby_raise_unalignedr;9s D B ~k"b1 < $o CG(: b# B "X r7a<AB   # %$rzz#F#$$$s B%%B.) group_keysdropnaobservedc|d|ini}|d|ini}|j|fd|i||} |r| |} | j|g|i|S)Nr=r>r<)r7apply r+grouperkeyfuncr<r=r>argsr9gs r"_groupby_slice_applyrGhsl$*#5h 2F)1)= H%2H 7HzHXHHA cF 1774 )$ )& ))r$c|d|ini}|d|ini}|j|fd|i||} |r| |} t|dk(r| j|g|i|S| j|g|i|S)Nr=r>r<r)r7rr@ transformrAs r"_groupby_slice_transformrJ}s$*#5h 2F)1)= H%2H 7HzHXHHA cF 2w!|qwwt-d-f-- 1;;t -d -f --r$c |d|ini}|d|ini}|r|j}|j|fd|i||}|r||}t5|jdi|} ddd| S#1swY SxYw)Nr=r>r<r2) sort_indexr7r shift) r+rBrCshuffledr<r=r>r9rFresults r"_groupby_slice_shiftrPs$*#5h 2F)1)= H%2H ]]_ 7HzHXHHA cF ' )#"6"# M# Ms A((A2ct||d} t|r||}|j|S#t$r"t|r||}|jddcYSwxYw)NF)r!r8r)r;r get_groupKeyErroriloc)r+by_keyget_keycolumnsgroupeds r"_groupby_get_grouprYsj&rfOG  R g&G  ))  R GBwwq| s 1(AAceZdZdZddZy) AggregationaUser defined groupby-aggregation. This class allows users to define their own custom aggregation in terms of operations on Pandas dataframes in a map-reduce style. You need to specify what operation to do on each chunk of data, how to combine those chunks of data together, and then how to finalize the result. See :ref:`dataframe.groupby.aggregate` for more. Parameters ---------- name : str the name of the aggregation. It should be unique, since intermediate result will be identified by this name. chunk : callable a function that will be called with the grouped column of each partition, takes a Pandas SeriesGroupBy in input. It can either return a single series or a tuple of series. The index has to be equal to the groups. agg : callable a function that will be called to aggregate the results of each chunk. Again the argument(s) will be a Pandas SeriesGroupBy. If ``chunk`` returned a tuple, ``agg`` will be called with all of them as individual positional arguments. finalize : callable an optional finalizer that will be called with the results from the aggregation. Examples -------- We could implement ``sum`` as follows: >>> custom_sum = dd.Aggregation( ... name='custom_sum', ... chunk=lambda s: s.sum(), ... agg=lambda s0: s0.sum() ... ) # doctest: +SKIP >>> df.groupby('g').agg(custom_sum) # doctest: +SKIP We can implement ``mean`` as follows: >>> custom_mean = dd.Aggregation( ... name='custom_mean', ... chunk=lambda s: (s.count(), s.sum()), ... agg=lambda count, sum: (count.sum(), sum.sum()), ... finalize=lambda count, sum: sum / count, ... ) # doctest: +SKIP >>> df.groupby('g').agg(custom_mean) # doctest: +SKIP Though of course, both of these are built-in and so you don't need to implement them yourself. Nc<||_||_||_||_yr')chunkaggfinalize__name__)selfnamer]r^r_s r"__init__zAggregation.__init__s    r$r')r` __module__ __qualname____doc__rcr2r$r"r[r[s 3jr$r[Fc |d|ini}|d|ini}t5|jd||d||}ddd|fi|S#1swYxYw)Nr=r>levelsortr2)r r7)r+aggfunclevelsr=rjr>r9rXs r"_groupby_aggregatermst$*#5h 2F)1)= H%2H # %L"**K6KKFKL 7 %f %%LLs AA c r|d|ini}|d|ini}|jd||d||j|fi|S)zq A simpler version of _groupby_aggregate that just calls ``aggregate`` using the user-provided spec. r=r>rhr2)r7 aggregate)r+specrlr=rjr>r9s r"_groupby_aggregate_specrq s`$*#5h 2F)1)= H%2H N:2:: DF D DV D N N   r$)r=r>c t|rI|jjt|dk(r|dn t ||j }nT|jt |}t |ttttjfr t |}||}|durd}t |jtjrJd}|jjjj|jj }nt |jtj rqt#d|jj$DrKd}tj j'|jj$|jj(}|r|j+|j} |j,D cic]'} | tj.| || j0)} } tj2| } tj4|| g}|Scc} w)z A non-aggregation agg function. This simulates the behavior of an initial partitionwise aggregation, but doesn't actually aggregate or throw away any data. rrFTc3PK|]}t|tj ywr')rpdCategoricalIndex)r)ris r"r,z!_non_agg_chunk..<s"= 7r!r9rOhas_categoricals full_indexnew_catsc empty_dataemptys r"_non_agg_chunkrs b((#b'Q,ADHMbggVd2h' cE4bhh7 8s)C5  fllB$7$7 8# 00557>>v||?P?PQJ  bmm 4= @F @S@S= :  $ 33 ##6<<+=+=4J ":??6<<#@"@AH 29986!9??CCJLL,EYY/F Ms",H>c4|jd}|jd}|d|ini}|d|ini}t|fd|i||}t|s| ||fi|St|tt t tjfr t |}|||fi|S)Nr]rWr=r>r!) popr;rrrrr|rtr})r+r=r>r!r9rDrWrFs r" _apply_chunkrQs ::g Djj#G#)#5h 2F)1)= H%2H AAhA&AAbW_A   gtS"((; <7mGAgJ)&))r$) numeric_onlyr>r=ct|}t|r|j}|j}t ||||}|j di|}||j jjd}|j } || dz|| <t ||||} | j di|jd} t|| |gdS) N)r!r>r=c |dfSNz-countr2rs r"z_var_chunk..js q(mr$rWc |dfS)Nz-x2r2rs r"rz_var_chunk..ps E r$raxisr2) rrrzrr;sumrWcountrr ) r+rr>r=r!numeric_only_kwargsrFxncolsg2x2s r" _var_chunkr`s1,?b [[] B XfMA $#$A !)) ##,C#DA 99D$x1}BtH !"hv NB  &% & - -6J - KB 1b!*1 %%r$ct|}|j||||jdi|}t|j}||jd|dz} ||j|dzd|zdzj d} ||j| dzdj d} | | dz| z z } | |z } d| | dk<| | z} t j| | |z dk(<t| sJd| | dk<| S) N)rirjr>r=rc |dSNrr2rs r"rz_var_agg..s adr$rc |dSrr2rs r"rz_var_agg..s !A$r$rr2) rr7rrrWrnpnanr)rFrlddofrjrr>r=rncrrrrOdivs r"_var_aggrus#2,?P THV LPP   A QYYB !))IbAg A 199R1Wq2v{ + , 3 3N 3 KB !))RC1HJ  '''?A!Q$(]F d(CCaL cMF ffFAH? V $$ $F6A: Mr$ctttj|d}t|}tt |}t t |t |}tj||jdD]:\}}||} ||} | || zz} ||} |d|z} |d|z}tj| |z}|dz }d||dk<|| ||||z|z z jd|jdz }|r||}||}||||dz| z z jd|jdz }||||dz|z z jd|jdz }tj||z}|dk(rtj}n||z }||| <||k7s.|| z| z} ||| <=|}tjj||g}tj ||S)Nr)repeatz%s-countrr)r.)rritproductrdictzipcombinations_with_replacementrWrsqrtvaluesrrtrrr)r+rr num_elementsnum_colsvalscol_idx_mappingr*jryidxmul_colninjrrvaliijj std_val_i std_val_jsqrt_vallevel_1r.s r"_cov_finalizerrs$tBJJtA678L4yH l# $D3tU8_56O00D1A1A1E1 A  A (Q,Cs)  Q   Q  GGBG !eC!G '{RURU]Q..66q9CJJqMI 3qcB3qcBB2a5A:"33;;A>ANIB2a5A:"33;;A>ANIwwy945H1}ffHnS 6Q,"CDI58G MM & &'9 :E 99T ''r$c|j}tj|dD]\}}||}||||z||<tjt |t |_|S)zInternal function to be used with apply to multiply each column in a dataframe by every other column a b c -> a*a, a*b, b*b, b*c, c*c rry) __class__rrrzerosrintr.)r+r_dfr*rcols r" _mul_colsrsn ,,.C00q9!1A3ia52a5=C!S-CI Jr$)rcjt|}t|r|j}|j}|dur7|j ddg}|j D]}t ||d||<tj}t|j D]\}}t|||<|j|}|jj } td|D} | s6|D cgc]} ||  }} | jtj |} t#||} | j$di|} t&rd dini}| j(t*fd | i|j-d d }| | j j/jd }| |||fScc} w)zCovariance Chunk Logic Parameters ---------- df : Pandas.DataFrame std : bool, optional When std=True we are calculating with Correlation Returns ------- tuple Processed X, Multiplied Cols, Fdatetime timedelta)includeTrc32K|]}t|ywr')r)r)ss r"r,z_cov_chunk..s0.#0sr include_groupsr)ridropc |dSrr2rs r"rz_cov_chunk..s 6lr$r2)rrrzr select_dtypesrWr collections OrderedDict enumerater5r_get_numeric_datar differencertr}r;rrr@r reset_indexr)r+rr!rdt_dfr col_mappingr*rris_maskkrFrrmulrs r" _cov_chunkrs2,?b [[] Bu  *k)B C== .s!>!t)!>sT)inplaceF)r=)rrrWr r7rr@ritemsr.rwrr0keysr|r3appendrlrrSr set_levels set_namesr stackr)_trlrrrjtsumsmulscounts col_mappingsrr total_sums total_muls total_countsrOrvinv_col_mappingidx_vals idx_mappingridx_namerris_results r"_cov_aggrs` RA'*Aw$D$ 7??Dr"K%%F%>BBDJ%%F%>BBDJ&>)))7;;=L J 5A> v  ~Dc 2 )4(9(9(;<1q!tX!>>,,.Z5G5G1HHI "&&sC08$ v~~$$Q' (3{+; ; )     " #Ds6>>0012F224u2EF LL;5<<><r)r7rWrr rz)r+rlrjrOs r"_nunique_df_combinerGsB dT :2::a=I     Mr$c*|d|dt||S)N-rrDcolumns r" _make_agg_idr^s!XQvj(4"8!9 ::r$c t|ts2tjt |t j |}g}t|tr|jD]k\ }t|tr)|j fd|jD?t|ts|g}|j fd|Dmntdt|tttftfd|jD }|r|Dcgc] \}}}|||f }}}}|Scc}}}w)a Return a list of ``(result_column, func, input_column)`` tuples. Spec can be - a function - a list of functions - a dictionary that maps input-columns to functions - a dictionary that maps input-columns to a lists of functions - a dictionary that maps input-columns to a dictionaries that map output-columns to functions. The non-group columns are a list of all column names that are not used in the groupby operation. Usually, the result columns are mutli-level names, returned as tuples. If only a single function is supplied or dictionary mapping columns to single functions, simple names are returned as strings (see the first two examples below). Examples -------- >>> _normalize_spec('mean', ['a', 'b', 'c']) [('a', 'mean', 'a'), ('b', 'mean', 'b'), ('c', 'mean', 'c')] >>> spec = collections.OrderedDict([('a', 'mean'), ('b', 'count')]) >>> _normalize_spec(spec, ['a', 'b', 'c']) [('a', 'mean', 'a'), ('b', 'count', 'b')] >>> _normalize_spec(['var', 'mean'], ['a', 'b', 'c']) ... # doctest: +NORMALIZE_WHITESPACE [(('a', 'var'), 'var', 'a'), (('a', 'mean'), 'mean', 'a'), (('b', 'var'), 'var', 'b'), (('b', 'mean'), 'mean', 'b'), (('c', 'var'), 'var', 'c'), (('c', 'mean'), 'mean', 'c')] >>> spec = collections.OrderedDict([('a', 'mean'), ('b', ['sum', 'count'])]) >>> _normalize_spec(spec, ['a', 'b', 'c']) ... # doctest: +NORMALIZE_WHITESPACE [(('a', 'mean'), 'mean', 'a'), (('b', 'sum'), 'sum', 'b'), (('b', 'count'), 'count', 'b')] >>> spec = collections.OrderedDict() >>> spec['a'] = ['mean', 'size'] >>> spec['b'] = collections.OrderedDict([('e', 'count'), ('f', 'var')]) >>> _normalize_spec(spec, ['a', 'b', 'c']) ... # doctest: +NORMALIZE_WHITESPACE [(('a', 'mean'), 'mean', 'a'), (('a', 'size'), 'size', 'a'), (('b', 'e'), 'count', 'b'), (('b', 'f'), 'var', 'b')] c32K|]\}}|f|fywr'r2)r) result_columnrD input_columns r"r,z"_normalize_spec..s)+ t#M2D,Gsc3>K|]}t|f|fywr')r)r)rDrs r"r,z"_normalize_spec..s)#HTN3T<Hszunsupported agg spec of type c36K|]}t|ywr')r)r)subspec compoundss r"r,z"_normalize_spec..s+2 7I&r-)rrrrrrrrextendrr4typerrr) rpnon_group_columnsresruse_flat_columns_rD input_colrrs @@r"_normalize_specr%bs*d dD !&&s+r?r)r_build_agg_args_simple_build_agg_args_var_build_agg_args_std_build_agg_args_mean_build_agg_args_listrr[_build_agg_args_customr4)rrDr7r8r simple_impls r"r/r/s`quu~quu~quu~''155!''177#   HH  K {!!% 4{4/@   " 4K   " 4K   #M4FF #M4FF D+ &%mT<HH-dV455r$c t||}|\}}t|tt||fg|tt||fg|t|tfS)NrrDr*r+r,rr_apply_func_to_columnr)rrDr impl_pair intermediate chunk_implagg_impls r"r@r@.spl3L$J %Lz:  %Lx8  !*\":DFC r$c  td|}td|}td|}|rtd|d|dh}|j|z } | rtd|d|d| t|tt|t j f|tt|t j f|tt| fg|||fD cgc]$} | tt| t j f&c} |ttd |||d |f Scc} w)Nrsum2rzaggregate function 'z0' doesn't support positional arguments, but got rz ' supports z keyword arguments, but got rH)r) sum_column count_column sum2_columnrIr2) r TypeErrorrrrKrrr_compute_sum_of_squares _finalize_var) rrDr7r8rint_sumint_sum2 int_countexpected_kwargsunexpected_kwargsrs r"rArAEsF5,/GFL1HWl3I"4&(XYbXc d  hO#((*_<"4& O3DD`ar`s t    +TAEE-R S -t.sr$rHc&|jdS)NcRttjj|Sr')rrchain from_iterable)r4s r"rz8_build_agg_args_list....stBHH,B,B6,J'Kr$)r@)s0s r"rz&_build_agg_args_list..sBHHK%r$rIrJ)rrDrrMs r"rDrDsm 5L %L/FG  %'   !*\":DFC) r$c Rtt||}|j!|tj|t f}n|t t |j|f}t |tt |j|fg|t t |j|fg|S)N)rDprefixrrI) rrr_operatorrr_apply_func_to_columnsrKr]r^)rrDrrr,s r"rErEs x~| 4C }}"H$7$7$| ||<Dt|r|j|S|jdjj|S)a Group a dataframe and apply multiple aggregation functions. Parameters ---------- df: pandas.DataFrame The dataframe to work on. by: list of groupers If given, they are added to the keyword arguments as the ``by`` argument. funcs: list of result-colum, function, keywordargument triples The list of functions that are applied on the grouped data frame. Has to be passed as a keyword argument. kwargs: All keyword arguments, but ``funcs``, are passed verbatim to the groupby operation of the dataframe Returns ------- aggregated: the aggregated dataframe. r r3rr)rr6rrr;rrrrrrrheadrz) r+r!r9r3rXrOrrDr8rrrs r"_groupby_apply_funcsros. 2w  b " JJw E&r4V4G  $ $ &F,1&( t[  (K ( a #A, 5Q34-#/0 5%&F= !&||F##wwqz""$..v66r$ctj5tjddtt |dr |j }n/t |dr |j }n|jj}ddd|r|j|jdn|jjd}|jjS#1swYcxYw)NignorezYDataFrameGroupBy.grouper is deprecated and will be removed in a future version of pandas.rB_grouperr) warningscatch_warningsfilterwarnings FutureWarninghasattrrBrrgroupingrobjpowr7r)rXrrr+s r"rVrVs  " )  g  7I &??D Wj )##D##((D )(.V   #7;;??13EB ::d    !! ) )s A$CC$c Bt|f|||d|}tj} |D]\} } } | |fi| | | <|j| } | | |} |r9|7t |t tfs!| jdk(r| | jd} | S#t$rYHwxYw)N)r3rirjrr) rorrrrSrrrndimrW) r+r+finalize_funcsrirjargrW is_seriesr9rOrrDfinalize_kwargss r" _agg_finalizer s   !T =C B  $ $ &F0><, t_ $R ;? ;}<\\& !F G_F  O3t - KK1 q)* M   sB BBc,|||S|||Sr'r2)df_likerrDs r"rKrK.s  ~G}   r$ct|r |j}n|jj}tfd|D}|Dcgc]}|| }}||Scc}w)Nc3FK|]}|js|ywr') startswith)r)rris r"r,z)_apply_func_to_columns..<sFSs~~f/ESFs!!)rrWryr0)rrirDrWrs ` r"rkrk5s[!//++%%FGFFG'./ws|/G/ >0s Ac6||||z }t|||Sr')_adjust_for_arrow_na)r+rRrSrOs r"r`r`Bs'  ^b. .F <(8 99r$ct|jtjr;|r#tj||j <|Stj||dk(<|Sr)rryrt ArrowDtypeNAisna)rOr+check_for_isnas r"rrGsJ&,, .  "F2779  M!eeF27O Mr$c |jdd}||}||}||} | |dz|z z } ||z } d| | dk<| | z} tj| ||z dk(<|r t| | S| S)Nrrrr)r3rrr) r+rSrRrT adjust_arrowr9rrrrrOrs r"rWrWQs ::fa D <A :A KB !Q$(]F d(CCaL cMF ffFAH?#FC00 r$c t||||fddi|}tj|}|j|jk7r|j |j}t ||dS)NrFT)r)rWrrryr r)r+rSrRrTr9rOr!s r"r^r^fse  L*k@EIOF ''&/C yyFLL jj& VD AAr$c|j|j|j|}|j|_||||SN fill_value)reindexr{r.)partcum_lastr.rWrDinitialaligns r"_cum_agg_alignedrpsB   T^^E288W  ME**EK W u %%r$c|jj|j}||j|||j|||Sr)r.unionr)abrDrrs r"_cum_agg_filledrvsH GGMM!'' "E  %G , %G , r$c.|j||dzS)Nrr)add)rrrs r"_cumcount_aggregaters 55z5 *Q ..r$c&|dnd|dfd}|S)N z Based on cdd|_|S)Nz9Aggregate using one or more specified operations a Parameters ---------- arg : callable, str, list or dict, optional Aggregation spec. Accepted combinations are: - callable function - string function name - list of functions and/or function names, e.g. ``[np.sum, 'mean']`` - dict of column names -> function, function name or list of such. - None only if named aggregation syntax is used split_every : int, optional Number of intermediate partitions that may be aggregated at once. This defaults to 8. If your intermediate partitions are likely to be small (either due to a small number of groups or a small initial partition size), consider increasing this number for better performance. split_out : int, optional Number of output partitions. Default is 1. shuffle : bool or str, optional Whether a shuffle-based algorithm should be used. A specific algorithm name may also be specified (e.g. ``"tasks"`` or ``"p2p"``). The shuffle-based algorithm is likely to be more efficient than ``shuffle=False`` when ``split_out>1`` and the number of unique groups is large (high cardinality). Default is ``False`` when ``split_out = 1``. When ``split_out > 1``, it chooses the algorithm set by the ``shuffle`` option in the dask config system, or ``"tasks"`` if nothing is set. kwargs: tuple or pd.NamedAgg, optional Used for named aggregations where the keywords are the output column names and the values are tuples where the first element is the input column name and the second element is the aggregation function. ``pandas.NamedAgg`` can also be used as the value. To use the named aggregation syntax, arg must be set to None. )rf)rD based_on_strs r"wrapperz%_aggregate_docstring..wrappers# ! "  F r$r2)based_onrrs @r"_aggregate_docstringrs'$+4;xj1KL$L Nr$c|Dcic]$\}}||jj&}}}t|j||}|jjj |j_|jj |jjjd|_|Scc}}w)N)rbF)r)r rrryr.rwr ry) series_gbrbrrdatarets r"_unique_aggregaters09 :1Aqyy{!!# # :D : $y}} d .Cmm))//CIIO   !4!4!:!: GCI J ;s)Cc |jr9tdt|jjtDrt j tS|jdi|S)Nc3FK|]}tj|ywr')rtr)r)rCs r"r,z _value_counts..s s!) containerrr2) groupsr0rrrrtrr value_counts)rr9s r" _value_countsrsS 88s ' 5 Iyys##q~~'''r$c|Dcic]&\}}||jdj(}}}|s/tj|jj dddg}tj ||jj j}tt|j jDcic]V}||j j|j|jj j|jX}}|j j|j|jd|_|Scc}}wcc}w) Nrrrfloat64rxrvF)riverify_integrity)r7rrtrryr.r rwrrrlr ryrrr)rrrrr!r* typed_levelss r"_value_counts_aggregaters.5> ?TQAqyyry"&&( ( ?D ?  3 3BQ 7yIJ ))D 3 3 9 9 :Cs399++,-  399  A  % %imm&9&9&@&@&C&I&I JJL $$\%6%6%85%CI J @s +E"AE(c t|rt|nd|ff\}}tj|Dcgc]}|jdi|c}|Scc}wNT)rr2)rrrtr tailrr9rrgroups r" _tail_chunkrK&))n3 ?7YL:QLD& 99?ujejj*6*?d KK?Ac |jd}|jdi|jtt |SN index_levelsr2)rr droplevelrrrr9rls r"_tail_aggregater8 ZZ 'F 9>> #F # - -d5=.A BBr$c t|rt|nd|ff\}}tj|Dcgc]}|jdi|c}|Scc}wr)rrrtr rmrs r" _head_chunkrrrc |jd}|jdi|jtt |Sr)rrmrrrrs r"_head_aggregaterrr$r)NNNFN)NNFN)F)FF)FNNFr')Y __future__rr itertoolsrrjrs functoolsrnumpyrpandasrt dask.baser dask.corerdask.dataframe._compatrr r r dask.dataframe.corer dask.dataframe.methodsr dask.dataframe.utilsrrr dask.typingr dask.utilsrrrNUMERIC_ONLY_NOT_IMPLEMENTEDr__annotations__r#r(r;rGrJrPrYr[rmrqrrrrrrrrrrrr%r:r/r@rArBrCrDrErorVrrKrkr`rrWr^rrrrrrrrrrrr2r$r"rs" 4) #..  #'K&,$j"  *6"  .>"  0,::|FJ&>B )-t3l"& *&0%&, j5QU0#(L(&0.$b2t*.;SlG$T)6X.'T*60/7d"4  "J! : =A*B& /,^( L C L Cr$