Lpj62SrSSKJr SSKJr SSKJr SSKJr SSK J r J r J r SSK JrJrJr SSKJrJrJrJrJrJrJr SS KJr \ (a2SS KJr SS K JrJr SS KrSS K r!SS K"J#r# SSK$J%r%J&r& SSK'J(r(J)r)J*r*J+r+J,r, S/r-SSjr."SS\\/S45r0g )zxSchema. Adapted from Polars implementation at: https://github.com/pola-rs/polars/blob/main/py-polars/polars/schema.py. ) annotations) OrderedDict)Mapping)partial) TYPE_CHECKINGcastoverload)ImplementationVersionqualified_type_name)get_cudf is_cudf_dtypeis_pandas_like_dtypeis_polars_data_typeis_polars_schemais_pyarrow_data_typeis_pyarrow_schema)DType)Iterable)AnyClassVarN) SupportsItems)SelfTypeIs) DTypeBackendIntoArrowSchema IntoDTypeIntoPandasSchemaIntoPolarsSchemaSchemac.[U[[45$N) isinstancedictr)objs K/var/www/html/pdf-tiff/venv/lib/python3.13/site-packages/narwhals/schema.py_supports_itemsr'/s cD'? ++ch^\rSrSr%Sr\R rS\S'\ SSSjj5r \ SSj5r SSU4Sjjjr SSjr SS jr SS jr \SS j5r\SS j5r\SS j5r\SSj5rS SjrSS!SjjrS"Sjr\S#Sj5r\S$Sj5rSrU=r$)%r 6arOrdered mapping of column names to their data type. Note: The pandas-like and dask backends allow non-string column names (e.g. integers or booleans). While discouraged, this is supported, so we cannot guarantee that the keys are strictly strings. See [concepts - column names](../concepts/column_names.md) for details. Arguments: schema: The schema definition given by column names and their associated Narwhals data type. Accepts a mapping or an iterable of tuples. Data types that take no required arguments may also be passed uninstantiated, e.g. `nw.Int8` instead of `nw.Int8()`; they are instantiated on construction. Examples: >>> import narwhals as nw >>> schema = nw.Schema({"foo": nw.Int8(), "bar": nw.String}) >>> schema Schema({'foo': Int8, 'bar': String}) Access the data type associated with a specific column name. >>> schema["foo"] Int8 Access various schema properties using the `names`, `dtypes`, and `len` methods. >>> schema.names() ['foo', 'bar'] >>> schema.dtypes() [Int8, String] >>> schema.len() 2 zClassVar[Version]_versioncgr"selfschemas r&__init__Schema.__init__^sORr(cgr"r-r.s r&r1r2`sILr(c>Uc[TU]5 g[TU]S[U5(aUR5OU55 g)Nc3f# UH'upU[U[5(aUOU"54v M) g7fr")r#r).0namedtypes r& "Schema.__init__..is.$YKD 5% 8 8uegF$Ys/1)superr1r'items)r/r0 __class__s r&r1r2bsE > G   G 6Ef6M6MFLLNSY$Y r(c4[UR55$)a?Get the column names of the schema. Note: The pandas-like and dask backends allow non-string column names (e.g. integers or booleans). While discouraged, this is supported, so the return type is not guaranteed to be `list[str]`. See [concepts - column names](../concepts/column_names.md) for details. )listkeysr/s r&names Schema.namesnsDIIK  r(c4[UR55$)z!Get the data types of the schema.)r?valuesrAs r&dtypes Schema.dtypeszsDKKM""r(c[U5$)z(Get the number of columns in the schema.)lenrAs r&rI Schema.len~s 4yr(c^^[U[5(a$U(dT"5$SSKnUR"U5nSSKJm T"UU4SjU55$)axConstruct a Schema from a pyarrow Schema. Arguments: schema: A pyarrow Schema or mapping of column names to pyarrow data types. Examples: >>> import pyarrow as pa >>> import narwhals as nw >>> >>> mapping = { ... "a": pa.timestamp("us", "UTC"), ... "b": pa.date32(), ... "c": pa.string(), ... "d": pa.uint8(), ... } >>> native = pa.schema(mapping) >>> >>> nw.Schema.from_arrow(native) Schema({'a': Datetime(time_unit='us', time_zone='UTC'), 'b': Date, 'c': String, 'd': UInt8}) >>> nw.Schema.from_arrow(mapping) == nw.Schema.from_arrow(native) True rNnative_to_narwhals_dtypec3v># UH.nURT"URTR54v M0 g7fr")r7typer+)r6fieldclsrMs r&r9$Schema.from_arrow..s1 ZZ1%**cllK Ls69)r#rpyarrowr0narwhals._arrow.utilsrM)rQr0parMs` @r& from_arrowSchema.from_arrowsJ2 fg & &u YYv&FB    r(cU(dU"5$[5(a5[SUR555(a[RO[R nUR X5$)asConstruct a Schema from a pandas-like schema representation. Arguments: schema: A mapping of column names to pandas-like data types. Examples: >>> import numpy as np >>> import pandas as pd >>> import pyarrow as pa >>> import narwhals as nw >>> >>> data = {"a": [1], "b": ["a"], "c": [False], "d": [9.2]} >>> native = pd.DataFrame(data).convert_dtypes().dtypes.to_dict() >>> >>> nw.Schema.from_pandas_like(native) Schema({'a': Int64, 'b': String, 'c': Boolean, 'd': Float64}) >>> >>> mapping = { ... "a": pd.DatetimeTZDtype("us", "UTC"), ... "b": pd.ArrowDtype(pa.date32()), ... "c": pd.StringDtype("python"), ... "d": np.dtype("uint8"), ... } >>> >>> nw.Schema.from_pandas_like(mapping) Schema({'a': Datetime(time_unit='us', time_zone='UTC'), 'b': Date, 'c': String, 'd': UInt8}) c38# UHn[U5v M g7fr")r)r6r8s r&r9*Schema.from_pandas_like..s!TO5-"6"6Os)r anyrEr CUDFPANDAS_from_pandas_like)rQr0impls r&from_pandas_likeSchema.from_pandas_likesY:5Lzzc!TFMMO!TTT   && $$V22r(c*[U5(aURU5$[U5(aURU5$[ U[ 5(aU(aUR U5$U"5$S[U5<SU<3n[U5e)aConstruct a Schema from a native schema representation. Arguments: schema: A native schema object, or mapping of column names to *instantiated* native data types. Examples: >>> import datetime as dt >>> import pyarrow as pa >>> import narwhals as nw >>> >>> data = {"a": [1], "b": ["a"], "c": [dt.time(1, 2, 3)], "d": [[2]]} >>> native = pa.table(data).schema >>> >>> nw.Schema.from_native(native) Schema({'a': Int64, 'b': String, 'c': Time, 'd': List(Int64)}) z5Expected an arrow, polars, or pandas schema, but got z ) rrVr from_polarsr#r_from_native_mappingr TypeError)rQr0msgs r& from_nativeSchema.from_natives* V $ $>>&) ) F # #??6* * fg & &7=3++F3 H35 HC"6*-T& = nr(cp^^U(dT"5$SSKJm T"UU4SjUR555$)aConstruct a Schema from a polars Schema. Arguments: schema: A polars Schema or mapping of column names to *instantiated* polars data types. Examples: >>> import polars as pl >>> import narwhals as nw >>> >>> mapping = { ... "a": pl.Datetime(time_zone="UTC"), ... "b": pl.Date(), ... "c": pl.String(), ... "d": pl.UInt8(), ... } >>> native = pl.Schema(mapping) >>> >>> nw.Schema.from_polars(native) Schema({'a': Datetime(time_unit='us', time_zone='UTC'), 'b': Date, 'c': String, 'd': UInt8}) >>> nw.Schema.from_polars(mapping) == nw.Schema.from_polars(native) True rrLc3R># UHupUT"UTR54v M g7fr"r+)r6r7r8rQrMs r&r9%Schema.from_polars.. s+ - +E3<<@ A-$')narwhals._polars.utilsrMr<)rQr0rMs` @r&rcSchema.from_polarss245LC %||~   r(cp^^SSKnSSKJm UR"UU4SjTR 555$)zConvert Schema to a pyarrow Schema. Examples: >>> import narwhals as nw >>> schema = nw.Schema({"a": nw.Int64(), "b": nw.Datetime("ns")}) >>> schema.to_arrow() a: int64 b: timestamp[ns] rNnarwhals_to_native_dtypec3R># UHupUT"UTR54v M g7fr"rkr6r7r8rrr/s r&r9"Schema.to_arrow.. s+ + +E4==A B+rm)rSrTrrr0r<)r/rUrrs` @r&to_arrowSchema.to_arrows/ Byy #zz|   r(c SSKJn [U[RUR S9nUb[ U[5(a)UR5VVs0sH upEXC"XQS9_M snn$[U5n[U5[U5:waoSSK J nJ nJn [U5[U5p[U"URU"U "U5U 55U 55n SU <SU <SUS USS U S 3 n [!U 5e[#UR%5UR'5US S 9VVVs0sH upEnXC"X^S9_M snnn$s snnfs snnnf)aConvert Schema to an ordered mapping of column names to their pandas data type. Arguments: dtype_backend: Backend(s) used for the native types. When providing more than one, the length of the iterable must be equal to the length of the schema. Examples: >>> import narwhals as nw >>> schema = nw.Schema({"a": nw.Int64(), "b": nw.Datetime("ns")}) >>> schema.to_pandas() {'a': 'int64', 'b': 'datetime64[ns]'} >>> schema.to_pandas("pyarrow") {'a': 'Int64[pyarrow]', 'b': 'timestamp[ns][pyarrow]'} rrq)implementationversion)r8 dtype_backend)chainislicerepeatz Provided z) `dtype_backend`(s), but schema contains z1 field(s). Hint: instead of schema.to_pandas(z+) you may want to use schema.to_pandas(z) or schema.to_pandas()T)strict)narwhals._pandas_like.utilsrrrr r]r+r#strr<tuplerI itertoolsr|r}r~ from_iterable ValueErrorzipr@rE)r/r{rrto_native_dtyper7r8backendsr|r}r~n_usern_actual suggestionrfbackends r& to_pandasSchema.to_pandas%sn$ I! $)00MM   J}c$B$B$(::<#/KDoEOO#/ ' x=CI % 7 7"8}c$iHu**6&2BH+MNPXYJF:%Nxl[((0z2((0 }5((2|1 6 S/ !), T[[]HT) )$W /E E)  -, s E)Ec^^SSKnSSKJm [RR 5nUU4SjTR 55nUS:aUR"U5$[S[U55$)zConvert Schema to a polars Schema. Examples: >>> import narwhals as nw >>> schema = nw.Schema({"a": nw.Int64(), "b": nw.Datetime("ns")}) >>> schema.to_polars() Schema({'a': Int64, 'b': Datetime(time_unit='ns', time_zone=None)}) rNrqc3R># UHupUT"UTR54v M g7fr"rkrts r&r9#Schema.to_polars..js+ + +E4==A B+rm)rr pl.Schema) polarsrnrrr POLARS_backend_versionr<r rr$)r/pl pl_versionr0rrs` @r& to_polarsSchema.to_polars\sf C#**;;=  #zz|  Y& IIf  k4<0 r(c[[UR555nUup4[U5(aUR [ SU55$[ U5(aUR[ SU55$[U5(aUR[ SU55$SUS[U5SU<3n[U5e)Nrrrz7Expected an arrow, polars, or pandas dtype, but found `z: z` ) nextiterr<rrcrrr`rrVr re)rQnative first_item first_key first_dtyperfs r&rdSchema._from_native_mappingts $v||~./ !+ { + +??4(:F#CD D  , ,''-?(HI I  , ,>>$'8&"AB B{"0=>eF: O nr(c\^^^SSKJm UmT"UUU4SjUR555$)NrrLc 3R># UHupUT"UTRTSS94v M g7f)T) allow_objectNrk)r6r7r8rQr_rMs r&r9+Schema._from_pandas_like..s0 - +E3<<TXY Z-rm)rrMr<)rQr0ryr_rMs` @@r&r^Schema._from_pandas_likes. I %||~   r(r-r")r0zMapping[str, IntoDType] | NonereturnNone)r0zIterable[tuple[str, IntoDType]]rr)r0z@Mapping[str, IntoDType] | Iterable[tuple[str, IntoDType]] | Nonerr)rz list[str])rz list[DType])rint)r0rrr)r0rrr)r0z5IntoArrowSchema | IntoPolarsSchema | IntoPandasSchemarr)r0rrr)rz pa.Schema)r{z%DTypeBackend | Iterable[DTypeBackend]rzdict[str, Any])rr)rzHMapping[str, pa.DataType] | Mapping[str, pl.DataType] | IntoPandasSchemarr)r0rryr rr)__name__ __module__ __qualname____firstlineno____doc__r MAINr+__annotations__r r1rBrFrI classmethodrVr`rgrcrvrrrdr^__static_attributes__ __classcell__)r=s@r&r r 6sE#J#*,,H. RR LLTX P     !## # J#3#3JJ @    D (FJ5 B5 5 n 0X  &  %  7E      r(r)r%rrz%TypeIs[SupportsItems[str, IntoDType]])1r __future__r collectionsrcollections.abcr functoolsrtypingrrr narwhals._utilsr r r narwhals.dependenciesr rrrrrrnarwhals.dtypesrrrrrrrSrU _typeshedrtyping_extensionsrrnarwhals.typingrrrrr__all__r'rr r-r(r&rs| ###00HH"($'. *,\ [g &\ r(