g2bddlmZddlZddlmZddlmZerbddlZejdk\rddlm Z nddl m Z ddl Z ddl m ZddlZddlZddlmZddlZddlZddlZddlmZddlmZddlmZdd lm Z dd l!m"Z"e#d gZ$d7d Z%d7d Z&d7dZ'd7dZ(d7dZ)d7dZ*d7dZ+d7dZ,d7dZ-d7dZ.d7dZ/d7dZ0d7dZ1d7dZ2d8dZ3d9dZ4d:dZ5d;dZ6dd Z9d?d!Z:d@d"Z;dAd#ZdDd&Z?dEd'Z@dFd(ZAdGd)ZBdHd*ZCdId+ZDdJd,ZEdKd-ZFdLd.ZGdMd/ZHdNd0ZIdOd1ZJdPd2ZKdQd3ZLdRd4ZMdSd5ZNgd6ZOy)T) annotationsN) TYPE_CHECKING)Any) ) TypeGuard DataFrame LazyFrameSeries) IntoSeries fireduckscBtjjddS)z;Get Polars module (if already imported - else return None).polarsNsysmodulesgetJ/var/www/openai/venv/lib/python3.12/site-packages/narwhals/dependencies.py get_polarsr& ;;??8T **rcBtjjddS)z;Get pandas module (if already imported - else return None).pandasNrrrr get_pandasr+rrc`tjjddx} |jSy)zAGet modin.pandas module (if already imported - else return None).modinN)rrrr)r s r get_modinr!0s)$//<|| rcBtjjddS)z9Get cudf module (if already imported - else return None).cudfNrrrrget_cudfr$7 ;;??64 ((rcBtjjddS)z9Get cupy module (if already imported - else return None).cupyNrrrrget_cupyr(<r%rcBtjjddS)zGet dask_expr module (if already imported - else return None). dask_exprNrrrr get_dask_exprr=_s ;;??; --rcBtjjddS)zz&is_pandas_dataframe..psSV(K  T2 24? 1 r3::// 0 1'AA)rrFr any IMPORT_HOOKS)rIpdrJs` @ris_pandas_dataframerPnsF< R , MB 1M RUV(VSrctx}duxrt|jxstfdtDS)z@Check whether `ser` is a pandas Series without importing pandas.Nc3K|]J}tjj|dxduxr tjj LywrE)rrrrFrr)rGrHrJsers rrKz#is_pandas_series..ysST(K  T2 24? / sCJJ-- . /'rL)rrFrrMrN)rSrOrJs` @ris_pandas_seriesrTwsF< R , KC1K PST(TQrctx}duxrt|jxstfdtDS)zACheck whether `index` is a pandas Index without importing pandas.Nc3K|]J}tjj|dxduxr tjj LywrE)rrrrFrIndex)rGrHindexrJs rrKz"is_pandas_index..sSU(K  T2 24? 0 ucjj.. / 0'rL)rrFrWrMrN)rXrOrJs` @ris_pandas_indexrYsF< R , LE2881L QTU(URrcNtx}duxrt||jS)z@Check whether `df` is a modin DataFrame without importing modin.N)r!rFr )rImpds ris_modin_dataframer\s$; Ct + M 2s}}0MMrcNtx}duxrt||jS)z>Check whether `ser` is a modin Series without importing modin.N)r!rFr)rSr[s ris_modin_seriesr^s$; Ct + K 3 0KKrcNtx}duxrt||jS)z?Check whether `index` is a modin Index without importing modin.N)r!rFrW)rXr[s ris_modin_indexr`s+; Ct +   syy1rcNtx}duxrt||jS)z>Check whether `df` is a cudf DataFrame without importing cudf.N)r$rFr )rIr#s ris_cudf_dataframerbs$J Dt + N 2t~~0NNrcNtx}duxrt||jS)zCheck whether `df` is a Dask DataFrame without importing Dask.N)r4rFr )rIdds ris_dask_dataframeris%$& &Bt 3 T 2r||8TTrcNtx}duxrt||jS)zACheck whether `df` is a DuckDB Relation without importing DuckDB.N)r7rFDuckDBPyRelation)rIr6s ris_duckdb_relationrls- l "F4 / J F # #5rcvtx}duxr*t||jjjS)z:Check whether `df` is a Ibis Table without importing Ibis.N)r:rFexprtypesTable)rIr9s r is_ibis_tablerqs.J Dt + U 2tyy?T?T0UUrcNtx}duxrt||jS)zBCheck whether `df` is a Polars DataFrame without importing Polars.N)rrFr rIpls ris_polars_dataframeru$, Bt + L 2r||0LLrcNtx}duxrt||jS)zBCheck whether `df` is a Polars LazyFrame without importing Polars.N)rrFr rss ris_polars_lazyframerxrvrcNtx}duxrt||jS)z@Check whether `ser` is a Polars Series without importing Polars.N)rrFr)rSrts ris_polars_seriesrzs$, Bt + J 3 0JJrcNtx}duxrt||jS)zHCheck whether `ser` is a PyArrow ChunkedArray without importing PyArrow.N)r+rF ChunkedArray)rSpas ris_pyarrow_chunked_arrayr~s$- B , QC1QQrcNtx}duxrt||jS)z@Check whether `df` is a PyArrow Table without importing PyArrow.N)r+rFrp)rIr}s ris_pyarrow_tablers$- B , IB1IIrc`ttx}duxrt||jS)zDCheck whether `df` is a PySpark DataFrame without importing PySpark.N)boolrBrFr )rI pyspark_sqls ris_pyspark_dataframers4 ') )$6 2 r;00 1 rcNtx}duxrt||jS)z=Check whether `arr` is a NumPy Array without importing NumPy.N)r/rFndarray)arrnps ris_numpy_arrayrs$+ Bd * Jz#rzz/JJrcFtx}duxr|j|S)zACheck whether `scalar` is a NumPy Scalar without importing NumPy.N)r/isscalar)scalarrs ris_numpy_scalarrs$+ Bd * B{r{{6/BBrcLt|xst|xs t|S)zCheck whether `df` is a pandas-like DataFrame without doing any imports. By "pandas-like", we mean: pandas, Modin, cuDF. )rPr\rb)rIs ris_pandas_like_dataframers& r " U&8&< U@QRT@UUrcLt|xst|xs t|S)zCheck whether `ser` is a pandas-like Series without doing any imports. By "pandas-like", we mean: pandas, Modin, cuDF. )rTr^rd)rSs ris_pandas_like_seriesrs# C OOC$8 ON3>> import pandas as pd >>> import polars as pl >>> import numpy as np >>> import narwhals as nw >>> s_pd = pd.Series([1, 2, 3]) >>> s_pl = pl.Series([1, 2, 3]) >>> np_arr = np.array([1, 2, 3]) >>> nw.dependencies.is_into_series(s_pd) True >>> nw.dependencies.is_into_series(s_pl) True >>> nw.dependencies.is_into_series(np_arr) False rr __narwhals_series__)narwhals.seriesrrFhasattrrzr~r) native_seriesrs ris_into_seriesrsS4' =&) 0 ="7 8 0 M * 0 $M 2 0 ! / rcddlm}t||xs3t|dxs%t |xst |xs t |S)aCheck whether `native_dataframe` can be converted to a Narwhals DataFrame. Arguments: native_dataframe: The object to check. Returns: `True` if `native_dataframe` can be converted to a Narwhals DataFrame, `False` otherwise. Examples: >>> import pandas as pd >>> import polars as pl >>> import numpy as np >>> from narwhals.dependencies import is_into_dataframe >>> df_pd = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}) >>> df_pl = pl.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}) >>> np_arr = np.array([[1, 4], [2, 5], [3, 6]]) >>> is_into_dataframe(df_pd) True >>> is_into_dataframe(df_pl) True >>> is_into_dataframe(np_arr) False rr __narwhals_dataframe__)narwhals.dataframer rFrrurr)native_dataframer s ris_into_dataframer&sX4- #Y/ 6 #%= > 6 / 0 6 , - 6 $$4 5 rc&ddlm}t||S)zCheck whether `df` is a Narwhals DataFrame. This is useful if you expect a user to pass in a Narwhals DataFrame directly, and you want to catch both ``narwhals.DataFrame`` and ``narwhals.stable.v1.DataFrame`. rr )rr rF)rIr s ris_narwhals_dataframerK- b) $$rc&ddlm}t||S)zCheck whether `lf` is a Narwhals LazyFrame. This is useful if you expect a user to pass in a Narwhals LazyFrame directly, and you want to catch both ``narwhals.LazyFrame`` and ``narwhals.stable.v1.LazyFrame`. rr )rr rF)lfr s ris_narwhals_lazyframerWrrc&ddlm}t||S)zCheck whether `ser` is a Narwhals Series. This is useful if you expect a user to pass in a Narwhals Series directly, and you want to catch both ``narwhals.Series`` and ``narwhals.stable.v1.Series`. rr )rrrF)rSrs ris_narwhals_seriesrcs' c6 ""r)r$r:r!r/rrr+rbrdrirqrrr\r^rrrrrPrYrrrTrurxrzr~r)returnr)rIrrzTypeGuard[pd.DataFrame])rSrrzTypeGuard[pd.Series[Any]])rXrrzTypeGuard[pd.Index])rIrrzTypeGuard[mpd.DataFrame])rSrrzTypeGuard[mpd.Series])rXrrzTypeGuard[mpd.Index])rIrrzTypeGuard[cudf.DataFrame])rSrrzTypeGuard[cudf.Series[Any]])rXrrzTypeGuard[cudf.Index])rIrrzTypeGuard[dd.DataFrame])rIrrz"TypeGuard[duckdb.DuckDBPyRelation])rIrrzTypeGuard[ibis.Table])rIrrzTypeGuard[pl.DataFrame])rIrrzTypeGuard[pl.LazyFrame])rSrrzTypeGuard[pl.Series])rSrrzTypeGuard[pa.ChunkedArray])rIrrzTypeGuard[pa.Table])rIrrz TypeGuard[pyspark_sql.DataFrame])rrrzTypeGuard[np.ndarray])rrrzTypeGuard[np.generic])rIrrr)rSrrr)rXrrr)rrrr)rrrr)rIrrzTypeGuard[DataFrame[Any]])rrrzTypeGuard[LazyFrame[Any]])rSrrzTypeGuard[Series[Any]])P __future__rrtypingrrr.r version_infortyping_extensionsr#dask.dataframe dataframerhr6r9 modin.pandasrr[rOrrtr*r} pyspark.sqlsqlrrr r rrnarwhals.typingr frozensetrNrrr!r$r(r+r/r2r4r7r:r=r@rBrPrTrYr\r^r`rbrdrfrirlrqrurxrzr~rrrrrrrrrrrr__all__rrrrsL#  7"$/%,,&* +' + + ) ) , * ) 3 + ) . , 0 N L O M U V M M K R J K C VP"J"J % % # r