o h8@sddlmZddlZddlmZddlmZerddlZddlmZ ddl Z ddl Z ddl m Zddl ZddlZddlZddlmZddlmZddlmZddlmZddlmZdd lmZdd lm Z dd l!m"Z"dd l#m$Z$dd l#m%Z%ddl#m&Z&ddl#m'Z'ddl#m(Z(ddl#m)Z)ddl#m*Z*ddl#m+Z+e,dgZ-dddZ.dddZ/dddZ0dddZ1ddd Z2dd!d"Z3dd#d$Z4dd%d&Z5dd'd(Z6dd)d*Z7dd+d,Z8dd-d.Z9dd/d0Z:dd1d2Z;dd3d4Zdd?d@Z?ddBdCZ@ddEdFZAddHdIZBddKdLZCddNdOZDddQdRZEddTdUZFddWdXZGddZd[ZHdd]d^ZIdd`daZJddcddZKddgdhZLddjdkZMddmdnZNddpdqZOddudvZPddxdyZQdd{d|ZRdddZSdddZTdddZUdddZVdddZWdddZXdddZYdddZZdddZ[gdZ\dS)) annotationsN) TYPE_CHECKING)Any) TypeGuard)TypeIs)ArrowChunkedArray)SQLFrameDataFrame DataFrame LazyFrameSeries)FrameT)IntoDataFrameT) IntoSeriesT)_1DArray)_2DArray)_NDArray) _NumpyScalar)_ShapeT fireducksreturnrcCtjddS)z;Get Polars module (if already imported - else return None).polarsNsysmodulesgetrrI/var/www/vscode/kcb/lib/python3.10/site-packages/narwhals/dependencies.py get_polars+r!cCr)z;Get pandas module (if already imported - else return None).pandasNrrrrr get_pandas0r"r$cCs tjdd}dur|jSdS)zAGet modin.pandas module (if already imported - else return None).modinN)rrrr#)r%rrr get_modin5sr&cCr)z9Get cudf module (if already imported - else return None).cudfNrrrrr get_cudf<r"r(cCr)z9Get cupy module (if already imported - else return None).cupyNrrrrr get_cupyAr"r*cCr)zGet dask_expr module (if already imported - else return None). dask_exprNrrrrr get_dask_exprdr"r7cCr)zz   z&is_pandas_dataframe..)r$rBr any IMPORT_HOOKS)r=pdrrFr is_pandas_dataframex(rMserTypeIs[pd.Series[Any]]cs2t}dur t|jptfddtDS)z@Check whether `ser` is a pandas Series without importing pandas.Nc3s4|]}tj|dduotjjVqdSrA)rrrrBr#rrCrGrOrr rHrIz#is_pandas_series..)r$rBrrJrK)rOrLrrQr is_pandas_seriesrNrRindexTypeIs[pd.Index[Any]]cr?)zACheck whether `index` is a pandas Index without importing pandas.Nc3r@rA)rrrrBr#IndexrCrSrGrr rHrIz"is_pandas_index..)r$rBrUrJrK)rSrLrrVr is_pandas_indexrNrWTypeIs[mpd.DataFrame]cCt}duo t||jS)z@Check whether `df` is a modin DataFrame without importing modin.N)r&rBr )r=mpdrrr is_modin_dataframer[TypeIs[mpd.Series]cCrY)z>Check whether `ser` is a modin Series without importing modin.N)r&rBr)rOrZrrr is_modin_seriesr\r^TypeIs[mpd.Index]cCrY)z?Check whether `index` is a modin Index without importing modin.N)r&rBrU)rSrZrrr is_modin_indexr`TypeIs[cudf.DataFrame]cCrY)z>Check whether `df` is a cudf DataFrame without importing cudf.N)r(rBr )r=r'rrr is_cudf_dataframer\rcTypeIs[cudf.Series[Any]]cCrY)zCheck whether `df` is a Dask DataFrame without importing Dask.N)r1rBr )r=ddrrr is_dask_dataframer\rjTypeIs[duckdb.DuckDBPyRelation]cCrY)zACheck whether `df` is a DuckDB Relation without importing DuckDB.N)r3rBDuckDBPyRelation)r=r2rrr is_duckdb_relationrarmTypeIs[ibis.Table]cCst}duot||jjjS)z:Check whether `df` is a Ibis Table without importing Ibis.N)r5rBexprtypesTable)r=r4rrr is_ibis_tablesrrTypeIs[pl.DataFrame]cCrY)zBCheck whether `df` is a Polars DataFrame without importing Polars.N)r!rBr r=plrrr is_polars_dataframer\rvTypeIs[pl.LazyFrame]cCrY)zBCheck whether `df` is a Polars LazyFrame without importing Polars.N)r!rBr rtrrr is_polars_lazyframer\rxTypeIs[pl.Series]cCrY)z@Check whether `ser` is a Polars Series without importing Polars.N)r!rBr)rOrurrr is_polars_seriesr\rzAny | ArrowChunkedArrayTypeIs[ArrowChunkedArray]cCrY)zHCheck whether `ser` is a PyArrow ChunkedArray without importing PyArrow.N)r,rB ChunkedArray)rOparrr is_pyarrow_chunked_arraysrTypeIs[pa.Table]cCrY)z@Check whether `df` is a PyArrow Table without importing PyArrow.N)r,rBrq)r=r~rrr is_pyarrow_tabler\rTypeIs[pyspark_sql.DataFrame]cCstt}duo t||jS)zDCheck whether `df` is a PySpark DataFrame without importing PySpark.N)boolr:rBr )r= pyspark_sqlrrr is_pyspark_dataframes rTypeIs[SQLFrameDataFrame]cCs$tdurddlm}t||SdS)zFCheck whether `df` is a SQLFrame DataFrame without importing SQLFrame.Nr) BaseDataFrameF)r<sqlframe.base.dataframerrB)r=rrrr is_sqlframe_dataframes   rarrAny | _NDArray[_ShapeT]TypeIs[_NDArray[_ShapeT]]cCrY)z=Check whether `arr` is a NumPy Array without importing NumPy.N)r.rBndarray)rnprrr is_numpy_arrayr\rTypeIs[_1DArray]cCt|o|jdkS)z@Check whether `arr` is a 1D NumPy Array without importing NumPy.rndimrrrr is_numpy_array_1drTypeIs[_2DArray]cCr)z@Check whether `arr` is a 2D NumPy Array without importing NumPy.rrrrr is_numpy_array_2drrscalarTypeGuard[_NumpyScalar]cCrY)zACheck whether `scalar` is a NumPy Scalar without importing NumPy.N)r.rBgeneric)rrrrr is_numpy_scalarsrrcCt|p t|p t|S)zCheck whether `df` is a pandas-like DataFrame without doing any imports. By "pandas-like", we mean: pandas, Modin, cuDF. )rMr[rc)r=rrr is_pandas_like_dataframe rcCr)zCheck whether `ser` is a pandas-like Series without doing any imports. By "pandas-like", we mean: pandas, Modin, cuDF. )rRr^re)rOrrr is_pandas_like_seriesrrcCr)zCheck whether `index` is a pandas-like Index without doing any imports. By "pandas-like", we mean: pandas, Modin, cuDF. )rWr`rg)rSrrr is_pandas_like_indexsr native_seriesAny | IntoSeriesTTypeIs[IntoSeriesT]cC8ddlm}t||pt|dpt|pt|pt|S)aCheck whether `native_series` can be converted to a Narwhals Series. Arguments: native_series: The object to check. Returns: `True` if `native_series` can be converted to a Narwhals Series, `False` otherwise. Examples: >>> 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.seriesrrBhasattrrzrr)rrrrr is_into_series#  rnative_dataframeAny | IntoDataFrameTTypeIs[IntoDataFrameT]cCr)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 rBrrvrr)rr rrr is_into_dataframeHrrDataFrame[IntoDataFrameT] | Any!TypeIs[DataFrame[IntoDataFrameT]]cCddlm}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 rB)r=r rrr is_narwhals_dataframems rlfAny | LazyFrame[FrameT]TypeIs[LazyFrame[FrameT]]cCr)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 rB)rr rrr is_narwhals_lazyframe{  rAny | Series[IntoSeriesT]TypeIs[Series[IntoSeriesT]]cCr)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 )rrrB)rOrrrr is_narwhals_seriesrr)r(r5r&r.r$r!r,rcrerjrrrrr[r^rrrrrMrWrrrRrvrxrzrr)rr)r=rrr>)rOrrrP)rSrrrT)r=rrrX)rOrrr])rSrrr_)r=rrrb)rOrrrd)rSrrrf)r=rrrh)r=rrrk)r=rrrn)r=rrrs)r=rrrw)rOrrry)rOr{rr|)r=rrr)r=rrr)r=rrr)rrrr)rrrr)rrrr)rrrr)r=rrr)rOrrr)rSrrr)rrrr)rrrr)r=rrr)rrrr)rOrrr)] __future__rrtypingrrr'dask.dataframe dataframerir2r4 modin.pandasr#rZrLrrur+r~ pyspark.sqlsqlrtyping_extensionsrrnarwhals._arrow.typingrnarwhals._spark_like.dataframerrr r rrnarwhals.typingrrrrrrrr frozensetrKr!r$r&r(r*r,r.r0r1r3r5r7r9r:r<rMrRrWr[r^r`rcrergrjrmrrrvrxrzrrrrrrrrrrrrrrrr__all__rrrr s                                                            % %