o 篪g@@s\ ddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd l mZdd lZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl m!Z"ddl m#Z$ddl m%Z%ddl m&Z&ddl m'Z'ddl m(Z(ddl m)Z)ddl m*Z*ddl m+Z+ddl m,Z-ddl m.Z.dd l m/Z/dd!l m0Z1dd"l2m3Z4dd#l5m6Z7dd$l8m9Z9dd%l:m;Z;dd&l:mZ>dd)l:m?Z?dd*l:m@Z@dd+l:mAZAdd,l:mBZBdd-l:mCZCdd.l:mDZDdd/l:mEZEdd0l:mFZFdd1l:mGZGdd2l:mHZHdd3l:mIZIdd4l:mJZJdd5l:mKZKdd6l:mLZLdd7l:mMZMdd8l:mNZNdd9l:mOZOdd:l:mPZPdd;l:mQZQddl:mTZTdd?lUmVZVdd@lUmWZWddAlUmXZXddBlYmZZZddClYm[Z[ddDl\m]Z]ddEl\m^Z^ddFl\m_Z_ddGl\m`Z`ddHl\maZaddIl\mbZbddJl\mcZcddKl\mdZdddLl\meZeddMl\mfZfddNl\mgZgddOl\mhZherddPlimjZjddQlkmlZlddRlmmnZnddSl moZoddTlYmpZpddUlYmqZqddVlYmrZrddWlYmsZsddXlYmtZte dYZuGdZd[d[eeZZGd\d]d]ee[ZGd^d_d_e7eZ6Gd`dadaeZGdbdcdce4Z3e dIdhdiZve dJdldiZve dKdndiZve dLdpdiZve dMdrdiZvdNdudiZve dvdvdwdOddZwe dvdvddPddZwe dvdvdvddQddZwe dvdvdvddRddZwe dvdvdvddSddZwe dvdvdvddTddZwe dvdvdvddUddZwe dvdvdvddVddZwe dvdvdvdvddWddZwe dvdvdvdvddXddZwe dvdvdvdvddYddZwe dvdvdvdvddZddZwe dvdvdvdvdd[ddZwe dvdvdvdvdd\ddZwe dvdvdvdvdvdd]ddZwe dvdvdwd^ddZwe dvdvdd_ddZwe dvdvdvdd`ddZwe dvdvdvddaddZwe dvdvdvddbddZwe dvdvdvddcddZwe dvdvdvdddddZwe dvdvdvddeddZwe dvdvdvdvddfddZwe dvdvdvdvddgddZwe dvdvdvdvddhddZwe dvdvdvdvddiddZwe dvdvdvdvddjddZwe dvdvdvdvddkddZwe dvdvdvdvdvddlddZwe dddmddZwd d dddd dœdnddZwe dvdƜdoddɄZxe dvdƜdpddɄZxe dvdƜdqddɄZxe drddɄZxe dvd͜dsddɄZxe dvd͜dtddɄZxe dvd͜duddɄZxe dvddɄZxd d dҜdwddɄZx dxd d dddddœdyddۄZydzdd݄Zzd{ddZ{d|ddZ|dzddZ}dxd}ddZ~d~ddZd~ddZd~ddZd~ddZd~ddZdddZdddZdddZdddZdddZdddZe dddd dZe dddddZe dddddZdddddZddddddZGddde$Z#Gdd d e"eZ!dd"d#Z0 dxdd(d)Zdd-d.Z, dxd d d/dd7d8Z dxdd;d<Zdd?d@ZddBdCZddDdEZddFdGZgdHZd S() annotationswraps) TYPE_CHECKING)Any)Callable)Iterable)Literal)Sequence)TypeVar)overload)warnN) dependencies) exceptions) selectors DataFrame LazyFrame) get_polars)InvalidIntoExprErrorExpr)Then)When)_from_dict_impl)_from_numpy_impl)_new_series_impl)_read_csv_impl)_read_parquet_impl)_scan_csv_impl)_scan_parquet_impl) from_arrow) get_level) show_versions)when)SchemaSeries)dtypes)Array)Boolean) Categorical)Date)Datetime)Decimal)Duration)Enum)Field)Float32)Float64)Int8)Int16)Int32)Int64)Int128)List)Object)String)Struct)UInt8)UInt16)UInt32)UInt64)UInt128)Unknown)_from_native_impl)get_native_namespace) to_py_scalar)IntoDataFrameT) IntoFrameT)Implementation)Versionfind_stacklevel)generate_temporary_column_name)is_ordered_categorical)maybe_align_index)maybe_convert_dtypes)maybe_get_index)maybe_reset_index)maybe_set_index)%validate_native_namespace_and_backendvalidate_strict_and_pass_though) ModuleType)Self)DType)ArrowStreamExportable)IntoExpr) IntoFrame) IntoSeries)_1DArray)_2DArrayTcseZdZdZed/ddZed0d d Zed1ddZed2ddZd3fdd Z d4d5fdd Z eddd6dd Z ed7d#d Z ed8d&d Z d'dd8fd(d Z d9fd)d* Z d9fd+d, Z d:d-d.Z ZS);raNarwhals DataFrame, backed by a native eager dataframe. !!! warning This class is not meant to be instantiated directly - instead: - If the native object is a eager dataframe from one of the supported backend (e.g. pandas.DataFrame, polars.DataFrame, pyarrow.Table), you can use [`narwhals.from_native`][]: ```py narwhals.from_native(native_dataframe) narwhals.from_native(native_dataframe, eager_only=True) ``` - If the object is a dictionary of column names and generic sequences mapping (e.g. `dict[str, list]`), you can create a DataFrame via [`narwhals.from_dict`][]: ```py narwhals.from_dict( data={"a": [1, 2, 3]}, native_namespace=narwhals.get_native_namespace(another_object), ) ``` selfrXreturn type[Series]cCtSNr'rargW/var/www/html/chatdoc2/venv/lib/python3.10/site-packages/narwhals/stable/v1/__init__.py_serieszDataFrame._seriestype[LazyFrame[Any]]cCrdrerrfrgrgrh _lazyframerjzDataFrame._lazyframeitem8str | tuple[slice | Sequence[int] | _1DArray, int | str]r(cCdSrergrarmrgrgrh __getitem__szDataFrame.__getitem__int | slice | _1DArray | Sequence[int] | Sequence[str] | tuple[slice | Sequence[int] | _1DArray, slice | Sequence[int] | Sequence[str]]cCrorergrprgrgrhrqs rc t|Sre)superrqrp __class__rgrhrqs Nbackend(ModuleType | Implementation | str | NoneLazyFrame[Any]ctj|dS)aRestrict available API methods to lazy-only ones. If `backend` is specified, then a conversion between different backends might be triggered. If a library does not support lazy execution and `backend` is not specified, then this is will only restrict the API to lazy-only operations. This is useful if you want to ensure that you write dataframe-agnostic code which all has the possibility of running entirely lazily. Arguments: backend: Which lazy backend collect to. This will be the underlying backend for the resulting Narwhals LazyFrame. If not specified, and the given library does not support lazy execution, then this will restrict the API to lazy-only operations. `backend` can be specified in various ways: - As `Implementation.` with `BACKEND` being `DASK`, `DUCKDB` or `POLARS`. - As a string: `"dask"`, `"duckdb"` or `"polars"` - Directly as a module `dask.dataframe`, `duckdb` or `polars`. Returns: A new LazyFrame. rw)rtlazy)rarwrurgrhr|szDataFrame.lazy. as_seriesr~ Literal[True]dict[str, Series]cCrorergrar~rgrgrhto_dictzDataFrame.to_dictLiteral[False]dict[str, list[Any]]cCrorergrrgrgrhrrbool(dict[str, Series] | dict[str, list[Any]]cCrorergrrgrgrhrTcrz)a1Convert DataFrame to a dictionary mapping column name to values. Arguments: as_series: If set to true ``True``, then the values are Narwhals Series, otherwise the values are Any. Returns: A mapping from column name to values / Series. r})rtrrrurgrhr c tS)ziGet a mask of all duplicated rows in this DataFrame. Returns: A new Series. )rt is_duplicatedrfrurgrhr zDataFrame.is_duplicatedcr)zeGet a mask of all unique rows in this DataFrame. Returns: A new Series. )rt is_uniquerfrurgrhrrzDataFrame.is_uniquecC|tS)zbPrivate, just used to test the stable API. Returns: A new DataFrame. selectall_l1_normrfrgrgrhrzDataFrame._l1_norm)rarXrbrc)rarXrbrk)rarXrmrnrbr()rarXrmrrrbrX)rarXrmrrbrre)rarXrwrxrbry)rarXr~rrbr)rarXr~rrbr)rarXr~rrbr)rarXrbr(rarXrbrX)__name__ __module__ __qualname____doc__propertyrirlr rqr|rrrr __classcell__rgrgrurhrcs0    "  rcsXeZdZdZedddZdd d Z ddfdd ZdddZdd fdd Z Z S)!raNarwhals LazyFrame, backed by a native lazyframe. !!! warning This class is not meant to be instantiated directly - instead use [`narwhals.from_native`][] with a native object that is a lazy dataframe from one of the supported backend (e.g. polars.LazyFrame, dask_expr._collection.DataFrame): ```py narwhals.from_native(native_lazyframe) ``` rarXrbtype[DataFrame[Any]]cCrdrerrfrgrgrh _dataframerjzLazyFrame._dataframeargrcCsddlm}ddlm}ddlm}t||r|jSt||r%d}t|t||r1| | St durJdt t |vrJdt |d}t|tt |) Nr BaseFramerr'z.Mixing Series with LazyFrame is not supported.polarszExpected Narwhals object, got: z[. Perhaps you: - Forgot a `nw.from_native` somewhere? - Used `pl.col` instead of `nw.col`?)narwhals.dataframer narwhals.exprrnarwhals.seriesr( isinstance_compliant_frame TypeError_to_compliant_expr__narwhals_namespace__rstrtyperfrom_invalid_type)rarrrr(msgrgrgrh_extract_compliants      zLazyFrame._extract_compliantNrwrxkwargsDataFrame[Any]c stjdd|i|S)aMaterialize this LazyFrame into a DataFrame. As each underlying lazyframe has different arguments to set when materializing the lazyframe into a dataframe, we allow to pass them as kwargs (see examples below for how to generalize the specification). Arguments: backend: specifies which eager backend collect to. This will be the underlying backend for the resulting Narwhals DataFrame. If None, then the following default conversions will be applied: - `polars.LazyFrame` -> `polars.DataFrame` - `dask.DataFrame` -> `pandas.DataFrame` - `duckdb.PyRelation` -> `pyarrow.Table` - `pyspark.DataFrame` -> `pyarrow.Table` `backend` can be specified in various ways: - As `Implementation.` with `BACKEND` being `PANDAS`, `PYARROW` or `POLARS`. - As a string: `"pandas"`, `"pyarrow"` or `"polars"` - Directly as a module `pandas`, `pyarrow` or `polars`. kwargs: backend specific kwargs to pass along. To know more please check the backend specific documentation: - [polars.LazyFrame.collect](https://docs.pola.rs/api/python/dev/reference/lazyframe/api/polars.LazyFrame.collect.html) - [dask.dataframe.DataFrame.compute](https://docs.dask.org/en/stable/generated/dask.dataframe.DataFrame.compute.html) Returns: DataFrame rwNrg)rtcollect)rarwrrurgrhrs$zLazyFrame.collectcCr)zbPrivate, just used to test the stable API. Returns: A new lazyframe. rrfrgrgrhr?rzLazyFrame._l1_normnintcrs)zGet the last `n` rows. Arguments: n: Number of rows to return. Returns: A subset of the LazyFrame of shape (n, n_columns). )rttailrarrurgrhrGs zLazyFrame.tailrarXrbr)rarXrrrbrre)rarXrwrxrrrbrr)r)rrrbrX) rrrrrrrrrrrrgrgrurhrs   &rcseZdZdZed9ddZd:fd d Zd d d d d d;fddZd d d d ddd dd<fd"d#Zd d d$d=fd(d)Z d d d$d=fd*d+Z d d dd,d>fd.d/Z d d dd,d>fd0d1Z d?d dd2d@fd7d8Z ZS)Ar(aiNarwhals Series, backed by a native series. !!! warning This class is not meant to be instantiated directly - instead: - If the native object is a series from one of the supported backend (e.g. pandas.Series, polars.Series, pyarrow.ChunkedArray), you can use [`narwhals.from_native`][]: ```py narwhals.from_native(native_series, allow_series=True) narwhals.from_native(native_series, series_only=True) ``` - If the object is a generic sequence (e.g. a list or a tuple of values), you can create a series via [`narwhals.new_series`][]: ```py narwhals.new_series( name=name, values=values, native_namespace=narwhals.get_native_namespace(another_object), ) ``` rarXrbrcCrdrerrfrgrgrhrorjzSeries._dataframercr)zsConvert to dataframe. Returns: A DataFrame containing this Series as a single column. )rtto_framerfrurgrhrsrzSeries.to_frameFNsortparallelname normalizerrrr str | Nonercstj||||dS)aCount the occurrences of unique values. Arguments: sort: Sort the output by count in descending order. If set to False (default), the order of the output is random. parallel: Execute the computation in parallel. Used for Polars only. name: Give the resulting count column a specific name; if `normalize` is True defaults to "proportion", otherwise defaults to "count". normalize: If true gives relative frequencies of the unique values Returns: A DataFrame with two columns: - The original values as first column - Either count or proportion as second column, depending on normalize parameter. r)rt value_counts)rarrrrrurgrhr{szSeries.value_countsTcomspan half_lifealphaadjust min_samples ignore_nullsr float | Nonerrrrrrrc Fddlm}ddlm} d} t| || dtj|||||||dS)aCompute exponentially-weighted moving average. !!! warning This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Arguments: com: Specify decay in terms of center of mass, $\gamma$, with
$\alpha = \frac{1}{1+\gamma}\forall\gamma\geq0$ span: Specify decay in terms of span, $\theta$, with
$\alpha = \frac{2}{\theta + 1} \forall \theta \geq 1$ half_life: Specify decay in terms of half-life, $\tau$, with
$\alpha = 1 - \exp \left\{ \frac{ -\ln(2) }{ \tau } \right\} \forall \tau > 0$ alpha: Specify smoothing factor alpha directly, $0 < \alpha \leq 1$. adjust: Divide by decaying adjustment factor in beginning periods to account for imbalance in relative weightings - When `adjust=True` (the default) the EW function is calculated using weights $w_i = (1 - \alpha)^i$ - When `adjust=False` the EW function is calculated recursively by $$ y_0=x_0 $$ $$ y_t = (1 - \alpha)y_{t - 1} + \alpha x_t $$ min_samples: Minimum number of observations in window required to have a value (otherwise result is null). ignore_nulls: Ignore missing values when calculating weights. - When `ignore_nulls=False` (default), weights are based on absolute positions. For example, the weights of $x_0$ and $x_2$ used in calculating the final weighted average of $[x_0, None, x_2]$ are $(1-\alpha)^2$ and $1$ if `adjust=True`, and $(1-\alpha)^2$ and $\alpha$ if `adjust=False`. - When `ignore_nulls=True`, weights are based on relative positions. For example, the weights of $x_0$ and $x_2$ used in calculating the final weighted average of $[x_0, None, x_2]$ are $1-\alpha$ and $1$ if `adjust=True`, and $1-\alpha$ and $\alpha$ if `adjust=False`. Returns: Series rNarwhalsUnstableWarningrKz^`Series.ewm_mean` is being called from the stable API although considered an unstable feature.messagecategory stacklevelrnarwhals.exceptionsrnarwhals.utilsrLr rtewm_mean rarrrrrrrrrLrrurgrhr 4 zSeries.ewm_meanrcenter window_size int | Nonerc>ddlm}ddlm}d}t|||dtj|||dS)aApply a rolling sum (moving sum) over the values. !!! warning This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. A window of length `window_size` will traverse the values. The resulting values will be aggregated to their sum. The window at a given row will include the row itself and the `window_size - 1` elements before it. Arguments: window_size: The length of the window in number of elements. It must be a strictly positive integer. min_samples: The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. If provided, it must be a strictly positive integer, and less than or equal to `window_size` center: Set the labels at the center of the window. Returns: A new series. rrrKza`Series.rolling_sum` is being called from the stable API although considered an unstable feature.rrrrrrrrLr rt rolling_sumrarrrrrLrrurgrhr  zSeries.rolling_sumcr)aApply a rolling mean (moving mean) over the values. !!! warning This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. A window of length `window_size` will traverse the values. The resulting values will be aggregated to their mean. The window at a given row will include the row itself and the `window_size - 1` elements before it. Arguments: window_size: The length of the window in number of elements. It must be a strictly positive integer. min_samples: The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. If provided, it must be a strictly positive integer, and less than or equal to `window_size` center: Set the labels at the center of the window. Returns: A new series. rrrKzb`Series.rolling_mean` is being called from the stable API although considered an unstable feature.rrrrrrLr rt rolling_meanrrurgrhr rzSeries.rolling_meanrrddofrc@ddlm}ddlm}d}t|||dtj||||dS)aApply a rolling variance (moving variance) over the values. !!! warning This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. A window of length `window_size` will traverse the values. The resulting values will be aggregated to their variance. The window at a given row will include the row itself and the `window_size - 1` elements before it. Arguments: window_size: The length of the window in number of elements. It must be a strictly positive integer. min_samples: The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. If provided, it must be a strictly positive integer, and less than or equal to `window_size`. center: Set the labels at the center of the window. ddof: Delta Degrees of Freedom; the divisor for a length N window is N - ddof. Returns: A new series. rrrKza`Series.rolling_var` is being called from the stable API although considered an unstable feature.rrrrrrrrrLr rt rolling_varrarrrrrrLrrurgrhr6 ! zSeries.rolling_varcr)aApply a rolling standard deviation (moving standard deviation) over the values. !!! warning This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. A window of length `window_size` will traverse the values. The resulting values will be aggregated to their standard deviation. The window at a given row will include the row itself and the `window_size - 1` elements before it. Arguments: window_size: The length of the window in number of elements. It must be a strictly positive integer. min_samples: The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. If provided, it must be a strictly positive integer, and less than or equal to `window_size`. center: Set the labels at the center of the window. ddof: Delta Degrees of Freedom; the divisor for a length N window is N - ddof. Returns: A new series. rrrKza`Series.rolling_std` is being called from the stable API although considered an unstable feature.rrrrrrLr rt rolling_stdrrurgrhrfrzSeries.rolling_std) bin_countinclude_breakpointbinslist[float | int] | Nonerrcr)akBin values into buckets and count their occurrences. !!! warning This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Arguments: bins: A monotonically increasing sequence of values. bin_count: If no bins provided, this will be used to determine the distance of the bins. include_breakpoint: Include a column that shows the intervals as categories. Returns: A new DataFrame containing the counts of values that occur within each passed bin. rrrKzZ`Series.hist` is being called from the stable API although considered an unstable feature.r)rrr)rrrrLr rthist)rarrrrrLrrurgrhrs  z Series.histr)rarXrbr) rarXrrrrrrrrrbrrarXrrrrrrrrrrrrrrrbrX rarXrrrrrrrbrX rarXrrrrrrrrrbrXre) rarXrrrrrrrbr)rrrrrrrrrrrrrrrrgrgrurhr(SsJ  J1142r(cseZdZdAfdd Zddddddd d dBfddZdd ddCfddZdd ddCfddZdd dddDfd!d"Zdd dddDfd#d$ZdEdFd'd(Z dEdFd)d*Z dGdHd-d.Z dd/dId2d3Z d d d4dJd7d8Z dAd9d:Z dKdd dd;dLd?d@ZZS)MrrarXrbcrre)rt _taxicab_normrfrurgrhrs z Expr._l1_normNTrFrrrrrrrrrrrc r)aCompute exponentially-weighted moving average. !!! warning This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. Arguments: com: Specify decay in terms of center of mass, $\gamma$, with
$\alpha = \frac{1}{1+\gamma}\forall\gamma\geq0$ span: Specify decay in terms of span, $\theta$, with
$\alpha = \frac{2}{\theta + 1} \forall \theta \geq 1$ half_life: Specify decay in terms of half-life, $\tau$, with
$\alpha = 1 - \exp \left\{ \frac{ -\ln(2) }{ \tau } \right\} \forall \tau > 0$ alpha: Specify smoothing factor alpha directly, $0 < \alpha \leq 1$. adjust: Divide by decaying adjustment factor in beginning periods to account for imbalance in relative weightings - When `adjust=True` (the default) the EW function is calculated using weights $w_i = (1 - \alpha)^i$ - When `adjust=False` the EW function is calculated recursively by $$ y_0=x_0 $$ $$ y_t = (1 - \alpha)y_{t - 1} + \alpha x_t $$ min_samples: Minimum number of observations in window required to have a value, (otherwise result is null). ignore_nulls: Ignore missing values when calculating weights. - When `ignore_nulls=False` (default), weights are based on absolute positions. For example, the weights of $x_0$ and $x_2$ used in calculating the final weighted average of $[x_0, None, x_2]$ are $(1-\alpha)^2$ and $1$ if `adjust=True`, and $(1-\alpha)^2$ and $\alpha$ if `adjust=False`. - When `ignore_nulls=True`, weights are based on relative positions. For example, the weights of $x_0$ and $x_2$ used in calculating the final weighted average of $[x_0, None, x_2]$ are $1-\alpha$ and $1$ if `adjust=True`, and $1-\alpha$ and $\alpha$ if `adjust=False`. Returns: Expr rrrKz\`Expr.ewm_mean` is being called from the stable API although considered an unstable feature.rrrrrurgrhrrz Expr.ewm_meanrrrrcr)aApply a rolling sum (moving sum) over the values. !!! warning This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. A window of length `window_size` will traverse the values. The resulting values will be aggregated to their sum. The window at a given row will include the row itself and the `window_size - 1` elements before it. Arguments: window_size: The length of the window in number of elements. It must be a strictly positive integer. min_samples: The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. If provided, it must be a strictly positive integer, and less than or equal to `window_size` center: Set the labels at the center of the window. Returns: A new expression. rrrKz_`Expr.rolling_sum` is being called from the stable API although considered an unstable feature.rrrrrurgrhrrzExpr.rolling_sumcr)a"Apply a rolling mean (moving mean) over the values. !!! warning This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. A window of length `window_size` will traverse the values. The resulting values will be aggregated to their mean. The window at a given row will include the row itself and the `window_size - 1` elements before it. Arguments: window_size: The length of the window in number of elements. It must be a strictly positive integer. min_samples: The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. If provided, it must be a strictly positive integer, and less than or equal to `window_size` center: Set the labels at the center of the window. Returns: A new expression. rrrKz``Expr.rolling_mean` is being called from the stable API although considered an unstable feature.rrrrrurgrhr1rzExpr.rolling_meanrrcr)aApply a rolling variance (moving variance) over the values. !!! warning This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. A window of length `window_size` will traverse the values. The resulting values will be aggregated to their variance. The window at a given row will include the row itself and the `window_size - 1` elements before it. Arguments: window_size: The length of the window in number of elements. It must be a strictly positive integer. min_samples: The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. If provided, it must be a strictly positive integer, and less than or equal to `window_size`. center: Set the labels at the center of the window. ddof: Delta Degrees of Freedom; the divisor for a length N window is N - ddof. Returns: A new expression. rrrKz_`Expr.rolling_var` is being called from the stable API although considered an unstable feature.rrrrrurgrhr^s ! zExpr.rolling_varcr)aApply a rolling standard deviation (moving standard deviation) over the values. !!! warning This functionality is considered **unstable**. It may be changed at any point without it being considered a breaking change. A window of length `window_size` will traverse the values. The resulting values will be aggregated to their standard deviation. The window at a given row will include the row itself and the `window_size - 1` elements before it. Arguments: window_size: The length of the window in number of elements. It must be a strictly positive integer. min_samples: The number of values in the window that should be non-null before computing a result. If set to `None` (default), it will be set equal to `window_size`. If provided, it must be a strictly positive integer, and less than or equal to `window_size` center: Set the labels at the center of the window. ddof: Delta Degrees of Freedom; the divisor for a length N window is N - ddof. Returns: A new expression. rrrKz_`Expr.rolling_std` is being called from the stable API although considered an unstable feature.rrrrrurgrhrrzExpr.rolling_std rcjfddddjdS)zGet the first `n` rows. Arguments: n: Number of rows to return. Returns: A new expression. c|Sre)rheadplxrrargrhzExpr.head..Tis_order_dependentchanges_length aggregatesrv _aggregatesrrgrrhr  z Expr.headcr)zGet the last `n` rows. Arguments: n: Number of rows to return. Returns: A new expression. crre)rrrrrgrhrrzExpr.tail..Trrrrgrrhrrz Expr.tailroffsetcs jfddddjdS)zTake every nth value in the Series and return as new Series. Arguments: n: Gather every *n*-th row. offset: Starting index. Returns: A new expression. c|jdS)N)rr)r gather_everyrrrrargrhrsz#Expr.gather_every..Trr)rarrrgrrhrs  zExpr.gather_every)maintain_orderr  bool | Nonecs:|durd}t|ttdjfddjdjdS)aTReturn unique values of this expression. Arguments: maintain_order: Keep the same order as the original expression. This is deprecated and will be removed in a future version, but will still be kept around in `narwhals.stable.v1`. Returns: A new expression. Nzx`maintain_order` has no effect and is only kept around for backwards-compatibility. You can safely remove this argument.rc|Sre)runiquerrfrgrhrzExpr.unique..T)rr)r UserWarningrLrv_is_order_dependentr)rar rrgrfrhr s  z Expr.unique descending nulls_lastrrcs"jfdddjjdS)zSort this column. Place null values first. Arguments: descending: Sort in descending order. nulls_last: Place null values last instead of first. Returns: A new expression. cr)Nr)rrrrrrargrhrs zExpr.sort..Tr)rv_changes_lengthr)rarrrgrrhrs  z Expr.sortcsjfddddjdS)zhFind elements where boolean expression is True. Returns: A new expression. cr re)rarg_truerrfrgrhrr zExpr.arg_true..Trrrfrgrfrhrs  z Expr.arg_truefractionwith_replacementseedrrrcs$jfddddjdS)aRSample randomly from this expression. !!! warning `Expr.sample` is deprecated and will be removed in a future version. Hint: instead of `df.select(nw.col('a').sample())`, use `df.select(nw.col('a')).sample()` instead. Note: this will remain available in `narwhals.stable.v1`. See [stable api](../backcompat.md/) for more information. Arguments: n: Number of items to return. Cannot be used with fraction. fraction: Fraction of items to return. Cannot be used with n. with_replacement: Allow values to be sampled more than once. seed: Seed for the random number generator. If set to None (default), a random seed is generated for each sample operation. Returns: A new expression. cs|jdS)Nr)rsamplerrrrrarrgrhr@s zExpr.sample..Trr)rarrrrrgrrhr$s z Expr.samplerrrr)r)rarXrrrbrX)r)rarXrrrrrbrX)rarXr r rbrX)rarXrrrrrbrXre) rarXrrrrrrrrrbrX)rrrrrrrrrrrrr rrrrrgrgrurhrsHJ111 0   rc@seZdZdZejZdS)r&a:Ordered mapping of column names to their data type. Arguments: schema: Mapping[str, DType] | Iterable[tuple[str, DType]] | None The schema definition given by column names and their associated. *instantiated* Narwhals data type. Accepts a mapping or an iterable of tuples. N)rrrrrJV1_versionrgrgrgrhr&Is r&objNwDataFrame[IntoFrameT]rbDataFrame[IntoFrameT]cCrorergrrgrgrh _stableifyUrr"NwLazyFrame[IntoFrameT]LazyFrame[IntoFrameT]cCrorergr!rgrgrhr"Wr NwSeries[Any]cCrorergr!rgrgrhr"YrNwExprcCrorergr!rgrgrhr"[rrcCrorergr!rgrgrhr"]rPNwDataFrame[IntoFrameT] | NwLazyFrame[IntoFrameT] | NwSeries[Any] | NwExpr | AnyCDataFrame[IntoFrameT] | LazyFrame[IntoFrameT] | Series | Expr | AnycCst|trt|jtj|jdSt|tr"t |jtj|jdSt|t r3t |j tj|jdSt|t rDt|j|j|j|jdS|S)N)levelr)r NwDataFramerr_change_versionrJr_level NwLazyFramerNwSeriesr(_compliant_seriesr&rrrrrr!rgrgrhr"as.       .) eager_only series_only native_objectIntoDataFrameT | IntoSeriesstrictrr0eager_or_interchange_onlyrr1 allow_series"DataFrame[IntoDataFrameT] | SeriescCrorergr2r4r0r5r1r6rgrgrh from_native} r9)r5r1cCrorergr8rgrgrhr9r:)r0r1r6rGNoneDataFrame[IntoDataFrameT]cCrorergr8rgrgrhr9r:cCrorergr8rgrgrhr9r:)r5r1r6cCrorergr8rgrgrhr9r:cCrorergr8rgrgrhr9r:)r0r5r1IntoFrameT | IntoSeries6DataFrame[IntoFrameT] | LazyFrame[IntoFrameT] | SeriescCrorergr8rgrgrhr9r:)r0r5r6r]cCrorergr8rgrgrhr9r:)r0r5r1r6rH-DataFrame[IntoFrameT] | LazyFrame[IntoFrameT]cCrorergr8rgrgrhr9r:cCrorergr8rgrgrhr9r:)r4r0r1r6cCrorergr8rgrgrhr9r:)r4r5r1r6cCrorergr8rgrgrhr9r:)r4r0r5r1IntoFrame | IntoSeries(DataFrame[Any] | LazyFrame[Any] | SeriescCrorergr8rgrgrhr9 r:)r4r0r5r6IntoSeries | AnycCrorergr8rgrgrhr9r:)r4r0r5r1r6cCrorergr8rgrgrhr9%r: pass_throughcCrorergr2rCr0r5r1r6rgrgrhr91r:cCrorergrDrgrgrhr9=r:cCrorergrDrgrgrhr9Ir:cCrorergrDrgrgrhr9Ur:cCrorergrDrgrgrhr9ar:cCrorergrDrgrgrhr9mr:cCrorergrDrgrgrhr9yr:cCrorergrDrgrgrhr9r:cCrorergrDrgrgrhr9r:cCrorergrDrgrgrhr9r:)rCr0r1r6cCrorergrDrgrgrhr9r:)rCr5r1r6cCrorergrDrgrgrhr9r:)rCr0r5r1cCrorergrDrgrgrhr9r:)rCr0r5r6cCrorergrDrgrgrhr9r:rCr0r5r1r6cCrorergrDrgrgrhr9r:F)r5rr cCrorergrDrgrgrhr9r:)r4rCr0r5r1r6'IntoFrameT | IntoFrame | IntoSeries | T:LazyFrame[IntoFrameT] | DataFrame[IntoFrameT] | Series | Tc Cs\t|ttfr |s |St|tr|s|r|St||ddd}t||||||tjd}t|S)a Convert `native_object` to Narwhals Dataframe, Lazyframe, or Series. Arguments: native_object: Raw object from user. Depending on the other arguments, input object can be: - a Dataframe / Lazyframe / Series supported by Narwhals (pandas, Polars, PyArrow, ...) - an object which implements `__narwhals_dataframe__`, `__narwhals_lazyframe__`, or `__narwhals_series__` strict: Determine what happens if the object can't be converted to Narwhals: - `True` or `None` (default): raise an error - `False`: pass object through as-is **Deprecated** (v1.13.0): Please use `pass_through` instead. Note that `strict` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). pass_through: Determine what happens if the object can't be converted to Narwhals: - `False` or `None` (default): raise an error - `True`: pass object through as-is eager_only: Whether to only allow eager objects: - `False` (default): don't require `native_object` to be eager - `True`: only convert to Narwhals if `native_object` is eager eager_or_interchange_only: Whether to only allow eager objects or objects which have interchange-level support in Narwhals: - `False` (default): don't require `native_object` to either be eager or to have interchange-level support in Narwhals - `True`: only convert to Narwhals if `native_object` is eager or has interchange-level support in Narwhals See [interchange-only support](../extending.md/#interchange-only-support) for more details. series_only: Whether to only allow Series: - `False` (default): don't require `native_object` to be a Series - `True`: only convert to Narwhals if `native_object` is a Series allow_series: Whether to allow Series (default is only Dataframe / Lazyframe): - `False` or `None` (default): don't convert to Narwhals if `native_object` is a Series - `True`: allow `native_object` to be a Series Returns: DataFrame, LazyFrame, Series, or original object, depending on which combination of parameters was passed. Fpass_through_defaultemit_deprecation_warning)rCr0r5r1r6version) rrrr(rVrDrJrr")r2r4rCr0r5r1r6resultrgrgrhr9s"< )r4narwhals_objectcCrorergrMr4rgrgrh to_nativeCrrOcCrorergrNrgrgrhrOGrcCrorergrNrgrgrhrOKrcCrorergrNrgrgrhrOMrrCcCrorergrMrCrgrgrhrOOrcCrorergrQrgrgrhrOSrcCrorergrQrgrgrhrOWrcCrorergrQrgrgrhrOYr)r4rC:DataFrame[IntoDataFrameT] | LazyFrame[IntoFrameT] | SeriesIntoFrameT | AnycCsxddlm}ddlm}ddlm}|||ddd}t||r#|jjSt||r,|j j S|s:dt |d}t ||S) a<Convert Narwhals object to native one. Arguments: narwhals_object: Narwhals object. strict: Determine what happens if `narwhals_object` isn't a Narwhals class: - `True` (default): raise an error - `False`: pass object through as-is **Deprecated** (v1.13.0): Please use `pass_through` instead. Note that `strict` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). pass_through: Determine what happens if `narwhals_object` isn't a Narwhals class: - `False` (default): raise an error - `True`: pass object through as-is Returns: Object of class that user started with. rrr'rUFrHzExpected Narwhals object, got .) rrrr(rrVrr _native_framer/_native_seriesrr)rMr4rCrr(rVrrgrgrhrO]s     TfuncCallable[..., Any] | NoneCallable[..., Any]cs:t|dddd fdd }|d ur|S||S) a Decorate function so it becomes dataframe-agnostic. This will try to convert any dataframe/series-like object into the Narwhals respective DataFrame/Series, while leaving the other parameters as they are. Similarly, if the output of the function is a Narwhals DataFrame or Series, it will be converted back to the original dataframe/series type, while if the output is another type it will be left as is. By setting `pass_through=False`, then every input and every output will be required to be a dataframe/series-like object. Arguments: func: Function to wrap in a `from_native`-`to_native` block. strict: **Deprecated** (v1.13.0): Please use `pass_through` instead. Note that `strict` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). Determine what happens if the object can't be converted to Narwhals: - `True` or `None` (default): raise an error - `False`: pass object through as-is pass_through: Determine what happens if the object can't be converted to Narwhals: - `False` or `None` (default): raise an error - `True`: pass object through as-is eager_only: Whether to only allow eager objects: - `False` (default): don't require `native_object` to be eager - `True`: only convert to Narwhals if `native_object` is eager eager_or_interchange_only: Whether to only allow eager objects or objects which have interchange-level support in Narwhals: - `False` (default): don't require `native_object` to either be eager or to have interchange-level support in Narwhals - `True`: only convert to Narwhals if `native_object` is eager or has interchange-level support in Narwhals See [interchange-only support](../extending.md/#interchange-only-support) for more details. series_only: Whether to only allow Series: - `False` (default): don't require `native_object` to be a Series - `True`: only convert to Narwhals if `native_object` is a Series allow_series: Whether to allow Series (default is only Dataframe / Lazyframe): - `False` or `None`: don't convert to Narwhals if `native_object` is a Series - `True` (default): allow `native_object` to be a Series Returns: Decorated function. TFrHrWrYrbcs$tdfdd }|S)Nargsrrrbcsfdd|D}fdd|D}fddg||RD}|dkr8d}t||i|}t|d S) Nc s g|] }t|dqSrEr9).0rr6r0r5rCr1rgrh s zBnarwhalify..decorator..wrapper..c s&i|]\}}|t|dqSr[r\)r]rvaluer^rgrh s zBnarwhalify..decorator..wrapper..cs"h|] }t|ddrqS)__native_namespace__N)getattr)r]vbrgrh s zAnarwhalify..decorator..wrapper..rz_Found multiple backends. Make sure that all dataframe/series inputs come from the same backend.rP)itemsvalues__len__ ValueErrorrO)rZrbackendsrrL)r6r0r5rWrCr1rerhwrappers      z.narwhalify..decorator..wrapper)rZrrrrbrr)rWrmr^)rWrh decorators'znarwhalify..decoratorN)rWrYrbrYrU)rWr4rCr0r5r1r6rnrgr^rh narwhalifys=+rocC ttS)z`Instantiate an expression representing all columns. Returns: A new expression. )r"nwrrgrgrgrhr rnamesstr | Iterable[str]cGttj|S)zCreates an expression that references one or more columns by their name(s). Arguments: names: Name(s) of the columns to use. Returns: A new expression. )r"rqcol)rsrgrgrhrvs rvindicesint | Sequence[int]cGru)aICreates an expression that references one or more columns by their index(es). Notes: `nth` is not supported for Polars version<1.0.0. Please use [`narwhals.col`][] instead. Arguments: indices: One or more indices representing the columns to retrieve. Returns: A new expression. )r"rqnth)rwrgrgrhry rycCrp)zGReturn the number of rows. Returns: A new expression. )r"rqlenrgrgrgrhr{#rrr{r`dtypeDType | type[DType] | NonecCstt||S)a Return an expression representing a literal value. Arguments: value: The value to use as literal. dtype: The data type of the literal value. If not provided, the data type will be inferred. Returns: A new expression. )r"rqlit)r`r|rgrgrhr~,s r~columnsrcGru)zReturn the minimum value. Note: Syntactic sugar for ``nw.col(columns).min()``. Arguments: columns: Name(s) of the columns to use in the aggregation function. Returns: A new expression. )r"rqminrrgrgrhr:rrcGru)zReturn the maximum value. Note: Syntactic sugar for ``nw.col(columns).max()``. Arguments: columns: Name(s) of the columns to use in the aggregation function. Returns: A new expression. )r"rqmaxrrgrgrhrIrrcGru)zGet the mean value. Note: Syntactic sugar for ``nw.col(columns).mean()`` Arguments: columns: Name(s) of the columns to use in the aggregation function Returns: A new expression. )r"rqmeanrrgrgrhrXrrcGru)atGet the median value. Notes: - Syntactic sugar for ``nw.col(columns).median()`` - Results might slightly differ across backends due to differences in the underlying algorithms used to compute the median. Arguments: columns: Name(s) of the columns to use in the aggregation function Returns: A new expression. )r"rqmedianrrgrgrhrgsrcGru)zSum all values. Note: Syntactic sugar for ``nw.col(columns).sum()`` Arguments: columns: Name(s) of the columns to use in the aggregation function Returns: A new expression. )r"rqsumrrgrgrhrxrrexprsIntoExpr | Iterable[IntoExpr]cGru)a2Sum all values horizontally across columns. Warning: Unlike Polars, we support horizontal sum over numeric columns only. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Returns: A new expression. )r"rqsum_horizontalrrgrgrhrrzrcGru)zCompute the bitwise AND horizontally across columns. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Returns: A new expression. )r"rqall_horizontalrrgrgrhr rcGru)zCompute the bitwise OR horizontally across columns. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Returns: A new expression. )r"rqany_horizontalrrgrgrhrrrcGru)zCompute the mean of all values horizontally across columns. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Returns: A new expression. )r"rqmean_horizontalrrgrgrhrrrcGru)a*Get the minimum value horizontally across columns. Notes: We support `min_horizontal` over numeric columns only. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Returns: A new expression. )r"rqmin_horizontalrrgrgrhrrzrcGru)a*Get the maximum value horizontally across columns. Notes: We support `max_horizontal` over numeric columns only. Arguments: exprs: Name(s) of the columns to use in the aggregation function. Accepts expression input. Returns: A new expression. )r"rqmax_horizontalrrgrgrhrrzrverticalhowrh#Iterable[DataFrame[IntoDataFrameT]]r-Literal['horizontal', 'vertical', 'diagonal']cCrorergrhrrgrgrhconcatrIterable[LazyFrame[IntoFrameT]]cCrorergrrgrgrhrr;Iterable[DataFrame[IntoDataFrameT] | LazyFrame[IntoFrameT]]1DataFrame[IntoDataFrameT] | LazyFrame[IntoFrameT]cCrorergrrgrgrhrrcCsttj||dS)aConcatenate multiple DataFrames, LazyFrames into a single entity. Arguments: items: DataFrames, LazyFrames to concatenate. how: concatenating strategy: - vertical: Concatenate vertically. Column names must match. - horizontal: Concatenate horizontally. If lengths don't match, then missing rows are filled with null values. - diagonal: Finds a union between the column schemas and fills missing column values with null. Returns: A new DataFrame, Lazyframe resulting from the concatenation. Raises: TypeError: The items to concatenate should either all be eager, or all lazy r)r"rqrrrgrgrhrs separatorr more_exprsr[rrcGsttj|g|R||dS)aHorizontally concatenate columns into a single string column. Arguments: exprs: Columns to concatenate into a single string column. Accepts expression input. Strings are parsed as column names, other non-expression inputs are parsed as literals. Non-`String` columns are cast to `String`. *more_exprs: Additional columns to concatenate into a single string column, specified as positional arguments. separator: String that will be used to separate the values of each column. ignore_nulls: Ignore null values (default is `False`). If set to `False`, null values will be propagated and if the row contains any null values, the output is null. Returns: A new expression. r)r"rq concat_str)rrrrrgrgrhrsrc,eZdZedddZdfd d ZZS)rclsrr%NwWhenrbcCs ||jSre) _predicates)rr%rgrgrh from_when,s zWhen.from_whenrarXr`rrcstt|Sre)r from_thenrtthenrar`rurgrhr0sz When.then)rrr%rrbr)rarXr`rrbr)rrr classmethodrrrrgrgrurhr+s rcr)rrrrNwThenrbcCs||j|j|j|jdS)Nr)rrrr)rrrgrgrhr5s zThen.from_thenrarXr`rrcstt|Sre)r"rt otherwiserrurgrhr>szThen.otherwise)rrrrrbr)rarXr`rrbr)rrrrrrrrgrgrurhr4s r predicatescGstt|S)aStart a `when-then-otherwise` expression. Expression similar to an `if-else` statement in Python. Always initiated by a `pl.when().then()`, and optionally followed by chaining one or more `.when().then()` statements. Chained when-then operations should be read as Python `if, elif, ... elif` blocks, not as `if, if, ... if`, i.e. the first condition that evaluates to `True` will be picked. If none of the conditions are `True`, an optional `.otherwise()` can be appended at the end. If not appended, and none of the conditions are `True`, `None` will be returned. Arguments: predicates: Condition(s) that must be met in order to apply the subsequent statement. Accepts one or more boolean expressions, which are implicitly combined with `&`. String input is parsed as a column name. Returns: A "when" object, which `.then` can be called on. )rrnw_when)rrgrgrhr%Bsr%rrinative_namespacerWcCstt||||tjdS)aInstantiate Narwhals Series from iterable (e.g. list or array). Arguments: name: Name of resulting Series. values: Values of make Series from. dtype: (Narwhals) dtype. If not provided, the native library may auto-infer it from `values`. native_namespace: The native library to use for DataFrame creation. Returns: A new Series rrK)r"rrJr)rrir|rrgrgrh new_seriesZsr native_framerZrcCstt||dS)aConstruct a DataFrame from an object which supports the PyCapsule Interface. Arguments: native_frame: Object which implements `__arrow_c_stream__`. native_namespace: The native library to use for DataFrame creation. Returns: A new DataFrame. )r)r" nw_from_arrow)rrrgrgrhr"xs r")rwrdatadict[str, Any]schema dict[str, DType] | Schema | NonerwrxModuleType | NonecCs t||dd}tt|||dS)aQInstantiate DataFrame from dictionary. Indexes (if present, for pandas-like backends) are aligned following the [left-hand-rule](../pandas_like_concepts/pandas_index.md/). Notes: For pandas-like dataframes, conversion to schema is applied after dataframe creation. Arguments: data: Dictionary to create DataFrame from. schema: The DataFrame schema as Schema or dict of {name: type}. backend: specifies which eager backend instantiate to. Only necessary if inputs are not Narwhals Series. `backend` can be specified in various ways: - As `Implementation.` with `BACKEND` being `PANDAS`, `PYARROW`, `POLARS`, `MODIN` or `CUDF`. - As a string: `"pandas"`, `"pyarrow"`, `"polars"`, `"modin"` or `"cudf"`. - Directly as a module `pandas`, `pyarrow`, `polars`, `modin` or `cudf`. native_namespace: The native library to use for DataFrame creation. **Deprecated** (v1.26.0): Please use `backend` instead. Note that `native_namespace` is still available (and won't emit a deprecation warning) if you use `narwhals.stable.v1`, see [perfect backwards compatibility policy](../backcompat.md/). Returns: A new DataFrame. F)rJr{)rTr"r)rrrwrrgrgrh from_dicts & rr_,dict[str, DType] | Schema | list[str] | NonecCstt|||tjdS)aConstruct a DataFrame from a NumPy ndarray. Notes: Only row orientation is currently supported. For pandas-like dataframes, conversion to schema is applied after dataframe creation. Arguments: data: Two-dimensional data represented as a NumPy ndarray. schema: The DataFrame schema as Schema, dict of {name: type}, or a list of str. native_namespace: The native library to use for DataFrame creation. Returns: A new DataFrame. r)r"rrJr)rrrrgrgrh from_numpysrsourcercKtt|fd|i|S)aRead a CSV file into a DataFrame. Arguments: source: Path to a file. native_namespace: The native library to use for DataFrame creation. kwargs: Extra keyword arguments which are passed to the native CSV reader. For example, you could use `nw.read_csv('file.csv', native_namespace=pd, engine='pyarrow')`. Returns: DataFrame. r)r"rrrrrgrgrhread_csvrrycKr)a&Lazily read from a CSV file. For the libraries that do not support lazy dataframes, the function reads a csv file eagerly and then converts the resulting dataframe to a lazyframe. Arguments: source: Path to a file. native_namespace: The native library to use for DataFrame creation. kwargs: Extra keyword arguments which are passed to the native CSV reader. For example, you could use `nw.scan_csv('file.csv', native_namespace=pd, engine='pyarrow')`. Returns: LazyFrame. r)r"r rrgrgrhscan_csvrcKr)aRead into a DataFrame from a parquet file. Arguments: source: Path to a file. native_namespace: The native library to use for DataFrame creation. kwargs: Extra keyword arguments which are passed to the native parquet reader. For example, you could use `nw.read_parquet('file.parquet', native_namespace=pd, engine='pyarrow')`. Returns: DataFrame. r)r"rrrgrgrh read_parquet rrcKr)a:Lazily read from a parquet file. For the libraries that do not support lazy dataframes, the function reads a parquet file eagerly and then converts the resulting dataframe to a lazyframe. Arguments: source: Path to a file. native_namespace: The native library to use for DataFrame creation. kwargs: Extra keyword arguments which are passed to the native parquet reader. For example, you could use `nw.scan_parquet('file.parquet', native_namespace=pd, engine='pyarrow')`. Returns: LazyFrame. r)r"r!rrgrgrh scan_parquet rr)Mr*r+r,rr-r.r/r0r1rr2r3r4rIr5r6r7r8r9rr:r;r&r(r<r=r>r?r@rArBrCrrrrvrrrr)rr"rr9rrMr#rErNr{r~rrrOrPrQrRrSrrrrrrorryrrrrrr$rrrOrFr%)rrrbr )rr#rbr$)rr%rbr()rr&rbr)rrrbr)rr'rbr()r2r3r4rr0rr5rr1rr6rrbr7)r2r3r4rr0rr5rr1rr6rrbr7)r2rGr4rr0rr5rr1rr6r;rbr<)r2r`r4rr0rr5rr1rr6r;rbr`)r2rGr4rr0rr5rr1rr6r;rbr<)r2r`r4rr0rr5rr1rr6r;rbr`)r2r=r4rr0rr5rr1rr6rrbr>)r2r]r4rr0rr5rr1rr6r;rbr()r2rHr4rr0rr5rr1rr6r;rbr?)r2r`r4rr0rr5rr1rr6r;rbr`)r2rGr4rr0rr5rr1rr6r;rbr<)r2rGr4rr0rr5rr1rr6r;rbr<)r2r@r4rr0rr5rr1rr6rrbrA)r2rBr4rr0rr5rr1rr6r;rbr()r2rHr4rr0rr5rr1rr6r;rbr?)r2r3rCrr0rr5rr1rr6rrbr<)r2r3rCrr0rr5rr1rr6rrbr7)r2rGrCrr0rr5rr1rr6r;rbr<)r2r`rCrr0rr5rr1rr6r;rbr`)r2rGrCrr0rr5rr1rr6r;rbr<)r2r`rCrr0rr5rr1rr6r;rbr`)r2r=rCrr0rr5rr1rr6rrbr>)r2r]rCrr0rr5rr1rr6r;rbr()r2rHrCrr0rr5rr1rr6r;rbr?)r2r`rCrr0rr5rr1rr6r;rbr`)r2rGrCrr0rr5rr1rr6r;rbr<)r2rGrCrr0rr5rr1rr6r;rbr<)r2r@rCrr0rr5rr1rr6rrbrA)r2r]rCrr0rr5rr1rr6r;rbr()r2rHrCrr0rr5rr1rr6r;rbr?)r2rrCrr0rr5rr1rr6r rbr)r2rFr4r rCr r0rr5rr1rr6r rbrG)rMr<r4rrbrG)rMr$r4rrbrH)rMr(r4rrbr)rMrr4rrbr)rMr<rCrrbrG)rMr$rCrrbrH)rMr(rCrrbr)rMrrCrrbr)rMrRr4r rCr rbrSre)rWrXr4r rCr r0rr5rr1rr6r rbrY)rbr)rsrtrbr)rwrxrbr)r`rr|r}rbr)rrrbr)rrrbr)rhrrrrbr<)rhrrrrbr$)rhrrrrbr) rrrr[rrrrrbr)rrrbr) rrrirr|r}rrWrbr()rrZrrWrbr) rrrrrwrxrrrbr)rr_rrrrWrbr)rrrrWrrrbr)rrrrWrrrbry) __future__r functoolsrtypingrrrrr r r r warningsr narwhalsrqrrrrrr*rr-narwhals.dependenciesrrrrrr&narwhals.functionsrrrrrrrrrr r!r"rr#r$r%rnarwhals.schemar&NwSchemarr(r.narwhals.stable.v1r)narwhals.stable.v1.dtypesr*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCnarwhals.translaterDrErFnarwhals.typingrGrHrrIrJrLrMrNrOrPrQrRrSrTrVtypesrWtyping_extensionsrXnarwhals.dtypesrYrZr[r\r]r^r_r`r"r9rOrorrvryr{r~rrrrrrrrrrrrrrrrrrrr__all__rgrgrgrhs                                                                                       di                                Q/ s             0