§ ­-Ph|ãó|—ddlmZddlmZmZmZmZerddlmZedd¬¦«Z Gd„dee ¦«Z d S) é)Ú annotations)Ú TYPE_CHECKINGÚCallableÚGenericÚTypeVar)ÚExprÚExprTr)ÚboundcóF—eZdZdd„Zdd„Zdd „Zdd „Zdd„Zdd„Zdd„Z dS)ÚExprNameNamespaceÚexprr ÚreturnÚNonecó—||_dS©N)Ú_expr)Úselfr s úR/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/narwhals/expr_name.pyÚ__init__zExprNameNamespace.__init__ s €ØˆŒ ˆ ˆ ócó>‡—‰j ˆfd„¦«S)a²Keep the original root name of the expression. Returns: A new expression. Notes: This will undo any previous renaming operations on the expression. Due to implementation constraints, this method can only be called as the last expression in a chain. Only one name operation per expression will work. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"foo": [1, 2], "BAR": [4, 5]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("foo").alias("alias_for_foo").name.keep()).columns ['foo'] cóf•—‰j |¦«j ¦«Sr)rÚ_to_compliant_exprÚnameÚkeep©Úplxrs €rúz(ExprNameNamespace.keep..#s&ø€˜œ ×5Ò5°cÑ:Ô:Ô?×DÒDÑFÔF€r©rÚ_with_elementwise_op©rs`rrzExprNameNamespace.keeps+ø€ð&Œz×.Ò.Ø FÐ FÐ FÐ Fñ ô ð rÚfunctionúCallable[[str], str]cóB‡‡—‰j ˆˆfd„¦«S)atRename the output of an expression by mapping a function over the root name. Arguments: function: Function that maps a root name to a new name. Returns: A new expression. Notes: This will undo any previous renaming operations on the expression. Due to implementation constraints, this method can only be called as the last expression in a chain. Only one name operation per expression will work. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"foo": [1, 2], "BAR": [4, 5]}) >>> df = nw.from_native(df_native) >>> renaming_func = lambda s: s[::-1] # reverse column name >>> df.select(nw.col("foo", "BAR").name.map(renaming_func)).columns ['oof', 'RAB'] cóh•—‰j |¦«j ‰¦«Sr)rrrÚmap)rr"rs €€rrz'ExprNameNamespace.map..>s(ø€˜œ ×5Ò5°cÑ:Ô:Ô?×CÒCÀHÑMÔM€rr)rr"s``rr&zExprNameNamespace.map&s/øø€ð.Œz×.Ò.Ø MÐ MÐ MÐ MÐ Mñ ô ð rÚprefixÚstrcóB‡‡—‰j ˆˆfd„¦«S)a&Add a prefix to the root column name of the expression. Arguments: prefix: Prefix to add to the root column name. Returns: A new expression. Notes: This will undo any previous renaming operations on the expression. Due to implementation constraints, this method can only be called as the last expression in a chain. Only one name operation per expression will work. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"foo": [1, 2], "BAR": [4, 5]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("foo", "BAR").name.prefix("with_prefix")).columns ['with_prefixfoo', 'with_prefixBAR'] cóh•—‰j |¦«j ‰¦«Sr)rrrr')rr'rs €€rrz*ExprNameNamespace.prefix..Xó(ø€˜œ ×5Ò5°cÑ:Ô:Ô?×FÒFÀvÑNÔN€rr)rr's``rr'zExprNameNamespace.prefixAó/øø€ð,Œz×.Ò.Ø NÐ NÐ NÐ NÐ Nñ ô ð rÚsuffixcóB‡‡—‰j ˆˆfd„¦«S)a)Add a suffix to the root column name of the expression. Arguments: suffix: Suffix to add to the root column name. Returns: A new expression. Notes: This will undo any previous renaming operations on the expression. Due to implementation constraints, this method can only be called as the last expression in a chain. Only one name operation per expression will work. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"foo": [1, 2], "BAR": [4, 5]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("foo", "BAR").name.suffix("_with_suffix")).columns ['foo_with_suffix', 'BAR_with_suffix'] cóh•—‰j |¦«j ‰¦«Sr)rrrr-)rrr-s €€rrz*ExprNameNamespace.suffix..rr+rr)rr-s``rr-zExprNameNamespace.suffix[r,rcó>‡—‰j ˆfd„¦«S)a¤Make the root column name lowercase. Returns: A new expression. Notes: This will undo any previous renaming operations on the expression. Due to implementation constraints, this method can only be called as the last expression in a chain. Only one name operation per expression will work. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, 2], "BAR": [4, 5]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("foo", "BAR").name.to_lowercase()).columns ['foo', 'bar'] cóf•—‰j |¦«j ¦«Sr)rrrÚ to_lowercasers €rrz0ExprNameNamespace.to_lowercase..‰ó&ø€˜œ ×5Ò5°cÑ:Ô:Ô?×LÒLÑNÔN€rrr!s`rr2zExprNameNamespace.to_lowercaseuó+ø€ð&Œz×.Ò.Ø NÐ NÐ NÐ Nñ ô ð rcó>‡—‰j ˆfd„¦«S)a¤Make the root column name uppercase. Returns: A new expression. Notes: This will undo any previous renaming operations on the expression. Due to implementation constraints, this method can only be called as the last expression in a chain. Only one name operation per expression will work. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> df_native = pa.table({"foo": [1, 2], "BAR": [4, 5]}) >>> df = nw.from_native(df_native) >>> df.select(nw.col("foo", "BAR").name.to_uppercase()).columns ['FOO', 'BAR'] cóf•—‰j |¦«j ¦«Sr)rrrÚ to_uppercasers €rrz0ExprNameNamespace.to_uppercase.. r3rrr!s`rr7zExprNameNamespace.to_uppercaseŒr4rN)r r rr)rr )r"r#rr )r'r(rr )r-r(rr ) Ú__name__Ú __module__Ú __qualname__rrr&r'r-r2r7©rrr r s €€€€€ððððð ð ð ð ð. ð ð ð ð6 ð ð ð ð4 ð ð ð ð4 ð ð ð ð. ð ð ð ð ð rr N) Ú __future__rÚtypingrrrrÚ narwhals.exprrr r r;rrúr?s«ðØ"Ð"Ð"Ð"Ð"Ð"à<Ð<Ð<Ð<Ð<Ð<Ð<Ð<Ð<Ð<Ð<Ð<àð#Ø"Ð"Ð"Ð"Ð"Ð"àˆ˜vÐ&Ñ&Ô&€ðV ðV ðV ðV ðV ˜ œñV ôV ðV ðV ðV r