g+ UddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z dd lm Z dd l m Z dd l mZdd lmZer~dd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZeeezezZde d<edeeZ!edeeefZ"edeZ#edeZ$edZ% d0dZ& d1dZ' d2d Z( d3d!Z) d4d"Z* d5d#Z+e d$d% d6d&Z,e d$d% d7d'Z,d$d% d8d(Z,e d9d)Z-e d:d*Z- d;d+Z-d) annotations)copy) TYPE_CHECKING)Any)Sequence)TypeVar)Union)cast)overload)is_numpy_array)InvalidIntoExprError)Implementation) TypeAlias) ArrowExpr)PandasLikeExpr)CompliantDataFrame) CompliantExpr)CompliantLazyFrame)CompliantNamespace)CompliantSeries)CompliantSeriesT_corIntoCompliantExprCompliantExprT)boundArrowOrPandasLikeExprPandasLikeExprT ArrowExprTTcHt||j}||S)zReturn list of raw columns. namespace)parse_into_expr__narwhals_namespace__)df into_exprexprs Q/var/www/openai/venv/lib/python3.12/site-packages/narwhals/_expression_parsing.pyevaluate_into_exprr(-s" 90I0I0K LD 8Ocfd|DDcgc] }|D]}| }}}|jD]Q\}}t|}t|dkDr d} t| |dj |} |j | S|Scc}}w)zEvaluate each expr into Series.c36K|]}t|ywN)r().0r%r$s r' z&evaluate_into_exprs..>sQ5i*2y95sz-Named expressions must return a single columnr)itemsr(lenAssertionErroraliasappend) r$exprs named_exprssublistitemseriesnamer&evaluated_exprmsg to_appends ` r'evaluate_into_exprsr>6sR5QQGD  Q  "'') d+B5 ~  "AC % %"1%++D1  i * MsB cFt|drtd|}||S|S)zAEvaluate `expr` if it's an expression, otherwise return it as is.__narwhals_expr__CompliantExpr[Any])hasattrr )r$r&compliant_exprs r'maybe_evaluate_exprrDKs,t()2D9b!! Kr)c |Dcgc]}t||c}|jDcgc]!\}}t||j|#c}}zScc}wcc}}w)znParse each input as an expression (if it's not already one). See `parse_into_expr` for more details. r )r"r0r3)r!r5r6r%r:r&s r'parse_into_exprsrFUsnNS SU OI ;U S%++-W-JD$  288>-W  SWs A&Ac0t|dr|St|dr|j|St|tr|j |St |r"|j |}|j|Stjt|)aParse `into_expr` as an expression. For example, in Polars, we can do both `df.select('a')` and `df.select(pl.col('a'))`. We do the same in Narwhals: - if `into_expr` is already an expression, just return it - if it's a Series, then convert it to an expression - if it's a numpy array, then convert it to a Series and then to an expression - if it's a string, then convert it to an expression - else, raise r@__narwhals_series__) rB_create_expr_from_series isinstancestrcolr _create_compliant_seriesr from_invalid_typetype)r%r!r9s r'r"r"ds y-.y/011)<<)S!}}Y''i 33I>11&99  0 0i AAr)c Jt|j}|j}t|j D]N}|Dt ||j r.|j|j|jCd}d}n|Ld}n|||| d}t|||fS)aReturn new root and output names after chaining expressions. Try tracking root and output names by combining them from all expressions appearing in kwargs. If any anonymous expression appears (e.g. nw.all()), then give up on tracking root names and just set it to None. Nz_Safety assertion failed, please report a bug to https://github.com/narwhals-dev/narwhals/issues) r _root_names _output_nameslistvaluesrJ __class__extendr2)r&kwargs root_names output_namesargr<s r'infer_new_root_output_namesr[sd&&'J%%LFMMO$  !jdnn&E*!!#//2! #   L %  *"4  $)?oS!! | ##r)F)returns_scalarc yr,r&attrr\rWs r'reuse_series_implementationrasr)c yr,r^r_s r'rarasr)c jdfd }tfi\}}j|jdzjd||ij S)aReuse Series implementation for expression. If Series.foo is already defined, and we'd like Expr.foo to be the same, we can leverage this method to do that for us. Arguments: expr: expression object. attr: name of method. returns_scalar: whether the Series version returns a scalar. In this case, the expression version should return a 1-row Series. args: arguments to pass to function. kwargs: keyword arguments to pass to function. c < jDcic]\}}|t||}}} r jtjurddini} |Dcgc];} r% j t | di|||nt | di|=}} j\|Dcgc]}|jc} jk7r5d jd|Dcgc]}|jc}}t||Scc}}wcc}wcc}wcc}w)N_return_py_scalarF)reference_serieszySafety assertion failed, please report a bug to https://github.com/narwhals-dev/narwhals/issues Expression output names: z Series names: r^) r0rD_implementationrPYARROW_create_series_from_scalargetattrrRr:r2)r$arg_name arg_value_kwargs extra_kwargsr9outsr<r`r&rWplxr\s r'funcz)reuse_series_implementation..funcsl(.||~ '5#) )"i8 8'5  $"6"6.:P:P"P!% ( r(& #  * *%%@ @@!' +  '&11  2 # &     ) !SQVVS !T%7%7 7,,0,>,>+?@!25!6#Q!&&#!6 79  !% % ? &  " "7sD AD/D$D r/->depth function_namerXrYrW)r$rreturnzSequence[CompliantSeries])r#r[_create_expr_from_callable_depth_function_namerm)r&r`r\rWrrrXrYrqs```` @r'raras(  % % 'C  D ;4J6JJ  ) ) kkAo,,-Rv6!)$,,)&) * r)c yr,r^r&series_namespacer`rWs r'%reuse_series_namespace_implementationr~sr)c yr,r^r|s r'r~r~sr)c j}|jfdjdzjddjj ij S)aReuse Series implementation for expression. Just like `reuse_series_implementation`, but for e.g. `Expr.dt.foo` instead of `Expr.foo`. Arguments: expr: expression object. series_namespace: The Series namespace (e.g. `dt`, `cat`, `str`, `list`, `name`) attr: name of method. args: arguments to pass to function. kwargs: keyword arguments to pass to function. c n|Dcgc]}tt|di c}Scc}w)Nr^)rj)r$r9r`r&rWr}s r'z7reuse_series_namespace_implementation..s@r( " =GGF$45t < Fv F"  s#2r/rs.rt)r#rxryrzrQrRrm)r&r}r`rWrqs```` r'r~r~s}$  % % 'C  ) ) kkAo,,-R0@/A4&I##'')$,,)&) *  r)c |jdkS)a(Check if expr is a very simple one. Examples: - nw.col('a').mean() # depth 1 - nw.mean('a') # depth 1 - nw.len() # depth 0 as opposed to, say - nw.col('a').filter(nw.col('b')>nw.col('c')).max() because then, we can use a fastpath in pandas. )ry)r&s r'is_simple_aggregationr s ;;?r)ct|dj}|ddD]1}||j|j|j.d}|S|S)Nrr/)rrQrV) parsed_exprsrXrZs r'combine_root_namesr1s_l1o112JAB  !*!!#//2!    r)cH|dj|djddSdS)z"Returns the left-most output name.rNr/)rR)rs r'reduce_output_namesr=s9 ? ( ( 4 Q%%bq)r)N)r$z'CompliantDataFrame | CompliantLazyFramer%&IntoCompliantExpr[CompliantSeriesT_co]rwSequence[CompliantSeriesT_co])r$rr5rr6rrwr)r$rr&z&CompliantExpr[CompliantSeriesT_co] | Trwz!Sequence[CompliantSeriesT_co] | T)r5rr!'CompliantNamespace[CompliantSeriesT_co]r6rrwz,Sequence[CompliantExpr[CompliantSeriesT_co]])r%rr!rrwz"CompliantExpr[CompliantSeriesT_co])r&rArWrrwz)tuple[list[str] | None, list[str] | None]) r&rr`rKr\boolrWrrwr) r&rr`rKr\rrWrrwr) r&ArrowExprT | PandasLikeExprTr`rKr\rrWrrwr) r&rr}rKr`rKrWrrwr) r&rr}rKr`rKrWrrwr) r&rr}rKr`rKrWrrwr)r&rArwr)rzSequence[CompliantExpr[Any]]rwzlist[str] | None)1 __future__rrtypingrrrrr r r narwhals.dependenciesr narwhals.exceptionsr narwhals.utilsrtyping_extensionsrnarwhals._arrow.exprrnarwhals._pandas_like.exprrnarwhals.typingrrrrrrrKr__annotations__rrrrrr(r>rDrFr"r[rar~rrrr^r)r'rs# 04)+.92-22/3 )*S03FFy-]35GHN#uY-F'G/~FOY7J A/5# 2:# *"H&  2 6 : 2 B5B7B( B8$ $(+$.$@ !          !         ! A &A A A  A " AH  (+36BE   -08;GJ  &   " @" r)