ó ŕ'ˇh­<ăóä •SSKJr SSKrSSKJrJrJrJr SSKJ r SSK J r SSKJr SSKJrJr SSKJrJrJrJr SSKJrJr SSKJrJr SSKJ r J!r! SS K"J#r#J$r$J%r% SS K&J'r'J(r(J)r)J*r* SS K+J,r, SS K-J.r. SS K-J/r0 SSK1J2r2J3r3 SSK4J5r5 \Rl"\75 SSK8J9r: SSS5 \(aUSSK;r;SSKr>J?r?J@r@ SSKJArA SSKBJCrCJDrDJErEJFrF SSKGJHrHJIrIJJrJJKrKJLrLJMrM SSK1JNrN \;RžS:źaSSKPJr OSSKQJr SqSjrRSrSjrSSsSjrTSS.StSjjrUSsSjrVSuSvSjjrWSuSvS jjrXSsS!jrYSsS"jrZSsS#jr[SsS$jr\SsS%jr]SsS&jr^S'S(.SwS)jjr_SxSyS*jjr`SxSyS+jjra\S,S,S,S,S-.SzS.jj5rb\S,S,S,S/.S{S0jj5rbS1SSSS-.S|S2jjrb\S,S,S3.S}S4jj5rc\S,S5.S~S6jj5rcSSS3.SS7jjrc"S8S95rdS€SSS:.SS;jjjreS€SSS:.SS<jjjrfSSSS=.S‚S>jjrgSƒS?jrhSSS@.S„SAjjriSSS@.S…SBjjrjSSSSC.S†SDjjrkSSS@.S…SEjjrlS‡SFjrm\"SG5S‡SHj5rnSˆSIjroS‰SJjrpSŠS‹SKjjrqSSS'SSL.SŒSMjjrr\"5\3"5S'S'S'S'SS'S'S'S'S'\2SNSO. SSPjj55rs\SN\2SQ.SŽSRjj5rt\SSN\2SS.SSTjj5rt\"5\"5SSN\2SS.SSUjj55rt\"5\2SV.S‘SWjj5ru\S,SX.S’SYjj5rv\S“SZj5rvS'SX.S”S[jjrv\S,SX.S•S\jj5rw\S–S]j5rwSSX.S—S^jjrw\S,SX.S˜S_jj5rx\S™S`j5rx\SšSaj5rxSSX.SšSbjjrx\S›SœScjj5ry\S›SSdjj5rySžSŸSejjry\"SfSgShSi9SSSj.S Skjj5rz\"SfSgShSi9SSSj.S Sljj5r{\SĄSmj5r|\S˘Snj5r|SŁSojr|\"5S¤SĽSpjj5r}g!,(df  GNC=f)Śé)Ú annotationsN)Ú TYPE_CHECKINGÚAnyÚCallableÚoverload)Ú_AioDataFrameResultÚ_GeventDataFrameResult)Údeprecate_renamed_parameterÚdeprecate_streaming_parameterÚ deprecatedÚissue_deprecation_warning)Úparse_into_expressionÚparse_into_list_of_expressions)Úissue_unstable_warningÚunstable)Ú extend_boolÚqualified_type_name)Úwrap_dfÚ wrap_exprÚwrap_s)ÚDTYPE_TEMPORAL_UNITSÚDateÚDatetimeÚInt64)Úparse_into_datatype_expr)Ú_check_for_numpy)Únumpy)ÚDEFAULT_QUERY_OPT_FLAGSÚforward_old_opt_flags)Úget_index_type)Ú AwaitableÚ CollectionÚIterableÚSequence)ÚLiteral)Ú DataFrameÚExprÚ LazyFrameÚSeries)ÚCorrelationMethodÚ EngineTypeÚ EpochTimeUnitÚIntoExprÚPolarsDataTypeÚQuantileMethod)Ú QueryOptFlags)éé )r cóp•[U[5(aU/n[[R"U55$)ze Select a field in the current `struct.with_fields` scope. name Name of the field(s) to select. )Ú isinstanceÚstrrÚplrÚfieldŠÚnames ÚhC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\polars/functions/lazy.pyr7r7<s+€ô$œ×ŃŘˆvˆÜ ”S—Y’Y˜t“_Ó %Đ%ócó.•[R"S5$)uš Alias for an element being evaluated in an `eval` or `filter` expression. Examples -------- A horizontal rank computation by taking the elements of a list >>> df = pl.DataFrame( ... { ... "a": [1, 8, 3], ... "b": [4, 5, 2], ... } ... ) >>> df.with_columns( ... pl.concat_list(["a", "b"]).list.eval(pl.element().rank()).alias("rank") ... ) shape: (3, 3) ┌─────┬─────┬────────────┐ │ a ┆ b ┆ rank │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ list[f64] │ ╞═════╪═════╪════════════╡ │ 1 ┆ 4 ┆ [1.0, 2.0] │ │ 8 ┆ 5 ┆ [2.0, 1.0] │ │ 3 ┆ 2 ┆ [2.0, 1.0] │ └─────┴─────┴────────────┘ A mathematical operation on array elements >>> df = pl.DataFrame( ... { ... "a": [1, 8, 3], ... "b": [4, 5, 2], ... } ... ) >>> df.with_columns( ... pl.concat_list(["a", "b"]).list.eval(pl.element() * 2).alias("a_b_doubled") ... ) shape: (3, 3) ┌─────┬─────┬─────────────┐ │ a ┆ b ┆ a_b_doubled │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ list[i64] │ ╞═════╪═════╪═════════════╡ │ 1 ┆ 4 ┆ [2, 8] │ │ 8 ┆ 5 ┆ [16, 10] │ │ 3 ┆ 2 ┆ [6, 4] │ └─────┴─────┴─────────────┘ A filter operation on list elements >>> import polars as pl >>> df = pl.DataFrame({"a": [1, 8, 3], "b": [4, 5, 2]}) >>> df.with_columns( ... evens=pl.concat_list("a", "b").list.filter(pl.element() % 2 == 0) ... ) shape: (3, 3) ┌─────┬─────┬───────────┐ │ a ┆ b ┆ evens │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ list[i64] │ ╞═════╪═════╪═══════════╡ │ 1 ┆ 4 ┆ [4] │ │ 8 ┆ 5 ┆ [8] │ │ 3 ┆ 2 ┆ [2] │ └─────┴─────┴───────────┘ Ú)ÚFÚcolŠr;r:ÚelementrAHs€ôH 5Š5‹9Đr;cóŽ•U(d.[SSS9 [R"5RS5$[R"U6R 5$)u| Return the number of non-null values in the column. This function is syntactic sugar for `col(columns).count()`. Calling this function without any arguments returns the number of rows in the context. **This way of using the function is deprecated.** Please use :func:`len` instead. Parameters ---------- *columns One or more column names. Returns ------- Expr Expression of data type :class:`UInt32`. See Also -------- Expr.count Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, None], ... "b": [3, None, None], ... "c": ["foo", "bar", "foo"], ... } ... ) >>> df.select(pl.count("a")) shape: (1, 1) ┌─────┐ │ a │ │ --- │ │ u32 │ ╞═════╡ │ 2 │ └─────┘ Return the number of non-null values in multiple columns. >>> df.select(pl.count("b", "c")) shape: (1, 2) ┌─────┬─────┐ │ b ┆ c │ │ --- ┆ --- │ │ u32 ┆ u32 │ ╞═════╪═════╡ │ 1 ┆ 3 │ └─────┴─────┘ Return the number of rows in a context. **This way of using the function is deprecated.** Please use :func:`len` instead. >>> df.select(pl.count()) # doctest: +SKIP shape: (1, 1) ┌───────┐ │ count │ │ --- │ │ u32 │ ╞═══════╡ │ 3 │ └───────┘ z:`pl.count()` is deprecated. Please use `pl.len()` instead.z0.20.5ŠÚversionÚcount)r r>ÚlenÚaliasr?rEŠÚcolumnss r:rErEsD€öH Ü!Ř HŘň ôuŠu‹w}‰}˜WÓ%Đ%Ü 5Š5'ˆ?× Ń Ó "Đ"r;FŠÚreversecóB•[R"U6RUS9$)u~ Return the cumulative count of the non-null values in the column. This function is syntactic sugar for `col(columns).cum_count()`. Parameters ---------- *columns Name(s) of the columns to use. reverse Reverse the operation. Examples -------- >>> df = pl.DataFrame({"a": [1, 2, None], "b": [3, None, None]}) >>> df.with_columns( ... ca=pl.cum_count("a"), ... cb=pl.cum_count("b"), ... ) shape: (3, 4) ┌──────┬──────┬─────┬─────┐ │ a ┆ b ┆ ca ┆ cb │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ u32 ┆ u32 │ ╞══════╪══════╪═════╪═════╡ │ 1 ┆ 3 ┆ 1 ┆ 1 │ │ 2 ┆ null ┆ 2 ┆ 1 │ │ null ┆ null ┆ 2 ┆ 1 │ └──────┴──────┴─────┴─────┘ rJ)r>r?Ú cum_count)rKrIs r:rMrMÜs €ô> 5Š5'ˆ?× $Ń $¨WĐ $Đ 5Đ5r;cóD•[R"U6R5$)ul Aggregate all column values into a list. This function is syntactic sugar for `pl.col(name).implode()`. Parameters ---------- *columns One or more column names. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, 3], ... "b": [9, 8, 7], ... "c": ["foo", "bar", "foo"], ... } ... ) >>> df.select(pl.implode("a")) shape: (1, 1) ┌───────────┐ │ a │ │ --- │ │ list[i64] │ ╞═══════════╡ │ [1, 2, 3] │ └───────────┘ >>> df.select(pl.implode("b", "c")) shape: (1, 2) ┌───────────┬───────────────────────┐ │ b ┆ c │ │ --- ┆ --- │ │ list[i64] ┆ list[str] │ ╞═══════════╪═══════════════════════╡ │ [9, 8, 7] ┆ ["foo", "bar", "foo"] │ └───────────┴───────────────────────┘ )r>r?ÚimploderHs r:rOrOţs€ôP 5Š5'ˆ?× "Ń "Ó $Đ$r;écóL•[R"U5RU5$)uŐ Get the standard deviation. This function is syntactic sugar for `pl.col(column).std(ddof)`. Parameters ---------- column Column name. ddof “Delta Degrees of Freedom”: the divisor used in the calculation is N - ddof, where N represents the number of elements. By default ddof is 1. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 8, 3], ... "b": [4, 5, 2], ... "c": ["foo", "bar", "foo"], ... } ... ) >>> df.select(pl.std("a")) shape: (1, 1) ┌──────────┐ │ a │ │ --- │ │ f64 │ ╞══════════╡ │ 3.605551 │ └──────────┘ >>> df["a"].std() 3.605551275463989 )r>r?ÚstdŠÚcolumnÚddofs r:rRrR)ó€ôH 5Š5‹=× Ń ˜TÓ "Đ"r;cóL•[R"U5RU5$)u‹ Get the variance. This function is syntactic sugar for `pl.col(column).var(ddof)`. Parameters ---------- column Column name. ddof “Delta Degrees of Freedom”: the divisor used in the calculation is N - ddof, where N represents the number of elements. By default ddof is 1. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 8, 3], ... "b": [4, 5, 2], ... "c": ["foo", "bar", "foo"], ... }, ... ) >>> df.select(pl.var("a")) shape: (1, 1) ┌──────┐ │ a │ │ --- │ │ f64 │ ╞══════╡ │ 13.0 │ └──────┘ >>> df["a"].var() 13.0 )r>r?ÚvarrSs r:rXrXPrVr;cóD•[R"U6R5$)u/ Get the mean value. This function is syntactic sugar for `pl.col(columns).mean()`. Parameters ---------- *columns One or more column names. See Also -------- mean_horizontal Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 8, 3], ... "b": [4, 5, 2], ... "c": ["foo", "bar", "foo"], ... } ... ) >>> df.select(pl.mean("a")) shape: (1, 1) ┌─────┐ │ a │ │ --- │ │ f64 │ ╞═════╡ │ 4.0 │ └─────┘ >>> df.select(pl.mean("a", "b")) shape: (1, 2) ┌─────┬──────────┐ │ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ f64 │ ╞═════╪══════════╡ │ 4.0 ┆ 3.666667 │ └─────┴──────────┘ )r>r?ÚmeanrHs r:rZrZws€ôX 5Š5'ˆ?× Ń Ó !Đ!r;cóD•[R"U6R5$)uŇ Get the median value. This function is syntactic sugar for `pl.col(columns).median()`. Parameters ---------- columns One or more column names. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 8, 3], ... "b": [4, 5, 2], ... "c": ["foo", "bar", "foo"], ... } ... ) >>> df.select(pl.median("a")) shape: (1, 1) ┌─────┐ │ a │ │ --- │ │ f64 │ ╞═════╡ │ 3.0 │ └─────┘ >>> df.select(pl.median("a", "b")) shape: (1, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ f64 ┆ f64 │ ╞═════╪═════╡ │ 3.0 ┆ 4.0 │ └─────┴─────┘ )r>r?ÚmedianrHs r:r\r\Śs€ôP 5Š5'ˆ?× !Ń !Ó #Đ#r;cóD•[R"U6R5$)u× Count unique values. This function is syntactic sugar for `pl.col(columns).n_unique()`. Parameters ---------- columns One or more column names. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 8, 1], ... "b": [4, 5, 2], ... "c": ["foo", "bar", "foo"], ... } ... ) >>> df.select(pl.n_unique("a")) shape: (1, 1) ┌─────┐ │ a │ │ --- │ │ u32 │ ╞═════╡ │ 2 │ └─────┘ >>> df.select(pl.n_unique("b", "c")) shape: (1, 2) ┌─────┬─────┐ │ b ┆ c │ │ --- ┆ --- │ │ u32 ┆ u32 │ ╞═════╪═════╡ │ 3 ┆ 2 │ └─────┴─────┘ )r>r?Ún_uniquerHs r:r^r^Ńs€ôP 5Š5'ˆ?× #Ń #Ó %Đ%r;cóD•[R"U6R5$)u< Approximate count of unique values. This function is syntactic sugar for `pl.col(columns).approx_n_unique()`, and uses the HyperLogLog++ algorithm for cardinality estimation. Parameters ---------- columns One or more column names. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 8, 1], ... "b": [4, 5, 2], ... "c": ["foo", "bar", "foo"], ... } ... ) >>> df.select(pl.approx_n_unique("a")) shape: (1, 1) ┌─────┐ │ a │ │ --- │ │ u32 │ ╞═════╡ │ 2 │ └─────┘ >>> df.select(pl.approx_n_unique("b", "c")) shape: (1, 2) ┌─────┬─────┐ │ b ┆ c │ │ --- ┆ --- │ │ u32 ┆ u32 │ ╞═════╪═════╡ │ 3 ┆ 2 │ └─────┴─────┘ )r>r?Úapprox_n_uniquerHs r:r`r`üs€ôR 5Š5'ˆ?× *Ń *Ó ,Đ,r;có˜•U(d#[R"5R5$[R"U6R5$)u„ Get the first column or value. This function has different behavior depending on the presence of `columns` values. If none given (the default), returns an expression that takes the first column of the context; otherwise, takes the first value of the given column(s). Parameters ---------- *columns One or more column names. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 8, 3], ... "b": [4, 5, 2], ... "c": ["foo", "bar", "baz"], ... } ... ) Return the first column: >>> df.select(pl.first()) shape: (3, 1) ┌─────┐ │ a │ │ --- │ │ i64 │ ╞═════╡ │ 1 │ │ 8 │ │ 3 │ └─────┘ Return the first value for the given column(s): >>> df.select(pl.first("b")) shape: (1, 1) ┌─────┐ │ b │ │ --- │ │ i64 │ ╞═════╡ │ 4 │ └─────┘ >>> df.select(pl.first("a", "c")) shape: (1, 2) ┌─────┬─────┐ │ a ┆ c │ │ --- ┆ --- │ │ i64 ┆ str │ ╞═════╪═════╡ │ 1 ┆ foo │ └─────┴─────┘ )ÚcsÚfirstÚas_exprr>r?rHs r:rcrc(s4€öv ܏xŠx‹z×!Ń!Ó#Đ#ä 5Š5'ˆ?× Ń Ó "Đ"r;có˜•U(d#[R"5R5$[R"U6R5$)u| Get the last column or value. This function has different behavior depending on the presence of `columns` values. If none given (the default), returns an expression that takes the last column of the context; otherwise, takes the last value of the given column(s). Parameters ---------- *columns One or more column names. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 8, 3], ... "b": [4, 5, 2], ... "c": ["foo", "bar", "baz"], ... } ... ) Return the last column: >>> df.select(pl.last()) shape: (3, 1) ┌─────┐ │ c │ │ --- │ │ str │ ╞═════╡ │ foo │ │ bar │ │ baz │ └─────┘ Return the last value for the given column(s): >>> df.select(pl.last("a")) shape: (1, 1) ┌─────┐ │ a │ │ --- │ │ i64 │ ╞═════╡ │ 3 │ └─────┘ >>> df.select(pl.last("b", "c")) shape: (1, 2) ┌─────┬─────┐ │ b ┆ c │ │ --- ┆ --- │ │ i64 ┆ str │ ╞═════╪═════╡ │ 2 ┆ baz │ └─────┴─────┘ )rbÚlastrdr>r?rHs r:rfrfis4€öv ܏wŠw‹y× Ń Ó"Đ"ä 5Š5'ˆ?× Ń Ó !Đ!r;T)ÚstrictcóJ•[R"USU06R5$)uó Get the nth column(s) of the context. Parameters ---------- indices One or more indices representing the columns to retrieve. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 8, 3], ... "b": [4, 5, 2], ... "c": ["foo", "bar", "baz"], ... } ... ) >>> df.select(pl.nth(1)) shape: (3, 1) ┌─────┐ │ b │ │ --- │ │ i64 │ ╞═════╡ │ 4 │ │ 5 │ │ 2 │ └─────┘ >>> df.select(pl.nth(2, 0)) shape: (3, 2) ┌─────┬─────┐ │ c ┆ a │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═════╡ │ foo ┆ 1 │ │ bar ┆ 8 │ │ baz ┆ 3 │ └─────┴─────┘ Ú require_all)rbÚby_indexrd)rgÚindicess r:ÚnthrlŞs"€ôR ;Š;˜Đ 4¨VŃ 4× <Ń <Ó >Đ>r;cóL•[R"U5RU5$)uŤ Get the first `n` rows. This function is syntactic sugar for `pl.col(column).head(n)`. Parameters ---------- column Column name. n Number of rows to return. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 8, 3], ... "b": [4, 5, 2], ... "c": ["foo", "bar", "foo"], ... } ... ) >>> df.select(pl.head("a")) shape: (3, 1) ┌─────┐ │ a │ │ --- │ │ i64 │ ╞═════╡ │ 1 │ │ 8 │ │ 3 │ └─────┘ >>> df.select(pl.head("a", 2)) shape: (2, 1) ┌─────┐ │ a │ │ --- │ │ i64 │ ╞═════╡ │ 1 │ │ 8 │ └─────┘ )r>r?ÚheadŠrTÚns r:rnrnÖó€ôX 5Š5‹=× Ń ˜aÓ Đ r;cóL•[R"U5RU5$)uŞ Get the last `n` rows. This function is syntactic sugar for `pl.col(column).tail(n)`. Parameters ---------- column Column name. n Number of rows to return. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 8, 3], ... "b": [4, 5, 2], ... "c": ["foo", "bar", "foo"], ... } ... ) >>> df.select(pl.tail("a")) shape: (3, 1) ┌─────┐ │ a │ │ --- │ │ i64 │ ╞═════╡ │ 1 │ │ 8 │ │ 3 │ └─────┘ >>> df.select(pl.tail("a", 2)) shape: (2, 1) ┌─────┐ │ a │ │ --- │ │ i64 │ ╞═════╡ │ 8 │ │ 3 │ └─────┘ )r>r?Útailros r:rsrsrqr;.)ÚmethodrUÚpropagate_nansÚeagercó•gŠNr@ŠÚaÚbrtrUrurvs r:Úcorrr|4s€đ r;)rtrUrucó•grxr@rys r:r|r|@s€đr;Úpearsonc óŚ•Ub [SSS9 U(aÇ[U[R5(d,[U[R5(d Sn[ U5e[R "X4Vs/sH&n[U[R5(dM$UPM( sn5nSX45n UR [U SX$S.65R5$[U5n [U5n US:Xa[[R"XŤ55$US :Xa [[R"XŤU55$S U<3n[ U5es snf) u Compute the Pearson's or Spearman rank correlation between two columns. Parameters ---------- a Column name or Expression. b Column name or Expression. ddof Has no effect, do not use. .. deprecated:: 1.17.0 method : {'pearson', 'spearman'} Correlation method. propagate_nans If `True` any `NaN` encountered will lead to `NaN` in the output. Defaults to `False` where `NaN` are regarded as larger than any finite number and thus lead to the highest rank. eager Evaluate immediately and return a `Series`; this requires that at least one of the given arguments is a `Series`. If set to `False` (default), return an expression instead. Examples -------- Pearson's correlation: >>> df = pl.DataFrame( ... { ... "a": [1, 8, 3], ... "b": [4, 5, 2], ... "c": ["foo", "bar", "foo"], ... } ... ) >>> df.select(pl.corr("a", "b")) shape: (1, 1) ┌──────────┐ │ a │ │ --- │ │ f64 │ ╞══════════╡ │ 0.544705 │ └──────────┘ Spearman rank correlation: >>> df.select(pl.corr("a", "b", method="spearman")) shape: (1, 1) ┌─────┐ │ a │ │ --- │ │ f64 │ ╞═════╡ │ 0.5 │ └─────┘ Eager evaluation: >>> s1 = pl.Series("a", [1, 8, 3]) >>> s2 = pl.Series("b", [4, 5, 2]) >>> pl.corr(s1, s2, eager=True) shape: (1,) Series: 'a' [f64] [ 0.544705 ] >>> pl.corr(s1, s2, method="spearman", eager=True) shape: (1,) Series: 'a' [f64] [ 0.5 ] z2the `ddof` parameter has no effect. Do not use it.z1.17.0rCz=expected at least one Series in 'corr' inputs if 'eager=True'c3ó|# •UH2n[U[R5(a UROUv• M4 g7frxŠr4Úplr)r9ŠÚ.0Úes r:Ú Úcorr..Źó)é€ĐMÂfŔœJ qŹ"Ż)Š)×4Ń4!—&’&¸!Ô;Âfůó‚:<F)rvrtrur~Úspearmanz3method must be one of {'pearson', 'spearman'}, got )r r4r‚r)Ú ValueErrorr&Úselectr|Ú to_seriesrrr6Ú pearson_corrÚspearman_rank_corr) rzr{rtrUrurvÚmsgr…ÚframeÚexprsÚa_pyexprÚb_pyexprs r:r|r|Ls€đh ŃÜ!Ř @Řň ö  ܘ1œbŸi™i×(Ń(ŹJ°qź"ż)š)×,DŃ,DŘQˆCܘS“/Đ !ä— ’ ¨!ŠÓLŞ A´:¸aÄÇÁ×3KŸaŠŃLÓMˆŮMŔqÁfÓMˆŘ|‰|Ü %˜u¨VŇ Só ç ‰)‹+đ ô)¨Ó+ˆÜ(¨Ó+ˆŕ YÓ ÜœS×-Ň-¨hÓAÓBĐ BŘ zÓ !ÜœS×3Ň3°HČÓWÓXĐ XŕIČ&ÉĐTˆCܘS“/Đ !ůňMs Á5#EÂE)rUrvcó•grxr@Šrzr{rUrvs r:Úcovr—˝s€đ r;)rUcó•grxr@r–s r:r—r—Çs€đr;c ó•U(aÇ[U[R5(d,[U[R5(d Sn[U5e[R"X4Vs/sH&n[U[R5(dM$UPM( sn5nSX45nUR [ USUS.65R5$[U5n[U5n [[R "X‰U55$s snf)ue Compute the covariance between two columns/ expressions. Parameters ---------- a Column name or Expression. b Column name or Expression. ddof "Delta Degrees of Freedom": the divisor used in the calculation is N - ddof, where N represents the number of elements. By default ddof is 1. eager Evaluate immediately and return a `Series`; this requires that at least one of the given arguments is a `Series`. If set to `False` (default), return an expression instead. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 8, 3], ... "b": [4, 5, 2], ... "c": ["foo", "bar", "foo"], ... }, ... ) >>> df.select( ... x=pl.cov("a", "b"), ... y=pl.cov("a", "b", ddof=2), ... ) shape: (1, 2) ┌─────┬─────┐ │ x ┆ y │ │ --- ┆ --- │ │ f64 ┆ f64 │ ╞═════╪═════╡ │ 3.0 ┆ 6.0 │ └─────┴─────┘ Eager evaluation: >>> s1 = pl.Series("a", [1, 8, 3]) >>> s2 = pl.Series("b", [4, 5, 2]) >>> pl.cov(s1, s2, eager=True) shape: (1,) Series: 'a' [f64] [ 3.0 ] z.rˆr‰F)rvrU) r4r‚r)r‹r&rŒr—rrrr6) rzr{rUrvrr…r‘r’r“r”s r:r—r—ŃsÁ€öv ܘ1œbŸi™i×(Ń(ŹJ°qź"ż)š)×,DŃ,DŘPˆCܘS“/Đ !ä— ’ ¨!ŠÓLŞ A´:¸aÄÇÁ×3KŸaŠŃLÓMˆŮMŔqÁfÓMˆŘ|‰|œC ¨e¸$Ň?Ó@×JŃJÓLĐLä(¨Ó+ˆÜ(¨Ó+ˆÜœŸš °TÓ:Ó;Đ;ůň Ms Á(#DÂDcóD•\rSrSrSSjrSSjrSrg)Ú_map_batches_wrappericó•XlX lgrxŠÚfunctionÚreturns_scalar)Úselfr rĄs r:Ú__init__Ú_map_batches_wrapper.__init__s€đ !Œ Ř,Őr;có”•USnUVs/sHn[U5PM nnUR"U/UQ70UD6n[ U5(a3[ U[R5(a[R"XtS9n[ U[R5(a UR$UR(a [R"U/US9R$S[U5<S3n [U 5es snf![aFnSURS;a-UR S5 UR"U/UQ70UD6nSnAGN eSnAff=f)NÚ return_dtypez*unexpected keyword argument 'return_dtype'rŠÚdtypez>`map` with `returns_scalar=False` must return a Series; found zP. If `returns_scalar` is set to `True`, a returned value can be a scalar value.)rr Ú TypeErrorÚargsÚpoprr4ÚnpÚndarrayr‚r)Ú_srĄr) r˘ÚslrŞÚkwargsrŚÚsÚslpÚrvr…rs r:Ú__call__Ú_map_batches_wrapper.__call__$s €đ˜nŃ-ˆ Ů"$Ó%˘"˜QŒvaŽyĄ"ˆĐ%đ Ř—’˜sĐ4 TŇ4¨VŃ4ˆBô ˜B× Ń ¤J¨r´2ˇ:ą:×$>Ń$>Ü—’˜2Ń2ˆBä bœ"Ÿ)™)× $Ń $Ř—5‘5ˆLŘ × × Ü—9’9˜b˜T¨Ń6×9Ń9Đ 9ŕRÔSfĐgiÓSjŃRmđn@đAˆCܘC“.Đ ůň+&řô ó Ř;¸qżvšvŔašyÓHŘ— ‘ ˜>Ô*Ř—]’] 3Đ8¨Ň8°Ń8–ŕűđ  ús"ŠC2˘C7Ă7 EÄ:EĹEĹErŸN)r ú*Callable[[Sequence[Series]], Series | Any]rĄÚboolÚreturnÚNone)rŻzlist[plr.PySeries]rŞrr°rr¸ú plr.PySeries)Ú__name__Ú __module__Ú __qualname__Ú__firstlineno__rŁr´Ú__static_attributes__r@r;r:rrsH†đ-ŕ<đ-đđ -đ ô -đ!Ř$đ!Ř-0đ!Ř>> def test_func(a, b, c): ... return a + b + c >>> df = pl.DataFrame( ... { ... "a": [1, 2, 3, 4], ... "b": [4, 5, 6, 7], ... } ... ) >>> >>> df.with_columns( ... ( ... pl.struct(["a", "b"]).map_batches( ... lambda x: test_func(x.struct.field("a"), x.struct.field("b"), 1) ... ) ... ).alias("a+b+c") ... ) shape: (4, 3) ┌─────┬─────┬───────┐ │ a ┆ b ┆ a+b+c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ ╞═════╪═════╪═══════╡ │ 1 ┆ 4 ┆ 6 │ │ 2 ┆ 5 ┆ 8 │ │ 3 ┆ 6 ┆ 10 │ │ 4 ┆ 7 ┆ 12 │ └─────┴─────┴───────┘ N)rĄrŔ)rrÚ_pydatatype_exprrr6Úmap_exprr)r’r rŚrÁrĄÚpyexprsÚreturn_dtype_exprs r:Ú map_batchesrÇ@s^€ôd-¨UÓ3€Gđ Ń #ô ! Ó.×?Ň?ŕ đô Ü  Š Ř Ü  Ń IŘ Ř)Ř)ń  ó đr;có•[UUUUUS9$)u9 Apply a custom/user-defined function (UDF) in a GroupBy context. .. warning:: This method is much slower than the native expressions API. Only use it if you cannot implement your logic otherwise. Parameters ---------- exprs Expression(s) representing the input Series to the function. function Function to apply over the input; should be of type Callable[[Series], Series]. return_dtype Datatype of the output Series. It is recommended to set this whenever possible. If this is `None`, it tries to infer the datatype by calling the function with dummy data and looking at the output. is_elementwise Set to true if the operations is elementwise for better performance and optimization. An elementwise operations has unit or equal length for all inputs and can be ran sequentially on slices without results being affected. returns_scalar If the function returns a single scalar as output. Notes ----- A UDF passed to `map_batches` must be pure, meaning that it cannot modify or depend on state other than its arguments. Polars may call the function with arbitrary input data. Returns ------- Expr Expression with the data type given by `return_dtype`. Examples -------- >>> df = pl.DataFrame( ... { ... "group": [1, 1, 2], ... "a": [1, 3, 3], ... "b": [5, 6, 7], ... } ... ) >>> df shape: (3, 3) ┌───────┬─────┬─────┐ │ group ┆ a ┆ b │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ ╞═══════╪═════╪═════╡ │ 1 ┆ 1 ┆ 5 │ │ 1 ┆ 3 ┆ 6 │ │ 2 ┆ 3 ┆ 7 │ └───────┴─────┴─────┘ >>> ( ... df.group_by("group").agg( ... pl.map_groups( ... exprs=["a", "b"], ... function=lambda list_of_series: list_of_series[0] ... / list_of_series[0].sum() ... + list_of_series[1], ... return_dtype=pl.Float64, ... ).alias("my_custom_aggregation") ... ) ... ).sort("group") shape: (2, 2) ┌───────┬───────────────────────┐ │ group ┆ my_custom_aggregation │ │ --- ┆ --- │ │ i64 ┆ list[f64] │ ╞═══════╪═══════════════════════╡ │ 1 ┆ [5.25, 6.75] │ │ 2 ┆ [8.0] │ └───────┴───────────────────────┘ The output for group `1` can be understood as follows: - group `1` contains Series `'a': [1, 3]` and `'b': [5, 6]` - applying the function to those lists of Series, one gets the output `[1 / 4 + 5, 3 / 4 + 6]`, i.e. `[5.25, 6.75]` rŔ)rÇ)r’r rŚrÁrĄs r:Ú map_groupsrÉĽs!€ô| Ř ŘŘŘ%Ř%ń  đr;)Ú unorderedÚ descendingÚ nulls_lastcóv•[U[R5(aUR5/nO"[U[R5(aU/n[ U5nU(a*UbeUbe[ RRU5nO [ RRXBU5n[U5$rx) r4r‚ÚSelectorrdr'rr6ÚPyExprÚrow_encode_unorderedÚrow_encode_orderedr)r’rĘrËrĚrĹÚresults r:Ú _row_encoderÓ s•€ô%œŸ™×%Ń%Ř—‘“Đ!‰Ü Eœ2Ÿ7™7× #Ń #ؐˆä,¨UÓ3€GćŘŃ!Đ!Đ!ŘŃ!Đ!Đ!ä—‘×0Ń0°Ó9‰ä—‘×.Ń.¨wŔJÓOˆä VÓ Đr;có^•SU4SjjnU$)NcóV>•UupT"[U5[U55R$rx)rrŽ)Útrzr{r s €r:ÚwrapperÚ _wrap_acc_lamba..wrapper(s%ř€Ř‰ˆŮœ˜q› ¤6¨!Ł9Ó-×0Ń0Đ0r;)rÖz!tuple[plr.PySeries, plr.PySeries]r¸rşr@)r r×s` r:Ú_wrap_acc_lambarŮ%sř€÷1đ €Nr;ŠrĄrŚc óř•[USS9n[U[R5(aU/nSnUb[ U5R n[ U5n[[R"U[U5UUUS95$)ul Accumulate over multiple columns horizontally/ row wise with a left fold. Parameters ---------- acc Accumulator Expression. This is the value that will be initialized when the fold starts. For a sum this could for instance be lit(0). function Function to apply over the accumulator and the value. Fn(acc, value) -> new_value exprs Expressions to aggregate over. May also be a wildcard expression. returns_scalar Whether or not `function` applied returns a scalar. This must be set correctly by the user. return_dtype Output datatype. If not set, the dtype will be inferred based on the dtype of the accumulator. Notes ----- If you simply want the first encountered expression as accumulator, consider using `reduce`. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, 3], ... "b": [3, 4, 5], ... "c": [5, 6, 7], ... } ... ) >>> df shape: (3, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╡ │ 1 ┆ 3 ┆ 5 │ │ 2 ┆ 4 ┆ 6 │ │ 3 ┆ 5 ┆ 7 │ └─────┴─────┴─────┘ Horizontally sum over all columns and add 1. >>> df.select( ... pl.fold( ... acc=pl.lit(1), function=lambda acc, x: acc + x, exprs=pl.col("*") ... ).alias("sum"), ... ) shape: (3, 1) ┌─────┐ │ sum │ │ --- │ │ i32 │ ╞═════╡ │ 10 │ │ 13 │ │ 16 │ └─────┘ You can also apply a condition/predicate on all columns: >>> df = pl.DataFrame( ... { ... "a": [1, 2, 3], ... "b": [0, 1, 2], ... } ... ) >>> df shape: (3, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 0 │ │ 2 ┆ 1 │ │ 3 ┆ 2 │ └─────┴─────┘ >>> df.filter( ... pl.fold( ... acc=pl.lit(True), ... function=lambda acc, x: acc & x, ... exprs=pl.col("*") > 1, ... ) ... ) shape: (1, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 3 ┆ 2 │ └─────┴─────┘ TŠÚ str_as_litNrÚ) rr4r‚r'rrĂrrr6ÚfoldrŮ)Úaccr r’rĄrŚÚpyaccÚrtrĹs r:rŢrŢ/s{€ô\ " #°$Ń 7€Eܐ%œŸ™×!Ń!ؐˆŕ$(€BŘŃÜ % lÓ 3× DŃ Dˆä,¨UÓ3€GÜ Ü ŠŘ Ü ˜HÓ %Ř Ř)Řń  ó đr;c óâ•[U[R5(aU/nSnUb[U5Rn[ U5n[ [R"[U5UUUS95$)uî Accumulate over multiple columns horizontally/ row wise with a left fold. Parameters ---------- function Function to apply over the accumulator and the value. Fn(acc, value) -> new_value exprs Expressions to aggregate over. May also be a wildcard expression. returns_scalar Whether or not `function` applied returns a scalar. This must be set correctly by the user. return_dtype Output datatype. If not set, the dtype will be inferred based on the dtype of the input expressions. Notes ----- See `fold` for the version with an explicit accumulator. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, 3], ... "b": [0, 1, 2], ... } ... ) >>> df shape: (3, 2) ┌─────┬─────┐ │ a ┆ b │ │ --- ┆ --- │ │ i64 ┆ i64 │ ╞═════╪═════╡ │ 1 ┆ 0 │ │ 2 ┆ 1 │ │ 3 ┆ 2 │ └─────┴─────┘ Horizontally sum over all columns. >>> df.select( ... pl.reduce(function=lambda acc, x: acc + x, exprs=pl.col("*")).alias("sum") ... ) shape: (3, 1) ┌─────┐ │ sum │ │ --- │ │ i64 │ ╞═════╡ │ 1 │ │ 3 │ │ 5 │ └─────┘ NrÚ) r4r‚r'rrĂrrr6ÚreducerŮŠr r’rĄrŚrárĹs r:rărăąsl€ôB%œŸ™×!Ń!ؐˆŕ$(€BŘŃÜ % lÓ 3× DŃ Dˆä,¨UÓ3€GÜ Ü  Š Ü ˜HÓ %Ř Ř)Řń  ó đr;ŠrĄrŚÚ include_initc ó•[USS9n[U[R5(aU/nSnUb[ U5R n[ U5n[[R"U[U5UUUUS9RS55$)uą Cumulatively fold horizontally across columns with a left fold. Every cumulative result is added as a separate field in a Struct column. Parameters ---------- acc Accumulator expression. This is the value that will be initialized when the fold starts. For a sum this could for instance be lit(0). function Function to apply over the accumulator and the value. Fn(acc, value) -> new_value exprs Expressions to aggregate over. May also be a wildcard expression. returns_scalar Whether or not `function` applied returns a scalar. This must be set correctly by the user. return_dtype Output datatype. If not set, the dtype will be inferred based on the dtype of the accumulator. include_init Include the initial accumulator state as struct field. Notes ----- If you simply want the first encountered expression as accumulator, consider using :func:`cum_reduce`. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, 3], ... "b": [3, 4, 5], ... "c": [5, 6, 7], ... } ... ) >>> df.with_columns( ... pl.cum_fold(acc=pl.lit(1), function=lambda acc, x: acc + x, exprs=pl.all()) ... ) shape: (3, 4) ┌─────┬─────┬─────┬───────────┐ │ a ┆ b ┆ c ┆ cum_fold │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 ┆ struct[3] │ ╞═════╪═════╪═════╪═══════════╡ │ 1 ┆ 3 ┆ 5 ┆ {2,5,10} │ │ 2 ┆ 4 ┆ 6 ┆ {3,7,13} │ │ 3 ┆ 5 ┆ 7 ┆ {4,9,16} │ └─────┴─────┴─────┴───────────┘ TrÜNrĺÚcum_fold) rr4r‚r'rrĂrrr6rčrŮrG) rßr r’rĄrŚrćrŕrárĹs r:rčrčsŠ€ô| " #°$Ń 7€Eܐ%œŸ™×!Ń!ؐˆŕ$(€BŘŃÜ % lÓ 3× DŃ Dˆä,¨UÓ3€GÜ Ü  Š Ř Ü ˜HÓ %Ř Ř)ŘŘ%ń  ÷ ‰% Ó ó đ r;c ó•[U[R5(aU/nSnUb[U5Rn[ U5n[ [R"[U5UUUS9RS55$)u8 Cumulatively reduce horizontally across columns with a left fold. Every cumulative result is added as a separate field in a Struct column. Parameters ---------- function Function to apply over the accumulator and the value. Fn(acc, value) -> new_value exprs Expressions to aggregate over. May also be a wildcard expression. return_dtype Output datatype. If not set, the dtype will be inferred based on the dtype of the input expressions. include_init Include the initial accumulator state as struct field. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, 2, 3], ... "b": [3, 4, 5], ... "c": [5, 6, 7], ... } ... ) >>> df.with_columns(pl.cum_reduce(function=lambda acc, x: acc + x, exprs=pl.all())) shape: (3, 4) ┌─────┬─────┬─────┬────────────┐ │ a ┆ b ┆ c ┆ cum_reduce │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 ┆ struct[3] │ ╞═════╪═════╪═════╪════════════╡ │ 1 ┆ 3 ┆ 5 ┆ {1,4,9} │ │ 2 ┆ 4 ┆ 6 ┆ {2,6,12} │ │ 3 ┆ 5 ┆ 7 ┆ {3,8,15} │ └─────┴─────┴─────┴────────────┘ NrÚÚ cum_reduce) r4r‚r'rrĂrrr6ręrŮrGräs r:ręręWsx€ô`%œŸ™×!Ń!ؐˆŕ$(€BŘŃÜ % lÓ 3× DŃ Dˆä,¨UÓ3€GÜ Ü ŠÜ ˜HÓ %Ř Ř)Řń  ÷ ‰% Ó ó  đr;có•[U[5(a[R"U5n[U[5(a[R"U5n[ US5(dS[ U5S3n[ U5e[ US5(dS[ U5S3n[ U5e[[R"URUR55$)ue Compute two argument arctan in radians. Returns the angle (in radians) in the plane between the positive x-axis and the ray from the origin to (x,y). Parameters ---------- y Column name or Expression. x Column name or Expression. Examples -------- >>> c = (2**0.5) / 2 >>> df = pl.DataFrame( ... { ... "y": [c, -c, c, -c], ... "x": [c, c, -c, -c], ... } ... ) >>> df.with_columns(pl.arctan2("y", "x").alias("atan2")) shape: (4, 3) ┌───────────┬───────────┬───────────┐ │ y ┆ x ┆ atan2 │ │ --- ┆ --- ┆ --- │ │ f64 ┆ f64 ┆ f64 │ ╞═══════════╪═══════════╪═══════════╡ │ 0.707107 ┆ 0.707107 ┆ 0.785398 │ │ -0.707107 ┆ 0.707107 ┆ -0.785398 │ │ 0.707107 ┆ -0.707107 ┆ 2.356194 │ │ -0.707107 ┆ -0.707107 ┆ -2.356194 │ └───────────┴───────────┴───────────┘ Ú_pyexprz,`arctan2` expected a `str` or `Expr` got a `Ú`) r4r5r>r?ÚhasattrrrŠrr6Úarctan2rě)ÚyÚxrs r:rďrď™sł€ôH!”S×ŃÜ EŠE!‹HˆÜ!”S×ŃÜ EŠE!‹HˆÜ 1i× Ń Ř<Ô=PĐQRÓ=SĐ>> c = (2**0.5) / 2 >>> df = pl.DataFrame( ... { ... "y": [c, -c, c, -c], ... "x": [c, c, -c, -c], ... } ... ) >>> df.select( # doctest: +SKIP ... pl.arctan2d("y", "x").alias("atan2d"), ... pl.arctan2("y", "x").alias("atan2"), ... ) shape: (4, 2) ┌────────┬───────────┐ │ atan2d ┆ atan2 │ │ --- ┆ --- │ │ f64 ┆ f64 │ ╞════════╪═══════════╡ │ 45.0 ┆ 0.785398 │ │ -45.0 ┆ -0.785398 │ │ 135.0 ┆ 2.356194 │ │ -135.0 ┆ -2.356194 │ └────────┴───────────┘ )rďÚdegrees)rđrńs r:Úarctan2drôËs€ôV 1‹=× Ń Ó "Đ"r;cóP•[R"S5R"U/UQ76$)uŔ Represent all columns except for the given columns. Syntactic sugar for `pl.all().exclude(columns)`. Parameters ---------- columns The name or datatype of the column(s) to exclude. Accepts regular expression input. Regular expressions should start with `^` and end with `$`. *more_columns Additional names or datatypes of columns to exclude, specified as positional arguments. Examples -------- Exclude by column name(s): >>> df = pl.DataFrame( ... { ... "aa": [1, 2, 3], ... "ba": ["a", "b", None], ... "cc": [None, 2.5, 1.5], ... } ... ) >>> df.select(pl.exclude("ba")) shape: (3, 2) ┌─────┬──────┐ │ aa ┆ cc │ │ --- ┆ --- │ │ i64 ┆ f64 │ ╞═════╪══════╡ │ 1 ┆ null │ │ 2 ┆ 2.5 │ │ 3 ┆ 1.5 │ └─────┴──────┘ Exclude by regex, e.g. removing all columns whose names end with the letter "a": >>> df.select(pl.exclude("^.*a$")) shape: (3, 1) ┌──────┐ │ cc │ │ --- │ │ f64 │ ╞══════╡ │ null │ │ 2.5 │ │ 1.5 │ └──────┘ Exclude by dtype(s), e.g. removing all columns of type Int64 or Float64: >>> df.select(pl.exclude([pl.Int64, pl.Float64])) shape: (3, 1) ┌──────┐ │ ba │ │ --- │ │ str │ ╞══════╡ │ a │ │ b │ │ null │ └──────┘ Ú*)r>r?Úexclude)rIÚ more_columnss r:r÷r÷ůs#€ôL 5Š5‹:× Ň ˜gĐ 5¨ Ň 5Đ5r;cóJ•[R"U5R5$)z1Syntactic sugar for `pl.col("foo").agg_groups()`.)r>r?Ú agg_groups)rTs r:ÚgroupsrűBs€ä 5Š5‹=× #Ń #Ó %Đ%r;cóL•[R"U5RX5$)zü Syntactic sugar for `pl.col("foo").quantile(..)`. Parameters ---------- column Column name. quantile Quantile between 0.0 and 1.0. interpolation : {'nearest', 'higher', 'lower', 'midpoint', 'linear', 'equiprobable'} Interpolation method. )r>r?Úquantile)rTrýÚ interpolations r:rýrýGs€ô" 5Š5‹=× !Ń ! (Ó :Đ:r;)rËrĚÚ multithreadedÚmaintain_orderc ó¸•[U/UQ76n[U[U5SS5n[U[U5SS5n[[R "XX#U55$)uź Return the row indices that would sort the column(s). Parameters ---------- exprs Column(s) to arg sort by. Accepts expression input. Strings are parsed as column names. *more_exprs Additional columns to arg sort by, specified as positional arguments. descending Sort in descending order. When sorting by multiple columns, can be specified per column by passing a sequence of booleans. nulls_last Place null values last. multithreaded Sort using multiple threads. maintain_order Whether the order should be maintained if elements are equal. See Also -------- Expr.gather: Take values by index. Expr.rank : Get the rank of each row. Examples -------- Pass a single column name to compute the arg sort by that column. >>> df = pl.DataFrame( ... { ... "a": [0, 1, 1, 0], ... "b": [3, 2, 3, 2], ... "c": [1, 2, 3, 4], ... } ... ) >>> df.select(pl.arg_sort_by("a")) shape: (4, 1) ┌─────┐ │ a │ │ --- │ │ u32 │ ╞═════╡ │ 0 │ │ 3 │ │ 1 │ │ 2 │ └─────┘ Compute the arg sort by multiple columns by either passing a list of columns, or by specifying each column as a positional argument. >>> df.select(pl.arg_sort_by(["a", "b"], descending=True)) shape: (4, 1) ┌─────┐ │ a │ │ --- │ │ u32 │ ╞═════╡ │ 2 │ │ 1 │ │ 0 │ │ 3 │ └─────┘ Use gather to apply the arg sort to other columns. >>> df.select(pl.col("c").gather(pl.arg_sort_by("a"))) shape: (4, 1) ┌─────┐ │ c │ │ --- │ │ i64 │ ╞═════╡ │ 1 │ │ 4 │ │ 2 │ │ 3 │ └─────┘ rËr’rĚ)rrrFrr6Ú arg_sort_by)r’rËrĚr˙rÚ more_exprss r:rr[sY€ôp +¨5Đ >°:Ň >€EܘZŹ¨UŤ°\Ŕ7ÓK€JܘZŹ¨UŤ°\Ŕ7ÓK€JÜ Ü Š˜¨:ŔnÓUó đr;Úauto) Ú type_coercionÚpredicate_pushdownÚprojection_pushdownÚsimplify_expressionÚno_optimizationÚslice_pushdownÚcomm_subplan_elimÚcomm_subexpr_elimÚcluster_with_columnsÚcollapse_joinsÚ optimizationsÚenginec óę•U S:Xa [S5 UV s/sHoÝRPM nn [R"XěU R5nUVs/sHn[ U5PM nnU$s sn fs snf)aú Collect multiple LazyFrames at the same time. This can run all the computation graphs in parallel or combined. Common Subplan Elimination is applied on the combined plan, meaning that diverging queries will run only once. Parameters ---------- lazy_frames A list of LazyFrames to collect. type_coercion Do type coercion optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. predicate_pushdown Do predicate pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. projection_pushdown Do projection pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. simplify_expression Run simplify expressions optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. no_optimization Turn off optimizations. .. deprecated:: 1.30.0 Use the `optimizations` parameters. slice_pushdown Slice pushdown optimization. .. deprecated:: 1.30.0 Use the `optimizations` parameters. comm_subplan_elim Will try to cache branching subplans that occur on self-joins or unions. .. deprecated:: 1.30.0 Use the `optimizations` parameters. comm_subexpr_elim Common subexpressions will be cached and reused. .. deprecated:: 1.30.0 Use the `optimizations` parameters. cluster_with_columns Combine sequential independent calls to with_columns .. deprecated:: 1.30.0 Use the `optimizations` parameters. collapse_joins Collapse a join and filters into a faster join .. deprecated:: 1.30.0 Use the `optimizations` parameters. optimizations The optimization passes done during query optimization. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. engine Select the engine used to process the query, optional. At the moment, if set to `"auto"` (default), the query is run using the polars in-memory engine. Polars will also attempt to use the engine set by the `POLARS_ENGINE_AFFINITY` environment variable. If it cannot run the query using the selected engine, the query is run using the polars in-memory engine. .. note:: The GPU engine does not support async, or running in the background. If either are enabled, then GPU execution is switched off. Returns ------- list of DataFrames The collected DataFrames, returned in the same order as the input LazyFrames. Ú streamingú&streaming mode is considered unstable.)rÚ_ldfr6Ú collect_allÚ _pyoptflagsr)Ú lazy_framesrrrrr r r r r rrrÚlfÚlfsÚoutÚpydfrŇs r:rrťsk€đRÓÜĐGÔHá(Ó )š[r7Œ7™[€CĐ )Ü /Š/˜# }×'@Ń'@Ó A€Cń),Ó ,Ş ŒgdŽmŠ€FĐ ,ŕ €Můň *ůň-s –A+ÁA0)rrcó•grxr@ŠrÚgeventrrs r:Úcollect_all_asyncr0s€đ/2r;)rrrcó•grxr@rs r:rr:s€đ"%r;cóö•US:Xa [S5 U(a [5O [5nUVs/sHoURPM nn[R "XbUR UR5 U$s snf)a‡ Collect multiple LazyFrames at the same time asynchronously in thread pool. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Collects into a list of DataFrame (like :func:`polars.collect_all`), but instead of returning them directly, they are scheduled to be collected inside thread pool, while this method returns almost instantly. May be useful if you use gevent or asyncio and want to release control to other greenlets/tasks while LazyFrames are being collected. Parameters ---------- lazy_frames A list of LazyFrames to collect. gevent Return wrapper to `gevent.event.AsyncResult` instead of Awaitable optimizations The optimization passes done during query optimization. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. engine Select the engine used to process the query, optional. At the moment, if set to `"auto"` (default), the query is run using the polars in-memory engine. Polars will also attempt to use the engine set by the `POLARS_ENGINE_AFFINITY` environment variable. If it cannot run the query using the selected engine, the query is run using the polars in-memory engine. .. note:: The GPU engine does not support async, or running in the background. If either are enabled, then GPU execution is switched off. See Also -------- polars.collect_all : Collect multiple LazyFrames at the same time. LazyFrame.collect_async : To collect single frame. Notes ----- In case of error `set_exception` is used on `asyncio.Future`/`gevent.event.AsyncResult` and will be reraised by them. Returns ------- If `gevent=False` (default) then returns awaitable. If `gevent=True` then returns wrapper that has `.get(block=True, timeout=None)` method. rr)rr rrr6Úcollect_all_with_callbackrÚ _callback_all)rrrrrŇrrs r:rrDsq€đBÓÜĐGÔHö%+ÔÔ Ô0CÓ0Eđ ń)Ó )š[r7Œ7™[€CĐ )Ü×!Ň!Ř ]×.Ń.°×0DŃ0Dôđ €Můň *sąA6)rcó‚•UVs/sHo"RPM nn[R"X1R5$s snf)aţ Explain multiple LazyFrames as if passed to `collect_all`. Common Subplan Elimination is applied on the combined plan, meaning that diverging queries will run only once. Parameters ---------- lazy_frames A list of LazyFrames to collect. optimizations The optimization passes done during query optimization. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Returns ------- Explained plan. )rr6Ú explain_allr)rrrrs r:r%r%’s4€ń6)Ó )š[r7Œ7™[€CĐ )Ü ?Š?˜3× 9Ń 9Ó :Đ:ůň *s…<Šrvcó•grxr@Šrvr’Ú named_exprss r:rŒrŒąó€đ r;có•grxr@r(s r:rŒrŒšr*r;cóˆ•U(a[R"5O[R"5nUR"U0UD6$)u Run polars expressions without a context. This is syntactic sugar for running `df.select` on an empty DataFrame (or LazyFrame if eager=False). Parameters ---------- *exprs Column(s) to select, specified as positional arguments. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. eager Evaluate immediately and return a `DataFrame` (default); if set to `False`, return a `LazyFrame` instead. **named_exprs Additional columns to select, specified as keyword arguments. The columns will be renamed to the keyword used. Returns ------- DataFrame or LazyFrame Examples -------- >>> foo = pl.Series("foo", [1, 2, 3]) >>> bar = pl.Series("bar", [3, 2, 1]) >>> pl.select(min=pl.min_horizontal(foo, bar)) shape: (3, 1) ┌─────┐ │ min │ │ --- │ │ i64 │ ╞═════╡ │ 1 │ │ 2 │ │ 1 │ └─────┘ >>> pl.select(pl.int_range(0, 100_000, 2).alias("n"), eager=False).filter( ... pl.col("n") % 22_500 == 0 ... ).collect() shape: (5, 1) ┌───────┐ │ n │ │ --- │ │ i64 │ ╞═══════╡ │ 0 │ │ 22500 │ │ 45000 │ │ 67500 │ │ 90000 │ └───────┘ )r‚r&r(rŒ)rvr’r)Ú empty_frames r:rŒrŒÁs0€öt%*”"—,’,”.ŹrŻ|Ş|Ť~€KŘ × Ň ˜uĐ 4¨ Ń 4Đ4r;có•grxr@ŠÚ conditionrvs r:Ú arg_wherer1˙s€ŘQTr;có•grxr@r/s r:r1r1 ó€ŘLOr;có’•U(a—[U[R5(d$S[U5R<3n[ U5eUR 5R[[R"UR555R5$[U5n[[R"U55$)aK Return indices where `condition` evaluates `True`. Parameters ---------- condition Boolean expression to evaluate eager Evaluate immediately and return a `Series`; this requires that the given condition is itself a `Series`. If set to `False` (default), return an expression instead. See Also -------- Series.arg_true : Return indices where Series is True Examples -------- >>> df = pl.DataFrame({"a": [1, 2, 3, 4, 5]}) >>> df.select( ... [ ... pl.arg_where(pl.col("a") % 2 == 0), ... ] ... ).to_series() shape: (2,) Series: 'a' [u32] [ 1 3 ] z4expected Series in 'arg_where' if 'eager=True', got )r4r‚r)Útyperťr‹Úto_framerŒr1r>r?r9rrrr6)r0rvrÚcondition_pyexprs r:r1r1 s™€ö@ ܘ)¤R§YĄY×/Ń/đܘ“O×,Ń,Ń/đ1đ ô˜S“/Đ !Ř×!Ń!Ó#×*Ń*Ź9´QˇU˛U¸9ż>š>Ó5JÓ+KÓL×VŃVÓXĐXä0°Ó;ĐÜœŸšĐ'7Ó8Ó9Đ9r;có•grxr@Šr’rvrs r:Úcoalescer:4 s€đ r;có•grxr@r9s r:r:r:< s€đ r;có•grxr@r9s r:r:r:D s€đ r;có•U(aĹU/UQnUVs/sH&n[U[R5(dM$UPM( sn=n(d Sn[U5eUVs/sH0n[U[R5(a UROUPM2 nn[R "U5R [USS95R5$[U/UQ76n[[R"U55$s snfs snf)u= Folds the columns from left to right, keeping the first non-null value. Parameters ---------- exprs Columns to coalesce. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. *more_exprs Additional columns to coalesce, specified as positional arguments. eager Evaluate immediately and return a `Series`; this requires that at least one of the given arguments is a `Series`. If set to `False` (default), return an expression instead. Examples -------- >>> df = pl.DataFrame( ... { ... "a": [1, None, None, None], ... "b": [1, 2, None, None], ... "c": [5, None, 3, None], ... } ... ) >>> df.with_columns(pl.coalesce("a", "b", "c", 10).alias("d")) shape: (4, 4) ┌──────┬──────┬──────┬─────┐ │ a ┆ b ┆ c ┆ d │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 ┆ i64 │ ╞══════╪══════╪══════╪═════╡ │ 1 ┆ 1 ┆ 5 ┆ 1 │ │ null ┆ 2 ┆ null ┆ 2 │ │ null ┆ null ┆ 3 ┆ 3 │ │ null ┆ null ┆ null ┆ 10 │ └──────┴──────┴──────┴─────┘ >>> df.with_columns(pl.coalesce(pl.col(["a", "b", "c"]), 10.0).alias("d")) shape: (4, 4) ┌──────┬──────┬──────┬──────┐ │ a ┆ b ┆ c ┆ d │ │ --- ┆ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 ┆ f64 │ ╞══════╪══════╪══════╪══════╡ │ 1 ┆ 1 ┆ 5 ┆ 1.0 │ │ null ┆ 2 ┆ null ┆ 2.0 │ │ null ┆ null ┆ 3 ┆ 3.0 │ │ null ┆ null ┆ null ┆ 10.0 │ └──────┴──────┴──────┴──────┘ >>> s1 = pl.Series("a", [None, 2, None]) >>> s2 = pl.Series("b", [1, None, 3]) >>> pl.coalesce(s1, s2, eager=True) shape: (3,) Series: 'a' [i64] [ 1 2 3 ] z:expected at least one Series in 'coalesce' if 'eager=True'Fr&) r4r‚r)r‹r9r&rŒr:rrrr6)r’rvrr…Úseriesrs r:r:r:L sрöF ŘĐ$˜Đ$ˆŮ&+ÓH˘e Źz¸!źRżYšY×/GŸ1ĄeŃHĐHŐHŘNˆCܘS“/Đ !áFKÓLÂeŔœJ qŹ"Ż)Š)×4Ń4!—&’&¸!Ň;ÁeˆĐL܏|Š|˜FÓ#×*Ń*Ź8°EŔŃ+GÓH×RŃRÓTĐTä.¨uĐB°zŇBˆÜœŸš eÓ,Ó-Đ-ůňIůňMs‘#C8¸C8Á7C=có•grxr@ŠrTÚ time_units r:Ú from_epochrBœ r3r;có•grxr@r@s r:rBrB  s€đr;cóđ•[U[5(a[R"U5nOE[U[R [R 45(d[R "U5nUS:XaUR[5$US:Xa0UR[5S-R[S55$U[;aUR[U55$SU<3n[U5e)u Utility function that parses an epoch timestamp (or Unix time) to Polars Date(time). Depending on the `time_unit` provided, this function will return a different dtype: - time_unit="d" returns pl.Date - time_unit="s" returns pl.Datetime["us"] (pl.Datetime's default) - time_unit="ms" returns pl.Datetime["ms"] - time_unit="us" returns pl.Datetime["us"] - time_unit="ns" returns pl.Datetime["ns"] Parameters ---------- column Series or expression to parse integers to pl.Datetime. time_unit The unit of time of the timesteps since epoch time. Examples -------- >>> df = pl.DataFrame({"timestamp": [1666683077, 1666683099]}).lazy() >>> df.select(pl.from_epoch(pl.col("timestamp"), time_unit="s")).collect() shape: (2, 1) ┌─────────────────────┐ │ timestamp │ │ --- │ │ datetime[Îźs] │ ╞═════════════════════╡ │ 2022-10-25 07:31:17 │ │ 2022-10-25 07:31:39 │ └─────────────────────┘ The function can also be used in an eager context by passing a Series. >>> s = pl.Series([12345, 12346]) >>> pl.from_epoch(s, time_unit="d") shape: (2,) Series: '' [date] [ 2003-10-20 2003-10-21 ] Údrąi@BÚusz=`time_unit` must be one of {'ns', 'us', 'ms', 's', 'd'}, got ) r4r5r>r?r‚r)r'Úcastrrrrr‹)rTrArs r:rBrBŚ s˝€ô\&œ#×ŃÜ—’v“‰Ü ˜¤§ĄŹBŻGŠGĐ 4× 5Ń 5Ü—’˜6Ó"ˆŕCÓ؏{‰{œ4Ó Đ Ř cÓ Ř— ‘ œEÓ" YŃ.×4Ń4´X¸dł^ÓDĐDŘ Ô*Ó *؏{‰{œ8 IÓ.Ó/Đ/ŕOĐPYÉ}Đ]ˆÜ˜‹oĐr;Ú min_periodsÚ min_samplesz1.21.0rC)rIrUc ó$•UcUn[U[5(a[R"U5n[U[5(a[R"U5n[ [ R "URURX#U55$)a™ Compute the rolling covariance between two columns/ expressions. The window at a given row includes the row itself and the `window_size - 1` elements before it. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- a Column name or Expression. b Column name or Expression. window_size The length of the window. min_samples The number of values in the window that should be non-null before computing a result. If None, it will be set equal to window size. ddof Delta degrees of freedom. The divisor used in calculations is `N - ddof`, where `N` represents the number of elements. )r4r5r>r?rr6Ú rolling_covrěŠrzr{Ú window_sizerIrUs r:rKrKä sk€đBŃŘ!ˆ ܐ!”S×ŃÜ EŠE!‹HˆÜ!”S×ŃÜ EŠE!‹HˆÜ Ü Š˜Ÿ ™  1§9Ą9¨kČÓMó đr;c ó$•UcUn[U[5(a[R"U5n[U[5(a[R"U5n[ [ R "URURX#U55$)aš Compute the rolling correlation between two columns/ expressions. The window at a given row includes the row itself and the `window_size - 1` elements before it. .. versionchanged:: 1.21.0 The `min_periods` parameter was renamed `min_samples`. Parameters ---------- a Column name or Expression. b Column name or Expression. window_size The length of the window. min_samples The number of values in the window that should be non-null before computing a result. If None, it will be set equal to window size. ddof Delta degrees of freedom. The divisor used in calculations is `N - ddof`, where `N` represents the number of elements. )r4r5r>r?rr6Ú rolling_corrrěrLs r:rOrO sm€đBŃŘ!ˆ ܐ!”S×ŃÜ EŠE!‹HˆÜ!”S×ŃÜ EŠE!‹HˆÜ Ü ×Ň˜Ÿ™ A§IĄI¨{ČÓNó đr;có•grxr@ŠÚsqls r:Úsql_exprrS< s€ŕr;có•grxr@rQs r:rSrSA s€Ř03r;cóԕ[U[5(a[[R"U55$UVs/sH"n[[R"U55PM$ sn$s snf)uo Parse one or more SQL expressions to Polars expression(s). Parameters ---------- sql One or more SQL expressions. Examples -------- Parse a single SQL expression: >>> df = pl.DataFrame({"a": [2, 1]}) >>> expr = pl.sql_expr("MAX(a)") >>> df.select(expr) shape: (1, 1) ┌─────┐ │ a │ │ --- │ │ i64 │ ╞═════╡ │ 2 │ └─────┘ Parse multiple SQL expressions: >>> df.with_columns( ... *pl.sql_expr(["POWER(a,a) AS a_a", "CAST(a AS TEXT) AS a_txt"]), ... ) shape: (2, 3) ┌─────┬─────┬───────┐ │ a ┆ a_a ┆ a_txt │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ str │ ╞═════╪═════╪═══════╡ │ 2 ┆ 4 ┆ 2 │ │ 1 ┆ 1 ┆ 1 │ └─────┴─────┴───────┘ )r4r5rr6rS)rRÚqs r:rSrSE sK€ôP#”s×ŃÜœŸš cÓ*Ó+Đ+á47Ó8˛C¨q” œ#Ÿ,š, q›/Ö*ąCŃ8Đ8ůŇ8sš)A%có€•[R"[R"5[5S9R U5$)uË Generates a sequence of integers. The length of the returned sequence will match the context length, and the datatype will match the one returned by `get_index_dtype()`. .. warning:: This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. If you would like to generate sequences with custom offsets / length / step size / datatypes, it is recommended to use `int_range` instead. Parameters ---------- name Name of the returned column. Returns ------- Expr Column of integers. See Also -------- int_range : Generate a range of integers. Examples -------- >>> df = pl.DataFrame({"x": ["A", "A", "B", "B", "B"]}) >>> df.with_columns(pl.row_index(), pl.row_index("another_index")) shape: (5, 3) ┌─────┬───────┬───────────────┐ │ x ┆ index ┆ another_index │ │ --- ┆ --- ┆ --- │ │ str ┆ u32 ┆ u32 │ ╞═════╪═══════╪═══════════════╡ │ A ┆ 0 ┆ 0 │ │ A ┆ 1 ┆ 1 │ │ B ┆ 2 ┆ 2 │ │ B ┆ 3 ┆ 3 │ │ B ┆ 4 ┆ 4 │ └─────┴───────┴───────────────┘ >>> df.group_by("x").agg(pl.row_index()).sort("x") shape: (2, 2) ┌─────┬───────────┐ │ x ┆ index │ │ --- ┆ --- │ │ str ┆ list[u32] │ ╞═════╪═══════════╡ │ A ┆ [0, 1] │ │ B ┆ [0, 1, 2] │ └─────┴───────────┘ >>> df.select(pl.row_index()) shape: (5, 1) ┌───────┐ │ index │ │ --- │ │ u32 │ ╞═══════╡ │ 0 │ │ 1 │ │ 2 │ │ 3 │ │ 4 │ └───────┘ r§)r>Ú int_rangerFr rGr8s r:Ú row_indexrYs s0€ôR ;Š;Ü Š‹ÜÓń ÷ eˆDƒkđr;)r9zstr | list[str]r¸r')r¸r')rIr5r¸r')rIr5rKrˇr¸r')rP)rTr5rUÚintr¸r')rkzint | Sequence[int]rgrˇr¸r')é )rTr5rprZr¸r')rzr-r{r-rtr*rUú int | NonerurˇrvúLiteral[False]r¸r')rzr-r{r-rtr*rUr\rurˇrvú Literal[True]r¸r))rzr-r{r-rtr*rUr\rurˇrvrˇr¸ú Expr | Series) rzr-r{r-rUrZrvr]r¸r') rzr-r{r-rUrZrvr^r¸r)) rzr-r{r-rUrZrvrˇr¸r_rx) r’zSequence[str | Expr]r rśrŚz'PolarsDataType | pl.DataTypeExpr | NonerÁrˇrĄrˇr¸r') r’z/pl.Selector | pl.Expr | Sequence[str | pl.Expr]rĘrˇrËúlist[bool] | NonerĚr`r¸r')r ú"Callable[[Series, Series], Series]r¸z;Callable[[tuple[plr.PySeries, plr.PySeries]], plr.PySeries]) rßr-r rar’úSequence[Expr | str] | ExprrĄrˇrŚú'pl.DataTypeExpr | PolarsDataType | Noner¸r') r rar’rbrĄrˇrŚrcr¸r')rßr-r rar’rbrĄrˇrŚrcrćrˇr¸r')rđú str | Exprrńrdr¸r')rIzCstr | PolarsDataType | Collection[str] | Collection[PolarsDataType]rřzstr | PolarsDataTyper¸r')rTr5r¸r')Únearest)rTr5rýz float | Exprrţr/r¸r')r’úIntoExpr | Iterable[IntoExpr]rr-rËúbool | Sequence[bool]rĚrgr˙rˇrrˇr¸r')rúIterable[LazyFrame]rrˇrrˇrrˇrrˇr rˇr rˇr rˇr rˇr rˇrrˇrr0rr+r¸zlist[DataFrame]) rrhrr^rr+rr0r¸z'_GeventDataFrameResult[list[DataFrame]]) rrhrr]rr+rr0r¸zAwaitable[list[DataFrame]]) rrhrrˇrr+rr0r¸zDAwaitable[list[DataFrame]] | _GeventDataFrameResult[list[DataFrame]])rrhrr0r¸r5)r’rfrvr^r)r-r¸r&)r’rfrvr]r)r-r¸r()r’rfrvrˇr)r-r¸zDataFrame | LazyFrame)r0r_rvr]r¸r')r0r_rvr^r¸r))r0r_rvrˇr¸r_)r’rfrr-rvr]r¸r')r’rfrr-rvr^r¸r))r’rfrr-rvrˇr¸r_).)rTrdrAr,r¸r')rTzSeries | Sequence[int]rAr,r¸r))rą)rTz#str | Expr | Series | Sequence[int]rAr,r¸r_) rzrdr{rdrMrZrIr\rUrZr¸r')rRr5r¸r')rRz Sequence[str]r¸z list[Expr])rRzstr | Sequence[str]r¸zExpr | list[Expr])Úindex)r9r5r¸zpl.Expr)~Ú __future__rÚ contextlibÚtypingrrrrÚpolars._reexportÚ _reexportr‚Úpolars.functionsÚ functionsr>Úpolars.selectorsÚ selectorsrbÚpolars._utils.async_rr Úpolars._utils.deprecationr r r r Úpolars._utils.parserrÚpolars._utils.unstablerrÚpolars._utils.variousrrÚpolars._utils.wraprrrÚpolars.datatypesrrrrÚpolars.datatypes._parserÚpolars.dependenciesrrrŹÚpolars.lazyframe.opt_flagsrrÚpolars.meta.index_typer ÚsuppressÚ ImportErrorÚ polars._plrÚ_plrr6ÚsysÚcollections.abcr!r"r#r$r%Úpolarsr&r'r(r)Úpolars._typingr*r+r,r-r.r/r0Ú version_infoÚwarningsÚtyping_extensionsr7rArErMrOrRrXrZr\r^r`rcrfrlrnrsr|r—rrÇrÉrÓrŮrŢrărčręrďrôr÷rűrýrrrr%rŒr1r:rBrKrOrSrYr@r;r:Úr‰sN đÝ"ăß9Ó9ĺÝÝßL÷ó÷ ÷DßBß9Ń9ßHÓHÝ<Ý0Ý+÷ő2ŕ×Ň˜Ő%Ý÷&öŰßIÓIÝç9Ó9÷÷őđ ×Ń˜7Ó"Ţ'ĺ0ô &ôDôNJ#đZ.3÷6ôD(%öV$#öN$#ôN,"ô^($ôV(&ôV)-ôX>#ôB>"đB7;÷)?öX,!ö^,!đ^ đ !$ŘŘŘńŘđŕđđ đ đ đ đ đ đ đđ ôó đđ đ !$ŘŘń Řđŕđđ đ đ đ đ đ đ đđ ôó đđ!*ŘŘ Řńn"Řđn"ŕđn"đ đ n"đ đ n"đ đ n"đ đn"đőn"đb đ Řń Řđŕđđ đ đ đ đ  ô ó đđ đ ń Řđŕđđ đ đ đ đ  ô ó đđŘń F<ŘđF<ŕđF<đ đ F<đ đ F<đ ő F<÷R#!ń#!đR=Ađbđ !Ř ń bŘ đbŕ8đbđ:đbđ đ bđ đ bđ öbđP=Ađdđ !Ř ń dŘ đdŕ8đdđ:đdđ đ dđ đ dđ ödđTŘ$(Ř$(ń Ř :đđđđ"đ đ "đ đ  ő đ2Ř0đŕ@ôđ!Ř<@ń Ř đŕ0đđ 'đđ đ đ :đ đ őđL!Ř<@ń PŘ0đPŕ &đPđđ Pđ :đ Pđ  ő Pđp!Ř<@ŘńPŘ đPŕ0đPđ 'đPđ đ Pđ :đ PđđPđ őPđn!Ř<@ń ?Ř0đ?ŕ &đ?đđ ?đ :đ ?đ  ő ?ôD/8ńd Đ WÓXó*#óYđ*#đZF6Ř PđF6ŕ'đF6đ ôF6ôR&đ%.đ;Ř đ;ŕđ;đ"đ;đ ő ;đ.).Ř(-ŘŘ ń ]Ř (đ]ŕđ]đ&đ]đ&đ ]đ đ ]đ đ ]đ ő]ń@Ó ŮÓđŘ#Ř $Ř $Ř!ŘŘ"Ř"Ř!%ŘŘ#:ŘńpŘ$đpđđpđđ pđ đ pđ đ pđđpđđpđđpđđpđđpđđpđ!đpđ đpđôpóó!đpđf đ  Ř#:ń 2Ř$đ2đ đ2đ đ 2đ !đ 2đ -ô 2ó đ2đ đ#ŘŘ#:ń %Ř$đ%đ đ%đ đ %đ !đ %đ  ô %ó đ%ń ƒŮÓ đŘŘ#:ń IŘ$đIđ đIđ đ Iđ !đ Iđ Jô Ió!ó đIńX ƒđ$;ń;Ř$đ;đ!đ;đ ô ;ó đ;đ< đńŘ )đŕ đđđđô ó đđ đŘ )đŕ đđđđó ó đđ:>ń;5Ř )đ;5Ř26đ;5ŘNVđ;5ŕő;5đ| ŘCFÖTó ŘTđ ŰOó ŘOđ:?÷*:đZ đ ńŘ (đŕđđ đđ ô ó đđ đŘ (đŕđđ đđ ó ó đđ đŘ (đŕđđ đđó ó đđńM.Ř (đM.ŕđM.đ đM.đő M.đ` ÝOó ŘOđ ŕ?BđŘ "đŘ/<đŕ ôó đđ MPđ;Ř /đ;Ř