gDUddlmZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl m Z dd l m Z dd l mZdd l mZdd l mZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddlm$Z$ddl%m&Z&dd l%m'Z'e rSdd!l(m)Z)ddl*Z+dd"l,m-Z-dd#l,m.Z.dd$l/m0Z0dd%l/m1Z1dd&l2m3Z3dd'l4m5Z5dd(l4m6Z6dd)l4m7Z7ed*ee1e e0e e3e f+Z8Gd,d-eZ9Gd.d/eZ:e:jvd0e:jxd0e:jzd1e:j|d2e:j~d3e:jd4e:jd5e:jd6e:jd7i ZDd8eEd9< dVd:ZFdWd;ZGdXd<ZHdYd=ZIdZd>ZJd[d?ZKd\d@ZLd]dAZMd^dBZNd_dCZO d`dDZPdadEZQ dbddF dcdGZRdddHZS dedIZT dfdJZUdgdKZVdhdLZWdidMZXdidNZY djdOZZdkdPZ[dldQZ\dmdRZ] dndSZ^ dodTZ_dpdUZ`y)q) annotationsN)Enum)auto) token_hex) TYPE_CHECKING)Any)Iterable)Sequence)TypeVar)Union)cast)warn)get_cudf)get_dask_dataframe) get_duckdb)get_ibis) get_modin) get_pandas) get_polars) get_pyarrow)get_pyspark_sql)is_cudf_series)is_modin_series)is_pandas_dataframe)is_pandas_like_dataframe)is_pandas_like_series)is_pandas_series)is_polars_series)is_pyarrow_chunked_array)ColumnNotFoundError)InvalidOperationError) ModuleType)Self) TypeGuard DataFrame LazyFrameSeries)DTypes) IntoSeriesT)SizeUnitFrameOrSeriesT)boundc(eZdZeZeZy)VersionN)__name__ __module__ __qualname__rV1MAINC/var/www/openai/venv/lib/python3.12/site-packages/narwhals/utils.pyr1r18s B 6Dr8r1c&eZdZdZeZ eZ eZ eZ eZ eZ eZ eZ eZ eZ e ddZddZddZddZddZddZddZdd Zdd Zdd Zdd Zdd Zy)Implementationz?Implementation of native object (pandas, Polars, PyArrow, ...).cttjttjt tj ttjttjttjttjttj t#tj$i }|j'|tj(S)zInstantiate Implementation object from a native namespace module. Arguments: native_namespace: Native namespace. Returns: Implementation. )rr;PANDASrMODINrCUDFrPYARROWrPYSPARKrPOLARSrDASKrDUCKDBrIBISgetUNKNOWN)clsnative_namespacemappings r9from_native_namespacez$Implementation.from_native_namespaceVs L.// K-- J++ M>11  ~55 L.//  ."5"5 L.// J++  {{+^-C-CDDr8c`tjttjt tj t tjttjttjttjti}||S)zyReturn the native namespace module corresponding to Implementation. Returns: Native module. )r;r=rr>rr?rr@rrArrBrrCr)selfrJs r9to_native_namespacez"Implementation.to_native_namespaceosu  ! !:<  )+     " "KM  " "O$5  ! !:<   !3!5 t}r8c&|tjuS)a^Return whether implementation is pandas. Returns: Boolean. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pandas() True )r;r=rMs r9 is_pandaszImplementation.is_pandas~,,,,r8cd|tjtjtjhvS)asReturn whether implementation is pandas, Modin, or cuDF. Returns: Boolean. Examples: >>> import pandas as pd >>> import narwhals as nw >>> df_native = pd.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pandas_like() True )r;r=r>r?rPs r9is_pandas_likezImplementation.is_pandas_likes(--~/C/C^EXEXYYYr8c&|tjuS)a^Return whether implementation is Polars. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_polars() True )r;rBrPs r9 is_polarszImplementation.is_polarsrRr8c&|tjuS)a[Return whether implementation is cuDF. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_cudf() False )r;r?rPs r9is_cudfzImplementation.is_cudf~****r8c&|tjuS)a]Return whether implementation is Modin. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_modin() False )r;r>rPs r9is_modinzImplementation.is_modins~++++r8c&|tjuS)aaReturn whether implementation is PySpark. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pyspark() False )r;rArPs r9 is_pysparkzImplementation.is_pyspark~----r8c&|tjuS)aaReturn whether implementation is PyArrow. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_pyarrow() False )r;r@rPs r9 is_pyarrowzImplementation.is_pyarrowr^r8c&|tjuS)a[Return whether implementation is Dask. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_dask() False )r;rCrPs r9is_daskzImplementation.is_daskrYr8c&|tjuS)a_Return whether implementation is DuckDB. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_duckdb() False )r;rDrPs r9 is_duckdbzImplementation.is_duckdbrRr8c&|tjuS)a[Return whether implementation is Ibis. Returns: Boolean. Examples: >>> import polars as pl >>> import narwhals as nw >>> df_native = pl.DataFrame({"a": [1, 2, 3]}) >>> df = nw.from_native(df_native) >>> df.implementation.is_ibis() False )r;rErPs r9is_ibiszImplementation.is_ibisrYr8N)rHz type[Self]rIr"returnr;)rMr#rgr")rgbool)r2r3r4__doc__rr=r>r?r@rArBrCrDrErG classmethodrKrNrQrTrVrXr[r]r`rbrdrfr7r8r9r;r;=sI VF FE 6DfG!fG! VF 6D VF 6DfG!E E+5E EE0"- Z - + , . . + - +r8r;)r) ) )rlrl)rrl)i))z%dict[Implementation, tuple[int, ...]] MIN_VERSIONScL|t|x}krd|d|d|}t|y)NzMinimum version of z supported by Narwhals is z , found: )rt ValueError)implementationbackend_version min_versionmsgs r9validate_backend_versionr{.sCn)EE+F#N#33Mk]ZcdsctuoGr8c|tjurddlm}|S|tjurddlm}|Sd|}t |)Nr)dtypeszCongratulations, you have entered unreachable code. Please report an issue at https://github.com/narwhals-dev/narwhals/issues. Version: )r1r5narwhals.stable.v1r}r6narwhalsAssertionError)versionr}rzs r9import_dtypes_moduler6sQ'**- M GLL # M  y " S!!r8cD|j|r|t|dS|SN) startswithlen)textprefixs r9 remove_prefixrEs$ vCKM"" Kr8cF|j|r|dt| S|Sr)endswithr)rsuffixs r9 remove_suffixrKs& }}VNs6{l## Kr8cP|sgSt|dk(rt|dr|dS|S)Nrrr)r _is_iterable)argss r9flattenrQs.   4yA~,tAw/Aw Kr8c8t|ttfs|fS|Sr) isinstancelisttuple)args r9tupleifyrYs cD%= )v Jr8c~ddlm}t|s t|rdt |d}t |t x}Rt||j|j|j|jfrdt |d}t |t|txrt|tt|f S)Nrr)z(Expected Narwhals class or scalar, got: z2. Perhaps you forgot a `nw.from_native` somewhere?z`. Hint: Perhaps you - forgot a `nw.from_native` somewhere? - used `pl.col` instead of `nw.col`?)narwhals.seriesr*rrtype TypeErrorrrExprr&r(r strbytes)rr*rzpls r9rr_s&3#3C#88c Cuvnl'J bii",, =-7tCykB3 3 n c8 $ RZc5&=Q-R)RRr8cht|tr|jd}td|DS)zSimple version parser; split into a tuple of ints for comparison. Arguments: version: Version string to parse. Returns: Parsed version number. .c 3nK|]-}ttjddt|/yw)z\DN)intresubr).0vs r9 z parse_version..s'AARVVE2s1v./s35)rrsplitr)rs r9 parse_versionrss-'3--$ AA AAr8cddlm}t||r t||St||xst|txr t ||S)Nr)DType)narwhals.dtypesrrr issubclass)objrHrs r9isinstance_or_issubclassrsA%#u#s## c3  SJsD$9$Rjc>RSr8cddlmddlmtfd|Dstfd|Dryd|Dcgc] }t |c}}t |cc}w)Nrr%r'c36K|]}t|ywrr)ritemr&s r9rz$validate_laziness..s 954:dI &5c36K|]}t|ywrr)rrr(s r9rz$validate_laziness..s :EDJtY 'ErzGThe items to concatenate should either all be eager, or all lazy, got: )narwhals.dataframer&r(allrr)itemsrrzr&r(s @@r9validate_lazinessrs`,, 95 99 :E :: SlqTrlqdhUYZ^U_lqTrSs tC C.UssAcddlm}ddlm}d d}t t |}t t |}t t|dd|rt t|dd|r||jjj||jjj|j|jj|jjj|jjjSt t|dd|rt t|dd|r||jjj||jjj|j|jj|jjj|jjjSt t|dd|rt t|dd|r||jjj||jjj|j!|jj#|jjj|jjjSt t|dd|rt t|dd|r||jjj||jjj|j!|jj#|jjj|jjjSt%|t%|k7r%dt%|d t%|}t'||S) aAlign `lhs` to the Index of `rhs`, if they're both pandas-like. Arguments: lhs: Dataframe or Series. rhs: Dataframe or Series to align with. Returns: Same type as input. Notes: This is only really intended for backwards-compatibility purposes, for example if your library already aligns indices for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this only checks that `lhs` and `rhs` are the same length. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2]}, index=[3, 4]) >>> s_pd = pd.Series([6, 7], index=[4, 3]) >>> df = nw.from_native(df_pd) >>> s = nw.from_native(s_pd, series_only=True) >>> nw.to_native(nw.maybe_align_index(df, s)) a 4 2 3 1 r)PandasLikeDataFrame)PandasLikeSeriesc6|js d}t|y)Nz'given index doesn't have a unique index) is_uniquerv)indexrzs r9_validate_indexz*maybe_align_index.._validate_indexs;CS/ !r8_compliant_frameN_compliant_seriesz6Expected `lhs` and `rhs` to have the same length, got z and )rrrgNone)narwhals._pandas_like.dataframernarwhals._pandas_like.seriesrr rrgetattrr _native_framer_from_compliant_dataframe_from_native_framelocr_native_series_from_compliant_series_from_native_seriesrrv)lhsrhsrrrlhs_anyrhs_anyrzs r9maybe_align_indexrsKBD=" 3nG3nG+T24G WW&8$?AT U00>>DDE00>>DDE00  $ $ 7 7((66::,,::@@   +T24G WW&94@BR S00>>DDE11@@FFG00  $ $ 7 7((66::--<<BB   ,d35E WW&8$?AT U11@@FFG00>>DDE--  % % 9 9))88<<,,::@@   ,d35E WW&94@BR S11@@FFG11@@FFG--  % % 9 9))88<<--<<BB    7|s7|#Fs7|nTYZ]^eZfYgho Jr8ctt|}|j}t|s t |r |j Sy)aGet the index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: Dataframe or Series. Returns: Same type as input. Notes: This is only really intended for backwards-compatibility purposes, for example if your library already aligns indices for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this returns `None`. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2], "b": [4, 5]}) >>> df = nw.from_native(df_pd) >>> nw.maybe_get_index(df) RangeIndex(start=0, stop=2, step=1) >>> series_pd = pd.Series([1, 2]) >>> series = nw.from_native(series_pd, series_only=True) >>> nw.maybe_get_index(series) RangeIndex(start=0, stop=2, step=1) N)r r to_nativerrr)robj_any native_objs r9maybe_get_indexrs<:3nG""$J +/DZ/P r8)rcddlm}tt|}|j}|| d}t ||s|s d}t ||.t |r|Dcgc] }||dc}n ||d}n|}t |r9|j|jj|j|St|rsddl m } |r d}t || |||jj|jj }|j!|jj#|S|Scc}w) aSet the index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: object for which maybe set the index (can be either a Narwhals `DataFrame` or `Series`). column_names: name or list of names of the columns to set as index. For dataframes, only one of `column_names` and `index` can be specified but not both. If `column_names` is passed and `df` is a Series, then a `ValueError` is raised. index: series or list of series to set as index. Returns: Same type as input. Raises: ValueError: If one of the following condition happens: - none of `column_names` and `index` are provided - both `column_names` and `index` are provided - `column_names` is provided and `df` is a Series Notes: This is only really intended for backwards-compatibility purposes, for example if your library already aligns indices for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this is a no-op. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2], "b": [4, 5]}) >>> df = nw.from_native(df_pd) >>> nw.to_native(nw.maybe_set_index(df, "b")) # doctest: +NORMALIZE_WHITESPACE a b 4 1 5 2 r)rz8Only one of `column_names` or `index` should be providedz3Either `column_names` or `index` should be providedT) pass_through) set_indexz/Cannot set index using column names on a Series)rwrx)narwhals.translaterr rrvrrrrrrrnarwhals._pandas_like.utilsr_implementation_backend_versionrr) r column_namesrrdf_anyrrzidxkeysrs r9maybe_set_indexrsN^- #s^F!!#JE$5Ho Co E";@ @%3Ys .% @5t4  +//  # # 6 6z7K7KD7Q R   z *9 CCS/ !  00@@11BB  ,,  $ $ 8 8 D   9 AsD?ctt|}|j}t|rX|j }t ||r|S|j |jj|jdSt|rX|j }t ||r|S|j|jj|jdS|S)aReset the index to the default integer index of a DataFrame or a Series, if it's pandas-like. Arguments: obj: Dataframe or Series. Returns: Same type as input. Notes: This is only really intended for backwards-compatibility purposes, for example if your library already resets the index for users. If you're designing a new library, we highly encourage you to not rely on the Index. For non-pandas-like inputs, this is a no-op. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> df_pd = pd.DataFrame({"a": [1, 2], "b": [4, 5]}, index=([6, 7])) >>> df = nw.from_native(df_pd) >>> nw.to_native(nw.maybe_reset_index(df)) a b 0 1 4 1 2 5 >>> series_pd = pd.Series([1, 2]) >>> series = nw.from_native(series_pd, series_only=True) >>> nw.maybe_get_index(series) RangeIndex(start=0, stop=2, step=1) T)drop)r rrr__native_namespace___has_default_indexrrr reset_indexrrrr)rrrrIs r9maybe_reset_indexrxs>3nG""$J +"779 j*: ;N00  $ $ 7 7 8N8NTX8N8Y Z  Z("779 j*: ;N--  % % 9 9&&D&1   Nr8c|j}t||jxr:|jdk(xr)|jt |k(xr|j dk(S)Nrrr)rr RangeIndexstartstoprstep)native_frame_or_seriesrIrs r9rrs] # ( (E5*556  KK1   JJ#e* $  JJ!O r8c Ztt|}|j}t|r:|j |j j |j|i|St|r:|j|jj|j|i|S|S)a9Convert columns or series to the best possible dtypes using dtypes supporting ``pd.NA``, if df is pandas-like. Arguments: obj: DataFrame or Series. *args: Additional arguments which gets passed through. **kwargs: Additional arguments which gets passed through. Returns: Same type as input. Notes: For non-pandas-like inputs, this is a no-op. Also, `args` and `kwargs` just get passed down to the underlying library as-is. Examples: >>> import pandas as pd >>> import polars as pl >>> import narwhals as nw >>> import numpy as np >>> df_pd = pd.DataFrame( ... { ... "a": pd.Series([1, 2, 3], dtype=np.dtype("int32")), ... "b": pd.Series([True, False, np.nan], dtype=np.dtype("O")), ... } ... ) >>> df = nw.from_native(df_pd) >>> nw.to_native(nw.maybe_convert_dtypes(df)).dtypes # doctest: +NORMALIZE_WHITESPACE a Int32 b boolean dtype: object ) r rrrrrrconvert_dtypesrrrr)rrkwargsrrs r9maybe_convert_dtypesrsD3nG""$J +00  $ $ 7 7) ))4:6:   Z(--  % % 9 9) ))4:6:   Nr8cv|dvr|S|dvr|dz S|dvr|dz S|dvr|dz S|dvr|d z Sd |}t|) zScale size in bytes to other size units (eg: "kb", "mb", "gb", "tb"). Arguments: sz: original size in bytes unit: size unit to convert into Returns: Integer or float. >br>kb kilobytesi>mb megabytesi>gb gigabytesi@>tb terabyteslz9`unit` must be one of {'b', 'kb', 'mb', 'gb', 'tb'}, got )rv)szunitrzs r9 scale_bytesrss ~ $ $Dy $ $G| $ $G| $ $G|KD8Tor8cddlm}t|jj}t |j|r<|j |jk(r#|jjjdS|j |jk(ry|j |jk7ry|j}t|r|j jdk(St|r|jj St#|r|jj St%|r|jj St'|r|j(j Sy)aReturn whether indices of categories are semantically meaningful. This is a convenience function to accessing what would otherwise be the `is_ordered` property from the DataFrame Interchange Protocol, see https://data-apis.org/dataframe-protocol/latest/API.html. - For Polars: - Enums are always ordered. - Categoricals are ordered if `dtype.ordering == "physical"`. - For pandas-like APIs: - Categoricals are ordered if `dtype.cat.ordered == True`. - For PyArrow table: - Categoricals are ordered if `dtype.type.ordered == True`. Arguments: series: Input Series. Returns: Whether the Series is an ordered categorical. Examples: >>> import narwhals as nw >>> import pandas as pd >>> import polars as pl >>> data = ["x", "y"] >>> s_pd = pd.Series(data, dtype=pd.CategoricalDtype(ordered=True)) >>> s_pl = pl.Series(data, dtype=pl.Categorical(ordering="physical")) Let's define a library-agnostic function: >>> @nw.narwhalify ... def func(s): ... return nw.is_ordered_categorical(s) Then, we can pass any supported library to `func`: >>> func(s_pd) True >>> func(s_pl) True r)InterchangeSeries is_orderedTFphysical)narwhals._interchange.seriesrrr_versionrdtype Categoricalrdescribe_categoricalrrrorderingrcatorderedrrrr)seriesrr} native_seriess r9is_ordered_categoricalrs'T? !&":":"C"C DF 6++->? LLF.. .''66KK   ||v{{" ||v)))$$&M &""++z99 &  (((}%  (((m$  ((( .!!))) r8c:d}t|dt||S)Nz}Use `generate_temporary_column_name` instead. `generate_unique_token` is deprecated and it will be removed in future versions1.13.0r)n_bytescolumns)issue_deprecation_warninggenerate_temporary_column_name)rrrzs r9generate_unique_tokenrLs% ?cH5 )'7 KKr8cfd} t|}||vr|S|dz }|dkDrd|d|}t|/)aGenerates a unique column name that is not present in the given list of columns. It relies on [python secrets token_hex](https://docs.python.org/3/library/secrets.html#secrets.token_hex) function to return a string nbytes random bytes. Arguments: n_bytes: The number of bytes to generate for the token. columns: The list of columns to check for uniqueness. Returns: A unique token that is not present in the given list of columns. Raises: AssertionError: If a unique token cannot be generated after 100 attempts. Examples: >>> import narwhals as nw >>> columns = ["abc", "xyz"] >>> nw.generate_temporary_column_name(n_bytes=8, columns=columns) not in columns True rrrdzMInternal Error: Narwhals was not able to generate a column name with n_bytes=z and not in )rr)rrcountertokenrzs r9rrUs_,G '"  L1  S=*L 3 !% % r8c|j}t|}|r/|Dcgc] }||vs| }}|rtj|||Stt |j t |}|Scc}w)N)missing_columnsavailable_columns)rrr 'from_missing_and_available_column_namesset intersection)compliant_framerstrictcolsto_dropxrs r9parse_columns_to_dropr)zs  " "D7mG &-?g$1g? %MM /4  Ns4y--c'l;< N@s A7A7cHt|txrt|t Sr)rr r)sequences r9is_sequence_but_not_strr,s h ) K*Xs2K.KKr8cpddl}ddlm}ddl}t ||j j }|j}d} |re|j|}|j|s*t|jddx}r#|jdr|j}|dz }n ~|S|re ~|S#~wxYw)zFind the first place in the stack that is not inside narwhals. Returns: Stacklevel. Taken from: https://github.com/pandas-dev/pandas/blob/ab89c53f48df67709a533b6a95ce3d911871a0a8/pandas/util/_exceptions.py#L30-L51 rN)Path co_qualnamezsingledispatch.rr) inspectpathlibr.rr__file__parent currentframegetfilerrf_codef_back)r0r.nwpkg_dirframenfnamequalnames r9find_stacklevelr>s$r{{#**+G  "E AOOE*E($U\\=$GGG''(9: Q  H'   H sA B2+B22B5c8t|tty)zIssue a deprecation warning. Arguments: message: The message associated with the warning. _version: Narwhals version when the warning was introduced. Just used for internal bookkeeping. )messagecategory stacklevelN)rDeprecationWarningr>)r@rs r9rrs #5/BSTr8cn|||}|S|||rd}t|d| }|S|| |Sd}t|)Nz`strict` in `from_native` is deprecated, please use `pass_through` instead. Note: `strict` will remain available in `narwhals.stable.v1`. See [stable api](../backcompat.md/) for more information. rrz,Cannot pass both `strict` and `pass_through`)rrv)r%rpass_through_defaultemit_deprecation_warningrzs r9validate_strict_and_pass_thoughrGsy~,.+     4 #N  &cH =!z  L4  =or8cb|dkr d}t|t|ts'|jj}d|d}t ||_|dkr d}t|t|ts'|jj}d|d}t |||kDr d}t |||fS|}||fS)Nrrz+window_size must be greater or equal than 1zargument 'window_size': 'z,' object cannot be interpreted as an integerz+min_periods must be greater or equal than 1zargument 'min_periods': 'z6`min_periods` must be less or equal than `window_size`)rvrr __class__r2rr!) window_size min_periodsrz_types r9_validate_rolling_argumentsrMsQ;o k3 '%%..'w/( ( n ??CS/ !+s+))22E+E73,, C.  $JC', ,  ##"  ##r8c f tjj}|j }t d|D}|dz|krt |t |}dd|zd}|t |z }|dd|dzz|d|dz|dzzzd z }|dd |zd z }||z dz}||z dz||z dzz} |D]$} |dd|z| d| |zt | z zd z }&|d d|zd z }|Sd t |z } dddd| dzz|d| dz| dzzzddd S#t$rd}YwxYw)NPc32K|]}t|ywr)r)rlines r9rz generate_repr.. s>3t9su┌u─u┐ | z| -u└u┘'uu───────────────────────────────────────u┐ |u/| | Use `.to_native` to see native output | └)osget_terminal_sizerOSError splitlinesmaxr) header native_reprterminal_width native_linesmax_native_widthlengthoutput header_extra start_extra end_extrarQdiffs r9 generate_reprrgs--/77))+L>>>!n,%s6{3uV|nE*F + \1_%&vhsL!OlSTn4T/U.VVY Z  Ac6l^3'' 00Q6 ..14AQ8QUV7VV  D #{+,TF3 DT8TWZ[_W`8`3a2bbef fF!C's++ F D l^ qM?6(3aQ#7"899 ,c + sD!! D0/D0)rwr;rxtuple[int, ...]rgr)rr1rgr+)rrrrrgr)rrrrrgr)rrrgz list[Any])rrrgr)rzAny | Iterable[Any]rgrh)rzSequence[str | int]rgrh)rrrHrrgrh)rz Iterable[Any]rgr)rr.rz-Series[Any] | DataFrame[Any] | LazyFrame[Any]rgr.)rz-DataFrame[Any] | LazyFrame[Any] | Series[Any]rgz Any | Noner)rr.rzstr | list[str] | Nonerz6Series[IntoSeriesT] | list[Series[IntoSeriesT]] | Nonergr.)rr.rgr.)rzpd.Series | pd.DataFramerIrrgrh)rr.rrhrz bool | strrgr.)rrrr-rgz int | float)rz Series[Any]rgrh)rrr list[str]rgr)r$rrz Iterable[str]r%rhrgri)r+rrgzTypeGuard[Sequence[Any]])rgr)r@rrrrgr) r% bool | NonerrjrErhrFrhrgrh)rJrrKz int | Nonergztuple[int, int])r\rr]rrgr)a __future__rrWrenumrrsecretsrtypingrrr r r r r warningsrnarwhals.dependenciesrrrrrrrrrrrrrrrrrnarwhals.exceptionsr r!typesr"pandaspdtyping_extensionsr#r$rr&r(rr*narwhals.typingr+r,r-r.r1r;r=r>r?r@rArBrCrDrErt__annotations__r{rrrrrrrrrrrrrrrrrrrr)r,r>rrGrMrgr7r8r9rxs"  *4,*+,,-1015:722:35 &+,,&&+(ininfSk&Q RN d a+Ta+J:*EF:4 7 3 "5D     S( BT ^ ^K^^B!L,0ZEI Z Z(Z B Z  Zz1h 4 HK   0 0 $00:00f2EPL"&J   $L' TU   #   4!$!$#-!$!$Hr8